Firesphere\ElasticSearch\Extensions\DataObjectElasticExtension

Complexity

Total Complexity

20

Size/Duplication

Total Lines	170
Duplicated Lines	0 %

Importance

Changes	3
Bugs	1	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getDeleteQuery()	0	8	1
A	onAfterDelete()	0	4	1
A	executeQuery()	0	18	2
A	deleteFromElastic()	0	16	3
A	pushToElastic()	0	17	3
A	isDeletedFromElastic()	0	3	1
A	onAfterWrite()	0	14	5
A	shouldPush()	0	16	4

<?php
/**
 * class DataObjectExtension|Firesphere\ElasticSearch\Extensions\DataObjectExtension Adds checking if changes should be
 * pushed to Elastic
 *
 * @package Firesphere\Elastic\Search
 * @author Simon `Firesphere` Erkelens; Marco `Sheepy` Hermo
 * @copyright Copyright (c) 2018 - now() Firesphere & Sheepy
 */

namespace Firesphere\ElasticSearch\Extensions;

use Elastic\Elasticsearch\Exception\ClientResponseException;
use Elastic\Elasticsearch\Exception\ServerResponseException;
use Elastic\Elasticsearch\Response\Elasticsearch;
use Exception;
use Firesphere\ElasticSearch\Indexes\ElasticIndex;
use Firesphere\ElasticSearch\Services\ElasticCoreService;
use Firesphere\SearchBackend\Extensions\DataObjectSearchExtension;
use Http\Promise\Promise;
use Psr\Container\NotFoundExceptionInterface;
use Psr\Log\LoggerInterface;
use SilverStripe\CMS\Model\SiteTree;
use SilverStripe\Core\Injector\Injector;
use SilverStripe\ORM\ArrayList;
use SilverStripe\ORM\DataExtension;
use SilverStripe\ORM\DataObject;
use SilverStripe\Versioned\Versioned;

/**
 * Class \Firesphere\ElasticSearch\Extensions\DataObjectElasticExtension
 *
 * @property DataObject|DataObjectElasticExtension $owner
 */
class DataObjectElasticExtension extends DataExtension
{
    protected $deletedFromElastic;

    /**
     * @throws NotFoundExceptionInterface
     */
    public function onAfterDelete()
    {
        parent::onAfterDelete();
        $this->deleteFromElastic();
    }

    /**
     * Can be called directly, if a DataObject needs to be removed
     * immediately.
     * @return bool|Elasticsearch|Promise
     * @throws NotFoundExceptionInterface
     */
    public function deleteFromElastic()
    {
        $result = false;
        $service = Injector::inst()->get(ElasticCoreService::class);
        $indexes = $service->getValidIndexes();
        foreach ($indexes as $index) {
            /** @var ElasticIndex $idx */
            $idx = Injector::inst()->get($index);
            $config = ElasticIndex::config()->get($idx->getIndexName());
            if (in_array($this->owner->ClassName, $config['Classes'])) {
                $deleteQuery = $this->getDeleteQuery($idx);
                $result = $this->executeQuery($service, $deleteQuery);
            }
        }

        return $result;
    }

    /**
     * @param ElasticIndex $index
     * @return array
     */
    private function getDeleteQuery(ElasticIndex $index): array
    {
        return [
            'index' => $index->getIndexName(),
            'body'  => [
                'query' => [
                    'match' => [
                        'id' => sprintf('%s-%s', $this->owner->ClassName, $this->owner->ID)
                    ]
                ]
            ]
        ];
    }

    /**
     * @param ElasticCoreService $service
     * @param array $deleteQuery
     * @return Elasticsearch|Promise|bool
     * @throws NotFoundExceptionInterface
     */
    protected function executeQuery(ElasticCoreService $service, array $deleteQuery)
    {
        try {
            return $service->getClient()->deleteByQuery($deleteQuery);
        } catch (Exception $e) {
            /** @var DataObjectSearchExtension|DataObject $owner */
            $owner = $this->owner;
            // DirtyClass handling is a DataObject Search Core extension
            $dirty = $owner->getDirtyClass('DELETE');
            $ids = json_decode($dirty->IDs ?? '[]');
            $ids[] = $owner->ID;
            $dirty->IDs = json_encode($ids);
            $dirty->write();
            /** @var LoggerInterface $logger */
            $logger = Injector::inst()->get(LoggerInterface::class);
            $logger->error($e->getMessage(), $e->getTrace());

            return false;
        }
    }

    /**
     * Reindex after write, if it's an indexed new/updated object
     * @throws ClientResponseException
     * @throws NotFoundExceptionInterface
     * @throws ServerResponseException
     */
    public function onAfterWrite()
    {
        parent::onAfterWrite();
        /** @var DataObject|SiteTree|DataObjectElasticExtension|DataObjectSearchExtension|Versioned $owner */
        $owner = $this->owner;
        if ($this->shouldPush($owner)) {

It seems like $owner can also be of type Firesphere\ElasticSearch\Extensions\DataObjectElasticExtension; however, parameter $owner of Firesphere\ElasticSearch\Extensions\DataObjectElasticExtension::shouldPush() does only seem to accept SilverStripe\ORM\DataObject, maybe add an additional type check?

            $this->pushToElastic();
        }

        if ($owner->hasField('ShowInSearch') &&
            $owner->isChanged('ShowInSearch') &&
            !$owner->ShowInSearch
        ) {
            $this->deletedFromElastic = $this->deleteFromElastic();
        }
    }

    /**
     * Check if:
     * - Owner has Versioned
     * - The versioned object is published
     * - The owner has the "ShowInSearch" Field
     * - And if so, is it set.
     * @param SiteTree|DataObjectSearchExtension|DataObjectElasticExtension|Versioned|DataObject $owner
     * @return bool
     */
    public function shouldPush(DataObject $owner): bool
    {
        $showInSearch = true;
        $versioned = $owner->hasExtension(Versioned::class);
        if ($versioned) {
            $versioned = $owner->isPublished();
        } else {
            // The owner is not versioned, so no publishing check
            $versioned = true;
        }
        $hasField = $owner->hasField('ShowInSearch');
        if ($hasField) {
            $showInSearch = $owner->ShowInSearch;
        }

        return ($versioned && $showInSearch);
    }

    /**
     * This is a separate method from the delete action, as it's a different route
     * and query components.
     * It can be called to add an object to the index immediately, without
     * requiring a write.
     * @return mixed
     * @throws ClientResponseException
     * @throws NotFoundExceptionInterface
     * @throws ServerResponseException
     */
    public function pushToElastic()
    {
        $result = false;
        $list = ArrayList::create();
        $list->push($this->owner);
        /** @var ElasticCoreService $service */
        $service = Injector::inst()->get(ElasticCoreService::class);
        foreach ($service->getValidIndexes() as $indexStr) {
            /** @var ElasticIndex $index */
            $index = Injector::inst()->get($indexStr);
            $idxConfig = ElasticIndex::config()->get($index->getIndexName());
            if (in_array($this->owner->ClassName, $idxConfig['Classes'])) {
                $result = $service->updateIndex($index, $list);
            }
        }

        return $result;
    }

    /**
     * Add ability to see what the response
     * from Elasticsearch was after a delete action.
     *
     * @return mixed
     */
    public function isDeletedFromElastic()
    {
        return $this->deletedFromElastic;
    }
}