#24550

pending completion

Build # #24550

Build Type

push

github

Committed by

web-flow

Commit Message

<a href="https://github.com/api-platform/core/commit/<a class=hub.com/api-platform/core/commit/02a73bf3acb9e6df9640341db849218e82050550">02a73bf3a<a href="https://github.com/api-platform/core/commit/02a73bf3acb9e6df9640341db849218e82050550">">Merge </a><a class="double-link" href="https://github.com/api-platform/core/commit/<a class="double-link" href="https://github.com/api-platform/core/commit/641281f1efdb1a3fd76ef899112fc417c9291f87">641281f1e</a>">641281f1e</a><a href="https://github.com/api-platform/core/commit/02a73bf3acb9e6df9640341db849218e82050550"> into 3a14131b3">3a14131b3</a>

Run Details

8732 of 9610 relevant lines covered (90.86%)

16.51 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

52.31

/src/JsonApi/Serializer/ItemNormalizer.php

<?php

/*
 * This file is part of the API Platform project.
 *
 * (c) Kévin Dunglas <dunglas@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace ApiPlatform\Core\JsonApi\Serializer;

use ApiPlatform\Core\Api\IriConverterInterface;
use ApiPlatform\Core\Api\ResourceClassResolverInterface;
use ApiPlatform\Core\Exception\ItemNotFoundException;
use ApiPlatform\Core\Metadata\Property\Factory\PropertyMetadataFactoryInterface;
use ApiPlatform\Core\Metadata\Property\Factory\PropertyNameCollectionFactoryInterface;
use ApiPlatform\Core\Metadata\Property\PropertyMetadata;
use ApiPlatform\Core\Metadata\Resource\Factory\ResourceMetadataFactoryInterface;
use ApiPlatform\Core\Serializer\AbstractItemNormalizer;
use ApiPlatform\Core\Serializer\CacheKeyTrait;
use ApiPlatform\Core\Serializer\ContextTrait;
use ApiPlatform\Core\Util\ClassInfoTrait;
use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
use Symfony\Component\Serializer\Exception\LogicException;
use Symfony\Component\Serializer\Exception\NotNormalizableValueException;
use Symfony\Component\Serializer\Exception\RuntimeException;
use Symfony\Component\Serializer\Exception\UnexpectedValueException;
use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
use Symfony\Component\Serializer\Normalizer\NormalizerInterface;

/**
 * Converts between objects and array.
 *
 * @author Kévin Dunglas <dunglas@gmail.com>
 * @author Amrouche Hamza <hamza.simperfit@gmail.com>
 * @author Baptiste Meyer <baptiste.meyer@gmail.com>
 */
final class ItemNormalizer extends AbstractItemNormalizer
{
    use CacheKeyTrait;
    use ClassInfoTrait;
    use ContextTrait;

    public const FORMAT = 'jsonapi';

    private $componentsCache = [];

    public function __construct(PropertyNameCollectionFactoryInterface $propertyNameCollectionFactory, PropertyMetadataFactoryInterface $propertyMetadataFactory, IriConverterInterface $iriConverter, ResourceClassResolverInterface $resourceClassResolver, ?PropertyAccessorInterface $propertyAccessor, ?NameConverterInterface $nameConverter, ResourceMetadataFactoryInterface $resourceMetadataFactory, array $defaultContext = [], iterable $dataTransformers = [])
    {
        parent::__construct($propertyNameCollectionFactory, $propertyMetadataFactory, $iriConverter, $resourceClassResolver, $propertyAccessor, $nameConverter, null, null, false, $defaultContext, $dataTransformers, $resourceMetadataFactory);
    }

    /**
     * {@inheritdoc}
     */
    public function supportsNormalization($data, $format = null): bool
    {
        return self::FORMAT === $format && parent::supportsNormalization($data, $format);
    }

