DoctrineResourceFlushTrait::collectUpdatedResource() - Code Metrics - Inspection of "Refresh related resources before adding to purge s..." - components-web-app/api-components-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — main ( 975c76...182af0 )

by Daniel
created 2022-11-05 13:29 UTC
collectUpdatedResource() A

↳ Parent: DoctrineResourceFlushTrait
Complexity

Conditions	2
Paths	2
Size

Total Lines	7
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	6
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	2
eloc	4
c	1
b	0
f	0
nc	2
nop	2
dl	0
loc	7
ccs	0
cts	5
cp	0
crap	6
rs	10
<?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\EntityRepository;
use Doctrine\ORM\Event\OnFlushEventArgs;
use Doctrine\ORM\Event\PostFlushEventArgs;
use Doctrine\ORM\Event\PreUpdateEventArgs;
use Doctrine\ORM\PersistentCollection;
use Doctrine\Persistence\ManagerRegistry;
use Doctrine\Persistence\ObjectManager;
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 = [];
    private array $gatherRelatedForEntities = [];

    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, 'updated');

        $changeSet = $eventArgs->getEntityChangeSet();
        $associationMappings = $this->getAssociationMappings($eventArgs->getObjectManager(), $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], 'updated');
            $this->collectUpdatedResource($value[1], 'updated');
        }
    }

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

        foreach ($uow->getScheduledEntityInsertions() as $entity) {
            $this->collectUpdatedResource($entity, 'created');
            $this->gatherRelatedForEntities[] = $entity;
        }

        foreach ($uow->getScheduledEntityUpdates() as $entity) {
            $this->collectUpdatedResource($entity, 'updated');
            $this->gatherRelatedForEntities[] = $entity;
        }

        foreach ($uow->getScheduledEntityDeletions() as $entity) {
            $this->collectUpdatedResource($entity, 'deleted');
            $this->gatherRelatedForEntities[] = $entity;
        }
    }

    public function postFlush(PostFlushEventArgs $eventArgs): void
    {
        foreach ($this->gatherRelatedForEntities as $object) {
            $this->gatherRelationResourceClasses($eventArgs->getObjectManager(), $object);
        }
        $this->addResourcesToPurge($this->gatherResourcesForPositionsWithPageDataProperties(), 'updated');
        $this->addResourcesToPurge($this->gatherIrisForCollectionResources(), 'updated');
        $this->purgeResources();
    }

    private function gatherRelationResourceClasses(ObjectManager $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) {
                    return;
                }
                if ($value instanceof PersistentCollection) {
                    foreach ($value as $item) {
                        if (!$item) {
                            continue;
                        }
                        $em->refresh($item);
                        $this->collectUpdatedResource($item, 'updated');
                    }
                } else {
                    $em->refresh($value);
                    $this->collectUpdatedResource($value, 'updated');
                }
            }
        }
    }

    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(ObjectManager $em, $entity): array
    {
        return $em->getClassMetadata(ClassUtils::getClass($entity))->getAssociationMappings();
    }

    private function collectUpdatedResource($resource, string $type): void
    {
        if (!$resource) {
            return;
        }
        $this->addResourceIris([$resource], $type);
        $this->resourceChangedPropagator->collectItems([$resource], $type);
    }

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

    private function addResourceIris(array $resources, string $type): void
    {
        foreach ($resources as $resource) {
            try {
                $this->resourceChangedPropagator->collectResource($resource, $type);

                $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

Push — main ( 975c76...182af0 )

collectUpdatedResource() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
