EntityVersionLockService::createEntityVersionLock() - Code Metrics - Inspection of "Merge pull request #2825 from OskarStark/sort-rule..." - Kunstmaan/KunstmaanBundlesCMS - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 5.6 ( 679697...f4d50c )

by Jeroen

created 2020-11-06 07:24 UTC

createEntityVersionLock() A

↳ Parent: EntityVersionLockService

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	11
CRAP Score	2.0023

Importance

Changes

Metric	Value
dl	0
loc	16
ccs	11
cts	12
cp	0.9167
rs	9.7333
c	0
b	0
f	0
cc	2
nc	2
nop	2
crap	2.0023

<?php

namespace Kunstmaan\AdminListBundle\Service;

use Doctrine\Common\Persistence\ObjectManager;
use FOS\UserBundle\Model\User;
use Kunstmaan\AdminListBundle\Entity\EntityVersionLock;
use Kunstmaan\AdminListBundle\Entity\LockableEntity;
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);
    }

    /**
     * @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;
    }

    /**
     * @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.
     */
    protected function createEntityVersionLock(User $user, LockableEntity $entity)
    {
        /** @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 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;
            },
            []
        );
    }

    protected function removeExpiredLocks(LockableEntity $entity)
    {
        $locks = $this->objectManager->getRepository(EntityVersionLock::class)->getExpiredLocks($entity, $this->threshold);
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
        foreach ($locks as $lock) {
            $this->objectManager->remove($lock);
        }
    }

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

     *
     * @return EntityVersionLock[]

     */
    protected function getEntityVersionLocksByLockableEntity(LockableEntity $entity, User $userToExclude = null)
    {
        /** @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
     *
     * @return LockableEntity
     */
    protected function getLockableEntity(LockableEntityInterface $entity, $create = true)
    {
        /** @var LockableEntity $lockable */
        $lockable = $this->objectManager->getRepository(LockableEntity::class)->getOrCreate($entity->getId(), \get_class($entity));
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}

        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\EntityVersionLock;
8		use Kunstmaan\AdminListBundle\Entity\LockableEntity;
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		* @return bool
38		*/
39	3	public function isEntityBelowThreshold(LockableEntityInterface $entity)
40		{
41		/** @var LockableEntity $lockable */
42	3	$lockable = $this->getLockableEntity($entity, false);
43
44	3	if ($this->lockEnabled && $lockable->getId() !== null) {
45	2	$now = new \DateTime();
46	2	$thresholdDate = clone $lockable->getUpdated();
47	2	$thresholdDate->add(new \DateInterval('PT' . $this->threshold . 'S'));
48
49	2	return $thresholdDate > $now;
50		}
51
52	1	return false;
53		}
54
55		/**
56		* @return bool
57		*/
58	2	public function isEntityLocked(User $user, LockableEntityInterface $entity)
59		{
60		/** @var LockableEntity $lockable */
61	2	$lockable = $this->getLockableEntity($entity);
62
63	2	if ($this->lockEnabled) {
64	2	$this->removeExpiredLocks($lockable);
65	2	$locks = $this->getEntityVersionLocksByLockableEntity($lockable, $user);
66
67	2	if ($locks === null \|\| !\count($locks)) {
68	1	$this->createEntityVersionLock($user, $lockable);
69
70	1	$lockable->setUpdated(new \DateTime());
71	1	$this->objectManager->flush();
72
73	1	return false;
74		}
75
76	1	return true;
77		}
78
79		return false;
80		}
81
82		/**
83		* When editing the entity, create a new entity translation lock.
84		*/
85	1	protected function createEntityVersionLock(User $user, LockableEntity $entity)
86		{
87		/** @var EntityVersionLock $lock */
88	1	$lock = $this->objectManager->getRepository(EntityVersionLock::class)->findOneBy([
89	1	'owner' => $user->getUsername(),
90	1	'lockableEntity' => $entity,
91		]);
92	1	if (!$lock) {
93		$lock = new EntityVersionLock();
94		}
95	1	$lock->setOwner($user->getUsername());
96	1	$lock->setLockableEntity($entity);
97	1	$lock->setCreatedAt(new \DateTime());
98	1	$this->objectManager->persist($lock);
99	1	$this->objectManager->flush();
100	1	}
101
102		/**
103		* @param User $userToExclude
		0 ignored issues – show Documentation introduced 2020-11-05 15:54 UTC by Report Bug Copy Issue Report 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...
104		*
105		* @return array
106		*/
107	1	public function getUsersWithEntityVersionLock(LockableEntityInterface $entity, User $userToExclude = null)
108		{
109		/** @var LockableEntity $lockable */
110	1	$lockable = $this->getLockableEntity($entity);
111
112	1	return array_reduce(
113	1	$this->getEntityVersionLocksByLockableEntity($lockable, $userToExclude),
114		function ($return, EntityVersionLock $item) {
115	1	$return[] = $item->getOwner();
116
117	1	return $return;
118	1	},
119	1	[]
120		);
121		}
122
123	2	protected function removeExpiredLocks(LockableEntity $entity)
124		{
125	2	$locks = $this->objectManager->getRepository(EntityVersionLock::class)->getExpiredLocks($entity, $this->threshold);
		0 ignored issues – show Bug introduced 2020-04-13 12:32 UTC by Report Bug Copy Issue Report 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\AdminListBundl...tyVersionLockRepository`, `Kunstmaan\NodeBundle\Rep...deVersionLockRepository`. Let’s take a look at an example: interface User { /** @return string / public function getPassword(); } class MyUser implements User { public function getPassword() { // return something } public function getDisplayName() { // return some name. } } class AuthSystem { public function authenticate(User $user) { $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName())); // do something. } } In the above example, the authenticate() method works fine as long as you just pass instances of MyUser. However, if you now also want to pass a different implementation of User which does not have a getDisplayName() method, the code will break. Available Fixes Change the type-hint for the parameter: class AuthSystem { public function authenticate(MyUser $user) { / ... / } } Add an additional type-check: class AuthSystem { public function authenticate(User $user) { if ($user instanceof MyUser) { $this->logger->info(/* ... /); } // or alternatively if ( ! $user instanceof MyUser) { throw new \LogicException( '$user must be an instance of MyUser, ' .'other instances are not supported.' ); } } } Note:* PHP Analyzer uses reverse abstract interpretation to narrow down the types inside the if block in such a case. Add the method to the interface: interface User { /** @return string / public function getPassword(); /* @return string */ public function getDisplayName(); } Loading history...
126	2	foreach ($locks as $lock) {
127	2	$this->objectManager->remove($lock);
128		}
129	2	}
130
131		/**
132		* When editing an entity, check if there is a lock for this entity.
133		*
134		* @param User $userToExclude
		0 ignored issues – show Documentation introduced 2020-11-05 15:54 UTC by Report Bug Copy Issue Report 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...
135		*
136		* @return EntityVersionLock[]
		0 ignored issues – show Documentation introduced 2018-09-26 07:17 UTC by Report Bug Copy Issue Report Should the return type not be `\Kunstmaan\AdminListBund...ory\EntityVersionLock[]`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
137		*/
138	3	protected function getEntityVersionLocksByLockableEntity(LockableEntity $entity, User $userToExclude = null)
139		{
140		/** @var EntityVersionLockRepository $objectRepository */
141	3	$objectRepository = $this->objectManager->getRepository(EntityVersionLock::class);
142
143	3	return $objectRepository->getLocksForLockableEntity($entity, $this->threshold, $userToExclude);
144		}
145
146		/**
147		* Get or create a LockableEntity for an entity with LockableEntityInterface
148		*
149		* @return LockableEntity
150		*/
151	6	protected function getLockableEntity(LockableEntityInterface $entity, $create = true)
152		{
153		/** @var LockableEntity $lockable */
154	6	$lockable = $this->objectManager->getRepository(LockableEntity::class)->getOrCreate($entity->getId(), \get_class($entity));
		0 ignored issues – show Bug introduced 2020-04-13 12:32 UTC by Report Bug Copy Issue Report 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\AdminListBundl...ockableEntityRepository`. Let’s take a look at an example: interface User { /** @return string / public function getPassword(); } class MyUser implements User { public function getPassword() { // return something } public function getDisplayName() { // return some name. } } class AuthSystem { public function authenticate(User $user) { $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName())); // do something. } } In the above example, the authenticate() method works fine as long as you just pass instances of MyUser. However, if you now also want to pass a different implementation of User which does not have a getDisplayName() method, the code will break. Available Fixes Change the type-hint for the parameter: class AuthSystem { public function authenticate(MyUser $user) { / ... / } } Add an additional type-check: class AuthSystem { public function authenticate(User $user) { if ($user instanceof MyUser) { $this->logger->info(/* ... /); } // or alternatively if ( ! $user instanceof MyUser) { throw new \LogicException( '$user must be an instance of MyUser, ' .'other instances are not supported.' ); } } } Note:* PHP Analyzer uses reverse abstract interpretation to narrow down the types inside the if block in such a case. Add the method to the interface: interface User { /** @return string / public function getPassword(); /* @return string */ public function getDisplayName(); } Loading history...
155
156	6	if ($create === true && $lockable->getId() === null) {
157		$this->objectManager->persist($lockable);
158		$this->objectManager->flush();
159		}
160
161	6	return $lockable;
162		}
163
164		/**
165		* @param ObjectManager $objectManager
166		*/
167	6	public function setObjectManager($objectManager)
168		{
169	6	$this->objectManager = $objectManager;
170	6	}
171
172		/**
173		* @param int $threshold
174		*/
175	6	public function setThreshold($threshold)
176		{
177	6	$this->threshold = $threshold;
178	6	}
179
180		/**
181		* @param bool lockEnabled
182		*/
183	6	public function setLockEnabled($lockEnabled)
184		{
185	6	$this->lockEnabled = $lockEnabled;
186	6	}
187		}
188

Kunstmaan / KunstmaanBundlesCMS

Push — 5.6 ( 679697...f4d50c )

createEntityVersionLock() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like