Searchable::syncRelationships() - Code Metrics - Inspection of "Sync parent eloquent models when a relationship ha..." - triadev/Leopard - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#14)

by Christopher

created 2018-12-20 23:56 UTC

Searchable::syncRelationships() A

↳ Parent: Searchable

Complexity

Conditions	5
Paths	4

Size

Total Lines	21
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	10
CRAP Score	5.0187

Importance

Changes

Metric	Value
cc	5
eloc	10
nc	4
nop	0
dl	0
loc	21
ccs	10
cts	11
cp	0.9091
crap	5.0187
rs	9.6111
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;

/**
 * Trait Searchable
 * @package Triadev\Leopard
 *
 * @property string $documentIndex
 * @property string $documentType
 * @property bool $syncDocument
 * @property array $searchable
 * @property array $syncRelationships
 *
 * @method static ElasticsearchManagerContract search()
 * @methdo static ElasticsearchManagerContract suggest()
 * @method array buildDocument()
 * @method array toArray()
 * @method string getTable()
 */
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 (property_exists($this, 'syncRelationships')) {
            foreach ($this->syncRelationships as $syncRelationshipClass) {
                /** @var Model $syncRelationship */
                $syncRelationship = new $syncRelationshipClass();
                
                /** @var BelongsTo $relation */
                $relation = $this->belongsTo(
                $relation = $this->belongsTo(
                    $syncRelationshipClass,
                    $syncRelationship->getForeignKey()
                );
                
                /** @var Model|Searchable $parent */
                $parent = $relation->first();
                
                if (!$parent || !$this->isModelSearchable($parent)) {
                if (!$parent || !$this->isModelSearchable(/** @scrutinizer ignore-type */ $parent)) {
                    continue;
                }
                
                $parent->repository()->save($parent);
            }
        }
    }
    
    /**
     * 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

Pull Request — master (#14)

Searchable::syncRelationships() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like