Silverback\ApiComponentsBundle\Metadata\Factory\ComponentUsageMetadataFactory

Complexity

Total Complexity

17

Size/Duplication

Total Lines	107
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
B	getPageDataTotal()	0	33	8
A	getPageDataLocations()	0	19	4
A	__construct()	0	13	1
A	findPageDataResourcesByPropertiesAndComponent()	0	17	3
A	create()	0	8	1

<?php

/*
 * This file is part of the Silverback API Components Bundle Project
 *
 * (c) Daniel West <daniel@silverback.is>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Silverback\ApiComponentsBundle\Metadata\Factory;

use ApiPlatform\Core\Metadata\Resource\Factory\ResourceMetadataFactoryInterface;
use ApiPlatform\Core\Metadata\Resource\Factory\ResourceNameCollectionFactoryInterface;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Proxy\Proxy;
use Doctrine\ORM\EntityManager;
use Doctrine\Persistence\ManagerRegistry;
use Silverback\ApiComponentsBundle\Entity\Core\ComponentInterface;
use Silverback\ApiComponentsBundle\Entity\Core\PageDataInterface;
use Silverback\ApiComponentsBundle\Metadata\ComponentUsageMetadata;
use Silverback\ApiComponentsBundle\Metadata\PageDataPropertyMetadata;
use Silverback\ApiComponentsBundle\Repository\Core\ComponentPositionRepository;
use Symfony\Component\PropertyAccess\PropertyAccess;
use Symfony\Component\PropertyAccess\PropertyAccessor;

/**
 * @author Daniel West <daniel@silverback.is>
 */
class ComponentUsageMetadataFactory
{
    private ResourceNameCollectionFactoryInterface $resourceNameCollectionFactory;
    private ResourceMetadataFactoryInterface $resourceMetadataFactory;
    private PageDataMetadataFactoryInterface $pageDataMetadataFactory;
    private ComponentPositionRepository $componentPositionRepository;
    private ManagerRegistry $managerRegistry;
    private PropertyAccessor $propertyAccessor;

    public function __construct(
        ResourceNameCollectionFactoryInterface $resourceNameCollectionFactory,
        ResourceMetadataFactoryInterface $resourceMetadataFactory,
        PageDataMetadataFactoryInterface $pageDataMetadataFactory,
        ComponentPositionRepository $componentPositionRepository,
        ManagerRegistry $managerRegistry
    ) {
        $this->resourceNameCollectionFactory = $resourceNameCollectionFactory;
        $this->resourceMetadataFactory = $resourceMetadataFactory;
        $this->pageDataMetadataFactory = $pageDataMetadataFactory;
        $this->componentPositionRepository = $componentPositionRepository;
        $this->managerRegistry = $managerRegistry;
        $this->propertyAccessor = PropertyAccess::createPropertyAccessor();
    }

    public function create(ComponentInterface $component): ComponentUsageMetadata
    {
        $componentPositions = $this->componentPositionRepository->findByComponent($component);
        $componentPositionCount = \count($componentPositions);

        $pageDataCount = $this->getPageDataTotal($component);

        return new ComponentUsageMetadata($componentPositionCount, $pageDataCount);
    }

    private function getPageDataTotal(ComponentInterface $component): ?int
    {
        // we want the SHORT NAME
        $resourceClass = \get_class($component);
        if ($component instanceof Proxy) {
            $em = $this->managerRegistry->getManagerForClass($resourceClass);
            if (!$em) {
                return null;
            }
            $resourceClass = $em->getClassMetadata($resourceClass)->getName();
        }
        $apiPlatformMetadata = $this->resourceMetadataFactory->create($resourceClass);
        $resourceShortName = $apiPlatformMetadata->getShortName();

        $pageDataLocations = $this->getPageDataLocations($resourceShortName);

It seems like $resourceShortName can also be of type null; however, parameter $resourceShortName of Silverback\ApiComponentsBundle\Metadata\Factory\ComponentUsageMetadataFactory::getPageDataLocations() does only seem to accept string, maybe add an additional type check?

        $pageDataCount = 0;
        foreach ($pageDataLocations as $pageDataClassName => $properties) {
            $pageDataResources = $this->findPageDataResourcesByPropertiesAndComponent($pageDataClassName, $properties, $component);
            if (!$pageDataResources) {
                continue;
            }
            $componentInDataCount = 0;
            foreach ($pageDataResources as $pageDataResource) {
                foreach ($properties as $property) {
                    if ($this->propertyAccessor->getValue($pageDataResource, $property) === $component) {
                        ++$componentInDataCount;
                    }
                }
            }
            $pageDataCount += $componentInDataCount;
        }

        return $pageDataCount;
    }

    private function findPageDataResourcesByPropertiesAndComponent(string $pageDataClassName, ArrayCollection $properties, ComponentInterface $component): ?array
    {
        $em = $this->managerRegistry->getManagerForClass($pageDataClassName);
        if (!$em instanceof EntityManager) {
            return null;
        }
        $qb = $em->createQueryBuilder();
        $expr = $qb->expr();
        $qb
            ->select('pd')
            ->from($pageDataClassName, 'pd')
            ->setParameter('component', $component);
        foreach ($properties as $property) {
            $qb->orWhere($expr->eq('pd.' . $property, ':component'));
        }

        return $qb->getQuery()->getResult();

The expression return $qb->getQuery()->getResult() could return the type integer which is incompatible with the type-hinted return array|null. Consider adding an additional type-check to rule them out.

    }

    private function getPageDataLocations(string $resourceShortName): array
    {
        $pageDataLocations = [];
        foreach ($this->resourceNameCollectionFactory->create() as $pageDataResourceClass) {
            $reflectionClass = new \ReflectionClass($pageDataResourceClass);
            if (!$reflectionClass->implementsInterface(PageDataInterface::class)) {
                continue;
            }

            $pageDataMetadata = $this->pageDataMetadataFactory->create($pageDataResourceClass);
            $resourceProperties = $pageDataMetadata->findPropertiesByComponentClass($resourceShortName);
            if ($resourceProperties->count() > 0) {
                $pageDataLocations[$pageDataResourceClass] = $resourceProperties->map(static function (PageDataPropertyMetadata $metadata) {
                    return $metadata->getProperty();
                });
            }
        }

        return $pageDataLocations;
    }
}