eZ\Publish\Core\Event\RoleService

Complexity

Total Complexity

46

Size/Duplication

Total Lines	419
Duplicated Lines	56.32 %

Coupling/Cohesion

Components	1
Dependencies	39

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	createRole()	20	20	3
A	createRoleDraft()	20	20	3
A	updateRoleDraft()	25	25	3
A	addPolicyByRoleDraft()	25	25	3
A	removePolicyByRoleDraft()	25	25	3
A	updatePolicyByRoleDraft()	0	27	3
A	deleteRoleDraft()	0	16	2
A	publishRoleDraft()	0	16	2
A	updateRole()	25	25	3
A	addPolicy()	25	25	3
A	deletePolicy()	0	16	2
A	updatePolicy()	25	25	3
A	deleteRole()	0	16	2
A	assignRoleToUserGroup()	23	23	2
A	unassignRoleFromUserGroup()	0	21	2
A	assignRoleToUser()	23	23	2
A	unassignRoleFromUser()	0	21	2
A	removeRoleAssignment()	0	16	2

<?php

/**
 * @copyright Copyright (C) eZ Systems AS. All rights reserved.
 * @license For full copyright and license information view LICENSE file distributed with this source code.
 */
declare(strict_types=1);

namespace eZ\Publish\Core\Event;

use eZ\Publish\SPI\Repository\Decorator\RoleServiceDecorator;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use eZ\Publish\API\Repository\RoleService as RoleServiceInterface;
use eZ\Publish\API\Repository\Values\User\Limitation\RoleLimitation;
use eZ\Publish\API\Repository\Values\User\Policy;
use eZ\Publish\API\Repository\Values\User\PolicyCreateStruct;
use eZ\Publish\API\Repository\Values\User\PolicyDraft;
use eZ\Publish\API\Repository\Values\User\PolicyUpdateStruct;
use eZ\Publish\API\Repository\Values\User\Role;
use eZ\Publish\API\Repository\Values\User\RoleAssignment;
use eZ\Publish\API\Repository\Values\User\RoleCreateStruct;
use eZ\Publish\API\Repository\Values\User\RoleDraft;
use eZ\Publish\API\Repository\Values\User\RoleUpdateStruct;
use eZ\Publish\API\Repository\Values\User\User;
use eZ\Publish\API\Repository\Values\User\UserGroup;
use eZ\Publish\Core\Event\Role\AddPolicyByRoleDraftEvent;
use eZ\Publish\Core\Event\Role\AddPolicyEvent;
use eZ\Publish\Core\Event\Role\AssignRoleToUserEvent;
use eZ\Publish\Core\Event\Role\AssignRoleToUserGroupEvent;
use eZ\Publish\Core\Event\Role\BeforeAddPolicyByRoleDraftEvent;
use eZ\Publish\Core\Event\Role\BeforeAddPolicyEvent;
use eZ\Publish\Core\Event\Role\BeforeAssignRoleToUserEvent;
use eZ\Publish\Core\Event\Role\BeforeAssignRoleToUserGroupEvent;
use eZ\Publish\Core\Event\Role\BeforeCreateRoleDraftEvent;
use eZ\Publish\Core\Event\Role\BeforeCreateRoleEvent;
use eZ\Publish\Core\Event\Role\BeforeDeletePolicyEvent;
use eZ\Publish\Core\Event\Role\BeforeDeleteRoleDraftEvent;
use eZ\Publish\Core\Event\Role\BeforeDeleteRoleEvent;
use eZ\Publish\Core\Event\Role\BeforePublishRoleDraftEvent;
use eZ\Publish\Core\Event\Role\BeforeRemovePolicyByRoleDraftEvent;
use eZ\Publish\Core\Event\Role\BeforeRemoveRoleAssignmentEvent;
use eZ\Publish\Core\Event\Role\BeforeUnassignRoleFromUserEvent;
use eZ\Publish\Core\Event\Role\BeforeUnassignRoleFromUserGroupEvent;
use eZ\Publish\Core\Event\Role\BeforeUpdatePolicyByRoleDraftEvent;
use eZ\Publish\Core\Event\Role\BeforeUpdatePolicyEvent;
use eZ\Publish\Core\Event\Role\BeforeUpdateRoleDraftEvent;
use eZ\Publish\Core\Event\Role\BeforeUpdateRoleEvent;
use eZ\Publish\Core\Event\Role\CreateRoleDraftEvent;
use eZ\Publish\Core\Event\Role\CreateRoleEvent;
use eZ\Publish\Core\Event\Role\DeletePolicyEvent;
use eZ\Publish\Core\Event\Role\DeleteRoleDraftEvent;
use eZ\Publish\Core\Event\Role\DeleteRoleEvent;
use eZ\Publish\Core\Event\Role\PublishRoleDraftEvent;
use eZ\Publish\Core\Event\Role\RemovePolicyByRoleDraftEvent;
use eZ\Publish\Core\Event\Role\RemoveRoleAssignmentEvent;
use eZ\Publish\Core\Event\Role\RoleEvents;
use eZ\Publish\Core\Event\Role\UnassignRoleFromUserEvent;
use eZ\Publish\Core\Event\Role\UnassignRoleFromUserGroupEvent;
use eZ\Publish\Core\Event\Role\UpdatePolicyByRoleDraftEvent;
use eZ\Publish\Core\Event\Role\UpdatePolicyEvent;
use eZ\Publish\Core\Event\Role\UpdateRoleDraftEvent;
use eZ\Publish\Core\Event\Role\UpdateRoleEvent;

