Yaro\Jarboe\Table\Fields\Traits\Relations

Complexity

Total Complexity

46

Size/Duplication

Total Lines	261
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	5
Bugs	0	Features	1

15 Methods

Rating	Name	Duplication	Size	Complexity
A	getRelatedList()	0	19	4
A	addCondition()	0	5	1
A	relationSearch()	0	5	1
A	getSelectedGroupedOptions()	0	8	2
A	getRelationMethod()	0	3	1
A	relation()	0	9	1
A	isRelationField()	0	3	1
A	isGroupedRelation()	0	3	1
C	syncRelations()	0	70	14
A	getRelationTitleField()	0	3	1
A	getGroupedOptions()	0	8	2
A	options()	0	5	1
A	getSelectedOptions()	0	21	5
A	getRelations()	0	3	1
B	getOptions()	0	40	10

<?php

namespace Yaro\Jarboe\Table\Fields\Traits;

use Illuminate\Database\Eloquent\Model;

This use statement conflicts with another class in this namespace, Yaro\Jarboe\Table\Fields\Traits\Model. Consider defining an alias.

use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\BelongsToMany;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\Relations\HasOne;
use Illuminate\Database\Eloquent\Relations\MorphMany;
use Illuminate\Database\Eloquent\Relations\MorphTo;
use Illuminate\Database\Eloquent\Relations\MorphToMany;
use Illuminate\Support\Arr;

trait Relations
{
    use RelationSearchUrl;

    protected $perPage = 20;

    protected $options = [];
    protected $relations = [];
    protected $additionalCondition;
    protected $searchCallback;

    public function options(array $options)
    {
        $this->options = $options;

        return $this;
    }

    public function getRelationMethod($relationIndex = 0)
    {
        return Arr::get($this->relations, $relationIndex .'.method');
    }

    public function getRelationTitleField($relationIndex = 0)
    {
        return Arr::get($this->relations, $relationIndex .'.title');
    }

    public function relation(string $method, string $titleField, string $groupTitle = '')
    {
        $this->relations[] = [
            'method' => $method,
            'title'  => $titleField,
            'group'  => $groupTitle,
        ];

        return $this;
    }

    public function isGroupedRelation()
    {
        return count($this->relations) > 1;
    }

    public function getRelations()
    {
        return $this->relations;
    }

    public function getOptions(int $page = null, int $perPage = null, $query = null, &$total = 0, $relationIndex = 0, \Closure $clause = null)
    {
        $options = $this->options;
        if ($this->isRelationField() && !$options) {

The expression $options of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            $options = [];
            $model = $this->getModel();

            $related = (new $model)->{$this->getRelationMethod($relationIndex)}()->getRelated();
            $relatedQuery = $related->query();
            if (!is_null($query)) {
                $callback = $this->searchCallback;
                if ($callback) {
                    $relatedQuery = $callback($relatedQuery, $this->getRelationTitleField($relationIndex), $query);
                } else {
                    $relatedQuery->where($this->getRelationTitleField($relationIndex), $query);
                }
            }
            if (!is_null($clause)) {
                $clause($relatedQuery, $related);
            }

            if (!is_null($page) && !is_null($perPage)) {
                $total += (clone $relatedQuery)->count();

                $offset = ($page - 1) * $perPage;
                $relatedQuery->limit($perPage)->offset($offset);
            }

            $callback = $this->additionalCondition;
            if ($callback) {
                $callback($relatedQuery, $related);
            }

            $relations = $relatedQuery->get();
            foreach ($relations as $relation) {
                $options[$relation->getKey()] = $relation->{$this->getRelationTitleField($relationIndex)};
            }
        }

        return $options;
    }

    public function getGroupedOptions(int $page = null, int $perPage = null, $query = null, &$total = 0)
    {
        $options = [];
        foreach ($this->getRelations() as $index => $relation) {
            $options[$relation['group']] = $this->getOptions($page, $perPage, $query, $total, $index);
        }

        return $options;
    }

    protected function getRelatedList($relationClass, $value, $ids): array
    {
        if (!$this->isMultiple()) {
            return array_filter([
                $relationClass->find($value)
            ]);
        }

        if (!$ids) {
            return [];
        }

        $relatedList = [];
        $relatedModels = $relationClass->whereIn($relationClass->getKeyName(), $ids)->get();
        foreach ($relatedModels as $relatedModel) {
            $relatedList[] = $relatedModel;
        }

        return array_filter($relatedList);
    }

