Yaro\Jarboe\Table\Repositories\ModelRepository

Complexity

Total Complexity

44

Size/Duplication

Total Lines	233
Duplicated Lines	18.88 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

68.6%

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	order()	0	7	1
A	applySortableOrder()	0	4	1
A	reorder()	0	23	3
A	setCrud()	0	6	1
A	get()	0	18	2
A	find()	0	13	2
A	delete()	0	6	1
A	store()	23	23	5
B	update()	21	21	6
A	updateField()	0	16	4
A	filter()	0	4	1
A	perPage()	0	8	2
A	applyFilter()	0	7	2
A	applySearchFilters()	0	8	3
B	applyOrder()	0	22	7
A	applyPaginate()	0	4	1
A	restore()	0	6	1
A	forceDelete()	0	6	1

<?php

namespace Yaro\Jarboe\Table\Repositories;

use Illuminate\Http\Request;
use Yaro\Jarboe\Table\CRUD;
use Yaro\Jarboe\Table\Fields\AbstractField;

class ModelRepository implements ModelRepositoryInterface
{
    /**
     * @var CRUD
     */
    private $crud;
    private $filter;
    private $perPage = 20;
    private $defaultOrder = [
        'column'    => false,
        'direction' => false,
    ];

    public function setCrud(CRUD $crud)
    {
        $this->crud = $crud;

        return $this;
    }

    public function get()

The return type could not be reliably inferred; please add a @return annotation.

    {
        $model = $this->crud->getModel();
        $model = $model::query();

        $this->applyFilter($model);
        $this->applySearchFilters($model);

        if ($this->crud->isSortableByWeightActive()) {
            $this->applySortableOrder($model);
        } else {
            $this->applyOrder($model);
        }

        $this->applyPaginate($model);

        return $model;
    }

    public function find($id)

The return type could not be reliably inferred; please add a @return annotation.

    {
        $model = $this->crud->getModel();
        $model = $model::query();
        $this->applyFilter($model);

        $model = $model->find($id);
        if (!$model) {
            throw new \RuntimeException(sprintf('Not allowed or no record to edit [%s]', $id));
        }

        return $model;
    }

    public function delete($id)

The return type could not be reliably inferred; please add a @return annotation.

    {
        $model = $this->find($id);

        return $model->delete();
    }

    public function store(Request $request)

The return type could not be reliably inferred; please add a @return annotation.

    {
        $fields = $this->crud->getFieldsWithoutMarkup();
        $model = $this->crud->getModel();

        $data = [];
        /** @var AbstractField $field */
        foreach ($fields as $field) {
            if ($field->hidden('create') || /*$field->isReadonly() || */$field->shouldSkip($request)) {
                continue;
            }
            $data += [$field->name() => $field->value($request)];
        }

        $model = $model::create($data);

        /** @var AbstractField $field */
        foreach ($fields as $field) {
            $field->afterStore($model, $request);
        }

        return $model;
    }

    public function update($id, Request $request)
    {
        $fields = $this->crud->getFieldsWithoutMarkup();
        $model = $this->find($id);

        $data = [];
        /** @var AbstractField $field */
        foreach ($fields as $field) {
            if ($field->hidden('edit') || $field->isReadonly() || $field->shouldSkip($request)) {
                continue;
            }
            $data += [$field->name() => $field->value($request)];
        }

        $model->update($data);

        /** @var AbstractField $field */
        foreach ($fields as $field) {
            $field->afterUpdate($model, $request);
        }
    }

    public function updateField($id, Request $request, AbstractField $field, $value)

The return type could not be reliably inferred; please add a @return annotation.

    {
        $model = $this->find($id);

        // FIXME: move
        if (!$field->isInline() || $field->isReadonly() || $field->shouldSkip($request)) {
            return;
        }

        $model->update([
            $field->name() => $value,
        ]);
        $field->afterUpdate($model, $request);

        return $model;
    }

    public function filter(\Closure $callback)
    {
        $this->filter = $callback;
    }

    public function order(string $column, string $direction)
    {
        $this->defaultOrder = [
            'column'    => $column,
            'direction' => $direction,
        ];
    }

    public function perPage(int $perPage = null)
    {
        if (is_null($perPage)) {
            return $this->perPage;
        }

        $this->perPage = $perPage;
    }

    private function applyFilter($model)
    {
        $callback = $this->filter;
        if ($callback) {
            $callback($model);
        }
    }

    private function applySearchFilters($model)
    {
        foreach ($this->crud->getAllFieldObjects() as $field) {
            if ($field->filter()) {
                $field->filter()->apply($model, $field->name());
            }
        }
    }

    private function applyOrder($model)
    {
        $shouldApplyDefaultOrder = true;
        foreach ($this->crud->getAllFieldObjects() as $field) {
            if ($field->isOrderable()) {
                $direction = $this->crud->getOrderFilterParam($field->name());
                if (!is_null($direction)) {
                    $callback = $field->getOverridedOrderCallback();
                    if ($callback) {
                        $callback($model, $field, $direction, $shouldApplyDefaultOrder);
                    } else {
                        $model->orderBy($field->name(), $direction);
                        $shouldApplyDefaultOrder = false;
                    }
                }
            }
        }

        if ($shouldApplyDefaultOrder && array_filter($this->defaultOrder)) {
            $model->orderBy($this->defaultOrder['column'], $this->defaultOrder['direction']);
        }
    }

    private function applyPaginate(&$model)
    {
        $model = $model->paginate($this->perPage());
    }

    private function applySortableOrder($model)
    {
        $model->orderBy($this->crud->getSortableWeightFieldName(), 'asc');
    }

    public function reorder($id, $idPrev, $idNext)
    {
        $sort = $this->crud->getSortableWeightFieldName();
        $model = $this->crud->getModel();
        $query = $model::query();
        $key = (new $model)->getKeyName();

        if ($idPrev) {
            $weight = $this->find($idPrev)->$sort + 1;
            $this->find($id)->update([
                $sort => $weight,
            ]);

            $query->where($key, '!=', $id)->where($sort, '>=', $weight)->increment($sort);
        } elseif ($idNext) {
            $weight = $this->find($idNext)->$sort - 1;
            $this->find($id)->update([
                $sort => $weight,
            ]);

            $query->where($key, '!=', $id)->where($sort, '<=', $weight)->decrement($sort);
        }
    }

    public function restore($id)

The return type could not be reliably inferred; please add a @return annotation.

    {
        $model = $this->find($id);

        return $model->restore();
    }

    public function forceDelete($id)

The return type could not be reliably inferred; please add a @return annotation.

    {
        $model = $this->find($id);

        return $model->forceDelete();
    }
}