Issues in DocumentationNormalizer.php - New Issues - Inspection of "Merge pull request #1238 from soyuka/fix-hydra-doc..." - api-platform/core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 0c3139...e3501a )

by Antoine

created 2017-07-07 11:34 UTC

src/Hydra/Serializer/DocumentationNormalizer.php (2 issues)

Labels

Duplication 2

Severity

Informational 2

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php

/*
 * This file is part of the API Platform project.
 *
 * (c) Kévin Dunglas <[email protected]>
 *
 * 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\Hydra\Serializer;

use ApiPlatform\Core\Api\OperationMethodResolverInterface;
use ApiPlatform\Core\Api\ResourceClassResolverInterface;
use ApiPlatform\Core\Api\UrlGeneratorInterface;
use ApiPlatform\Core\Documentation\Documentation;
use ApiPlatform\Core\JsonLd\ContextBuilderInterface;
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\Metadata\Resource\ResourceMetadata;
use Symfony\Component\PropertyInfo\Type;
use Symfony\Component\Serializer\Normalizer\NormalizerInterface;

/**
 * Creates a machine readable Hydra API documentation.
 *
 * @author Kévin Dunglas <[email protected]>
 */
final class DocumentationNormalizer implements NormalizerInterface
{
    const FORMAT = 'jsonld';

    private $resourceMetadataFactory;
    private $propertyNameCollectionFactory;
    private $propertyMetadataFactory;
    private $resourceClassResolver;
    private $operationMethodResolver;
    private $urlGenerator;

    public function __construct(ResourceMetadataFactoryInterface $resourceMetadataFactory, PropertyNameCollectionFactoryInterface $propertyNameCollectionFactory, PropertyMetadataFactoryInterface $propertyMetadataFactory, ResourceClassResolverInterface $resourceClassResolver, OperationMethodResolverInterface $operationMethodResolver, UrlGeneratorInterface $urlGenerator)

    {
        $this->resourceMetadataFactory = $resourceMetadataFactory;
        $this->propertyNameCollectionFactory = $propertyNameCollectionFactory;
        $this->propertyMetadataFactory = $propertyMetadataFactory;
        $this->resourceClassResolver = $resourceClassResolver;
        $this->operationMethodResolver = $operationMethodResolver;
        $this->urlGenerator = $urlGenerator;
    }

    /**
     * {@inheritdoc}
     */
    public function normalize($object, $format = null, array $context = [])
    {
        $classes = [];
        $entrypointProperties = [];

        foreach ($object->getResourceNameCollection() as $resourceClass) {
            $resourceMetadata = $this->resourceMetadataFactory->create($resourceClass);
            $shortName = $resourceMetadata->getShortName();
            $prefixedShortName = $resourceMetadata->getIri() ?? "#$shortName";

            $this->populateEntrypointProperties($resourceClass, $resourceMetadata, $shortName, $prefixedShortName, $entrypointProperties);
            $classes[] = $this->getClass($resourceClass, $resourceMetadata, $shortName, $prefixedShortName);
        }

        return $this->computeDoc($object, $this->getClasses($entrypointProperties, $classes));
    }

    /**
     * Populates entrypoint properties.
     *
     * @param string           $resourceClass
     * @param ResourceMetadata $resourceMetadata
     * @param string           $shortName
     * @param string           $prefixedShortName
     * @param array            $entrypointProperties
     */
    private function populateEntrypointProperties(string $resourceClass, ResourceMetadata $resourceMetadata, string $shortName, string $prefixedShortName, array &$entrypointProperties)
    {
        $hydraCollectionOperations = $this->getHydraOperations($resourceClass, $resourceMetadata, $prefixedShortName, true);
        if (empty($hydraCollectionOperations)) {
            return;
        }

        $entrypointProperties[] = [
            '@type' => 'hydra:SupportedProperty',
            'hydra:property' => [
                '@id' => sprintf('#Entrypoint/%s', lcfirst($shortName)),
                '@type' => 'hydra:Link',
                'domain' => '#Entrypoint',
                'rdfs:label' => "The collection of $shortName resources",
                'rdfs:range' => [
                    'hydra:Collection',
                    [
                        'owl:equivalentClass' => [
                            'owl:onProperty' => 'hydra:member',
                            'owl:allValuesFrom' => "#$shortName",
                        ],
                    ],
                ],
                'hydra:supportedOperation' => $hydraCollectionOperations,
            ],
            'hydra:title' => "The collection of $shortName resources",
            'hydra:readable' => true,
            'hydra:writable' => false,
        ];
    }

