SearchApi::getLinksInner() - Code Metrics - Inspection of "MINOR: better searching" - sunnysideup/silverstripe-site-wide-search - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 3cb69a...782ded )

by Nicolaas
created 2023-12-05 05:15 UTC
SearchApi::getLinksInner() A

↳ Parent: SearchApi
Complexity

Conditions	1
Paths	1
Size

Total Lines	12
Code Lines	5
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	5
c	0
b	0
f	0
nc	1
nop	1
dl	0
loc	12
rs	10
<?php

namespace Sunnysideup\SiteWideSearch\Api;

use SilverStripe\Core\ClassInfo;
use SilverStripe\Core\Config\Config;
use SilverStripe\Core\Config\Configurable;
use SilverStripe\Core\Environment;
use SilverStripe\Core\Extensible;
use SilverStripe\Core\Injector\Injectable;
use SilverStripe\Core\Injector\Injector;
use SilverStripe\ORM\ArrayList;
use SilverStripe\ORM\DataObject;
use SilverStripe\ORM\DB;
use SilverStripe\ORM\FieldType\DBDatetime;
use SilverStripe\ORM\FieldType\DBField;
use SilverStripe\ORM\FieldType\DBString;
use SilverStripe\Security\LoginAttempt;
use SilverStripe\Security\MemberPassword;
use SilverStripe\Security\RememberLoginHash;
use SilverStripe\Versioned\ChangeSet;
use SilverStripe\Versioned\Versioned;
use SilverStripe\Versioned\ReadingMode;
use SilverStripe\Versioned\ChangeSetItem;
use SilverStripe\View\ArrayData;

use SilverStripe\SessionManager\Models\LoginSession;
use Sunnysideup\SiteWideSearch\Helpers\Cache;
use Sunnysideup\SiteWideSearch\Helpers\FindEditableObjects;

class SearchApi
{
    use Extensible;
    use Configurable;
    use Injectable;

    /**
     * @var string
     */
    private const CACHE_NAME = 'SearchApi';

    protected $debug = false;

    protected $isQuickSearch = false;

    protected $searchWholePhrase = false;

    protected $baseClass = DataObject::class;

    protected $quickSearchType = 'all';

    protected $excludedClasses = [];

    protected $includedClasses = [];

    protected $excludedFields = [];

    protected $includedFields = [];

    protected $includedClassFieldCombos = [];

    protected $sortOverride = null;

    protected $words = [];

    protected $replace = '';

    /**
     * format is as follows:
     * ```php
     *      [
     *          'AllDataObjects' => [
     *              'BaseClassUsed' => [
     *                  0 => ClassNameA,
     *                  1 => ClassNameB,
     *              ],
     *          ],
     *          'AllValidFields' => [
     *              'ClassNameA' => [
     *                  'FieldA' => 'FieldA'
     *              ],
     *          ],
     *          'IndexedFields' => [
     *              'ClassNameA' => [
     *                  0 => ClassNameA,
     *                  1 => ClassNameB,
     *              ],
     *          ],
     *          'ListOfTextClasses' => [
     *              0 => ClassNameA,
     *              1 => ClassNameB,
     *          ],
     *          'ValidFieldTypes' => [
     *              'Varchar(30)' => true,
     *              'Boolean' => false,
     *          ],
     *     ],
     * ```
     * we use true rather than false to be able to use empty to work out if it has been tested before.
     *
     * @var array
     */
    protected $cache = [];

    private $objects = [];

    private static $limit_of_count_per_data_object = 999;

    private static $hours_back_for_recent = 48;

    private static $limit_per_class_for_recent = 5;

    private static $default_exclude_classes = [
        MemberPassword::class,
        LoginAttempt::class,
        ChangeSet::class,
        ChangeSetItem::class,
        RememberLoginHash::class,
        LoginSession::class,
    ];

    private static $default_exclude_fields = [
        'ClassName',
        'LastEdited',
        'Created',
        'ID',
    ];

    private static $default_include_classes = [];

    private static $default_include_fields = [];

    private static $default_include_class_field_combos = [];

    public function setDebug(bool $b): SearchApi
    {
        $this->debug = $b;

        return $this;
    }

