UnitOfWork::getDirtyFields() - Code Metrics - Inspection of "Merge pull request #72 from mapado/jd-feat-scrutin..." - mapado/rest-client-sdk - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 7067f6...c51298 )

by Julien

created 2018-03-31 22:46 UTC

UnitOfWork::getDirtyFields() C

↳ Parent: UnitOfWork

Complexity

Conditions	23
Paths	78

Size

Total Lines	79
Code Lines	41

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	39
CRAP Score	23

Importance

Changes

Metric	Value
cc	23
eloc	41
nc	78
nop	3
dl	0
loc	79
ccs	39
cts	39
cp	1
crap	23
rs	5.0403
c	0
b	0
f	0

How to fix Long Method Complexity

<?php

namespace Mapado\RestClientSdk;

use Mapado\RestClientSdk\Helper\ArrayHelper;
use Mapado\RestClientSdk\Mapping;
use Mapado\RestClientSdk\Mapping\ClassMetadata;
use Mapado\RestClientSdk\Mapping\Relation;

/**
 * UnitOfWork
 */
class UnitOfWork
{
    /**
     * mapping
     *
     * @var Mapping
     * @access private
     */
    private $mapping;

    /**
     * storage for every entity retrieved
     *
     * @var array
     */
    private $storage;

    /**
     * Constructor.
     */
    public function __construct(Mapping $mapping)
    {
        $this->mapping = $mapping;
        $this->storage = [];
    }

    /**
     * getDirtyData
     *
     * return the new serialized model with only needed fields to update
     *
     * @param array $newSerializedModel
     * @param array $oldSerializedModel
     * @param ClassMetadata $classMetadata
     * @access public
     * @return array
     */
    public function getDirtyData(array $newSerializedModel, array $oldSerializedModel, ClassMetadata $classMetadata)
    {
        return $this->getDirtyFields($newSerializedModel, $oldSerializedModel, $classMetadata);
    }

    /**
     * registerClean
     *
     * @param string $id
     * @param object $entity
     * @access public
     * @return UnitOfWork
     */
    public function registerClean($id, $entity)
    {
        if (is_object($entity)) {
            $entityStored = clone $entity;
            $this->storage[$id] = $entityStored;
        }

        return $this;
    }

    /**
     * getDirtyEntity
     *
     * @param string $id
     * @access public
     * @return mixed
     */
    public function getDirtyEntity($id)
    {
        if (isset($this->storage[$id])) {
            return $this->storage[$id];
        }
        return null;
    }

    /**
     * clear
     *
     * @param string $id
     * @access public
     * @return UnitOfWork
     */
    public function clear($id)
    {
        unset($this->storage[$id]);
        return $this;
    }

