Einzelne Gruppenmitglieder, Austritt per Redesign, Ladebalken beim Abgleich

Bei einem CC mit mehreren Nutzern gibt es zwei Ebenen, und bisher liess sich
nur die obere bedienen. Jetzt beide:

Ein Spieler kann seinen Anteil redesignen und steigt damit aus - er bekommt
einen eigenen CC, die Gruppe laeuft unberuehrt weiter. Fuer ihn ist es ein
Tausch wie jeder andere: der Gruppenplatz geht weg, der eigene CC kommt an
seine Stelle, es kommt keiner hinzu. Wohin er gewechselt ist, bleibt an der
Mitgliedschaft festgehalten und steht bei den frueheren Nutzern. Das Redesign
der ganzen Gruppe, bei dem alle mitwandern, gibt es unveraendert daneben.

Ebenso koennen einzelne Nutzer ausfallen, ohne die uebrigen zu beruehren: bei
einem Trio kann einer im Rollenspiel sterben, waehrend die anderen
weiterspielen, und ebenso koennen alle nacheinander wegfallen. Grund und
Begruendung haengen jetzt auch an der Mitgliedschaft. Die Rueckkehr folgt
denselben Regeln wie beim eigenen CC - geputzt gratis, entzogen gegen
Guthaben, gestorben nur durch einen Administrator mit Begruendung. Wer
ausgefallen ist, sieht seinen CC weiter auf der Spielerseite; sonst gaebe es
nichts, worueber er zurueckkehren koennte. Ein freiwilliger Austritt bleibt
davon getrennt: dort gibt es nichts zurueckzuholen, ein Wiedereintritt kostet
neu.

Der GExtension-Abgleich hat denselben Ladebalken wie der Forumslauf bekommen,
fuer alle Spieler wie fuer einzelne, samt Protokoll. Beide teilen sich jetzt
dieselbe Anzeige.

Dabei aufgefallen: Zeitplan und Handklick konnten denselben Abgleich doppelt
starten und haetten dieselben Profile zweimal abgerufen. Die Sperre sitzt
jetzt im Lauf selbst statt im Starter, damit sie fuer beide Wege gilt.

server/src/routes/characters.routes.ts

@@ -2,6 +2,8 @@ import type { FastifyInstance } from 'fastify';
 import { z } from 'zod';
 import { CreditKind, InactiveReason } from '@prisma/client';
 import { requireAdmin, requireAuth, requireEditor } from '../auth/guard.js';
+import { forbidden } from '../errors.js';
+import { prisma } from '../db.js';
 import {
   addMember,
   createCharacter,
@@ -14,6 +16,9 @@ import {
   redesignCharacter,
   revertCharacter,
   updateCharacter,
+  deactivateMember,
+  reactivateMember,
+  redesignMembership,
 } from '../services/characters.js';
 import { parseThreadId } from '../lib/forum.js';
 import { linkThreadToCharacter } from '../services/forum.js';
@@ -163,6 +168,109 @@ export async function characterRoutes(app: FastifyInstance): Promise<void> {
     );
   });
 
