SortableListener::addGroupFilter() - Code Metrics - core23/doctrine-extensions - Measure and Improve Code Quality continuously with Scrutinizer

SortableListener::addGroupFilter() A
last analyzed 2019-12-07 21:59 UTC

↳ Parent: SortableListener

Complexity

Conditions	5
Paths	3

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	5
dl	0
loc	10
rs	9.6111
c	1
b	0
f	0
cc	5
nc	3
nop	3

<?php

declare(strict_types=1);

/*
 * (c) Christian Gripp <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Core23\Doctrine\EventListener\ORM;

use Core23\Doctrine\Model\PositionAwareInterface;
use Core23\Doctrine\Model\Traits\SortableTrait;
use Core23\Doctrine\Util\ClassUtils;
use Doctrine\Common\EventSubscriber;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\Event\LifecycleEventArgs;
use Doctrine\ORM\Event\LoadClassMetadataEventArgs;
use Doctrine\ORM\Event\PreUpdateEventArgs;
use Doctrine\ORM\Events;
use Doctrine\ORM\Mapping\MappingException;
use Doctrine\ORM\NonUniqueResultException;
use Doctrine\ORM\QueryBuilder;
use Doctrine\ORM\UnitOfWork;
use Symfony\Component\PropertyAccess\PropertyAccess;
use Symfony\Component\PropertyAccess\PropertyAccessor;

final class SortableListener implements EventSubscriber
{
    /**
     * @var PropertyAccessor
     */
    private $propertyAccessor;

    /**
     * @param PropertyAccessor $propertyAccessor
     */
    public function __construct(PropertyAccessor $propertyAccessor = null)
    {
        if (null === $propertyAccessor) {
            $propertyAccessor = PropertyAccess::createPropertyAccessor();
        }

        $this->propertyAccessor = $propertyAccessor;
    }

    public function getSubscribedEvents()
    {
        return [
            Events::prePersist,
            Events::preUpdate,
            Events::preRemove,
            Events::loadClassMetadata,
        ];
    }

    public function prePersist(LifecycleEventArgs $args): void
    {
        if (!$args->getEntity() instanceof PositionAwareInterface) {
            return;
        }

        $this->uniquePosition($args);
    }

    public function preUpdate(PreUpdateEventArgs $args): void
    {
        if (!$args->getEntity() instanceof PositionAwareInterface) {
            return;
        }

        $position = $args->getEntity()->getPosition();

        if ($args->hasChangedField('position')) {
            $position = $args->getOldValue('position');
        }

        $this->uniquePosition($args, $position);
    }

    public function preRemove(LifecycleEventArgs $args): void
    {
        $entity = $args->getEntity();

        if ($entity instanceof PositionAwareInterface) {
            $this->movePosition($args->getEntityManager(), $entity, -1);
        }
    }

    /**
     * @throws MappingException
     */
    public function loadClassMetadata(LoadClassMetadataEventArgs $eventArgs): void
    {
        $meta = $eventArgs->getClassMetadata();

        $reflClass = $meta->getReflectionClass();

        if (null === $reflClass || !ClassUtils::containsTrait($reflClass, SortableTrait::class)) {
            return;
        }

        if (!$meta->hasField('position')) {
            $meta->mapField([
                'type'      => 'integer',
                'fieldName' => 'position',
            ]);
        }
    }

    private function uniquePosition(LifecycleEventArgs $args, ?int $oldPosition = null): void
    {
        $entity = $args->getEntity();

        if ($entity instanceof PositionAwareInterface) {
            if (null === $entity->getPosition()) {
                $position = $this->getNextPosition($args->getEntityManager(), $entity);
                $entity->setPosition($position);
            } elseif (null !== $oldPosition && $oldPosition !== $entity->getPosition()) {
                $this->movePosition($args->getEntityManager(), $entity);
            }
        }
    }

    private function movePosition(EntityManager $em, PositionAwareInterface $entity, int $direction = 1): void
    {
        $uow  = $em->getUnitOfWork();
        $meta = $em->getClassMetadata(\get_class($entity));

        $qb = $em->createQueryBuilder()
            ->update($meta->getName(), 'e')
            ->set('e.position', 'e.position + '.$direction)
        ;

        if ($direction > 0) {
            $qb->andWhere('e.position <= :position')->setParameter('position', $entity->getPosition());
        } elseif ($direction < 0) {
            $qb->andWhere('e.position >= :position')->setParameter('position', $entity->getPosition());
        } else {
            return;
        }

        $this->addGroupFilter($qb, $entity, $uow);

        $qb->getQuery()->execute();
    }

    private function getNextPosition(EntityManager $em, PositionAwareInterface $entity): int
    {
        $meta = $em->getClassMetadata(\get_class($entity));

        $qb = $em->createQueryBuilder()
            ->select('e')
            ->from($meta->getName(), 'e')
            ->addOrderBy('e.position', 'DESC')
            ->setMaxResults(1)
        ;

        $this->addGroupFilter($qb, $entity);

        try {
            $result = $qb->getQuery()->getOneOrNullResult();

            if ($result instanceof PositionAwareInterface && null !== $result->getPosition()) {
                return $result->getPosition() + 1;
            }
        } catch (NonUniqueResultException $ignored) {

        }

        return 0;
    }

    private function addGroupFilter(QueryBuilder $qb, PositionAwareInterface $entity, UnitOfWork $uow = null): void
    {
        foreach ($entity->getPositionGroup() as $field) {
            $value = $this->propertyAccessor->getValue($entity, $field);

            if (\is_object($value) && (null === $uow || null === $uow->getSingleIdentifierValue($value))) {
                continue;
            }

            $qb->andWhere('e.'.$field.' = :'.$field)->setParameter($field, $value);
        }
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* (c) Christian Gripp <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Core23\Doctrine\EventListener\ORM;
13
14			use Core23\Doctrine\Model\PositionAwareInterface;
15			use Core23\Doctrine\Model\Traits\SortableTrait;
16			use Core23\Doctrine\Util\ClassUtils;
17			use Doctrine\Common\EventSubscriber;
18			use Doctrine\ORM\EntityManager;
19			use Doctrine\ORM\Event\LifecycleEventArgs;
20			use Doctrine\ORM\Event\LoadClassMetadataEventArgs;
21			use Doctrine\ORM\Event\PreUpdateEventArgs;
22			use Doctrine\ORM\Events;
23			use Doctrine\ORM\Mapping\MappingException;
24			use Doctrine\ORM\NonUniqueResultException;
25			use Doctrine\ORM\QueryBuilder;
26			use Doctrine\ORM\UnitOfWork;
27			use Symfony\Component\PropertyAccess\PropertyAccess;
28			use Symfony\Component\PropertyAccess\PropertyAccessor;
29
30			final class SortableListener implements EventSubscriber
31			{
32			/**
33			* @var PropertyAccessor
34			*/
35			private $propertyAccessor;
36
37			/**
38			* @param PropertyAccessor $propertyAccessor
39			*/
40			public function __construct(PropertyAccessor $propertyAccessor = null)
41			{
42			if (null === $propertyAccessor) {
43			$propertyAccessor = PropertyAccess::createPropertyAccessor();
44			}
45
46			$this->propertyAccessor = $propertyAccessor;
47			}
48
49			public function getSubscribedEvents()
50			{
51			return [
52			Events::prePersist,
53			Events::preUpdate,
54			Events::preRemove,
55			Events::loadClassMetadata,
56			];
57			}
58
59			public function prePersist(LifecycleEventArgs $args): void
60			{
61			if (!$args->getEntity() instanceof PositionAwareInterface) {
62			return;
63			}
64
65			$this->uniquePosition($args);
66			}
67
68			public function preUpdate(PreUpdateEventArgs $args): void
69			{
70			if (!$args->getEntity() instanceof PositionAwareInterface) {
71			return;
72			}
73
74			$position = $args->getEntity()->getPosition();
75
76			if ($args->hasChangedField('position')) {
77			$position = $args->getOldValue('position');
78			}
79
80			$this->uniquePosition($args, $position);
81			}
82
83			public function preRemove(LifecycleEventArgs $args): void
84			{
85			$entity = $args->getEntity();
86
87			if ($entity instanceof PositionAwareInterface) {
88			$this->movePosition($args->getEntityManager(), $entity, -1);
89			}
90			}
91
92			/**
93			* @throws MappingException
94			*/
95			public function loadClassMetadata(LoadClassMetadataEventArgs $eventArgs): void
96			{
97			$meta = $eventArgs->getClassMetadata();
98
99			$reflClass = $meta->getReflectionClass();
100
101			if (null === $reflClass \|\| !ClassUtils::containsTrait($reflClass, SortableTrait::class)) {
102			return;
103			}
104
105			if (!$meta->hasField('position')) {
106			$meta->mapField([
107			'type' => 'integer',
108			'fieldName' => 'position',
109			]);
110			}
111			}
112
113			private function uniquePosition(LifecycleEventArgs $args, ?int $oldPosition = null): void
114			{
115			$entity = $args->getEntity();
116
117			if ($entity instanceof PositionAwareInterface) {
118			if (null === $entity->getPosition()) {
119			$position = $this->getNextPosition($args->getEntityManager(), $entity);
120			$entity->setPosition($position);
121			} elseif (null !== $oldPosition && $oldPosition !== $entity->getPosition()) {
122			$this->movePosition($args->getEntityManager(), $entity);
123			}
124			}
125			}
126
127			private function movePosition(EntityManager $em, PositionAwareInterface $entity, int $direction = 1): void
128			{
129			$uow = $em->getUnitOfWork();
130			$meta = $em->getClassMetadata(\get_class($entity));
131
132			$qb = $em->createQueryBuilder()
133			->update($meta->getName(), 'e')
134			->set('e.position', 'e.position + '.$direction)
135			;
136
137			if ($direction > 0) {
138			$qb->andWhere('e.position <= :position')->setParameter('position', $entity->getPosition());
139			} elseif ($direction < 0) {
140			$qb->andWhere('e.position >= :position')->setParameter('position', $entity->getPosition());
141			} else {
142			return;
143			}
144
145			$this->addGroupFilter($qb, $entity, $uow);
146
147			$qb->getQuery()->execute();
148			}
149
150			private function getNextPosition(EntityManager $em, PositionAwareInterface $entity): int
151			{
152			$meta = $em->getClassMetadata(\get_class($entity));
153
154			$qb = $em->createQueryBuilder()
155			->select('e')
156			->from($meta->getName(), 'e')
157			->addOrderBy('e.position', 'DESC')
158			->setMaxResults(1)
159			;
160
161			$this->addGroupFilter($qb, $entity);
162
163			try {
164			$result = $qb->getQuery()->getOneOrNullResult();
165
166			if ($result instanceof PositionAwareInterface && null !== $result->getPosition()) {
167			return $result->getPosition() + 1;
168			}
169			} catch (NonUniqueResultException $ignored) {
			0 ignored issues – show Coding Style Comprehensibility introduced 2017-11-20 16:49 UTC by Report Bug Copy Issue Report Consider adding a comment why this CATCH block is empty. Loading history...
170			}
171
172			return 0;
173			}
174
175			private function addGroupFilter(QueryBuilder $qb, PositionAwareInterface $entity, UnitOfWork $uow = null): void
176			{
177			foreach ($entity->getPositionGroup() as $field) {
178			$value = $this->propertyAccessor->getValue($entity, $field);
179
180			if (\is_object($value) && (null === $uow \|\| null === $uow->getSingleIdentifierValue($value))) {
181			continue;
182			}
183
184			$qb->andWhere('e.'.$field.' = :'.$field)->setParameter($field, $value);
185			}
186			}
187			}
188

core23 / doctrine-extensions

GitHub Access Token became invalid

SortableListener::addGroupFilter() A last analyzed 2019-12-07 21:59 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

SortableListener::addGroupFilter() A
last analyzed 2019-12-07 21:59 UTC