EventListener::isUnitializedProxy() - Code Metrics - addiks/symfony_rdm - Measure and Improve Code Quality continuously with Scrutinizer

EventListener::isUnitializedProxy() A
last analyzed 2024-11-12 10:58 UTC

↳ Parent: EventListener
Complexity

Conditions	3
Paths	2
Size

Total Lines	10
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	12
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	3
eloc	4
c	1
b	0
f	0
nc	2
nop	1
dl	0
loc	10
ccs	0
cts	0
cp	0
crap	12
rs	10
<?php
/**
 * Copyright (C) 2018 Gerrit Addiks.
 * This package (including this file) was released under the terms of the GPL-3.0.
 * You should have received a copy of the GNU General Public License along with this program.
 * If not, see <http://www.gnu.org/licenses/> or send me a mail so i can send you a copy.
 * @license GPL-3.0
 * @author Gerrit Addiks <[email protected]>
 */

namespace Addiks\RDMBundle\Doctrine;

use Addiks\RDMBundle\Hydration\EntityHydratorInterface;
use Addiks\RDMBundle\Mapping\Drivers\MappingDriverInterface;
use Addiks\RDMBundle\Mapping\EntityMappingInterface;
use Addiks\RDMBundle\DataLoader\DataLoaderInterface;
use Doctrine\ORM\Event\LifecycleEventArgs;
use Doctrine\ORM\Mapping\ClassMetadata;
use Doctrine\ORM\Tools\SchemaTool;
use Doctrine\ORM\Tools\Event\GenerateSchemaTableEventArgs;
use Doctrine\ORM\Event\LoadClassMetadataEventArgs;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\UnitOfWork;
use Doctrine\DBAL\Schema\Table;
use Doctrine\ORM\Event\PostFlushEventArgs;
use Doctrine\ORM\Proxy\Proxy;
use Doctrine\DBAL\Schema\Column;
use PDOException;
use Doctrine\DBAL\Exception\ConnectionException;

/**
 * Hooks into the event's of doctrine2-ORM and forwards the entities to other objects.
 */
final class EventListener
{

    /**
     * @var EntityHydratorInterface
     */
    private $entityHydrator;

    /**
     * @var MappingDriverInterface
     */
    private $mappingDriver;

    /**
     * @var DataLoaderInterface
     */
    private $dbalDataLoader;

    /**
     * @var array<class-string, bool>

     */
    private $hasRdmMappingForClass = array();

    public function __construct(
        EntityHydratorInterface $entityHydrator,
        MappingDriverInterface $mappingDriver,
        DataLoaderInterface $dbalDataLoader
    ) {
        $this->entityHydrator = $entityHydrator;
        $this->mappingDriver = $mappingDriver;
        $this->dbalDataLoader = $dbalDataLoader;
    }

    public function postLoad(LifecycleEventArgs $arguments): void
    {
        /** @var object $entity */
        $entity = $arguments->getEntity();
        $entity = /** @scrutinizer ignore-deprecated */ $arguments->getEntity();

        /** @var EntityManagerInterface $entityManager */
        $entityManager = $arguments->getEntityManager();
        $entityManager = /** @scrutinizer ignore-deprecated */ $arguments->getEntityManager();

        $this->entityHydrator->hydrateEntity($entity, $entityManager);
    }

    public function prePersist(LifecycleEventArgs $arguments): void
    {
        /** @var object $entity */
        $entity = $arguments->getEntity();
        $entity = /** @scrutinizer ignore-deprecated */ $arguments->getEntity();

        /** @var EntityManagerInterface $entityManager */
        $entityManager = $arguments->getEntityManager();
        $entityManager = /** @scrutinizer ignore-deprecated */ $arguments->getEntityManager();

        if (!($entity instanceof Proxy)) {
            $this->entityHydrator->assertHydrationOnEntity($entity, $entityManager);
        }
    }