    /**
     * Gets a Hydra class.
     *
     * @param string           $resourceClass
     * @param ResourceMetadata $resourceMetadata
     * @param string           $shortName
     * @param string           $prefixedShortName
     *
     * @return array
     */
    private function getClass(string $resourceClass, ResourceMetadata $resourceMetadata, string $shortName, string $prefixedShortName): array
    {
        $class = [
            '@id' => $prefixedShortName,
            '@type' => 'hydra:Class',
            'rdfs:label' => $shortName,
            'hydra:title' => $shortName,
            'hydra:supportedProperty' => $this->getHydraProperties($resourceClass, $resourceMetadata, $shortName, $prefixedShortName),
            'hydra:supportedOperation' => $this->getHydraOperations($resourceClass, $resourceMetadata, $prefixedShortName, false),
        ];

        if (null !== $description = $resourceMetadata->getDescription()) {
            $class['hydra:description'] = $description;
        }

        return $class;
    }

    /**
     * Gets the context for the property name factory.
     *
     * @param ResourceMetadata $resourceMetadata
     *
     * @return array
     */
    private function getPropertyNameCollectionFactoryContext(ResourceMetadata $resourceMetadata): array
    {
        $attributes = $resourceMetadata->getAttributes();
        $context = [];

        if (isset($attributes['normalization_context']['groups'])) {
            $context['serializer_groups'] = $attributes['normalization_context']['groups'];
        }

        if (isset($attributes['denormalization_context']['groups'])) {
            if (isset($context['serializer_groups'])) {
                $context['serializer_groups'] += $attributes['denormalization_context']['groups'];
            } else {
                $context['serializer_groups'] = $attributes['denormalization_context']['groups'];
            }
        }

        return $context;
    }

    /**
     * Gets Hydra properties.
     *
     * @param string           $resourceClass
     * @param ResourceMetadata $resourceMetadata
     * @param string           $shortName
     * @param string           $prefixedShortName
     *
     * @return array
     */
    private function getHydraProperties(string $resourceClass, ResourceMetadata $resourceMetadata, string $shortName, string $prefixedShortName): array
    {
        $properties = [];
        foreach ($this->propertyNameCollectionFactory->create($resourceClass, $this->getPropertyNameCollectionFactoryContext($resourceMetadata)) as $propertyName) {
            $propertyMetadata = $this->propertyMetadataFactory->create($resourceClass, $propertyName);
            if (true === $propertyMetadata->isIdentifier() && false === $propertyMetadata->isWritable()) {
                continue;
            }

            $properties[] = $this->getProperty($propertyMetadata, $propertyName, $prefixedShortName, $shortName);
        }

        return $properties;
    }

    /**
     * Gets Hydra operations.
     *
     * @param string           $resourceClass
     * @param ResourceMetadata $resourceMetadata
     * @param string           $prefixedShortName
     * @param bool             $collection
     *
     * @return array
     */
    private function getHydraOperations(string $resourceClass, ResourceMetadata $resourceMetadata, string $prefixedShortName, bool $collection): array
    {
        if (null === $operations = $collection ? $resourceMetadata->getCollectionOperations() : $resourceMetadata->getItemOperations()) {
            return [];
        }

        $hydraOperations = [];
        foreach ($operations as $operationName => $operation) {
            $hydraOperations[] = $this->getHydraOperation($resourceClass, $resourceMetadata, $operationName, $operation, $prefixedShortName, $collection);
        }

        return $hydraOperations;
    }

    /**
     * Gets and populates if applicable a Hydra operation.
     *
     * @param string           $resourceClass
     * @param ResourceMetadata $resourceMetadata
     * @param string           $operationName
     * @param array            $operation
     * @param string           $prefixedShortName
     * @param bool             $collection
     *
     * @return array
     */
    private function getHydraOperation(string $resourceClass, ResourceMetadata $resourceMetadata, string $operationName, array $operation, string $prefixedShortName, bool $collection): array
    {
        if ($collection) {
            $method = $this->operationMethodResolver->getCollectionOperationMethod($resourceClass, $operationName);
        } else {
            $method = $this->operationMethodResolver->getItemOperationMethod($resourceClass, $operationName);
        }

        $hydraOperation = $operation['hydra_context'] ?? [];
        $shortName = $resourceMetadata->getShortName();

        if ('GET' === $method && $collection) {
            $hydraOperation = [
                '@type' => ['hydra:Operation', 'schema:FindAction'],
                'hydra:title' => "Retrieves the collection of $shortName resources.",
                'returns' => 'hydra:Collection',
            ] + $hydraOperation;
        } elseif ('GET' === $method) {
            $hydraOperation = [
                '@type' => ['hydra:Operation', 'schema:FindAction'],
                'hydra:title' => "Retrieves $shortName resource.",
                'returns' => $prefixedShortName,
            ] + $hydraOperation;
        } elseif ('POST' === $method) {
            $hydraOperation = [
                '@type' => ['hydra:Operation', 'schema:CreateAction'],
                'hydra:title' => "Creates a $shortName resource.",
                'returns' => $prefixedShortName,
                'expects' => $prefixedShortName,
            ] + $hydraOperation;
        } elseif ('PUT' === $method) {

            $hydraOperation = [
                '@type' => ['hydra:Operation', 'schema:ReplaceAction'],
                'hydra:title' => "Replaces the $shortName resource.",
                'returns' => $prefixedShortName,
                'expects' => $prefixedShortName,
            ] + $hydraOperation;
        } elseif ('DELETE' === $method) {
            $hydraOperation = [
                '@type' => ['hydra:Operation', 'schema:DeleteAction'],
                'hydra:title' => "Deletes the $shortName resource.",
                'returns' => 'owl:Nothing',
            ] + $hydraOperation;
        }

        $hydraOperation['hydra:method'] ?? $hydraOperation['hydra:method'] = $method;

        if (!isset($hydraOperation['rdfs:label']) && isset($hydraOperation['hydra:title'])) {
            $hydraOperation['rdfs:label'] = $hydraOperation['hydra:title'];
        }

        ksort($hydraOperation);

        return $hydraOperation;
    }

