DoctrineElastic\Query\ElasticQueryExecutor

Complexity

Total Complexity

9

Size/Duplication

Total Lines	80
Duplicated Lines	13.75 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	execute()	0	20	3
A	hydrateEntityWith()	11	11	2
A	fetchElasticResult()	0	13	2
A	createEventArgs()	0	7	1

<?php

namespace DoctrineElastic\Query;

use DoctrineElastic\Elastic\DoctrineElasticEvents;
use DoctrineElastic\Elastic\SearchParams;
use DoctrineElastic\Elastic\SearchParser;
use DoctrineElastic\ElasticEntityManager;
use DoctrineElastic\Event\QueryEventArgs;
use DoctrineElastic\Hydrate\AnnotationEntityHydrator;
use DoctrineElastic\Mapping\Field;
use DoctrineElastic\Mapping\MetaField;

/**
 * Class for query execution with entity hydration task
 *
 * @author Ands
 */
class ElasticQueryExecutor {

    /** @var AnnotationEntityHydrator */
    private $_hydrator;

    /** @var ElasticEntityManager */
    private $_eem;

    public function __construct(ElasticEntityManager $elasticEntityManager) {
        $this->_eem = $elasticEntityManager;
        $this->_hydrator = new AnnotationEntityHydrator();
    }

    /**
     * Executes a elastic query from $searchParams, creates a hydrated entity $entityClass object
     * with the results
     *
     * @param SearchParams $searchParams
     * @param $entityClass
     * @return array
     */
    public function execute(SearchParams $searchParams, $entityClass) {
        if (!$searchParams->isValid()) {
            throw new \InvalidArgumentException('Elastic search params are invalid for request. ');
        }

        $eventArgs = $this->createEventArgs($entityClass);
        $this->_eem->getEventManager()->dispatchEvent(DoctrineElasticEvents::beforeQuery, $eventArgs);

        $resultSets = $this->fetchElasticResult($searchParams);
        $results = [];

        foreach ($resultSets as $resultSet) {
            $results[] = $this->hydrateEntityWith(new $entityClass(), $resultSet);
        }

        $eventArgs->setResults($results);
        $this->_eem->getEventManager()->dispatchEvent(DoctrineElasticEvents::postQuery, $eventArgs);

        return $results;
    }

    private function hydrateEntityWith($entity, array $rawData) {

This method seems to be duplicated in your project.

        $this->_hydrator->hydrate($entity, $rawData);
        $this->_hydrator->hydrateByAnnotation($entity, Field::class, $rawData);
        $this->_hydrator->hydrateByAnnotation($entity, MetaField::class, $rawData);

        if (isset($rawData['_source'])) {
            $this->hydrateEntityWith($entity, $rawData['_source']);
        }

        return $entity;
    }

    private function fetchElasticResult(SearchParams $searchParams) {
        $results = [];
        $connection = $this->_eem->getConnection();

        if ($connection->getElasticClient()->indices()->exists(['index' => $searchParams->getIndex()])) {
            $arrayParams = SearchParser::parseSearchParams($searchParams);
            $results = $connection->search(
                $arrayParams['index'], $arrayParams['type'], $arrayParams['body'], $arrayParams
            );
        }

        return $results;
    }

    /**
     * @param $entityClass
     * @return QueryEventArgs
     */
    private function createEventArgs($entityClass) {
        $eventArgs = new QueryEventArgs();
        $eventArgs->setTargetEntity($entityClass);
        $eventArgs->setEntityManager($this->_eem);

        return $eventArgs;
    }
}