Mapper::createRoleFromCopyStruct() - 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

Mapper::createRoleFromCopyStruct() A

↳ Parent: Mapper

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	10
Ratio	100 %

Importance

Changes

Metric	Value
dl	10
loc	10
c	0
b	0
f	0
cc	1
nc	1
nop	1
rs	9.9332

<?php

/**
 * File containing the User mapper.
 *
 * @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\Legacy\User;

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\Policy;
use eZ\Publish\SPI\Persistence\User\RoleAssignment;

/**
 * mapper for User related objects.
 */
class Mapper
{
    /**
     * Map user data into user object.
     *
     * @param array $data
     *
     * @return \eZ\Publish\SPI\Persistence\User
     */
    public function mapUser(array $data)
    {
        $user = new User();
        $user->id = $data['contentobject_id'];
        $user->login = $data['login'];
        $user->email = $data['email'];
        $user->passwordHash = $data['password_hash'];
        $user->hashAlgorithm = (int)$data['password_hash_type'];
        $user->passwordUpdatedAt = $data['password_updated_at'] !== null ? (int)$data['password_updated_at'] : null;
        $user->isEnabled = (bool)$data['is_enabled'];
        $user->maxLogin = $data['max_login'];

        return $user;
    }

    /**
     * Map data for a set of user data.
     *
     * @param array $data
     *
     * @return \eZ\Publish\SPI\Persistence\User[]
     */
    public function mapUsers(array $data)
    {
        $users = [];
        foreach ($data as $row) {
            $users[] = $this->mapUser($row);
        }

        return $users;
    }

    /**
     * Map policy data to an array of policies.
     *
     * @param array $data
     *
     * @return \eZ\Publish\SPI\Persistence\User\Policy
     */
    public function mapPolicies(array $data)
    {
        /** @var \eZ\Publish\SPI\Persistence\User\Policy[] */
        $policies = [];
        foreach ($data as $row) {
            $policyId = $row['ezpolicy_id'];
            if (!isset($policies[$policyId]) && ($policyId !== null)) {
                $originalId = null;
                if ($row['ezpolicy_original_id']) {
                    $originalId = (int)$row['ezpolicy_original_id'];
                } elseif ($row['ezrole_version']) {
                    $originalId = (int)$policyId;
                }

                $policies[$policyId] = new Policy(
                    [
                        'id' => (int)$policyId,
                        'roleId' => (int)$row['ezrole_id'],
                        'originalId' => $originalId,
                        'module' => $row['ezpolicy_module_name'],
                        'function' => $row['ezpolicy_function_name'],
                        'limitations' => '*', // limitations must be '*' if not a non empty array of limitations
                    ]
                );
            }

            if (!$row['ezpolicy_limitation_identifier']) {
                continue;
            } elseif ($policies[$policyId]->limitations === '*') {
                $policies[$policyId]->limitations = [];
            }

            if (!isset($policies[$policyId]->limitations[$row['ezpolicy_limitation_identifier']])) {
                $policies[$policyId]->limitations[$row['ezpolicy_limitation_identifier']] = [$row['ezpolicy_limitation_value_value']];
            } elseif (!in_array($row['ezpolicy_limitation_value_value'], $policies[$policyId]->limitations[$row['ezpolicy_limitation_identifier']])) {
                $policies[$policyId]->limitations[$row['ezpolicy_limitation_identifier']][] = $row['ezpolicy_limitation_value_value'];
            }
        }

        return array_values($policies);
    }

    /**
     * Map role data to a role.
     *
     * @param array $data
     *
     * @return \eZ\Publish\SPI\Persistence\User\Role
     */
    public function mapRole(array $data)
    {
        $role = new Role();

        foreach ($data as $row) {
            if (empty($role->id)) {
                $role->id = (int)$row['ezrole_id'];
                $role->identifier = $row['ezrole_name'];
                $role->status = $row['ezrole_version'] != 0 ? Role::STATUS_DRAFT : Role::STATUS_DEFINED;
                $role->originalId = $row['ezrole_version'] ? (int)$row['ezrole_version'] : Role::STATUS_DEFINED;
                // skip name and description as they don't exist in legacy
            }
        }

        $role->policies = $this->mapPolicies($data);


        return $role;
    }

