Nord\Lumen\Elasticsearch\Search\Query\Joining\HasChildQuery

Complexity

Total Complexity

17

Size/Duplication

Total Lines	173
Duplicated Lines	5.78 %

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
B	toArray()	0	23	4
A	getMaxChildren()	0	3	1
A	getQuery()	0	3	1
A	setType()	0	4	1
A	setMinChildren()	0	5	1
A	assertMaxChildren()	0	6	2
A	getType()	0	3	1
A	getMinChildren()	0	3	1
A	setQuery()	0	4	1
A	setMaxChildren()	0	5	1
A	getValidScoreModes()	8	8	1
A	assertMinChildren()	0	6	2

<?php namespace Nord\Lumen\Elasticsearch\Search\Query\Joining;

use Nord\Lumen\Elasticsearch\Exceptions\InvalidArgument;
use Nord\Lumen\Elasticsearch\Search\Query\QueryDSL;

/**
 * The has_child filter accepts a query and the child type to run against, and results in parent documents that have
 * child docs matching the query.
 *
 * @see https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-has-child-query.html
 */
class HasChildQuery extends AbstractQuery
{

    /**
     * @var string
     */
    private $type;

    /**
     * @var int
     */
    private $minChildren;

    /**
     * @var int
     */
    private $maxChildren;

    /**
     * @var QueryDSL
     */
    private $query;


    /**
     * @inheritdoc
     */
    public function toArray()
    {
        $hasChild = [
            'type'  => $this->getType(),
            'query' => $this->getQuery()->toArray(),
        ];

        $scoreMode = $this->getScoreMode();
        if (!is_null($scoreMode)) {
            $hasChild['score_mode'] = $scoreMode;
        }

        $minChildren = $this->getMinChildren();
        if (!is_null($minChildren)) {
            $hasChild['min_children'] = $minChildren;
        }

        $maxChildren = $this->getMaxChildren();
        if (!is_null($maxChildren)) {
            $hasChild['max_children'] = $maxChildren;
        }

        return ['has_child' => $hasChild];
    }

    /**
     * @inheritdoc
     */
    protected function getValidScoreModes()

This method seems to be duplicated in your project.

    {
        return [
            self::SCORE_MODE_AVG,
            self::SCORE_MODE_SUM,
            self::SCORE_MODE_MIN,
            self::SCORE_MODE_MAX,
            self::SCORE_MODE_NONE,
        ];
    }

    /**
     * @param string $type
     * @return HasChildQuery
     */
    public function setType($type)
    {
        $this->type = $type;
        return $this;
    }


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


    /**
     * @param int $minChildren
     * @return HasChildQuery
     */
    public function setMinChildren($minChildren)
    {
        $this->assertMinChildren($minChildren);
        $this->minChildren = $minChildren;
        return $this;
    }


    /**
     * @return int
     */
    public function getMinChildren()
    {
        return $this->minChildren;
    }


    /**
     * @param int $maxChildren
     * @return HasChildQuery
     */
    public function setMaxChildren($maxChildren)
    {
        $this->assertMaxChildren($maxChildren);
        $this->maxChildren = $maxChildren;
        return $this;
    }


    /**
     * @return int
     */
    public function getMaxChildren()
    {
        return $this->maxChildren;
    }


    /**
     * @param QueryDSL $query
     * @return HasChildQuery
     */
    public function setQuery(QueryDSL $query)
    {
        $this->query = $query;
        return $this;
    }


    /**
     * @return QueryDSL
     */
    public function getQuery()
    {
        return $this->query;
    }


    /**
     * @param int $minChildren
     * @throws InvalidArgument
     */
    protected function assertMinChildren($minChildren)
    {
        if (!is_int($minChildren)) {
            throw new InvalidArgument(sprintf(
                'HasChild Query `min_children` must be an integer, "%s" given.',
                gettype($minChildren)
            ));
        }
    }


    /**
     * @param int $maxChildren
     * @throws InvalidArgument
     */
    protected function assertMaxChildren($maxChildren)
    {
        if (!is_int($maxChildren)) {
            throw new InvalidArgument(sprintf(
                'HasChild Query `max_children` must be an integer, "%s" given.',
                gettype($maxChildren)
            ));
        }
    }
}