BaseQuery::take() - Code Metrics - Inspection of "Relations" - arrilot/bitrix-models - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#17)

unknown

created 2018-04-18 17:03 UTC

BaseQuery::take() A

↳ Parent: BaseQuery

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	1

<?php

namespace Arrilot\BitrixModels\Queries;

use Arrilot\BitrixModels\Models\BaseBitrixModel;
use BadMethodCallException;
use Bitrix\Main\Data\Cache;
use Closure;
use CPHPCache;
use Illuminate\Pagination\Paginator;
use Illuminate\Pagination\LengthAwarePaginator;
use Illuminate\Support\Collection;
use LogicException;

abstract class BaseQuery
{
    use BaseRelationQuery;

    /**
     * Query select.
     *
     * @var array
     */
    public $select = [];
    /**
     * Bitrix object to be queried.
     *
     * @var object|string
     */
    protected $bxObject;

    /**
     * Name of the model that calls the query.
     *
     * @var string
     */
    protected $modelName;

    /**
     * Model that calls the query.
     *
     * @var object
     */
    protected $model;

    /**
     * Query sort.
     *
     * @var array
     */
    public $sort = [];

    /**
     * Query filter.
     *
     * @var array
     */
    public $filter = [];

    /**
     * Query navigation.
     *
     * @var array|bool
     */
    public $navigation = false;

    /**
     * The key to list items in array of results.
     * Set to false to have auto incrementing integer.
     *
     * @var string|bool
     */
    public $keyBy = 'ID';

    /**
     * Number of minutes to cache a query
     *
     * @var double|int
     */
    public $cacheTtl = 0;

    /**
     * Indicates that the query should be stopped instead of touching the DB.
     * Can be set in query scopes or manually.
     *
     * @var bool
     */
    protected $queryShouldBeStopped = false;

    /**
     * Get count of users that match $filter.
     *
     * @return int
     */
    abstract public function count();

    /**
     * Подготавливает запрос и вызывает loadModels()
     *
     * @return Collection
     */
    public function getList()
    {
        if ($this->queryShouldBeStopped) {
            return new Collection();
        }

        if (!is_null($this->primaryModel)) {
            // Запрос - подгрузка релейшена. Надо добавить filter
            $this->filterByModels([$this->primaryModel]);
        }

        $models = $this->loadModels();

        if (!empty($this->with)) {
            $this->findWith($this->with, $models);
        }

        if ($this->inverseOf !== null) {
            $this->addInverseRelations($models);
        }

        return $models;

    }

    /**
     * Get list of items.
     *
     * @return Collection
     */
    abstract protected function loadModels();

    /**
     * Constructor.
     *
     * @param object|string $bxObject
     * @param string $modelName
     */
    public function __construct($bxObject, $modelName)
    {
        $this->bxObject = $bxObject;
        $this->modelName = $modelName;
        $this->model = new $modelName();
    }

    /**
     * Get the first item that matches query params.
     *
     * @return mixed
     */
    public function first()
    {
        return $this->limit(1)->getList()->first(null, false);
    }

    /**
     * Get item by its id.
     *
     * @param int $id
     *
     * @return mixed
     */
    public function getById($id)
    {
        if (!$id || $this->queryShouldBeStopped) {
            return false;
        }

        $this->sort = [];
        $this->filter['ID'] = $id;

        return $this->getList()->first(null, false);
    }

    /**
     * Setter for sort.
     *
     * @param mixed  $by
     * @param string $order
     *
     * @return $this
     */
    public function sort($by, $order = 'ASC')
    {
        $this->sort = is_array($by) ? $by : [$by => $order];

        return $this;
    }

    /**
     * Another setter for sort.
     *
     * @param mixed  $by
     * @param string $order
     *
     * @return $this
     */
    public function order($by, $order = 'ASC')
    {
        return $this->sort($by, $order);
    }

    /**
     * Setter for filter.
     *
     * @param array $filter
     *
     * @return $this
     */
    public function filter($filter)
    {
        $this->filter = array_merge($this->filter, $filter);

        return $this;
    }

