Kunstmaan\AdminListBundle\Service\EntityVersionLockService

Complexity

Total Complexity

28

Size/Duplication

Total Lines	211
Duplicated Lines	5.69 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

94.12%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	isEntityBelowThreshold()	0	15	3
B	isEntityLocked()	3	28	6
A	createEntityVersionLock()	3	21	4
A	getUsersWithEntityVersionLock()	3	20	3
A	removeExpiredLocks()	0	7	2
A	getEntityVersionLocksByLockableEntity()	3	12	3
A	getLockableEntity()	0	12	3
A	setObjectManager()	0	4	1
A	setThreshold()	0	4	1
A	setLockEnabled()	0	4	1

<?php

namespace Kunstmaan\AdminListBundle\Service;

use Doctrine\Common\Persistence\ObjectManager;
use FOS\UserBundle\Model\User;
use Kunstmaan\AdminBundle\Entity\UserInterface;
use Kunstmaan\AdminListBundle\Entity\LockableEntity;
use Kunstmaan\AdminListBundle\Entity\EntityVersionLock;
use Kunstmaan\AdminListBundle\Entity\LockableEntityInterface;
use Kunstmaan\AdminListBundle\Repository\EntityVersionLockRepository;

class EntityVersionLockService
{
    /**
     * @var ObjectManager
     */
    private $objectManager;

    /**
     * @var int
     */
    private $threshold;

    /**
     * @var bool
     */
    private $lockEnabled;

    public function __construct(ObjectManager $em, $threshold, $lockEnabled)
    {
        $this->setObjectManager($em);
        $this->setThreshold($threshold);
        $this->setLockEnabled($lockEnabled);
    }

    /**
     * @param LockableEntityInterface $entity
     *
     * @return bool
     */
    public function isEntityBelowThreshold(LockableEntityInterface $entity)
    {
        /** @var LockableEntity $lockable */
        $lockable = $this->getLockableEntity($entity, false);

        if ($this->lockEnabled && $lockable->getId() !== null) {
            $now = new \DateTime();
            $thresholdDate = clone $lockable->getUpdated();
            $thresholdDate->add(new \DateInterval('PT'.$this->threshold.'S'));

            return $thresholdDate > $now;
        }

        return false;
    }

    /**
     * @param User                    $user
     * @param LockableEntityInterface $entity
     *
     * @return bool
     */
    public function isEntityLocked(/*\Kunstmaan\AdminBundle\Entity\UserInterface*/ $user, LockableEntityInterface $entity)
    {
        // NEXT_MAJOR: remove type check and enable parameter typehint
        if (!$user instanceof User && !$user instanceof UserInterface) {

This code seems to be duplicated across your project.

            throw new \InvalidArgumentException(sprintf('The "$user" argument must be of type "%s" or implement the "%s" interface', User::class, UserInterface::class));
        }

        /** @var LockableEntity $lockable */
        $lockable = $this->getLockableEntity($entity);

        if ($this->lockEnabled) {
            $this->removeExpiredLocks($lockable);
            $locks = $this->getEntityVersionLocksByLockableEntity($lockable, $user);

            if ($locks === null || !\count($locks)) {
                $this->createEntityVersionLock($user, $lockable);

                $lockable->setUpdated(new \DateTime());
                $this->objectManager->flush();

                return false;
            }

            return true;
        }

        return false;
    }

    /**
     * When editing the entity, create a new entity translation lock.
     *
     * @param User           $user
     * @param LockableEntity $entity
     */
    protected function createEntityVersionLock(/*\Kunstmaan\AdminBundle\Entity\UserInterface*/ $user, LockableEntity $entity)
    {
        // NEXT_MAJOR: remove type check and enable parameter typehint
        if (!$user instanceof User && !$user instanceof UserInterface) {

This code seems to be duplicated across your project.

            throw new \InvalidArgumentException(sprintf('The "$user" argument must be of type "%s" or implement the "%s" interface', User::class, UserInterface::class));
        }

        /** @var EntityVersionLock $lock */
        $lock = $this->objectManager->getRepository(EntityVersionLock::class)->findOneBy([
            'owner' => $user->getUsername(),
            'lockableEntity' => $entity,
        ]);
        if (!$lock) {
            $lock = new EntityVersionLock();
        }
        $lock->setOwner($user->getUsername());
        $lock->setLockableEntity($entity);
        $lock->setCreatedAt(new \DateTime());
        $this->objectManager->persist($lock);
        $this->objectManager->flush();
    }

