RoleDomainMapper::buildPersistenceRoleCopyStruct() - Code Metrics - Inspection of "EZP-31383: Initial role copy service commit" - ezsystems/ezpublish-kernel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — EZP-31383 ( 83ce0c )

unknown

created 2020-02-13 14:17 UTC

RoleDomainMapper::buildPersistenceRoleCopyStruct() A

↳ Parent: RoleDomainMapper

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	19
Ratio	100 %

Importance

Changes

Metric	Value
dl	19
loc	19
c	0
b	0
f	0
cc	2
nc	2
nop	2
rs	9.6333

<?php

/**
 * File containing the RoleDomainMapper class.
 *
 * @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\Repository\Helper;

use eZ\Publish\Core\Repository\Values\User\Policy;
use eZ\Publish\Core\Repository\Values\User\PolicyDraft;
use eZ\Publish\Core\Repository\Values\User\Role;
use eZ\Publish\API\Repository\Values\User\Role as APIRole;
use eZ\Publish\Core\Repository\Values\User\RoleDraft;
use eZ\Publish\API\Repository\Values\User\RoleCreateStruct as APIRoleCreateStruct;
use eZ\Publish\API\Repository\Values\User\RoleCopyStruct as APIRoleCopyStruct;
use eZ\Publish\Core\Repository\Values\User\UserRoleAssignment;
use eZ\Publish\Core\Repository\Values\User\UserGroupRoleAssignment;
use eZ\Publish\API\Repository\Values\User\User;
use eZ\Publish\API\Repository\Values\User\UserGroup;
use eZ\Publish\SPI\Persistence\User\Policy as SPIPolicy;
use eZ\Publish\SPI\Persistence\User\RoleAssignment as SPIRoleAssignment;
use eZ\Publish\SPI\Persistence\User\Role as SPIRole;
use eZ\Publish\SPI\Persistence\User\RoleCreateStruct as SPIRoleCreateStruct;
use eZ\Publish\SPI\Persistence\User\RoleCopyStruct as SPIRoleCopyStruct;

/**
 * Internal service to map Role objects between API and SPI values.
 *
 * @internal Meant for internal use by Repository.
 */
class RoleDomainMapper
{
    /** @var \eZ\Publish\Core\Repository\Helper\LimitationService */
    protected $limitationService;

    /**
     * @param \eZ\Publish\Core\Repository\Helper\LimitationService $limitationService
     */
    public function __construct(LimitationService $limitationService)
    {
        $this->limitationService = $limitationService;
    }

    /**
     * Maps provided SPI Role value object to API Role value object.
     *
     * @param \eZ\Publish\SPI\Persistence\User\Role $role
     *
     * @return \eZ\Publish\API\Repository\Values\User\Role
     */
    public function buildDomainRoleObject(SPIRole $role)
    {
        $rolePolicies = [];
        foreach ($role->policies as $spiPolicy) {
            $rolePolicies[] = $this->buildDomainPolicyObject($spiPolicy);
        }

        return new Role(
            [
                'id' => $role->id,
                'identifier' => $role->identifier,
                'status' => $role->status,
                'policies' => $rolePolicies,
            ]
        );
    }

    /**
     * Builds a RoleDraft domain object from value object returned by persistence
     * Decorates Role.
     *
     * @param \eZ\Publish\SPI\Persistence\User\Role $spiRole
     *
     * @return \eZ\Publish\API\Repository\Values\User\RoleDraft
     */
    public function buildDomainRoleDraftObject(SPIRole $spiRole)
    {
        return new RoleDraft(
            [
                'innerRole' => $this->buildDomainRoleObject($spiRole),
            ]
        );
    }

    /**
     * Maps provided SPI Policy value object to API Policy value object.
     *
     * @param \eZ\Publish\SPI\Persistence\User\Policy $spiPolicy
     *
     * @return \eZ\Publish\API\Repository\Values\User\Policy|\eZ\Publish\API\Repository\Values\User\PolicyDraft
     */
    public function buildDomainPolicyObject(SPIPolicy $spiPolicy)
    {
        $policyLimitations = [];
        if ($spiPolicy->module !== '*' && $spiPolicy->function !== '*' && $spiPolicy->limitations !== '*') {
            foreach ($spiPolicy->limitations as $identifier => $values) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
                $policyLimitations[] = $this->limitationService->getLimitationType($identifier)->buildValue($values);
            }
        }