    /**
     * Reset filter.
     *
     * @return $this
     */
    public function resetFilter()
    {
        $this->filter = [];

        return $this;
    }

    /**
     * Add another filter to filters array.
     *
     * @param array $filters
     *
     * @return $this
     */
    public function addFilter($filters)
    {
        foreach ($filters as $field => $value) {
            $this->filter[$field] = $value;
        }

        return $this;
    }

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

        return $this;
    }

    /**
     * Setter for select.
     *
     * @param $value
     *
     * @return $this
     */
    public function select($value)
    {
        $this->select = is_array($value) ? $value : func_get_args();

        return $this;
    }

    /**
     * Setter for cache ttl.
     *
     * @param float|int $minutes
     *
     * @return $this
     */
    public function cache($minutes)
    {
        $this->cacheTtl = $minutes;

        return $this;
    }

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

        return $this;
    }

    /**
     * Set the "limit" value of the query.
     *
     * @param int $value
     *
     * @return $this
     */
    public function limit($value)
    {
        $this->navigation['nPageSize'] = $value;

        return $this;
    }

    /**
     * Set the "page number" value of the query.
     *
     * @param int $num
     *
     * @return $this
     */
    public function page($num)
    {
        $this->navigation['iNumPage'] = $num;

        return $this;
    }

    /**
     * Alias for "limit".
     *
     * @param int $value
     *
     * @return $this
     */
    public function take($value)
    {
        return $this->limit($value);
    }

    /**
     * Set the limit and offset for a given page.
     *
     * @param  int  $page
     * @param  int  $perPage
     * @return $this
     */
    public function forPage($page, $perPage = 15)
    {
        return $this->page($page)->take($perPage);
    }

    /**
     * Paginate the given query into a paginator.
     *
     * @param  int  $perPage
     * @param  string  $pageName
     *
     * @return \Illuminate\Pagination\LengthAwarePaginator
     */
    public function paginate($perPage = 15, $pageName = 'page')

    {
        $page = Paginator::resolveCurrentPage($pageName);
        $total = $this->count();
        $results = $this->forPage($page, $perPage)->getList();

        return new LengthAwarePaginator($results, $total, $perPage, $page, [
            'path' => Paginator::resolveCurrentPath(),
            'pageName' => $pageName,
        ]);
    }

    /**
     * Get a paginator only supporting simple next and previous links.
     *
     * This is more efficient on larger data-sets, etc.
     *
     * @param  int  $perPage
     * @param  string  $pageName
     *
     * @return \Illuminate\Pagination\Paginator
     */
    public function simplePaginate($perPage = 15, $pageName = 'page')

    {
        $page = Paginator::resolveCurrentPage($pageName);
        $results = $this->forPage($page, $perPage + 1)->getList();

        return new Paginator($results, $perPage, $page, [
            'path' => Paginator::resolveCurrentPath(),
            'pageName' => $pageName,
        ]);
    }

    /**
     * Stop the query from touching DB.
     *
     * @return $this
     */
    public function stopQuery()
    {
        $this->queryShouldBeStopped = true;

        return $this;
    }

    /**
     * Adds $item to $results using keyBy value.
     *
     * @param $results
     * @param BaseBitrixModel $object
     *
     * @return void
     */
    protected function addItemToResultsUsingKeyBy(&$results, BaseBitrixModel $object)
    {
        $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;
        }
    }

    /**
     * Determine if all fields must be selected.
     *
     * @return bool
     */
    protected function fieldsMustBeSelected()
    {
        return in_array('FIELDS', $this->select);
    }

    /**
     * Determine if all fields must be selected.
     *
     * @return bool
     */
    protected function propsMustBeSelected()
    {
        return in_array('PROPS', $this->select)
            || in_array('PROPERTIES', $this->select)
            || in_array('PROPERTY_VALUES', $this->select);
    }

    /**
     * Set $array[$new] as $array[$old] and delete $array[$old].
     *
     * @param array $array
     * @param $old
     * @param $new
     *
     * return null
     */
    protected function substituteField(&$array, $old, $new)
    {
        if (isset($array[$old]) && !isset($array[$new])) {
            $array[$new] = $array[$old];
        }

        unset($array[$old]);
    }

    /**
     * Clear select array from duplication and additional fields.
     *
     * @return array
     */
    protected function clearSelectArray()
    {
        $strip = ['FIELDS', 'PROPS', 'PROPERTIES', 'PROPERTY_VALUES', 'GROUPS', 'GROUP_ID', 'GROUPS_ID'];

        return array_values(array_diff(array_unique($this->select), $strip));
    }

    /**
     * Store closure's result in the cache for a given number of minutes.
     *
     * @param string $key
     * @param double $minutes
     * @param Closure $callback
     * @return mixed
     */
    protected function rememberInCache($key, $minutes, Closure $callback)
    {
        $minutes = (double) $minutes;
        if ($minutes <= 0) {
            return $callback();
        }

        $cache = Cache::createInstance();
        if ($cache->initCache($minutes * 60, $key, 'bitrix-models')) {
            $vars = $cache->getVars();
            return $vars['cache'];
        }

        $cache->startDataCache();
        $result = $callback();
        $cache->endDataCache(['cache' => $result]);

        return $result;
    }

    protected function handleCacheIfNeeded($cacheKeyParams, Closure $callback)
    {
        return $this->cacheTtl
            ? $this->rememberInCache(md5(json_encode($cacheKeyParams)), $this->cacheTtl, $callback)
            : $callback();
    }

    /**
     * Handle dynamic method calls into the method.
     *
     * @param string $method
     * @param array  $parameters
     *
     * @throws BadMethodCallException
     *
     * @return $this
     */
    public function __call($method, $parameters)
    {
        if (method_exists($this->model, 'scope'.$method)) {
            array_unshift($parameters, $this);

            $query = call_user_func_array([$this->model, 'scope'.$method], $parameters);

            if ($query === false) {
                $this->stopQuery();
            }

            return $query instanceof static ? $query : $this;
        }

        $className = get_class($this);

        throw new BadMethodCallException("Call to undefined method {$className}::{$method}()");
    }
}


