Tote CCs zurueckholen, Redesign-Beitritte und Problemfaelle

Vier Punkte aus dem Betrieb.

Ein toter CC liess sich nicht zurueckholen. Der Knopf dafuer wurde nie
angezeigt: bei Grund "Im RP gestorben" landete die Seite im Zweig "Bezahlt
reaktivieren", den der Server zu Recht abweist - ein Toter kehrt nur durch
einen Administrator zurueck. Der Dialog dafuer war fertig gebaut und wurde
schlicht nie geoeffnet. Jetzt steht an einem toten CC "Zurueckholen", fuer
Editoren stattdessen der Hinweis, dass das ein Administrator entscheidet.

Der Abgleich eines einzelnen Spielers fragte nur dessen hinterlegte SteamID
ab. Guthaben, das unter einem frueheren Konto gekauft wurde, blieb damit
unsichtbar - obwohl das Konto hinterlegt war und der Sammellauf es beruecksichtigt
hat. Jetzt werden alle Kennungen des Spielers abgefragt.

Ein Beitritt zu einem Gruppen-CC ueber ein Redesign kostete nur das Guthaben.
Damit entstand aus einem Redesign ein zusaetzlicher CC, was die Regel gerade
nicht hergibt: ein Redesign ersetzt einen CC. Jetzt muss angegeben werden,
welcher eigene CC dafuer aufgegeben wird; ein aktiver wird dabei inaktiv
gesetzt, ein bereits inaktiver bleibt unveraendert. Ueber ein CC-Paket kommt
weiterhin ein Platz hinzu, ohne Vorgaenger. Welcher CC aufgegeben wurde, haengt
am Beitritt und bleibt nachvollziehbar.

Faelle, die sich beim Eintragen nicht klaeren lassen - ein Antrag ohne
auffindbares Paket, ein fehlender GExtension-Eintrag, widerspruechliche Angaben
- koennen als Spieler angelegt und dabei als Problem vorgemerkt werden, mit
Notiz. Auch nachtraeglich setzbar und wieder abraeumbar. Die Markierung ist
folgenlos: sie sperrt nichts und veraendert weder Guthaben noch CCs. Die
Uebersicht kennzeichnet betroffene Spieler und laesst sich darauf eingrenzen.

Nebenbei: die Spielerliste gab die Markierung nicht mit aus, aufgefallen beim
Test.

server/test/gruppen.test.ts

@@ -69,22 +69,113 @@ describe('Gruppen-CCs', () => {
     assert.equal(gruenderStand.CC, 0, 'nur sein eigener CC, nichts zusätzlich');
   });
 