    /**
     * Gets the range of the property.
     *
     * @param PropertyMetadata $propertyMetadata
     *
     * @return string|null
     */
    private function getRange(PropertyMetadata $propertyMetadata)
    {
        $jsonldContext = $propertyMetadata->getAttributes()['jsonld_context'] ?? [];

        if (isset($jsonldContext['@type'])) {
            return $jsonldContext['@type'];
        }

        if (null === $type = $propertyMetadata->getType()) {
            return null;
        }

        if ($type->isCollection() && null !== $collectionType = $type->getCollectionValueType()) {
            $type = $collectionType;
        }

        switch ($type->getBuiltinType()) {
            case Type::BUILTIN_TYPE_STRING:
                return 'xmls:string';
            case Type::BUILTIN_TYPE_INT:
                return 'xmls:integer';
            case Type::BUILTIN_TYPE_FLOAT:
                return 'xmls:decimal';
            case Type::BUILTIN_TYPE_BOOL:
                return 'xmls:boolean';
            case Type::BUILTIN_TYPE_OBJECT:
                if (null === $className = $type->getClassName()) {
                    return null;
                }

                if (is_a($className, \DateTimeInterface::class, true)) {
                    return 'xmls:dateTime';
                }

                if ($this->resourceClassResolver->isResourceClass($className)) {
                    $resourceMetadata = $this->resourceMetadataFactory->create($className);

                    return $resourceMetadata->getIri() ?? "#{$resourceMetadata->getShortName()}";
                }
                break;
        }
    }

    /**
     * Builds the classes array.
     *
     * @param array $entrypointProperties
     * @param array $classes
     *
     * @return array
     */
    private function getClasses(array $entrypointProperties, array $classes): array
    {
        $classes[] = [
            '@id' => '#Entrypoint',
            '@type' => 'hydra:Class',
            'hydra:title' => 'The API entrypoint',
            'hydra:supportedProperty' => $entrypointProperties,
            'hydra:supportedOperation' => [
                '@type' => 'hydra:Operation',
                'hydra:method' => 'GET',
                'rdfs:label' => 'The API entrypoint.',
                'returns' => '#EntryPoint',
            ],
        ];

        // Constraint violation
        $classes[] = [
            '@id' => '#ConstraintViolation',
            '@type' => 'hydra:Class',
            'hydra:title' => 'A constraint violation',
            'hydra:supportedProperty' => [
                [
                    '@type' => 'hydra:SupportedProperty',
                    'hydra:property' => [
                        '@id' => '#ConstraintViolation/propertyPath',
                        '@type' => 'rdf:Property',
                        'rdfs:label' => 'propertyPath',
                        'domain' => '#ConstraintViolation',
                        'range' => 'xmls:string',
                    ],
                    'hydra:title' => 'propertyPath',
                    'hydra:description' => 'The property path of the violation',
                    'hydra:readable' => true,
                    'hydra:writable' => false,
                ],
                [
                    '@type' => 'hydra:SupportedProperty',
                    'hydra:property' => [
                        '@id' => '#ConstraintViolation/message',
                        '@type' => 'rdf:Property',
                        'rdfs:label' => 'message',
                        'domain' => '#ConstraintViolation',
                        'range' => 'xmls:string',
                    ],
                    'hydra:title' => 'message',
                    'hydra:description' => 'The message associated with the violation',
                    'hydra:readable' => true,
                    'hydra:writable' => false,
                ],
            ],
        ];

        // Constraint violation list
        $classes[] = [
            '@id' => '#ConstraintViolationList',
            '@type' => 'hydra:Class',
            'subClassOf' => 'hydra:Error',
            'hydra:title' => 'A constraint violation list',
            'hydra:supportedProperty' => [
                [
                    '@type' => 'hydra:SupportedProperty',
                    'hydra:property' => [
                        '@id' => '#ConstraintViolationList/violations',
                        '@type' => 'rdf:Property',
                        'rdfs:label' => 'violations',
                        'domain' => '#ConstraintViolationList',
                        'range' => '#ConstraintViolation',
                    ],
                    'hydra:title' => 'violations',
                    'hydra:description' => 'The violations',
                    'hydra:readable' => true,
                    'hydra:writable' => false,
                ],
            ],
        ];

        return $classes;
    }

