Sortable::moveToEnd() - Code Metrics - squadron-api/base - Measure and Improve Code Quality continuously with Scrutinizer

Sortable::moveToEnd() A
last analyzed 2019-08-05 17:33 UTC

↳ Parent: Sortable
Complexity

Conditions	2
Paths	2
Size

Total Lines	21
Code Lines	11
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	2
eloc	11
c	1
b	0
f	0
nc	2
nop	0
dl	0
loc	21
rs	9.9
<?php

namespace Squadron\Base\Models\Traits;

use ArrayAccess;
use InvalidArgumentException;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\SoftDeletingScope;

/**
 * @property int $sortOrder
 */
trait Sortable
{
    public static function bootSortable(): void
    {
        static::creating(function ($model) {
            $model->setHighestOrderNumber();
        });
    }

    /**
     * Let's be nice and provide an ordered scope.
     *
     * @param Builder $query
     * @param string  $direction
     *
     * @return Builder
     */
    public function scopeOrdered(Builder $query, string $direction = 'asc'): Builder
    {
        return $query->orderBy($this->determineOrderColumnName(), $direction);

    }

    /**
     * Modify the order column value.
     */
    public function setHighestOrderNumber(): void
    {
        $orderColumnName = $this->determineOrderColumnName();

        $this->$orderColumnName = $this->getHighestOrderNumber() + 1;
    }

    /**
     * Determine the order value for the new record.
     */
    public function getHighestOrderNumber(): int
    {
        return (int) $this->buildSortQuery()->max($this->determineOrderColumnName());
    }

    /**
     * This function reorders the records: the record with the first id in the array
     * will get order 1, the record with the second it will get order 2, ...
     *
     * A starting order number can be optionally supplied (defaults to 1).
     *
     * @param array|\ArrayAccess $ids
     * @param int                $startOrder
     */
    public static function setNewOrder($ids, int $startOrder = 1): void
    {
        if (! \is_array($ids) && ! $ids instanceof ArrayAccess)

        {
            throw new InvalidArgumentException('You must pass an array or ArrayAccess object to setNewOrder');
        }

        $model = new static;

        $orderColumnName = $model->determineOrderColumnName();
        $primaryKeyColumn = $model->getKeyName();
        $primaryKeyColumn = $model->getKeyName();

        foreach ($ids as $id)
        {
            static::withoutGlobalScope(SoftDeletingScope::class)
                ->where($primaryKeyColumn, $id)
                ->update([$orderColumnName => $startOrder++]);
        }
    }

    /**
     * Swaps the order of this model with the model 'below' this model.
     *
     * @return $this
     */
    public function moveOrderDown(): self
    {
        $orderColumnName = $this->determineOrderColumnName();

        $swapWithModel = $this->buildSortQuery()->limit(1)->ordered()
                            ->where($orderColumnName, '>', $this->$orderColumnName)
                            ->first();

        if (! $swapWithModel)
        {
            return $this;
        }

        return $this->swapOrderWithModel($swapWithModel);
    }

    /**
     * Swaps the order of this model with the model 'above' this model.
     *
     * @return $this
     */
    public function moveOrderUp(): self
    {
        $orderColumnName = $this->determineOrderColumnName();

        $swapWithModel = $this->buildSortQuery()->limit(1)
            ->ordered('desc')
            ->where($orderColumnName, '<', $this->$orderColumnName)
            ->first();

        if (! $swapWithModel)
        {
            return $this;
        }

        return $this->swapOrderWithModel($swapWithModel);
    }

    /**
     * Swap the order of this model with the order of another model.
     *
     * @param $otherModel
     *
     * @return $this
     */
    public function swapOrderWithModel(Sortable $otherModel): self
    {
        $orderColumnName = $this->determineOrderColumnName();

        $oldOrderOfOtherModel = $otherModel->$orderColumnName;

        $otherModel->$orderColumnName = $this->$orderColumnName;
        $otherModel->save();
                     save();

        $this->$orderColumnName = $oldOrderOfOtherModel;
        $this->save();

        return $this;
    }

    /**
     * Swap the order of two models.
     *
     * @param $model
     * @param $otherModel
     */
    public static function swapOrder($model, $otherModel): void
    {
        $model->swapOrderWithModel($otherModel);
    }

    /**
     * Moves this model to the first position.
     *
     * @return $this
     */
    public function moveToStart(): self
    {
        $firstModel = $this->buildSortQuery()->limit(1)
            ->ordered()
            ->first();

        if ($firstModel->getKey() === $this->getKey())
        if ($firstModel->getKey() === $this->/** @scrutinizer ignore-call */ getKey())
        {
            return $this;
        }

        $orderColumnName = $this->determineOrderColumnName();

        $this->$orderColumnName = $firstModel->$orderColumnName;
        $this->save();

        $this->buildSortQuery()->where($this->getKeyName(), '!=', $this->getKey())->increment($orderColumnName);

        return $this;
    }

    /**
     * Moves this model to the last position.
     *
     * @return $this
     */
    public function moveToEnd(): self
    {
        $maxOrder = $this->getHighestOrderNumber();

        $orderColumnName = $this->determineOrderColumnName();

        if ($this->$orderColumnName === $maxOrder)
        {
            return $this;
        }

        $oldOrder = $this->$orderColumnName;

        $this->$orderColumnName = $maxOrder;
        $this->save();

        $this->buildSortQuery()->where($this->getKeyName(), '!=', $this->getKey())
            ->where($orderColumnName, '>', $oldOrder)
            ->decrement($orderColumnName);

        return $this;
    }

    /**
     * Determine the column name of the order column.
     */
    protected function determineOrderColumnName(): string
    {
        return 'sortOrder';
    }

    /**
     * Determine the column name of the sorting key column (for filtering reasons).
     */
    protected function determineKeyColumnName(): string
    {
        return null;

    }

    /**
     * Build eloquent builder of sortable.
     *
     * @return Builder
     */
    public function buildSortQuery(): Builder
    {
        $keyColumn = $this->determineKeyColumnName();

        return $keyColumn !== null

                ? static::query()->where($keyColumn, $this->$keyColumn)
                : static::query();
    }
}

squadron-api / base

Sortable::moveToEnd() A last analyzed 2019-08-05 17:33 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Sortable::moveToEnd() A
last analyzed 2019-08-05 17:33 UTC