    public function setQuickSearchType(string $s): SearchApi
    {
        if($s === 'all') {
            $this->isQuickSearch = false;
            $this->quickSearchType = '';
        } elseif($s === 'limited') {
            $this->isQuickSearch = true;
            $this->quickSearchType = '';
        } elseif(class_exists($s)) {
            $this->quickSearchType = $s;
            $object = Injector::inst()->get($s);
            $this->setIncludedClasses($object->getClassesToSearch());
            $this->setIncludedFields($object->getFieldsToSearch());
            $this->setIncludedClassFieldCombos($object->getIncludedClassFieldCombos());
            $this->setSortOverride($object->getSortOverride());
        } else {
            user_error('QuickSearchType must be either "all" or "limited" or a defined quick search class. Provided was: ' . $s);
        }

        return $this;
    }

    public function setIsQuickSearch(bool $b): SearchApi
    {
        $this->isQuickSearch = $b;

        return $this;
    }

    public function setSearchWholePhrase(bool $b): SearchApi
    {
        $this->searchWholePhrase = $b;

        return $this;
    }

    public function setBaseClass(string $class): SearchApi
    {
        $this->baseClass = $class;

        return $this;
    }

    public function setExcludedClasses(array $a): SearchApi
    {
        $this->excludedClasses = $a;

        return $this;
    }

    public function setIncludedClasses(array $a): SearchApi
    {
        $this->includedClasses = $a;
        return $this;
    }

    public function setExcludedFields(array $a): SearchApi
    {
        $this->excludedFields = $a;

        return $this;
    }

    public function setIncludedFields(array $a): SearchApi
    {
        $this->includedFields = $a;

        return $this;
    }

    public function setIncludedClassFieldCombos(array $a): SearchApi
    {
        $this->includedClassFieldCombos = $a;

        return $this;
    }

    public function setSortOverride(?array $a = null): SearchApi
    {
        $this->sortOverride = $a;

        return $this;
    }

    public function setWordsAsString(string $s): SearchApi
    {
        $this->words = explode(' ', $s);

        return $this;
    }

    public function setWords(array $a): SearchApi
    {
        $this->words = array_combine($a, $a);

        return $this;
    }

    public function addWord(string $s): SearchApi
    {
        $this->words[$s] = $s;

        return $this;
    }

    public function getFileCache()
    {
        return Injector::inst()->get(Cache::class);
    }

    public function initCache(): self
    {
        $this->cache = $this->getFileCache()->getCacheValues(self::CACHE_NAME . '_' . $this->quickSearchType);

        return $this;
    }

    public function saveCache(): self
    {
        $this->getFileCache()->setCacheValues(self::CACHE_NAME . '_' . $this->quickSearchType, $this->cache);

        return $this;
    }

    // public function __construct()
    // {
    //     Environment::increaseTimeLimitTo(300);
    //     Environment::setMemoryLimitMax(-1);
    //     Environment::increaseMemoryLimitTo(-1);
    // }

    public function buildCache(?string $word = ''): SearchApi
    {
        $this->getLinksInner($word);

        return $this;

    }

    public function getLinks(?string $word = ''): ArrayList
    {
        return $this->getLinksInner($word);
    }

    protected function getLinksInner(?string $word = ''): ArrayList
    {
        $this->initCache();

        //always do first ...
        $matches = $this->getMatches($word);

        $list = $this->turnMatchesIntoList($matches);

        $this->saveCache();

        return $list;

    }

    public function doReplacement(string $word, string $replace): int
    {
        $this->initCache();
        $count = 0;
        // we should have these already.
        foreach ($this->objects as $item) {
            if ($item->canEdit()) {
                $fields = $this->getAllValidFields($item->ClassName);
                foreach ($fields as $field) {
                    $new = str_replace($word, $replace, $item->{$field});
                    if ($new !== $item->{$field}) {
                        ++$count;
                        $item->{$field} = $new;
                        $this->writeAndPublishIfAppropriate($item);

                        if ($this->debug) {
                            DB::alteration_message('<h2>Match:  ' . $item->ClassName . $item->ID . '</h2>' . $new . '<hr />');
                        }
                    }
                }
            }
        }

        return $count;
    }

    protected function writeAndPublishIfAppropriate($item)
    {
        if ($item->hasExtension(Versioned::class)) {
            $myStage = Versioned::get_stage();
            Versioned::set_stage(Versioned::DRAFT);
            // is it on live and is live the same as draft
            $canBePublished = $item->isPublished() && !$item->isModifiedOnDraft();
            $item->writeToStage(Versioned::DRAFT);
            if ($canBePublished) {
                $item->publishSingle();
            }
            Versioned::set_stage($myStage);
        } else {
            $item->write();
        }

    }

