Apps\Controller\Admin\Main\Boot

Complexity

Total Complexity

15

Size/Duplication

Total Lines	101
Duplicated Lines	0 %

Importance

Changes

0

1 Method

Rating	Name	Duplication	Size	Complexity
C	boot()	0	96	15

<?php

namespace Apps\Controller\Admin\Main;


use Apps\Controller\Admin\Main;
use Apps\Model\Admin\Main\AbstractSearchItem;
use Apps\Model\Admin\Main\CollectionSearchResults;
use Ffcms\Core\App;
use Ffcms\Core\Helper\FileSystem\File;
use Ffcms\Core\Helper\Type\Any;
use Ffcms\Core\Helper\Type\Arr;
use Ffcms\Core\Helper\Type\Str;
use Illuminate\Support\Collection;

trait Boot
{
    /**
     * Hook boot for search features
     */
    public static function boot(): void
    {
        App::$Event->on(Main::SEARCH_EVENT_NAME, function ($model) {
            /** @var CollectionSearchResults $model */
            $records = \Apps\ActiveRecord\App::search($model->getQuery())
                ->take($model->getLimit())
                ->get();

            /** @var \Apps\ActiveRecord\App[]|Collection $records */
            $records->each(function($item) use ($model) {
                /** @var \Apps\ActiveRecord\App $item */
                $text = App::$Translate->get('Main', 'Type: %type%, system name: %sys%, version: %version%', [
                    'type' => $item->type,
                    'sys' => $item->sys_name,
                    'version' => $item->version
                ]);

                // initialize abstract response pattern
                $res = new AbstractSearchItem();
                $res->setTitle($item->getLocaled('name'));

It seems like $item->getLocaled('name') can also be of type array; however, parameter $value of Apps\Model\Front\Search\AbstractSearchResult::setTitle() does only seem to accept string, maybe add an additional type check?

                $res->setSnippet($text);
                $res->setDate($item->created_at);
                $res->setRelevance((int)$item->relevance);

The property relevance does not exist on Apps\ActiveRecord\App. Since you implemented __get, consider adding a @property annotation.

                $res->setUrl(Str::lowerCase($item->sys_name) . '/index');
                $res->setMarker('App');

                $model->add($res);
            });

            // search in translation files
            $usedLanguage = App::$Request->getLanguage();
            $onlyKeys = false;
            if ($usedLanguage === 'en') {
                $usedLanguage = 'ru'; // use "ru" locale with keys as default
                $onlyKeys = true;
            }

            // prepare search words for input query
            $searchWords = explode(' ', $model->getQuery());
            $usedWords = array_filter($searchWords, function($value) {
                return Str::length($value) > 2;
            });

            if (!$usedWords || count($usedWords) < 1) {

The expression $usedWords 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.

                return;
            }

            $files = File::listFiles('/I18n/Admin/' . $usedLanguage, ['.php']);
            // each translation files
            foreach ($files as $file) {
                // prepare file name and route target
                $name = Str::lastIn($file, DIRECTORY_SEPARATOR, true);
                $route = Str::lowerCase(Str::firstIn($name, '.'));
                if (Arr::in($name, ['Main.php', 'Default.php'])) { // do not process main & defaults
                    continue;
                }
                $lines = File::inc($file, true, false);
                if (!Any::isArray($lines) && count($lines) < 1) {

It seems like $lines can also be of type boolean; however, parameter $var of count() does only seem to accept Countable|array, maybe add an additional type check?

                    continue;
                }
                // list i18n file translation lines and search for entries
                $filter = array_filter($lines, function($target, $en) use ($usedWords, $onlyKeys) {

It seems like $lines can also be of type boolean; however, parameter $input of array_filter() does only seem to accept array, maybe add an additional type check?

                    $enWords = explode(' ', $en);
                    foreach ($enWords as $enWord) {
                        if(Arr::in($enWord, $usedWords)) {
                            return true;
                        }
                    }

                    if (!$onlyKeys) {
                        $targetWords = explode(' ', $target);
                        foreach ($targetWords as $targetWord) {
                            if (Arr::in($targetWord, $usedWords)) {
                                return true;
                            }
                        }
                    }

                    return false;
                }, ARRAY_FILTER_USE_BOTH);

                if (!$filter || count($filter) < 1) {

The expression $filter 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.

                    continue;
                }

                $relevance = 10 * (count($filter) / count($files));
                // initialize abstract response pattern
                $res = new AbstractSearchItem();
                $res->setTitle(ucfirst($route));
                $res->setSnippet(implode('; ', $filter));
                $res->setDate(time());
                $res->setRelevance($relevance);
                $res->setUrl($route . '/index');
                $res->setMarker('i18n');

                $model->add($res);
            }
        });
    }
}