+  /**
+   * Der Anteil eines Spielers an einem Gruppen-CC wird redesignt: er steigt
+   * aus, bekommt einen eigenen CC, die Gruppe läuft weiter.
+   */
+  app.post(
+    '/api/characters/:id/members/:playerId/redesign',
+    { preHandler: requireEditor },
+    async (request) => {
+      const params = parseWith(
+        z.object({
+          id: z.coerce.number().int().positive(),
+          playerId: z.coerce.number().int().positive(),
+        }),
+        request.params,
+      );
+      const body = parseWith(
+        z.object({
+          name: z.string().trim().min(1).max(160),
+          loreText: z.string().trim().max(5000).optional(),
+          useKind: z.enum([CreditKind.REDESIGN_PAID, CreditKind.REDESIGN_KULANZ]),
+          note: optionalNote,
+        }),
+        request.body,
+      );
+      return redesignMembership(params.id, params.playerId, body, contextOf(request));
+    },
+  );
+
+  /** Ein einzelnes Mitglied fällt aus, der CC bleibt bestehen. */
+  app.post(
+    '/api/characters/:id/members/:playerId/deactivate',
+    { preHandler: requireEditor },
+    async (request) => {
+      const params = parseWith(
+        z.object({
+          id: z.coerce.number().int().positive(),
+          playerId: z.coerce.number().int().positive(),
+        }),
+        request.params,
+      );
+      const body = parseWith(
+        z.object({
+          reason: z.enum([
+            InactiveReason.PLAYER_INACTIVITY,
+            InactiveReason.OTHER,
+            InactiveReason.NO_FREE_CLAIM,
+            InactiveReason.DEAD,
+          ]),
+          note: optionalNote,
+        }),
+        request.body,
+      );
+
+      // Ein Tod im Rollenspiel ist eine Ausnahmeentscheidung, genau wie beim
+      // ganzen CC - und bleibt deshalb Administratoren vorbehalten.
+      if (body.reason === InactiveReason.DEAD && request.user?.role !== 'ADMIN') {
+        throw forbidden('Einen Tod im Rollenspiel trägt nur ein Administrator ein');
+      }
+
+      return deactivateMember(
+        params.id,
+        params.playerId,
+        body.reason,
+        contextOf(request),
+        body.note,
+      );
+    },
+  );
+
+  /** Rückkehr eines ausgefallenen Mitglieds. */
+  app.post(
+    '/api/characters/:id/members/:playerId/reactivate',
+    { preHandler: requireEditor },
+    async (request) => {
+      const params = parseWith(
+        z.object({
+          id: z.coerce.number().int().positive(),
+          playerId: z.coerce.number().int().positive(),
+        }),
+        request.params,
+      );
+      const body = parseWith(
+        z.object({
+          useKind: reviveKind.optional(),
+          reason: z.string().trim().max(500).optional(),
+        }),
+        request.body ?? {},
+      );
+
+      // Wer im Rollenspiel gestorben ist, kehrt nur durch einen Administrator
+      // zurück. Geprüft wird am tatsächlichen Grund, nicht an der Eingabe.
+      const mitglied = await prisma.characterMember.findUnique({
+        where: { characterId_playerId: { characterId: params.id, playerId: params.playerId } },
+        select: { inactiveReason: true },
+      });
+      if (mitglied?.inactiveReason === InactiveReason.DEAD && request.user?.role !== 'ADMIN') {
+        throw forbidden('Über die Rückkehr eines Gestorbenen entscheidet ein Administrator');
+      }
+
+      return reactivateMember(params.id, params.playerId, body, contextOf(request));
+    },
+  );
+
   app.delete('/api/characters/:id/members/:playerId', { preHandler: requireEditor }, async (request) => {
     const params = parseWith(
       z.object({

server/src/routes/scraper.routes.ts

@@ -4,7 +4,9 @@ import { requireAdmin, requireAuth, requireEditor } from '../auth/guard.js';
 import { notFound } from '../errors.js';
 import { prisma } from '../db.js';
 import {
+  getScrapeState,
   knownSteamIds,
+  startScrape,
   steamIdsOf,
   listUnmatched,
   resolveUnmatched,
@@ -30,7 +32,11 @@ export async function scraperRoutes(app: FastifyInstance): Promise<void> {
       ? all.filter((entry) => body.playerIds?.includes(entry.playerId))
       : all;
 
-    return scrapePlayers(targets, contextOf(request));
+    return startScrape(targets, contextOf(request));
+  });
+
+  app.get('/api/scrape/status', { preHandler: requireAuth }, async () => {
+    return getScrapeState();
   });
 
   /**
@@ -49,7 +55,7 @@ export async function scraperRoutes(app: FastifyInstance): Promise<void> {
       throw notFound('SteamID des Spielers');
     }
 
-    return scrapePlayers(
+    return startScrape(
       steamIds.map((steamId) => ({ playerId: id, steamId })),
       contextOf(request),
     );