        $policy = new Policy(
            [
                'id' => $spiPolicy->id,
                'roleId' => $spiPolicy->roleId,
                'module' => $spiPolicy->module,
                'function' => $spiPolicy->function,
                'limitations' => $policyLimitations,
            ]
        );

        // Original ID is set on SPI policy, which means that it's a draft.
        if ($spiPolicy->originalId) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            $policy = new PolicyDraft(['innerPolicy' => $policy, 'originalId' => $spiPolicy->originalId]);
        }

        return $policy;
    }

    /**
     * Builds the API UserRoleAssignment object from provided SPI RoleAssignment object.
     *
     * @param \eZ\Publish\SPI\Persistence\User\RoleAssignment $spiRoleAssignment
     * @param \eZ\Publish\API\Repository\Values\User\User $user
     * @param \eZ\Publish\API\Repository\Values\User\Role $role
     *
     * @return \eZ\Publish\API\Repository\Values\User\UserRoleAssignment
     */
    public function buildDomainUserRoleAssignmentObject(SPIRoleAssignment $spiRoleAssignment, User $user, APIRole $role)
    {
        $limitation = null;
        if (!empty($spiRoleAssignment->limitationIdentifier)) {
            $limitation = $this
                ->limitationService
                ->getLimitationType($spiRoleAssignment->limitationIdentifier)
                ->buildValue($spiRoleAssignment->values);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        }

        return new UserRoleAssignment(
            [
                'id' => $spiRoleAssignment->id,
                'limitation' => $limitation,
                'role' => $role,
                'user' => $user,
            ]
        );
    }

    /**
     * Builds the API UserGroupRoleAssignment object from provided SPI RoleAssignment object.
     *
     * @param \eZ\Publish\SPI\Persistence\User\RoleAssignment $spiRoleAssignment
     * @param \eZ\Publish\API\Repository\Values\User\UserGroup $userGroup
     * @param \eZ\Publish\API\Repository\Values\User\Role $role
     *
     * @return \eZ\Publish\API\Repository\Values\User\UserGroupRoleAssignment
     */
    public function buildDomainUserGroupRoleAssignmentObject(SPIRoleAssignment $spiRoleAssignment, UserGroup $userGroup, APIRole $role)
    {
        $limitation = null;
        if (!empty($spiRoleAssignment->limitationIdentifier)) {
            $limitation = $this
                ->limitationService
                ->getLimitationType($spiRoleAssignment->limitationIdentifier)
                ->buildValue($spiRoleAssignment->values);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        }

        return new UserGroupRoleAssignment(
            [
                'id' => $spiRoleAssignment->id,
                'limitation' => $limitation,
                'role' => $role,
                'userGroup' => $userGroup,
            ]
        );
    }

    /**
     * Creates SPI Role create struct from provided API role create struct.
     *
     * @param \eZ\Publish\API\Repository\Values\User\RoleCreateStruct $roleCreateStruct
     *
     * @return \eZ\Publish\SPI\Persistence\User\RoleCreateStruct
     */
    public function buildPersistenceRoleCreateStruct(APIRoleCreateStruct $roleCreateStruct)
    {
        $policiesToCreate = [];
        foreach ($roleCreateStruct->getPolicies() as $policyCreateStruct) {
            $policiesToCreate[] = $this->buildPersistencePolicyObject(
                $policyCreateStruct->module,
                $policyCreateStruct->function,
                $policyCreateStruct->getLimitations()
            );
        }

        return new SPIRoleCreateStruct(
            [
                'identifier' => $roleCreateStruct->identifier,
                'policies' => $policiesToCreate,
            ]
        );
    }

    /**
     * Creates SPI Role copy struct from provided API role copy struct.
     *
     * @param \eZ\Publish\API\Repository\Values\User\RoleCopyStruct $roleCopyStruct
     * @param mixed $clonedRoleId
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     *
     * @return \eZ\Publish\SPI\Persistence\User\RoleCopyStruct
     */
    public function buildPersistenceRoleCopyStruct(APIRoleCopyStruct $roleCopyStruct, $clonedId)
    {
        $policiesToCopy = [];
        foreach ($roleCopyStruct->getPolicies() as $policyCopyStruct) {
            $policiesToCopy[] = $this->buildPersistencePolicyObject(
                $policyCopyStruct->module,
                $policyCopyStruct->function,
                $policyCopyStruct->getLimitations()
            );
        }

        return new SPIRoleCopyStruct(
            [
                'clonedId' => $clonedId,
                'newIdentifier' => $roleCopyStruct->newIdentifier,
                'policies' => $policiesToCopy,
            ]
        );
    }

    /**
     * Creates SPI Policy value object from provided module, function and limitations.
     *
     * @param string $module
     * @param string $function
     * @param \eZ\Publish\API\Repository\Values\User\Limitation[] $limitations
     *
     * @return \eZ\Publish\SPI\Persistence\User\Policy
     */
    public function buildPersistencePolicyObject($module, $function, array $limitations)
    {
        $limitationsToCreate = '*';
        if ($module !== '*' && $function !== '*' && !empty($limitations)) {
            $limitationsToCreate = [];
            foreach ($limitations as $limitation) {
                $limitationsToCreate[$limitation->getIdentifier()] = $limitation->limitationValues;
            }
        }

        return new SPIPolicy(
            [
                'module' => $module,
                'function' => $function,
                'limitations' => $limitationsToCreate,
            ]
        );
    }
}


