Reorder soft-deleted records

src/SortableTrait.php

@@ -4,6 +4,7 @@
 
 use ArrayAccess;
 use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\SoftDeletingScope;
 use InvalidArgumentException;
 
 trait SortableTrait
@@ -48,6 +49,32 @@ public function scopeOrdered(Builder $query, string $direction = 'asc')
         return $query->orderBy($this->determineOrderColumnName(), $direction);
     }
 
+    /**
+     * Query records which are ordered above the given position.
+     *
+     * @param \Illuminate\Database\Eloquent\Builder $query
+     * @param int $position
+     *
+     * @return \Illuminate\Database\Query\Builder
+     */
+    public function scopeAbove(Builder $query, int $position)
+    {
+        return $query->where($this->determineOrderColumnName(), '<', $position);
+    }
+
+    /**
+     * Query records which are ordered below the given position.
+     *
+     * @param \Illuminate\Database\Eloquent\Builder $query
+     * @param int $position
+     *
+     * @return \Illuminate\Database\Query\Builder
+     */
+    public function scopeBelow(Builder $query, int $position)
+    {
+        return $query->where($this->determineOrderColumnName(), '>', $position);
+    }
+
     /**
      * 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, ...
@@ -69,7 +96,9 @@ public static function setNewOrder($ids, int $startOrder = 1)
         $primaryKeyColumn = $model->getKeyName();
 
         foreach ($ids as $id) {
-            static::where($primaryKeyColumn, $id)->update([$orderColumnName => $startOrder++]);
+            static::withoutGlobalScope(SoftDeletingScope::class)
+                ->where($primaryKeyColumn, $id)
+                ->update([$orderColumnName => $startOrder++]);
         }
     }
 
@@ -107,7 +136,7 @@ public function moveOrderDown()
 
         $swapWithModel = static::limit(1)
             ->ordered()
-            ->where($orderColumnName, '>', $this->$orderColumnName)
+            ->below($this->$orderColumnName)
             ->first();
 
         if (! $swapWithModel) {
@@ -128,7 +157,7 @@ public function moveOrderUp()
 
         $swapWithModel = static::limit(1)
             ->ordered('desc')
-            ->where($orderColumnName, '<', $this->$orderColumnName)
+            ->above($this->$orderColumnName)
             ->first();
 
         if (! $swapWithModel) {
@@ -217,7 +246,7 @@ public function moveToEnd()
         $this->save();
 
         static::where($this->getKeyName(), '!=', $this->id)
-            ->where($orderColumnName, '>', $oldOrder)
+            ->below($oldOrder)
             ->decrement($orderColumnName);
 
         return $this;

tests/DummyWithSoftDeletes.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Spatie\EloquentSortable\Test;
+
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\SoftDeletes;
+use Spatie\EloquentSortable\Sortable;
+use Spatie\EloquentSortable\SortableTrait;
+
+class DummyWithSoftDeletes extends Model implements Sortable
+{
+    use SoftDeletes, SortableTrait;
+
+    protected $table = 'dummies';
+    protected $guarded = [];
+    public $timestamps = false;
+}

tests/SortableTest.php

@@ -20,6 +20,16 @@ public function it_can_get_the_highest_order_number()
         $this->assertEquals(Dummy::all()->count(), (new Dummy())->getHighestOrderNumber());
     }
 
+    /** @test */
+    public function it_can_get_the_highest_order_number_with_trashed_models()
+    {
+        $this->setUpSoftDeletes();
+
+        DummyWithSoftDeletes::first()->delete();
+
+        $this->assertEquals(DummyWithSoftDeletes::withTrashed()->count(), (new DummyWithSoftDeletes())->getHighestOrderNumber());
+    }
+
     /** @test */
     public function it_can_set_a_new_order()
     {
@@ -44,6 +54,40 @@ public function it_can_set_a_new_order_from_collection()
         }
     }
 
+    /** @test */
+    public function it_can_set_a_new_order_with_trashed_models()
+    {
+        $this->setUpSoftDeletes();
+
+        $dummies = DummyWithSoftDeletes::all();
+
+        $dummies->random()->delete();
+
+        $newOrder = Collection::make($dummies->pluck('id'))->shuffle();
+
+        DummyWithSoftDeletes::setNewOrder($newOrder);
+
+        foreach (DummyWithSoftDeletes::withTrashed()->orderBy('order_column')->get() as $i => $dummy) {
+            $this->assertEquals($newOrder[$i], $dummy->id);
+        }
+    }
+
+    /** @test */
+    public function it_can_set_a_new_order_without_trashed_models()
+    {
+        $this->setUpSoftDeletes();
+
+        DummyWithSoftDeletes::first()->delete();
+
+        $newOrder = Collection::make(DummyWithSoftDeletes::pluck('id'))->shuffle();
+
+        DummyWithSoftDeletes::setNewOrder($newOrder);
+
+        foreach (DummyWithSoftDeletes::orderBy('order_column')->get() as $i => $dummy) {
+            $this->assertEquals($newOrder[$i], $dummy->id);
+        }
+    }
+
     /** @test */
     public function it_will_determine_to_sort_when_creating_if_sortable_attribute_does_not_exist()
     {

tests/TestCase.php

@@ -51,4 +51,11 @@ protected function setUpDatabase()
             Dummy::create(['name' => $i]);
         });
     }
+
+    protected function setUpSoftDeletes()
+    {
+        $this->app['db']->connection()->getSchemaBuilder()->table('dummies', function (Blueprint $table) {
+            $table->softDeletes();
+        });
+    }
 }