feat(umpires): move umpires between 3 lists by drag-and-drop

src/app/services/settings-service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { SettingsService } from './settings-service';
+
+describe('SettingsService', () => {
+  let service: SettingsService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(SettingsService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

src/app/services/settings-service.ts

@@ -0,0 +1,46 @@
+import { Injectable } from '@angular/core';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { db, Settings } from 'db';
+import { liveQuery } from 'dexie';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class SettingsService {
+  constructor() {
+    void this.ensureSettings();
+  }
+
+  /**
+   * Reactive settings signal
+   */
+  readonly settings = toSignal<Settings | undefined>(
+    liveQuery(() => db.settings.get(1)),
+    { initialValue: undefined }
+  );
+
+  /**
+   * Update settings
+   */
+  async update(changes: Partial<Omit<Settings, 'id'>>): Promise<void> {
+    const current = await db.settings.get(1);
+
+    if (!current) {
+      return;
+    }
+
+    await db.settings.update(1, changes);
+  }
+
+  private async ensureSettings() {
+    const existing = await db.settings.get(1);
+
+    if (!existing) {
+      await db.settings.put({
+        id: 1,
+        numberOfCourts: 5,
+        withServiceJudge: true
+      });
+    }
+  }
+}

src/app/services/waiting-service-judges.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { WaitingServiceJudgesService } from './waiting-service-judges.service';
+
+describe('WaitingServiceJudgesService', () => {
+  let service: WaitingServiceJudgesService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(WaitingServiceJudgesService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

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

@@ -0,0 +1,70 @@
+import { Injectable } from '@angular/core';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { db } from 'db';
+import { liveQuery } from 'dexie';
+import { from } from 'rxjs';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class WaitingServiceJudgesService {
+  /**
+   * Reactive list sorted by order
+   */
+  readonly waitingServiceJudges = toSignal(
+    from(liveQuery(() => db.waitingServiceJudges.orderBy('order').toArray())),
+    {
+      initialValue: []
+    }
+  );
+
+  /**
+   * Add new umpire to queue with max(order) + 1
+   */
+  async add(serviceJudgeId: number): Promise<number> {
+    return db.transaction('rw', db.waitingServiceJudges, async () => {
+      const last = await db.waitingServiceJudges.orderBy('order').last();
+
+      const nextOrder = last ? last.order + 1 : 1;
+
+      return db.waitingServiceJudges.add({
+        serviceJudgeId,
+        order: nextOrder
+      });
+    });
+  }
+
+  /**
+   * Remove from queue
+   */
+  async remove(id: number): Promise<void> {
+    await db.waitingServiceJudges.delete(id);
+  }
+
+  async removeByUmpireId(umpireId: number): Promise<void> {
+    const item = await db.waitingServiceJudges
+      .where('serviceJudgeId')
+      .equals(umpireId)
+      .first();
+
+    if (!item?.id) {
+      return;
+    }
+
+    await db.waitingServiceJudges.delete(item.id);
+  }
+
+  /**
+   * Reorder (optional helper)
+   */
+  async updateOrder(id: number, order: number): Promise<void> {
+    await db.waitingServiceJudges.update(id, { order });
+  }
+
+  /**
+   * Clear queue
+   */
+  async clear(): Promise<void> {
+    await db.waitingServiceJudges.clear();
+  }
+}

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

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { WaitingUmpiresService } from './waiting-umpires.service';
+
+describe('WaitingUmpiresService', () => {
+  let service: WaitingUmpiresService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(WaitingUmpiresService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

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

@@ -0,0 +1,70 @@
+import { Injectable } from '@angular/core';
+import { toSignal } from '@angular/core/rxjs-interop';
+import { db } from 'db';
+import { liveQuery } from 'dexie';
+import { from } from 'rxjs';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class WaitingUmpiresService {
+  /**
+   * Reactive list sorted by order
+   */
+  readonly waitingUmpires = toSignal(
+    from(liveQuery(() => db.waitingUmpires.orderBy('order').toArray())),
+    {
+      initialValue: []
+    }
+  );
+
+  /**
+   * Add new umpire to queue with max(order) + 1
+   */
+  async add(umpireId: number): Promise<number> {
+    return db.transaction('rw', db.waitingUmpires, async () => {
+      const last = await db.waitingUmpires.orderBy('order').last();
+
+      const nextOrder = last ? last.order + 1 : 1;
+
+      return db.waitingUmpires.add({
+        umpireId,
+        order: nextOrder
+      });
+    });
+  }
+
+  /**
+   * Remove from queue
+   */
+  async remove(id: number): Promise<void> {
+    await db.waitingUmpires.delete(id);
+  }
+
+  async removeByUmpireId(umpireId: number): Promise<void> {
+    const item = await db.waitingUmpires
+      .where('umpireId')
+      .equals(umpireId)
+      .first();
+
+    if (!item?.id) {
+      return;
+    }
+
+    await db.waitingUmpires.delete(item.id);
+  }
+
+  /**
+   * Reorder (optional helper)
+   */
+  async updateOrder(id: number, order: number): Promise<void> {
+    await db.waitingUmpires.update(id, { order });
+  }
+
+  /**
+   * Clear queue
+   */
+  async clear(): Promise<void> {
+    await db.waitingUmpires.clear();
+  }
+}