    protected function getMatches(?string $word = ''): array
    {
        $startInner = 0;
        $startOuter = 0;
        if ($this->debug) {
            $startOuter = microtime(true);
        }
        $this->workOutInclusionsAndExclusions();
        $this->workOutWords($word);
        $this->workOutWords(/** @scrutinizer ignore-type */ $word);
        if ($this->debug) {
            DB::alteration_message('Words searched for ' . implode(', ', $this->words));
        }

        $array = [];

        if (count($this->words)) {
            foreach ($this->getAllDataObjects() as $className) {

                if ($this->debug) {
                    DB::alteration_message(' ... Searching in ' . $className);
                }
                if(count($this->includedClasses) && !in_array($className, $this->includedClasses, true)) {
                    continue;
                }
                if (!in_array($className, $this->excludedClasses, true)) {

                    $array[$className] = [];
                    $fields = $this->getAllValidFields($className);
                    $filterAny = [];
                    foreach ($fields as $field) {
                        if(count($this->includedClassFieldCombos) && isset($this->includedClassFieldCombos[$className][$field])) {
                            // all good
                        } elseif(count($this->includedFields) && in_array($field, $this->includedFields, true)) {
                            // all good
                        } elseif (!in_array($field, $this->excludedFields, true)) {
                            // all good
                        } else {
                            continue;
                        }
                    }
                    if ($this->debug) {
                        DB::alteration_message(' ... ... Searching in ' . $className . '.' . $field);

                    }
                    $filterAny[$field . ':PartialMatch'] = $this->words;

                    if ([] !== $filterAny) {
                        if ($this->debug) {
                            $startInner = microtime(true);
                            DB::alteration_message(' ... Filter: ' . implode(', ', array_keys($filterAny)));
                        }

                        $array[$className] = $className::get()
                            ->filterAny($filterAny)
                            ->limit($this->Config()->get('limit_of_count_per_data_object'))
                            ->column('ID')
                        ;
                        if ($this->debug) {
                            $elaps = microtime(true) - $startInner;
                            DB::alteration_message('search for ' . $className . ' taken : ' . $elaps);
                        }
                    }

                    if ($this->debug) {
                        DB::alteration_message(' ... No fields in ' . $className);
                    }
                }

                if ($this->debug) {
                    DB::alteration_message(' ... Skipping ' . $className);
                }
            }
        } else {
            $array = $this->getDefaultList();
        }

        if ($this->debug) {
            $elaps = microtime(true) - $startOuter;
            DB::alteration_message('seconds taken find results: ' . $elaps);
        }

        return $array;
    }

    protected function getDefaultList(): array
    {
        $back = $this->config()->get('hours_back_for_recent') ?? 24;
        $limit = $this->Config()->get('limit_per_class_for_recent') ?? 5;
        $threshold = strtotime('-' . $back . ' hours', DBDatetime::now()->getTimestamp());
        if (!$threshold) {
            $threshold = time() - 86400;
        }

        $array = [];
        $classNames = $this->getAllDataObjects();
        foreach ($classNames as $className) {
            if(count($this->includedClasses) && !in_array($className, $this->includedClasses, true)) {
                continue;
            }
            if (!in_array($className, $this->excludedClasses, true)) {
                $array[$className] = $className::get()
                    ->filter('LastEdited:GreaterThan', date('Y-m-d H:i:s', $threshold))
                    ->sort(['LastEdited' => 'DESC'])
                    ->limit($limit)
                    ->column('ID')
                ;
            }
        }

        return $array;
    }

    protected function turnArrayIntoObjects(array $matches, ?int $limit = 0): array
    {
        $start = 0;
        if (empty($this->objects)) {
            if (empty($limit)) {
                $limit = (int) $this->Config()->get('limit_of_count_per_data_object');
            }

            $this->objects = [];
            if ($this->debug) {
                DB::alteration_message('number of classes: ' . count($matches));
            }

            foreach ($matches as $className => $ids) {
                if ($this->debug) {
                    $start = microtime(true);
                    DB::alteration_message(' ... number of matches for : ' . $className . ': ' . count($ids));
                }

                if (count($ids)) {
                    $className = (string) $className;
                    $items = $className::get()
                        ->filter(['ID' => $ids, 'ClassName' => $className])
                        ->limit($limit)
                    ;
                    foreach ($items as $item) {
                        if ($item->canView()) {
                            $this->objects[] = $item;
                        }
                    }
                }

                if ($this->debug) {
                    $elaps = microtime(true) - $start;
                    DB::alteration_message('seconds taken to find objects in: ' . $className . ': ' . $elaps);
                }
            }
        }

        return $this->objects;
    }