-  it('lässt den Beitritt auch über ein Redesign zu', async () => {
+  it('lässt den Beitritt auch über ein Redesign zu, kostet dann aber den eigenen CC', async () => {
     const gruender = await spielerMitPaket('Chef');
     const zweiter = await spielerMitPaket('Nachzügler');
     const { character } = await characters.createCharacter(gruender, { name: 'Redesign-Bande' }, ctx);
 
     // Sein CC-Guthaben hat er schon anderweitig gebraucht, das Redesign nicht.
-    await characters.createCharacter(zweiter, { name: 'Eigener CC' }, ctx);
+    const eigener = await characters.createCharacter(zweiter, { name: 'Eigener CC' }, ctx);
     const result = await characters.addMember(
       character.id,
       zweiter,
-      { useKind: 'REDESIGN_PAID' },
+      { useKind: 'REDESIGN_PAID', predecessorId: eigener.character.id },
       ctx,
     );
 
     assert.equal(result.balances.REDESIGN_PAID, 0, 'das Redesign ist verbraucht');
     assert.equal(result.memberCount, 2);
+
+    // Ein Redesign ersetzt einen CC, es kommt keiner dazu.
+    const aufgegeben = await db.prisma.character.findUniqueOrThrow({
+      where: { id: eigener.character.id },
+    });
+    assert.equal(aufgegeben.status, 'INACTIVE');
+    assert.equal(aufgegeben.inactiveReason, 'REWORKED');
+
+    const eigene = await characters.listCharacters(zweiter);
+    assert.deepEqual(
+      eigene.filter((c) => c.status === 'ACTIVE').map((c) => c.name),
+      ['Redesign-Bande'],
+      'der alte CC ist weg, der Gruppen-CC an seiner Stelle',
+    );
+
+    const beitritt = await db.prisma.characterMember.findFirstOrThrow({
+      where: { characterId: character.id, playerId: zweiter },
+    });
+    assert.equal(beitritt.predecessorId, eigener.character.id, 'die Kette bleibt nachvollziehbar');
+  });
+
+  it('verlangt für einen Beitritt über ein Redesign einen eigenen CC', async () => {
+    const gruender = await spielerMitPaket('Chefin');
+    const zweiter = await spielerMitPaket('Ohne CC');
+    const { character } = await characters.createCharacter(gruender, { name: 'Geschlossene Runde' }, ctx);
+
+    await assert.rejects(
+      () => characters.addMember(character.id, zweiter, { useKind: 'REDESIGN_PAID' }, ctx),
+      (error: Error & { code?: string }) => error.code === 'NEED_PREDECESSOR',
+      'ohne Vorgänger gäbe es nichts zu ersetzen',
+    );
+  });
+
+  it('nimmt als Vorgänger auch einen längst inaktiven CC an', async () => {
+    const gruender = await spielerMitPaket('Anführer');
+    const zweiter = await spielerMitPaket('Rückkehrer');
+    const { character } = await characters.createCharacter(gruender, { name: 'Zweite Chance' }, ctx);
+
+    const alt = await characters.createCharacter(zweiter, { name: 'Alter CC' }, ctx);
+    await characters.deactivateCharacter(alt.character.id, 'PLAYER_INACTIVITY', ctx);
+
+    const result = await characters.addMember(
+      character.id,
+      zweiter,
+      { useKind: 'REDESIGN_PAID', predecessorId: alt.character.id },
+      ctx,
+    );
+    assert.equal(result.memberCount, 2);
+
+    // Was schon inaktiv war, wird nicht ein zweites Mal aufgegeben.
+    const unveraendert = await db.prisma.character.findUniqueOrThrow({
+      where: { id: alt.character.id },
+    });
+    assert.equal(unveraendert.inactiveReason, 'PLAYER_INACTIVITY');
+  });
+
+  it('lässt niemanden einen fremden CC aufgeben', async () => {
+    const gruender = await spielerMitPaket('Wirt');
+    const fremder = await spielerMitPaket('Fremder');
+    const { character } = await characters.createCharacter(gruender, { name: 'Stammtisch' }, ctx);
+    const fremdesCC = await characters.createCharacter(gruender, { name: 'Nicht deiner' }, ctx);
+
+    await assert.rejects(
+      () =>
+        characters.addMember(
+          character.id,
+          fremder,
+          { useKind: 'REDESIGN_PAID', predecessorId: fremdesCC.character.id },
+          ctx,
+        ),
+      (error: Error & { code?: string }) => error.code === 'NOT_OWN_CHARACTER',
+    );
+  });
+
+  it('verlangt für einen Platz aus dem CC-Guthaben keinen Vorgänger', async () => {
+    const gruender = await spielerMitPaket('Gastgeber');
+    const zweiter = await spielerMitPaket('Gast');
+    const { character } = await characters.createCharacter(gruender, { name: 'Offene Tür' }, ctx);
+    const eigener = await characters.createCharacter(zweiter, { name: 'Bleibt bestehen' }, ctx);
+
+    await assert.rejects(
+      () =>
+        characters.addMember(
+          character.id,
+          zweiter,
+          { useKind: 'CC', predecessorId: eigener.character.id },
+          ctx,
+        ),
+      (error: Error & { code?: string }) => error.code === 'NO_PREDECESSOR_NEEDED',
+      'ein CC-Paket kauft einen Platz, es ersetzt nichts',
+    );
   });
 
   it('nimmt denselben Spieler nicht zweimal auf', async () => {