    /**
     * Gets a property definition.
     *
     * @param PropertyMetadata $propertyMetadata
     * @param string           $propertyName
     * @param string           $prefixedShortName
     * @param string           $shortName
     *
     * @return array
     */
    private function getProperty(PropertyMetadata $propertyMetadata, string $propertyName, string $prefixedShortName, string $shortName): array
    {
        $propertyData = [
            '@id' => $propertyMetadata->getIri() ?? "#$shortName/$propertyName",
            '@type' => $propertyMetadata->isReadableLink() ? 'rdf:Property' : 'hydra:Link',
            'rdfs:label' => $propertyName,
            'domain' => $prefixedShortName,
        ];

        $type = $propertyMetadata->getType();

        if (null !== $type && !$type->isCollection() && (null !== $className = $type->getClassName()) && $this->resourceClassResolver->isResourceClass($className)) {
            $propertyData['owl:maxCardinality'] = 1;
        }

        $property = [
            '@type' => 'hydra:SupportedProperty',
            'hydra:property' => $propertyData,
            'hydra:title' => $propertyName,
            'hydra:required' => $propertyMetadata->isRequired(),
            'hydra:readable' => $propertyMetadata->isReadable(),
            'hydra:writable' => $propertyMetadata->isWritable(),
        ];

        if (null !== $range = $this->getRange($propertyMetadata)) {
            $property['hydra:property']['range'] = $range;
        }

        if (null !== $description = $propertyMetadata->getDescription()) {
            $property['hydra:description'] = $description;
        }

        return $property;
    }

    /**
     * Computes the documentation.
     *
     * @param Documentation $object
     * @param array         $classes
     *
     * @return array
     */
    private function computeDoc(Documentation $object, array $classes): array
    {
        $doc = ['@context' => $this->getContext(), '@id' => $this->urlGenerator->generate('api_doc', ['_format' => self::FORMAT]), '@type' => 'hydra:ApiDocumentation'];

        if ('' !== $object->getTitle()) {
            $doc['hydra:title'] = $object->getTitle();
        }

        if ('' !== $object->getDescription()) {
            $doc['hydra:description'] = $object->getDescription();
        }

        $doc['hydra:entrypoint'] = $this->urlGenerator->generate('api_entrypoint');
        $doc['hydra:supportedClass'] = $classes;

        return $doc;
    }

    /**
     * Builds the JSON-LD context for the API documentation.
     *
     * @return array
     */
    private function getContext(): array
    {
        return [
            '@vocab' => $this->urlGenerator->generate('api_doc', ['_format' => self::FORMAT], UrlGeneratorInterface::ABS_URL).'#',
            'hydra' => ContextBuilderInterface::HYDRA_NS,
            'rdf' => ContextBuilderInterface::RDF_NS,
            'rdfs' => ContextBuilderInterface::RDFS_NS,
            'xmls' => ContextBuilderInterface::XML_NS,
            'owl' => ContextBuilderInterface::OWL_NS,
            'schema' => ContextBuilderInterface::SCHEMA_ORG_NS,
            'domain' => ['@id' => 'rdfs:domain', '@type' => '@id'],
            'range' => ['@id' => 'rdfs:range', '@type' => '@id'],
            'subClassOf' => ['@id' => 'rdfs:subClassOf', '@type' => '@id'],
            'expects' => ['@id' => 'hydra:expects', '@type' => '@id'],
            'returns' => ['@id' => 'hydra:returns', '@type' => '@id'],
        ];
    }

    /**
     * {@inheritdoc}
     */
    public function supportsNormalization($data, $format = null, array $context = [])
    {
        return self::FORMAT === $format && $data instanceof Documentation;
    }
}


