Searchable::bootSearchable() - Code Metrics - triadev/Leopard - Measure and Improve Code Quality continuously with Scrutinizer

Searchable::bootSearchable() A
last analyzed 2019-01-12 21:01 UTC

↳ Parent: Searchable

Complexity

Conditions	3
Paths	1

Size

Total Lines	18
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	3.4746

Importance

Changes

Metric	Value
cc	3
eloc	8
nc	1
nop	0
dl	0
loc	18
ccs	5
cts	8
cp	0.625
crap	3.4746
rs	10
c	0
b	0
f	0

<?php
namespace Triadev\Leopard;

use Carbon\Carbon;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Support\Collection;
use Triadev\Leopard\Business\Helper\IsModelSearchable;
use Triadev\Leopard\Contract\ElasticsearchManagerContract;
use Triadev\Leopard\Contract\Repository\ElasticsearchRepositoryContract;
use Triadev\Leopard\Facade\Leopard;
use Triadev\Leopard\Model\SyncRelationship;

/**
 * Trait Searchable
 * @package Triadev\Leopard
 *
 * @property string $documentIndex
 * @property string $documentType
 * @property bool $syncDocument
 * @property array $searchable
 *
 * @method static ElasticsearchManagerContract search()
 * @methdo static ElasticsearchManagerContract suggest()
 * @method array buildDocument()
 * @method SyncRelationship[] buildSyncRelationships()
 * @method array toArray()
 * @method string getTable()
 *
 * @method BelongsTo belongsTo($related, $foreignKey = null, $ownerKey = null, $relation = null)
 */
trait Searchable
{
    use IsModelSearchable;
    
    /** @var bool */
    public $isDocument = false;
    
    /** @var float|null */
    public $documentScore;
    
    /** @var int|null */
    public $documentVersion;
    
    /**
     * Searchable boot model.
     */
    public static function bootSearchable()
    {
        static::saved(function (Model $model) {
            /** @var Model|Searchable $model */
            if ($model->shouldSyncDocument()) {
                $model->repository()->save($model);
                $model->repository()->save(/** @scrutinizer ignore-type */ $model);
            }
    
            $model->syncRelationships();
        });
        
        static::deleted(function (Model $model) {
            /** @var Model|Searchable $model */
            if ($model->shouldSyncDocument()) {
                $model->repository()->delete($model);
                $model->repository()->delete(/** @scrutinizer ignore-type */ $model);
            }
    
            $model->syncRelationships();
        });
    }
    
    /**
     * Repository
     *
     * @return ElasticsearchRepositoryContract
     */
    public function repository(): ElasticsearchRepositoryContract
    {
        return app(ElasticsearchRepositoryContract::class);
    }
    
    /**
     * Get document index
     *
     * @return string|null
     */
    public function getDocumentIndex(): ?string
    {
        if (property_exists($this, 'documentIndex')) {
            return $this->documentIndex;
        }
        
        return null;
    }
    
    /**
     * Get document type
     *
     * @return string
     */
    public function getDocumentType(): string
    {
        if (property_exists($this, 'documentType')) {
            return (string)$this->documentType;
        }
        
        return (string)$this->getTable();
    }
    
    /**
     * Should sync document
     *
     * @return bool
     */
    public function shouldSyncDocument(): bool
    {
        if (property_exists($this, 'syncDocument')) {
            return (bool)$this->syncDocument;
        }
        
        return true;
    }
    
    /**
     * Sync relationships
     */
    public function syncRelationships()
    {
        if (method_exists($this, 'buildSyncRelationships')) {
            foreach ($this->buildSyncRelationships() as $syncRelationship) {
                if (!$syncRelationship instanceof SyncRelationship) {
                    continue;
                }
                
                /** @var BelongsTo $relation */
                $relation = $this->belongsTo(
                    $syncRelationship->getRelatedClass(),
                    $syncRelationship->getForeignKey(),
                    $syncRelationship->getOwnerKey(),
                    $syncRelationship->getRelation()
                );
    
                foreach ($relation->get() as $r) {
                    /** @var Model|Searchable $r */
                    if (!$r || !$this->isModelSearchable($r)) {
                    if (!$r || !$this->isModelSearchable(/** @scrutinizer ignore-type */ $r)) {
                        continue;
                    }
        
                    $r->repository()->save($r);
                }
            }
        }
    }
    
    /**
     * Get document data
     *
     * @return array
     */
    public function getDocumentData() : array
    {
        if (method_exists($this, 'buildDocument')) {
            return $this->buildDocument();
        }
        
        if (property_exists($this, 'searchable') && is_array($this->searchable)) {
            return $this->buildDocumentFromArray($this->searchable);
        }
        
        return $this->toArray();
    }
    
    private function buildDocumentFromArray(array $searchable)
    {
        $document = [];
        
        foreach ($searchable as $value) {
            $result = $this->$value;
            
            if ($result instanceof Collection) {
                $result = $result->toArray();
            } elseif ($result instanceof Carbon) {
                $result = $result->toDateTimeString();
            } else {
                $result = $this->$value;
            }
            
            $document[$value] = $result;
        }
        
        return $document;
    }
    
    /**
     * @param $name
     * @param $arguments
     * @return mixed
     */
    public function __call($name, $arguments)
    {
        if ($name == 'search') {
            return Leopard::search()->model($this);
            return Leopard::search()->model(/** @scrutinizer ignore-type */ $this);
        }
        
        if ($name == 'suggest') {
            return Leopard::suggest();
        }
        
        return parent::__call($name, $arguments);
    }
}


triadev / Leopard

Searchable::bootSearchable() A last analyzed 2019-01-12 21:01 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Searchable::bootSearchable() A
last analyzed 2019-01-12 21:01 UTC