DH\DoctrineAuditBundle\Transaction\TransactionHydrator

Complexity

Total Complexity

23

Size/Duplication

Total Lines	135
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	hydrateWithScheduledDeletions()	0	8	3
A	hydrateWithScheduledUpdates()	0	7	3
A	hydrate()	0	9	1
A	__construct()	0	4	1
A	hydrateWithScheduledInsertions()	0	7	3
B	hydrateWithScheduledCollectionUpdates()	0	21	7
A	hydrateWithScheduledCollectionDeletions()	0	12	5

<?php

namespace DH\DoctrineAuditBundle\Transaction;

use DH\DoctrineAuditBundle\Configuration;
use DH\DoctrineAuditBundle\Model\Transaction;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\UnitOfWork;

class TransactionHydrator
{
    use AuditTrait;

The trait DH\DoctrineAuditBundle\Transaction\AuditTrait requires some properties which are not provided by DH\DoctrineAuditBundle\Transaction\TransactionHydrator: $fieldMappings, $embeddedClasses, $name

    /**
     * @var Configuration
     */
    private $configuration;

    /**
     * @var EntityManagerInterface
     */
    private $em;

    public function __construct(Configuration $configuration)
    {
        $this->configuration = $configuration;
        $this->em = $this->configuration->getEntityManager();
    }

    public function hydrate(Transaction $transaction): void
    {
        $uow = $this->em->getUnitOfWork();

        $this->hydrateWithScheduledInsertions($transaction, $uow);
        $this->hydrateWithScheduledUpdates($transaction, $uow);
        $this->hydrateWithScheduledDeletions($transaction, $uow, $this->em);
        $this->hydrateWithScheduledCollectionUpdates($transaction, $uow, $this->em);
        $this->hydrateWithScheduledCollectionDeletions($transaction, $uow, $this->em);
    }

    /**
     * @param UnitOfWork $uow
     */
    private function hydrateWithScheduledInsertions(Transaction $transaction, UnitOfWork $uow): void
    {
        foreach (array_reverse($uow->getScheduledEntityInsertions()) as $entity) {
            if ($this->configuration->isAudited($entity)) {
                $transaction->trackAuditEvent(Transaction::INSERT, [
                    $entity,
                    $uow->getEntityChangeSet($entity),
                ]);
            }
        }
    }

    /**
     * @param UnitOfWork $uow
     */
    private function hydrateWithScheduledUpdates(Transaction $transaction, UnitOfWork $uow): void
    {
        foreach (array_reverse($uow->getScheduledEntityUpdates()) as $entity) {
            if ($this->configuration->isAudited($entity)) {
                $transaction->trackAuditEvent(Transaction::UPDATE, [
                    $entity,
                    $uow->getEntityChangeSet($entity),
                ]);
            }
        }
    }

    /**
     * @param UnitOfWork             $uow
     * @param EntityManagerInterface $em
     *
     * @throws \Doctrine\DBAL\DBALException
     * @throws \Doctrine\ORM\Mapping\MappingException
     */
    private function hydrateWithScheduledDeletions(Transaction $transaction, UnitOfWork $uow, EntityManagerInterface $em): void
    {
        foreach (array_reverse($uow->getScheduledEntityDeletions()) as $entity) {
            if ($this->configuration->isAudited($entity)) {
                $uow->initializeObject($entity);
                $transaction->trackAuditEvent(Transaction::REMOVE, [
                    $entity,
                    $this->id($em, $entity),
                ]);
            }
        }
    }

    /**
     * @param UnitOfWork             $uow
     * @param EntityManagerInterface $em
     *
     * @throws \Doctrine\DBAL\DBALException
     * @throws \Doctrine\ORM\Mapping\MappingException
     */
    private function hydrateWithScheduledCollectionUpdates(Transaction $transaction, UnitOfWork $uow, EntityManagerInterface $em): void
    {
        foreach (array_reverse($uow->getScheduledCollectionUpdates()) as $collection) {
            if ($this->configuration->isAudited($collection->getOwner())) {
                $mapping = $collection->getMapping();
                foreach ($collection->getInsertDiff() as $entity) {
                    if ($this->configuration->isAudited($entity)) {
                        $transaction->trackAuditEvent(Transaction::ASSOCIATE, [
                            $collection->getOwner(),
                            $entity,
                            $mapping,
                        ]);
                    }
                }
                foreach ($collection->getDeleteDiff() as $entity) {
                    if ($this->configuration->isAudited($entity)) {
                        $transaction->trackAuditEvent(Transaction::DISSOCIATE, [
                            $collection->getOwner(),
                            $entity,
                            $this->id($em, $entity),
                            $mapping,
                        ]);
                    }
                }
            }
        }
    }

    /**
     * @param UnitOfWork             $uow
     * @param EntityManagerInterface $em
     *
     * @throws \Doctrine\DBAL\DBALException
     * @throws \Doctrine\ORM\Mapping\MappingException
     */
    private function hydrateWithScheduledCollectionDeletions(Transaction $transaction, UnitOfWork $uow, EntityManagerInterface $em): void
    {
        foreach (array_reverse($uow->getScheduledCollectionDeletions()) as $collection) {
            if ($this->configuration->isAudited($collection->getOwner())) {
                $mapping = $collection->getMapping();
                foreach ($collection->toArray() as $entity) {
                    if ($this->configuration->isAudited($entity)) {
                        $transaction->trackAuditEvent(Transaction::DISSOCIATE, [
                            $collection->getOwner(),
                            $entity,
                            $this->id($em, $entity),
                            $mapping,
                        ]);
                    }
                }
            }
        }
    }
}