class RoleService extends RoleServiceDecorator implements RoleServiceInterface
{
    /**
     * @var \Symfony\Component\EventDispatcher\EventDispatcherInterface
     */
    protected $eventDispatcher;

    public function __construct(
        RoleServiceInterface $innerService,
        EventDispatcherInterface $eventDispatcher
    ) {
        parent::__construct($innerService);

        $this->eventDispatcher = $eventDispatcher;
    }

    public function createRole(RoleCreateStruct $roleCreateStruct): RoleDraft
    {
        $eventData = [$roleCreateStruct];

        $beforeEvent = new BeforeCreateRoleEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_CREATE_ROLE, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $roleDraft = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::createRole($roleCreateStruct);

        $this->eventDispatcher->dispatch(
            RoleEvents::CREATE_ROLE,
            new CreateRoleEvent($roleDraft, ...$eventData)
        );

        return $roleDraft;
    }

    public function createRoleDraft(Role $role)
    {
        $eventData = [$role];

        $beforeEvent = new BeforeCreateRoleDraftEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_CREATE_ROLE_DRAFT, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $roleDraft = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::createRoleDraft($role);

        $this->eventDispatcher->dispatch(
            RoleEvents::CREATE_ROLE_DRAFT,
            new CreateRoleDraftEvent($roleDraft, ...$eventData)
        );

        return $roleDraft;
    }

    public function updateRoleDraft(
        RoleDraft $roleDraft,
        RoleUpdateStruct $roleUpdateStruct
    ) {
        $eventData = [
            $roleDraft,
            $roleUpdateStruct,
        ];

        $beforeEvent = new BeforeUpdateRoleDraftEvent(...$eventData);

The call to BeforeUpdateRoleDraftEvent::__construct() misses a required argument $roleUpdateStruct.

        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_UPDATE_ROLE_DRAFT, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $updatedRoleDraft = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::updateRoleDraft($roleDraft, $roleUpdateStruct);

        $this->eventDispatcher->dispatch(
            RoleEvents::UPDATE_ROLE_DRAFT,
            new UpdateRoleDraftEvent($updatedRoleDraft, ...$eventData)

The call to UpdateRoleDraftEvent::__construct() misses a required argument $roleUpdateStruct.

        );

        return $updatedRoleDraft;
    }

    public function addPolicyByRoleDraft(
        RoleDraft $roleDraft,
        PolicyCreateStruct $policyCreateStruct
    ) {
        $eventData = [
            $roleDraft,
            $policyCreateStruct,
        ];

        $beforeEvent = new BeforeAddPolicyByRoleDraftEvent(...$eventData);

The call to BeforeAddPolicyByRoleDraftEvent::__construct() misses a required argument $policyCreateStruct.

        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_ADD_POLICY_BY_ROLE_DRAFT, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $updatedRoleDraft = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::addPolicyByRoleDraft($roleDraft, $policyCreateStruct);

        $this->eventDispatcher->dispatch(
            RoleEvents::ADD_POLICY_BY_ROLE_DRAFT,
            new AddPolicyByRoleDraftEvent($updatedRoleDraft, ...$eventData)

The call to AddPolicyByRoleDraftEvent::__construct() misses a required argument $policyCreateStruct.

        );

        return $updatedRoleDraft;
    }

    public function removePolicyByRoleDraft(
        RoleDraft $roleDraft,
        PolicyDraft $policyDraft
    ) {
        $eventData = [
            $roleDraft,
            $policyDraft,
        ];

        $beforeEvent = new BeforeRemovePolicyByRoleDraftEvent(...$eventData);

The call to BeforeRemovePolicyByRoleDraftEvent::__construct() misses a required argument $policyDraft.

        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_REMOVE_POLICY_BY_ROLE_DRAFT, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $updatedRoleDraft = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::removePolicyByRoleDraft($roleDraft, $policyDraft);

        $this->eventDispatcher->dispatch(
            RoleEvents::REMOVE_POLICY_BY_ROLE_DRAFT,
            new RemovePolicyByRoleDraftEvent($updatedRoleDraft, ...$eventData)

The call to RemovePolicyByRoleDraftEvent::__construct() misses a required argument $policyDraft.

        );

        return $updatedRoleDraft;
    }

