Firesphere\ElasticSearch\Extensions\DataObjectElasticExtension

Complexity

Total Complexity

18

Size/Duplication

Total Lines	141
Duplicated Lines	0 %

Importance

Changes	4
Bugs	1	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	pushToElastic()	0	17	3
A	getDeletedFromElastic()	0	3	1
B	onAfterWrite()	0	16	7
A	getDeleteQuery()	0	8	1
A	onAfterDelete()	0	4	1
A	executeQuery()	0	18	2
A	deleteFromElastic()	0	16	3

<?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\ORM\ValidationException;
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 = new ElasticCoreService();
        $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'])) {

The property ClassName does not exist on Firesphere\ElasticSearch\Extensions\DataObjectElasticExtension. Did you maybe forget to declare it?

                $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)

The property ClassName does not exist on Firesphere\ElasticSearch\Extensions\DataObjectElasticExtension. Did you maybe forget to declare it?

The property ID does not exist on Firesphere\ElasticSearch\Extensions\DataObjectElasticExtension. Did you mean IDs?

                    ]
                ]
            ]
        ];
    }

    /**
     * @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 (
            !$owner->hasExtension(Versioned::class) ||

The method hasExtension() does not exist on Firesphere\ElasticSearch\Extensions\DataObjectElasticExtension.

            ($owner->hasExtension(Versioned::class) && $owner->isPublished())

The method isPublished() does not exist on Firesphere\ElasticSearch\Extensions\DataObjectElasticExtension.

        ) {
            $this->pushToElastic();
        }

        if ($owner->hasField('ShowInSearch') &&

The method hasField() does not exist on Firesphere\ElasticSearch\Extensions\DataObjectElasticExtension.

            $owner->isChanged('ShowInSearch') &&

The method isChanged() does not exist on Firesphere\ElasticSearch\Extensions\DataObjectElasticExtension.

            !$owner->ShowInSearch) {

The property ShowInSearch does not exist on Firesphere\ElasticSearch\Extensions\DataObjectElasticExtension. Did you maybe forget to declare it?

            $this->deletedFromElastic = $this->deleteFromElastic();
        }
    }

    /**
     * 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 array|void|bool
     * @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'])) {

The property ClassName does not exist on Firesphere\ElasticSearch\Extensions\DataObjectElasticExtension. Did you maybe forget to declare it?

                $result = $service->updateIndex($index, $list);
            }
        }

        return $result;

The expression return $result also could return the type Elastic\Elasticsearch\Response\Elasticsearch|Http\Promise\Promise which is incompatible with the documented return type array|boolean.

    }

    /**
     * @return mixed
     */
    public function getDeletedFromElastic()
    {
        return $this->deletedFromElastic;
    }
}