Yaro\Jarboe\Table\Fields\Select

Complexity

Total Complexity

34

Size/Duplication

Total Lines	164
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	3
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	getCreateFormView()	0	4	1
A	getListView()	0	6	1
A	getEditFormView()	0	7	2
A	isSimpleType()	0	3	1
A	afterStore()	0	3	1
A	value()	0	13	6
A	isSelect2Type()	0	3	1
B	isCurrentOption()	0	36	10
A	afterUpdate()	0	10	3
A	getType()	0	3	1
A	filterValuesForMorphToManyRelation()	0	11	3
A	isMultiple()	0	3	1
A	multiple()	0	5	1
A	type()	0	10	2

<?php

namespace Yaro\Jarboe\Table\Fields;

use Illuminate\Http\Request;
use Illuminate\Support\Collection;
use Yaro\Jarboe\Table\Fields\Traits\Ajax;
use Yaro\Jarboe\Table\Fields\Traits\Nullable;
use Yaro\Jarboe\Table\Fields\Traits\Orderable;
use Yaro\Jarboe\Table\Fields\Traits\Relations;

class Select extends AbstractField

The type Yaro\Jarboe\Table\Fields\AbstractField was not found. Maybe you did not declare it correctly or list all dependencies?

{
    use Orderable;
    use Relations;
    use Nullable;
    use Ajax;

    const SIMPLE   = 'simple';
    const SELECT_2 = 'select2';

    const ALLOWED_TYPES = [
        self::SIMPLE,
        self::SELECT_2,
    ];

    protected $multiple = false;
    protected $type = self::SIMPLE;

    public function isSelect2Type()
    {
        return $this->type == self::SELECT_2;
    }

    public function isSimpleType()
    {
        return $this->type == self::SIMPLE;
    }

    public function type($type)
    {
        $type = strtolower($type);
        if (!in_array($type, self::ALLOWED_TYPES)) {
            throw new \RuntimeException(sprintf('Not allowed type [%s] for SelectField', $type));
        }

        $this->type = $type;

        return $this;
    }

    public function getType()
    {
        return $this->type;
    }

    public function multiple(bool $multiple = true)
    {
        $this->multiple = $multiple;

        return $this;
    }

    public function isMultiple()
    {
        return $this->multiple;
    }

    public function isCurrentOption($option, $model = null, $relationIndex = 0): bool
    {
        if ($this->hasOld()) {
            if ($this->isGroupedRelation()) {
                $option = crc32($this->relations[$relationIndex]['group']) .'~~~'. $option;
            }
            if ($this->isMultiple()) {
                return in_array($option, $this->old());
            }
            return $this->old() == $option;
        }

        if (is_null($model)) {
            return (string) $option === (string) $this->getDefault();
        }

        if ($this->isMultiple() && !$this->isRelationField()) {
            return in_array($option, $model->{$this->name});
        }

        if ($this->isRelationField()) {
            $related = $model->{$this->getRelationMethod($relationIndex)};
            if ($related) {
                $relatedModelClass = get_class($model->{$this->getRelationMethod($relationIndex)}()->getRelated());
                $freshRelatedModel = new $relatedModelClass;
                $collection = $related;
                if (!is_a($related, Collection::class)) {
                    $collection = collect([$related]);
                }

                return $collection->contains($freshRelatedModel->getKeyName(), $option);
            }
            return false;
        }

        return (string) $option === (string) $model->{$this->name};
    }

    public function value(Request $request)
    {
        $value = $request->get($this->name());

        if ($this->isMultiple() && !$this->isRelationField()) {
            $value = $value ?: [];
        }

        if (!$value && $this->isNullable()) {
            return null;
        }

        return $value;
    }

    public function afterStore($model, Request $request)
    {
        $this->afterUpdate($model, $request);
    }

    public function afterUpdate($model, Request $request)
    {
        if (!$this->isRelationField()) {
            return;
        }
        if ($this->isReadonly()) {
            return;
        }

        $this->syncRelations($model, $request->get($this->name()));
    }

    public function getListView($model)
    {
        return view('jarboe::crud.fields.select.list', [
            'model' => $model,
            'field' => $this,
            'options' => $this->getOptions(),
        ]);
    }

    public function getEditFormView($model)
    {
        $template = $this->isReadonly() ? 'readonly' : 'edit';

        return view('jarboe::crud.fields.select.'. $template, [
            'model' => $model,
            'field' => $this,
        ]);
    }

    public function getCreateFormView()
    {
        return view('jarboe::crud.fields.select.create', [
            'field' => $this,
        ]);
    }

    private function filterValuesForMorphToManyRelation($ids, $relationHash)
    {
        $filtered = [];
        foreach ($ids as $id) {
            if (strpos($id, $relationHash .'~~~') !== false) {
                $id = substr($id, 13);
                $filtered[] = $id;
            }
        }

        return $filtered;
    }
}