    public function postFlush(PostFlushEventArgs $arguments): void
    {
        /** @var EntityManagerInterface $entityManager */
        $entityManager = $arguments->getEntityManager();
        $entityManager = /** @scrutinizer ignore-deprecated */ $arguments->getEntityManager();

        /** @var UnitOfWork $unitOfWork */
        $unitOfWork = $entityManager->getUnitOfWork();

        /** @param class-string $className */
        foreach ($unitOfWork->getIdentityMap() as $className => $entities) {
            if (!$this->hasRdmMappingForClass($className)) {
                continue;
            }

            foreach ($entities as $entity) {
                /** @var object $entity */

                if (!$this->isUnitializedProxy($entity)) {
                    if ($unitOfWork->isScheduledForDelete($entity)) {
                        $this->dbalDataLoader->removeDBALDataForEntity($entity, $entityManager);

                    } else {
                        $this->dbalDataLoader->storeDBALDataForEntity($entity, $entityManager);
                    }
                }
            }
        }
    }

    public function loadClassMetadata(LoadClassMetadataEventArgs $arguments): void
    {
        /** @var EntityManagerInterface $entityManager */
        $entityManager = $arguments->getEntityManager();

        /** @var ClassMetadata $classMetadata */
        $classMetadata = $arguments->getClassMetadata();

        try {
            $this->dbalDataLoader->prepareOnMetadataLoad($entityManager, $classMetadata);

        } catch (PDOException | ConnectionException $exception) {
            var_dump($exception->getMessage());

            if (!str_contains($exception->getMessage(), 'No such file or directory')) {
                throw $exception;
            }
        }
    }

    /**
     * Invoked when doctrine has generated a table-definition in the target-schema.
     * Collects the additional schema-columns from the mapping and add's them to the table.
     *
     * Dispatched in:
     * @see SchemaTool::getSchemaFromMetadata
     */
    public function postGenerateSchemaTable(GenerateSchemaTableEventArgs $arguments): void
    {
        /** @var Table $table */
        $table = $arguments->getClassTable();

        /** @var ClassMetadata $classMetadata */
        $classMetadata = $arguments->getClassMetadata();

        /** @var class-string $className */
        $className = $classMetadata->getName();

        /** @var ?EntityMappingInterface $entityMapping */
        $entityMapping = $this->mappingDriver->loadRDMMetadataForClass($className);

        if ($entityMapping instanceof EntityMappingInterface) {
            /** @var array<Column> $additionalColumns */
            $additionalColumns = $entityMapping->collectDBALColumns();

            foreach ($additionalColumns as $column) {
                /** @var Column $column */

                /** @var string $columnName */
                $columnName = $column->getName();

                if (!$table->hasColumn($columnName)) {
                    
                    /** @var array<string, mixed> $columnConfig */
                    $columnConfig = $column->toArray();
                    unset($columnConfig['name']);
                    
                    $table->addColumn(
                        $columnName,
                        $column->getType()->getName(),
                        $columnConfig
                    );
                }
            }
        }
    }

    /** @param class-string $className */

    private function hasRdmMappingForClass(string $className): bool
    {
        if (!isset($this->hasRdmMappingForClass[$className])) {
            /** @var class-string $currentClassName */
            $currentClassName = $className;

            do {
                $this->hasRdmMappingForClass[$className] = is_object(
                    $this->mappingDriver->loadRDMMetadataForClass($currentClassName)
                );

                $currentClassName = current(class_parents($currentClassName));
            } while (class_exists($currentClassName) && !$this->hasRdmMappingForClass[$className]);
        }

        return $this->hasRdmMappingForClass[$className];
    }

    /**
     * @param object $entity
     */
    private function isUnitializedProxy($entity): bool
    {
        /** @var bool $isUnitializedProxy */
        $isUnitializedProxy = false;

        if ($entity instanceof Proxy && !$entity->__isInitialized()) {
            $isUnitializedProxy = true;
        }

        return $isUnitializedProxy;
    }

}

addiks / symfony_rdm

EventListener::isUnitializedProxy() A last analyzed 2024-11-12 10:58 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

EventListener::isUnitializedProxy() A
last analyzed 2024-11-12 10:58 UTC
