Search::__construct() - Code Metrics - Inspection of "Changed namespace path to leopard." - triadev/Leopard - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Branch — master (8cb5b2)

by Christopher
created 2018-12-17 13:21 UTC
Search::__construct() A

↳ Parent: Search
Complexity

Conditions	1
Paths	1
Size

Total Lines	9
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	4
CRAP Score	1
Importance

Changes
Metric	Value
cc	1
eloc	3
nc	1
nop	2
dl	0
loc	9
ccs	4
cts	4
cp	1
crap	1
rs	10
c	0
b	0
f	0
<?php
namespace Triadev\Leopard\Business\Dsl;

use Illuminate\Database\Eloquent\Model;
use ONGR\ElasticsearchDSL\Sort\FieldSort;
use Triadev\Leopard\Busines\Dsl\Query\Specialized;
use Triadev\Leopard\Business\Dsl\Query\Compound;
use Triadev\Leopard\Business\Dsl\Query\Fulltext;
use Triadev\Leopard\Business\Dsl\Query\Geo;
use Triadev\Leopard\Business\Dsl\Query\InnerHit;
use Triadev\Leopard\Business\Dsl\Query\Joining;
use Triadev\Leopard\Business\Filler\EloquentFiller;
use Triadev\Leopard\Business\Helper\IsModelSearchable;
use Triadev\Leopard\Contract\ElasticsearchManagerContract;
use Triadev\Leopard\Contract\FillerContract;
use Triadev\Leopard\Searchable;
use Triadev\Leopard\Model\SearchResult;
use Triadev\Leopard\Business\Dsl\Query\TermLevel;

class Search extends AbstractQuery
{
    use IsModelSearchable;
    
    /** @var string */
    private $index;
    
    /** @var string */
    private $type;
    
    /** @var Model */
    private $model;
    
    /** @var ElasticsearchManagerContract */
    private $manager;
    
    /**
     * Search constructor.
     * @param ElasticsearchManagerContract $manager
     * @param \ONGR\ElasticsearchDSL\Search|null $search
     */
    public function __construct(
        ElasticsearchManagerContract $manager,
        ?\ONGR\ElasticsearchDSL\Search $search = null
    ) {
        parent::__construct($search);
        
        $this->manager = $manager;
        
        $this->index = config('leopard.index');
    }
    
    /**
     * Overwrite default index
     *
     * @param string $index
     * @return Search
     */
    public function overwriteIndex(string $index) : Search
    {
        $this->index = $index;
        return $this;
    }
    
    /**
     * Get index
     *
     * @return string
     */
    public function getIndex() : string
    {
        return $this->index;
    }
    
    /**
     * Overwrite default type
     *
     * @param string $type
     * @return Search
     */
    public function overwriteType(string $type) : Search
    {
        $this->type = $type;
        return $this;
    }
    
    /**
     * Get type
     *
     * @return string|null
     */
    public function getType() : ?string
    {
        return $this->type;
    }
    
    /**
     * Add model
     *
     * @param Model|Searchable $model
     * @return Search
     *
     * @throws \InvalidArgumentException
     */
    public function model(Model $model) : Search
    {
        $this->isModelSearchable($model);
        
        $this->model = $model;
        
        if (is_string($index = $model->getDocumentIndex())) {
            $this->overwriteIndex($index);
        }
    
        $this->overwriteType($model->getDocumentType());
        $this->overwriteType(/** @scrutinizer ignore-type */ $model->getDocumentType());
        
        return $this;
    }
    
    /**
     * Get
     *
     * @param FillerContract|null $filler
     * @return SearchResult
     */
    public function get(?FillerContract $filler = null) : SearchResult
    {
        $searchResult = new SearchResult($this->getRaw());
        
        if ($this->model) {
            $filler = $filler ?: new EloquentFiller();
            $filler->fill($this->model, $searchResult);
        }
        
        return $searchResult;
    }
    
    /**
     * Get raw search result
     *
     * @return array
     */
    public function getRaw() : array
    {
        $params = [
            'index' => $this->index,
            'body' => $this->toDsl()
        ];
    
        if ($this->type) {
            $params['type'] = $this->type;
        }
        
        return $this->manager->searchStatement($params);
    }
    
    /**
     * Aggregation
     *
     * @param \Closure $aggregation
     * @return Search
     */
    public function aggregation(\Closure $aggregation) : Search
    {
        $aggregation(new Aggregation($this->search));
        return $this;
    }
    
    /**
     * Term level
     *
     * @param \Closure $termLevel
     * @return Search
     */
    public function termLevel(\Closure $termLevel) : Search
    {
        $termLevel(new TermLevel($this->search));
        return $this;
    }
    
    /**
     * Fulltext
     *
     * @param \Closure $fulltext
     * @return Search
     */
    public function fulltext(\Closure $fulltext) : Search
    {
        $fulltext(new Fulltext($this->search));
        return $this;
    }
    
    /**
     * Geo
     *
     * @param \Closure $geo
     * @return Search
     */
    public function geo(\Closure $geo) : Search
    {
        $geo(new Geo($this->search));
        return $this;
    }
    
    /**
     * Compound
     *
     * @param \Closure $compound
     * @return Search
     */
    public function compound(\Closure $compound) : Search
    {
        $compound(new Compound($this->search));
        return $this;
    }
    
    /**
     * Joining
     *
     * @param \Closure $joining
     * @return Search
     */
    public function joining(\Closure $joining) : Search
    {
        $joining(new Joining($this->search));
        return $this;
    }
    
    /**
     * Specialized
     *
     * @param \Closure $specialized
     * @return Search
     */
    public function specialized(\Closure $specialized) : Search
    {
        $specialized(new Specialized($this->search));
        return $this;
    }
    
    /**
     * Inner hit
     *
     * @param \Closure $innerHit
     * @return Search
     */
    public function innerHit(\Closure $innerHit) : Search
    {
        $innerHit(new InnerHit($this->search));
        return $this;
    }
    
    /**
     * Paginate
     *
     * @param int $page
     * @param int $limit
     * @return Search
     */
    public function paginate(int $page, int $limit = 25) : Search
    {
        $this->search
            ->setFrom($limit * ($page - 1))
            ->setSize($limit);
        
        return $this;
    }
    
    /**
     * Min score
     *
     * @param int $minScore
     * @return Search
     */
    public function minScore(int $minScore) : Search
    {
        $this->search->setMinScore($minScore);
        return $this;
    }
    
    /**
     * Sort
     *
     * @param string $field
     * @param string $order
     * @param array $params
     * @return Search
     */
    public function sort(string $field, string $order = FieldSort::DESC, array $params = []) : Search
    {
        $this->search->addSort(new FieldSort(
            $field,
            $order,
            $params
        ));
        
        return $this;
    }
}

triadev / Leopard

Branch — master (8cb5b2)

Search::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
