Isswp101\Persimmon\QueryBuilder\QueryBuilder

Complexity

Total Complexity

42

Size/Duplication

Total Lines	273
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	3

Test Coverage

Coverage

30.29%

Importance

Changes

0

34 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	3
A	getMatchAllQuery()	0	4	1
A	from()	0	5	1
A	size()	0	5	1
A	hasSort()	0	4	1
A	sort()	0	5	1
A	filter()	0	23	3
A	fields()	0	11	3
A	getOnlyIds()	0	4	1
A	build()	0	4	1
A	__toString()	0	4	1
A	toJson()	0	4	1
A	merge()	0	10	2
A	aggregation()	0	5	1
A	where()	0	6	1
A	notWhere()	0	6	1
A	orWhere()	0	6	1
A	between()	0	6	1
A	betweenOrEquals()	0	6	1
A	range()	0	4	1
A	greaterThan()	0	6	1
A	gt()	0	4	1
A	greaterThanOrEquals()	0	6	1
A	gte()	0	4	1
A	lessThan()	0	6	1
A	lt()	0	4	1
A	lessThanOrEquals()	0	6	1
A	lte()	0	4	1
A	match()	0	6	1
A	notMatch()	0	6	1
A	orMatch()	0	6	1
A	columns()	0	5	1
A	noColumns()	0	5	1
A	chunk()	0	7	2

<?php

namespace Isswp101\Persimmon\QueryBuilder;

use Isswp101\Persimmon\QueryBuilder\Aggregations\Aggregation;
use Isswp101\Persimmon\QueryBuilder\Filters\Filter;
use ONGR\ElasticsearchDSL\Search;

class QueryBuilder implements IQueryBuilder
{
    protected $query = [];
    protected $chunk = 0;

    /**
     * @param Search|array|null $query
     */
    public function __construct($query = null)
    {
        if ($query instanceof Search) {
            $query = $query->toArray();
        }
        $this->query = is_array($query) ? $query : $this->getMatchAllQuery();
    }

    protected function getMatchAllQuery()
    {
        return ['query' => ['match_all' => new \stdClass()]];
    }

    public function from(int $from): QueryBuilder
    {
        $this->query['from'] = $from;
        return $this;
    }

    public function size(int $size): QueryBuilder
    {
        $this->query['size'] = $size;
        return $this;
    }

    public function hasSort(): bool
    {
        return !empty($this->query['body']['sort']);
    }

    /**
     * @param array|string $sort
     * @return $this
     */
    public function sort($sort)
    {
        $this->query['body']['sort'] = $sort;
        return $this;
    }

    /**
     * @param Filter|array $filter
     * @param string $mode
     * @return $this
     */
    public function filter($filter = [], $mode = Filter::MODE_INCLUDE)
    {
        if (!$filter) {
            unset($this->query['body']['filter']);
            return $this;
        }

        if ($filter instanceof Filter) {
            $filter = $filter->makeQuery();
        }

        $map = [
            Filter::MODE_INCLUDE => 'must',
            Filter::MODE_EXCLUDE => 'must_not',
            'should' => 'should'
        ];

        $mode = $map[$mode];

        $this->merge($filter, $mode);

        return $this;
    }

    /**
     * Set _source to search query.
     *
     * @param mixed $fields
     * @return $this
     */
    public function fields($fields = false)
    {
        if ($fields === false) {
            $this->query['body']['_source'] = false;
        } elseif ((array)$fields == ['*']) {
            unset($this->query['body']['_source']);
        } else {
            $this->query['body']['_source'] = $fields;
        }
        return $this;
    }

    /**
     * Return only _id.
     *
     * @return $this
     */
    public function getOnlyIds()
    {
        return $this->fields(false);
    }

    public function build(): array
    {
        return $this->query;
    }

    /**
     * @return string
     */
    public function __toString()
    {
        return $this->toJson();
    }

    /**
     * @param int $options
     * @return string
     */
    public function toJson($options = 0)
    {
        return json_encode($this->query, $options);
    }

    protected function merge(array $query, $mode = 'must')
    {
        if (!array_key_exists('filter', $this->query['body'])) {
            $this->query['body']['filter']['bool'][$mode] = [];
        }

        $this->query['body']['filter']['bool'][$mode][] = $query;

        return $this;
    }

    public function aggregation(Aggregation $aggregation)
    {
        $this->query['body']['aggs'][$aggregation->getName()] = $aggregation->make();
        return $this;
    }

    public function where($field, $value)
    {
        $query = ['term' => [$field => $value]];
        $this->merge($query);
        return $this;
    }

    public function notWhere($field, $value)
    {
        $query = ['term' => [$field => $value]];
        $this->merge($query, 'must_not');
        return $this;
    }

    public function orWhere($field, $value)
    {
        $query = ['term' => [$field => $value]];
        $this->merge($query, 'should');
        return $this;
    }

    public function between($field, $start, $end)
    {
        $query = ['range' => [$field => ['gt' => $start, 'lt' => $end]]];
        $this->merge($query);
        return $this;
    }

    public function betweenOrEquals($field, $start, $end)
    {
        $query = ['range' => [$field => ['gte' => $start, 'lte' => $end]]];
        $this->merge($query);
        return $this;
    }

    public function range($field, $start, $end)
    {
        return $this->betweenOrEquals($field, $start, $end);
    }

    public function greaterThan($field, $start)
    {
        $query = ['range' => [$field => ['gt' => $start]]];
        $this->merge($query);
        return $this;
    }

    public function gt($field, $start)
    {
        return $this->greaterThan($field, $start);
    }

    public function greaterThanOrEquals($field, $start)
    {
        $query = ['range' => [$field => ['gte' => $start]]];
        $this->merge($query);
        return $this;
    }

    public function gte($field, $start)
    {
        return $this->greaterThanOrEquals($field, $start);
    }

    public function lessThan($field, $end)
    {
        $query = ['range' => [$field => ['lt' => $end]]];
        $this->merge($query);
        return $this;
    }

    public function lt($field, $start)
    {
        return $this->lessThan($field, $start);
    }

    public function lessThanOrEquals($field, $end)
    {
        $query = ['range' => [$field => ['lte' => $end]]];
        $this->merge($query);
        return $this;
    }

    public function lte($field, $start)
    {
        return $this->lessThanOrEquals($field, $start);
    }

    public function match($field, $value)
    {
        $query = ['query' => ['match' => [$field => $value]]];
        $this->merge($query);
        return $this;
    }

    public function notMatch($field, $value)
    {
        $query = ['query' => ['match' => [$field => $value]]];
        $this->merge($query, 'must_not');
        return $this;
    }

    public function orMatch($field, $value)
    {
        $query = ['query' => ['match' => [$field => $value]]];
        $this->merge($query, 'should');
        return $this;
    }

    public function columns(array $columns): IQueryBuilder
    {
        $this->query['_source'] = $columns;
        return $this;
    }

    public function noColumns(): IQueryBuilder
    {
        $this->query['_source'] = false;
        return $this;
    }

    public function chunk(int $count = null): IQueryBuilder
    {
        if ($count != null) {

It seems like you are loosely comparing $count of type null|integer against null; this is ambiguous if the integer can be zero. Consider using a strict comparison !== instead.

            $this->chunk = $count;
        }
        return $this;
    }
}