    /**
     * getDirtyFields
     *
     * compares serialize object and returns only modified fields
     *
     * @param array $newSerializedModel
     * @param array $oldSerializedModel
     * @param ClassMetadata $classMetadata
     * @access private
     * @return array
     */
    private function getDirtyFields(array $newSerializedModel, array $oldSerializedModel, ClassMetadata $classMetadata)
    {
        $dirtyFields = [];

        foreach ($newSerializedModel as $key => $value) {
            if (!array_key_exists($key, $oldSerializedModel)) {
                // a new key has been found, add it to the dirtyFields
                $dirtyFields[$key] = $value;
                continue;
            }

            $oldValue = $oldSerializedModel[$key];

            $currentRelation = $classMetadata ? $classMetadata->getRelation($key) : null;

            if (!$currentRelation) {
                if (is_array($value) && !ArrayHelper::arraySame($value, $oldValue ?: [])

                    || $value !== $oldValue
                ) {
                    $dirtyFields[$key] = $value;
                }
                continue;
            }

            $currentClassMetadata = $this->mapping->getClassMetadata($currentRelation->getTargetEntity());

            $idSerializedKey = $currentClassMetadata ? $currentClassMetadata->getIdSerializeKey() : null;

            if ($currentRelation->getType() === Relation::MANY_TO_ONE) {
                if ($value !== $oldValue) {
                    if (is_string($value) || is_string($oldValue)) {
                        $dirtyFields[$key] = $value;
                    } else {
                        $recursiveDiff = $this->getDirtyFields($value, $oldValue, $currentClassMetadata);

                        if (!empty($recursiveDiff)) {
                            $recursiveDiff[$idSerializedKey] = self::getEntityId($value, $idSerializedKey);
                            $dirtyFields[$key] = $recursiveDiff;
                        }
                    }
                }

                continue;
            }

            // ONE_TO_MANY relation

            if (count($value ?? []) !== count($oldValue ?? [])) {
                // get all objects ids of new array
                $dirtyFields[$key] = $this->addIdentifiers($value, [], $idSerializedKey);
            }

            if (!empty($value)) {
                foreach ($value as $relationKey => $relationValue) {
                    $oldRelationValue = $this->findOldRelation($relationValue, $oldValue, $currentClassMetadata);

                    if ($relationValue !== $oldRelationValue) {
                        if (is_string($relationValue) || is_string($oldRelationValue)) {
                            $dirtyFields[$key][$relationKey] = $relationValue;
                        } else {
                            $recursiveDiff = $this->getDirtyFields($relationValue, $oldRelationValue, $currentClassMetadata);

                            if (!empty($recursiveDiff)) {
                                $idSerializedKey = $currentClassMetadata->getIdSerializeKey();

                                $entityId = self::getEntityId($relationValue, $idSerializedKey);
                                if ($entityId !== null) {
                                    $recursiveDiff[$idSerializedKey] = $entityId;
                                }
                                $dirtyFields[$key][$relationKey] = $recursiveDiff;
                            }
                        }
                    }
                }
            }
        }


        return $dirtyFields;
    }

    /**
     * addIdentifiers
     *
     * add defined identifiers to given model
     *
     * @param array $newSerializedModel
     * @param array $dirtyFields
     * @access private
     * @return array
     */
    private function addIdentifiers($newSerializedModel, $dirtyFields, $idSerializedKey = null)
    {
        foreach ($newSerializedModel as $key => $value) {
            if ($idSerializedKey && isset($value[$idSerializedKey])) {
                $dirtyFields[$key][$idSerializedKey] = $value[$idSerializedKey];
            } elseif (is_string($value) && is_int($key)) {
                $dirtyFields[$key] = $value;
            }
        }

        return $dirtyFields;
    }

    private function findOldRelation($relationValue, array $oldValue, ClassMetadata $classMetadata)
    {
        $idSerializedKey = $classMetadata->getIdSerializeKey();

        $relationValueId = self::getEntityId($relationValue, $idSerializedKey);

        foreach ($oldValue as $oldRelationValue) {
            $oldRelationValueId = self::getEntityId($oldRelationValue, $idSerializedKey);

            if ($relationValueId === $oldRelationValueId) {
                return $oldRelationValue;
            }
        }

        return $classMetadata->getDefaultSerializedModel();
    }

    /**
     * get entity id from string or array
     * @param mixed $stringOrEntity
     * @param string $idSerializedKey
     */
    private static function getEntityId($stringOrEntity, $idSerializedKey)
    {
        if (!is_array($stringOrEntity)) {
            return $stringOrEntity;
        }

        return isset($stringOrEntity[$idSerializedKey])
            ? $stringOrEntity[$idSerializedKey]
            : null;
    }
}