    protected function turnMatchesIntoList(array $matches): ArrayList
    {
        // helper
        //return values
        $list = ArrayList::create();
        $finder = Injector::inst()->get(FindEditableObjects::class);
        $finder->initCache($this->quickSearchType)
            ->setIncludedClasses($this->includedClasses)
            ->setExcludedClasses($this->excludedClasses);

        $items = $this->turnArrayIntoObjects($matches);
        foreach ($items as $item) {
            $link = $finder->getLink($item, $this->excludedClasses);
            if($item->canView()) {
                $cmsEditLink = $item->canEdit() ? $finder->getCMSEditLink($item) : '';
                $list->push(
                    ArrayData::create(
                        [
                            'HasLink' => (bool) $link,
                            'HasCMSEditLink' => (bool) $cmsEditLink,
                            'Link' => $link,
                            'CMSEditLink' => $cmsEditLink,
                            'ID' => $item->ID,
                            'Title' => $item->getTitle(),
                            'SingularName' => $item->i18n_singular_name(),
                            'SiteWideSearchSortValue' => $this->getSortValue($item),
                            'CMSThumbnail' => DBField::create_field('HTMLText', $finder->getCMSThumbnail($item)),
                        ]
                    )
                );
            }
        }

        $finder->saveCache();
        if(!empty($this->sortOverride)) {
            return $list->sort($this->sortOverride);
        } else {
            return $list->sort(['SiteWideSearchSortValue' => 'ASC']);
        }
    }

    protected function getSortValue($item)
    {
        $className = $item->ClassName;
        $fields = $this->getAllValidFields($className);
        $fullWords = implode(' ', $this->words);

        $done = false;
        $score = 0;
        if ($fullWords) {
            $fieldValues = [];
            $fieldValuesAll = '';

            foreach ($fields as $field) {
                $fieldValues[$field] = strtolower(strip_tags((string) $item->{$field}));
            }

            $fieldValuesAll = implode(' ', $fieldValues);
            $testWords = array_merge(
                [$fullWords],
                $this->words
            );
            $testWords = array_unique($testWords);
            foreach ($testWords as $wordKey => $word) {
                //match a exact field to full words / one word
                $fullWords = !(bool) $wordKey;
                if (false === $done) {
                    $count = 0;
                    foreach ($fieldValues as $fieldValue) {
                        ++$count;
                        if ($fieldValue === $word) {
                            $score += (int) $wordKey + $count;
                            $done = true;

                            break;
                        }
                    }
                }

                // the full string / any of the words are present?
                if (false === $done) {
                    $pos = strpos($fieldValuesAll, $word);
                    if (false !== $pos) {
                        $score += (($pos + 1) / strlen($word)) * 1000;
                        $done = true;
                    }
                }

                // all individual words are present
                if (false === $done) {
                    if ($fullWords) {
                        $score += 1000;
                        $allMatch = true;
                        foreach ($this->words as $tmpWord) {
                            $pos = strpos($fieldValuesAll, $tmpWord);
                            if (false === $pos) {
                                $allMatch = false;

                                break;
                            }
                        }

                        if ($allMatch) {
                            $done = true;
                        }
                    }
                }
            }
        }

        //the older the item, the higher the scoare
        //1104622247 = 1 jan 2005
        return $score + (1 / (strtotime($item->LastEdited) - 1104537600));
    }

    protected function workOutInclusionsAndExclusions()
    {
        $this->excludedClasses = array_unique(
            array_merge(
                $this->Config()->get('default_exclude_classes'),
                $this->excludedClasses
            )
        );
        $this->excludedFields = array_unique(
            array_merge(
                $this->Config()->get('default_exclude_fields'),
                $this->excludedFields
            )
        );
        $this->includedClasses = array_unique(
            array_merge(
                $this->Config()->get('default_include_classes'),
                $this->includedClasses
            )
        );
        $this->includedFields = array_unique(
            array_merge(
                $this->Config()->get('default_include_fields'),
                $this->includedFields
            )
        );
        $this->includedClassFieldCombos = array_unique(
            array_merge(
                $this->Config()->get('default_include_class_field_combos'),
                $this->includedClassFieldCombos
            )
        );
    }

