steevanb\DoctrineReadOnlyHydrator\EventSubscriber\ReadOnlySubscriber

Complexity

Total Complexity

12

Size/Duplication

Total Lines	79
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	8

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	getSubscribedEvents()	0	9	1
A	prePersist()	0	6	2
A	preFlush()	0	14	3
A	onClassMetadataNotFound()	0	11	2
A	postLoad()	0	10	2
A	isReadOnlyEntity()	0	6	2

<?php

namespace steevanb\DoctrineReadOnlyHydrator\EventSubscriber;

use Doctrine\ORM\Event\OnClassMetadataNotFoundEventArgs;
use steevanb\DoctrineReadOnlyHydrator\Hydrator\SimpleObjectHydrator;
use Doctrine\Common\EventSubscriber;
use Doctrine\Common\Persistence\Event\LifecycleEventArgs;
use Doctrine\ORM\Event\PreFlushEventArgs;
use Doctrine\ORM\Events;
use steevanb\DoctrineReadOnlyHydrator\Entity\ReadOnlyEntityInterface;
use steevanb\DoctrineReadOnlyHydrator\Exception\ReadOnlyEntityCantBeFlushedException;
use steevanb\DoctrineReadOnlyHydrator\Exception\ReadOnlyEntityCantBePersistedException;

class ReadOnlySubscriber implements EventSubscriber
{
    /** @return array */
    public function getSubscribedEvents()
    {
        return [
            Events::prePersist,
            Events::preFlush,
            Events::onClassMetadataNotFound,
            Events::postLoad
        ];
    }

    /**
     * @param LifecycleEventArgs $args
     * @throws ReadOnlyEntityCantBePersistedException
     */
    public function prePersist(LifecycleEventArgs $args)
    {
        if ($this->isReadOnlyEntity($args->getObject())) {
            throw new ReadOnlyEntityCantBePersistedException($args->getObject());
        }
    }

    /**
     * @param PreFlushEventArgs $args
     * @throws ReadOnlyEntityCantBeFlushedException
     */
    public function preFlush(PreFlushEventArgs $args)
    {
        $unitOfWork = $args->getEntityManager()->getUnitOfWork();
        $entities = array_merge(
            $unitOfWork->getScheduledEntityInsertions(),
            $unitOfWork->getScheduledEntityUpdates(),
            $unitOfWork->getScheduledEntityDeletions()
        );
        foreach ($entities as $entity) {
            if ($this->isReadOnlyEntity($entity)) {
                throw new ReadOnlyEntityCantBeFlushedException($entity);
            }
        }
    }

    /** @param OnClassMetadataNotFoundEventArgs $eventArgs */
    public function onClassMetadataNotFound(OnClassMetadataNotFoundEventArgs $eventArgs)
    {
        if (class_implements(
            $eventArgs->getClassName(),
            'steevanb\\DoctrineReadOnlyHydrator\\Entity\\ReadOnlyEntityInterface'
        )) {
            $eventArgs->setFoundMetadata(
                $eventArgs->getObjectManager()->getClassMetadata(get_parent_class($eventArgs->getClassName()))
            );
        }
    }

    /** @param LifecycleEventArgs $eventArgs */
    public function postLoad(LifecycleEventArgs $eventArgs)
    {
        if ($eventArgs->getObject() instanceof ReadOnlyEntityInterface) {
            // add ReadOnlyProxy to classMetada list
            // without it, you can't use Doctrine automatic id finder
            // like $queryBuilder->setParameter('foo', $foo)

59% of this comment could be valid code. Did you maybe forget this after debugging?

            // instead of  $queryBuilder->setParameter('foo', $foo->getId())

56% of this comment could be valid code. Did you maybe forget this after debugging?

            $eventArgs->getObjectManager()->getClassMetadata(get_class($eventArgs->getObject()));
        }
    }

    /**
     * @param object $entity
     * @return bool
     */
    protected function isReadOnlyEntity($entity)
    {
        return
            $entity instanceof ReadOnlyEntityInterface
            || isset($entity->{SimpleObjectHydrator::READ_ONLY_PROPERTY});
    }
}