UserHandler::loadRole() - Code Metrics - Inspection of "EZP-29891: fixes loading targets in ParentContentL..." - ezsystems/ezpublish-kernel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — EZP-29891 ( 916cf6...0402ff )

unknown

created 2019-02-08 07:26 UTC

UserHandler::loadRole() A

↳ Parent: UserHandler

Complexity

Conditions	3
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
nc	3
nop	2
dl	0
loc	16
rs	9.7333
c	0
b	0
f	0

<?php

/**
 * File containing a User Handler impl.
 *
 * @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\Persistence\Cache;

use eZ\Publish\API\Repository\Exceptions\NotFoundException;
use eZ\Publish\SPI\Persistence\User\Handler as UserHandlerInterface;
use eZ\Publish\SPI\Persistence\User;
use eZ\Publish\SPI\Persistence\User\Role;
use eZ\Publish\SPI\Persistence\User\RoleCreateStruct;
use eZ\Publish\SPI\Persistence\User\RoleUpdateStruct;
use eZ\Publish\SPI\Persistence\User\Policy;

/**
 * Cache handler for user module.
 */
class UserHandler extends AbstractHandler implements UserHandlerInterface
{
    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::create
     */
    public function create(User $user)
    {
        $this->logger->logCall(__METHOD__, array('struct' => $user));
        $return = $this->persistenceHandler->userHandler()->create($user);

        // Clear corresponding content cache as creation of the User changes it's external data
        $this->cache->clear('content', $user->id);

        return $return;
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::load
     */
    public function load($userId)
    {
        $this->logger->logCall(__METHOD__, array('user' => $userId));

        return $this->persistenceHandler->userHandler()->load($userId);
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::loadByLogin
     */
    public function loadByLogin($login)
    {
        $this->logger->logCall(__METHOD__, array('user' => $login));

        return $this->persistenceHandler->userHandler()->loadByLogin($login);
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::loadByEmail
     */
    public function loadByEmail($email)
    {
        $this->logger->logCall(__METHOD__, array('email' => $email));

        return $this->persistenceHandler->userHandler()->loadByEmail($email);
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::update
     */
    public function update(User $user)
    {
        $this->logger->logCall(__METHOD__, array('struct' => $user));
        $return = $this->persistenceHandler->userHandler()->update($user);

        // Clear corresponding content cache as update of the User changes it's external data
        $this->cache->clear('content', $user->id);

        return $return;
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::delete
     */
    public function delete($userId)
    {
        $this->logger->logCall(__METHOD__, array('user' => $userId));
        $return = $this->persistenceHandler->userHandler()->delete($userId);

        // user id == content id == group id
        $this->cache->clear('content', $userId);
        $this->cache->clear('user', 'role', 'assignments', 'byGroup', $userId);
        $this->cache->clear('user', 'role', 'assignments', 'byGroup', 'inherited', $userId);

        return $return;
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::createRole
     */
    public function createRole(RoleCreateStruct $createStruct)
    {
        $this->logger->logCall(__METHOD__, array('struct' => $createStruct));

        return $this->persistenceHandler->userHandler()->createRole($createStruct);
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::createRoleDraft
     */
    public function createRoleDraft($roleId)
    {
        $this->logger->logCall(__METHOD__, array('role' => $roleId));

        return $this->persistenceHandler->userHandler()->createRoleDraft($roleId);
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::loadRole
     */
    public function loadRole($roleId, $status = Role::STATUS_DEFINED)
    {
        if ($status === Role::STATUS_DEFINED) {
            $cache = $this->cache->getItem('user', 'role', $roleId);
            $role = $cache->get();
            if ($cache->isMiss()) {
                $this->logger->logCall(__METHOD__, array('role' => $roleId));
                $role = $this->persistenceHandler->userHandler()->loadRole($roleId, $status);
                $cache->set($role)->save();
            }
        } else {
            $role = $this->persistenceHandler->userHandler()->loadRole($roleId, $status);
        }

        return $role;
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::loadRoleByIdentifier
     */
    public function loadRoleByIdentifier($identifier, $status = Role::STATUS_DEFINED)
    {
        $this->logger->logCall(__METHOD__, array('role' => $identifier));

        return $this->persistenceHandler->userHandler()->loadRoleByIdentifier($identifier, $status);
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::loadRoleDraftByRoleId
     */
    public function loadRoleDraftByRoleId($roleId)
    {
        $this->logger->logCall(__METHOD__, array('role' => $roleId));

        return $this->persistenceHandler->userHandler()->loadRoleDraftByRoleId($roleId);
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::loadRoles
     */
    public function loadRoles()
    {
        $this->logger->logCall(__METHOD__);

        return $this->persistenceHandler->userHandler()->loadRoles();
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::loadRoleAssignment
     */
    public function loadRoleAssignment($roleAssignmentId)
    {
        $this->logger->logCall(__METHOD__, array('assignment' => $roleAssignmentId));

        return $this->persistenceHandler->userHandler()->loadRoleAssignment($roleAssignmentId);
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::loadRoleAssignmentsByRoleId
     */
    public function loadRoleAssignmentsByRoleId($roleId)
    {
        $this->logger->logCall(__METHOD__, array('role' => $roleId));

        return $this->persistenceHandler->userHandler()->loadRoleAssignmentsByRoleId($roleId);
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::loadRoleAssignmentsByGroupId
     */
    public function loadRoleAssignmentsByGroupId($groupId, $inherit = false)
    {
        if ($inherit) {
            $cache = $this->cache->getItem('user', 'role', 'assignments', 'byGroup', 'inherited', $groupId);
        } else {
            $cache = $this->cache->getItem('user', 'role', 'assignments', 'byGroup', $groupId);
        }
        $assignments = $cache->get();
        if ($cache->isMiss()) {
            $this->logger->logCall(__METHOD__, array('group' => $groupId, 'inherit' => $inherit));
            $assignments = $this->persistenceHandler->userHandler()->loadRoleAssignmentsByGroupId(
                $groupId,
                $inherit
            );
            $cache->set($assignments)->save();
        }

        return $assignments;
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::updateRole
     */
    public function updateRole(RoleUpdateStruct $struct)
    {
        $this->logger->logCall(__METHOD__, array('struct' => $struct));
        $this->persistenceHandler->userHandler()->updateRole($struct);

        $this->cache->clear('user', 'role', $struct->id);
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::deleteRole
     */
    public function deleteRole($roleId, $status = Role::STATUS_DEFINED)
    {
        $this->logger->logCall(__METHOD__, array('role' => $roleId));
        $return = $this->persistenceHandler->userHandler()->deleteRole($roleId, $status);

        if ($status === Role::STATUS_DEFINED) {
            $this->cache->clear('user', 'role', $roleId);
            $this->cache->clear('user', 'role', 'assignments');
        }

        return $return;
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::publishRoleDraft
     */
    public function publishRoleDraft($roleDraftId)
    {
        $this->logger->logCall(__METHOD__, array('role' => $roleDraftId));
        $userHandler = $this->persistenceHandler->userHandler();
        $roleDraft = $userHandler->loadRole($roleDraftId, Role::STATUS_DRAFT);
        $return = $userHandler->publishRoleDraft($roleDraftId);

        $this->cache->clear('user', 'role', 'assignments');
        // Get right published role to cache it.
        try {
            // Role draft created from existing role.
            $publishedRole = $userHandler->loadRole($roleDraft->originalId);
        } catch (NotFoundException $e) {
            // Completely new role.
            $publishedRole = $userHandler->loadRole($roleDraftId);
        }
        $this->cache
            ->getItem('user', 'role', $publishedRole->id)
            ->set($publishedRole)
            ->save();

        return $return;
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::addPolicyByRoleDraft
     */
    public function addPolicyByRoleDraft($roleId, Policy $policy)
    {
        $this->logger->logCall(__METHOD__, array('role' => $roleId, 'struct' => $policy));

        return $this->persistenceHandler->userHandler()->addPolicyByRoleDraft($roleId, $policy);
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::addPolicy
     */
    public function addPolicy($roleId, Policy $policy)
    {
        $this->logger->logCall(__METHOD__, array('role' => $roleId, 'struct' => $policy));
        $return = $this->persistenceHandler->userHandler()->addPolicy($roleId, $policy);

        $this->cache->clear('user', 'role', $roleId);

        return $return;
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::updatePolicy
     */
    public function updatePolicy(Policy $policy)
    {
        $this->logger->logCall(__METHOD__, array('struct' => $policy));
        $return = $this->persistenceHandler->userHandler()->updatePolicy($policy);

        $this->cache->clear('user', 'role', $policy->roleId);

        return $return;
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::deletePolicy
     */
    public function deletePolicy($policyId)
    {
        $this->logger->logCall(__METHOD__, array('policy' => $policyId));
        $this->persistenceHandler->userHandler()->deletePolicy($policyId);

        $this->cache->clear('user', 'role');
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::loadPoliciesByUserId
     */
    public function loadPoliciesByUserId($userId)
    {
        $this->logger->logCall(__METHOD__, array('user' => $userId));

        return $this->persistenceHandler->userHandler()->loadPoliciesByUserId($userId);
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::assignRole
     */
    public function assignRole($contentId, $roleId, array $limitation = null)
    {
        $this->logger->logCall(__METHOD__, array('group' => $contentId, 'role' => $roleId, 'limitation' => $limitation));
        $return = $this->persistenceHandler->userHandler()->assignRole($contentId, $roleId, $limitation);

        $this->cache->clear('user', 'role', $roleId);
        $this->cache->clear('user', 'role', 'assignments', 'byGroup', $contentId);
        $this->cache->clear('user', 'role', 'assignments', 'byGroup', 'inherited');

        return $return;
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::unassignRole
     */
    public function unassignRole($contentId, $roleId)
    {
        $this->logger->logCall(__METHOD__, array('group' => $contentId, 'role' => $roleId));
        $return = $this->persistenceHandler->userHandler()->unassignRole($contentId, $roleId);

        $this->cache->clear('user', 'role', $roleId);
        $this->cache->clear('user', 'role', 'assignments', 'byGroup', $contentId);
        $this->cache->clear('user', 'role', 'assignments', 'byGroup', 'inherited');

        return $return;
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::removeRoleAssignment
     */
    public function removeRoleAssignment($roleAssignmentId)
    {
        $this->logger->logCall(__METHOD__, array('assignment' => $roleAssignmentId));
        $return = $this->persistenceHandler->userHandler()->removeRoleAssignment($roleAssignmentId);

        // We don't know the contentId, so clear all assignment cache.
        $this->cache->clear('user', 'role', 'assignments'); //TIMBER!

        return $return;
    }
}


1		<?php
2
3		/**
4		* File containing a User Handler impl.
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\Persistence\Cache;
10
11		use eZ\Publish\API\Repository\Exceptions\NotFoundException;
12		use eZ\Publish\SPI\Persistence\User\Handler as UserHandlerInterface;
13		use eZ\Publish\SPI\Persistence\User;
14		use eZ\Publish\SPI\Persistence\User\Role;
15		use eZ\Publish\SPI\Persistence\User\RoleCreateStruct;
16		use eZ\Publish\SPI\Persistence\User\RoleUpdateStruct;
17		use eZ\Publish\SPI\Persistence\User\Policy;
18
19		/**
20		* Cache handler for user module.
21		*/
22		class UserHandler extends AbstractHandler implements UserHandlerInterface
23		{
24		/**
25		* @see eZ\Publish\SPI\Persistence\User\Handler::create
26		*/
27		public function create(User $user)
28		{
29		$this->logger->logCall(__METHOD__, array('struct' => $user));
30		$return = $this->persistenceHandler->userHandler()->create($user);
31
32		// Clear corresponding content cache as creation of the User changes it's external data
33		$this->cache->clear('content', $user->id);
34
35		return $return;
36		}
37
38		/**
39		* @see eZ\Publish\SPI\Persistence\User\Handler::load
40		*/
41		public function load($userId)
42		{
43		$this->logger->logCall(__METHOD__, array('user' => $userId));
44
45		return $this->persistenceHandler->userHandler()->load($userId);
46		}
47
48		/**
49		* @see eZ\Publish\SPI\Persistence\User\Handler::loadByLogin
50		*/
51		public function loadByLogin($login)
52		{
53		$this->logger->logCall(__METHOD__, array('user' => $login));
54
55		return $this->persistenceHandler->userHandler()->loadByLogin($login);
56		}
57
58		/**
59		* @see eZ\Publish\SPI\Persistence\User\Handler::loadByEmail
60		*/
61		public function loadByEmail($email)
62		{
63		$this->logger->logCall(__METHOD__, array('email' => $email));
64
65		return $this->persistenceHandler->userHandler()->loadByEmail($email);
66		}
67
68		/**
69		* @see eZ\Publish\SPI\Persistence\User\Handler::update
70		*/
71		public function update(User $user)
72		{
73		$this->logger->logCall(__METHOD__, array('struct' => $user));
74		$return = $this->persistenceHandler->userHandler()->update($user);
75
76		// Clear corresponding content cache as update of the User changes it's external data
77		$this->cache->clear('content', $user->id);
78
79		return $return;
80		}
81
82		/**
83		* @see eZ\Publish\SPI\Persistence\User\Handler::delete
84		*/
85		public function delete($userId)
86		{
87		$this->logger->logCall(__METHOD__, array('user' => $userId));
88		$return = $this->persistenceHandler->userHandler()->delete($userId);
89
90		// user id == content id == group id
91		$this->cache->clear('content', $userId);
92		$this->cache->clear('user', 'role', 'assignments', 'byGroup', $userId);
93		$this->cache->clear('user', 'role', 'assignments', 'byGroup', 'inherited', $userId);
94
95		return $return;
96		}
97
98		/**
99		* @see eZ\Publish\SPI\Persistence\User\Handler::createRole
100		*/
101		public function createRole(RoleCreateStruct $createStruct)
102		{
103		$this->logger->logCall(__METHOD__, array('struct' => $createStruct));
104
105		return $this->persistenceHandler->userHandler()->createRole($createStruct);
106		}
107
108		/**
109		* @see eZ\Publish\SPI\Persistence\User\Handler::createRoleDraft
110		*/
111		public function createRoleDraft($roleId)
112		{
113		$this->logger->logCall(__METHOD__, array('role' => $roleId));
114
115		return $this->persistenceHandler->userHandler()->createRoleDraft($roleId);
116		}
117
118		/**
119		* @see eZ\Publish\SPI\Persistence\User\Handler::loadRole
120		*/
121		public function loadRole($roleId, $status = Role::STATUS_DEFINED)
122		{
123		if ($status === Role::STATUS_DEFINED) {
124		$cache = $this->cache->getItem('user', 'role', $roleId);
125		$role = $cache->get();
126		if ($cache->isMiss()) {
127		$this->logger->logCall(__METHOD__, array('role' => $roleId));
128		$role = $this->persistenceHandler->userHandler()->loadRole($roleId, $status);
129		$cache->set($role)->save();
130		}
131		} else {
132		$role = $this->persistenceHandler->userHandler()->loadRole($roleId, $status);
133		}
134
135		return $role;
136		}
137
138		/**
139		* @see eZ\Publish\SPI\Persistence\User\Handler::loadRoleByIdentifier
140		*/
141		public function loadRoleByIdentifier($identifier, $status = Role::STATUS_DEFINED)
142		{
143		$this->logger->logCall(__METHOD__, array('role' => $identifier));
144
145		return $this->persistenceHandler->userHandler()->loadRoleByIdentifier($identifier, $status);
146		}
147
148		/**
149		* @see eZ\Publish\SPI\Persistence\User\Handler::loadRoleDraftByRoleId
150		*/
151		public function loadRoleDraftByRoleId($roleId)
152		{
153		$this->logger->logCall(__METHOD__, array('role' => $roleId));
154
155		return $this->persistenceHandler->userHandler()->loadRoleDraftByRoleId($roleId);
156		}
157
158		/**
159		* @see eZ\Publish\SPI\Persistence\User\Handler::loadRoles
160		*/
161		public function loadRoles()
162		{
163		$this->logger->logCall(__METHOD__);
164
165		return $this->persistenceHandler->userHandler()->loadRoles();
166		}
167
168		/**
169		* @see eZ\Publish\SPI\Persistence\User\Handler::loadRoleAssignment
170		*/
171		public function loadRoleAssignment($roleAssignmentId)
172		{
173		$this->logger->logCall(__METHOD__, array('assignment' => $roleAssignmentId));
174
175		return $this->persistenceHandler->userHandler()->loadRoleAssignment($roleAssignmentId);
176		}
177
178		/**
179		* @see eZ\Publish\SPI\Persistence\User\Handler::loadRoleAssignmentsByRoleId
180		*/
181		public function loadRoleAssignmentsByRoleId($roleId)
182		{
183		$this->logger->logCall(__METHOD__, array('role' => $roleId));
184
185		return $this->persistenceHandler->userHandler()->loadRoleAssignmentsByRoleId($roleId);
186		}
187
188		/**
189		* @see eZ\Publish\SPI\Persistence\User\Handler::loadRoleAssignmentsByGroupId
190		*/
191		public function loadRoleAssignmentsByGroupId($groupId, $inherit = false)
192		{
193		if ($inherit) {
194		$cache = $this->cache->getItem('user', 'role', 'assignments', 'byGroup', 'inherited', $groupId);
195		} else {
196		$cache = $this->cache->getItem('user', 'role', 'assignments', 'byGroup', $groupId);
197		}
198		$assignments = $cache->get();
199		if ($cache->isMiss()) {
200		$this->logger->logCall(__METHOD__, array('group' => $groupId, 'inherit' => $inherit));
201		$assignments = $this->persistenceHandler->userHandler()->loadRoleAssignmentsByGroupId(
202		$groupId,
203		$inherit
204		);
205		$cache->set($assignments)->save();
206		}
207
208		return $assignments;
209		}
210
211		/**
212		* @see eZ\Publish\SPI\Persistence\User\Handler::updateRole
213		*/
214	View Code Duplication	public function updateRole(RoleUpdateStruct $struct)
215		{
216		$this->logger->logCall(__METHOD__, array('struct' => $struct));
217		$this->persistenceHandler->userHandler()->updateRole($struct);
218
219		$this->cache->clear('user', 'role', $struct->id);
220		}
221
222		/**
223		* @see eZ\Publish\SPI\Persistence\User\Handler::deleteRole
224		*/
225		public function deleteRole($roleId, $status = Role::STATUS_DEFINED)
226		{
227		$this->logger->logCall(__METHOD__, array('role' => $roleId));
228		$return = $this->persistenceHandler->userHandler()->deleteRole($roleId, $status);
229
230		if ($status === Role::STATUS_DEFINED) {
231		$this->cache->clear('user', 'role', $roleId);
232		$this->cache->clear('user', 'role', 'assignments');
233		}
234
235		return $return;
236		}
237
238		/**
239		* @see eZ\Publish\SPI\Persistence\User\Handler::publishRoleDraft
240		*/
241		public function publishRoleDraft($roleDraftId)
242		{
243		$this->logger->logCall(__METHOD__, array('role' => $roleDraftId));
244		$userHandler = $this->persistenceHandler->userHandler();
245		$roleDraft = $userHandler->loadRole($roleDraftId, Role::STATUS_DRAFT);
246		$return = $userHandler->publishRoleDraft($roleDraftId);
247
248		$this->cache->clear('user', 'role', 'assignments');
249		// Get right published role to cache it.
250		try {
251		// Role draft created from existing role.
252		$publishedRole = $userHandler->loadRole($roleDraft->originalId);
253		} catch (NotFoundException $e) {
254		// Completely new role.
255		$publishedRole = $userHandler->loadRole($roleDraftId);
256		}
257		$this->cache
258		->getItem('user', 'role', $publishedRole->id)
259		->set($publishedRole)
260		->save();
261
262		return $return;
263		}
264
265		/**
266		* @see eZ\Publish\SPI\Persistence\User\Handler::addPolicyByRoleDraft
267		*/
268		public function addPolicyByRoleDraft($roleId, Policy $policy)
269		{
270		$this->logger->logCall(__METHOD__, array('role' => $roleId, 'struct' => $policy));
271
272		return $this->persistenceHandler->userHandler()->addPolicyByRoleDraft($roleId, $policy);
273		}
274
275		/**
276		* @see eZ\Publish\SPI\Persistence\User\Handler::addPolicy
277		*/
278		public function addPolicy($roleId, Policy $policy)
279		{
280		$this->logger->logCall(__METHOD__, array('role' => $roleId, 'struct' => $policy));
281		$return = $this->persistenceHandler->userHandler()->addPolicy($roleId, $policy);
282
283		$this->cache->clear('user', 'role', $roleId);
284
285		return $return;
286		}
287
288		/**
289		* @see eZ\Publish\SPI\Persistence\User\Handler::updatePolicy
290		*/
291		public function updatePolicy(Policy $policy)
292		{
293		$this->logger->logCall(__METHOD__, array('struct' => $policy));
294		$return = $this->persistenceHandler->userHandler()->updatePolicy($policy);
295
296		$this->cache->clear('user', 'role', $policy->roleId);
297
298		return $return;
299		}
300
301		/**
302		* @see eZ\Publish\SPI\Persistence\User\Handler::deletePolicy
303		*/
304	View Code Duplication	public function deletePolicy($policyId)
305		{
306		$this->logger->logCall(__METHOD__, array('policy' => $policyId));
307		$this->persistenceHandler->userHandler()->deletePolicy($policyId);
308
309		$this->cache->clear('user', 'role');
310		}
311
312		/**
313		* @see eZ\Publish\SPI\Persistence\User\Handler::loadPoliciesByUserId
314		*/
315		public function loadPoliciesByUserId($userId)
316		{
317		$this->logger->logCall(__METHOD__, array('user' => $userId));
318
319		return $this->persistenceHandler->userHandler()->loadPoliciesByUserId($userId);
320		}
321
322		/**
323		* @see eZ\Publish\SPI\Persistence\User\Handler::assignRole
324		*/
325	View Code Duplication	public function assignRole($contentId, $roleId, array $limitation = null)
326		{
327		$this->logger->logCall(__METHOD__, array('group' => $contentId, 'role' => $roleId, 'limitation' => $limitation));
328		$return = $this->persistenceHandler->userHandler()->assignRole($contentId, $roleId, $limitation);
329
330		$this->cache->clear('user', 'role', $roleId);
331		$this->cache->clear('user', 'role', 'assignments', 'byGroup', $contentId);
332		$this->cache->clear('user', 'role', 'assignments', 'byGroup', 'inherited');
333
334		return $return;
335		}
336
337		/**
338		* @see eZ\Publish\SPI\Persistence\User\Handler::unassignRole
339		*/
340	View Code Duplication	public function unassignRole($contentId, $roleId)
341		{
342		$this->logger->logCall(__METHOD__, array('group' => $contentId, 'role' => $roleId));
343		$return = $this->persistenceHandler->userHandler()->unassignRole($contentId, $roleId);
344
345		$this->cache->clear('user', 'role', $roleId);
346		$this->cache->clear('user', 'role', 'assignments', 'byGroup', $contentId);
347		$this->cache->clear('user', 'role', 'assignments', 'byGroup', 'inherited');
348
349		return $return;
350		}
351
352		/**
353		* @see eZ\Publish\SPI\Persistence\User\Handler::removeRoleAssignment
354		*/
355	View Code Duplication	public function removeRoleAssignment($roleAssignmentId)
356		{
357		$this->logger->logCall(__METHOD__, array('assignment' => $roleAssignmentId));
358		$return = $this->persistenceHandler->userHandler()->removeRoleAssignment($roleAssignmentId);
359
360		// We don't know the contentId, so clear all assignment cache.
361		$this->cache->clear('user', 'role', 'assignments'); //TIMBER!
362
363		return $return;
364		}
365		}
366

ezsystems / ezpublish-kernel

Push — EZP-29891 ( 916cf6...0402ff )

UserHandler::loadRole() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like