hiapi\commands\SearchHandler

Complexity

Total Complexity

9

Size/Duplication

Total Lines	73
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

0%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	createSpecification()	0	4	1
A	handle()	0	11	2
A	buildSpecification()	0	19	4
A	getRepository()	0	4	1

<?php
/**
 * HiAPI Yii2 base project for building API
 *
 * @link      https://github.com/hiqdev/hiapi
 * @package   hiapi
 * @license   BSD-3-Clause
 * @copyright Copyright (c) 2017, HiQDev (http://hiqdev.com/)
 */

namespace hiapi\commands;

use hiqdev\DataMapper\Query\Specification;
use hiqdev\DataMapper\Repository\RepositoryInterface;
use hiqdev\DataMapper\Repository\EntityManagerInterface;

/**
 * Class SearchHandler
 *
 * @author Dmytro Naumenko <d.naumenko.a@gmail.com>
 */
class SearchHandler
{
    /**
     * @var EntityManagerInterface
     */
    private $em;

    /**
     * SearchHandler constructor.
     *
     * @param EntityManagerInterface $em
     */
    public function __construct(EntityManagerInterface $em)
    {
        $this->em = $em;
    }

    /**
     * @return Specification
     */
    protected function createSpecification()
    {
        return new Specification();
    }

    /**
     * @param SearchCommand $command
     */
    public function handle(EntityCommandInterface $command)
    {
        $repo = $this->getRepository($command);

$command of type object<hiapi\commands\EntityCommandInterface> is not a sub-type of object<hiapi\commands\EntityCommand>. It seems like you assume a concrete implementation of the interface hiapi\commands\EntityCommandInterface to be always present.

        $specification = $this->buildSpecification($command);

        if ($command->count) {

Accessing count on the interface hiapi\commands\EntityCommandInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

            return $repo->count($specification);
        }

        return $repo->findAll($specification);
    }

    /**
     * @param EntityCommandInterface|SearchCommand $command
     * @return Specification
     */
    protected function buildSpecification(EntityCommandInterface $command)
    {
        $spec = $this->createSpecification();
        $spec->where(array_merge($command->filter, $command->where));

Accessing filter on the interface hiapi\commands\EntityCommandInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

Accessing where on the interface hiapi\commands\EntityCommandInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

        if (!$command->count) {

Accessing count on the interface hiapi\commands\EntityCommandInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

            if (strtolower($command->limit) === 'all') {

Accessing limit on the interface hiapi\commands\EntityCommandInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

                $command->limit = -1;

Accessing limit on the interface hiapi\commands\EntityCommandInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

            }
            $limit = $command->limit ?? 25;

Accessing limit on the interface hiapi\commands\EntityCommandInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

            $spec->limit($limit);
            if ($limit !== -1) {
                $spec->offset((($command->page ?? 0) * $limit) - $limit);

Accessing page on the interface hiapi\commands\EntityCommandInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

            }
            $spec->with(array_merge($command->include, $command->with));

Accessing include on the interface hiapi\commands\EntityCommandInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

Accessing with on the interface hiapi\commands\EntityCommandInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

        }

        return $spec;
    }

    /**
     * @param SearchCommand $command
     * @return RepositoryInterface
     */
    protected function getRepository(EntityCommand $command)
    {
        return $this->em->getRepository($command->getEntityClass());
    }
}