Isswp101\Persimmon\Repository\ElasticsearchRepository

Complexity

Total Complexity

12

Size/Duplication

Total Lines	109
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	instantiate()	0	8	2
A	find()	0	20	2
A	all()	0	21	3
A	fill()	0	6	1
A	insert()	0	13	1
A	update()	0	13	1
A	delete()	0	12	1

<?php

namespace Isswp101\Persimmon\Repository;

use Elasticsearch\Client;
use Elasticsearch\Common\Exceptions\Missing404Exception;
use Isswp101\Persimmon\Collection\ElasticsearchCollection;
use Isswp101\Persimmon\Collection\ICollection;
use Isswp101\Persimmon\CollectionParser\ElasticsearchCollectionParser;
use Isswp101\Persimmon\Contracts\Storable;
use Isswp101\Persimmon\Exceptions\ClassTypeErrorException;
use Isswp101\Persimmon\Exceptions\ModelNotFoundException;
use Isswp101\Persimmon\Model\IElasticsearchModel;
use Isswp101\Persimmon\QueryBuilder\IQueryBuilder;
use Isswp101\Persimmon\Relationship\RelationshipKey;
use Isswp101\Persimmon\Response\ElasticsearchCollectionResponse;
use Isswp101\Persimmon\Response\ElasticsearchItemResponse;

class ElasticsearchRepository implements IRepository
{
    private $client;

    public function __construct(Client $client)
    {
        $this->client = $client;
    }

    public function instantiate(string $class): Storable
    {
        $instance = new $class;
        if (!$instance instanceof IElasticsearchModel) {
            throw new ClassTypeErrorException(IElasticsearchModel::class);
        }
        return $instance;
    }

    protected function fill(Storable $model, ElasticsearchItemResponse $response)
    {
        $relationshipKey = new RelationshipKey($response->id(), $response->parent());
        $model->setPrimaryKey($relationshipKey->build());
        $model->fill($response->source());
    }

    public function find(string $id, string $class, array $columns = []): ?Storable
    {
        $model = $this->instantiate($class);
        $relationshipKey = RelationshipKey::parse($id);
        $collection = new ElasticsearchCollectionParser($model->getCollection());
        $params = [
            'index' => $collection->getIndex(),
            'type' => $collection->getType(),
            'id' => $relationshipKey->getId(),
            'parent' => $relationshipKey->getParentId(),
            '_source' => $columns
        ];
        try {
            $response = new ElasticsearchItemResponse($this->client->get($params));

$this->client->get($params) is of type callable, but the function expects a array.

        } catch (Missing404Exception $e) {
            throw new ModelNotFoundException($class, $id);
        }
        $this->fill($model, $response);
        return $model;
    }

    public function all(IQueryBuilder $query, string $class, callable $callback = null): ICollection
    {
        $model = $this->instantiate($class);
        $collection = new ElasticsearchCollectionParser($model->getCollection());
        $params = [
            'index' => $collection->getIndex(),
            'type' => $collection->getType(),
            'body' => $query->build()
        ];
        $response = new ElasticsearchCollectionResponse($this->client->search($params));

$this->client->search($params) is of type callable, but the function expects a array.

        $models = new ElasticsearchCollection([], $response);
        foreach ($response->hits() as $hit) {
            $model = $this->instantiate($class);
            $this->fill($model, new ElasticsearchItemResponse($hit));
            if ($callback != null) {
                $callback($model);
            }
            $models->put($model->getPrimaryKey(), $model);
        }
        return $models;
    }

    public function insert(Storable $model): void
    {
        $relationshipKey = RelationshipKey::parse($model->getPrimaryKey());
        $collection = new ElasticsearchCollectionParser($model->getCollection());
        $params = [
            'index' => $collection->getIndex(),
            'type' => $collection->getType(),
            'id' => $relationshipKey->getId(),
            'parent' => $relationshipKey->getParentId(),
            'body' => $model->toArray()
        ];
        $this->client->index($params);
    }

    public function update(Storable $model): void
    {
        $relationshipKey = RelationshipKey::parse($model->getPrimaryKey());
        $collection = new ElasticsearchCollectionParser($model->getCollection());
        $params = [
            'index' => $collection->getIndex(),
            'type' => $collection->getType(),
            'id' => $relationshipKey->getId(),
            'parent' => $relationshipKey->getParentId(),
            'body' => $model->toArray()
        ];
        $this->client->index($params);
    }

    public function delete(Storable $model): void
    {
        $relationshipKey = RelationshipKey::parse($model->getPrimaryKey());
        $collection = new ElasticsearchCollectionParser($model->getCollection());
        $params = [
            'index' => $collection->getIndex(),
            'type' => $collection->getType(),
            'id' => $relationshipKey->getId(),
            'parent' => $relationshipKey->getParentId()
        ];
        $this->client->delete($params);
    }
}