SlayerBirden\DataFlowServer\Db\Controller\GetConfigsAction

Complexity

Total Complexity

12

Size/Duplication

Total Lines	120
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

92.45%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
B	process()	0	66	6
A	buildCriteria()	0	24	5

<?php
declare(strict_types=1);

namespace SlayerBirden\DataFlowServer\Db\Controller;

use Doctrine\Common\Collections\Collection;
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\Middleware\TokenMiddleware;
use SlayerBirden\DataFlowServer\Db\Entities\DbConfiguration;
use SlayerBirden\DataFlowServer\Notification\DangerMessage;
use Zend\Diactoros\Response\JsonResponse;
use Zend\Hydrator\HydratorInterface;

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

    public function __construct(
        EntityManager $entityManager,

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.

        LoggerInterface $logger,
        HydratorInterface $hydrator
    ) {
        $this->entityManager = $entityManager;
        $this->logger = $logger;
        $this->hydrator = $hydrator;
    }

    /**
     * @inheritdoc
     */
    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
    {
        $data = $request->getQueryParams();
        $page = isset($data['p']) ? abs($data['p']) : 1;
        $limit = isset($data['l']) ? abs($data['l']) : 10;
        $filters = $data['f'] ?? [];
        $sorting = $data['s'] ?? [];


        $currentOwner = $request->getAttribute(TokenMiddleware::USER_PARAM);

        if (!$currentOwner) {
            return new JsonResponse([
                'data' => [
                    'configurations' => [],
                    'count' => 0,
                ],
                'msg' => new DangerMessage('Access denied. Only Logged In users can access this resource.'),
                'success' => false
            ], 403);
        }
        $filters['owner'] = $currentOwner;

        try {
            $criteria = $this->buildCriteria($filters, $sorting, $page, $limit);

            /** @var Collection $configs */
            $configs = $this->entityManager
                ->getRepository(DbConfiguration::class)
                ->matching($criteria);
            // before collection load to count all records without pagination
            $count = $configs->count();
            if ($count > 0) {
                $arrayConfigs = array_map(function ($config) {
                    return $this->hydrator->extract($config);
                }, $configs->toArray());
                return new JsonResponse([
                    'data' => [
                        'configurations' => $arrayConfigs,
                        'count' => $count,
                    ],
                    'success' => true,
                    'msg' => null,
                ], 200);
            } else {
                return new JsonResponse([
                    'data' => [
                        'configurations' => [],
                        'count' => 0,
                    ],
                    'success' => false,
                    'msg' => new DangerMessage('Could not find configurations using given conditions.'),
                ], 404);
            }
        } catch (ORMException $exception) {
            $this->logger->error((string)$exception);
            return new JsonResponse([
                'data' => [
                    'configurations' => [],
                    'count' => 0,
                ],
                'success' => false,
                'msg' => new DangerMessage('There was an error while fetching configurations.'),
            ], 400);
        }
    }

    private function buildCriteria(
        array $filters = [],
        array $sorting = [],
        int $page = 1,
        int $limit = 10
    ): Criteria {
        $criteria = Criteria::create();
        $criteria->setFirstResult(($page - 1) * $limit)
            ->setMaxResults($limit);
        foreach ($filters as $key => $value) {
            if (is_string($value)) {
                $criteria->andWhere(Criteria::expr()->contains($key, $value));
            } else {
                $criteria->andWhere(Criteria::expr()->eq($key, $value));
            }
        }
        if ($sorting) {

The expression $sorting of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            foreach ($sorting as $key => $dir) {
                $criteria->orderBy($sorting);
            }
        }

        return $criteria;
    }
}