feat(pilot): do not add 2 umpires to the same splace

* placeholder fixes

src/app/services/waiting-umpires.service.ts

@@ -1,6 +1,6 @@
 import { Injectable } from '@angular/core';
 import { toSignal } from '@angular/core/rxjs-interop';
-import { db } from 'db';
+import { db, Umpire } from 'db';
 import { liveQuery } from 'dexie';
 import { from } from 'rxjs';
 
@@ -21,8 +21,8 @@ export class WaitingUmpiresService {
   /**
    * Add new umpire to queue with max(order) + 1
    */
-  async add(umpireId: number): Promise<number> {
-    return db.transaction('rw', db.waitingUmpires, async () => {
+  async add(umpireId: number, toPosition?: number): Promise<number> {
+    const id = await db.transaction('rw', db.waitingUmpires, async () => {
       const last = await db.waitingUmpires.orderBy('order').last();
 
       const nextOrder = last ? last.order + 1 : 1;
@@ -32,6 +32,12 @@ export class WaitingUmpiresService {
         order: nextOrder
       });
     });
+
+    if (toPosition !== undefined) {
+      await this.moveToPosition(umpireId, toPosition);
+    }
+
+    return id;
   }
 
   /**
@@ -39,6 +45,8 @@ export class WaitingUmpiresService {
    */
   async remove(id: number): Promise<void> {
     await db.waitingUmpires.delete(id);
+
+    await this.reinitOrders();
   }
 
   async removeByUmpireId(umpireId: number): Promise<void> {
@@ -51,7 +59,7 @@ export class WaitingUmpiresService {
       return;
     }
 
-    await db.waitingUmpires.delete(item.id);
+    await this.remove(item.id);
   }
 
   /**
@@ -67,4 +75,81 @@ export class WaitingUmpiresService {
   async clear(): Promise<void> {
     await db.waitingUmpires.clear();
   }
+
+  async moveToPosition(umpireId: number, newOrder: number): Promise<void> {
+    await db.transaction('rw', db.waitingUmpires, async () => {
+      const current = await db.waitingUmpires
+        .where('umpireId')
+        .equals(umpireId)
+        .first();
+
+      if (!current) {
+        return;
+      }
+
+      const oldOrder = current.order;
+
+      if (oldOrder === newOrder) {
+        return;
+      }
+
+      if (newOrder < oldOrder) {
+        // Moving up: shift affected records down
+
+        const affected = await db.waitingUmpires
+          .filter(
+            (item) =>
+              item.order >= newOrder &&
+              item.order < oldOrder &&
+              item.id !== current.id
+          )
+          .toArray();
+
+        for (const item of affected) {
+          await db.waitingUmpires.update(item.id!, {
+            order: item.order + 1
+          });
+        }
+      } else {
+        // Moving down: shift affected records up
+
+        const affected = await db.waitingUmpires
+          .filter(
+            (item) =>
+              item.order > oldOrder &&
+              item.order <= newOrder &&
+              item.id !== current.id
+          )
+          .toArray();
+
+        for (const item of affected) {
+          await db.waitingUmpires.update(item.id!, {
+            order: item.order - 1
+          });
+        }
+      }
+
+      await db.waitingUmpires.update(current.id!, {
+        order: newOrder
+      });
+    });
+  }
+
+  async reinitOrders(): Promise<void> {
+    await db.transaction('rw', db.waitingUmpires, async () => {
+      const items = await db.waitingUmpires.orderBy('order').toArray();
+
+      for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+
+        const expectedOrder = i + 1;
+
+        if (item.order !== expectedOrder) {
+          await db.waitingUmpires.update(item.id!, {
+            order: expectedOrder
+          });
+        }
+      }
+    });
+  }
 }