1		<?php
2
3		/**
4		* File containing the RoleDomainMapper class.
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\Repository\Helper;
10
11		use eZ\Publish\Core\Repository\Values\User\Policy;
12		use eZ\Publish\Core\Repository\Values\User\PolicyDraft;
13		use eZ\Publish\Core\Repository\Values\User\Role;
14		use eZ\Publish\API\Repository\Values\User\Role as APIRole;
15		use eZ\Publish\Core\Repository\Values\User\RoleDraft;
16		use eZ\Publish\API\Repository\Values\User\RoleCreateStruct as APIRoleCreateStruct;
17		use eZ\Publish\API\Repository\Values\User\RoleCopyStruct as APIRoleCopyStruct;
18		use eZ\Publish\Core\Repository\Values\User\UserRoleAssignment;
19		use eZ\Publish\Core\Repository\Values\User\UserGroupRoleAssignment;
20		use eZ\Publish\API\Repository\Values\User\User;
21		use eZ\Publish\API\Repository\Values\User\UserGroup;
22		use eZ\Publish\SPI\Persistence\User\Policy as SPIPolicy;
23		use eZ\Publish\SPI\Persistence\User\RoleAssignment as SPIRoleAssignment;
24		use eZ\Publish\SPI\Persistence\User\Role as SPIRole;
25		use eZ\Publish\SPI\Persistence\User\RoleCreateStruct as SPIRoleCreateStruct;
26		use eZ\Publish\SPI\Persistence\User\RoleCopyStruct as SPIRoleCopyStruct;
27
28		/**
29		* Internal service to map Role objects between API and SPI values.
30		*
31		* @internal Meant for internal use by Repository.
32		*/
33		class RoleDomainMapper
34		{
35		/** @var \eZ\Publish\Core\Repository\Helper\LimitationService */
36		protected $limitationService;
37
38		/**
39		* @param \eZ\Publish\Core\Repository\Helper\LimitationService $limitationService
40		*/
41		public function __construct(LimitationService $limitationService)
42		{
43		$this->limitationService = $limitationService;
44		}
45
46		/**
47		* Maps provided SPI Role value object to API Role value object.
48		*
49		* @param \eZ\Publish\SPI\Persistence\User\Role $role
50		*
51		* @return \eZ\Publish\API\Repository\Values\User\Role
52		*/
53		public function buildDomainRoleObject(SPIRole $role)
54		{
55		$rolePolicies = [];
56		foreach ($role->policies as $spiPolicy) {
57		$rolePolicies[] = $this->buildDomainPolicyObject($spiPolicy);
58		}
59
60		return new Role(
61		[
62		'id' => $role->id,
63		'identifier' => $role->identifier,
64		'status' => $role->status,
65		'policies' => $rolePolicies,
66		]
67		);
68		}
69
70		/**
71		* Builds a RoleDraft domain object from value object returned by persistence
72		* Decorates Role.
73		*
74		* @param \eZ\Publish\SPI\Persistence\User\Role $spiRole
75		*
76		* @return \eZ\Publish\API\Repository\Values\User\RoleDraft
77		*/
78		public function buildDomainRoleDraftObject(SPIRole $spiRole)
79		{
80		return new RoleDraft(
81		[
82		'innerRole' => $this->buildDomainRoleObject($spiRole),
83		]
84		);
85		}
86
87		/**
88		* Maps provided SPI Policy value object to API Policy value object.
89		*
90		* @param \eZ\Publish\SPI\Persistence\User\Policy $spiPolicy
91		*
92		* @return \eZ\Publish\API\Repository\Values\User\Policy\|\eZ\Publish\API\Repository\Values\User\PolicyDraft
93		*/
94		public function buildDomainPolicyObject(SPIPolicy $spiPolicy)
95		{
96		$policyLimitations = [];
97		if ($spiPolicy->module !== '' && $spiPolicy->function !== '' && $spiPolicy->limitations !== '*') {
98		foreach ($spiPolicy->limitations as $identifier => $values) {
		0 ignored issues – show Bug introduced 2015-11-21 14:37 UTC by Report Bug Copy Issue Report The expression `$spiPolicy->limitations` of type `array\|string` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
99		$policyLimitations[] = $this->limitationService->getLimitationType($identifier)->buildValue($values);
100		}
101		}
102
103		$policy = new Policy(
104		[
105		'id' => $spiPolicy->id,
106		'roleId' => $spiPolicy->roleId,
107		'module' => $spiPolicy->module,
108		'function' => $spiPolicy->function,
109		'limitations' => $policyLimitations,
110		]
111		);
112
113		// Original ID is set on SPI policy, which means that it's a draft.
114		if ($spiPolicy->originalId) {
		0 ignored issues – show Bug Best Practice introduced 2015-11-21 14:37 UTC by Report Bug Copy Issue Report The expression `$spiPolicy->originalId` of type `integer\|null` is loosely compared to `true`; this is ambiguous if the integer can be zero. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `integer` values, zero is a special case, in particular the following results might be unexpected: 0 == false // true 0 == null // true 123 == false // false 123 == null // false // It is often better to use strict comparison 0 === false // false 0 === null // false Loading history...
115		$policy = new PolicyDraft(['innerPolicy' => $policy, 'originalId' => $spiPolicy->originalId]);
116		}
117
118		return $policy;
119		}
120
121		/**
122		* Builds the API UserRoleAssignment object from provided SPI RoleAssignment object.
123		*
124		* @param \eZ\Publish\SPI\Persistence\User\RoleAssignment $spiRoleAssignment
125		* @param \eZ\Publish\API\Repository\Values\User\User $user
126		* @param \eZ\Publish\API\Repository\Values\User\Role $role
127		*
128		* @return \eZ\Publish\API\Repository\Values\User\UserRoleAssignment
129		*/
130	View Code Duplication	public function buildDomainUserRoleAssignmentObject(SPIRoleAssignment $spiRoleAssignment, User $user, APIRole $role)
131		{
132		$limitation = null;
133		if (!empty($spiRoleAssignment->limitationIdentifier)) {
134		$limitation = $this
135		->limitationService
136		->getLimitationType($spiRoleAssignment->limitationIdentifier)
137		->buildValue($spiRoleAssignment->values);
		0 ignored issues – show Bug introduced 2015-11-21 14:37 UTC by Report Bug Copy Issue Report It seems like `$spiRoleAssignment->values` can also be of type `null`; however, `eZ\Publish\SPI\Limitation\Type::buildValue()` does only seem to accept `array<integer,>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /* * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
138		}
139
140		return new UserRoleAssignment(
141		[
142		'id' => $spiRoleAssignment->id,
143		'limitation' => $limitation,
144		'role' => $role,
145		'user' => $user,
146		]
147		);
148		}
149
150		/**
151		* Builds the API UserGroupRoleAssignment object from provided SPI RoleAssignment object.
152		*
153		* @param \eZ\Publish\SPI\Persistence\User\RoleAssignment $spiRoleAssignment
154		* @param \eZ\Publish\API\Repository\Values\User\UserGroup $userGroup
155		* @param \eZ\Publish\API\Repository\Values\User\Role $role
156		*
157		* @return \eZ\Publish\API\Repository\Values\User\UserGroupRoleAssignment
158		*/
159	View Code Duplication	public function buildDomainUserGroupRoleAssignmentObject(SPIRoleAssignment $spiRoleAssignment, UserGroup $userGroup, APIRole $role)
160		{
161		$limitation = null;
162		if (!empty($spiRoleAssignment->limitationIdentifier)) {
163		$limitation = $this
164		->limitationService
165		->getLimitationType($spiRoleAssignment->limitationIdentifier)
166		->buildValue($spiRoleAssignment->values);
		0 ignored issues – show Bug introduced 2015-11-21 14:37 UTC by Report Bug Copy Issue Report It seems like `$spiRoleAssignment->values` can also be of type `null`; however, `eZ\Publish\SPI\Limitation\Type::buildValue()` does only seem to accept `array<integer,>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /* * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
167		}
168
169		return new UserGroupRoleAssignment(
170		[
171		'id' => $spiRoleAssignment->id,
172		'limitation' => $limitation,
173		'role' => $role,
174		'userGroup' => $userGroup,
175		]
176		);
177		}
178
179		/**
180		* Creates SPI Role create struct from provided API role create struct.
181		*
182		* @param \eZ\Publish\API\Repository\Values\User\RoleCreateStruct $roleCreateStruct
183		*
184		* @return \eZ\Publish\SPI\Persistence\User\RoleCreateStruct
185		*/
186	View Code Duplication	public function buildPersistenceRoleCreateStruct(APIRoleCreateStruct $roleCreateStruct)
187		{
188		$policiesToCreate = [];
189		foreach ($roleCreateStruct->getPolicies() as $policyCreateStruct) {
190		$policiesToCreate[] = $this->buildPersistencePolicyObject(
191		$policyCreateStruct->module,
192		$policyCreateStruct->function,
193		$policyCreateStruct->getLimitations()
194		);
195		}
196
197		return new SPIRoleCreateStruct(
198		[
199		'identifier' => $roleCreateStruct->identifier,
200		'policies' => $policiesToCreate,
201		]
202		);
203		}
204
205		/**
206		* Creates SPI Role copy struct from provided API role copy struct.
207		*
208		* @param \eZ\Publish\API\Repository\Values\User\RoleCopyStruct $roleCopyStruct
209		* @param mixed $clonedRoleId
		0 ignored issues – show Bug introduced 2020-02-13 14:36 UTC by Report Bug Copy Issue Report There is no parameter named `$clonedRoleId`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
210		*
211		* @return \eZ\Publish\SPI\Persistence\User\RoleCopyStruct
212		*/
213	View Code Duplication	public function buildPersistenceRoleCopyStruct(APIRoleCopyStruct $roleCopyStruct, $clonedId)
214		{
215		$policiesToCopy = [];
216		foreach ($roleCopyStruct->getPolicies() as $policyCopyStruct) {
217		$policiesToCopy[] = $this->buildPersistencePolicyObject(
218		$policyCopyStruct->module,
219		$policyCopyStruct->function,
220		$policyCopyStruct->getLimitations()
221		);
222		}
223
224		return new SPIRoleCopyStruct(
225		[
226		'clonedId' => $clonedId,
227		'newIdentifier' => $roleCopyStruct->newIdentifier,
228		'policies' => $policiesToCopy,
229		]
230		);
231		}
232
233		/**
234		* Creates SPI Policy value object from provided module, function and limitations.
235		*
236		* @param string $module
237		* @param string $function
238		* @param \eZ\Publish\API\Repository\Values\User\Limitation[] $limitations
239		*
240		* @return \eZ\Publish\SPI\Persistence\User\Policy
241		*/
242		public function buildPersistencePolicyObject($module, $function, array $limitations)
243		{
244		$limitationsToCreate = '*';
245		if ($module !== '' && $function !== '' && !empty($limitations)) {
246		$limitationsToCreate = [];
247		foreach ($limitations as $limitation) {
248		$limitationsToCreate[$limitation->getIdentifier()] = $limitation->limitationValues;
249		}
250		}
251
252		return new SPIPolicy(
253		[
254		'module' => $module,
255		'function' => $function,
256		'limitations' => $limitationsToCreate,
257		]
258		);
259		}
260		}
261

ezsystems / ezpublish-kernel

Push — EZP-31383 ( 83ce0c )

RoleDomainMapper::buildPersistenceRoleCopyStruct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like