UserHandler::deletePolicy() - Code Metrics - Inspection of "TMP" - ezsystems/ezpublish-kernel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — sf_cache ( 94d0e5...42a66b )

by André

created 2017-01-19 08:44 UTC

UserHandler::deletePolicy() A

↳ Parent: UserHandler

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	4

Duplication

Lines	7
Ratio	100 %

Importance

Changes

Metric	Value
cc	1
eloc	4
nc	1
nop	1
dl	7
loc	7
rs	9.4285
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->invalidateTags(['content-fields-'.$user->id]);

        return $return;
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::load
     */
    public function load($userId)
    {
        $cacheItem = $this->cache->getItem("ez-user-${userId}");
        if ($cacheItem->isHit()) {
            return $cacheItem->get();
        }

        $this->logger->logCall(__METHOD__, array('user' => $userId));
        $user = $this->persistenceHandler->userHandler()->load($userId);

        $cacheItem->set($user);
        $cacheItem->tag(['content-'.$user->id, 'user-'.$user->id]);
        $this->cache->save($cacheItem);

        return $user;
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::loadByLogin
     */
    public function loadByLogin($login)
    {
        $cacheItem = $this->cache->getItem("ez-user-login-${login}");
        if ($cacheItem->isHit()) {
            return $cacheItem->get();
        }

        $this->logger->logCall(__METHOD__, array('user' => $login));
        $user = $this->persistenceHandler->userHandler()->loadByLogin($login);

        $cacheItem->set($user);
        $cacheItem->tag(['content-'.$user->id, 'user-'.$user->id]);
        $this->cache->save($cacheItem);

        return $user;
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::loadByEmail
     */
    public function loadByEmail($email)
    {
        $cacheItem = $this->cache->getItem("ez-user-email-${email}");
        if ($cacheItem->isHit()) {
            return $cacheItem->get();
        }

        $this->logger->logCall(__METHOD__, array('email' => $email));
        $users = $this->persistenceHandler->userHandler()->loadByEmail($email);

        $cacheItem->set($users);
        $cacheTags = [];
        foreach ($users as $user) {
            $cacheTags[] = 'content-'.$user->id;
            $cacheTags[] = 'user-'.$user->id;
        }
        $cacheItem->tag($cacheTags);
        $this->cache->save($cacheItem);

        return $users;
    }

    /**
     * @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->invalidateTags(['content-fields-'.$user->id, 'user-'.$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->invalidateTags(['content-fields-'.$userId, 'user-'.$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) {
            $this->logger->logCall(__METHOD__, array('role' => $roleId));

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

        $cacheItem = $this->cache->getItem("ez-role-${roleId}");
        if ($cacheItem->isHit()) {
            return $cacheItem->get();
        }

        $this->logger->logCall(__METHOD__, array('role' => $roleId));
        $role = $this->persistenceHandler->userHandler()->loadRole($roleId);

        $cacheItem->set($role);
        $cacheItem->tag(['role-'.$role->id]);
        $this->cache->save($cacheItem);

        return $role;
    }

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

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

        $cacheItem = $this->cache->getItem("ez-role-identifier-${identifier}");
        if ($cacheItem->isHit()) {
            return $cacheItem->get();
        }

        $this->logger->logCall(__METHOD__, array('role' => $identifier));
        $role = $this->persistenceHandler->userHandler()->loadRoleByIdentifier($identifier, $status);

        $cacheItem->set($role);
        $cacheItem->tag(['role-'.$role->id]);
        $this->cache->save($cacheItem);

        return $role;
    }

    /**
     * @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)
    {
        $cacheItem = $this->cache->getItem("ez-role-assignment-${roleAssignmentId}");
        if ($cacheItem->isHit()) {
            return $cacheItem->get();
        }

        $this->logger->logCall(__METHOD__, array('assignment' => $roleAssignmentId));
        $roleAssignment = $this->persistenceHandler->userHandler()->loadRoleAssignment($roleAssignmentId);

        $cacheItem->set($roleAssignment);
        $cacheItem->tag(
            [
                'role-assignment-group-list-'.$roleAssignment->contentId,
                'role-assignment-role-list-'.$roleAssignment->roleId,
                'role-assignment-'.$roleAssignmentId
            ]
        );
        $this->cache->save($cacheItem);

        return $roleAssignment;
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::loadRoleAssignmentsByRoleId
     */
    public function loadRoleAssignmentsByRoleId($roleId)
    {
        $cacheItem = $this->cache->getItem("ez-role-assignment-by-role-${roleId}");
        if ($cacheItem->isHit()) {
            return $cacheItem->get();
        }

        $this->logger->logCall(__METHOD__, array('role' => $roleId));
        $roleAssignments = $this->persistenceHandler->userHandler()->loadRoleAssignmentsByRoleId($roleId);

        $cacheItem->set($roleAssignments);
        $cacheTags = [];
        foreach($roleAssignments as $roleAssignment) {
            $cacheTags[] = 'role-assignment-'.$roleAssignment->id;
            $cacheTags[] = 'role-assignment-group-list-'.$roleAssignment->contentId;
            $cacheTags[] = 'role-assignment-role-list-'.$roleAssignment->roleId;
        }
        $cacheItem->tag($cacheTags);
        $this->cache->save($cacheItem);

        return $roleAssignments;
    }

    /**
     * @see eZ\Publish\SPI\Persistence\User\Handler::loadRoleAssignmentsByGroupId
     */
    public function loadRoleAssignmentsByGroupId($groupId, $inherit = false)
    {
        if ($inherit) {
            $cacheItem = $this->cache->getItem("ez-role-assignment-by-role-${groupId}-inherited");
        } else {
            $cacheItem = $this->cache->getItem("ez-role-assignment-by-role-${groupId}");
        }

        if ($cacheItem->isHit()) {
            return $cacheItem->get();
        }

        $this->logger->logCall(__METHOD__, array('group' => $groupId, 'inherit' => $inherit));
        $roleAssignments = $this->persistenceHandler->userHandler()->loadRoleAssignmentsByGroupId($groupId, $inherit);

        $cacheItem->set($roleAssignments);
        $cacheTags = [];
        foreach($roleAssignments as $roleAssignment) {
            $cacheTags[] = 'role-assignment-'.$roleAssignment->contentId;
            $cacheTags[] = 'role-assignment-group-list-'.$roleAssignment->contentId;
            $cacheTags[] = 'role-assignment-role-list-'.$roleAssignment->roleId;
        }
        $cacheItem->tag($cacheTags);
        $this->cache->save($cacheItem);

        return $roleAssignments;
    }

    /**
     * @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->invalidateTags(['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->invalidateTags(['role-'.$roleId]);
        }

        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);

        // If there was a original role for the draft, then we clean cache for it
        if ($roleDraft->originalId > -1) {
            $this->cache->invalidateTags(['role-'.$roleDraft->originalId]);
        }

        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->invalidateTags(['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->invalidateTags(['policy-'.$policy->id, '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->invalidateTags(['policy-'.$policyId]);
    }

    /**
     * @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->deleteItem("ez-role-assignment-by-role-${roleId}");
        $this->cache->invalidateTags(['role-assignment-group-list-'.$contentId]);

        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->deleteItem("ez-role-assignment-by-role-${roleId}");
        $this->cache->invalidateTags(['role-assignment-group-list-'.$contentId]);

        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);

        $this->cache->invalidateTags(['role-assignment-'.$roleAssignmentId]);

        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->invalidateTags(['content-fields-'.$user->id]);
34
35		return $return;
36		}
37
38		/**
39		* @see eZ\Publish\SPI\Persistence\User\Handler::load
40		*/
41	View Code Duplication	public function load($userId)
42		{
43		$cacheItem = $this->cache->getItem("ez-user-${userId}");
44		if ($cacheItem->isHit()) {
45		return $cacheItem->get();
46		}
47
48		$this->logger->logCall(__METHOD__, array('user' => $userId));
49		$user = $this->persistenceHandler->userHandler()->load($userId);
50
51		$cacheItem->set($user);
52		$cacheItem->tag(['content-'.$user->id, 'user-'.$user->id]);
53		$this->cache->save($cacheItem);
54
55		return $user;
56		}
57
58		/**
59		* @see eZ\Publish\SPI\Persistence\User\Handler::loadByLogin
60		*/
61	View Code Duplication	public function loadByLogin($login)
62		{
63		$cacheItem = $this->cache->getItem("ez-user-login-${login}");
64		if ($cacheItem->isHit()) {
65		return $cacheItem->get();
66		}
67
68		$this->logger->logCall(__METHOD__, array('user' => $login));
69		$user = $this->persistenceHandler->userHandler()->loadByLogin($login);
70
71		$cacheItem->set($user);
72		$cacheItem->tag(['content-'.$user->id, 'user-'.$user->id]);
73		$this->cache->save($cacheItem);
74
75		return $user;
76		}
77
78		/**
79		* @see eZ\Publish\SPI\Persistence\User\Handler::loadByEmail
80		*/
81	View Code Duplication	public function loadByEmail($email)
82		{
83		$cacheItem = $this->cache->getItem("ez-user-email-${email}");
84		if ($cacheItem->isHit()) {
85		return $cacheItem->get();
86		}
87
88		$this->logger->logCall(__METHOD__, array('email' => $email));
89		$users = $this->persistenceHandler->userHandler()->loadByEmail($email);
90
91		$cacheItem->set($users);
92		$cacheTags = [];
93		foreach ($users as $user) {
94		$cacheTags[] = 'content-'.$user->id;
95		$cacheTags[] = 'user-'.$user->id;
96		}
97		$cacheItem->tag($cacheTags);
98		$this->cache->save($cacheItem);
99
100		return $users;
101		}
102
103		/**
104		* @see eZ\Publish\SPI\Persistence\User\Handler::update
105		*/
106	View Code Duplication	public function update(User $user)
107		{
108		$this->logger->logCall(__METHOD__, array('struct' => $user));
109		$return = $this->persistenceHandler->userHandler()->update($user);
110
111		// Clear corresponding content cache as update of the User changes it's external data
112		$this->cache->invalidateTags(['content-fields-'.$user->id, 'user-'.$user->id]);
113
114		return $return;
115		}
116
117		/**
118		* @see eZ\Publish\SPI\Persistence\User\Handler::delete
119		*/
120		public function delete($userId)
121		{
122		$this->logger->logCall(__METHOD__, array('user' => $userId));
123		$return = $this->persistenceHandler->userHandler()->delete($userId);
124
125		// user id == content id == group id
126		$this->cache->invalidateTags(['content-fields-'.$userId, 'user-'.$userId]);
127
128		return $return;
129		}
130
131		/**
132		* @see eZ\Publish\SPI\Persistence\User\Handler::createRole
133		*/
134		public function createRole(RoleCreateStruct $createStruct)
135		{
136		$this->logger->logCall(__METHOD__, array('struct' => $createStruct));
137
138		return $this->persistenceHandler->userHandler()->createRole($createStruct);
139		}
140
141		/**
142		* @see eZ\Publish\SPI\Persistence\User\Handler::createRoleDraft
143		*/
144		public function createRoleDraft($roleId)
145		{
146		$this->logger->logCall(__METHOD__, array('role' => $roleId));
147
148		return $this->persistenceHandler->userHandler()->createRoleDraft($roleId);
149		}
150
151		/**
152		* @see eZ\Publish\SPI\Persistence\User\Handler::loadRole
153		*/
154	View Code Duplication	public function loadRole($roleId, $status = Role::STATUS_DEFINED)
155		{
156		if ($status !== Role::STATUS_DEFINED) {
157		$this->logger->logCall(__METHOD__, array('role' => $roleId));
158
159		return $this->persistenceHandler->userHandler()->loadRole($roleId);
160		}
161
162		$cacheItem = $this->cache->getItem("ez-role-${roleId}");
163		if ($cacheItem->isHit()) {
164		return $cacheItem->get();
165		}
166
167		$this->logger->logCall(__METHOD__, array('role' => $roleId));
168		$role = $this->persistenceHandler->userHandler()->loadRole($roleId);
169
170		$cacheItem->set($role);
171		$cacheItem->tag(['role-'.$role->id]);
172		$this->cache->save($cacheItem);
173
174		return $role;
175		}
176
177		/**
178		* @see eZ\Publish\SPI\Persistence\User\Handler::loadRoleByIdentifier
179		*/
180	View Code Duplication	public function loadRoleByIdentifier($identifier, $status = Role::STATUS_DEFINED)
181		{
182		if ($status !== Role::STATUS_DEFINED) {
183		$this->logger->logCall(__METHOD__, array('role' => $identifier));
184
185		return $this->persistenceHandler->userHandler()->loadRoleByIdentifier($identifier, $status);
186		}
187
188		$cacheItem = $this->cache->getItem("ez-role-identifier-${identifier}");
189		if ($cacheItem->isHit()) {
190		return $cacheItem->get();
191		}
192
193		$this->logger->logCall(__METHOD__, array('role' => $identifier));
194		$role = $this->persistenceHandler->userHandler()->loadRoleByIdentifier($identifier, $status);
195
196		$cacheItem->set($role);
197		$cacheItem->tag(['role-'.$role->id]);
198		$this->cache->save($cacheItem);
199
200		return $role;
201		}
202
203		/**
204		* @see eZ\Publish\SPI\Persistence\User\Handler::loadRoleDraftByRoleId
205		*/
206		public function loadRoleDraftByRoleId($roleId)
207		{
208		$this->logger->logCall(__METHOD__, array('role' => $roleId));
209
210		return $this->persistenceHandler->userHandler()->loadRoleDraftByRoleId($roleId);
211		}
212
213		/**
214		* @see eZ\Publish\SPI\Persistence\User\Handler::loadRoles
215		*/
216		public function loadRoles()
217		{
218		$this->logger->logCall(__METHOD__);
219
220		return $this->persistenceHandler->userHandler()->loadRoles();
221		}
222
223		/**
224		* @see eZ\Publish\SPI\Persistence\User\Handler::loadRoleAssignment
225		*/
226	View Code Duplication	public function loadRoleAssignment($roleAssignmentId)
227		{
228		$cacheItem = $this->cache->getItem("ez-role-assignment-${roleAssignmentId}");
229		if ($cacheItem->isHit()) {
230		return $cacheItem->get();
231		}
232
233		$this->logger->logCall(__METHOD__, array('assignment' => $roleAssignmentId));
234		$roleAssignment = $this->persistenceHandler->userHandler()->loadRoleAssignment($roleAssignmentId);
235
236		$cacheItem->set($roleAssignment);
237		$cacheItem->tag(
238		[
239		'role-assignment-group-list-'.$roleAssignment->contentId,
240		'role-assignment-role-list-'.$roleAssignment->roleId,
241		'role-assignment-'.$roleAssignmentId
242		]
243		);
244		$this->cache->save($cacheItem);
245
246		return $roleAssignment;
247		}
248
249		/**
250		* @see eZ\Publish\SPI\Persistence\User\Handler::loadRoleAssignmentsByRoleId
251		*/
252	View Code Duplication	public function loadRoleAssignmentsByRoleId($roleId)
253		{
254		$cacheItem = $this->cache->getItem("ez-role-assignment-by-role-${roleId}");
255		if ($cacheItem->isHit()) {
256		return $cacheItem->get();
257		}
258
259		$this->logger->logCall(__METHOD__, array('role' => $roleId));
260		$roleAssignments = $this->persistenceHandler->userHandler()->loadRoleAssignmentsByRoleId($roleId);
261
262		$cacheItem->set($roleAssignments);
263		$cacheTags = [];
264		foreach($roleAssignments as $roleAssignment) {
265		$cacheTags[] = 'role-assignment-'.$roleAssignment->id;
266		$cacheTags[] = 'role-assignment-group-list-'.$roleAssignment->contentId;
267		$cacheTags[] = 'role-assignment-role-list-'.$roleAssignment->roleId;
268		}
269		$cacheItem->tag($cacheTags);
270		$this->cache->save($cacheItem);
271
272		return $roleAssignments;
273		}
274
275		/**
276		* @see eZ\Publish\SPI\Persistence\User\Handler::loadRoleAssignmentsByGroupId
277		*/
278		public function loadRoleAssignmentsByGroupId($groupId, $inherit = false)
279		{
280		if ($inherit) {
281		$cacheItem = $this->cache->getItem("ez-role-assignment-by-role-${groupId}-inherited");
282		} else {
283		$cacheItem = $this->cache->getItem("ez-role-assignment-by-role-${groupId}");
284		}
285
286		if ($cacheItem->isHit()) {
287		return $cacheItem->get();
288		}
289
290		$this->logger->logCall(__METHOD__, array('group' => $groupId, 'inherit' => $inherit));
291		$roleAssignments = $this->persistenceHandler->userHandler()->loadRoleAssignmentsByGroupId($groupId, $inherit);
292
293		$cacheItem->set($roleAssignments);
294		$cacheTags = [];
295		foreach($roleAssignments as $roleAssignment) {
296		$cacheTags[] = 'role-assignment-'.$roleAssignment->contentId;
297		$cacheTags[] = 'role-assignment-group-list-'.$roleAssignment->contentId;
298		$cacheTags[] = 'role-assignment-role-list-'.$roleAssignment->roleId;
299		}
300		$cacheItem->tag($cacheTags);
301		$this->cache->save($cacheItem);
302
303		return $roleAssignments;
304		}
305
306		/**
307		* @see eZ\Publish\SPI\Persistence\User\Handler::updateRole
308		*/
309	View Code Duplication	public function updateRole(RoleUpdateStruct $struct)
310		{
311		$this->logger->logCall(__METHOD__, array('struct' => $struct));
312		$this->persistenceHandler->userHandler()->updateRole($struct);
313
314		$this->cache->invalidateTags(['role-'.$struct->id]);
315		}
316
317		/**
318		* @see eZ\Publish\SPI\Persistence\User\Handler::deleteRole
319		*/
320		public function deleteRole($roleId, $status = Role::STATUS_DEFINED)
321		{
322		$this->logger->logCall(__METHOD__, array('role' => $roleId));
323		$return = $this->persistenceHandler->userHandler()->deleteRole($roleId, $status);
324
325		if ($status === Role::STATUS_DEFINED) {
326		$this->cache->invalidateTags(['role-'.$roleId]);
327		}
328
329		return $return;
330		}
331
332		/**
333		* @see eZ\Publish\SPI\Persistence\User\Handler::publishRoleDraft
334		*/
335		public function publishRoleDraft($roleDraftId)
336		{
337		$this->logger->logCall(__METHOD__, array('role' => $roleDraftId));
338		$userHandler = $this->persistenceHandler->userHandler();
339		$roleDraft = $userHandler->loadRole($roleDraftId, Role::STATUS_DRAFT);
340		$return = $userHandler->publishRoleDraft($roleDraftId);
341
342		// If there was a original role for the draft, then we clean cache for it
343		if ($roleDraft->originalId > -1) {
344		$this->cache->invalidateTags(['role-'.$roleDraft->originalId]);
345		}
346
347		return $return;
348		}
349
350		/**
351		* @see eZ\Publish\SPI\Persistence\User\Handler::addPolicyByRoleDraft
352		*/
353		public function addPolicyByRoleDraft($roleId, Policy $policy)
354		{
355		$this->logger->logCall(__METHOD__, array('role' => $roleId, 'struct' => $policy));
356
357		return $this->persistenceHandler->userHandler()->addPolicyByRoleDraft($roleId, $policy);
358		}
359
360		/**
361		* @see eZ\Publish\SPI\Persistence\User\Handler::addPolicy
362		*/
363		public function addPolicy($roleId, Policy $policy)
364		{
365		$this->logger->logCall(__METHOD__, array('role' => $roleId, 'struct' => $policy));
366		$return = $this->persistenceHandler->userHandler()->addPolicy($roleId, $policy);
367
368		$this->cache->invalidateTags(['role-'.$roleId]);
369
370		return $return;
371		}
372
373		/**
374		* @see eZ\Publish\SPI\Persistence\User\Handler::updatePolicy
375		*/
376	View Code Duplication	public function updatePolicy(Policy $policy)
377		{
378		$this->logger->logCall(__METHOD__, array('struct' => $policy));
379		$return = $this->persistenceHandler->userHandler()->updatePolicy($policy);
380
381		$this->cache->invalidateTags(['policy-'.$policy->id, 'role-'.$policy->roleId]);
382
383		return $return;
384		}
385
386		/**
387		* @see eZ\Publish\SPI\Persistence\User\Handler::deletePolicy
388		*/
389	View Code Duplication	public function deletePolicy($policyId)
390		{
391		$this->logger->logCall(__METHOD__, array('policy' => $policyId));
392		$this->persistenceHandler->userHandler()->deletePolicy($policyId);
393
394		$this->cache->invalidateTags(['policy-'.$policyId]);
395		}
396
397		/**
398		* @see eZ\Publish\SPI\Persistence\User\Handler::loadPoliciesByUserId
399		*/
400		public function loadPoliciesByUserId($userId)
401		{
402		$this->logger->logCall(__METHOD__, array('user' => $userId));
403
404		return $this->persistenceHandler->userHandler()->loadPoliciesByUserId($userId);
405		}
406
407		/**
408		* @see eZ\Publish\SPI\Persistence\User\Handler::assignRole
409		*/
410	View Code Duplication	public function assignRole($contentId, $roleId, array $limitation = null)
411		{
412		$this->logger->logCall(__METHOD__, array('group' => $contentId, 'role' => $roleId, 'limitation' => $limitation));
413		$return = $this->persistenceHandler->userHandler()->assignRole($contentId, $roleId, $limitation);
414
415		$this->cache->deleteItem("ez-role-assignment-by-role-${roleId}");
416		$this->cache->invalidateTags(['role-assignment-group-list-'.$contentId]);
417
418		return $return;
419		}
420
421		/**
422		* @see eZ\Publish\SPI\Persistence\User\Handler::unassignRole
423		*/
424		public function unassignRole($contentId, $roleId)
425		{
426		$this->logger->logCall(__METHOD__, array('group' => $contentId, 'role' => $roleId));
427		$return = $this->persistenceHandler->userHandler()->unassignRole($contentId, $roleId);
428
429		$this->cache->deleteItem("ez-role-assignment-by-role-${roleId}");
430		$this->cache->invalidateTags(['role-assignment-group-list-'.$contentId]);
431
432		return $return;
433		}
434
435		/**
436		* @see eZ\Publish\SPI\Persistence\User\Handler::removeRoleAssignment
437		*/
438	View Code Duplication	public function removeRoleAssignment($roleAssignmentId)
439		{
440		$this->logger->logCall(__METHOD__, array('assignment' => $roleAssignmentId));
441		$return = $this->persistenceHandler->userHandler()->removeRoleAssignment($roleAssignmentId);
442
443		$this->cache->invalidateTags(['role-assignment-'.$roleAssignmentId]);
444
445		return $return;
446		}
447		}
448

ezsystems / ezpublish-kernel

Push — sf_cache ( 94d0e5...42a66b )

UserHandler::deletePolicy() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like