    /**
     * {@inheritdoc}
     */
    public function normalize($object, $format = null, array $context = [])
    {
        if (null !== $this->getOutputClass($this->getObjectClass($object), $context)) {
            return parent::normalize($object, $format, $context);
        }

        if (!isset($context['cache_key'])) {
            $context['cache_key'] = $this->getCacheKey($format, $context);
        }

        $resourceClass = $this->resourceClassResolver->getResourceClass($object, $context['resource_class'] ?? null);
        $context = $this->initContext($resourceClass, $context);
        $iri = $this->iriConverter->getIriFromItem($object);
        $context['iri'] = $iri;
        $context['api_normalize'] = true;

        $data = parent::normalize($object, $format, $context);
        if (!\is_array($data)) {
            return $data;
        }

        $resourceMetadata = $this->resourceMetadataFactory->create($resourceClass);

        // Get and populate relations
        $allRelationshipsData = $this->getComponents($object, $format, $context)['relationships'];
        $populatedRelationContext = $context;
        $relationshipsData = $this->getPopulatedRelations($object, $format, $populatedRelationContext, $allRelationshipsData);
        $includedResourcesData = $this->getRelatedResources($object, $format, $context, $allRelationshipsData);

        $resourceData = [
            'id' => $context['iri'],
            'type' => $resourceMetadata->getShortName(),
        ];

        if ($data) {
            $resourceData['attributes'] = $data;
        }

        if ($relationshipsData) {
            $resourceData['relationships'] = $relationshipsData;
        }

        $document = ['data' => $resourceData];

        if ($includedResourcesData) {
            $document['included'] = $includedResourcesData;
        }

        return $document;
    }

    /**
     * {@inheritdoc}
     */
    public function supportsDenormalization($data, $type, $format = null): bool
    {
        return self::FORMAT === $format && parent::supportsDenormalization($data, $type, $format);
    }

    /**
     * {@inheritdoc}
     *
     * @throws NotNormalizableValueException
     */
    public function denormalize($data, $class, $format = null, array $context = [])
    {
        // Avoid issues with proxies if we populated the object
        if (!isset($context[self::OBJECT_TO_POPULATE]) && isset($data['data']['id'])) {
            if (true !== ($context['api_allow_update'] ?? true)) {
                throw new NotNormalizableValueException('Update is not allowed for this operation.');
            }

            $context[self::OBJECT_TO_POPULATE] = $this->iriConverter->getItemFromIri(
                $data['data']['id'],
                $context + ['fetch_data' => false]
            );
        }

        // Merge attributes and relationships, into format expected by the parent normalizer
        $dataToDenormalize = array_merge(
            $data['data']['attributes'] ?? [],
            $data['data']['relationships'] ?? []
        );

        return parent::denormalize(
            $dataToDenormalize,
            $class,
            $format,
            $context
        );
    }

    /**
     * {@inheritdoc}
     */
    protected function getAttributes($object, $format = null, array $context): array
    {
        return $this->getComponents($object, $format, $context)['attributes'];
    }

    /**
     * {@inheritdoc}
     */
    protected function setAttributeValue($object, $attribute, $value, $format = null, array $context = []): void
    {
        parent::setAttributeValue($object, $attribute, \is_array($value) && \array_key_exists('data', $value) ? $value['data'] : $value, $format, $context);
    }

