Nacherfassung an alten Kettengliedern, Filter fuer die Spielerliste

Beim Durcharbeiten von Spieler A stellt sich heraus, dass er schon vor drei
Redesigns bei einem Gruppen-CC von Spieler B dabei war. Das ging bisher nicht:
"Einem inaktiven CC kann niemand beitreten" - richtig fuer den laufenden
Betrieb, falsch fuers Nacherfassen. Dort geht es nicht um jetzt, sondern um
eine Geschichte, die laengst gelaufen ist.

An einem stillgelegten CC wird deshalb nachgetragen statt beigetreten: mit
Zeitraum, und die Guthaben-Angabe ist freigestellt, weil die Buchung im Konto
stehen kann. Wer weiter unten in derselben Kette schon steht, kommt auch an
einem laufenden CC ohne neue Buchung dazu - sein Platz wurde einmal bezahlt,
und ein Redesign tauscht ihn aus. Fuer alle anderen bleibt die Angabe Pflicht.
Damit vier Kettenglieder nicht vier Klicks bedeuten, traegt ein Aufruf einen
Spieler ab einem Glied in die ganze weitere Kette ein; gebucht wird einmal.

Ein Test spielt den ganzen Fall durch: B fertig, A nachgetragen, C steigt in
der Mitte ein und wieder aus, D kommt erst am Ende dazu - und am Schluss sieht
jeder seine eigene Geschichte.

Leere Import-Vorschauen blieben in der Liste stehen, sobald alle Zeilen beim
Spieler gebucht waren. Bestaetigen liess sich so eine Huelle nicht ("nichts zu
buchen"), sie war nur im Weg. Jetzt gilt sie als erledigt - sie ist es ja.
Auch der Bestand wird beim naechsten Aufruf der Liste abgeraeumt.

Und die Spielerliste laesst sich eingrenzen: nur mit aktivem CC, nur mit
ausschliesslich stillgelegten, nur Beteiligte eines Gruppen-CCs, nur ohne
jeden CC, nur Problemfaelle. Sortiert wird nach Namen, nach der Zahl der
CC-Eintraege oder nach Anlage.

server/test/imports.test.ts

@@ -357,6 +357,56 @@ describe('Einzelne Zeilen beim Spieler buchen', () => {
     await imports.discardImport(zweiterImport, ctx);
   });
 
+  it('lässt keine leere Vorschau in der Liste zurück', async () => {
+    // Genau der Fall aus dem Betrieb: alle Zeilen beim Spieler gebucht, die
+    // Vorschau bleibt als leere Hülle stehen und lässt sich nicht bestätigen.
+    const importId = await vorschau('LEER');
+
+    const offen = [
+      ...(await imports.listPendingRowsFor(eule)),
+      ...(await imports.listPendingRowsFor(specht)),
+    ].filter((row) => row.importId === importId);
+    assert.equal(offen.length, 3, 'alle drei Zeilen dieses Imports');
+
+    await imports.bookRows(offen.map((row) => row.id), ctx);
+
+    const danach = await db.prisma.import.findUniqueOrThrow({ where: { id: importId } });
+    assert.equal(danach.status, 'COMMITTED', 'nichts mehr zu tun heisst erledigt');
+
+    const liste = await imports.listImports();
+    assert.equal(
+      liste.some((i) => i.id === importId && i.status === 'PENDING'),
+      false,
+      'und damit aus der Liste offener Importe verschwunden',
+    );
+  });
+
+  it('räumt auch Vorschauen ab, die schon leer herumlagen', async () => {
+    const importId = await vorschau('ALTLAST');
+    const offen = [
+      ...(await imports.listPendingRowsFor(eule)),
+      ...(await imports.listPendingRowsFor(specht)),
+    ].filter((row) => row.importId === importId);
+
+    // Von Hand leergeräumt, ohne den Import anzufassen - so sieht der
+    // Bestand aus, der vor dieser Korrektur entstanden ist.
+    await db.prisma.importRow.updateMany({
+      where: { id: { in: offen.map((row) => row.id) } },
+      data: { plan: 'SKIP_DUPLICATE' },
+    });
+    assert.equal(
+      (await db.prisma.import.findUniqueOrThrow({ where: { id: importId } })).status,
+      'PENDING',
+    );
+
+    await imports.listImports();
+
+    assert.equal(
+      (await db.prisma.import.findUniqueOrThrow({ where: { id: importId } })).status,
+      'COMMITTED',
+    );
+  });
+
   it('weist eine leere Auswahl ab', async () => {
     await assert.rejects(
       () => imports.bookRows([], ctx),