Apps\Model\Front\Content\EntityContentSearch

Complexity

Total Complexity

15

Size/Duplication

Total Lines	104
Duplicated Lines	0 %

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	before()	0	20	4
A	__construct()	0	10	3
A	buildContent()	0	19	4
A	makeSearch()	0	13	4

<?php

namespace Apps\Model\Front\Content;

use Apps\ActiveRecord\Content as ContentEntity;
use Ffcms\Core\App;
use Ffcms\Core\Arch\Model;
use Ffcms\Core\Exception\NotFoundException;
use Ffcms\Core\Helper\Text;
use Ffcms\Core\Helper\Type\Any;
use Ffcms\Core\Helper\Type\Str;

/**
 * Class EntityContentSearch. Search similar content items.
 * @package Apps\Model\Front\Content
 */
class EntityContentSearch extends Model
{
    const MAX_ITEMS = 5;
    const MIN_QUERY_LENGTH = 2;
    const SEARCH_BY_WORDS_COUNT = 3;
    const CACHE_TIME = 120; // seconds

    public $items;

    private $_terms;
    private $_skip = [0];
    private $_categoryId;
    private $_records;

    /**
     * EntityContentSearch constructor. Pass search terms (query string) to model and used items to skip it by id.
     * @param $terms
     * @param int|array $skipIds
     * @param int|null $categoryId
     */
    public function __construct($terms, $skipIds = 0, $categoryId = null)
    {
        $this->_terms = App::$Security->strip_tags(trim($terms, ' '));
        $this->_categoryId = $categoryId;
        if (Any::isInt($skipIds)) {
            $this->_skip = [$skipIds];
        } elseif (Any::isArray($skipIds)) {
            $this->_skip = $skipIds;
        }
        parent::__construct();
    }

    /**
     * Prepare conditions to build content list
     * @throws NotFoundException
     * @throws \Psr\Cache\InvalidArgumentException
     * @return void
     */
    public function before(): void
    {
        // check length of passed terms
        if (!Any::isStr($this->_terms) || Str::length($this->_terms) < self::MIN_QUERY_LENGTH) {
            throw new NotFoundException(__('Search terms is too short'));
        }

        $index = implode('-', $this->_skip);
        // try to get this slow query from cache
        $cache = App::$Cache->getItem('entity.content.search.index.' . $index);
        if (!$cache->isHit()) {
            $cache->set($this->makeSearch());
            $cache->expiresAfter(static::CACHE_TIME);
            App::$Cache->save($cache);
        }
        $this->_records = $cache->get();

        // lets make active record building
        $this->buildContent();
        parent::before();
    }

    /**
     * Build content items as array
     * @return void
     */
    private function buildContent(): void
    {
        if (!$this->_records || $this->_records->count() < 1) {
            return;
        }

        foreach ($this->_records as $item) {
            /** @var \Apps\ActiveRecord\Content $item */
            // full text
            $text = $item->getLocaled('text');
            // remove html
            $text = App::$Security->strip_tags($text);
            // build items
            $this->items[] = [
                'id' => $item->id,
                'title' => $item->getLocaled('title'),
                'snippet' => Text::snippet($text),

It seems like $text can also be of type array and array and null; however, parameter $text of Ffcms\Core\Helper\Text::snippet() does only seem to accept string, maybe add an additional type check?

                'uri' => '/content/read/' . $item->getPath(),
                'thumb' => $item->getPosterThumbUri()
            ];
        }
    }

    /**
     * Search records in database and get object result
     * @return ContentEntity[]
     */
    private function makeSearch()
    {
        $records = new ContentEntity();
        $records = $records->search($this->_terms, null, static::SEARCH_BY_WORDS_COUNT)

The call to Ffcms\Core\Arch\ActiveModel::search() has too many arguments starting with static::SEARCH_BY_WORDS_COUNT.

            ->whereNotIn('id', $this->_skip)
            ->where('display', true);

        if ($this->_categoryId && Any::isInt($this->_categoryId) && $this->_categoryId > 0) {

The expression $this->_categoryId of type integer|null is loosely compared to true; this is ambiguous if the integer can be 0. You might want to explicitly use !== null instead.

            $records = $records->where('category_id', $this->_categoryId);
        }

        return $records->take(self::MAX_ITEMS)

The expression return $records->take(self::MAX_ITEMS)->get() returns the type Illuminate\Database\Eloquent\Collection which is incompatible with the documented return type Apps\ActiveRecord\Content[].

            ->get();
    }
}