Issues in EntityVersionLockService.php - All Issues - Inspection of "Merge branch '5.3'" - Kunstmaan/KunstmaanBundlesCMS - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 770316...74fc07 )

by Jeroen

created 2019-10-18 13:07 UTC

Service/EntityVersionLockService.php (2 issues)

Showing only issues like (Show All)

Check that @param annotations have the correct type.

Documentation Informational

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php

namespace Kunstmaan\AdminListBundle\Service;

use Doctrine\Common\Persistence\ObjectManager;
use FOS\UserBundle\Model\User;
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(User $user, LockableEntityInterface $entity)
    {
        /** @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(User $user, LockableEntity $entity)
    {
        /** @var EntityVersionLock $lock */
        $lock = $this->objectManager->getRepository('KunstmaanAdminListBundle:EntityVersionLock')->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

     *
     * @return array
     */
    public function getUsersWithEntityVersionLock(LockableEntityInterface $entity, User $userToExclude = null)
    {
        /** @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('KunstmaanAdminListBundle:EntityVersionLock')->getExpiredLocks($entity, $this->threshold);
        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

     *
     * @return EntityVersionLock[]
     */
    protected function getEntityVersionLocksByLockableEntity(LockableEntity $entity, User $userToExclude = null)
    {
        /** @var EntityVersionLockRepository $objectRepository */
        $objectRepository = $this->objectManager->getRepository('KunstmaanAdminListBundle:EntityVersionLock');

        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('KunstmaanAdminListBundle:LockableEntity')->getOrCreate($entity->getId(), \get_class($entity));

        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;
    }
}


1		<?php
2
3		namespace Kunstmaan\AdminListBundle\Service;
4
5		use Doctrine\Common\Persistence\ObjectManager;
6		use FOS\UserBundle\Model\User;
7		use Kunstmaan\AdminListBundle\Entity\LockableEntity;
8		use Kunstmaan\AdminListBundle\Entity\EntityVersionLock;
9		use Kunstmaan\AdminListBundle\Entity\LockableEntityInterface;
10		use Kunstmaan\AdminListBundle\Repository\EntityVersionLockRepository;
11
12		class EntityVersionLockService
13		{
14		/**
15		* @var ObjectManager
16		*/
17		private $objectManager;
18
19		/**
20		* @var int
21		*/
22		private $threshold;
23
24		/**
25		* @var bool
26		*/
27		private $lockEnabled;
28
29	6	public function __construct(ObjectManager $em, $threshold, $lockEnabled)
30		{
31	6	$this->setObjectManager($em);
32	6	$this->setThreshold($threshold);
33	6	$this->setLockEnabled($lockEnabled);
34	6	}
35
36		/**
37		* @param LockableEntityInterface $entity
38		*
39		* @return bool
40		*/
41	3	public function isEntityBelowThreshold(LockableEntityInterface $entity)
42		{
43		/** @var LockableEntity $lockable */
44	3	$lockable = $this->getLockableEntity($entity, false);
45
46	3	if ($this->lockEnabled && $lockable->getId() !== null) {
47	2	$now = new \DateTime();
48	2	$thresholdDate = clone $lockable->getUpdated();
49	2	$thresholdDate->add(new \DateInterval('PT'.$this->threshold.'S'));
50
51	2	return $thresholdDate > $now;
52		}
53
54	1	return false;
55		}
56
57		/**
58		* @param User $user
59		* @param LockableEntityInterface $entity
60		*
61		* @return bool
62		*/
63	2	public function isEntityLocked(User $user, LockableEntityInterface $entity)
64		{
65		/** @var LockableEntity $lockable */
66	2	$lockable = $this->getLockableEntity($entity);
67
68	2	if ($this->lockEnabled) {
69	2	$this->removeExpiredLocks($lockable);
70	2	$locks = $this->getEntityVersionLocksByLockableEntity($lockable, $user);
71
72	2	if ($locks === null \|\| !\count($locks)) {
73	1	$this->createEntityVersionLock($user, $lockable);
74
75	1	$lockable->setUpdated(new \DateTime());
76	1	$this->objectManager->flush();
77
78	1	return false;
79		}
80
81	1	return true;
82		}
83
84		return false;
85		}
86
87		/**
88		* When editing the entity, create a new entity translation lock.
89		*
90		* @param User $user
91		* @param LockableEntity $entity
92		*/
93	1	protected function createEntityVersionLock(User $user, LockableEntity $entity)
94		{
95		/** @var EntityVersionLock $lock */
96	1	$lock = $this->objectManager->getRepository('KunstmaanAdminListBundle:EntityVersionLock')->findOneBy([
97	1	'owner' => $user->getUsername(),
98	1	'lockableEntity' => $entity,
99		]);
100	1	if (!$lock) {
101		$lock = new EntityVersionLock();
102		}
103	1	$lock->setOwner($user->getUsername());
104	1	$lock->setLockableEntity($entity);
105	1	$lock->setCreatedAt(new \DateTime());
106	1	$this->objectManager->persist($lock);
107	1	$this->objectManager->flush();
108	1	}
109
110		/**
111		* @param LockableEntityInterface $entity
112		* @param User $userToExclude
		0 ignored issues – show Documentation introduced 2017-11-21 06:15 UTC by Report Bug Copy Issue Report Show Similar Issues like this Should the type for parameter `$userToExclude` not be `null\|User`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
113		*
114		* @return array
115		*/
116	1	public function getUsersWithEntityVersionLock(LockableEntityInterface $entity, User $userToExclude = null)
117		{
118		/** @var LockableEntity $lockable */
119	1	$lockable = $this->getLockableEntity($entity);
120
121	1	return array_reduce(
122	1	$this->getEntityVersionLocksByLockableEntity($lockable, $userToExclude),
123		function ($return, EntityVersionLock $item) {
124	1	$return[] = $item->getOwner();
125
126	1	return $return;
127	1	},
128	1	[]
129		);
130		}
131
132		/**
133		* @param LockableEntity $entity
134		*/
135	2	protected function removeExpiredLocks(LockableEntity $entity)
136		{
137	2	$locks = $this->objectManager->getRepository('KunstmaanAdminListBundle:EntityVersionLock')->getExpiredLocks($entity, $this->threshold);
138	2	foreach ($locks as $lock) {
139	2	$this->objectManager->remove($lock);
140		}
141	2	}
142
143		/**
144		* When editing an entity, check if there is a lock for this entity.
145		*
146		* @param LockableEntity $entity
147		* @param User $userToExclude
		0 ignored issues – show Documentation introduced 2018-09-26 07:17 UTC by Report Bug Copy Issue Report Show Similar Issues like this Should the type for parameter `$userToExclude` not be `null\|User`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
148		*
149		* @return EntityVersionLock[]
150		*/
151	3	protected function getEntityVersionLocksByLockableEntity(LockableEntity $entity, User $userToExclude = null)
152		{
153		/** @var EntityVersionLockRepository $objectRepository */
154	3	$objectRepository = $this->objectManager->getRepository('KunstmaanAdminListBundle:EntityVersionLock');
155
156	3	return $objectRepository->getLocksForLockableEntity($entity, $this->threshold, $userToExclude);
157		}
158
159		/**
160		* Get or create a LockableEntity for an entity with LockableEntityInterface
161		*
162		* @param LockableEntityInterface $entity
163		*
164		* @return LockableEntity
165		*/
166	6	protected function getLockableEntity(LockableEntityInterface $entity, $create = true)
167		{
168		/** @var LockableEntity $lockable */
169	6	$lockable = $this->objectManager->getRepository('KunstmaanAdminListBundle:LockableEntity')->getOrCreate($entity->getId(), \get_class($entity));
170
171	6	if ($create === true && $lockable->getId() === null) {
172		$this->objectManager->persist($lockable);
173		$this->objectManager->flush();
174		}
175
176	6	return $lockable;
177		}
178
179		/**
180		* @param ObjectManager $objectManager
181		*/
182	6	public function setObjectManager($objectManager)
183		{
184	6	$this->objectManager = $objectManager;
185	6	}
186
187		/**
188		* @param int $threshold
189		*/
190	6	public function setThreshold($threshold)
191		{
192	6	$this->threshold = $threshold;
193	6	}
194
195		/**
196		* @param bool lockEnabled
197		*/
198	6	public function setLockEnabled($lockEnabled)
199		{
200	6	$this->lockEnabled = $lockEnabled;
201	6	}
202		}
203

Kunstmaan / KunstmaanBundlesCMS

Push — master ( 770316...74fc07 )

Service/EntityVersionLockService.php (2 issues)

Showing only issues like (Show All)

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like