1		<?php
2
3		namespace Arrilot\BitrixModels\Queries;
4
5		use Arrilot\BitrixModels\Models\BaseBitrixModel;
6		use BadMethodCallException;
7		use Bitrix\Main\Data\Cache;
8		use Closure;
9		use CPHPCache;
10		use Illuminate\Pagination\Paginator;
11		use Illuminate\Pagination\LengthAwarePaginator;
12		use Illuminate\Support\Collection;
13		use LogicException;
14
15		abstract class BaseQuery
16		{
17		use BaseRelationQuery;
18
19		/**
20		* Query select.
21		*
22		* @var array
23		*/
24		public $select = [];
25		/**
26		* Bitrix object to be queried.
27		*
28		* @var object\|string
29		*/
30		protected $bxObject;
31
32		/**
33		* Name of the model that calls the query.
34		*
35		* @var string
36		*/
37		protected $modelName;
38
39		/**
40		* Model that calls the query.
41		*
42		* @var object
43		*/
44		protected $model;
45
46		/**
47		* Query sort.
48		*
49		* @var array
50		*/
51		public $sort = [];
52
53		/**
54		* Query filter.
55		*
56		* @var array
57		*/
58		public $filter = [];
59
60		/**
61		* Query navigation.
62		*
63		* @var array\|bool
64		*/
65		public $navigation = false;
66
67		/**
68		* The key to list items in array of results.
69		* Set to false to have auto incrementing integer.
70		*
71		* @var string\|bool
72		*/
73		public $keyBy = 'ID';
74
75		/**
76		* Number of minutes to cache a query
77		*
78		* @var double\|int
79		*/
80		public $cacheTtl = 0;
81
82		/**
83		* Indicates that the query should be stopped instead of touching the DB.
84		* Can be set in query scopes or manually.
85		*
86		* @var bool
87		*/
88		protected $queryShouldBeStopped = false;
89
90		/**
91		* Get count of users that match $filter.
92		*
93		* @return int
94		*/
95		abstract public function count();
96
97		/**
98		* Подготавливает запрос и вызывает loadModels()
99		*
100		* @return Collection
101		*/
102		public function getList()
103		{
104		if ($this->queryShouldBeStopped) {
105		return new Collection();
106		}
107
108		if (!is_null($this->primaryModel)) {
109		// Запрос - подгрузка релейшена. Надо добавить filter
110		$this->filterByModels([$this->primaryModel]);
111		}
112
113		$models = $this->loadModels();
114
115		if (!empty($this->with)) {
116		$this->findWith($this->with, $models);
117		}
118
119		if ($this->inverseOf !== null) {
120		$this->addInverseRelations($models);
121		}
122
123		return $models;
		0 ignored issues – show Bug Compatibility introduced 2018-04-15 13:26 UTC by Report Bug Copy Issue Report The expression `return $models;` of type `Illuminate\Support\Colle...odels\BaseBitrixModel[]` is incompatible with the return type documented by `Arrilot\BitrixModels\Queries\BaseQuery::getList` of type `Illuminate\Support\Collection` as it can also be of type `Arrilot\BitrixModels\Models\BaseBitrixModel[]` which is not included in this return type. Loading history...
124		}
125
126		/**
127		* Get list of items.
128		*
129		* @return Collection
130		*/
131		abstract protected function loadModels();
132
133		/**
134		* Constructor.
135		*
136		* @param object\|string $bxObject
137		* @param string $modelName
138		*/
139		public function __construct($bxObject, $modelName)
140		{
141		$this->bxObject = $bxObject;
142		$this->modelName = $modelName;
143		$this->model = new $modelName();
144		}
145
146		/**
147		* Get the first item that matches query params.
148		*
149		* @return mixed
150		*/
151		public function first()
152		{
153		return $this->limit(1)->getList()->first(null, false);
154		}
155
156		/**
157		* Get item by its id.
158		*
159		* @param int $id
160		*
161		* @return mixed
162		*/
163		public function getById($id)
164		{
165		if (!$id \|\| $this->queryShouldBeStopped) {
166		return false;
167		}
168
169		$this->sort = [];
170		$this->filter['ID'] = $id;
171
172		return $this->getList()->first(null, false);
173		}
174
175		/**
176		* Setter for sort.
177		*
178		* @param mixed $by
179		* @param string $order
180		*
181		* @return $this
182		*/
183		public function sort($by, $order = 'ASC')
184		{
185		$this->sort = is_array($by) ? $by : [$by => $order];
186
187		return $this;
188		}
189
190		/**
191		* Another setter for sort.
192		*
193		* @param mixed $by
194		* @param string $order
195		*
196		* @return $this
197		*/
198		public function order($by, $order = 'ASC')
199		{
200		return $this->sort($by, $order);
201		}
202
203		/**
204		* Setter for filter.
205		*
206		* @param array $filter
207		*
208		* @return $this
209		*/
210		public function filter($filter)
211		{
212		$this->filter = array_merge($this->filter, $filter);
213
214		return $this;
215		}
216
217		/**
218		* Reset filter.
219		*
220		* @return $this
221		*/
222		public function resetFilter()
223		{
224		$this->filter = [];
225
226		return $this;
227		}
228
229		/**
230		* Add another filter to filters array.
231		*
232		* @param array $filters
233		*
234		* @return $this
235		*/
236		public function addFilter($filters)
237		{
238		foreach ($filters as $field => $value) {
239		$this->filter[$field] = $value;
240		}
241
242		return $this;
243		}
244
245		/**
246		* Setter for navigation.
247		*
248		* @param $value
249		*
250		* @return $this
251		*/
252		public function navigation($value)
253		{
254		$this->navigation = $value;
255
256		return $this;
257		}
258
259		/**
260		* Setter for select.
261		*
262		* @param $value
263		*
264		* @return $this
265		*/
266		public function select($value)
267		{
268		$this->select = is_array($value) ? $value : func_get_args();
269
270		return $this;
271		}
272
273		/**
274		* Setter for cache ttl.
275		*
276		* @param float\|int $minutes
277		*
278		* @return $this
279		*/
280		public function cache($minutes)
281		{
282		$this->cacheTtl = $minutes;
283
284		return $this;
285		}
286
287		/**
288		* Setter for keyBy.
289		*
290		* @param string $value
291		*
292		* @return $this
293		*/
294		public function keyBy($value)
295		{
296		$this->keyBy = $value;
297
298		return $this;
299		}
300
301		/**
302		* Set the "limit" value of the query.
303		*
304		* @param int $value
305		*
306		* @return $this
307		*/
308		public function limit($value)
309		{
310		$this->navigation['nPageSize'] = $value;
311
312		return $this;
313		}
314
315		/**
316		* Set the "page number" value of the query.
317		*
318		* @param int $num
319		*
320		* @return $this
321		*/
322		public function page($num)
323		{
324		$this->navigation['iNumPage'] = $num;
325
326		return $this;
327		}
328
329		/**
330		* Alias for "limit".
331		*
332		* @param int $value
333		*
334		* @return $this
335		*/
336		public function take($value)
337		{
338		return $this->limit($value);
339		}
340
341		/**
342		* Set the limit and offset for a given page.
343		*
344		* @param int $page
345		* @param int $perPage
346		* @return $this
347		*/
348		public function forPage($page, $perPage = 15)
349		{
350		return $this->page($page)->take($perPage);
351		}
352
353		/**
354		* Paginate the given query into a paginator.
355		*
356		* @param int $perPage
357		* @param string $pageName
358		*
359		* @return \Illuminate\Pagination\LengthAwarePaginator
360		*/
361	View Code Duplication	public function paginate($perPage = 15, $pageName = 'page')
		0 ignored issues – show Duplication introduced 2017-09-28 23:31 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
362		{
363		$page = Paginator::resolveCurrentPage($pageName);
364		$total = $this->count();
365		$results = $this->forPage($page, $perPage)->getList();
366
367		return new LengthAwarePaginator($results, $total, $perPage, $page, [
368		'path' => Paginator::resolveCurrentPath(),
369		'pageName' => $pageName,
370		]);
371		}
372
373		/**
374		* Get a paginator only supporting simple next and previous links.
375		*
376		* This is more efficient on larger data-sets, etc.
377		*
378		* @param int $perPage
379		* @param string $pageName
380		*
381		* @return \Illuminate\Pagination\Paginator
382		*/
383	View Code Duplication	public function simplePaginate($perPage = 15, $pageName = 'page')
		0 ignored issues – show Duplication introduced 2017-09-28 23:31 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
384		{
385		$page = Paginator::resolveCurrentPage($pageName);
386		$results = $this->forPage($page, $perPage + 1)->getList();
387
388		return new Paginator($results, $perPage, $page, [
389		'path' => Paginator::resolveCurrentPath(),
390		'pageName' => $pageName,
391		]);
392		}
393
394		/**
395		* Stop the query from touching DB.
396		*
397		* @return $this
398		*/
399		public function stopQuery()
400		{
401		$this->queryShouldBeStopped = true;
402
403		return $this;
404		}
405
406		/**
407		* Adds $item to $results using keyBy value.
408		*
409		* @param $results
410		* @param BaseBitrixModel $object
411		*
412		* @return void
413		*/
414		protected function addItemToResultsUsingKeyBy(&$results, BaseBitrixModel $object)
415		{
416		$item = $object->fields;
417		if (!isset($item[$this->keyBy])) {
418		throw new LogicException("Field {$this->keyBy} is not found in object");
419		}
420
421		$keyByValue = $item[$this->keyBy];
422
423		if (!isset($results[$keyByValue])) {
424		$results[$keyByValue] = $object;
425		} else {
426		$oldFields = $results[$keyByValue]->fields;
427		foreach ($oldFields as $field => $oldValue) {
428		// пропускаем служебные поля.
429		if (in_array($field, ['_were_multiplied', 'PROPERTIES'])) {
430		continue;
431		}
432
433		$alreadyMultiplied = !empty($oldFields['_were_multiplied'][$field]);
434
435		// мультиплицируем только несовпадающие значения полей
436		$newValue = $item[$field];
437		if ($oldValue !== $newValue) {
438		// если еще не мультиплицировали поле, то его надо превратить в массив.
439		if (!$alreadyMultiplied) {
440		$oldFields[$field] = [
441		$oldFields[$field]
442		];
443		$oldFields['_were_multiplied'][$field] = true;
444		}
445
446		// добавляем новое значению поле если такого еще нет.
447		if (empty($oldFields[$field]) \|\| (is_array($oldFields[$field]) && !in_array($newValue, $oldFields[$field]))) {
448		$oldFields[$field][] = $newValue;
449		}
450		}
451		}
452
453		$results[$keyByValue]->fields = $oldFields;
454		}
455		}
456
457		/**
458		* Determine if all fields must be selected.
459		*
460		* @return bool
461		*/
462		protected function fieldsMustBeSelected()
463		{
464		return in_array('FIELDS', $this->select);
465		}
466
467		/**
468		* Determine if all fields must be selected.
469		*
470		* @return bool
471		*/
472		protected function propsMustBeSelected()
473		{
474		return in_array('PROPS', $this->select)
475		\|\| in_array('PROPERTIES', $this->select)
476		\|\| in_array('PROPERTY_VALUES', $this->select);
477		}
478
479		/**
480		* Set $array[$new] as $array[$old] and delete $array[$old].
481		*
482		* @param array $array
483		* @param $old
484		* @param $new
485		*
486		* return null
487		*/
488		protected function substituteField(&$array, $old, $new)
489		{
490		if (isset($array[$old]) && !isset($array[$new])) {
491		$array[$new] = $array[$old];
492		}
493
494		unset($array[$old]);
495		}
496
497		/**
498		* Clear select array from duplication and additional fields.
499		*
500		* @return array
501		*/
502		protected function clearSelectArray()
503		{
504		$strip = ['FIELDS', 'PROPS', 'PROPERTIES', 'PROPERTY_VALUES', 'GROUPS', 'GROUP_ID', 'GROUPS_ID'];
505
506		return array_values(array_diff(array_unique($this->select), $strip));
507		}
508
509		/**
510		* Store closure's result in the cache for a given number of minutes.
511		*
512		* @param string $key
513		* @param double $minutes
514		* @param Closure $callback
515		* @return mixed
516		*/
517		protected function rememberInCache($key, $minutes, Closure $callback)
518		{
519		$minutes = (double) $minutes;
520		if ($minutes <= 0) {
521		return $callback();
522		}
523
524		$cache = Cache::createInstance();
525		if ($cache->initCache($minutes * 60, $key, 'bitrix-models')) {
526		$vars = $cache->getVars();
527		return $vars['cache'];
528		}
529
530		$cache->startDataCache();
531		$result = $callback();
532		$cache->endDataCache(['cache' => $result]);
533
534		return $result;
535		}
536
537		protected function handleCacheIfNeeded($cacheKeyParams, Closure $callback)
538		{
539		return $this->cacheTtl
540		? $this->rememberInCache(md5(json_encode($cacheKeyParams)), $this->cacheTtl, $callback)
541		: $callback();
542		}
543
544		/**
545		* Handle dynamic method calls into the method.
546		*
547		* @param string $method
548		* @param array $parameters
549		*
550		* @throws BadMethodCallException
551		*
552		* @return $this
553		*/
554		public function __call($method, $parameters)
555		{
556		if (method_exists($this->model, 'scope'.$method)) {
557		array_unshift($parameters, $this);
558
559		$query = call_user_func_array([$this->model, 'scope'.$method], $parameters);
560
561		if ($query === false) {
562		$this->stopQuery();
563		}
564
565		return $query instanceof static ? $query : $this;
566		}
567
568		$className = get_class($this);
569
570		throw new BadMethodCallException("Call to undefined method {$className}::{$method}()");
571		}
572		}
573

arrilot / bitrix-models

Pull Request — master (#17)

BaseQuery::take() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like