1		<?php
2
3		namespace Mapado\RestClientSdk;
4
5		use Mapado\RestClientSdk\Helper\ArrayHelper;
6		use Mapado\RestClientSdk\Mapping;
7		use Mapado\RestClientSdk\Mapping\ClassMetadata;
8		use Mapado\RestClientSdk\Mapping\Relation;
9
10		/**
11		* UnitOfWork
12		*/
13		class UnitOfWork
14		{
15		/**
16		* mapping
17		*
18		* @var Mapping
19		* @access private
20		*/
21		private $mapping;
22
23		/**
24		* storage for every entity retrieved
25		*
26		* @var array
27		*/
28		private $storage;
29
30		/**
31		* Constructor.
32		*/
33		public function __construct(Mapping $mapping)
34		{
35	1	$this->mapping = $mapping;
36	1	$this->storage = [];
37	1	}
38
39		/**
40		* getDirtyData
41		*
42		* return the new serialized model with only needed fields to update
43		*
44		* @param array $newSerializedModel
45		* @param array $oldSerializedModel
46		* @param ClassMetadata $classMetadata
47		* @access public
48		* @return array
49		*/
50		public function getDirtyData(array $newSerializedModel, array $oldSerializedModel, ClassMetadata $classMetadata)
51		{
52	1	return $this->getDirtyFields($newSerializedModel, $oldSerializedModel, $classMetadata);
53		}
54
55		/**
56		* registerClean
57		*
58		* @param string $id
59		* @param object $entity
60		* @access public
61		* @return UnitOfWork
62		*/
63		public function registerClean($id, $entity)
64		{
65	1	if (is_object($entity)) {
66	1	$entityStored = clone $entity;
67	1	$this->storage[$id] = $entityStored;
68		}
69
70	1	return $this;
71		}
72
73		/**
74		* getDirtyEntity
75		*
76		* @param string $id
77		* @access public
78		* @return mixed
79		*/
80		public function getDirtyEntity($id)
81		{
82	1	if (isset($this->storage[$id])) {
83	1	return $this->storage[$id];
84		}
85		return null;
86		}
87
88		/**
89		* clear
90		*
91		* @param string $id
92		* @access public
93		* @return UnitOfWork
94		*/
95		public function clear($id)
96		{
97		unset($this->storage[$id]);
98		return $this;
99		}
100
101		/**
102		* getDirtyFields
103		*
104		* compares serialize object and returns only modified fields
105		*
106		* @param array $newSerializedModel
107		* @param array $oldSerializedModel
108		* @param ClassMetadata $classMetadata
109		* @access private
110		* @return array
111		*/
112		private function getDirtyFields(array $newSerializedModel, array $oldSerializedModel, ClassMetadata $classMetadata)
113		{
114	1	$dirtyFields = [];
115
116	1	foreach ($newSerializedModel as $key => $value) {
117	1	if (!array_key_exists($key, $oldSerializedModel)) {
118		// a new key has been found, add it to the dirtyFields
119	1	$dirtyFields[$key] = $value;
120	1	continue;
121		}
122
123	1	$oldValue = $oldSerializedModel[$key];
124
125	1	$currentRelation = $classMetadata ? $classMetadata->getRelation($key) : null;
126
127	1	if (!$currentRelation) {
128	1	if (is_array($value) && !ArrayHelper::arraySame($value, $oldValue ?: [])
		0 ignored issues – show introduced 2018-03-31 22:42 UTC by Report Bug Copy Issue Report Consider adding parentheses for clarity. Current Interpretation: `{currentAssign}`, Probably Intended Meaning: `{alternativeAssign}` Loading history...
129	1	\|\| $value !== $oldValue
130		) {
131	1	$dirtyFields[$key] = $value;
132		}
133	1	continue;
134		}
135
136	1	$currentClassMetadata = $this->mapping->getClassMetadata($currentRelation->getTargetEntity());
137
138	1	$idSerializedKey = $currentClassMetadata ? $currentClassMetadata->getIdSerializeKey() : null;
139
140	1	if ($currentRelation->getType() === Relation::MANY_TO_ONE) {
141	1	if ($value !== $oldValue) {
142	1	if (is_string($value) \|\| is_string($oldValue)) {
143	1	$dirtyFields[$key] = $value;
144		} else {
145	1	$recursiveDiff = $this->getDirtyFields($value, $oldValue, $currentClassMetadata);
146
147	1	if (!empty($recursiveDiff)) {
148	1	$recursiveDiff[$idSerializedKey] = self::getEntityId($value, $idSerializedKey);
149	1	$dirtyFields[$key] = $recursiveDiff;
150		}
151		}
152		}
153
154	1	continue;
155		}
156
157		// ONE_TO_MANY relation
158
159	1	if (count($value ?? []) !== count($oldValue ?? [])) {
160		// get all objects ids of new array
161	1	$dirtyFields[$key] = $this->addIdentifiers($value, [], $idSerializedKey);
162		}
163
164	1	if (!empty($value)) {
165	1	foreach ($value as $relationKey => $relationValue) {
166	1	$oldRelationValue = $this->findOldRelation($relationValue, $oldValue, $currentClassMetadata);
167
168	1	if ($relationValue !== $oldRelationValue) {
169	1	if (is_string($relationValue) \|\| is_string($oldRelationValue)) {
170	1	$dirtyFields[$key][$relationKey] = $relationValue;
171		} else {
172	1	$recursiveDiff = $this->getDirtyFields($relationValue, $oldRelationValue, $currentClassMetadata);
173
174	1	if (!empty($recursiveDiff)) {
175	1	$idSerializedKey = $currentClassMetadata->getIdSerializeKey();
176
177	1	$entityId = self::getEntityId($relationValue, $idSerializedKey);
178	1	if ($entityId !== null) {
179	1	$recursiveDiff[$idSerializedKey] = $entityId;
180		}
181	1	$dirtyFields[$key][$relationKey] = $recursiveDiff;
182		}
183		}
184		}
185		}
186		}
187		}
188
189
190	1	return $dirtyFields;
191		}
192
193		/**
194		* addIdentifiers
195		*
196		* add defined identifiers to given model
197		*
198		* @param array $newSerializedModel
199		* @param array $dirtyFields
200		* @access private
201		* @return array
202		*/
203		private function addIdentifiers($newSerializedModel, $dirtyFields, $idSerializedKey = null)
204		{
205	1	foreach ($newSerializedModel as $key => $value) {
206	1	if ($idSerializedKey && isset($value[$idSerializedKey])) {
207	1	$dirtyFields[$key][$idSerializedKey] = $value[$idSerializedKey];
208	1	} elseif (is_string($value) && is_int($key)) {
209	1	$dirtyFields[$key] = $value;
210		}
211		}
212
213	1	return $dirtyFields;
214		}
215
216		private function findOldRelation($relationValue, array $oldValue, ClassMetadata $classMetadata)
217		{
218	1	$idSerializedKey = $classMetadata->getIdSerializeKey();
219
220	1	$relationValueId = self::getEntityId($relationValue, $idSerializedKey);
221
222	1	foreach ($oldValue as $oldRelationValue) {
223	1	$oldRelationValueId = self::getEntityId($oldRelationValue, $idSerializedKey);
224
225	1	if ($relationValueId === $oldRelationValueId) {
226	1	return $oldRelationValue;
227		}
228		}
229
230	1	return $classMetadata->getDefaultSerializedModel();
231		}
232
233		/**
234		* get entity id from string or array
235		* @param mixed $stringOrEntity
236		* @param string $idSerializedKey
237		*/
238		private static function getEntityId($stringOrEntity, $idSerializedKey)
239		{
240	1	if (!is_array($stringOrEntity)) {
241	1	return $stringOrEntity;
242		}
243
244	1	return isset($stringOrEntity[$idSerializedKey])
245	1	? $stringOrEntity[$idSerializedKey]
246	1	: null;
247		}
248		}
249

mapado / rest-client-sdk

Push — master ( 7067f6...c51298 )

UnitOfWork::getDirtyFields() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like