    protected function workOutWords(string $word = ''): array
    {
        if ($this->searchWholePhrase) {
            $this->words = [implode(' ', $this->words)];
        }

        if ($word) {
            $this->words[] = $word;
        }

        if (!count($this->words)) {
            user_error('No word has been provided');
        }

        $this->words = array_unique($this->words);
        $this->words = array_filter($this->words);
        $this->words = array_map('strtolower', $this->words);

        return $this->words;
    }

    protected function getAllDataObjects(): array
    {
        if ($this->debug) {
            DB::alteration_message('Base Class: ' . $this->baseClass);
        }

        if (!isset($this->cache['AllDataObjects'][$this->baseClass])) {
            $this->cache['AllDataObjects'][$this->baseClass] = array_values(
                ClassInfo::subclassesFor($this->baseClass, false)
            );
            $this->cache['AllDataObjects'][$this->baseClass] = array_unique($this->cache['AllDataObjects'][$this->baseClass]);
        }

        return $this->cache['AllDataObjects'][$this->baseClass];
    }

    protected function getAllValidFields(string $className): array
    {
        if (!isset($this->cache['AllValidFields'][$className])) {
            $array = [];
            $fullList = Config::inst()->get($className, 'db') + ['ID' => 'Int', 'Created' => 'DBDatetime', 'LastEdited' => 'DBDatetime', 'ClassName' => 'Varchar'];
            if ($this->isQuickSearch) {
                $fullList = $this->getIndexedFields(
                    $className,
                    $fullList
                );
            } else {
                $fullList = Config::inst()->get($className, 'db') + ['ID' => 'Int', 'Created' => 'DBDatetime', 'LastEdited' => 'DBDatetime', 'ClassName' => 'Varchar'];
            }
            foreach ($fullList as $name => $type) {
                if ($this->isValidFieldType($className, $name, $type)) {
                    $array[] = $name;
                } elseif(in_array($name, $this->includedFields, true)) {
                    $array[] = $name;
                }
            }
            if(isset($this->includedClassFieldCombos[$className])) {
                foreach($this->includedClassFieldCombos[$className] as $name => $type) {
                    $array[] = $name;
                }
            }
            $this->cache['AllValidFields'][$className] = $array;
        }

        return $this->cache['AllValidFields'][$className];
    }

    protected function getIndexedFields(string $className, array $dbFields): array
    {
        if (!isset($this->cache['IndexedFields'][$className])) {
            $this->cache['IndexedFields'][$className] = [];
            $indexes = Config::inst()->get($className, 'indexes');
            if (is_array($indexes)) {
                foreach ($indexes as $key => $field) {
                    if (isset($dbFields[$key])) {
                        $this->cache['IndexedFields'][$className][$key] = $dbFields[$key];
                    } elseif (is_array($field)) {
                        foreach ($field as $test) {
                            if (is_array($test)) {
                                if (isset($test['columns'])) {
                                    $test = $test['columns'];
                                } else {
                                    continue;
                                }
                            }

                            $testArray = explode(',', $test);
                            foreach ($testArray as $testInner) {
                                $testInner = trim($testInner);
                                if (isset($dbFields[$testInner])) {
                                    $this->cache['IndexedFields'][$className][$testInner] = $dbFields[$key];
                                }
                            }
                        }
                    }
                }
            }
        }

        return $this->cache['IndexedFields'][$className];
    }

    protected function isValidFieldType(string $className, string $fieldName, string $type): bool
    {
        if (!isset($this->cache['ValidFieldTypes'][$type])) {
            $this->cache['ValidFieldTypes'][$type] = false;
            $singleton = Injector::inst()->get($className);
            $field = $singleton->dbObject($fieldName);
            if ($fieldName !== 'ClassName' && $field instanceof DBString) {
                $this->cache['ValidFieldTypes'][$type] = true;
            }
        }

        return $this->cache['ValidFieldTypes'][$type];
    }
}

sunnysideup / silverstripe-site-wide-search

Push — master ( 3cb69a...782ded )

SearchApi::getLinksInner() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
