InvalidateTokensAction::__construct() - Code Metrics - Inspection of "test coverage improvements;" - SlayerBirden/dataflow-server - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 178a08...5c0b6f )

by Oleg

created 2018-07-26 21:57 UTC

InvalidateTokensAction::__construct() A

↳ Parent: InvalidateTokensAction

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	6
ccs	5
cts	5
cp	1
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	3
crap	1

<?php
declare(strict_types=1);

namespace SlayerBirden\DataFlowServer\Authentication\Controller;

use Doctrine\Common\Collections\Criteria;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\ORMException;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Psr\Log\LoggerInterface;
use SlayerBirden\DataFlowServer\Authentication\Entities\Token;
use SlayerBirden\DataFlowServer\Domain\Entities\User;
use SlayerBirden\DataFlowServer\Notification\SuccessMessage;
use Zend\Diactoros\Response\JsonResponse;
use Zend\Hydrator\HydratorInterface;

class InvalidateTokensAction implements MiddlewareInterface
{
    /**
     * @var EntityManager
     */
    private $entityManager;
    /**
     * @var LoggerInterface
     */
    private $logger;
    /**
     * @var HydratorInterface
     */
    private $hydrator;

    public function __construct(EntityManager $entityManager, LoggerInterface $logger, HydratorInterface $hydrator)
function someFunction(ManagerRegistry $registry) {
    $em = $registry->getManager();
    $em->getConnection()->beginTransaction();
    try {
        // Do something.
        $em->getConnection()->commit();
    } catch (\Exception $ex) {
        $em->getConnection()->rollback();
        $em->close();

        throw $ex;
    }
}
    {
        $this->entityManager = $entityManager;
        $this->logger = $logger;
        $this->hydrator = $hydrator;
    }

    /**
     * {@inheritdoc}
     * @throws ORMException
     * @throws \Doctrine\ORM\OptimisticLockException
     */
    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
    {
        $data = $request->getParsedBody();

        $users = $data['users'] ?? [];
        return $this->invalidate($users);
    }

    /**
     * @param array $users
     * @return ResponseInterface
     * @throws ORMException
     * @throws \Doctrine\ORM\OptimisticLockException
     */
    private function invalidate(array $users = []): ResponseInterface
    {
        $criteria = Criteria::create();
        $criteria->where(Criteria::expr()->eq('active', true));
        if (!empty($users)) {
            $criteria->andWhere(Criteria::expr()->in('owner', $this->getUsers($users)));
        }

        $collection = $this->entityManager
            ->getRepository(Token::class)
            ->matching($criteria);

        if ($collection->count() === 0) {
            return new JsonResponse([
                'data' => [
                    'count' => 0,
                    'tokens' => [],
                ],
                'success' => false,
                'msg' => new SuccessMessage('No tokens found to invalidate for given criteria.'),
            ], 400);
        }
        foreach ($collection as $token) {
            $token->setActive(false);
            $this->entityManager->persist($token);
        }
        $this->entityManager->flush();
        return new JsonResponse([
            'data' => [
                'count' => $collection->count(),
                'tokens' => array_map([$this->hydrator, 'extract'], $collection->toArray()),
            ],
            'success' => true,
            'msg' => new SuccessMessage('Tokens have been deactivated.'),
        ], 200);
    }

    private function getUsers(array $users): array
    {
        $collection = $this->entityManager
            ->getRepository(User::class)
            ->matching(
                Criteria::create()->where(Criteria::expr()->in('id', $users))
            );
        return $collection->toArray();
    }
}


