Slots durchsetzen, Abgleiche nach Zeitplan, Kaufdatum im Kontobuch

Ein CC-Paket ist ein Platz fuer einen gleichzeitig aktiven CC - ein Redesign
tauscht einen CC aus, statt einen Platz hinzuzufuegen. Beim Gruppen-Beitritt
galt das seit dem letzten Stand, an anderer Stelle aber noch nicht: ein
redesignter CC liess sich mit einem Redesign-Guthaben zurueckholen, waehrend
sein Nachfolger aktiv blieb. Zwei aktive CCs auf ein einziges Paket.

Geprueft wird das jetzt an einer Stelle statt an jedem Weg einzeln, fuer
Erschaffen, Redesign, Reaktivierung, Rueckkehr und Beitritt. Der Massstab ist
die Deckung, nicht der Kontostand: jeder aktive CC braucht eine eigene Buchung
im CC-Topf. Ein bewusst ueberzogenes Konto bleibt damit moeglich - die Buchung
ist da, nur das Guthaben fehlt, und das Minus steht sichtbar auf der
Spielerseite.

Beide Abgleiche laufen jetzt von allein: die Kaeufe alle zwei Stunden, bei
Spielern ohne Kauf in den letzten drei Jahren alle sechs, das Forum einmal
nachts. Das spart den Grossteil der Anfragen, denn ruhende Konten sind mit der
Zeit die Mehrheit. Gebucht wird dabei nichts - neue Pakete landen in der
Vorschau, neue Antraege in der Liste. Der Stand steht in der Datenbank, damit
ein Neustart nicht alles erneut anstoesst. Unter Verwaltung steht, wann
zuletzt gelaufen wurde; auf der Uebersicht, wie viele Pakete auf eine Buchung
warten und bei wem.

Ausserdem:

- Die Guthaben-Historie zeigt bei Importen den Kauf im Shop, nicht den
  Zeitpunkt der Eingabe hier. Bereits gebuchte Importe werden nachgetragen.
- Forums-Antraege tragen ihr Datum, im Forum ausgelesen statt geraten.
- Die Hinweisbox ueber den Antraegen beim Spieler faellt weg.
- Die Aktionsspalte der Nutzerverwaltung war per display:flex aus dem
  Tabellenlayout gefallen, daher die versetzte Trennlinie.
- Die Zeitzone steht jetzt im Compose-Stack, sonst laege "nachts um vier"
  nach UTC und im Sommer zwei Stunden daneben.

server/test/gruppen.test.ts

@@ -347,3 +347,96 @@ describe('Tote und entzogene CCs', () => {
     assert.equal(result.character.status, 'ACTIVE');
   });
 });
+
+describe('Slots: ein CC-Paket, ein gleichzeitig aktiver CC', () => {
+  it('lässt einen redesignten CC nicht neben seinem Nachfolger zurückkehren', async () => {
+    const spieler = await spielerMitPaket('Schlaufuchs');
+    const a = await characters.createCharacter(spieler, { name: 'CC A' }, ctx);
+    await characters.redesignCharacter(
+      a.character.id,
+      { name: 'CC B', useKind: 'REDESIGN_PAID' },
+      ctx,
+    );
+
+    // Ein weiteres Redesign-Paket kauft keinen Platz, nur einen Tausch.
+    await credits.bookRedesignPackage(spieler, ctx);
+
+    await assert.rejects(
+      () => characters.reactivatePaid(a.character.id, 'REDESIGN_PAID', ctx),
+      (error: Error & { code?: string }) => error.code === 'NO_FREE_SLOT',
+      'sonst stünden zwei aktive CCs auf einem einzigen Paket',
+    );
+
+    const aktive = (await characters.listCharacters(spieler)).filter((c) => c.status === 'ACTIVE');
+    assert.equal(aktive.length, 1);
+  });
+
+  it('lässt ihn zurückkehren, sobald der Nachfolger weg ist', async () => {
+    const spieler = await spielerMitPaket('Geduldig');
+    const a = await characters.createCharacter(spieler, { name: 'Erster' }, ctx);
+    const b = await characters.redesignCharacter(
+      a.character.id,
+      { name: 'Zweiter', useKind: 'REDESIGN_PAID' },
+      ctx,
+    );
+    await credits.bookRedesignPackage(spieler, ctx);
+
+    await characters.deactivateCharacter(b.character.id, 'OTHER', ctx, 'Platz gemacht');
+
+    const zurueck = await characters.reactivatePaid(a.character.id, 'REDESIGN_PAID', ctx);
+    assert.equal(zurueck.character.status, 'ACTIVE');
+  });
+
+  it('lässt ihn mit einem zweiten CC-Paket auch neben dem Nachfolger zurückkehren', async () => {
+    const spieler = await spielerMitPaket('Grossverdiener');
+    const a = await characters.createCharacter(spieler, { name: 'Alpha' }, ctx);
+    await characters.redesignCharacter(
+      a.character.id,
+      { name: 'Beta', useKind: 'REDESIGN_PAID' },
+      ctx,
+    );
+
+    // Das zweite Paket ist ein zweiter Platz - damit dürfen beide laufen.
+    await credits.bookCcPackage(spieler, ctx);
+    const zurueck = await characters.reactivatePaid(a.character.id, 'CC', ctx);
+
+    assert.equal(zurueck.character.status, 'ACTIVE');
+    const aktive = (await characters.listCharacters(spieler)).filter((c) => c.status === 'ACTIVE');
+    assert.equal(aktive.length, 2, 'zwei Pakete, zwei Plätze');
+  });
+
+  it('lässt ein überzogenes Konto weiterhin zu', async () => {
+    // Ein CC vor dem Paket einzutragen bleibt möglich; das Minus steht
+    // sichtbar da. Gebucht ist der Platz trotzdem - das ist der Unterschied
+    // zu einem CC, der ohne jede Buchung aktiv wird.
+    const spieler = (await db.prisma.player.create({ data: { displayName: 'Vorab' } })).id;
+    const ergebnis = await characters.createCharacter(spieler, { name: 'Vorab-CC' }, ctx);
+
+    assert.equal(ergebnis.balances.CC, -1);
+    assert.equal(ergebnis.overdrawn, true);
+    assert.equal(ergebnis.character.status, 'ACTIVE');
+  });
+
+  it('hält die Regel auch bei einem Gruppen-CC ein', async () => {
+    const gruender = await spielerMitPaket('Wirtin');
+    const gast = await spielerMitPaket('Gast mit Plan');
+    const { character } = await characters.createCharacter(gruender, { name: 'Die Runde' }, ctx);
+
+    // Der Gast hat einen eigenen CC und gibt ihn für den Platz auf.
+    const eigener = await characters.createCharacter(gast, { name: 'Eigener' }, ctx);
+    await credits.bookRedesignPackage(gast, ctx);
+    await characters.addMember(
+      character.id,
+      gast,
+      { useKind: 'REDESIGN_PAID', predecessorId: eigener.character.id },
+      ctx,
+    );
+
+    const aktive = (await characters.listCharacters(gast)).filter((c) => c.status === 'ACTIVE');
+    assert.deepEqual(
+      aktive.map((c) => c.name),
+      ['Die Runde'],
+      'ein Platz, ein aktiver CC - der eigene ist dafür weg',
+    );
+  });
+});