PropagateUpdatesListener::refreshUpdatedEntities() - Code Metrics - Inspection of "Refactor so we only have 1 doctrine listener" - components-web-app/api-components-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — main ( a8d12f...4cb83a )

by Daniel
created 2022-11-12 16:37 UTC
PropagateUpdatesListener::refreshUpdatedEntities() A

↳ Parent: PropagateUpdatesListener
Complexity

Conditions	4
Paths	3
Size

Total Lines	7
Code Lines	5
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	20
Importance

Changes
Metric	Value
cc	4
eloc	5
c	0
b	0
f	0
nc	3
nop	1
dl	0
loc	7
ccs	0
cts	6
cp	0
crap	20
rs	10
<?php

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\EntityRepository;
use Doctrine\ORM\Event\OnFlushEventArgs;
use Doctrine\ORM\Event\PostFlushEventArgs;
use Doctrine\ORM\PersistentCollection;
use Doctrine\ORM\UnitOfWork;
use Doctrine\Persistence\ManagerRegistry;
use Doctrine\Persistence\ObjectManager;
use Doctrine\Persistence\ObjectRepository;
use Silverback\ApiComponentsBundle\DataProvider\PageDataProvider;
use Silverback\ApiComponentsBundle\Entity\Component\Collection;
use Silverback\ApiComponentsBundle\Entity\Core\PageDataInterface;
use Silverback\ApiComponentsBundle\HttpCache\ResourceChangedPropagatorInterface;
use Silverback\ApiComponentsBundle\Repository\Core\ComponentPositionRepository;
use Symfony\Component\PropertyAccess\PropertyAccess;
use Symfony\Component\PropertyAccess\PropertyAccessor;

class PropagateUpdatesListener
{
    private PropertyAccessor $propertyAccessor;
    private ObjectRepository|EntityRepository $collectionRepository;
    private \SplObjectStorage $updatedResources;
    private array $pageDataPropertiesChanged = [];
    private array $updatedCollectionClassToIriMapping = [];

    /**
     * @param IriConverterInterface $iriConverter
     * @param ManagerRegistry $entityManager
     * @param iterable|ResourceChangedPropagatorInterface[] $resourceChangedPropagators
     * @param ResourceClassResolverInterface $resourceClassResolver
     * @param PageDataProvider $pageDataProvider
     * @param ComponentPositionRepository $positionRepository
     */
    public function __construct(
        private readonly IriConverterInterface $iriConverter,
        ManagerRegistry $entityManager,
        private readonly iterable $resourceChangedPropagators,
        private readonly ResourceClassResolverInterface $resourceClassResolver,
        private readonly PageDataProvider $pageDataProvider,
        private readonly ComponentPositionRepository $positionRepository
    ) {
        $this->propertyAccessor = PropertyAccess::createPropertyAccessor();
        $this->collectionRepository = $entityManager->getRepository(Collection::class);
        $this->reset();
    }

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

        foreach ($uow->getScheduledEntityInsertions() as $entity) {
            $this->gatherResourceAndAssociated($entity, 'created', $em, $uow);
        }

        foreach ($uow->getScheduledEntityUpdates() as $entity) {
            $this->gatherResourceAndAssociated($entity, 'updated', $em, $uow);
        }

        foreach ($uow->getScheduledEntityDeletions() as $entity) {
            $this->gatherResourceAndAssociated($entity, 'deleted', $em, $uow);
        }