1		<?php
2		declare(strict_types=1);
3
4		namespace SlayerBirden\DataFlowServer\Authentication\Controller;
5
6		use Doctrine\Common\Collections\Criteria;
7		use Doctrine\ORM\EntityManager;
8		use Doctrine\ORM\ORMException;
9		use Psr\Http\Message\ResponseInterface;
10		use Psr\Http\Message\ServerRequestInterface;
11		use Psr\Http\Server\MiddlewareInterface;
12		use Psr\Http\Server\RequestHandlerInterface;
13		use Psr\Log\LoggerInterface;
14		use SlayerBirden\DataFlowServer\Authentication\Entities\Token;
15		use SlayerBirden\DataFlowServer\Domain\Entities\User;
16		use SlayerBirden\DataFlowServer\Notification\SuccessMessage;
17		use Zend\Diactoros\Response\JsonResponse;
18		use Zend\Hydrator\HydratorInterface;
19
20		class InvalidateTokensAction implements MiddlewareInterface
21		{
22		/**
23		* @var EntityManager
24		*/
25		private $entityManager;
26		/**
27		* @var LoggerInterface
28		*/
29		private $logger;
30		/**
31		* @var HydratorInterface
32		*/
33		private $hydrator;
34
35	3	public function __construct(EntityManager $entityManager, LoggerInterface $logger, HydratorInterface $hydrator)
		0 ignored issues – show Bug introduced 2018-06-19 09:10 UTC by Report Bug Copy Issue Report You have injected the EntityManager via parameter `$entityManager`. This is generally not recommended as it might get closed and become unusable. Instead, it is recommended to inject the ManagerRegistry and retrieve the EntityManager via `getManager()` each time you need it. The `EntityManager` might become unusable for example if a transaction is rolled back and it gets closed. Let’s assume that somewhere in your application, or in a third-party library, there is code such as the following: function someFunction(ManagerRegistry $registry) { $em = $registry->getManager(); $em->getConnection()->beginTransaction(); try { // Do something. $em->getConnection()->commit(); } catch (\Exception $ex) { $em->getConnection()->rollback(); $em->close(); throw $ex; } } If that code throws an exception and the `EntityManager` is closed. Any other code which depends on the same instance of the `EntityManager` during this request will fail. On the other hand, if you instead inject the `ManagerRegistry`, the `getManager()` method guarantees that you will always get a usable manager instance. Loading history...
36		{
37	3	$this->entityManager = $entityManager;
38	3	$this->logger = $logger;
39	3	$this->hydrator = $hydrator;
40	3	}
41
42		/**
43		* {@inheritdoc}
44		* @throws ORMException
45		* @throws \Doctrine\ORM\OptimisticLockException
46		*/
47	3	public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
48		{
49	3	$data = $request->getParsedBody();
50
51	3	$users = $data['users'] ?? [];
52	3	return $this->invalidate($users);
53		}
54
55		/**
56		* @param array $users
57		* @return ResponseInterface
58		* @throws ORMException
59		* @throws \Doctrine\ORM\OptimisticLockException
60		*/
61	3	private function invalidate(array $users = []): ResponseInterface
62		{
63	3	$criteria = Criteria::create();
64	3	$criteria->where(Criteria::expr()->eq('active', true));
65	3	if (!empty($users)) {
66	2	$criteria->andWhere(Criteria::expr()->in('owner', $this->getUsers($users)));
67		}
68
69	3	$collection = $this->entityManager
70	3	->getRepository(Token::class)
71	3	->matching($criteria);
72
73	3	if ($collection->count() === 0) {
74	1	return new JsonResponse([
75	1	'data' => [
76		'count' => 0,
77		'tokens' => [],
78		],
79		'success' => false,
80	1	'msg' => new SuccessMessage('No tokens found to invalidate for given criteria.'),
81	1	], 400);
82		}
83	2	foreach ($collection as $token) {
84	2	$token->setActive(false);
85	2	$this->entityManager->persist($token);
86		}
87	2	$this->entityManager->flush();
88	2	return new JsonResponse([
89	2	'data' => [
90	2	'count' => $collection->count(),
91	2	'tokens' => array_map([$this->hydrator, 'extract'], $collection->toArray()),
92		],
93		'success' => true,
94	2	'msg' => new SuccessMessage('Tokens have been deactivated.'),
95	2	], 200);
96		}
97
98	2	private function getUsers(array $users): array
99		{
100	2	$collection = $this->entityManager
101	2	->getRepository(User::class)
102	2	->matching(
103	2	Criteria::create()->where(Criteria::expr()->in('id', $users))
104		);
105	2	return $collection->toArray();
106		}
107		}
108

SlayerBirden / dataflow-server

Push — master ( 178a08...5c0b6f )

InvalidateTokensAction::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like