    /**
     * @param Model $model
     * @param $value
     */
    public function syncRelations($model, $value)
    {
        foreach ($this->relations as $index => $relation) {
            $relationQuery = $model->{$this->getRelationMethod($index)}()->getRelated();
            $relationClass = get_class($relationQuery);
            $relationClass = new $relationClass;
            $ids = $value ?: [];
            
            switch (get_class($model->{$this->getRelationMethod($index)}())) {
                case HasMany::class:
                    $model->{$this->getRelationMethod($index)}()->update([
                        $model->{$this->getRelationMethod($index)}()->getForeignKeyName() => null,
                    ]);

                    $relatedList = $this->getRelatedList($relationClass, $value, $ids);

                    $model->{$this->getRelationMethod($index)}()->saveMany($relatedList);
                    break;
                case MorphMany::class:
                    $model->{$this->getRelationMethod($index)}()->update([
                        $model->{$this->getRelationMethod($index)}()->getMorphType() => null,
                        $model->{$this->getRelationMethod($index)}()->getForeignKeyName() => null,
                    ]);

                    $relatedList = $this->getRelatedList($relationClass, $value, $ids);
                    if ($relatedList) {
                        $model->{$this->getRelationMethod($index)}()->saveMany($relatedList);
                    }
                    break;
                case MorphToMany::class:
                    if ($relation['group']) { // is morphedByMany
                        $ids = $this->filterValuesForMorphToManyRelation($ids, crc32($relation['group']));

It seems like filterValuesForMorphToManyRelation() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                        $model->{$this->getRelationMethod($index)}()->sync($ids);
                    } else { // is morphToMany
                        $model->{$this->getRelationMethod($index)}()->update([
                            $model->{$this->getRelationMethod($index)}()->getMorphType() => null,
                            $model->{$this->getRelationMethod($index)}()->getForeignPivotKeyName() => null,
                            $model->{$this->getRelationMethod($index)}()->getRelatedPivotKeyName() => null,
                        ]);

                        $relatedList = $this->getRelatedList($relationClass, $value, $ids);
                        $model->{$this->getRelationMethod($index)}()->saveMany($relatedList);
                    }
                    break;
                case BelongsTo::class:
                case MorphTo::class:
                    $model->{$this->getRelationMethod($index)}()->dissociate();

                    $relatedList = $this->getRelatedList($relationClass, $value, $ids);
                    foreach ($relatedList as $relatedModel) {
                        $model->{$this->getRelationMethod($index)}()->associate($relatedModel);
                    }
                    $model->save();
                    break;
                case HasOne::class:
                    $model->{$this->getRelationMethod($index)}()->update([
                        $model->{$this->getRelationMethod($index)}()->getForeignKeyName() => null,
                    ]);

                    $relatedList = $this->getRelatedList($relationClass, $value, $ids);
                    foreach ($relatedList as $relatedModel) {
                        $model->{$this->getRelationMethod($index)}()->save($relatedModel);
                    }
                    break;
                case BelongsToMany::class:
                    $relatedList = $this->getRelatedList($relationClass, $value, $ids);
                    $model->{$this->getRelationMethod($index)}()->sync(
                        collect($relatedList)->pluck($relationClass->getKeyName())->toArray()
                    );
                    break;
            }
        }
    }

    /**
     * Get selected options array.
     *
     * @param null $model

Are you sure the doc-type for parameter $model is correct as it would always require null to be passed?

     * @param int $index
     * @return array
     */
    public function getSelectedOptions($model = null, $index = 0)
    {
        $options = [];
        if (is_null($model)) {

The condition is_null($model) is always true.

            return $options;
        }

        $relations = $model->{$this->getRelationMethod($index)};
        if (is_null($relations)) {
            return $options;
        }

        if ($this->isMultiple()) {
            foreach ($relations as $relation) {
                $options[$relation->getKey()] = $relation->{$this->getRelationTitleField($index)};
            }
        } else {
            $options[$relations->getKey()] = $relations->{$this->getRelationTitleField($index)};
        }

        return $options;
    }

    public function getSelectedGroupedOptions($model = null)
    {
        $options = [];
        foreach ($this->relations as $index => $relation) {
            $options[$relation['group']] = $this->getSelectedOptions($model, $index);
        }

        return $options;
    }

    public function isRelationField()
    {
        return (bool) $this->relations;
    }

    public function addCondition(\Closure $callback)
    {
        $this->additionalCondition = $callback;

        return $this;
    }

    public function relationSearch(\Closure $callback)
    {
        $this->searchCallback = $callback;

        return $this;
    }

    abstract public function getModel();
    abstract public function isMultiple();
}