Antraege durchsuchbar, Fortschritt sichtbar, Spieler an einem Stueck

Der Abgleich zeigt jetzt, was er tut. Gelesen wird zuerst von jedem Board die erste Seite - danach steht der Umfang fest, und der Balken zeigt einen ehrlichen Anteil statt einer Schaetzung. Ein Protokoll schreibt Seite fuer Seite mit. Beide Antragslisten lassen sich durchsuchen und wahlweise mit dem neuesten oder dem aeltesten Antrag zuerst anzeigen. Die Liste ohne zugeordneten Spieler blaettert seitenweise, statt bei fuenfhundert Eintraegen die ersten fuenfzig zu zeigen und den Rest zu verschweigen. Neu darueber: "Ersteller ohne Spieler" - dieselben Antraege, nach Ersteller zusammengefasst. Wer dreiundzwanzig Antraege gestellt hat, faellt dort auf, waehrend er zwischen fuenfhundert Einzelantraegen untergeht. Ein Klick legt den Spieler mit bereits eingetragenem Forum-Namen an. Ein Spieler laesst sich jetzt an einem Stueck abarbeiten, statt zwischen drei Seiten zu wechseln: - Seine Forums-Antraege stehen auf der Spielerseite, aeltester zuerst, jeder als Link ins Forum. Offene sind dort direkt entscheidbar, ueber denselben Weg wie auf der Antraege-Seite - danach stehen sie dort nicht mehr offen. - Pakete, die noch in einer Import-Vorschau liegen, erscheinen unter "Offene Pakete aus dem Abgleich" und lassen sich einzeln oder am Stueck buchen. Gebuchtes wird ueberall abgehakt, wo dieselbe Bestellung noch offen liegt, auch in einem zweiten Import - doppelt buchen ist ausgeschlossen. Wer ein Paket gar nicht buchen will, legt es weg, ohne das Konto zu beruehren. Die beiden Antrags-Dialoge liegen dafuer jetzt unter components/, weil beide Seiten sie brauchen.
2026-09-21 00:49:38 +02:00
parent e65fdfc0ad
commit 293d882cb4
16 changed files with 1655 additions and 431 deletions
@@ -14,6 +14,13 @@ export const BOARDS: { board: ForumBoard; path: string }[] = [
  { board: ForumBoard.CC_ARCHIV, path: 'board/113-cc-archiv' },
 ];

+/// Die Board-Pfade in lesbarer Form, für das Protokoll des Laufs.
+const BOARD_NAMES: Record<string, string> = {
+  'board/66-custom-characters': 'Antragsübersicht',
+  'board/355-aktive-ccs': 'Aktive CCs',
+  'board/113-cc-archiv': 'Archiv',
+};
+
 const MIN_REQUEST_GAP_MS = 1200;
 /// Bremst das Forum, wird der Abstand verdoppelt, bis hierhin.
 const MAX_REQUEST_GAP_MS = 10000;
@@ -118,6 +125,10 @@ export interface ScanState {
  /// Woran gerade gelesen wird, für die Anzeige während des Laufs.
  currentBoard: string | null;
  pagesRead: number;
+  /// Steht fest, sobald von jedem Board die erste Seite gelesen ist. Vorher 0.
+  totalPages: number;
+  /// Was der Lauf bisher getan hat, jüngster Eintrag zuletzt.
+  log: string[];
  summary: ForumScanSummary | null;
  error: string | null;
 }
@@ -136,10 +147,20 @@ const scanState: ScanState = {
  finishedAt: null,
  currentBoard: null,
  pagesRead: 0,
+  totalPages: 0,
+  log: [],
  summary: null,
  error: null,
 };

+/// Damit ein langer Lauf den Speicher nicht vollschreibt.
+const MAX_LOG_LINES = 200;
+
+function protokoll(zeile: string): void {
+  scanState.log.push(zeile);
+  if (scanState.log.length > MAX_LOG_LINES) scanState.log.shift();
+}
+
 export function getScanState(): ScanState {
  return { ...scanState };
 }
