DataIncludedHelper::addToRelationshipsArray() - Code Metrics - nilportugues/json-api - Measure and Improve Code Quality continuously with Scrutinizer

DataIncludedHelper::addToRelationshipsArray() B
last analyzed 2016-05-09 15:54 UTC

↳ Parent: DataIncludedHelper

Complexity

Conditions	4
Paths	4

Size

Total Lines	34
Code Lines	21

Duplication

Lines	0
Ratio	0 %

Importance

Changes	5
Bugs	0	Features	1

Metric	Value
c	5
b	0
f	1
dl	0
loc	34
rs	8.5806
cc	4
eloc	21
nc	4
nop	6

<?php

/**
 * Author: Nil Portugués Calderó <[email protected]>
 * Date: 7/25/15
 * Time: 5:15 PM.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace NilPortugues\Api\JsonApi\Helpers;

use NilPortugues\Api\JsonApi\JsonApiTransformer;
use NilPortugues\Serializer\Serializer;

class DataIncludedHelper
{
    /**
     * @param \NilPortugues\Api\Mapping\Mapping[] $mappings
     * @param array                               $array
     * @param array                               $data
     * @param null                                $parentType
     */
    public static function setResponseDataIncluded(array &$mappings, array $array, array &$data, $parentType = null)
    {
        $parentType = (null === $parentType) ? $array[Serializer::CLASS_IDENTIFIER_KEY] : $parentType;

        foreach (self::removeTypeAndId($mappings, $array) as $value) {
            if (\is_array($value)) {
                if (\array_key_exists(Serializer::CLASS_IDENTIFIER_KEY, $value)) {
                    $attributes = [];
                    $relationships = [];
                    $type = $value[Serializer::CLASS_IDENTIFIER_KEY];

                    self::addToRelationshipsArray($mappings, $data, $value, $type, $relationships, $attributes);
                    self::addToIncludedArray($mappings, $data, $attributes, $value);
                    continue;
                }

                if (\is_array($value)) {
                    foreach ($value as $inArrayValue) {
                        if (\is_array($inArrayValue)) {

                            //Remove those resources that do not to appear in the getIncludedResources array.
                            foreach ($inArrayValue as $position => $includableValue) {
                                if ($mappings[$parentType]->isFilteringIncludedResources()
                                    && false === in_array(
                                        $includableValue[Serializer::CLASS_IDENTIFIER_KEY],
                                        $mappings[$parentType]->getIncludedResources(),
                                        true
                                    )
                                ) {
                                    unset($inArrayValue[$position]);
                                }
                            }

                            self::setResponseDataIncluded($mappings, $inArrayValue, $data, $parentType);
                        }
                    }
                }
            }
        }
    }

    /**
     * @param \NilPortugues\Api\Mapping\Mapping[] $mappings
     * @param array                               $copy
     *
     * @return array
     */
    protected static function removeTypeAndId(array &$mappings, array $copy)
    {
        if (!empty($copy[Serializer::CLASS_IDENTIFIER_KEY])) {
            $type = $copy[Serializer::CLASS_IDENTIFIER_KEY];

            if (\is_scalar($type)) {
                foreach ($mappings[$type]->getIdProperties() as $propertyName) {
                    unset($copy[$propertyName]);
                }
                unset($copy[Serializer::CLASS_IDENTIFIER_KEY]);
            }
        }

        return $copy;
    }

    /**
     * @param \NilPortugues\Api\Mapping\Mapping[] $mappings
     * @param array                               $data
     * @param array                               $value
     * @param string                              $type
     * @param array                               $relationships
     * @param array                               $attributes
     */
    protected static function addToRelationshipsArray(
        array &$mappings,
        array &$data,
        array &$value,
        $type,
        array &$relationships,
        array &$attributes
    ) {
        foreach ($value as $propertyName => $attribute) {
            if (PropertyHelper::isAttributeProperty($mappings, $propertyName, $type)) {
                $propertyName = DataAttributesHelper::transformToValidMemberName($propertyName);

                if (\array_key_exists(Serializer::CLASS_IDENTIFIER_KEY, $attribute)) {
                    self::setResponseDataIncluded($mappings, $value, $data);

                    $relationships[$propertyName] = \array_merge(
                        DataLinksHelper::setResponseDataLinks($mappings, $attribute),
                        [
                            JsonApiTransformer::DATA_KEY => [
                                $propertyName => PropertyHelper::setResponseDataTypeAndId(
                                        $mappings,
                                        $attribute
                                    ),
                            ],
                        ],
                        $mappings[$type]->getRelationships()
                    );

                    continue;
                }
                $attributes[$propertyName] = $attribute;
            }
        }
    }

    /**
     * @param \NilPortugues\Api\Mapping\Mapping[] $mappings
     * @param array                               $data
     * @param array                               $attributes
     * @param array                               $value
     */
    protected static function addToIncludedArray(array &$mappings, array &$data, array &$attributes, array &$value)
    {
        if (\count($attributes) > 0) {
            $includedData = PropertyHelper::setResponseDataTypeAndId($mappings, $value);

            if (self::hasIdKey($includedData)) {
                $arrayData = \array_merge(
                    [
                        JsonApiTransformer::TYPE_KEY => $includedData[JsonApiTransformer::TYPE_KEY],
                        JsonApiTransformer::ID_KEY => $includedData[JsonApiTransformer::ID_KEY],
                        JsonApiTransformer::ATTRIBUTES_KEY => $attributes,
                        JsonApiTransformer::RELATIONSHIPS_KEY => [],
                    ],
                    DataLinksHelper::setResponseDataLinks($mappings, $value)
                );

                $relationshipData = [];
                self::addRelationshipsToIncludedResources(
                    $mappings,
                    $relationshipData,
                    $value,
                    $value[Serializer::CLASS_IDENTIFIER_KEY],
                    $attributes

                );

                if ($relationshipData) {

                    $arrayData[JsonApiTransformer::RELATIONSHIPS_KEY] = \array_merge(
                        $arrayData[JsonApiTransformer::RELATIONSHIPS_KEY],
                        $relationshipData
                    );
                }

                $data[JsonApiTransformer::INCLUDED_KEY][] = \array_filter($arrayData);
            }
        }

        if (!empty($data[JsonApiTransformer::INCLUDED_KEY])) {
            $data[JsonApiTransformer::INCLUDED_KEY] = \array_values(
                \array_unique($data[JsonApiTransformer::INCLUDED_KEY], SORT_REGULAR)
            );
        }
    }

    /**
     * @param array  $mappings
     * @param array  $data
     * @param array  $value
     * @param string $type
     */
    protected static function addRelationshipsToIncludedResources(

        array &$mappings,
        array &$data,
        array &$value,
        $type
    ) {
        foreach ($value as $propertyName => $attribute) {
            if (PropertyHelper::isAttributeProperty($mappings, $propertyName, $type)) {
                $propertyName = DataAttributesHelper::transformToValidMemberName($propertyName);

                if (\is_array($attribute) && \array_key_exists(Serializer::CLASS_IDENTIFIER_KEY, $attribute)) {
                    $data[$propertyName][JsonApiTransformer::DATA_KEY] = PropertyHelper::setResponseDataTypeAndId(
                        $mappings,
                        $attribute
                    );

                    continue;
                }
            }
        }
    }

    /**
     * @param array $includedData
     *
     * @return bool
     */
    protected static function hasIdKey(array &$includedData)
    {
        return \array_key_exists(JsonApiTransformer::ID_KEY, $includedData)
        && !empty($includedData[JsonApiTransformer::ID_KEY]);
    }
}