    public function updatePolicyByRoleDraft(
        RoleDraft $roleDraft,
        PolicyDraft $policy,
        PolicyUpdateStruct $policyUpdateStruct
    ) {
        $eventData = [
            $roleDraft,
            $policy,
            $policyUpdateStruct,
        ];

        $beforeEvent = new BeforeUpdatePolicyByRoleDraftEvent(...$eventData);

The call to BeforeUpdatePolicyByRoleDraftEvent::__construct() misses some required arguments starting with $policy.

        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_UPDATE_POLICY_BY_ROLE_DRAFT, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $updatedPolicyDraft = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::updatePolicyByRoleDraft($roleDraft, $policy, $policyUpdateStruct);

        $this->eventDispatcher->dispatch(
            RoleEvents::UPDATE_POLICY_BY_ROLE_DRAFT,
            new UpdatePolicyByRoleDraftEvent($updatedPolicyDraft, ...$eventData)

The call to UpdatePolicyByRoleDraftEvent::__construct() misses some required arguments starting with $policy.

        );

        return $updatedPolicyDraft;
    }

    public function deleteRoleDraft(RoleDraft $roleDraft): void
    {
        $eventData = [$roleDraft];

        $beforeEvent = new BeforeDeleteRoleDraftEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_DELETE_ROLE_DRAFT, $beforeEvent)->isPropagationStopped()) {
            return;
        }

        parent::deleteRoleDraft($roleDraft);

        $this->eventDispatcher->dispatch(
            RoleEvents::DELETE_ROLE_DRAFT,
            new DeleteRoleDraftEvent(...$eventData)
        );
    }

    public function publishRoleDraft(RoleDraft $roleDraft): void
    {
        $eventData = [$roleDraft];

        $beforeEvent = new BeforePublishRoleDraftEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_PUBLISH_ROLE_DRAFT, $beforeEvent)->isPropagationStopped()) {
            return;
        }

        parent::publishRoleDraft($roleDraft);

        $this->eventDispatcher->dispatch(
            RoleEvents::PUBLISH_ROLE_DRAFT,
            new PublishRoleDraftEvent(...$eventData)
        );
    }

    public function updateRole(
        Role $role,
        RoleUpdateStruct $roleUpdateStruct
    ) {
        $eventData = [
            $role,
            $roleUpdateStruct,
        ];

        $beforeEvent = new BeforeUpdateRoleEvent(...$eventData);

The call to BeforeUpdateRoleEvent::__construct() misses a required argument $roleUpdateStruct.

        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_UPDATE_ROLE, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $updatedRole = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::updateRole($role, $roleUpdateStruct);

        $this->eventDispatcher->dispatch(
            RoleEvents::UPDATE_ROLE,
            new UpdateRoleEvent($updatedRole, ...$eventData)

The call to UpdateRoleEvent::__construct() misses a required argument $roleUpdateStruct.

        );

        return $updatedRole;
    }

    public function addPolicy(
        Role $role,
        PolicyCreateStruct $policyCreateStruct
    ) {
        $eventData = [
            $role,
            $policyCreateStruct,
        ];

        $beforeEvent = new BeforeAddPolicyEvent(...$eventData);

The call to BeforeAddPolicyEvent::__construct() misses a required argument $policyCreateStruct.

        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_ADD_POLICY, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $updatedRole = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::addPolicy($role, $policyCreateStruct);

        $this->eventDispatcher->dispatch(
            RoleEvents::ADD_POLICY,
            new AddPolicyEvent($updatedRole, ...$eventData)

The call to AddPolicyEvent::__construct() misses a required argument $policyCreateStruct.

        );

        return $updatedRole;
    }

    public function deletePolicy(Policy $policy)
    {
        $eventData = [$policy];

        $beforeEvent = new BeforeDeletePolicyEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_DELETE_POLICY, $beforeEvent)->isPropagationStopped()) {
            return;
        }

        parent::deletePolicy($policy);

        $this->eventDispatcher->dispatch(
            RoleEvents::DELETE_POLICY,
            new DeletePolicyEvent(...$eventData)
        );
    }

    public function updatePolicy(
        Policy $policy,
        PolicyUpdateStruct $policyUpdateStruct
    ) {
        $eventData = [
            $policy,
            $policyUpdateStruct,
        ];

        $beforeEvent = new BeforeUpdatePolicyEvent(...$eventData);

The call to BeforeUpdatePolicyEvent::__construct() misses a required argument $policyUpdateStruct.

        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_UPDATE_POLICY, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        }

        $updatedPolicy = $beforeEvent->hasReturnValue()
            ? $beforeEvent->getReturnValue()
            : parent::updatePolicy($policy, $policyUpdateStruct);

        $this->eventDispatcher->dispatch(
            RoleEvents::UPDATE_POLICY,
            new UpdatePolicyEvent($updatedPolicy, ...$eventData)

The call to UpdatePolicyEvent::__construct() misses a required argument $policyUpdateStruct.

        );

        return $updatedPolicy;
    }

    public function deleteRole(Role $role)
    {
        $eventData = [$role];

        $beforeEvent = new BeforeDeleteRoleEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_DELETE_ROLE, $beforeEvent)->isPropagationStopped()) {
            return;
        }

        parent::deleteRole($role);

        $this->eventDispatcher->dispatch(
            RoleEvents::DELETE_ROLE,
            new DeleteRoleEvent(...$eventData)
        );
    }

    public function assignRoleToUserGroup(
        Role $role,
        UserGroup $userGroup,
        RoleLimitation $roleLimitation = null
    ) {
        $eventData = [
            $role,
            $userGroup,
            $roleLimitation,
        ];

        $beforeEvent = new BeforeAssignRoleToUserGroupEvent(...$eventData);

The call to BeforeAssignRoleToUserGroupEvent::__construct() misses some required arguments starting with $userGroup.

        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_ASSIGN_ROLE_TO_USER_GROUP, $beforeEvent)->isPropagationStopped()) {
            return;
        }

        parent::assignRoleToUserGroup($role, $userGroup, $roleLimitation);

        $this->eventDispatcher->dispatch(
            RoleEvents::ASSIGN_ROLE_TO_USER_GROUP,
            new AssignRoleToUserGroupEvent(...$eventData)

The call to AssignRoleToUserGroupEvent::__construct() misses some required arguments starting with $userGroup.

        );
    }

    public function unassignRoleFromUserGroup(
        Role $role,
        UserGroup $userGroup
    ) {
        $eventData = [
            $role,
            $userGroup,
        ];

        $beforeEvent = new BeforeUnassignRoleFromUserGroupEvent(...$eventData);

The call to BeforeUnassignRoleFromUserGroupEvent::__construct() misses a required argument $userGroup.

        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_UNASSIGN_ROLE_FROM_USER_GROUP, $beforeEvent)->isPropagationStopped()) {
            return;
        }

        parent::unassignRoleFromUserGroup($role, $userGroup);

        $this->eventDispatcher->dispatch(
            RoleEvents::UNASSIGN_ROLE_FROM_USER_GROUP,
            new UnassignRoleFromUserGroupEvent(...$eventData)

The call to UnassignRoleFromUserGroupEvent::__construct() misses a required argument $userGroup.

        );
    }

    public function assignRoleToUser(
        Role $role,
        User $user,
        RoleLimitation $roleLimitation = null
    ) {
        $eventData = [
            $role,
            $user,
            $roleLimitation,
        ];

        $beforeEvent = new BeforeAssignRoleToUserEvent(...$eventData);

The call to BeforeAssignRoleToUserEvent::__construct() misses some required arguments starting with $user.

        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_ASSIGN_ROLE_TO_USER, $beforeEvent)->isPropagationStopped()) {
            return;
        }

        parent::assignRoleToUser($role, $user, $roleLimitation);

        $this->eventDispatcher->dispatch(
            RoleEvents::ASSIGN_ROLE_TO_USER,
            new AssignRoleToUserEvent(...$eventData)

The call to AssignRoleToUserEvent::__construct() misses some required arguments starting with $user.

        );
    }

    public function unassignRoleFromUser(
        Role $role,
        User $user
    ) {
        $eventData = [
            $role,
            $user,
        ];

        $beforeEvent = new BeforeUnassignRoleFromUserEvent(...$eventData);

The call to BeforeUnassignRoleFromUserEvent::__construct() misses a required argument $user.

        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_UNASSIGN_ROLE_FROM_USER, $beforeEvent)->isPropagationStopped()) {
            return;
        }

        parent::unassignRoleFromUser($role, $user);

        $this->eventDispatcher->dispatch(
            RoleEvents::UNASSIGN_ROLE_FROM_USER,
            new UnassignRoleFromUserEvent(...$eventData)

The call to UnassignRoleFromUserEvent::__construct() misses a required argument $user.

        );
    }

    public function removeRoleAssignment(RoleAssignment $roleAssignment)
    {
        $eventData = [$roleAssignment];

        $beforeEvent = new BeforeRemoveRoleAssignmentEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_REMOVE_ROLE_ASSIGNMENT, $beforeEvent)->isPropagationStopped()) {
            return;
        }

        parent::removeRoleAssignment($roleAssignment);

        $this->eventDispatcher->dispatch(
            RoleEvents::REMOVE_ROLE_ASSIGNMENT,
            new RemoveRoleAssignmentEvent(...$eventData)
        );
    }
}