    /**
     * @param LockableEntityInterface $entity
     * @param User                    $userToExclude

Should the type for parameter $userToExclude not be User|null?

     *
     * @return array
     */
    public function getUsersWithEntityVersionLock(LockableEntityInterface $entity, /*\Kunstmaan\AdminBundle\Entity\UserInterface*/ $userToExclude = null)
    {
        // NEXT_MAJOR: remove type check and enable parameter typehint
        if (!$userToExclude instanceof User && !$userToExclude instanceof UserInterface) {

This code seems to be duplicated across your project.

            throw new \InvalidArgumentException(sprintf('The "$userToExclude" argument must be of type "%s" or implement the "%s" interface', User::class, UserInterface::class));
        }

        /** @var LockableEntity $lockable */
        $lockable = $this->getLockableEntity($entity);

        return  array_reduce(
            $this->getEntityVersionLocksByLockableEntity($lockable, $userToExclude),
            function ($return, EntityVersionLock $item) {
                $return[] = $item->getOwner();

                return $return;
            },
            []
        );
    }

    /**
     * @param LockableEntity $entity
     */
    protected function removeExpiredLocks(LockableEntity $entity)
    {
        $locks = $this->objectManager->getRepository(EntityVersionLock::class)->getExpiredLocks($entity, $this->threshold);

It seems like you code against a concrete implementation and not the interface Doctrine\Persistence\ObjectRepository as the method getExpiredLocks() does only exist in the following implementations of said interface: Kunstmaan\AdminListBundle\Repository\EntityVersionLockRepository, Kunstmaan\NodeBundle\Repository\NodeVersionLockRepository.

        foreach ($locks as $lock) {
            $this->objectManager->remove($lock);
        }
    }

    /**
     * When editing an entity, check if there is a lock for this entity.
     *
     * @param LockableEntity $entity
     * @param User           $userToExclude

Should the type for parameter $userToExclude not be User|null?

     *
     * @return EntityVersionLock[]

Should the return type not be \Kunstmaan\AdminListBundle\Repository\EntityVersionLock[]?

     */
    protected function getEntityVersionLocksByLockableEntity(LockableEntity $entity, /*\Kunstmaan\AdminBundle\Entity\UserInterface*/ $userToExclude = null)
    {
        // NEXT_MAJOR: remove type check and enable parameter typehint
        if (!$userToExclude instanceof User && !$userToExclude instanceof UserInterface) {

This code seems to be duplicated across your project.

            throw new \InvalidArgumentException(sprintf('The "$userToExclude" argument must be of type "%s" or implement the "%s" interface', User::class, UserInterface::class));
        }

        /** @var EntityVersionLockRepository $objectRepository */
        $objectRepository = $this->objectManager->getRepository(EntityVersionLock::class);

        return $objectRepository->getLocksForLockableEntity($entity, $this->threshold, $userToExclude);
    }

    /**
     * Get or create a LockableEntity for an entity with LockableEntityInterface
     *
     * @param LockableEntityInterface $entity
     *
     * @return LockableEntity
     */
    protected function getLockableEntity(LockableEntityInterface $entity, $create = true)
    {
        /** @var LockableEntity $lockable */
        $lockable = $this->objectManager->getRepository(LockableEntity::class)->getOrCreate($entity->getId(), \get_class($entity));

It seems like you code against a concrete implementation and not the interface Doctrine\Persistence\ObjectRepository as the method getOrCreate() does only exist in the following implementations of said interface: Kunstmaan\AdminListBundle\Repository\LockableEntityRepository.

        if ($create === true && $lockable->getId() === null) {
            $this->objectManager->persist($lockable);
            $this->objectManager->flush();
        }

        return $lockable;
    }

    /**
     * @param ObjectManager $objectManager
     */
    public function setObjectManager($objectManager)
    {
        $this->objectManager = $objectManager;
    }

    /**
     * @param int $threshold
     */
    public function setThreshold($threshold)
    {
        $this->threshold = $threshold;
    }

    /**
     * @param bool lockEnabled
     */
    public function setLockEnabled($lockEnabled)
    {
        $this->lockEnabled = $lockEnabled;
    }
}