DoctrineResourceFlushTrait::gatherRelationResourceClasses() - Code Metrics - Inspection of "feat: publish updates to mercure when we clear cac..." - components-web-app/api-components-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed
Pull Request — main (#152)

by Daniel
created 2022-10-24 19:45 UTC
gatherRelationResourceClasses() A

↳ Parent: DoctrineResourceFlushTrait
Complexity

Conditions	5
Paths	4
Size

Total Lines	12
Code Lines	9
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	5
eloc	9
c	1
b	0
f	0
nc	4
nop	2
dl	0
loc	12
rs	9.6111
<?php

/*
 * This file is part of the Silverback API Components Bundle Project
 *
 * (c) Daniel West <[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 Silverback\ApiComponentsBundle\EventListener\Doctrine;

use ApiPlatform\Api\IriConverterInterface;
use ApiPlatform\Api\ResourceClassResolverInterface;
use ApiPlatform\Api\UrlGeneratorInterface;
use ApiPlatform\Exception\InvalidArgumentException;
use ApiPlatform\Metadata\GetCollection;
use Doctrine\Common\Util\ClassUtils;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\EntityRepository;
use Doctrine\ORM\Event\OnFlushEventArgs;
use Doctrine\ORM\Event\PreUpdateEventArgs;
use Doctrine\ORM\PersistentCollection;
use Doctrine\Persistence\ManagerRegistry;
use Doctrine\Persistence\ObjectRepository;
use Silverback\ApiComponentsBundle\Entity\Component\Collection;
use Silverback\ApiComponentsBundle\Entity\Core\ComponentPosition;
use Silverback\ApiComponentsBundle\Entity\Core\PageDataInterface;
use Silverback\ApiComponentsBundle\HttpCache\ResourceChangedPropagatorInterface;
use Symfony\Component\PropertyAccess\PropertyAccess;
use Symfony\Component\PropertyAccess\PropertyAccessor;

trait DoctrineResourceFlushTrait
{
    private array $pageDataPropertiesChanged = [];
    private PropertyAccessor $propertyAccessor;
    private ObjectRepository|EntityRepository $collectionRepository;
    private ObjectRepository|EntityRepository $positionRepository;
    private array $resourceIris = [];

    public function __construct(
        private readonly IriConverterInterface $iriConverter,
        ManagerRegistry $entityManager,
        private readonly ResourceChangedPropagatorInterface $resourceChangedPropagator,
        private readonly ResourceClassResolverInterface $resourceClassResolver
    ) {
        $this->propertyAccessor = PropertyAccess::createPropertyAccessor();
        $this->collectionRepository = $entityManager->getRepository(Collection::class);
        $this->positionRepository = $entityManager->getRepository(ComponentPosition::class);
    }

    public function preUpdate(PreUpdateEventArgs $eventArgs): void
    {
        $object = $eventArgs->getObject();
        $this->collectUpdatedResource($object);

        $changeSet = $eventArgs->getEntityChangeSet();
        $associationMappings = $this->getAssociationMappings($eventArgs->getEntityManager(), $eventArgs->getObject());
        $associationMappings = $this->getAssociationMappings(/** @scrutinizer ignore-deprecated */ $eventArgs->getEntityManager(), $eventArgs->getObject());

        if ($object instanceof PageDataInterface) {
            $this->pageDataPropertiesChanged = array_keys($changeSet);
        }

        foreach ($changeSet as $field => $value) {
            if (!isset($associationMappings[$field])) {
                continue;
            }

            $this->collectUpdatedResource($value[0]);
            $this->collectUpdatedResource($value[1]);
        }
    }

    public function onFlush(OnFlushEventArgs $eventArgs): void
    {
        $em = $eventArgs->getObjectManager();
        $uow = $em->getUnitOfWork();
        $uow = $em->getUnitOfWork();

        foreach ($uow->getScheduledEntityInsertions() as $entity) {
            $this->collectUpdatedResource($entity, $em, true);
        }

        foreach ($uow->getScheduledEntityUpdates() as $entity) {
            $this->collectUpdatedResource($entity, $em, true);
        }

        foreach ($uow->getScheduledEntityDeletions() as $entity) {
            $this->collectUpdatedResource($entity, $em, true);
        }
    }

    public function postFlush(): void
    {
        $this->addResourcesToPurge($this->gatherResourcesForPositionsWithPageDataProperties());
        $this->addResourcesToPurge($this->gatherIrisForCollectionResources());
        $this->purgeResources();
    }

    private function gatherRelationResourceClasses(EntityManagerInterface $em, $entity): void
    {
        $associationMappings = $this->getAssociationMappings($em, $entity);
        foreach (array_keys($associationMappings) as $property) {
            if ($this->propertyAccessor->isReadable($entity, $property)) {
                $value = $this->propertyAccessor->getValue($entity, $property);
                if ($value instanceof PersistentCollection) {
                    foreach ($value as $item) {
                        $this->collectUpdatedResource($item);
                    }
                } else {
                    $this->collectUpdatedResource($value);
                }
            }
        }
    }

    private function gatherResourcesForPositionsWithPageDataProperties(): array
    {
        $positionResources = [];
        foreach ($this->pageDataPropertiesChanged as $pageDataProperty) {
            $positions = $this->positionRepository->findBy([
                'pageDataProperty' => $pageDataProperty,
            ]);
            foreach ($positions as $position) {
                $positionResources[] = $position;
            }
        }

        return $positionResources;
    }

    private function gatherIrisForCollectionResources(): array
    {
        if (empty($this->resourceIris)) {
            return [];
        }

        $collectionResources = [];
        foreach ($this->resourceIris as $resourceIri) {
            $collections = $this->collectionRepository->findBy([
                'resourceIri' => $resourceIri,
            ]);
            foreach ($collections as $collection) {
                $collectionResources[] = $collection;
            }
        }

        $this->resourceIris = [];
        if (empty($collectionResources)) {
            return [];
        }

        return $collectionResources;
    }

    private function getAssociationMappings(EntityManagerInterface $em, $entity): array
    {
        return $em->getClassMetadata(ClassUtils::getClass($entity))->getAssociationMappings();
    }

    private function collectUpdatedResource($resource, ?EntityManagerInterface $em = null, bool $gatherRelated = false): void
    {
        if (!$resource) {
            return;
        }
        $this->addResourceIris([$resource]);
        $this->resourceChangedPropagator?->collectItem($resource);
        if ($gatherRelated && $em) {
            $this->gatherRelationResourceClasses($em, $resource);
        }
    }

    private function addResourcesToPurge(array $resources): void
    {
        $this->addResourceIris($resources);
        $this->resourceChangedPropagator->collectItems($resources);
    }

    private function addResourceIris(array $resources): void
    {
        foreach ($resources as $resource) {
            try {
                $resourceClass = $this->resourceClassResolver->getResourceClass($resource);
                $resourceIri = $this->iriConverter->getIriFromResource($resourceClass, UrlGeneratorInterface::ABS_PATH, (new GetCollection())->withClass($resourceClass));

                if (!\in_array($resourceIri, $this->resourceIris, true)) {
                    $this->resourceIris[] = $resourceIri;
                }
            } catch (InvalidArgumentException $e) {}

        }
    }

    private function purgeResources(): void
    {
        $this->resourceChangedPropagator->propagate();
        $this->resourceIris = [];
    }
}

components-web-app / api-components-bundle

Pull Request — main (#152)

gatherRelationResourceClasses() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