        $this->collectUpdatedPageDataAndPositions();
    }

    public function postFlush(PostFlushEventArgs $eventArgs): void
    {
        $this->refreshUpdatedEntities($eventArgs->getObjectManager());
        $this->collectDynamicComponentPositionResources();
        $this->collectRelatedCollectionComponentResources();
        $this->purgeResources();
    }

    private function collectUpdatedPageDataAndPositions(): void
    {
        foreach ($this->updatedResources as $updatedResource) {
            $pageDataComponentMetadata = $this->pageDataProvider->findPageDataComponentMetadata($updatedResource);
            foreach ($pageDataComponentMetadata as $pageDataComponentMetadatum) {
                $pageDataResources = $pageDataComponentMetadatum->getPageDataResources();
                if (count($pageDataResources)) {
                    foreach ($pageDataResources as $pageDataResource) {
                        $this->collectUpdatedResource($pageDataResource, 'updated');
                        $this->addToPropagators($pageDataResource, 'updated');
                    }

                    $pageDataComponentProperties = $pageDataComponentMetadatum->getProperties();
                    $this->collectDynamicComponentPositionResources($pageDataComponentProperties->toArray());
                }
            }
        }
    }

    private function refreshUpdatedEntities(ObjectManager $om): void
    {
        foreach ($this->updatedResources as $updatedResource) {
            $data = $this->updatedResources[$updatedResource];
            if ('deleted' !== $data['type'] && $om->contains($updatedResource)) {
                $om->refresh($updatedResource);
                $this->addToPropagators($updatedResource, $data['type']);
            }
        }
    }

    private function gatherResourceAndAssociated(object $entity, string $type, ObjectManager $em, UnitOfWork $uow): void
    {
        $changeSet = $uow->getEntityChangeSet($entity);
        $this->collectUpdatedResource($entity, $type);

        $associationMappings = $em->getClassMetadata(ClassUtils::getClass($entity))->getAssociationMappings();

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

        if ('updated' === $type) {
            $this->gatherUpdatedAssociatedEntities($associationMappings, $changeSet);

            return;
        }

        // created and deleted - full entity change, all properties to check
        // catch any related resources that may have changed backwards relation or database cascades
        $this->gatherAllAssociatedEntities($entity, $associationMappings);
    }

    private function gatherUpdatedAssociatedEntities(array $associationMappings, array $changeSet): void
    {
        foreach ($changeSet as $field => $values) {
            // detect whether changed field was an association
            if (!isset($associationMappings[$field])) {
                continue;
            }

            if (isset($associationMappings[$field]['inversedBy'])) {
                $notNullValues = array_filter($values);
                foreach ($notNullValues as $entityInverseValuesUpdated) {
                    // note: the resource may get removed if orphaned
                    $this->collectUpdatedResource($entityInverseValuesUpdated, 'updated');
                }
            }
        }
    }

    private function gatherAllAssociatedEntities(object $entity, array $associationMappings): void
    {
        foreach (array_keys($associationMappings) as $property) {
            if (
                !$this->propertyAccessor->isReadable($entity, $property) ||
                !$assocEntity = $this->propertyAccessor->getValue($entity, $property)
            ) {
                continue;
            }

            if ($assocEntity instanceof PersistentCollection) {
                foreach ($assocEntity as $oneToManyEntity) {
                    if (!$oneToManyEntity) {
                        continue;
                    }
                    $this->collectUpdatedResource($oneToManyEntity, 'updated');
                }

                return;
            }
            $this->collectUpdatedResource($assocEntity, 'updated');
        }
    }

    private function collectUpdatedResource($resource, string $type): void
    {
        if (!$resource) {
            return;
        }
        $this->addResourceIrisFromObject($resource, $type);
        $this->addToPropagators($resource, $type);
    }

    private function addResourceIrisFromObject($resource, string $type): void
    {
        if (
            isset($this->updatedResources[$resource]) &&
            $type !== 'deleted'
        ) {
            return;
        }

        try {
            $resourceClass = $this->resourceClassResolver->getResourceClass($resource);
        } catch (InvalidArgumentException $e) {
            return;
        }

        // collect get collection iris for clearing the collection components in the cache later
        if (!isset($this->updatedCollectionClassToIriMapping[$resourceClass])) {
            try {
                $collectionIri = $this->iriConverter->getIriFromResource($resource, UrlGeneratorInterface::ABS_PATH, (new GetCollection())->withClass($resourceClass));
                $this->updatedCollectionClassToIriMapping[$resourceClass] = $collectionIri;
            } catch (InvalidArgumentException $e) {

            }
        }

        // keep a record of all the resources we are triggering updates for related from the database changes
        $resourceIri = $this->iriConverter->getIriFromResource($resource);

        $this->updatedResources[$resource] = [
            'iri' => $resourceIri,
            'type' => $type,
            'resourceClass' => $resourceClass,
        ];
    }

    private function collectDynamicComponentPositionResources(array $pageDataPropertiesChanged = null): void
    {
        if (!$pageDataPropertiesChanged) {
            $pageDataPropertiesChanged = $this->pageDataPropertiesChanged;
        }
        if (0 === count($pageDataPropertiesChanged)) {
            return;
        }
        $positions = $this->positionRepository->findByPageDataProperties($pageDataPropertiesChanged);

        foreach ($positions as $position) {
            $this->collectUpdatedResource($position, 'updated');
            $this->addToPropagators($position, 'updated');
        }
    }

    private function collectRelatedCollectionComponentResources(): void
    {
        if (empty($this->updatedCollectionClassToIriMapping)) {
            return;
        }

        foreach ($this->updatedCollectionClassToIriMapping as $resourceIri) {
            $collections = $this->collectionRepository->findBy([
                'resourceIri' => $resourceIri,
            ]);
            foreach ($collections as $collection) {
                $this->collectUpdatedResource($collection, 'updated');
                $this->addToPropagators($collection, 'updated');
            }
        }
    }

    private function purgeResources(): void
    {
        foreach ($this->resourceChangedPropagators as $resourceChangedPropagator) {
            $resourceChangedPropagator->propagate();
        }

        $this->reset();
    }

    private function addToPropagators(object $item, string $type): void
    {
        foreach ($this->resourceChangedPropagators as $resourceChangedPropagator) {
            $resourceChangedPropagator->add($item, $type);
        }
    }

    private function reset(): void
    {
        $this->updatedResources = new \SplObjectStorage();
        $this->pageDataPropertiesChanged = [];
        $this->updatedCollectionClassToIriMapping = [];
    }
}

components-web-app / api-components-bundle

Push — main ( a8d12f...4cb83a )

PropagateUpdatesListener::refreshUpdatedEntities() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