    /**
     * Map data for a set of roles.
     *
     * @param array $data
     *
     * @return \eZ\Publish\SPI\Persistence\User\Role[]
     */
    public function mapRoles(array $data)
    {
        $roleData = [];
        foreach ($data as $row) {
            $roleData[$row['ezrole_id']][] = $row;
        }

        $roles = [];
        foreach ($roleData as $data) {
            $roles[] = $this->mapRole($data);
        }

        return $roles;
    }

    /**
     * Map data for a set of role assignments.
     *
     * @param array $data
     *
     * @return \eZ\Publish\SPI\Persistence\User\RoleAssignment[]
     */
    public function mapRoleAssignments(array $data)
    {
        $roleAssignmentData = [];
        foreach ($data as $row) {
            $id = (int)$row['id'];
            $roleId = (int)$row['role_id'];
            $contentId = (int)$row['contentobject_id'];
            // if user already have full access to a role, continue
            if (isset($roleAssignmentData[$roleId][$contentId])
                && $roleAssignmentData[$roleId][$contentId] instanceof RoleAssignment) {
                continue;
            }

            $limitIdentifier = $row['limit_identifier'];
            if (!empty($limitIdentifier)) {
                $roleAssignmentData[$roleId][$contentId][$limitIdentifier][$id] = new RoleAssignment(
                    [
                        'id' => $id,
                        'roleId' => $roleId,
                        'contentId' => $contentId,
                        'limitationIdentifier' => $limitIdentifier,
                        'values' => [$row['limit_value']],
                    ]
                );
            } else {
                $roleAssignmentData[$roleId][$contentId] = new RoleAssignment(
                    [
                        'id' => $id,
                        'roleId' => $roleId,
                        'contentId' => $contentId,
                    ]
                );
            }
        }

        $roleAssignments = [];
        array_walk_recursive(
            $roleAssignmentData,
            function ($roleAssignment) use (&$roleAssignments) {
                $roleAssignments[] = $roleAssignment;
            }
        );

        return $roleAssignments;
    }

    /**
     * Creates a create struct from an existing $role.
     *
     * @param \eZ\Publish\SPI\Persistence\User\Role $role
     *
     * @return \eZ\Publish\SPI\Persistence\User\RoleCreateStruct
     */
    public function createCreateStructFromRole(Role $role)
    {
        $createStruct = new RoleCreateStruct();

        $createStruct->identifier = $role->identifier;
        $createStruct->policies = $role->policies;

        return $createStruct;
    }

    /**
     * Maps properties from $struct to $role.
     *
     * @param \eZ\Publish\SPI\Persistence\User\RoleCreateStruct $createStruct
     *
     * @return \eZ\Publish\SPI\Persistence\User\Role
     */
    public function createRoleFromCreateStruct(RoleCreateStruct $createStruct)
    {
        $role = new Role();

        $role->identifier = $createStruct->identifier;
        $role->policies = $createStruct->policies;

        $role->status = Role::STATUS_DRAFT;

        return $role;
    }

    /**
     * Maps properties from $struct to $role.
     *
     * @param \eZ\Publish\SPI\Persistence\User\RoleCopyStruct $copyStruct
     *
     * @return \eZ\Publish\SPI\Persistence\User\Role
     */
    public function createRoleFromCopyStruct(User\RoleCopyStruct $copyStruct)
    {
        $role = new Role();

        $role->identifier = $copyStruct->newIdentifier;
        $role->policies = $copyStruct->policies;

        $role->status = Role::STATUS_DEFINED;

        return $role;
    }
}


