RoleService::updatePolicyByRoleDraft() - Code Metrics - Inspection of "new EventDispatcher Repository Layer" - ezsystems/ezpublish-kernel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — signal-slots ( f9cce0...3c05c8 )

unknown

created 2019-05-29 22:01 UTC

RoleService::updatePolicyByRoleDraft() A

↳ Parent: RoleService

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	25
Ratio	100 %

Importance

Changes

Metric	Value
cc	2
nc	2
nop	3
dl	25
loc	25
rs	9.52
c	0
b	0
f	0

<?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();
        } else {
            $roleDraft = 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();
        } else {
            $roleDraft = parent::createRoleDraft($role);
        }

        $this->eventDispatcher->dispatch(
            RoleEvents::CREATE_ROLE_DRAFT,
            new CreateRoleDraftEvent($roleDraft, ...$eventData)
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
        );

        return $roleDraft;
    }

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

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

        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_UPDATE_ROLE_DRAFT, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        } else {
            $updatedRoleDraft = parent::updateRoleDraft($roleDraft, $roleUpdateStruct);
        }

        $this->eventDispatcher->dispatch(
            RoleEvents::UPDATE_ROLE_DRAFT,
            new UpdateRoleDraftEvent($updatedRoleDraft, ...$eventData)
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
        );

        return $updatedRoleDraft;
    }

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

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

        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_ADD_POLICY_BY_ROLE_DRAFT, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        } else {
            $updatedRoleDraft = parent::addPolicyByRoleDraft($roleDraft, $policyCreateStruct);
        }

        $this->eventDispatcher->dispatch(
            RoleEvents::ADD_POLICY_BY_ROLE_DRAFT,
            new AddPolicyByRoleDraftEvent($updatedRoleDraft, ...$eventData)
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
        );

        return $updatedRoleDraft;
    }

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

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

        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_REMOVE_POLICY_BY_ROLE_DRAFT, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        } else {
            $updatedRoleDraft = parent::removePolicyByRoleDraft($roleDraft, $policyDraft);
        }

        $this->eventDispatcher->dispatch(
            RoleEvents::REMOVE_POLICY_BY_ROLE_DRAFT,
            new RemovePolicyByRoleDraftEvent($updatedRoleDraft, ...$eventData)
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
        );

        return $updatedRoleDraft;
    }

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

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

        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_UPDATE_POLICY_BY_ROLE_DRAFT, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        } else {
            $updatedPolicyDraft = parent::updatePolicyByRoleDraft($roleDraft, $policy, $policyUpdateStruct);
        }

        $this->eventDispatcher->dispatch(
            RoleEvents::UPDATE_POLICY_BY_ROLE_DRAFT,
            new UpdatePolicyByRoleDraftEvent($updatedPolicyDraft, ...$eventData)
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
        );

        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;
        } else {
            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;
        } else {
            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);

        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_UPDATE_ROLE, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        } else {
            $updatedRole = parent::updateRole($role, $roleUpdateStruct);
        }

        $this->eventDispatcher->dispatch(
            RoleEvents::UPDATE_ROLE,
            new UpdateRoleEvent($updatedRole, ...$eventData)
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
        );

        return $updatedRole;
    }

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

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

        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_ADD_POLICY, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        } else {
            $updatedRole = parent::addPolicy($role, $policyCreateStruct);
        }

        $this->eventDispatcher->dispatch(
            RoleEvents::ADD_POLICY,
            new AddPolicyEvent($updatedRole, ...$eventData)
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
        );

        return $updatedRole;
    }

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

        $beforeEvent = new BeforeDeletePolicyEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_DELETE_POLICY, $beforeEvent)->isPropagationStopped()) {
            return;
        } else {
            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);

        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_UPDATE_POLICY, $beforeEvent)->isPropagationStopped()) {
            return $beforeEvent->getReturnValue();
        } else {
            $updatedPolicy = parent::updatePolicy($policy, $policyUpdateStruct);
        }

        $this->eventDispatcher->dispatch(
            RoleEvents::UPDATE_POLICY,
            new UpdatePolicyEvent($updatedPolicy, ...$eventData)
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
        );

        return $updatedPolicy;
    }

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

        $beforeEvent = new BeforeDeleteRoleEvent(...$eventData);
        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_DELETE_ROLE, $beforeEvent)->isPropagationStopped()) {
            return;
        } else {
            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);

        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_ASSIGN_ROLE_TO_USER_GROUP, $beforeEvent)->isPropagationStopped()) {
            return;
        } else {
            parent::assignRoleToUserGroup($role, $userGroup, $roleLimitation);
        }

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

        );
    }

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

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

        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_UNASSIGN_ROLE_FROM_USER_GROUP, $beforeEvent)->isPropagationStopped()) {
            return;
        } else {
            parent::unassignRoleFromUserGroup($role, $userGroup);
        }

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

        );
    }

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

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

        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_ASSIGN_ROLE_TO_USER, $beforeEvent)->isPropagationStopped()) {
            return;
        } else {
            parent::assignRoleToUser($role, $user, $roleLimitation);
        }

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

        );
    }

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

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

        if ($this->eventDispatcher->dispatch(RoleEvents::BEFORE_UNASSIGN_ROLE_FROM_USER, $beforeEvent)->isPropagationStopped()) {
            return;
        } else {
            parent::unassignRoleFromUser($role, $user);
        }

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

        );
    }

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

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

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