1		<?php
2
3		/**
4		* Author: Nil Portugués Calderó <[email protected]>
5		* Date: 7/25/15
6		* Time: 5:15 PM.
7		*
8		* For the full copyright and license information, please view the LICENSE
9		* file that was distributed with this source code.
10		*/
11		namespace NilPortugues\Api\JsonApi\Helpers;
12
13		use NilPortugues\Api\JsonApi\JsonApiTransformer;
14		use NilPortugues\Serializer\Serializer;
15
16		class DataIncludedHelper
17		{
18		/**
19		* @param \NilPortugues\Api\Mapping\Mapping[] $mappings
20		* @param array $array
21		* @param array $data
22		* @param null $parentType
23		*/
24		public static function setResponseDataIncluded(array &$mappings, array $array, array &$data, $parentType = null)
25		{
26		$parentType = (null === $parentType) ? $array[Serializer::CLASS_IDENTIFIER_KEY] : $parentType;
27
28		foreach (self::removeTypeAndId($mappings, $array) as $value) {
29		if (\is_array($value)) {
30		if (\array_key_exists(Serializer::CLASS_IDENTIFIER_KEY, $value)) {
31		$attributes = [];
32		$relationships = [];
33		$type = $value[Serializer::CLASS_IDENTIFIER_KEY];
34
35		self::addToRelationshipsArray($mappings, $data, $value, $type, $relationships, $attributes);
36		self::addToIncludedArray($mappings, $data, $attributes, $value);
37		continue;
38		}
39
40		if (\is_array($value)) {
41		foreach ($value as $inArrayValue) {
42		if (\is_array($inArrayValue)) {
43
44		//Remove those resources that do not to appear in the getIncludedResources array.
45		foreach ($inArrayValue as $position => $includableValue) {
46		if ($mappings[$parentType]->isFilteringIncludedResources()
47		&& false === in_array(
48		$includableValue[Serializer::CLASS_IDENTIFIER_KEY],
49		$mappings[$parentType]->getIncludedResources(),
50		true
51		)
52		) {
53		unset($inArrayValue[$position]);
54		}
55		}
56
57		self::setResponseDataIncluded($mappings, $inArrayValue, $data, $parentType);
58		}
59		}
60		}
61		}
62		}
63		}
64
65		/**
66		* @param \NilPortugues\Api\Mapping\Mapping[] $mappings
67		* @param array $copy
68		*
69		* @return array
70		*/
71		protected static function removeTypeAndId(array &$mappings, array $copy)
72		{
73		if (!empty($copy[Serializer::CLASS_IDENTIFIER_KEY])) {
74		$type = $copy[Serializer::CLASS_IDENTIFIER_KEY];
75
76		if (\is_scalar($type)) {
77		foreach ($mappings[$type]->getIdProperties() as $propertyName) {
78		unset($copy[$propertyName]);
79		}
80		unset($copy[Serializer::CLASS_IDENTIFIER_KEY]);
81		}
82		}
83
84		return $copy;
85		}
86
87		/**
88		* @param \NilPortugues\Api\Mapping\Mapping[] $mappings
89		* @param array $data
90		* @param array $value
91		* @param string $type
92		* @param array $relationships
93		* @param array $attributes
94		*/
95		protected static function addToRelationshipsArray(
96		array &$mappings,
97		array &$data,
98		array &$value,
99		$type,
100		array &$relationships,
101		array &$attributes
102		) {
103		foreach ($value as $propertyName => $attribute) {
104		if (PropertyHelper::isAttributeProperty($mappings, $propertyName, $type)) {
105		$propertyName = DataAttributesHelper::transformToValidMemberName($propertyName);
106
107		if (\array_key_exists(Serializer::CLASS_IDENTIFIER_KEY, $attribute)) {
108		self::setResponseDataIncluded($mappings, $value, $data);
109
110		$relationships[$propertyName] = \array_merge(
111		DataLinksHelper::setResponseDataLinks($mappings, $attribute),
112		[
113		JsonApiTransformer::DATA_KEY => [
114		$propertyName => PropertyHelper::setResponseDataTypeAndId(
115		$mappings,
116		$attribute
117		),
118		],
119		],
120		$mappings[$type]->getRelationships()
121		);
122
123		continue;
124		}
125		$attributes[$propertyName] = $attribute;
126		}
127		}
128		}
129
130		/**
131		* @param \NilPortugues\Api\Mapping\Mapping[] $mappings
132		* @param array $data
133		* @param array $attributes
134		* @param array $value
135		*/
136		protected static function addToIncludedArray(array &$mappings, array &$data, array &$attributes, array &$value)
137		{
138		if (\count($attributes) > 0) {
139		$includedData = PropertyHelper::setResponseDataTypeAndId($mappings, $value);
140
141		if (self::hasIdKey($includedData)) {
142		$arrayData = \array_merge(
143		[
144		JsonApiTransformer::TYPE_KEY => $includedData[JsonApiTransformer::TYPE_KEY],
145		JsonApiTransformer::ID_KEY => $includedData[JsonApiTransformer::ID_KEY],
146		JsonApiTransformer::ATTRIBUTES_KEY => $attributes,
147		JsonApiTransformer::RELATIONSHIPS_KEY => [],
148		],
149		DataLinksHelper::setResponseDataLinks($mappings, $value)
150		);
151
152		$relationshipData = [];
153		self::addRelationshipsToIncludedResources(
154		$mappings,
155		$relationshipData,
156		$value,
157		$value[Serializer::CLASS_IDENTIFIER_KEY],
158		$attributes
		0 ignored issues – show Unused Code introduced 2016-05-09 15:54 UTC by Report Bug Copy Issue Report The call to `DataIncludedHelper::addR...psToIncludedResources()` has too many arguments starting with `$attributes`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
159		);
160
161		if ($relationshipData) {
		0 ignored issues – show Bug Best Practice introduced 2016-05-09 15:54 UTC by Report Bug Copy Issue Report The expression `$relationshipData` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
162		$arrayData[JsonApiTransformer::RELATIONSHIPS_KEY] = \array_merge(
163		$arrayData[JsonApiTransformer::RELATIONSHIPS_KEY],
164		$relationshipData
165		);
166		}
167
168		$data[JsonApiTransformer::INCLUDED_KEY][] = \array_filter($arrayData);
169		}
170		}
171
172		if (!empty($data[JsonApiTransformer::INCLUDED_KEY])) {
173		$data[JsonApiTransformer::INCLUDED_KEY] = \array_values(
174		\array_unique($data[JsonApiTransformer::INCLUDED_KEY], SORT_REGULAR)
175		);
176		}
177		}
178
179		/**
180		* @param array $mappings
181		* @param array $data
182		* @param array $value
183		* @param string $type
184		*/
185	View Code Duplication	protected static function addRelationshipsToIncludedResources(
		0 ignored issues – show Duplication introduced 2016-05-09 15:54 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
186		array &$mappings,
187		array &$data,
188		array &$value,
189		$type
190		) {
191		foreach ($value as $propertyName => $attribute) {
192		if (PropertyHelper::isAttributeProperty($mappings, $propertyName, $type)) {
193		$propertyName = DataAttributesHelper::transformToValidMemberName($propertyName);
194
195		if (\is_array($attribute) && \array_key_exists(Serializer::CLASS_IDENTIFIER_KEY, $attribute)) {
196		$data[$propertyName][JsonApiTransformer::DATA_KEY] = PropertyHelper::setResponseDataTypeAndId(
197		$mappings,
198		$attribute
199		);
200
201		continue;
202		}
203		}
204		}
205		}
206
207		/**
208		* @param array $includedData
209		*
210		* @return bool
211		*/
212		protected static function hasIdKey(array &$includedData)
213		{
214		return \array_key_exists(JsonApiTransformer::ID_KEY, $includedData)
215		&& !empty($includedData[JsonApiTransformer::ID_KEY]);
216		}
217		}
218

nilportugues / json-api

DataIncludedHelper::addToRelationshipsArray() B last analyzed 2016-05-09 15:54 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

DataIncludedHelper::addToRelationshipsArray() B
last analyzed 2016-05-09 15:54 UTC