1		<?php
2
3		/**
4		* File containing the User mapper.
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\Legacy\User;
10
11		use eZ\Publish\SPI\Persistence\User;
12		use eZ\Publish\SPI\Persistence\User\Role;
13		use eZ\Publish\SPI\Persistence\User\RoleCreateStruct;
14		use eZ\Publish\SPI\Persistence\User\Policy;
15		use eZ\Publish\SPI\Persistence\User\RoleAssignment;
16
17		/**
18		* mapper for User related objects.
19		*/
20		class Mapper
21		{
22		/**
23		* Map user data into user object.
24		*
25		* @param array $data
26		*
27		* @return \eZ\Publish\SPI\Persistence\User
28		*/
29		public function mapUser(array $data)
30		{
31		$user = new User();
32		$user->id = $data['contentobject_id'];
33		$user->login = $data['login'];
34		$user->email = $data['email'];
35		$user->passwordHash = $data['password_hash'];
36		$user->hashAlgorithm = (int)$data['password_hash_type'];
37		$user->passwordUpdatedAt = $data['password_updated_at'] !== null ? (int)$data['password_updated_at'] : null;
38		$user->isEnabled = (bool)$data['is_enabled'];
39		$user->maxLogin = $data['max_login'];
40
41		return $user;
42		}
43
44		/**
45		* Map data for a set of user data.
46		*
47		* @param array $data
48		*
49		* @return \eZ\Publish\SPI\Persistence\User[]
50		*/
51		public function mapUsers(array $data)
52		{
53		$users = [];
54		foreach ($data as $row) {
55		$users[] = $this->mapUser($row);
56		}
57
58		return $users;
59		}
60
61		/**
62		* Map policy data to an array of policies.
63		*
64		* @param array $data
65		*
66		* @return \eZ\Publish\SPI\Persistence\User\Policy
67		*/
68		public function mapPolicies(array $data)
69		{
70		/** @var \eZ\Publish\SPI\Persistence\User\Policy[] */
71		$policies = [];
72		foreach ($data as $row) {
73		$policyId = $row['ezpolicy_id'];
74		if (!isset($policies[$policyId]) && ($policyId !== null)) {
75		$originalId = null;
76		if ($row['ezpolicy_original_id']) {
77		$originalId = (int)$row['ezpolicy_original_id'];
78		} elseif ($row['ezrole_version']) {
79		$originalId = (int)$policyId;
80		}
81
82		$policies[$policyId] = new Policy(
83		[
84		'id' => (int)$policyId,
85		'roleId' => (int)$row['ezrole_id'],
86		'originalId' => $originalId,
87		'module' => $row['ezpolicy_module_name'],
88		'function' => $row['ezpolicy_function_name'],
89		'limitations' => '', // limitations must be '' if not a non empty array of limitations
90		]
91		);
92		}
93
94		if (!$row['ezpolicy_limitation_identifier']) {
95		continue;
96		} elseif ($policies[$policyId]->limitations === '*') {
97		$policies[$policyId]->limitations = [];
98		}
99
100		if (!isset($policies[$policyId]->limitations[$row['ezpolicy_limitation_identifier']])) {
101		$policies[$policyId]->limitations[$row['ezpolicy_limitation_identifier']] = [$row['ezpolicy_limitation_value_value']];
102		} elseif (!in_array($row['ezpolicy_limitation_value_value'], $policies[$policyId]->limitations[$row['ezpolicy_limitation_identifier']])) {
103		$policies[$policyId]->limitations[$row['ezpolicy_limitation_identifier']][] = $row['ezpolicy_limitation_value_value'];
104		}
105		}
106
107		return array_values($policies);
108		}
109
110		/**
111		* Map role data to a role.
112		*
113		* @param array $data
114		*
115		* @return \eZ\Publish\SPI\Persistence\User\Role
116		*/
117		public function mapRole(array $data)
118		{
119		$role = new Role();
120
121		foreach ($data as $row) {
122		if (empty($role->id)) {
123		$role->id = (int)$row['ezrole_id'];
124		$role->identifier = $row['ezrole_name'];
125		$role->status = $row['ezrole_version'] != 0 ? Role::STATUS_DRAFT : Role::STATUS_DEFINED;
126		$role->originalId = $row['ezrole_version'] ? (int)$row['ezrole_version'] : Role::STATUS_DEFINED;
127		// skip name and description as they don't exist in legacy
128		}
129		}
130
131		$role->policies = $this->mapPolicies($data);
		0 ignored issues – show Documentation Bug introduced 2015-11-21 14:37 UTC by Report Bug Copy Issue Report It seems like `$this->mapPolicies($data)` of type `array<integer,?>` is incompatible with the declared type `array<integer,object<eZ\...rsistence\User\Policy>>` of property `$policies`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
132
133		return $role;
134		}
135
136		/**
137		* Map data for a set of roles.
138		*
139		* @param array $data
140		*
141		* @return \eZ\Publish\SPI\Persistence\User\Role[]
142		*/
143		public function mapRoles(array $data)
144		{
145		$roleData = [];
146		foreach ($data as $row) {
147		$roleData[$row['ezrole_id']][] = $row;
148		}
149
150		$roles = [];
151		foreach ($roleData as $data) {
152		$roles[] = $this->mapRole($data);
153		}
154
155		return $roles;
156		}
157
158		/**
159		* Map data for a set of role assignments.
160		*
161		* @param array $data
162		*
163		* @return \eZ\Publish\SPI\Persistence\User\RoleAssignment[]
164		*/
165		public function mapRoleAssignments(array $data)
166		{
167		$roleAssignmentData = [];
168		foreach ($data as $row) {
169		$id = (int)$row['id'];
170		$roleId = (int)$row['role_id'];
171		$contentId = (int)$row['contentobject_id'];
172		// if user already have full access to a role, continue
173		if (isset($roleAssignmentData[$roleId][$contentId])
174		&& $roleAssignmentData[$roleId][$contentId] instanceof RoleAssignment) {
175		continue;
176		}
177
178		$limitIdentifier = $row['limit_identifier'];
179		if (!empty($limitIdentifier)) {
180		$roleAssignmentData[$roleId][$contentId][$limitIdentifier][$id] = new RoleAssignment(
181		[
182		'id' => $id,
183		'roleId' => $roleId,
184		'contentId' => $contentId,
185		'limitationIdentifier' => $limitIdentifier,
186		'values' => [$row['limit_value']],
187		]
188		);
189		} else {
190		$roleAssignmentData[$roleId][$contentId] = new RoleAssignment(
191		[
192		'id' => $id,
193		'roleId' => $roleId,
194		'contentId' => $contentId,
195		]
196		);
197		}
198		}
199
200		$roleAssignments = [];
201		array_walk_recursive(
202		$roleAssignmentData,
203		function ($roleAssignment) use (&$roleAssignments) {
204		$roleAssignments[] = $roleAssignment;
205		}
206		);
207
208		return $roleAssignments;
209		}
210
211		/**
212		* Creates a create struct from an existing $role.
213		*
214		* @param \eZ\Publish\SPI\Persistence\User\Role $role
215		*
216		* @return \eZ\Publish\SPI\Persistence\User\RoleCreateStruct
217		*/
218	View Code Duplication	public function createCreateStructFromRole(Role $role)
219		{
220		$createStruct = new RoleCreateStruct();
221
222		$createStruct->identifier = $role->identifier;
223		$createStruct->policies = $role->policies;
224
225		return $createStruct;
226		}
227
228		/**
229		* Maps properties from $struct to $role.
230		*
231		* @param \eZ\Publish\SPI\Persistence\User\RoleCreateStruct $createStruct
232		*
233		* @return \eZ\Publish\SPI\Persistence\User\Role
234		*/
235	View Code Duplication	public function createRoleFromCreateStruct(RoleCreateStruct $createStruct)
236		{
237		$role = new Role();
238
239		$role->identifier = $createStruct->identifier;
240		$role->policies = $createStruct->policies;
		0 ignored issues – show Documentation Bug introduced 2015-11-21 14:37 UTC by Report Bug Copy Issue Report It seems like `$createStruct->policies` of type `array<integer,*>` is incompatible with the declared type `array<integer,object<eZ\...rsistence\User\Policy>>` of property `$policies`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
241		$role->status = Role::STATUS_DRAFT;
242
243		return $role;
244		}
245
246		/**
247		* Maps properties from $struct to $role.
248		*
249		* @param \eZ\Publish\SPI\Persistence\User\RoleCopyStruct $copyStruct
250		*
251		* @return \eZ\Publish\SPI\Persistence\User\Role
252		*/
253	View Code Duplication	public function createRoleFromCopyStruct(User\RoleCopyStruct $copyStruct)
254		{
255		$role = new Role();
256
257		$role->identifier = $copyStruct->newIdentifier;
258		$role->policies = $copyStruct->policies;
		0 ignored issues – show Documentation Bug introduced 2020-02-13 14:36 UTC by Report Bug Copy Issue Report It seems like `$copyStruct->policies` of type `array<integer,*>` is incompatible with the declared type `array<integer,object<eZ\...rsistence\User\Policy>>` of property `$policies`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
259		$role->status = Role::STATUS_DEFINED;
260
261		return $role;
262		}
263		}
264

ezsystems / ezpublish-kernel

Push — EZP-31383 ( 83ce0c )

Mapper::createRoleFromCopyStruct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like