1			<?php
2
3			/**
4			* @copyright Copyright (C) eZ Systems AS. All rights reserved.
5			* @license For full copyright and license information view LICENSE file distributed with this source code.
6			*/
7			declare(strict_types=1);
8
9			namespace eZ\Publish\Core\Event;
10
11			use eZ\Publish\SPI\Repository\Decorator\RoleServiceDecorator;
12			use Symfony\Component\EventDispatcher\EventDispatcherInterface;
13			use eZ\Publish\API\Repository\RoleService as RoleServiceInterface;
14			use eZ\Publish\API\Repository\Values\User\Limitation\RoleLimitation;
15			use eZ\Publish\API\Repository\Values\User\Policy;
16			use eZ\Publish\API\Repository\Values\User\PolicyCreateStruct;
17			use eZ\Publish\API\Repository\Values\User\PolicyDraft;
18			use eZ\Publish\API\Repository\Values\User\PolicyUpdateStruct;
19			use eZ\Publish\API\Repository\Values\User\Role;
20			use eZ\Publish\API\Repository\Values\User\RoleAssignment;
21			use eZ\Publish\API\Repository\Values\User\RoleCreateStruct;
22			use eZ\Publish\API\Repository\Values\User\RoleDraft;
23			use eZ\Publish\API\Repository\Values\User\RoleUpdateStruct;
24			use eZ\Publish\API\Repository\Values\User\User;
25			use eZ\Publish\API\Repository\Values\User\UserGroup;
26			use eZ\Publish\Core\Event\Role\AddPolicyByRoleDraftEvent;
27			use eZ\Publish\Core\Event\Role\AddPolicyEvent;
28			use eZ\Publish\Core\Event\Role\AssignRoleToUserEvent;
29			use eZ\Publish\Core\Event\Role\AssignRoleToUserGroupEvent;
30			use eZ\Publish\Core\Event\Role\BeforeAddPolicyByRoleDraftEvent;
31			use eZ\Publish\Core\Event\Role\BeforeAddPolicyEvent;
32			use eZ\Publish\Core\Event\Role\BeforeAssignRoleToUserEvent;
33			use eZ\Publish\Core\Event\Role\BeforeAssignRoleToUserGroupEvent;
34			use eZ\Publish\Core\Event\Role\BeforeCreateRoleDraftEvent;
35			use eZ\Publish\Core\Event\Role\BeforeCreateRoleEvent;
36			use eZ\Publish\Core\Event\Role\BeforeDeletePolicyEvent;
37			use eZ\Publish\Core\Event\Role\BeforeDeleteRoleDraftEvent;
38			use eZ\Publish\Core\Event\Role\BeforeDeleteRoleEvent;
39			use eZ\Publish\Core\Event\Role\BeforePublishRoleDraftEvent;
40			use eZ\Publish\Core\Event\Role\BeforeRemovePolicyByRoleDraftEvent;

ezsystems / ezpublish-kernel

Push — signal-slots ( f9cce0...3c05c8 )

RoleService::updatePolicyByRoleDraft() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like