ApiPlatform\Core\Bridge\Symfony\Routing\CachedIriConverter

Complexity

Total Complexity

21

Size/Duplication

Total Lines	144
Duplicated Lines	37.5 %

Coupling/Cohesion

Components	2
Dependencies	13

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	10	10	2
A	getItemFromIri()	0	4	1
A	getIriFromItem()	9	9	1
F	getIdentifiersFromItem()	35	85	16
A	getIriFromResourceClass()	0	4	1

<?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.
 */

namespace ApiPlatform\Core\Bridge\Symfony\Routing;

use ApiPlatform\Core\Api\IriConverterInterface;
use ApiPlatform\Core\Api\UrlGeneratorInterface;
use ApiPlatform\Core\Exception\CacheException;
use ApiPlatform\Core\Metadata\Property\Factory\PropertyMetadataFactoryInterface;
use ApiPlatform\Core\Metadata\Property\Factory\PropertyNameCollectionFactoryInterface;
use ApiPlatform\Core\Util\ClassInfoTrait;
use Psr\Cache\CacheException as CacheExceptionInterface;
use Psr\Cache\CacheItemPoolInterface;
use Symfony\Component\PropertyAccess\PropertyAccess;
use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
use Symfony\Component\Routing\RouterInterface;

/**
 * {@inheritdoc}
 *
 * @author Antoine Bluchet <soyuka@gmail.com>
 */
final class CachedIriConverter implements IriConverterInterface
{
    use ClassInfoTrait;
    use IriConverterTrait;

    const CACHE_KEY_PREFIX = 'iri_converter';

    private $propertyNameCollectionFactory;
    private $propertyMetadataFactory;
    private $routeNameResolver;
    private $router;
    private $propertyAccessor;
    private $cacheItemPool;
    private $decorated;

    public function __construct(PropertyNameCollectionFactoryInterface $propertyNameCollectionFactory, PropertyMetadataFactoryInterface $propertyMetadataFactory, RouteNameResolverInterface $routeNameResolver, RouterInterface $router, PropertyAccessorInterface $propertyAccessor = null, CacheItemPoolInterface $cacheItemPool, IriConverterInterface $decorated)

This method seems to be duplicated in your project.

    {
        $this->propertyNameCollectionFactory = $propertyNameCollectionFactory;
        $this->propertyMetadataFactory = $propertyMetadataFactory;
        $this->routeNameResolver = $routeNameResolver;
        $this->router = $router;
        $this->propertyAccessor = $propertyAccessor ?: PropertyAccess::createPropertyAccessor();
        $this->cacheItemPool = $cacheItemPool;
        $this->decorated = $decorated;
    }

    public function getItemFromIri(string $iri, array $context = [])
    {
        return $this->decorated->getItemFromIri($iri, $context);
    }

    /**
     * {@inheritdoc}
     */
    public function getIriFromItem($item, int $referenceType = UrlGeneratorInterface::ABS_PATH): string

This method seems to be duplicated in your project.

    {
        $resourceClass = $this->getObjectClass($item);
        $routeName = $this->routeNameResolver->getRouteName($resourceClass, false);

        $identifiers = $this->generateIdentifiersUrl($this->getIdentifiersFromItem($item));

        return $this->router->generate($routeName, ['id' => implode(';', $identifiers)], $referenceType);
    }

    /**
     * Find identifiers from an Item (Object).
     *
     * @param object $item
     *
     * @throws RuntimeException
     *
     * @return array
     */
    private function getIdentifiersFromItem($item): array
    {
        $identifiers = [];
        $resourceClass = $this->getObjectClass($item);

        $cacheKey = self::CACHE_KEY_PREFIX.md5($resourceClass);

        try {
            $cacheItem = $this->cacheItemPool->getItem($cacheKey);

            if ($cacheItem->isHit()) {
                foreach ($cacheItem->get() as $propertyName) {
                    $identifiers[$propertyName] = $this->propertyAccessor->getValue($item, $propertyName);

                    if (is_object($identifiers[$propertyName])) {
                        $relatedCacheKey = self::CACHE_KEY_PREFIX.md5($this->getObjectClass($identifiers[$propertyName]));

                        $cacheItem = $this->cacheItemPool->getItem($relatedCacheKey);

                        if (!$cacheItem->isHit()) {
                            throw new CacheException('No relation cache item founded, we need more cache to continue.');
                        }

                        $relatedItem = $identifiers[$propertyName];

                        unset($identifiers[$propertyName]);

                        // Because composite identifiers aren't allowed in this case, we can use the first identifier only
                        $identifiers[$propertyName] = $this->propertyAccessor->getValue($relatedItem, $cacheItem->get()[0]);
                    }
                }

                return $identifiers;
            }
        } catch (CacheExceptionInterface $e) {
            // do nothing
        }

        foreach ($this->propertyNameCollectionFactory->create($resourceClass) as $propertyName) {

This code seems to be duplicated across your project.

            $propertyMetadata = $this->propertyMetadataFactory->create($resourceClass, $propertyName);

            $identifier = $propertyMetadata->isIdentifier();
            if (null === $identifier || false === $identifier) {
                continue;
            }

            $identifiers[$propertyName] = $this->propertyAccessor->getValue($item, $propertyName);

            if (!is_object($identifiers[$propertyName])) {
                continue;
            }

            $relatedResourceClass = $this->getObjectClass($identifiers[$propertyName]);
            $relatedItem = $identifiers[$propertyName];

            unset($identifiers[$propertyName]);

            foreach ($this->propertyNameCollectionFactory->create($relatedResourceClass) as $relatedPropertyName) {
                $propertyMetadata = $this->propertyMetadataFactory->create($relatedResourceClass, $relatedPropertyName);

                if ($propertyMetadata->isIdentifier()) {
                    if (isset($identifiers[$propertyName])) {
                        throw new RuntimeException(sprintf('Composite identifiers not supported in "%s" through relation "%s" of "%s" used as identifier', $relatedResourceClass, $propertyName, $resourceClass));
                    }

                    $identifiers[$propertyName] = $this->propertyAccessor->getValue($relatedItem, $relatedPropertyName);
                }
            }

            if (!isset($identifiers[$propertyName])) {
                throw new RuntimeException(sprintf('No identifier found in "%s" through relation "%s" of "%s" used as identifier', $relatedResourceClass, $propertyName, $resourceClass));
            }
        }

        if (isset($cacheItem)) {
            try {
                $cacheItem->set(array_keys($identifiers));
                $this->cacheItemPool->save($cacheItem);
            } catch (CacheExceptionInterface $e) {
                // do nothing
            }
        }

        return $identifiers;
    }

    public function getIriFromResourceClass(string $resourceClass, int $referenceType = UrlGeneratorInterface::ABS_PATH): string
    {
        return $this->decorated->getIriFromResourceClass($resourceClass, $referenceType);
    }
}