@@ -155,6 +176,8 @@ export function startScan(ctx: ActionContext): ScanState {
  scanState.finishedAt = null;
  scanState.currentBoard = null;
  scanState.pagesRead = 0;
+  scanState.totalPages = 0;
+  scanState.log = [];
  scanState.summary = null;
  scanState.error = null;

@@ -206,40 +229,62 @@ export async function scanForum(ctx: ActionContext): Promise<ForumScanSummary> {
  // dauern als der Abruf selbst und den Aufruf ins Zeitlimit treiben.
  const gefunden = new Map<number, { thread: ForumThread; board: ForumBoard }>();

+  // Erst von jedem Board die erste Seite. Danach steht der Umfang des Laufs
+  // fest, und die Anzeige kann einen ehrlichen Fortschritt zeigen statt zu
+  // raten, wie viel noch kommt.
+  const offen: { board: ForumBoard; path: string; seiten: number; gelesen: number }[] = [];
+
  for (const { board, path } of BOARDS) {
-    let gelesen = 0;
    scanState.currentBoard = path;
+    protokoll(`${BOARD_NAMES[path] ?? path}: Umfang wird ermittelt`);

    try {
      const first = await fetchPage(path, 1);
-      gelesen += 1;
      summary.scannedPages += 1;
      scanState.pagesRead = summary.scannedPages;
-
-      const seiten = Math.min(parsePageCount(first), MAX_PAGES_PER_BOARD);
      for (const thread of parseBoard(first)) gefunden.set(thread.threadId, { thread, board });

-      for (let page = 2; page <= seiten; page += 1) {
-        const html = await fetchPage(path, page);
-        gelesen += 1;
+      const seiten = Math.min(parsePageCount(first), MAX_PAGES_PER_BOARD);
+      scanState.totalPages += seiten;
+      offen.push({ board, path, seiten, gelesen: 1 });
+      protokoll(`${BOARD_NAMES[path] ?? path}: Seite 1 von ${seiten} gelesen`);
+    } catch (error) {
+      const grund = error instanceof Error ? error.message : 'Unbekannter Fehler';
+      summary.failedBoards.push({ board: path, reason: grund, pagesRead: 0 });
+      protokoll(`${BOARD_NAMES[path] ?? path}: nicht erreichbar (${grund})`);
+    }
+  }
+
+  for (const eintrag of offen) {
+    const name = BOARD_NAMES[eintrag.path] ?? eintrag.path;
+    scanState.currentBoard = eintrag.path;
+
+    try {
+      for (let page = 2; page <= eintrag.seiten; page += 1) {
+        const html = await fetchPage(eintrag.path, page);
+        eintrag.gelesen += 1;
        summary.scannedPages += 1;
        scanState.pagesRead = summary.scannedPages;
-        for (const thread of parseBoard(html)) gefunden.set(thread.threadId, { thread, board });
+        for (const thread of parseBoard(html)) {
+          gefunden.set(thread.threadId, { thread, board: eintrag.board });
+        }
+        protokoll(`${name}: Seite ${page} von ${eintrag.seiten} gelesen`);
      }
      summary.scannedBoards += 1;
+      protokoll(`${name}: fertig`);
    } catch (error) {
      // Was bis hierher gelesen wurde, bleibt erhalten und wird gleich
      // verarbeitet - ein Abbruch auf Seite 17 darf nicht die ersten 16
      // Seiten mit in den Papierkorb nehmen.
-      summary.failedBoards.push({
-        board: path,
-        reason: error instanceof Error ? error.message : 'Unbekannter Fehler',
-        pagesRead: gelesen,
-      });
+      const grund = error instanceof Error ? error.message : 'Unbekannter Fehler';
+      summary.failedBoards.push({ board: eintrag.path, reason: grund, pagesRead: eintrag.gelesen });
+      protokoll(`${name}: abgebrochen nach Seite ${eintrag.gelesen} (${grund})`);
    }
  }

  summary.rateLimited = rateLimitHits;
+  scanState.currentBoard = null;
+  protokoll(`${gefunden.size} Threads gelesen, wird gespeichert`);

  const relevant: { thread: ForumThread; board: ForumBoard }[] = [];
  for (const eintrag of gefunden.values()) {
@@ -353,6 +398,12 @@ export async function scanForum(ctx: ActionContext): Promise<ForumScanSummary> {
    });
  }

+  protokoll(
+    summary.newThreads > 0
+      ? `${summary.newThreads} neue Anträge erfasst`
+      : 'Keine neuen Anträge',
+  );
+
  await recordAudit(prisma, ctx, {
    action: 'forum.scan',
    targetType: 'forum',
@@ -388,10 +439,33 @@ async function forumNameIndex(): Promise<Map<string, number>> {
  return index;
 }

+/// Neueste oder älteste zuerst. Massgeblich ist die Thread-ID: sie waechst
+/// mit der Zeit und bleibt stabil, waehrend der Zeitpunkt des letzten Abrufs
+/// nach einem Lauf bei allen Threads derselbe ist.
+export type ThreadOrder = 'newest' | 'oldest';
+
+function orderOf(order: ThreadOrder | undefined): Prisma.ForumThreadOrderByWithRelationInput {
+  return { threadId: order === 'oldest' ? 'asc' : 'desc' };
+}
+
+/** Freitextsuche über Titel und Ersteller. */
+function sucheNach(query: string | undefined): Prisma.ForumThreadWhereInput {
+  const suche = query?.trim();
+  if (!suche) return {};
+  return {
+    OR: [
+      { title: { contains: suche, mode: 'insensitive' } },
+      { authorName: { contains: suche, mode: 'insensitive' } },
+    ],
+  };
+}
+
 export async function listThreads(options: {
  onlyOpen?: boolean;
  playerId?: number;
  board?: ForumBoard;
+  query?: string;
+  order?: ThreadOrder;
 }) {
  return prisma.forumThread.findMany({
    where: {
@@ -401,8 +475,9 @@ export async function listThreads(options: {
      ...(options.onlyOpen ? { needsClassification: true, playerId: { not: null } } : {}),
      ...(options.playerId !== undefined ? { playerId: options.playerId } : {}),
      ...(options.board ? { currentBoard: options.board } : {}),
+      ...sucheNach(options.query),
    },
-    orderBy: [{ lastSeenAt: 'desc' }, { threadId: 'desc' }],
+    orderBy: orderOf(options.order),
    include: {
      player: { select: { id: true, displayName: true } },
      linkedCharacter: { select: { id: true, name: true } },
@@ -413,30 +488,29 @@ export async function listThreads(options: {
 /**
 * Threads, zu denen kein Spieler gefunden wurde. Das Archiv reicht Jahre
 * zurück und enthält hunderte Anträge von Leuten, die hier nie erfasst
- * wurden - deshalb durchsuchbar und begrenzt statt als eine lange Liste.
+ * wurden - deshalb durchsuchbar und seitenweise statt als eine lange Liste.
 */
-export async function listUnassignedThreads(options: { query?: string; take?: number }) {
+export async function listUnassignedThreads(options: {
+  query?: string;
+  take?: number;
+  skip?: number;
+  order?: ThreadOrder;
+}) {
  const take = Math.min(Math.max(options.take ?? 50, 1), 200);
-  const suche = options.query?.trim();
+  const skip = Math.max(options.skip ?? 0, 0);

  const where: Prisma.ForumThreadWhereInput = {
    playerId: null,
    needsClassification: true,
-    ...(suche
-      ? {
-          OR: [
-            { title: { contains: suche, mode: 'insensitive' } },
-            { authorName: { contains: suche, mode: 'insensitive' } },
-          ],
-        }
-      : {}),
+    ...sucheNach(options.query),
  };

  const [items, total] = await Promise.all([
    prisma.forumThread.findMany({
      where,
-      orderBy: [{ threadId: 'desc' }],
+      orderBy: orderOf(options.order),
      take,
+      skip,
      include: {
        player: { select: { id: true, displayName: true } },
        linkedCharacter: { select: { id: true, name: true } },
@@ -445,7 +519,32 @@ export async function listUnassignedThreads(options: { query?: string; take?: nu
    prisma.forumThread.count({ where }),
  ]);

-  return { items, total };
+  return { items, total, take, skip };
+}
+
+/**
+ * Wer im Forum Anträge gestellt hat, hier aber unter keinem Namen geführt
+ * wird - zusammengefasst je Ersteller statt je Antrag. So sieht man auf einen
+ * Blick, wen anzulegen sich lohnt: drei Anträge unter einem Namen sind ein
+ * anderes Signal als ein einzelner.
+ */
+export async function listUntrackedAuthors(take = 100) {
+  const gruppen = await prisma.forumThread.groupBy({
+    by: ['authorName'],
+    where: { playerId: null, needsClassification: true, authorName: { not: null } },
+    _count: { _all: true },
+    _max: { threadId: true },
+    orderBy: { _count: { threadId: 'desc' } },
+    take: Math.min(Math.max(take, 1), 500),
+  });
+
+  return {
+    items: gruppen.map((gruppe) => ({
+      authorName: gruppe.authorName as string,
+      threadCount: gruppe._count._all,
+      latestThreadId: gruppe._max.threadId,
+    })),
+  };
 }

 /**
@@ -485,6 +485,172 @@ export async function commitImport(importId: number, ctx: ActionContext) {
  return result;
 }

+/**
+ * Offene Paket-Zeilen eines Spielers, quer über alle noch nicht bestätigten
+ * Importe. Damit lässt sich ein Spieler an einem Stück abarbeiten, statt
+ * seine Zeilen in der Import-Vorschau zwischen fremden zu suchen.
+ */
+export async function listPendingRowsFor(playerId: number) {
+  return prisma.importRow.findMany({
+    where: {
+      resolvedPlayerId: playerId,
+      plan: { in: [PLANS.BOOK, PLANS.CREATE_PLAYER_AND_BOOK] },
+      import: { status: ImportStatus.PENDING },
+    },
+    orderBy: [{ purchasedAt: 'asc' }, { lineNo: 'asc' }],
+    select: {
+      id: true,
+      importId: true,
+      productName: true,
+      purchasedAt: true,
+      target: true,
+      externalId: true,
+      import: { select: { id: true, filename: true, createdAt: true } },
+    },
+  });
+}
+
+/**
+ * Bucht einzelne Zeilen sofort, ohne auf die Bestätigung des ganzen Imports
+ * zu warten. Gebuchte Zeilen werden als erledigt vermerkt - und zwar überall,
+ * wo dieselbe Bestellung noch offen liegt. Ohne das stünde sie später in der
+ * Import-Vorschau ein zweites Mal zur Buchung bereit.
+ *
+ * Gebucht wird über dieselbe Regel wie beim Import: ein CC-Paket schreibt
+ * zwei Zeilen, ein Redesign-Paket eine. Es gibt keinen zweiten Buchungsweg.
+ */
+export async function bookRows(rowIds: number[], ctx: ActionContext) {
+  if (rowIds.length === 0) {
+    throw badRequest('NOTHING_SELECTED', 'Es ist nichts zum Buchen ausgewählt');
+  }
+
+  const rows = await prisma.importRow.findMany({
+    where: {
+      id: { in: rowIds },
+      plan: { in: [PLANS.BOOK, PLANS.CREATE_PLAYER_AND_BOOK] },
+      import: { status: ImportStatus.PENDING },
+    },
+    orderBy: [{ purchasedAt: 'asc' }, { lineNo: 'asc' }],
+  });
+  if (rows.length === 0) {
+    throw conflict('NOTHING_TO_BOOK', 'Keine dieser Zeilen steht noch zur Buchung an');
+  }
+
+  return prisma.$transaction(async (tx) => {
+    let booked = 0;
+    let skipped = 0;
+    const erledigt: number[] = [];
+    const externalIds: string[] = [];
+
+    for (const row of rows) {
+      if (row.resolvedPlayerId === null) {
+        // Hier wird gezielt für einen bekannten Spieler gebucht; einen neuen
+        // anzulegen ist Sache der Import-Vorschau.
+        skipped += 1;
+        continue;
+      }
+
+      if (row.externalId) {
+        const bereitsGebucht = await tx.importedOrder.findUnique({
+          where: { externalId: row.externalId },
+          select: { id: true },
+        });
+        if (bereitsGebucht) {
+          skipped += 1;
+          erledigt.push(row.id);
+          externalIds.push(row.externalId);
+          continue;
+        }
+      }
+
+      const target =
+        row.target === ProductTarget.REDESIGN_PACKAGE ? 'REDESIGN_PACKAGE' : 'CC_PACKAGE';
+      const groupId = randomUUID();
+
+      await tx.creditLedger.createMany({
+        data: buildPackageRows(target, {
+          playerId: row.resolvedPlayerId,
+          groupId,
+          note: row.productName ? `Import: ${row.productName}` : `Import #${row.importId}`,
+          importId: row.importId,
+          actorId: ctx.actorId,
+        }),
+      });
+
+      if (row.externalId) {
+        await tx.importedOrder.create({
+          data: {
+            externalId: row.externalId,
+            importId: row.importId,
+            playerId: row.resolvedPlayerId,
+            target: row.target ?? ProductTarget.CC_PACKAGE,
+            groupId,
+          },
+        });
+        externalIds.push(row.externalId);
+      }
+
+      erledigt.push(row.id);
+      booked += 1;
+    }
+
+    // Die gebuchten Zeilen selbst und jede andere offene Zeile mit derselben
+    // Bestellung abhaken, damit nichts ein zweites Mal gebucht wird.
+    if (erledigt.length > 0) {
+      await tx.importRow.updateMany({
+        where: { id: { in: erledigt } },
+        data: { plan: PLANS.SKIP_DUPLICATE },
+      });
+    }
+    if (externalIds.length > 0) {
+      await tx.importRow.updateMany({
+        where: {
+          externalId: { in: externalIds },
+          plan: { in: [PLANS.BOOK, PLANS.CREATE_PLAYER_AND_BOOK] },
+        },
+        data: { plan: PLANS.SKIP_DUPLICATE },
+      });
+    }
+
+    await recordAudit(tx, ctx, {
+      action: 'import.rows_booked',
+      targetType: 'player',
+      targetId: rows[0]?.resolvedPlayerId ?? null,
+      details: { booked, skipped, rowIds: erledigt },
+    });
+
+    return { booked, skipped };
+  });
+}
+
+/**
+ * Nimmt offene Zeilen aus der Vorschau, ohne sie zu buchen. Für Pakete, die
+ * hier nichts verloren haben - ein Kauf, der schon von Hand eingetragen war.
+ */
+export async function dismissRows(rowIds: number[], ctx: ActionContext) {
+  if (rowIds.length === 0) {
+    throw badRequest('NOTHING_SELECTED', 'Es ist nichts ausgewählt');
+  }
+
+  const result = await prisma.importRow.updateMany({
+    where: {
+      id: { in: rowIds },
+      plan: { in: [PLANS.BOOK, PLANS.CREATE_PLAYER_AND_BOOK] },
+      import: { status: ImportStatus.PENDING },
+    },
+    data: { plan: PLANS.SKIP_IGNORED },
+  });
+
+  await recordAudit(prisma, ctx, {
+    action: 'import.rows_dismissed',
+    targetType: 'import_row',
+    targetId: null,
+    details: { count: result.count, rowIds },
+  });
+
+  return { dismissed: result.count };
+}
+
 export async function discardImport(importId: number, ctx: ActionContext): Promise<void> {
  const record = await prisma.import.findUnique({ where: { id: importId } });
  if (!record) throw notFound('Import');
@@ -80,20 +80,29 @@ export async function getPlayerDetail(playerId: number) {
  const player = await prisma.player.findUnique({ where: { id: playerId } });
  if (!player) throw notFound('Spieler');

-  const [balances, characters, ledger, unmatched, aliases] = await Promise.all([
-    getBalances(playerId),
-    listCharacters(playerId),
-    listLedger({ playerId, take: 200 }),
-    prisma.unmatchedPackage.findMany({
-      where: { playerId, resolved: false },
-      orderBy: { scrapedAt: 'desc' },
-      include: { player: { select: { id: true, displayName: true } } },
-    }),
-    prisma.playerAlias.findMany({
-      where: { playerId },
-      orderBy: [{ type: 'asc' }, { value: 'asc' }],
-    }),
-  ]);
+  // Threads und offene Paket-Zeilen kommen mit, damit sich ein Spieler an
+  // einem Stück abarbeiten lässt, statt zwischen drei Seiten zu wechseln.
+  const { listThreads } = await import('./forum.js');
+  const { listPendingRowsFor } = await import('./imports.js');
+
+  const [balances, characters, ledger, unmatched, aliases, threads, pendingRows] =
+    await Promise.all([
+      getBalances(playerId),
+      listCharacters(playerId),
+      listLedger({ playerId, take: 200 }),
+      prisma.unmatchedPackage.findMany({
+        where: { playerId, resolved: false },
+        orderBy: { scrapedAt: 'desc' },
+        include: { player: { select: { id: true, displayName: true } } },
+      }),
+      prisma.playerAlias.findMany({
+        where: { playerId },
+        orderBy: [{ type: 'asc' }, { value: 'asc' }],
+      }),
+      // Ältester zuerst: Anträge werden der Reihe nach abgearbeitet.
+      listThreads({ playerId, order: 'oldest' }),
+      listPendingRowsFor(playerId),
+    ]);

  return {
    player,
@@ -103,6 +112,8 @@ export async function getPlayerDetail(playerId: number) {
    ledgerTotal: ledger.total,
    unmatched,
    aliases,
+    threads,
+    pendingRows,
  };
 }