Arrilot\BitrixModels\Queries\HLQuery

Complexity

Total Complexity

29

Size/Duplication

Total Lines	191
Duplicated Lines	22.51 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	groupBy()	0	6	1
A	limit()	0	6	1
A	page()	0	6	1
A	cache()	0	6	1
C	getList()	0	28	8
D	addItemToResultsUsingKeyBy()	43	43	10
A	count()	0	8	2
A	normalizeFilter()	0	4	1
A	normalizeSelect()	0	4	3

<?php

namespace Arrilot\BitrixModels\Queries;


use Arrilot\BitrixModels\Models\HLModel;
use Illuminate\Support\Collection;
use LogicException;

class HLQuery extends BaseQuery
{
    public $keyBy = 'ID';

    /**
     * Query sort.
     *
     * @var array
     */
    public $select = false;
    public $sort = ['ID' => 'ASC'];
    public $limit;
    public $page;
    public $ttl = 0;

    /**
     * Query group by.
     *
     * @var array
     */
    public $groupBy = false;

    /**
     * Iblock id.
     *
     * @var int
     */
    protected $tableName;

    /**
     * Constructor.
     *
     * @param object $bxObject
     * @param string $modelName
     */
    public function __construct($bxObject, $modelName)
    {
        parent::__construct($bxObject, $modelName);

        $this->tableName = $modelName::tableName();
    }

    /**
     * Setter for groupBy.
     *
     * @param $value
     *
     * @return $this
     */
    public function groupBy($value)
    {
        $this->groupBy = $value;

        return $this;
    }

    public function limit($value)
    {
        $this->limit = $value;

        return $this;
    }

    public function page($num)
    {
        $this->page = $num;

        return $this;
    }

    public function cache($ttl)
    {
        $this->ttl = (int) $ttl;

        return $this;
    }

    /**
     * Get list of items.
     *
     * @return Collection
     */
    public function getList()
    {
        if ($this->queryShouldBeStopped) {
            return new Collection();
        }

        $items = [];


        $params = [
            'filter' => $this->normalizeFilter(),
            'order' => $this->sort,
            'select' => $this->normalizeSelect(),
            //'cache' => ['ttl' => 3600],

67% of this comment could be valid code. Did you maybe forget this after debugging?

        ];

        if ($this->groupBy) $params['group'] = $this->groupBy;

The expression $this->groupBy of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

        if ($this->limit) $params['limit'] = $this->limit;
        if ($this->ttl) $params['cache'] = ['ttl' => $this->ttl];
        if ($this->page && $this->limit) $params['offset'] = $this->page * $this->limit;

        $rsItems = $this->bxObject::getList($params);
        while ($arItem = $rsItems->fetch()) {
            $this->addItemToResultsUsingKeyBy($items, new $this->modelName($arItem['ID'], $arItem));
        }

        return new Collection($items);
    }

    protected function addItemToResultsUsingKeyBy(&$results, HLModel $object)

This method seems to be duplicated in your project.

    {
        $item = $object->fields;

        if (!isset($item[$this->keyBy])) {
            throw new LogicException("Field {$this->keyBy} is not found in object");
        }

        $keyByValue = $item[$this->keyBy];

        if (!isset($results[$keyByValue])) {
            $results[$keyByValue] = $object;
        } else {
            $oldFields = $results[$keyByValue]->fields;
            foreach ($oldFields as $field => $oldValue) {
                // пропускаем служебные поля.
                if (in_array($field, ['_were_multiplied', 'PROPERTIES'])) {
                    continue;
                }

                $alreadyMultiplied = !empty($oldFields['_were_multiplied'][$field]);

                // мультиплицируем только несовпадающие значения полей
                $newValue = $item[$field];
                if ($oldValue !== $newValue) {
                    // если еще не мультиплицировали поле, то его надо превратить в массив.
                    if (!$alreadyMultiplied) {
                        $oldFields[$field] = [
                            $oldFields[$field]
                        ];
                        $oldFields['_were_multiplied'][$field] = true;
                    }

                    // добавляем новое значению поле если такого еще нет.
                    if (empty($oldFields[$field]) || (is_array($oldFields[$field]) && !in_array($newValue, $oldFields[$field]))) {
                        $oldFields[$field][] = $newValue;
                    }
                }
            }

            $results[$keyByValue]->fields = $oldFields;
        }
    }

    /**
     * Get count of elements that match $filter.
     *
     * @return int
     */
    public function count()
    {
        if ($this->queryShouldBeStopped) {
            return 0;
        }

        return (int) $this->bxObject->getCount($this->normalizeFilter());
    }

    /**
     * Normalize filter before sending it to getList.
     * This prevents some inconsistency.
     *
     * @return array
     */
    protected function normalizeFilter()
    {
        return $this->filter;
    }

    /**
     * Normalize select before sending it to getList.
     * This prevents some inconsistency.
     *
     * @return array
     */
    protected function normalizeSelect()
    {
        return ( !$this->select || empty($this->select) ) ? ['*'] : $this->select;

The expression $this->select of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

    }
}