DataObjectElasticExtension::deleteFromElastic() - Code Metrics - Inspection of "Delete object from index when unticked 'ShowInSear..." - Firesphere/silverstripe-elastic - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — main (#50)

by Simon

created 2023-10-16 22:53 UTC

DataObjectElasticExtension::deleteFromElastic() A

↳ Parent: DataObjectElasticExtension

Complexity

Conditions	3
Paths	3

Size

Total Lines	11
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	8
c	0
b	0
f	0
nc	3
nop	0
dl	0
loc	11
rs	10

<?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 Http\Promise\Promise;
use Psr\Container\NotFoundExceptionInterface;
use Psr\Log\LoggerInterface;
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
{
    /**
     * @throws NotFoundExceptionInterface
     * @throws ValidationException
     */
    public function onAfterDelete()
    {
        parent::onAfterDelete();
        $this->deleteFromElastic();
    }

    /**
     * Can be called directly, if a DataObject needs to be removed
     * immediately.
     * @return void
     * @throws NotFoundExceptionInterface
     */
    public function deleteFromElastic(): void
    {
        $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'])) {

                $deleteQuery = $this->getDeleteQuery($index);
                $this->executeQuery($service, $deleteQuery);
            }
        }
    }

    /**
     * @param mixed $index
     * @return array
     */
    private function getDeleteQuery(mixed $index): array
    {
        return [
            'index' => $index,
            '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) {
            // DirtyClass handling is a DataObject Search Core extension
            $dirty = $this->owner->getDirtyClass('DELETE');
            $dirty = $this->owner->getDirtyClass('DELETE');
            $ids = json_decode($dirty->IDs ?? '[]');
            $ids[] = $this->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();
        if (
            !$this->owner->hasExtension(Versioned::class) ||
            !$this->owner->/** @scrutinizer ignore-call */ hasExtension(Versioned::class) ||
            ($this->owner->hasExtension(Versioned::class) && $this->owner->isPublished())
            ($this->owner->hasExtension(Versioned::class) && $this->owner->/** @scrutinizer ignore-call */ isPublished())
        ) {
            $this->pushToElastic();
        }

        // @codeCoverageIgnoreStart Elastic during tests isn't fast enough to pick this up properly
        if ($this->owner->isChanged('ShowInSearch') && !$this->owner->ShowInSearch) {
        if ($this->owner->/** @scrutinizer ignore-call */ isChanged('ShowInSearch') && !$this->owner->ShowInSearch) {
            $this->deleteFromElastic();
        }
        // @codeCoverageIgnoreEnd
    }

    /**
     * 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()
    {
        $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 ?? false;
    }
}


Firesphere / silverstripe-elastic

Pull Request — main (#50)

DataObjectElasticExtension::deleteFromElastic() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like