1		<?php
2
3		/*
4		* This file is part of the API Platform project.
5		*
6		* (c) Kévin Dunglas <[email protected]>
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\Hydra\Serializer;
15
16		use ApiPlatform\Core\Api\OperationMethodResolverInterface;
17		use ApiPlatform\Core\Api\ResourceClassResolverInterface;
18		use ApiPlatform\Core\Api\UrlGeneratorInterface;
19		use ApiPlatform\Core\Documentation\Documentation;
20		use ApiPlatform\Core\JsonLd\ContextBuilderInterface;
21		use ApiPlatform\Core\Metadata\Property\Factory\PropertyMetadataFactoryInterface;
22		use ApiPlatform\Core\Metadata\Property\Factory\PropertyNameCollectionFactoryInterface;
23		use ApiPlatform\Core\Metadata\Property\PropertyMetadata;
24		use ApiPlatform\Core\Metadata\Resource\Factory\ResourceMetadataFactoryInterface;
25		use ApiPlatform\Core\Metadata\Resource\ResourceMetadata;
26		use Symfony\Component\PropertyInfo\Type;
27		use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
28
29		/**
30		* Creates a machine readable Hydra API documentation.
31		*
32		* @author Kévin Dunglas <[email protected]>
33		*/
34		final class DocumentationNormalizer implements NormalizerInterface
35		{
36		const FORMAT = 'jsonld';
37
38		private $resourceMetadataFactory;
39		private $propertyNameCollectionFactory;
40		private $propertyMetadataFactory;
41		private $resourceClassResolver;
42		private $operationMethodResolver;
43		private $urlGenerator;
44
45	View Code Duplication	public function __construct(ResourceMetadataFactoryInterface $resourceMetadataFactory, PropertyNameCollectionFactoryInterface $propertyNameCollectionFactory, PropertyMetadataFactoryInterface $propertyMetadataFactory, ResourceClassResolverInterface $resourceClassResolver, OperationMethodResolverInterface $operationMethodResolver, UrlGeneratorInterface $urlGenerator)
		0 ignored issues – show Duplication introduced 2017-04-19 17:13 UTC by Report Bug Copy Issue Report Show Similar Issues like this 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...
46		{
47		$this->resourceMetadataFactory = $resourceMetadataFactory;
48		$this->propertyNameCollectionFactory = $propertyNameCollectionFactory;
49		$this->propertyMetadataFactory = $propertyMetadataFactory;
50		$this->resourceClassResolver = $resourceClassResolver;
51		$this->operationMethodResolver = $operationMethodResolver;
52		$this->urlGenerator = $urlGenerator;
53		}
54
55		/**
56		* {@inheritdoc}
57		*/
58		public function normalize($object, $format = null, array $context = [])
59		{
60		$classes = [];
61		$entrypointProperties = [];
62
63		foreach ($object->getResourceNameCollection() as $resourceClass) {
64		$resourceMetadata = $this->resourceMetadataFactory->create($resourceClass);
65		$shortName = $resourceMetadata->getShortName();
66		$prefixedShortName = $resourceMetadata->getIri() ?? "#$shortName";
67
68		$this->populateEntrypointProperties($resourceClass, $resourceMetadata, $shortName, $prefixedShortName, $entrypointProperties);
69		$classes[] = $this->getClass($resourceClass, $resourceMetadata, $shortName, $prefixedShortName);
70		}
71
72		return $this->computeDoc($object, $this->getClasses($entrypointProperties, $classes));
73		}
74
75		/**
76		* Populates entrypoint properties.
77		*
78		* @param string $resourceClass
79		* @param ResourceMetadata $resourceMetadata
80		* @param string $shortName
81		* @param string $prefixedShortName
82		* @param array $entrypointProperties
83		*/
84		private function populateEntrypointProperties(string $resourceClass, ResourceMetadata $resourceMetadata, string $shortName, string $prefixedShortName, array &$entrypointProperties)
85		{
86		$hydraCollectionOperations = $this->getHydraOperations($resourceClass, $resourceMetadata, $prefixedShortName, true);
87		if (empty($hydraCollectionOperations)) {
88		return;
89		}
90
91		$entrypointProperties[] = [
92		'@type' => 'hydra:SupportedProperty',
93		'hydra:property' => [
94		'@id' => sprintf('#Entrypoint/%s', lcfirst($shortName)),
95		'@type' => 'hydra:Link',
96		'domain' => '#Entrypoint',
97		'rdfs:label' => "The collection of $shortName resources",
98		'rdfs:range' => [
99		'hydra:Collection',
100		[
101		'owl:equivalentClass' => [
102		'owl:onProperty' => 'hydra:member',
103		'owl:allValuesFrom' => "#$shortName",
104		],
105		],
106		],
107		'hydra:supportedOperation' => $hydraCollectionOperations,
108		],
109		'hydra:title' => "The collection of $shortName resources",
110		'hydra:readable' => true,
111		'hydra:writable' => false,
112		];
113		}
114
115		/**
116		* Gets a Hydra class.
117		*
118		* @param string $resourceClass
119		* @param ResourceMetadata $resourceMetadata
120		* @param string $shortName
121		* @param string $prefixedShortName
122		*
123		* @return array
124		*/
125		private function getClass(string $resourceClass, ResourceMetadata $resourceMetadata, string $shortName, string $prefixedShortName): array
126		{
127		$class = [
128		'@id' => $prefixedShortName,
129		'@type' => 'hydra:Class',
130		'rdfs:label' => $shortName,
131		'hydra:title' => $shortName,
132		'hydra:supportedProperty' => $this->getHydraProperties($resourceClass, $resourceMetadata, $shortName, $prefixedShortName),
133		'hydra:supportedOperation' => $this->getHydraOperations($resourceClass, $resourceMetadata, $prefixedShortName, false),
134		];
135
136		if (null !== $description = $resourceMetadata->getDescription()) {
137		$class['hydra:description'] = $description;
138		}
139
140		return $class;
141		}
142
143		/**
144		* Gets the context for the property name factory.
145		*
146		* @param ResourceMetadata $resourceMetadata
147		*
148		* @return array
149		*/
150		private function getPropertyNameCollectionFactoryContext(ResourceMetadata $resourceMetadata): array
151		{
152		$attributes = $resourceMetadata->getAttributes();
153		$context = [];
154
155	View Code Duplication	if (isset($attributes['normalization_context']['groups'])) {
156		$context['serializer_groups'] = $attributes['normalization_context']['groups'];
157		}
158
159		if (isset($attributes['denormalization_context']['groups'])) {
160	View Code Duplication	if (isset($context['serializer_groups'])) {
161		$context['serializer_groups'] += $attributes['denormalization_context']['groups'];
162		} else {
163		$context['serializer_groups'] = $attributes['denormalization_context']['groups'];
164		}
165		}
166
167		return $context;
168		}
169
170		/**
171		* Gets Hydra properties.
172		*
173		* @param string $resourceClass
174		* @param ResourceMetadata $resourceMetadata
175		* @param string $shortName
176		* @param string $prefixedShortName
177		*
178		* @return array
179		*/
180		private function getHydraProperties(string $resourceClass, ResourceMetadata $resourceMetadata, string $shortName, string $prefixedShortName): array
181		{
182		$properties = [];
183		foreach ($this->propertyNameCollectionFactory->create($resourceClass, $this->getPropertyNameCollectionFactoryContext($resourceMetadata)) as $propertyName) {
184		$propertyMetadata = $this->propertyMetadataFactory->create($resourceClass, $propertyName);
185		if (true === $propertyMetadata->isIdentifier() && false === $propertyMetadata->isWritable()) {
186		continue;
187		}
188
189		$properties[] = $this->getProperty($propertyMetadata, $propertyName, $prefixedShortName, $shortName);
190		}
191
192		return $properties;
193		}
194
195		/**
196		* Gets Hydra operations.
197		*
198		* @param string $resourceClass
199		* @param ResourceMetadata $resourceMetadata
200		* @param string $prefixedShortName
201		* @param bool $collection
202		*
203		* @return array
204		*/
205		private function getHydraOperations(string $resourceClass, ResourceMetadata $resourceMetadata, string $prefixedShortName, bool $collection): array
206		{
207		if (null === $operations = $collection ? $resourceMetadata->getCollectionOperations() : $resourceMetadata->getItemOperations()) {
208		return [];
209		}
210
211		$hydraOperations = [];
212		foreach ($operations as $operationName => $operation) {
213		$hydraOperations[] = $this->getHydraOperation($resourceClass, $resourceMetadata, $operationName, $operation, $prefixedShortName, $collection);
214		}
215
216		return $hydraOperations;
217		}
218
219		/**
220		* Gets and populates if applicable a Hydra operation.
221		*
222		* @param string $resourceClass
223		* @param ResourceMetadata $resourceMetadata
224		* @param string $operationName
225		* @param array $operation
226		* @param string $prefixedShortName
227		* @param bool $collection
228		*
229		* @return array
230		*/
231		private function getHydraOperation(string $resourceClass, ResourceMetadata $resourceMetadata, string $operationName, array $operation, string $prefixedShortName, bool $collection): array
232		{
233		if ($collection) {
234		$method = $this->operationMethodResolver->getCollectionOperationMethod($resourceClass, $operationName);
235		} else {
236		$method = $this->operationMethodResolver->getItemOperationMethod($resourceClass, $operationName);
237		}
238
239		$hydraOperation = $operation['hydra_context'] ?? [];
240		$shortName = $resourceMetadata->getShortName();
241
242		if ('GET' === $method && $collection) {
243		$hydraOperation = [
244		'@type' => ['hydra:Operation', 'schema:FindAction'],
245		'hydra:title' => "Retrieves the collection of $shortName resources.",
246		'returns' => 'hydra:Collection',
247		] + $hydraOperation;
248	View Code Duplication	} elseif ('GET' === $method) {
249		$hydraOperation = [
250		'@type' => ['hydra:Operation', 'schema:FindAction'],
251		'hydra:title' => "Retrieves $shortName resource.",
252		'returns' => $prefixedShortName,
253		] + $hydraOperation;
254		} elseif ('POST' === $method) {
255		$hydraOperation = [
256		'@type' => ['hydra:Operation', 'schema:CreateAction'],
257		'hydra:title' => "Creates a $shortName resource.",
258		'returns' => $prefixedShortName,
259		'expects' => $prefixedShortName,
260		] + $hydraOperation;
261	View Code Duplication	} elseif ('PUT' === $method) {
		0 ignored issues – show Duplication introduced 2017-04-08 20:58 UTC by Report Bug Copy Issue Report Show Similar Issues like this This code seems to be duplicated across 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...
262		$hydraOperation = [
263		'@type' => ['hydra:Operation', 'schema:ReplaceAction'],
264		'hydra:title' => "Replaces the $shortName resource.",
265		'returns' => $prefixedShortName,
266		'expects' => $prefixedShortName,
267		] + $hydraOperation;
268		} elseif ('DELETE' === $method) {
269		$hydraOperation = [
270		'@type' => ['hydra:Operation', 'schema:DeleteAction'],
271		'hydra:title' => "Deletes the $shortName resource.",
272		'returns' => 'owl:Nothing',
273		] + $hydraOperation;
274		}
275
276		$hydraOperation['hydra:method'] ?? $hydraOperation['hydra:method'] = $method;
277
278		if (!isset($hydraOperation['rdfs:label']) && isset($hydraOperation['hydra:title'])) {
279		$hydraOperation['rdfs:label'] = $hydraOperation['hydra:title'];
280		}
281
282		ksort($hydraOperation);
283
284		return $hydraOperation;
285		}
286
287		/**
288		* Gets the range of the property.
289		*
290		* @param PropertyMetadata $propertyMetadata
291		*
292		* @return string\|null
293		*/
294		private function getRange(PropertyMetadata $propertyMetadata)
295		{
296		$jsonldContext = $propertyMetadata->getAttributes()['jsonld_context'] ?? [];
297
298		if (isset($jsonldContext['@type'])) {
299		return $jsonldContext['@type'];
300		}
301
302		if (null === $type = $propertyMetadata->getType()) {
303		return null;
304		}
305
306		if ($type->isCollection() && null !== $collectionType = $type->getCollectionValueType()) {
307		$type = $collectionType;
308		}
309
310		switch ($type->getBuiltinType()) {
311		case Type::BUILTIN_TYPE_STRING:
312		return 'xmls:string';
313		case Type::BUILTIN_TYPE_INT:
314		return 'xmls:integer';
315		case Type::BUILTIN_TYPE_FLOAT:
316		return 'xmls:decimal';
317		case Type::BUILTIN_TYPE_BOOL:
318		return 'xmls:boolean';
319		case Type::BUILTIN_TYPE_OBJECT:
320		if (null === $className = $type->getClassName()) {
321		return null;
322		}
323
324		if (is_a($className, \DateTimeInterface::class, true)) {
325		return 'xmls:dateTime';
326		}
327
328		if ($this->resourceClassResolver->isResourceClass($className)) {
329		$resourceMetadata = $this->resourceMetadataFactory->create($className);
330
331		return $resourceMetadata->getIri() ?? "#{$resourceMetadata->getShortName()}";
332		}
333		break;
334		}
335		}
336
337		/**
338		* Builds the classes array.
339		*
340		* @param array $entrypointProperties
341		* @param array $classes
342		*
343		* @return array
344		*/
345		private function getClasses(array $entrypointProperties, array $classes): array
346		{
347		$classes[] = [
348		'@id' => '#Entrypoint',
349		'@type' => 'hydra:Class',
350		'hydra:title' => 'The API entrypoint',
351		'hydra:supportedProperty' => $entrypointProperties,
352		'hydra:supportedOperation' => [
353		'@type' => 'hydra:Operation',
354		'hydra:method' => 'GET',
355		'rdfs:label' => 'The API entrypoint.',
356		'returns' => '#EntryPoint',
357		],
358		];
359
360		// Constraint violation
361		$classes[] = [
362		'@id' => '#ConstraintViolation',
363		'@type' => 'hydra:Class',
364		'hydra:title' => 'A constraint violation',
365		'hydra:supportedProperty' => [
366		[
367		'@type' => 'hydra:SupportedProperty',
368		'hydra:property' => [
369		'@id' => '#ConstraintViolation/propertyPath',
370		'@type' => 'rdf:Property',
371		'rdfs:label' => 'propertyPath',
372		'domain' => '#ConstraintViolation',
373		'range' => 'xmls:string',
374		],
375		'hydra:title' => 'propertyPath',
376		'hydra:description' => 'The property path of the violation',
377		'hydra:readable' => true,
378		'hydra:writable' => false,
379		],
380		[
381		'@type' => 'hydra:SupportedProperty',
382		'hydra:property' => [
383		'@id' => '#ConstraintViolation/message',
384		'@type' => 'rdf:Property',
385		'rdfs:label' => 'message',
386		'domain' => '#ConstraintViolation',
387		'range' => 'xmls:string',
388		],
389		'hydra:title' => 'message',
390		'hydra:description' => 'The message associated with the violation',
391		'hydra:readable' => true,
392		'hydra:writable' => false,
393		],
394		],
395		];
396
397		// Constraint violation list
398		$classes[] = [
399		'@id' => '#ConstraintViolationList',
400		'@type' => 'hydra:Class',
401		'subClassOf' => 'hydra:Error',
402		'hydra:title' => 'A constraint violation list',
403		'hydra:supportedProperty' => [
404		[
405		'@type' => 'hydra:SupportedProperty',
406		'hydra:property' => [
407		'@id' => '#ConstraintViolationList/violations',
408		'@type' => 'rdf:Property',
409		'rdfs:label' => 'violations',
410		'domain' => '#ConstraintViolationList',
411		'range' => '#ConstraintViolation',
412		],
413		'hydra:title' => 'violations',
414		'hydra:description' => 'The violations',
415		'hydra:readable' => true,
416		'hydra:writable' => false,
417		],
418		],
419		];
420
421		return $classes;
422		}
423
424		/**
425		* Gets a property definition.
426		*
427		* @param PropertyMetadata $propertyMetadata
428		* @param string $propertyName
429		* @param string $prefixedShortName
430		* @param string $shortName
431		*
432		* @return array
433		*/
434		private function getProperty(PropertyMetadata $propertyMetadata, string $propertyName, string $prefixedShortName, string $shortName): array
435		{
436		$propertyData = [
437		'@id' => $propertyMetadata->getIri() ?? "#$shortName/$propertyName",
438		'@type' => $propertyMetadata->isReadableLink() ? 'rdf:Property' : 'hydra:Link',
439		'rdfs:label' => $propertyName,
440		'domain' => $prefixedShortName,
441		];
442
443		$type = $propertyMetadata->getType();
444
445		if (null !== $type && !$type->isCollection() && (null !== $className = $type->getClassName()) && $this->resourceClassResolver->isResourceClass($className)) {
446		$propertyData['owl:maxCardinality'] = 1;
447		}
448
449		$property = [
450		'@type' => 'hydra:SupportedProperty',
451		'hydra:property' => $propertyData,
452		'hydra:title' => $propertyName,
453		'hydra:required' => $propertyMetadata->isRequired(),
454		'hydra:readable' => $propertyMetadata->isReadable(),
455		'hydra:writable' => $propertyMetadata->isWritable(),
456		];
457
458		if (null !== $range = $this->getRange($propertyMetadata)) {
459		$property['hydra:property']['range'] = $range;
460		}
461
462		if (null !== $description = $propertyMetadata->getDescription()) {
463		$property['hydra:description'] = $description;
464		}
465
466		return $property;
467		}
468
469		/**
470		* Computes the documentation.
471		*
472		* @param Documentation $object
473		* @param array $classes
474		*
475		* @return array
476		*/
477		private function computeDoc(Documentation $object, array $classes): array
478		{
479		$doc = ['@context' => $this->getContext(), '@id' => $this->urlGenerator->generate('api_doc', ['_format' => self::FORMAT]), '@type' => 'hydra:ApiDocumentation'];
480
481		if ('' !== $object->getTitle()) {
482		$doc['hydra:title'] = $object->getTitle();
483		}
484
485		if ('' !== $object->getDescription()) {
486		$doc['hydra:description'] = $object->getDescription();
487		}
488
489		$doc['hydra:entrypoint'] = $this->urlGenerator->generate('api_entrypoint');
490		$doc['hydra:supportedClass'] = $classes;
491
492		return $doc;
493		}
494
495		/**
496		* Builds the JSON-LD context for the API documentation.
497		*
498		* @return array
499		*/
500		private function getContext(): array
501		{
502		return [
503		'@vocab' => $this->urlGenerator->generate('api_doc', ['_format' => self::FORMAT], UrlGeneratorInterface::ABS_URL).'#',
504		'hydra' => ContextBuilderInterface::HYDRA_NS,
505		'rdf' => ContextBuilderInterface::RDF_NS,
506		'rdfs' => ContextBuilderInterface::RDFS_NS,
507		'xmls' => ContextBuilderInterface::XML_NS,
508		'owl' => ContextBuilderInterface::OWL_NS,
509		'schema' => ContextBuilderInterface::SCHEMA_ORG_NS,
510		'domain' => ['@id' => 'rdfs:domain', '@type' => '@id'],
511		'range' => ['@id' => 'rdfs:range', '@type' => '@id'],
512		'subClassOf' => ['@id' => 'rdfs:subClassOf', '@type' => '@id'],
513		'expects' => ['@id' => 'hydra:expects', '@type' => '@id'],
514		'returns' => ['@id' => 'hydra:returns', '@type' => '@id'],
515		];
516		}
517
518		/**
519		* {@inheritdoc}
520		*/
521		public function supportsNormalization($data, $format = null, array $context = [])
522		{
523		return self::FORMAT === $format && $data instanceof Documentation;
524		}
525		}
526

api-platform / core

Push — master ( 0c3139...e3501a )

src/Hydra/Serializer/DocumentationNormalizer.php (2 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like