    /**
     * {@inheritdoc}
     *
     * @see http://jsonapi.org/format/#document-resource-object-linkage
     *
     * @throws RuntimeException
     * @throws NotNormalizableValueException
     */
    protected function denormalizeRelation(string $attributeName, PropertyMetadata $propertyMetadata, string $className, $value, ?string $format, array $context)
    {
        if (!\is_array($value) || !isset($value['id'], $value['type'])) {
            throw new NotNormalizableValueException('Only resource linkage supported currently, see: http://jsonapi.org/format/#document-resource-object-linkage.');
        }

        try {
            return $this->iriConverter->getItemFromIri($value['id'], $context + ['fetch_data' => true]);
        } catch (ItemNotFoundException $e) {
            throw new RuntimeException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**
     * {@inheritdoc}
     *
     * @see http://jsonapi.org/format/#document-resource-object-linkage
     */
    protected function normalizeRelation(PropertyMetadata $propertyMetadata, $relatedObject, string $resourceClass, ?string $format, array $context)
    {
        if (null !== $relatedObject) {
            $iri = $this->iriConverter->getIriFromItem($relatedObject);
            $context['iri'] = $iri;

            if (isset($context['resources'])) {
                $context['resources'][$iri] = $iri;
            }
        }

        if (null === $relatedObject || isset($context['api_included'])) {
            if (!$this->serializer instanceof NormalizerInterface) {
                throw new LogicException(sprintf('The injected serializer must be an instance of "%s".', NormalizerInterface::class));
            }

            $normalizedRelatedObject = $this->serializer->normalize($relatedObject, $format, $context);
            if (!\is_string($normalizedRelatedObject) && !\is_array($normalizedRelatedObject) && !$normalizedRelatedObject instanceof \ArrayObject && null !== $normalizedRelatedObject) {
                throw new UnexpectedValueException('Expected normalized relation to be an IRI, array, \ArrayObject or null');
            }

            return $normalizedRelatedObject;
        }

        return [
            'data' => [
                'type' => $this->resourceMetadataFactory->create($resourceClass)->getShortName(),
                'id' => $iri,
            ],
        ];
    }

    /**
     * {@inheritdoc}
     */
    protected function isAllowedAttribute($classOrObject, $attribute, $format = null, array $context = []): bool
    {
        return preg_match('/^\\w[-\\w_]*$/', $attribute) && parent::isAllowedAttribute($classOrObject, $attribute, $format, $context);
    }

    /**
     * Gets JSON API components of the resource: attributes, relationships, meta and links.
     *
     * @param object $object
     */
    private function getComponents($object, ?string $format, array $context): array
    {
        $cacheKey = $this->getObjectClass($object).'-'.$context['cache_key'];

        if (isset($this->componentsCache[$cacheKey])) {
            return $this->componentsCache[$cacheKey];
        }

        $attributes = parent::getAttributes($object, $format, $context);

        $options = $this->getFactoryOptions($context);

        $components = [
            'links' => [],
            'relationships' => [],
            'attributes' => [],
            'meta' => [],
        ];

        foreach ($attributes as $attribute) {
            $propertyMetadata = $this
                ->propertyMetadataFactory
                ->create($context['resource_class'], $attribute, $options);

            $type = $propertyMetadata->getType();
            $isOne = $isMany = false;

            if (null !== $type) {
                if ($type->isCollection()) {
                    $isMany = ($type->getCollectionValueType() && $className = $type->getCollectionValueType()->getClassName()) ? $this->resourceClassResolver->isResourceClass($className) : false;
                } else {
                    $isOne = ($className = $type->getClassName()) ? $this->resourceClassResolver->isResourceClass($className) : false;
                }
            }

            if (!isset($className) || !$isOne && !$isMany) {
                $components['attributes'][] = $attribute;

                continue;
            }

            $relation = [
                'name' => $attribute,
                'type' => $this->resourceMetadataFactory->create($className)->getShortName(),
                'cardinality' => $isOne ? 'one' : 'many',
            ];

            $components['relationships'][] = $relation;
        }

        if (false !== $context['cache_key']) {
            $this->componentsCache[$cacheKey] = $components;
        }

        return $components;
    }

    /**
     * Populates relationships keys.
     *
     * @param object $object
     *
     * @throws UnexpectedValueException
     */
    private function getPopulatedRelations($object, ?string $format, array $context, array $relationships): array
    {
        $data = [];

        if (!isset($context['resource_class'])) {
            return $data;
        }

        unset($context['api_included']);
        foreach ($relationships as $relationshipDataArray) {
            $relationshipName = $relationshipDataArray['name'];

            $attributeValue = $this->getAttributeValue($object, $relationshipName, $format, $context);

            if ($this->nameConverter) {
                $relationshipName = $this->nameConverter->normalize($relationshipName, $context['resource_class'], self::FORMAT, $context);
            }

            if (!$attributeValue) {
                continue;
            }

            $data[$relationshipName] = [
                'data' => [],
            ];

            // Many to one relationship
            if ('one' === $relationshipDataArray['cardinality']) {
                unset($attributeValue['data']['attributes']);
                $data[$relationshipName] = $attributeValue;

                continue;
            }

            // Many to many relationship
            foreach ($attributeValue as $attributeValueElement) {
                if (!isset($attributeValueElement['data'])) {
                    throw new UnexpectedValueException(sprintf('The JSON API attribute \'%s\' must contain a "data" key.', $relationshipName));
                }
                unset($attributeValueElement['data']['attributes']);
                $data[$relationshipName]['data'][] = $attributeValueElement['data'];
            }
        }

        return $data;
    }

    /**
     * Populates included keys.
     */
    private function getRelatedResources($object, ?string $format, array $context, array $relationships): array
    {
        if (!isset($context['api_included'])) {
            return [];
        }

        $included = [];
        foreach ($relationships as $relationshipDataArray) {
            if (!\in_array($relationshipDataArray['name'], $context['api_included'], true)) {
                continue;
            }

            $relationshipName = $relationshipDataArray['name'];
            $relationContext = $context;
            $attributeValue = $this->getAttributeValue($object, $relationshipName, $format, $relationContext);

            if (!$attributeValue) {
                continue;
            }

            // Many to one relationship
            if ('one' === $relationshipDataArray['cardinality']) {
                $included[] = $attributeValue['data'];

                continue;
            }
            // Many to many relationship
            foreach ($attributeValue as $attributeValueElement) {
                if (isset($attributeValueElement['data'])) {
                    $included[] = $attributeValueElement['data'];
                }
            }
        }

        return $included;
    }
}

1	<?php
2
3	/*
4	* This file is part of the API Platform project.
5	*
6	* (c) Kévin Dunglas <dunglas@gmail.com>
7	*
8	* For the full copyright and license information, please view the LICENSE
9	* file that was distributed with this source code.
10	*/
11
12	declare(strict_types=1);
13
14	namespace ApiPlatform\Core\JsonApi\Serializer;
15
16	use ApiPlatform\Core\Api\IriConverterInterface;
17	use ApiPlatform\Core\Api\ResourceClassResolverInterface;
18	use ApiPlatform\Core\Exception\ItemNotFoundException;
19	use ApiPlatform\Core\Metadata\Property\Factory\PropertyMetadataFactoryInterface;
20	use ApiPlatform\Core\Metadata\Property\Factory\PropertyNameCollectionFactoryInterface;
21	use ApiPlatform\Core\Metadata\Property\PropertyMetadata;
22	use ApiPlatform\Core\Metadata\Resource\Factory\ResourceMetadataFactoryInterface;
23	use ApiPlatform\Core\Serializer\AbstractItemNormalizer;
24	use ApiPlatform\Core\Serializer\CacheKeyTrait;
25	use ApiPlatform\Core\Serializer\ContextTrait;
26	use ApiPlatform\Core\Util\ClassInfoTrait;
27	use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
28	use Symfony\Component\Serializer\Exception\LogicException;
29	use Symfony\Component\Serializer\Exception\NotNormalizableValueException;
30	use Symfony\Component\Serializer\Exception\RuntimeException;
31	use Symfony\Component\Serializer\Exception\UnexpectedValueException;
32	use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
33	use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
34
35	/**
36	* Converts between objects and array.
37	*
38	* @author Kévin Dunglas <dunglas@gmail.com>
39	* @author Amrouche Hamza <hamza.simperfit@gmail.com>
40	* @author Baptiste Meyer <baptiste.meyer@gmail.com>
41	*/
42	final class ItemNormalizer extends AbstractItemNormalizer
43	{
44	use CacheKeyTrait;
45	use ClassInfoTrait;
46	use ContextTrait;
47
48	public const FORMAT = 'jsonapi';
49
50	private $componentsCache = [];
51
52	public function __construct(PropertyNameCollectionFactoryInterface $propertyNameCollectionFactory, PropertyMetadataFactoryInterface $propertyMetadataFactory, IriConverterInterface $iriConverter, ResourceClassResolverInterface $resourceClassResolver, ?PropertyAccessorInterface $propertyAccessor, ?NameConverterInterface $nameConverter, ResourceMetadataFactoryInterface $resourceMetadataFactory, array $defaultContext = [], iterable $dataTransformers = [])
53	{
54	parent::__construct($propertyNameCollectionFactory, $propertyMetadataFactory, $iriConverter, $resourceClassResolver, $propertyAccessor, $nameConverter, null, null, false, $defaultContext, $dataTransformers, $resourceMetadataFactory);	44✔
55	}	44✔
56
57	/**
58	* {@inheritdoc}
59	*/
60	public function supportsNormalization($data, $format = null): bool
61	{
62	return self::FORMAT === $format && parent::supportsNormalization($data, $format);	21✔
63	}
64
65	/**
66	* {@inheritdoc}
67	*/
68	public function normalize($object, $format = null, array $context = [])
69	{
70	if (null !== $this->getOutputClass($this->getObjectClass($object), $context)) {	3✔
71	return parent::normalize($object, $format, $context);	×
72	}
73
74	if (!isset($context['cache_key'])) {	3✔
75	$context['cache_key'] = $this->getCacheKey($format, $context);	3✔
76	}
77
78	$resourceClass = $this->resourceClassResolver->getResourceClass($object, $context['resource_class'] ?? null);	3✔
79	$context = $this->initContext($resourceClass, $context);	3✔
80	$iri = $this->iriConverter->getIriFromItem($object);	3✔
81	$context['iri'] = $iri;	3✔
82	$context['api_normalize'] = true;	3✔
83
84	$data = parent::normalize($object, $format, $context);	3✔
85	if (!\is_array($data)) {	2✔
86	return $data;	1✔
87	}
88
89	$resourceMetadata = $this->resourceMetadataFactory->create($resourceClass);	1✔
90
91	// Get and populate relations
92	$allRelationshipsData = $this->getComponents($object, $format, $context)['relationships'];	1✔
93	$populatedRelationContext = $context;	1✔
94	$relationshipsData = $this->getPopulatedRelations($object, $format, $populatedRelationContext, $allRelationshipsData);	1✔
95	$includedResourcesData = $this->getRelatedResources($object, $format, $context, $allRelationshipsData);	1✔
96
97	$resourceData = [
98	'id' => $context['iri'],	1✔
99	'type' => $resourceMetadata->getShortName(),	1✔
100	];
101
102	if ($data) {	1✔
103	$resourceData['attributes'] = $data;	1✔
104	}
105
106	if ($relationshipsData) {	1✔
107	$resourceData['relationships'] = $relationshipsData;	×
108	}
109
110	$document = ['data' => $resourceData];	1✔
111
112	if ($includedResourcesData) {	1✔
113	$document['included'] = $includedResourcesData;	×
114	}
115
116	return $document;	1✔
117	}
118
119	/**
120	* {@inheritdoc}
121	*/
122	public function supportsDenormalization($data, $type, $format = null): bool
123	{
124	return self::FORMAT === $format && parent::supportsDenormalization($data, $type, $format);	5✔
125	}
126
127	/**
128	* {@inheritdoc}
129	*
130	* @throws NotNormalizableValueException
131	*/
132	public function denormalize($data, $class, $format = null, array $context = [])
133	{
134	// Avoid issues with proxies if we populated the object
135	if (!isset($context[self::OBJECT_TO_POPULATE]) && isset($data['data']['id'])) {	5✔
136	if (true !== ($context['api_allow_update'] ?? true)) {	1✔
137	throw new NotNormalizableValueException('Update is not allowed for this operation.');	1✔
138	}
139
140	$context[self::OBJECT_TO_POPULATE] = $this->iriConverter->getItemFromIri(	×
141	$data['data']['id'],	×
142	$context + ['fetch_data' => false]	×
143	);
144	}
145
146	// Merge attributes and relationships, into format expected by the parent normalizer
147	$dataToDenormalize = array_merge(	4✔
148	$data['data']['attributes'] ?? [],	4✔
149	$data['data']['relationships'] ?? []	4✔
150	);
151
152	return parent::denormalize(	4✔
153	$dataToDenormalize,	4✔
154	$class,
155	$format,
156	$context
157	);
158	}
159
160	/**
161	* {@inheritdoc}
162	*/
163	protected function getAttributes($object, $format = null, array $context): array
164	{
165	return $this->getComponents($object, $format, $context)['attributes'];	2✔
166	}
167
168	/**
169	* {@inheritdoc}
170	*/
171	protected function setAttributeValue($object, $attribute, $value, $format = null, array $context = []): void
172	{
173	parent::setAttributeValue($object, $attribute, \is_array($value) && \array_key_exists('data', $value) ? $value['data'] : $value, $format, $context);	4✔
174	}	1✔
175
176	/**
177	* {@inheritdoc}
178	*
179	* @see http://jsonapi.org/format/#document-resource-object-linkage
180	*
181	* @throws RuntimeException
182	* @throws NotNormalizableValueException
183	*/
184	protected function denormalizeRelation(string $attributeName, PropertyMetadata $propertyMetadata, string $className, $value, ?string $format, array $context)
185	{
186	if (!\is_array($value) \|\| !isset($value['id'], $value['type'])) {	2✔
187	throw new NotNormalizableValueException('Only resource linkage supported currently, see: http://jsonapi.org/format/#document-resource-object-linkage.');	1✔
188	}
189
190	try {
191	return $this->iriConverter->getItemFromIri($value['id'], $context + ['fetch_data' => true]);	1✔
192	} catch (ItemNotFoundException $e) {	×
193	throw new RuntimeException($e->getMessage(), $e->getCode(), $e);	×
194	}
195	}
196
197	/**
198	* {@inheritdoc}
199	*
200	* @see http://jsonapi.org/format/#document-resource-object-linkage
201	*/
202	protected function normalizeRelation(PropertyMetadata $propertyMetadata, $relatedObject, string $resourceClass, ?string $format, array $context)
203	{
204	if (null !== $relatedObject) {	×
205	$iri = $this->iriConverter->getIriFromItem($relatedObject);	×
206	$context['iri'] = $iri;	×
207
208	if (isset($context['resources'])) {	×
209	$context['resources'][$iri] = $iri;	×
210	}
211	}
212
213	if (null === $relatedObject \|\| isset($context['api_included'])) {	×
214	if (!$this->serializer instanceof NormalizerInterface) {	×
215	throw new LogicException(sprintf('The injected serializer must be an instance of "%s".', NormalizerInterface::class));	×
216	}
217
218	$normalizedRelatedObject = $this->serializer->normalize($relatedObject, $format, $context);	×
219	if (!\is_string($normalizedRelatedObject) && !\is_array($normalizedRelatedObject) && !$normalizedRelatedObject instanceof \ArrayObject && null !== $normalizedRelatedObject) {	×
220	throw new UnexpectedValueException('Expected normalized relation to be an IRI, array, \ArrayObject or null');	×
221	}
222
223	return $normalizedRelatedObject;	×
224	}
225
226	return [
227	'data' => [
228	'type' => $this->resourceMetadataFactory->create($resourceClass)->getShortName(),	×
229	'id' => $iri,	×
230	],
231	];
232	}
233
234	/**
235	* {@inheritdoc}
236	*/
237	protected function isAllowedAttribute($classOrObject, $attribute, $format = null, array $context = []): bool
238	{
239	return preg_match('/^\\w[-\\w_]*$/', $attribute) && parent::isAllowedAttribute($classOrObject, $attribute, $format, $context);	6✔
240	}
241
242	/**
243	* Gets JSON API components of the resource: attributes, relationships, meta and links.
244	*
245	* @param object $object
246	*/
247	private function getComponents($object, ?string $format, array $context): array
248	{
249	$cacheKey = $this->getObjectClass($object).'-'.$context['cache_key'];	2✔
250
251	if (isset($this->componentsCache[$cacheKey])) {	2✔
252	return $this->componentsCache[$cacheKey];	1✔
253	}
254
255	$attributes = parent::getAttributes($object, $format, $context);	2✔
256
257	$options = $this->getFactoryOptions($context);	2✔
258
259	$components = [
260	'links' => [],	2✔
261	'relationships' => [],
262	'attributes' => [],
263	'meta' => [],
264	];
265
266	foreach ($attributes as $attribute) {	2✔
267	$propertyMetadata = $this
268	->propertyMetadataFactory	2✔
269	->create($context['resource_class'], $attribute, $options);	2✔
270
271	$type = $propertyMetadata->getType();	2✔
272	$isOne = $isMany = false;	2✔
273
274	if (null !== $type) {	2✔
275	if ($type->isCollection()) {	×
276	$isMany = ($type->getCollectionValueType() && $className = $type->getCollectionValueType()->getClassName()) ? $this->resourceClassResolver->isResourceClass($className) : false;	×
277	} else {
278	$isOne = ($className = $type->getClassName()) ? $this->resourceClassResolver->isResourceClass($className) : false;	×
279	}
280	}
281
282	if (!isset($className) \|\| !$isOne && !$isMany) {	2✔
283	$components['attributes'][] = $attribute;	2✔
284
285	continue;	2✔
286	}
287
288	$relation = [
289	'name' => $attribute,	×
290	'type' => $this->resourceMetadataFactory->create($className)->getShortName(),	×
291	'cardinality' => $isOne ? 'one' : 'many',	×
292	];
293
294	$components['relationships'][] = $relation;	×
295	}
296
297	if (false !== $context['cache_key']) {	2✔
298	$this->componentsCache[$cacheKey] = $components;	2✔
299	}
300
301	return $components;	2✔
302	}
303
304	/**
305	* Populates relationships keys.
306	*
307	* @param object $object
308	*
309	* @throws UnexpectedValueException
310	*/
311	private function getPopulatedRelations($object, ?string $format, array $context, array $relationships): array
312	{
313	$data = [];	1✔
314
315	if (!isset($context['resource_class'])) {	1✔
316	return $data;	×
317	}
318
319	unset($context['api_included']);	1✔
320	foreach ($relationships as $relationshipDataArray) {	1✔
321	$relationshipName = $relationshipDataArray['name'];	×
322
323	$attributeValue = $this->getAttributeValue($object, $relationshipName, $format, $context);	×
324
325	if ($this->nameConverter) {	×
326	$relationshipName = $this->nameConverter->normalize($relationshipName, $context['resource_class'], self::FORMAT, $context);	×
327	}
328
329	if (!$attributeValue) {	×
330	continue;	×
331	}
332
333	$data[$relationshipName] = [	×
334	'data' => [],
335	];
336
337	// Many to one relationship
338	if ('one' === $relationshipDataArray['cardinality']) {	×
339	unset($attributeValue['data']['attributes']);	×
340	$data[$relationshipName] = $attributeValue;	×
341
342	continue;	×
343	}
344
345	// Many to many relationship
346	foreach ($attributeValue as $attributeValueElement) {	×
347	if (!isset($attributeValueElement['data'])) {	×
348	throw new UnexpectedValueException(sprintf('The JSON API attribute \'%s\' must contain a "data" key.', $relationshipName));	×
349	}
350	unset($attributeValueElement['data']['attributes']);	×
351	$data[$relationshipName]['data'][] = $attributeValueElement['data'];	×
352	}
353	}
354
355	return $data;	1✔
356	}
357
358	/**
359	* Populates included keys.
360	*/
361	private function getRelatedResources($object, ?string $format, array $context, array $relationships): array
362	{
363	if (!isset($context['api_included'])) {	1✔
364	return [];	1✔
365	}
366
367	$included = [];	×
368	foreach ($relationships as $relationshipDataArray) {	×
369	if (!\in_array($relationshipDataArray['name'], $context['api_included'], true)) {	×
370	continue;	×
371	}
372
373	$relationshipName = $relationshipDataArray['name'];	×
374	$relationContext = $context;	×
375	$attributeValue = $this->getAttributeValue($object, $relationshipName, $format, $relationContext);	×
376
377	if (!$attributeValue) {	×
378	continue;	×
379	}
380
381	// Many to one relationship
382	if ('one' === $relationshipDataArray['cardinality']) {	×
383	$included[] = $attributeValue['data'];	×
384
385	continue;	×
386	}
387	// Many to many relationship
388	foreach ($attributeValue as $attributeValueElement) {	×
389	if (isset($attributeValueElement['data'])) {	×
390	$included[] = $attributeValueElement['data'];	×
391	}
392	}
393	}
394
395	return $included;	×
396	}
397	}

api-platform / core / #24550

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous