From 293d882cb4c50a5f1af02e5c9318be924892b4f2 Mon Sep 17 00:00:00 2001 From: Harlekin Date: Mon, 21 Sep 2026 00:49:38 +0200 Subject: [PATCH] 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. --- README.md | 30 +- server/src/routes/forum.routes.ts | 18 + server/src/routes/imports.routes.ts | 24 + server/src/services/forum.ts | 153 ++++-- server/src/services/imports.ts | 166 +++++++ server/src/services/players.ts | 39 +- server/test/antraege.test.ts | 104 ++++ server/test/imports.test.ts | 142 ++++++ web/src/components/PendingRowsBox.tsx | 142 ++++++ web/src/components/ThreadModals.tsx | 328 +++++++++++++ web/src/components/ThreadsBox.tsx | 113 +++++ web/src/lib/types.ts | 29 ++ web/src/pages/Dashboard.tsx | 31 +- web/src/pages/Forum.tsx | 652 +++++++++++--------------- web/src/pages/PlayerDetail.tsx | 24 + web/src/styles.css | 91 ++++ 16 files changed, 1655 insertions(+), 431 deletions(-) create mode 100644 web/src/components/PendingRowsBox.tsx create mode 100644 web/src/components/ThreadModals.tsx create mode 100644 web/src/components/ThreadsBox.tsx diff --git a/README.md b/README.md index c794e9d..4dc656d 100644 --- a/README.md +++ b/README.md @@ -234,6 +234,14 @@ Steam- oder Forumsaccount gewechselt hat, behält so seine Ansprüche. Steht der landet der Antrag unter *Ohne zugeordneten Spieler*: erfasst und durchsuchbar, aber außerhalb der Arbeitsliste, denn ohne Spieler lässt sich nichts buchen. Von dort ordnest du ihn von Hand zu. +Darüber steht *Ersteller ohne Spieler*: dieselben Anträge, aber nach Ersteller zusammengefasst. +Wer dreiundzwanzig Anträge gestellt hat, fällt dort auf, während er zwischen fünfhundert +Einzelanträgen untergeht. Ein Klick auf *Spieler anlegen* öffnet das Formular mit bereits +eingetragenem Forum-Namen; danach wandern seine Anträge von selbst in die Arbeitsliste. + +Beide Listen lassen sich durchsuchen und wahlweise mit dem neuesten oder dem ältesten Antrag +zuerst anzeigen; die untere blättert seitenweise. + Legst du später einen Spieler mit passendem Forum-Namen an - oder trägst den Namen nach, oder ergänzt ein früheres Konto -, wandern seine wartenden Anträge **von selbst** in die Arbeitsliste. Ein erneuter Abgleich ist dafür nicht nötig. Bereits zugeordnete Anträge bleiben dabei unberührt. @@ -241,6 +249,19 @@ Ein erneuter Abgleich ist dafür nicht nötig. Bereits zugeordnete Anträge blei Ist ein Antrag entschieden, hängt sein Thread am entstandenen CC: auf der Spielerseite führt ein Klick auf den CC-Namen direkt zum Forumsbeitrag. +### Einen Spieler an einem Stück abarbeiten + +Auf der Spielerseite stehen seine Anträge unter *Forums-Anträge*, ältester zuerst, jeder als Link +ins Forum. Offene lassen sich dort direkt entscheiden - dieselbe Entscheidung wie auf der +Anträge-Seite, nur ohne den Spieler dort erst suchen zu müssen. Danach steht der Antrag in der +Anträge-Liste nicht mehr offen. + +Genauso mit den Käufen: Liegen Pakete dieses Spielers noch in einer Import-Vorschau, erscheinen +sie unter *Offene Pakete aus dem Abgleich* und können einzeln oder am Stück gebucht werden. Was +hier gebucht ist, steht in keiner Vorschau mehr zur Buchung an - auch nicht, wenn dieselbe +Bestellung in einem zweiten Import liegt. Wer ein Paket gar nicht buchen will, legt es weg; es +verschwindet dann aus der Vorschau, ohne das Konto zu berühren. + Angepinnte Ankündigungen (Changelogs, Regelwerke) liegen mit in den Boards. Sie werden über ihre Labels *Wichtig* und *Information* aussortiert. Der Titel wird dagegen **nie** ausgewertet: CC-Anträge heißen mal „CC Antrag | Name", mal „\"The Duke\" Rang Update" - daran ist nichts zu erkennen. @@ -261,9 +282,12 @@ voller Lauf braucht also rund eine halbe Minute. Bremst das Forum den Zugriff au angegebene Wartezeit eingehalten, der Abstand für den Rest des Laufs verdoppelt und die Seite erneut versucht - der Lauf dauert dann länger, liest aber trotzdem alles. -Deshalb läuft der Abgleich **im Hintergrund**. Der Knopf zeigt den Fortschritt, und der Lauf -geht weiter, auch wenn du die Seite verlässt. Bricht ein Board doch ab, bleibt erhalten, was bis -dahin gelesen wurde; die Meldung nennt das Board und die Seite, bis zu der es gereicht hat. +Deshalb läuft der Abgleich **im Hintergrund**, mit einem Fortschrittsbalken und einem Protokoll, +das Seite für Seite mitschreibt. Gelesen wird zuerst von jedem Board die erste Seite - erst +danach steht der Umfang fest, und der Balken zeigt einen ehrlichen Anteil statt einer Schätzung. +Der Lauf geht weiter, auch wenn du die Seite verlässt. Bricht ein Board doch ab, bleibt erhalten, +was bis dahin gelesen wurde; die Meldung nennt das Board und die Seite, bis zu der es gereicht +hat. ## Problemfälle diff --git a/server/src/routes/forum.routes.ts b/server/src/routes/forum.routes.ts index 5093189..955aaff 100644 --- a/server/src/routes/forum.routes.ts +++ b/server/src/routes/forum.routes.ts @@ -10,6 +10,7 @@ import { listBoardChangeNotices, listThreads, listUnassignedThreads, + listUntrackedAuthors, startScan, } from '../services/forum.js'; import { contextOf, idParam, parseWith } from './helpers.js'; @@ -31,6 +32,8 @@ export async function forumRoutes(app: FastifyInstance): Promise { open: z.enum(['true', 'false']).default('true'), playerId: z.coerce.number().int().positive().optional(), board: z.nativeEnum(ForumBoard).optional(), + q: z.string().trim().max(120).optional(), + order: z.enum(['newest', 'oldest']).default('newest'), }), request.query, ); @@ -38,8 +41,10 @@ export async function forumRoutes(app: FastifyInstance): Promise { return { items: await listThreads({ onlyOpen: query.open === 'true', + order: query.order, ...(query.playerId !== undefined ? { playerId: query.playerId } : {}), ...(query.board ? { board: query.board } : {}), + ...(query.q ? { query: query.q } : {}), }), }; }); @@ -49,16 +54,29 @@ export async function forumRoutes(app: FastifyInstance): Promise { z.object({ q: z.string().trim().max(120).optional(), take: z.coerce.number().int().min(1).max(200).default(50), + skip: z.coerce.number().int().min(0).default(0), + order: z.enum(['newest', 'oldest']).default('newest'), }), request.query, ); return listUnassignedThreads({ take: query.take, + skip: query.skip, + order: query.order, ...(query.q ? { query: query.q } : {}), }); }); + /** Ersteller aus dem Forum, die hier unter keinem Namen geführt werden. */ + app.get('/api/forum/authors/untracked', { preHandler: requireAuth }, async (request) => { + const query = parseWith( + z.object({ take: z.coerce.number().int().min(1).max(500).default(100) }), + request.query, + ); + return listUntrackedAuthors(query.take); + }); + app.get('/api/forum/notices', { preHandler: requireAuth }, async () => { return { items: await listBoardChangeNotices() }; }); diff --git a/server/src/routes/imports.routes.ts b/server/src/routes/imports.routes.ts index c1dd32b..e56dc4a 100644 --- a/server/src/routes/imports.routes.ts +++ b/server/src/routes/imports.routes.ts @@ -10,6 +10,8 @@ import { getImport, listImports, parseUpload, + bookRows, + dismissRows, } from '../services/imports.js'; import { contextOf, idParam, parseWith } from './helpers.js'; @@ -63,6 +65,28 @@ export async function importRoutes(app: FastifyInstance): Promise { return commitImport(id, contextOf(request)); }); + /** + * Einzelne Zeilen sofort buchen, statt auf den ganzen Import zu warten. + * Gedacht für den Weg über die Spielerseite: einen Spieler an einem Stück + * abarbeiten. Gebuchtes verschwindet danach aus der Vorschau. + */ + app.post('/api/imports/rows/book', { preHandler: requireEditor }, async (request) => { + const body = parseWith( + z.object({ rowIds: z.array(z.number().int().positive()).min(1).max(500) }), + request.body, + ); + return bookRows(body.rowIds, contextOf(request)); + }); + + /** Zeilen aus der Vorschau nehmen, ohne sie zu buchen. */ + app.post('/api/imports/rows/dismiss', { preHandler: requireEditor }, async (request) => { + const body = parseWith( + z.object({ rowIds: z.array(z.number().int().positive()).min(1).max(500) }), + request.body, + ); + return dismissRows(body.rowIds, contextOf(request)); + }); + app.post('/api/imports/:id/discard', { preHandler: requireEditor }, async (request) => { const { id } = parseWith(idParam, request.params); await discardImport(id, contextOf(request)); diff --git a/server/src/services/forum.ts b/server/src/services/forum.ts index 2c1e73f..ca7c6a4 100644 --- a/server/src/services/forum.ts +++ b/server/src/services/forum.ts @@ -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 = { + '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 { // dauern als der Abruf selbst und den Aufruf ins Zeitlimit treiben. const gefunden = new Map(); + // 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 { }); } + 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> { 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, + })), + }; } /** diff --git a/server/src/services/imports.ts b/server/src/services/imports.ts index 544d644..c3f6178 100644 --- a/server/src/services/imports.ts +++ b/server/src/services/imports.ts @@ -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 { const record = await prisma.import.findUnique({ where: { id: importId } }); if (!record) throw notFound('Import'); diff --git a/server/src/services/players.ts b/server/src/services/players.ts index b0fbab6..e0811b3 100644 --- a/server/src/services/players.ts +++ b/server/src/services/players.ts @@ -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, }; } diff --git a/server/test/antraege.test.ts b/server/test/antraege.test.ts index 82a21fa..9d426d5 100644 --- a/server/test/antraege.test.ts +++ b/server/test/antraege.test.ts @@ -311,3 +311,107 @@ describe('Konten beim Abgleich', () => { assert.deepEqual(await scraper.steamIdsOf(spieler.id), []); }); }); + +describe('Sortieren, Blättern und Suchen', () => { + before(async () => { + // Eigener Namensraum, damit die Faelle davor nicht hineinspielen. + for (const id of [8801, 8802, 8803, 8804, 8805]) { + await offenerThread(id, `Serienantrag ${id}`, 'Vielschreiber'); + } + }); + + it('sortiert nach jüngstem und ältestem Antrag', async () => { + const neueste = await forum.listUnassignedThreads({ query: 'Vielschreiber', order: 'newest' }); + assert.deepEqual( + neueste.items.map((t) => t.threadId), + [8805, 8804, 8803, 8802, 8801], + ); + + const aelteste = await forum.listUnassignedThreads({ query: 'Vielschreiber', order: 'oldest' }); + assert.deepEqual( + aelteste.items.map((t) => t.threadId), + [8801, 8802, 8803, 8804, 8805], + ); + }); + + it('blättert seitenweise durch und nennt die volle Zahl', async () => { + const erste = await forum.listUnassignedThreads({ + query: 'Vielschreiber', + order: 'oldest', + take: 2, + }); + assert.deepEqual( + erste.items.map((t) => t.threadId), + [8801, 8802], + ); + assert.equal(erste.total, 5); + + const zweite = await forum.listUnassignedThreads({ + query: 'Vielschreiber', + order: 'oldest', + take: 2, + skip: 2, + }); + assert.deepEqual( + zweite.items.map((t) => t.threadId), + [8803, 8804], + 'keine Ueberschneidung mit der ersten Seite', + ); + }); + + it('durchsucht auch die Arbeitsliste', async () => { + const spieler = await players.createPlayer( + { displayName: 'Suchbar', steamId: '76561198000015555', forumName: 'Suchbar' }, + ctx, + ); + await offenerThread(8901, 'Ein ganz bestimmter Antrag', 'Suchbar'); + await offenerThread(8902, 'Etwas voellig anderes', 'Suchbar'); + await forum.claimThreadsForPlayer(spieler.id, ['Suchbar']); + + const treffer = await forum.listThreads({ onlyOpen: true, query: 'bestimmter' }); + assert.deepEqual( + treffer.map((t) => t.threadId), + [8901], + ); + + const nachAutor = await forum.listThreads({ onlyOpen: true, query: 'Suchbar' }); + assert.equal(nachAutor.length, 2, 'die Suche greift auch auf den Ersteller'); + }); +}); + +describe('Ersteller ohne Spieler', () => { + it('fasst die Anträge je Ersteller zusammen', async () => { + const liste = await forum.listUntrackedAuthors(); + const vielschreiber = liste.items.find((a) => a.authorName === 'Vielschreiber'); + + assert.ok(vielschreiber, 'wer fuenf Antraege gestellt hat, faellt auf'); + assert.equal(vielschreiber?.threadCount, 5); + assert.equal(vielschreiber?.latestThreadId, 8805); + }); + + it('führt niemanden auf, der längst einem Spieler gehört', async () => { + const liste = await forum.listUntrackedAuthors(); + assert.equal( + liste.items.some((a) => a.authorName === 'Suchbar'), + false, + ); + }); + + it('verschwindet aus der Liste, sobald der Spieler angelegt ist', async () => { + assert.equal( + (await forum.listUntrackedAuthors()).items.some((a) => a.authorName === 'Vielschreiber'), + true, + ); + + await players.createPlayer( + { displayName: 'Vielschreiber', steamId: '76561198000016666', forumName: 'Vielschreiber' }, + ctx, + ); + + assert.equal( + (await forum.listUntrackedAuthors()).items.some((a) => a.authorName === 'Vielschreiber'), + false, + 'seine Antraege stehen jetzt in der Arbeitsliste', + ); + }); +}); diff --git a/server/test/imports.test.ts b/server/test/imports.test.ts index d6565b7..791101e 100644 --- a/server/test/imports.test.ts +++ b/server/test/imports.test.ts @@ -241,3 +241,145 @@ describe('Kollisionen beim Buchen', () => { assert.equal(balances.CC, 1, 'genau einmal gebucht, nicht doppelt'); }); }); + +describe('Einzelne Zeilen beim Spieler buchen', () => { + // Jeder Fall bekommt eigene Bestellnummern: ein gebuchter Dedup-Anker gilt + // dauerhaft und wuerde sonst den naechsten Fall stillschweigend leerlaufen + // lassen. Die Spieler stehen fest - beim Weg ueber die Spielerseite geht es + // genau darum, einen Bekannten abzuarbeiten. + let eule = 0; + let specht = 0; + + function datei(praefix: string): Buffer { + return Buffer.from( + [ + 'Bestellnummer;Steam-ID;Spielername;Produkt;Kaufdatum', + `${praefix}-1;76561198000000011;Eule;CC-Paket Groß;2025-02-01`, + `${praefix}-2;76561198000000011;Eule;Redesign Gutschein;2025-02-02`, + `${praefix}-3;76561198000000012;Specht;CC-Paket Klein;2025-02-03`, + ].join('\n'), + 'utf8', + ); + } + + async function vorschau(praefix: string, name = `${praefix}.csv`) { + const parsed = imports.parseUpload(name, datei(praefix)); + const id = await imports.createImport(name, parsed, ctx); + await imports.applyMapping(id, MAPPING, ctx); + return id; + } + + before(async () => { + eule = ( + await db.prisma.player.create({ + data: { displayName: 'Eule', steamId: '76561198000000011' }, + }) + ).id; + specht = ( + await db.prisma.player.create({ + data: { displayName: 'Specht', steamId: '76561198000000012' }, + }) + ).id; + }); + + it('bucht nur die gewählte Zeile und lässt den Rest der Vorschau offen', async () => { + const importId = await vorschau('EINZ'); + + const offen = await imports.listPendingRowsFor(eule); + assert.equal(offen.length, 2, 'ein CC-Paket und ein Redesign-Gutschein'); + assert.equal(offen[0]?.productName, 'CC-Paket Groß', 'ältester Kauf zuerst'); + + const ergebnis = await imports.bookRows([offen[0]!.id], ctx); + assert.equal(ergebnis.booked, 1); + + // Ein CC-Paket schreibt zwei Zeilen - dieselbe Regel wie beim Import. + const stand = await credits.getBalances(eule); + assert.equal(stand.CC, 1); + assert.equal(stand.REDESIGN_PAID, 1); + + assert.equal( + (await imports.listPendingRowsFor(eule)).length, + 1, + 'die gebuchte Zeile ist aus der Liste, die andere wartet weiter', + ); + + const nachher = await db.prisma.import.findUniqueOrThrow({ where: { id: importId } }); + assert.equal(nachher.status, 'PENDING', 'der Import als Ganzes bleibt offen'); + + await imports.discardImport(importId, ctx); + }); + + it('bucht dieselbe Bestellung nicht ein zweites Mal über den Import', async () => { + const importId = await vorschau('ZWEI'); + + const offen = await imports.listPendingRowsFor(specht); + assert.equal(offen.length, 1); + await imports.bookRows([offen[0]!.id], ctx); + + const vorher = await credits.getBalances(specht); + + // Der Import wird danach ganz normal bestätigt - die eben gebuchte Zeile + // steht dabei gar nicht mehr zur Buchung an, sie ist ja abgehakt. + const ergebnis = await imports.commitImport(importId, ctx); + assert.equal(ergebnis.booked, 2, 'nur die beiden Zeilen der Eule bleiben übrig'); + + assert.deepEqual( + await credits.getBalances(specht), + vorher, + 'sonst stünde das Paket doppelt im Konto', + ); + }); + + it('hakt dieselbe Bestellung auch in einem zweiten offenen Import ab', async () => { + // Zweimal dieselbe Datei eingelesen, etwa weil der Abgleich doppelt lief. + const ersterImport = await vorschau('DREI', 'lauf-a.csv'); + const zweiterImport = await vorschau('DREI', 'lauf-b.csv'); + + const offen = await imports.listPendingRowsFor(eule); + const redesigns = offen.filter((row) => row.externalId === 'DREI-2'); + assert.equal(redesigns.length, 2, 'dieselbe Bestellung liegt in beiden Vorschauen'); + + const vorher = await credits.getBalances(eule); + await imports.bookRows([redesigns[0]!.id], ctx); + + assert.equal( + (await imports.listPendingRowsFor(eule)).filter((row) => row.externalId === 'DREI-2').length, + 0, + 'die Zwillingszeile im anderen Import ist mit abgehakt', + ); + assert.equal( + (await credits.getBalances(eule)).REDESIGN_PAID, + vorher.REDESIGN_PAID + 1, + 'einmal gekauft, einmal gebucht', + ); + + await imports.discardImport(ersterImport, ctx); + await imports.discardImport(zweiterImport, ctx); + }); + + it('weist eine leere Auswahl ab', async () => { + await assert.rejects( + () => imports.bookRows([], ctx), + (error: Error & { code?: string }) => error.code === 'NOTHING_SELECTED', + ); + }); + + it('nimmt Zeilen auch ohne Buchung aus der Vorschau', async () => { + const importId = await vorschau('VIER'); + + const offen = await imports.listPendingRowsFor(specht); + assert.equal(offen.length, 1); + const vorher = await credits.getBalances(specht); + + const ergebnis = await imports.dismissRows( + offen.map((row) => row.id), + ctx, + ); + assert.equal(ergebnis.dismissed, 1); + + assert.deepEqual(await imports.listPendingRowsFor(specht), []); + assert.deepEqual(await credits.getBalances(specht), vorher, 'weggelegt ist nicht gebucht'); + + await imports.discardImport(importId, ctx); + }); +}); diff --git a/web/src/components/PendingRowsBox.tsx b/web/src/components/PendingRowsBox.tsx new file mode 100644 index 0000000..57800b4 --- /dev/null +++ b/web/src/components/PendingRowsBox.tsx @@ -0,0 +1,142 @@ +import { useState } from 'react'; +import Notice from './Notice'; +import { ApiError, api } from '../lib/api'; +import { formatDate } from '../lib/format'; +import type { PendingRow } from '../lib/types'; + +const ZIEL_LABEL: Record = { + CC_PACKAGE: 'CC-Paket', + REDESIGN_PACKAGE: 'Redesign-Paket', + IGNORE: 'Ohne Wirkung', +}; + +/** + * Pakete dieses Spielers, die noch in einer offenen Import-Vorschau liegen. + * + * Damit lässt sich ein Spieler an einem Stück abarbeiten, statt seine Zeilen + * in der Import-Vorschau zwischen fremden zu suchen. Was hier gebucht wird, + * steht danach in keiner Vorschau mehr zur Buchung an - auch nicht, wenn + * dieselbe Bestellung in einem zweiten Import liegt. + */ +export default function PendingRowsBox({ + rows, + canEdit, + onChanged, + onError, + onFlash, +}: { + rows: PendingRow[]; + canEdit: boolean; + onChanged: () => void; + onError: (message: string) => void; + onFlash: (message: string) => void; +}) { + const [busy, setBusy] = useState(false); + const [gewaehlt, setGewaehlt] = useState>(new Set()); + + if (rows.length === 0) return null; + + const umschalten = (id: number) => { + setGewaehlt((alt) => { + const neu = new Set(alt); + if (neu.has(id)) neu.delete(id); + else neu.add(id); + return neu; + }); + }; + + const ausgewaehlt = rows.filter((row) => gewaehlt.has(row.id)); + const betroffen = ausgewaehlt.length > 0 ? ausgewaehlt : rows; + + const ausfuehren = async (pfad: 'book' | 'dismiss') => { + const anzahl = betroffen.length; + if ( + pfad === 'dismiss' && + !window.confirm( + `${anzahl} ${anzahl === 1 ? 'Paket' : 'Pakete'} ohne Buchung aus der Vorschau nehmen?`, + ) + ) { + return; + } + + setBusy(true); + try { + await api(`/api/imports/rows/${pfad}`, { + method: 'POST', + body: { rowIds: betroffen.map((row) => row.id) }, + }); + onFlash( + pfad === 'book' + ? `${anzahl} ${anzahl === 1 ? 'Paket' : 'Pakete'} gebucht.` + : `${anzahl} ${anzahl === 1 ? 'Paket' : 'Pakete'} weggelegt.`, + ); + setGewaehlt(new Set()); + onChanged(); + } catch (err) { + onError(err instanceof ApiError ? err.message : 'Buchen fehlgeschlagen'); + } finally { + setBusy(false); + } + }; + + return ( +
+

Offene Pakete aus dem Abgleich ({rows.length})

+ + Diese Käufe liegen in einer Import-Vorschau und sind noch nicht gebucht. Hier gebucht, + verschwinden sie aus der Vorschau - doppelt buchen ist ausgeschlossen. + + +
    + {rows.map((row) => ( +
  • +
    + +

    + {row.purchasedAt ? `Gekauft ${formatDate(row.purchasedAt)}` : 'Ohne Kaufdatum'} · + aus „{row.import.filename}" + {row.externalId && ` · ${row.externalId}`} +

    +
    +
    • + ))} +
+ + {canEdit && ( +
+ + +
+ )} +
+ ); +} diff --git a/web/src/components/ThreadModals.tsx b/web/src/components/ThreadModals.tsx new file mode 100644 index 0000000..be8d117 --- /dev/null +++ b/web/src/components/ThreadModals.tsx @@ -0,0 +1,328 @@ +import { useEffect, useState } from 'react'; +import Modal from './Modal'; +import Notice from './Notice'; +import { ApiError, api } from '../lib/api'; +import { CLASSIFICATION_LABEL } from '../lib/format'; +import type { + Character, + ForumClassification, + ForumThread, + PlayerDetail, + PlayerSummary, +} from '../lib/types'; + +export function ClassifyModal({ + thread, + onClose, + onDone, + onError, +}: { + thread: ForumThread; + onClose: () => void; + onDone: (message: string) => void; + onError: (message: string) => void; +}) { + const [choice, setChoice] = useState('NEW_CC'); + const [name, setName] = useState(thread.title); + const [predecessorId, setPredecessorId] = useState(null); + const [reviveId, setReviveId] = useState(null); + const [useKind, setUseKind] = useState<'REDESIGN_KULANZ' | 'REDESIGN_PAID'>('REDESIGN_KULANZ'); + const [characters, setCharacters] = useState([]); + const [inactive, setInactive] = useState([]); + const [busy, setBusy] = useState(false); + + // Für ein Redesign braucht der Admin die Liste der aktiven CCs des Spielers. + useEffect(() => { + if (!thread.playerId) return; + void (async () => { + try { + const detail = await api(`/api/players/${thread.playerId}`); + setCharacters(detail.characters.filter((c) => c.status === 'ACTIVE')); + setInactive(detail.characters.filter((c) => c.status === 'INACTIVE')); + } catch { + // Ohne Liste bleibt nur die Ablehnung - das Formular sagt es. + } + })(); + }, [thread.playerId]); + + const needsPlayer = choice === 'NEW_CC' || choice === 'REDESIGN' || choice === 'REACTIVATION'; + const needsName = choice === 'NEW_CC' || choice === 'REDESIGN'; + // Ein redesignter CC existiert im Original nicht mehr und kostet deshalb. + const gewaehlterCC = inactive.find((c) => c.id === reviveId); + const reaktivierungKostet = gewaehlterCC?.inactiveReason === 'REWORKED'; + + const submit = async (event: React.FormEvent) => { + event.preventDefault(); + setBusy(true); + try { + await api(`/api/forum/threads/${thread.threadId}/classify`, { + method: 'POST', + body: { + classification: choice, + ...(needsName ? { characterName: name.trim() } : {}), + ...(choice === 'REDESIGN' ? { predecessorId, useKind } : {}), + ...(choice === 'REACTIVATION' + ? { characterId: reviveId, ...(reaktivierungKostet ? { useKind } : {}) } + : {}), + }, + }); + onDone(`Antrag entschieden: ${CLASSIFICATION_LABEL[choice]}.`); + } catch (err) { + onError(err instanceof ApiError ? err.message : 'Entscheidung fehlgeschlagen'); + } finally { + setBusy(false); + } + }; + + return ( + +
+ + {thread.title} +
+ von {thread.authorName ?? 'unbekannt'} + {thread.player ? ` · ${thread.player.displayName}` : ' · kein Spieler zugeordnet'} + + +
+ {( + [ + ['NEW_CC', 'Angenommen - neuer CC', 'verbraucht 1 CC-Guthaben'], + ['REDESIGN', 'Angenommen - Redesign', 'verbraucht 1 Redesign-Guthaben'], + ['REACTIVATION', 'Angenommen - Reaktivierung', 'ein inaktiver CC kehrt zurück'], + ['REJECTED', 'Abgelehnt', 'keine Buchung'], + ['IGNORE', 'Kein Antrag', 'keine Buchung'], + ] as const + ).map(([value, label, hint]) => ( + + ))} +
+ + {needsPlayer && !thread.playerId && ( + + Ohne zugeordneten Spieler lässt sich nichts buchen. Bitte erst „Spieler zuordnen". + + )} + + {needsName && thread.playerId && ( + <> + + setName(event.target.value)} + required + /> +

Vorbelegt mit dem Thread-Titel - bitte anpassen.

+ + )} + + {choice === 'REACTIVATION' && thread.playerId && ( + <> + + + {inactive.length === 0 && ( +

Dieser Spieler hat keine inaktiven CCs.

+ )} + + {gewaehlterCC && !reaktivierungKostet && ( + + Kommt gratis zurück - der CC existiert unverändert weiter. + + )} + + {reaktivierungKostet && ( + <> + + Dieser CC wurde redesignt und existiert im Original nicht mehr. Die Rückkehr + kostet ein Guthaben. + + +
+ + +
+ + )} + + )} + + {choice === 'REDESIGN' && thread.playerId && ( + <> + + + {characters.length === 0 && ( +

Dieser Spieler hat keine aktiven CCs.

+ )} + + +
+ + +
+ + )} + +
+ + +
+
+ + ); +} + +export function AssignModal({ + thread, + onClose, + onDone, + onError, +}: { + thread: ForumThread; + onClose: () => void; + onDone: () => void; + onError: (message: string) => void; +}) { + const [query, setQuery] = useState(thread.authorName ?? ''); + const [results, setResults] = useState([]); + + useEffect(() => { + const timer = setTimeout(async () => { + try { + const params = new URLSearchParams({ q: query, take: '20' }); + const data = await api<{ items: PlayerSummary[] }>(`/api/players?${params}`); + setResults(data.items); + } catch { + // Suchfehler blockieren den Dialog nicht. + } + }, 250); + return () => clearTimeout(timer); + }, [query]); + + const assign = async (playerId: number) => { + try { + await api(`/api/forum/threads/${thread.threadId}/player`, { + method: 'POST', + body: { playerId }, + }); + onDone(); + } catch (err) { + onError(err instanceof ApiError ? err.message : 'Zuordnen fehlgeschlagen'); + } + }; + + return ( + + + Forumsname des Antragstellers: {thread.authorName ?? 'unbekannt'}. Passt + kein Eintrag, trag den Forumsnamen beim Spieler nach - dann findet der nächste Abgleich + ihn von allein. + + + + setQuery(event.target.value)} + autoFocus + /> + +
    + {results.map((player) => ( +
  • +
    + {player.displayName} + {player.forumName && · Forum: {player.forumName}} +
    +
    + +
    +
    • + ))} + {results.length === 0 &&

    Kein Treffer.

    } +
+ + ); +} diff --git a/web/src/components/ThreadsBox.tsx b/web/src/components/ThreadsBox.tsx new file mode 100644 index 0000000..fbe29fb --- /dev/null +++ b/web/src/components/ThreadsBox.tsx @@ -0,0 +1,113 @@ +import { useState } from 'react'; +import Notice from './Notice'; +import { ClassifyModal } from './ThreadModals'; +import { BOARD_LABEL, CLASSIFICATION_LABEL, formatDate } from '../lib/format'; +import type { ForumThread } from '../lib/types'; + +/** + * Die Forums-Anträge dieses Spielers, ältester zuerst - so wie sie + * abgearbeitet werden. Offene lassen sich hier direkt entscheiden, statt + * dafür auf die Anträge-Seite zu wechseln und ihn dort zu suchen. + */ +export default function ThreadsBox({ + threads, + canEdit, + onChanged, + onError, + onFlash, +}: { + threads: ForumThread[]; + canEdit: boolean; + onChanged: () => void; + onError: (message: string) => void; + onFlash: (message: string) => void; +}) { + const [dialog, setDialog] = useState(null); + + const offen = threads.filter((thread) => thread.needsClassification); + const entschieden = threads.filter((thread) => !thread.needsClassification); + + return ( +
0 ? 'block block-flag' : 'block'}> +

Forums-Anträge ({threads.length})

+ + {threads.length === 0 ? ( +

+ Keine Anträge zugeordnet. Zugeordnet wird über den Forum-Namen des Erstellers - steht + hier keiner, findet der Abgleich nichts. +

+ ) : ( + <> + {offen.length > 0 && ( + + {offen.length} {offen.length === 1 ? 'Antrag wartet' : 'Anträge warten'} auf eine + Entscheidung. Was hier entschieden wird, steht danach in der Anträge-Liste nicht + mehr offen. + + )} + +
    + {threads.map((thread) => ( +
  • +
    + + {thread.title} + + {BOARD_LABEL[thread.currentBoard]} + {thread.classification && ( + + {CLASSIFICATION_LABEL[thread.classification]} + + )} +

    + von {thread.authorName ?? 'unbekannt'} + {thread.labels && ` · ${thread.labels}`} + {thread.linkedCharacter && ` · CC: ${thread.linkedCharacter.name}`} + {thread.classifiedAt && ` · entschieden ${formatDate(thread.classifiedAt)}`} +

    +
    + {canEdit && thread.needsClassification && ( +
    + +
    + )} +
    • + ))} +
+ + {entschieden.length > 0 && offen.length === 0 && ( +

Alle Anträge sind entschieden.

+ )} + + )} + + {dialog && ( + setDialog(null)} + onDone={(message) => { + setDialog(null); + onFlash(message); + onChanged(); + }} + onError={onError} + /> + )} +
+ ); +} diff --git a/web/src/lib/types.ts b/web/src/lib/types.ts index f8105cf..5cbfd76 100644 --- a/web/src/lib/types.ts +++ b/web/src/lib/types.ts @@ -168,6 +168,10 @@ export interface PlayerDetail { ledgerTotal: number; unmatched: UnmatchedPackage[]; aliases: PlayerAlias[]; + /// Forums-Anträge dieses Spielers, ältester zuerst. + threads: ForumThread[]; + /// Pakete, die noch in einer offenen Import-Vorschau liegen. + pendingRows: PendingRow[]; } export interface AdminUser { @@ -260,6 +264,7 @@ export interface ForumThread { lastBoardChangeAt: string | null; classification: ForumClassification | null; needsClassification: boolean; + classifiedAt: string | null; linkedCharacterId: number | null; linkedCharacter: { id: number; name: string; status?: string } | null; boardChangeNotice: boolean; @@ -282,6 +287,8 @@ export interface ForumScanSummary { export interface UnassignedThreads { items: ForumThread[]; total: number; + take: number; + skip: number; } export interface ScanState { @@ -290,6 +297,28 @@ export interface ScanState { finishedAt: string | null; currentBoard: string | null; pagesRead: number; + /// Steht erst fest, wenn von jedem Board die erste Seite gelesen ist. + totalPages: number; + log: string[]; summary: ForumScanSummary | null; error: string | null; } + +export type ThreadOrder = 'newest' | 'oldest'; + +export interface UntrackedAuthor { + authorName: string; + threadCount: number; + latestThreadId: number | null; +} + +/// Eine offene Paket-Zeile aus einem noch nicht bestätigten Import. +export interface PendingRow { + id: number; + importId: number; + productName: string | null; + purchasedAt: string | null; + target: ProductTarget | null; + externalId: string | null; + import: { id: number; filename: string; createdAt: string }; +} diff --git a/web/src/pages/Dashboard.tsx b/web/src/pages/Dashboard.tsx index 3d9ffbd..4b74659 100644 --- a/web/src/pages/Dashboard.tsx +++ b/web/src/pages/Dashboard.tsx @@ -1,5 +1,5 @@ import { useCallback, useEffect, useState } from 'react'; -import { Link } from 'react-router-dom'; +import { Link, useSearchParams } from 'react-router-dom'; import Modal from '../components/Modal'; import Notice from '../components/Notice'; import { ApiError, api } from '../lib/api'; @@ -25,6 +25,10 @@ export default function Dashboard() { const [result, setResult] = useState({ total: 0, items: [] }); const [loading, setLoading] = useState(true); const [error, setError] = useState(null); + // Von der Anträge-Seite aus: "Spieler anlegen" für einen Ersteller, dessen + // Forum-Name schon feststeht. + const [params, setParams] = useSearchParams(); + const vorgabe = params.get('anlegen'); const [creating, setCreating] = useState(false); const [flagged, setFlagged] = useState({ total: 0, players: [] }); const [syncing, setSyncing] = useState(false); @@ -215,11 +219,16 @@ export default function Dashboard() {

)} - {creating && ( + {(creating || vorgabe !== null) && ( setCreating(false)} + forumNameVorgabe={vorgabe ?? ''} + onClose={() => { + setCreating(false); + if (vorgabe !== null) setParams({}, { replace: true }); + }} onCreated={() => { setCreating(false); + if (vorgabe !== null) setParams({}, { replace: true }); void load(query, nurProbleme); }} /> @@ -228,10 +237,20 @@ export default function Dashboard() { ); } -function CreatePlayerModal({ onClose, onCreated }: { onClose: () => void; onCreated: () => void }) { - const [displayName, setDisplayName] = useState(''); +function CreatePlayerModal({ + forumNameVorgabe, + onClose, + onCreated, +}: { + forumNameVorgabe: string; + onClose: () => void; + onCreated: () => void; +}) { + // Kommt der Aufruf von einem Forums-Ersteller, ist der Name schon bekannt - + // und taugt bis auf Weiteres auch als Anzeigename. + const [displayName, setDisplayName] = useState(forumNameVorgabe); const [steamId, setSteamId] = useState(''); - const [forumName, setForumName] = useState(''); + const [forumName, setForumName] = useState(forumNameVorgabe); const [istProblem, setIstProblem] = useState(false); const [problemNote, setProblemNote] = useState(''); const [error, setError] = useState(null); diff --git a/web/src/pages/Forum.tsx b/web/src/pages/Forum.tsx index 82e33ba..34cb636 100644 --- a/web/src/pages/Forum.tsx +++ b/web/src/pages/Forum.tsx @@ -1,19 +1,17 @@ import { useCallback, useEffect, useState } from 'react'; -import { Link } from 'react-router-dom'; -import Modal from '../components/Modal'; +import { Link, useNavigate } from 'react-router-dom'; import Notice from '../components/Notice'; +import { AssignModal, ClassifyModal } from '../components/ThreadModals'; import { ApiError, api } from '../lib/api'; import { BOARD_LABEL, CLASSIFICATION_LABEL, formatDate } from '../lib/format'; import { useSession } from '../lib/session'; import type { - Character, - ForumClassification, ForumScanSummary, ForumThread, - PlayerDetail, - PlayerSummary, ScanState, + ThreadOrder, UnassignedThreads, + UntrackedAuthor, } from '../lib/types'; /// Die Board-Pfade des Abgleichs in lesbarer Form. @@ -23,8 +21,11 @@ const BOARD_PFAD: Record = { 'board/113-cc-archiv': 'das Archiv', }; +const SEITE = 25; + export default function Forum() { const { can } = useSession(); + const navigate = useNavigate(); const darfEntscheiden = can('EDITOR'); const [threads, setThreads] = useState([]); @@ -34,36 +35,73 @@ export default function Forum() { const [busy, setBusy] = useState(false); const [dialog, setDialog] = useState(null); const [assigning, setAssigning] = useState(null); - const [ohneSpieler, setOhneSpieler] = useState(null); - const [suche, setSuche] = useState(''); - const [zeigeOhneSpieler, setZeigeOhneSpieler] = useState(false); - /// Hochzählen heißt: die Liste ohne Spieler neu holen. - const [stand, setStand] = useState(0); const [scanZustand, setScan] = useState(null); - const ladeOhneSpieler = useCallback(async (query: string) => { - const param = query.trim() ? `?q=${encodeURIComponent(query.trim())}` : ''; + // Arbeitsliste + const [sucheOffen, setSucheOffen] = useState(''); + const [sortOffen, setSortOffen] = useState('newest'); + + // Ohne zugeordneten Spieler + const [ohneSpieler, setOhneSpieler] = useState(null); + const [sucheOhne, setSucheOhne] = useState(''); + const [sortOhne, setSortOhne] = useState('newest'); + const [seite, setSeite] = useState(0); + const [zeigeOhneSpieler, setZeigeOhneSpieler] = useState(false); + + // Ersteller ohne Spieler + const [autoren, setAutoren] = useState([]); + const [zeigeAutoren, setZeigeAutoren] = useState(false); + + /// Hochzählen heißt: die abhängigen Listen neu holen. + const [stand, setStand] = useState(0); + + const ladeOffene = useCallback(async (query: string, order: ThreadOrder) => { + const params = new URLSearchParams({ open: 'true', order }); + if (query.trim()) params.set('q', query.trim()); try { - setOhneSpieler(await api(`/api/forum/threads/unassigned${param}`)); + const data = await api<{ items: ForumThread[] }>(`/api/forum/threads?${params}`); + setThreads(data.items); } catch (err) { setError(err instanceof ApiError ? err.message : 'Laden fehlgeschlagen'); } }, []); + const ladeOhneSpieler = useCallback( + async (query: string, order: ThreadOrder, skip: number) => { + const params = new URLSearchParams({ + order, + take: String(SEITE), + skip: String(skip), + }); + if (query.trim()) params.set('q', query.trim()); + try { + setOhneSpieler(await api(`/api/forum/threads/unassigned?${params}`)); + } catch (err) { + setError(err instanceof ApiError ? err.message : 'Laden fehlgeschlagen'); + } + }, + [], + ); + + const ladeAutoren = useCallback(async () => { + try { + const data = await api<{ items: UntrackedAuthor[] }>('/api/forum/authors/untracked'); + setAutoren(data.items); + } catch { + // Die Liste ist Beiwerk; ein Fehler hier darf den Rest nicht stören. + } + }, []); + const load = useCallback(async () => { try { - const [open, notice] = await Promise.all([ - api<{ items: ForumThread[] }>('/api/forum/threads?open=true'), - api<{ items: ForumThread[] }>('/api/forum/notices'), - ]); - setThreads(open.items); - setNotices(notice.items); + setNotices((await api<{ items: ForumThread[] }>('/api/forum/notices')).items); setError(null); } catch (err) { setError(err instanceof ApiError ? err.message : 'Laden fehlgeschlagen'); } + await ladeAutoren(); setStand((n) => n + 1); - }, []); + }, [ladeAutoren]); useEffect(() => { void load(); @@ -71,9 +109,25 @@ export default function Forum() { // Beim Tippen kurz abwarten, statt jede Taste an den Server zu schicken. useEffect(() => { - const timer = window.setTimeout(() => void ladeOhneSpieler(suche), suche ? 250 : 0); + const timer = window.setTimeout( + () => void ladeOffene(sucheOffen, sortOffen), + sucheOffen ? 250 : 0, + ); return () => window.clearTimeout(timer); - }, [suche, stand, ladeOhneSpieler]); + }, [sucheOffen, sortOffen, stand, ladeOffene]); + + useEffect(() => { + const timer = window.setTimeout( + () => void ladeOhneSpieler(sucheOhne, sortOhne, seite * SEITE), + sucheOhne ? 250 : 0, + ); + return () => window.clearTimeout(timer); + }, [sucheOhne, sortOhne, seite, stand, ladeOhneSpieler]); + + // Eine neue Suche fängt wieder auf Seite eins an. + useEffect(() => { + setSeite(0); + }, [sucheOhne, sortOhne]); const bericht = (result: ForumScanSummary): string => { const parts = [`${result.scannedPages} Seiten gelesen`]; @@ -100,27 +154,26 @@ export default function Forum() { useEffect(() => { if (!busy) return; - const timer = window.setInterval(() => { - void (async () => { - try { - const state = await api('/api/forum/scan/status'); - setScan(state); - if (state.running) return; + const abfragen = async () => { + try { + const state = await api('/api/forum/scan/status'); + setScan(state); + if (state.running) return; - setBusy(false); - if (state.error) setError(state.error); - else if (state.summary) { - setFlash(bericht(state.summary)); - window.setTimeout(() => setFlash(null), 12000); - } - await load(); - } catch (err) { - setBusy(false); - setError(err instanceof ApiError ? err.message : 'Abgleich fehlgeschlagen'); + setBusy(false); + if (state.error) setError(state.error); + else if (state.summary) { + setFlash(bericht(state.summary)); + window.setTimeout(() => setFlash(null), 12000); } - })(); - }, 2000); + await load(); + } catch (err) { + setBusy(false); + setError(err instanceof ApiError ? err.message : 'Abgleich fehlgeschlagen'); + } + }; + const timer = window.setInterval(() => void abfragen(), 1500); return () => window.clearInterval(timer); }, [busy, load]); @@ -156,6 +209,8 @@ export default function Forum() { } }; + const seiten = ohneSpieler ? Math.ceil(ohneSpieler.total / SEITE) : 0; + return (
@@ -163,15 +218,13 @@ export default function Forum() {

Forums-Anträge

Jeder Antrag wird von Hand entschieden - Titel und Board sind kein verlässliches - Signal und lösen nie eine Buchung aus. Aufgenommen werden nur Threads von Spielern, - die hier mit passendem Forum-Namen erfasst sind. + Signal und lösen nie eine Buchung aus. Anträge von Erstellern, die hier unter keinem + Forum-Namen geführt werden, stehen weiter unten.

{darfEntscheiden && ( )}
@@ -179,14 +232,7 @@ export default function Forum() { {error && setError(null)}>{error}} {flash && setFlash(null)}>{flash}} - {busy && ( - - Der Abgleich liest gerade {BOARD_PFAD[scanZustand?.currentBoard ?? ''] ?? 'das Forum'} - - bisher {scanZustand?.pagesRead ?? 0} Seiten. Das Archiv umfasst über zwanzig Seiten, und - zwischen den Abrufen wird bewusst gewartet, damit das Forum den Zugriff nicht bremst. Der - Lauf geht im Hintergrund weiter, auch wenn diese Seite geschlossen wird. - - )} + {busy && } {notices.length > 0 && (
@@ -229,9 +275,28 @@ export default function Forum() {

Wartet auf Entscheidung ({threads.length})

+
+ setSucheOffen(event.target.value)} + /> + +
+ {threads.length === 0 ? (

- Keine offenen Anträge. {darfEntscheiden && 'Über „Forum abgleichen" nach neuen suchen.'} + {sucheOffen + ? 'Kein Treffer.' + : `Keine offenen Anträge. ${darfEntscheiden ? 'Über „Forum abgleichen" nach neuen suchen.' : ''}`}

) : (
    @@ -281,14 +346,77 @@ export default function Forum() { )}
+
+
+
+

Ersteller ohne Spieler ({autoren.length})

+

+ Wer im Forum Anträge gestellt hat, hier aber unter keinem Forum-Namen geführt wird. + Ein Klick legt den Spieler an - der Forum-Name steht schon drin, und seine Anträge + wandern anschließend von selbst in die Arbeitsliste. +

+
+ {autoren.length > 0 && ( + + )} +
+ + {autoren.length === 0 ? ( +

Jeder Ersteller ist einem Spieler zugeordnet.

+ ) : ( + zeigeAutoren && ( +
    + {autoren.map((autor) => ( +
  • +
    + {autor.authorName} + + {autor.threadCount} {autor.threadCount === 1 ? 'Antrag' : 'Anträge'} + +
    +
    + + {darfEntscheiden && ( + + )} +
    +
    • + ))} +
+ ) + )} +
+

Ohne zugeordneten Spieler ({ohneSpieler?.total ?? 0})

- Anträge, deren Ersteller hier unter keinem Forum-Namen geführt wird. Sie bleiben - aus der Arbeitsliste heraus, gehen aber nicht verloren. Sobald ein Spieler mit - passendem Forum-Namen angelegt wird, wandern sie von selbst hinüber. + Einzelne Anträge, deren Ersteller hier nicht geführt wird. Sie bleiben aus der + Arbeitsliste heraus, gehen aber nicht verloren.

+ + Seite {seite + 1} von {seiten} · {ohneSpieler.total} Anträge + + +
)} )} @@ -390,318 +545,53 @@ export default function Forum() { ); } -function ClassifyModal({ - thread, - onClose, - onDone, - onError, -}: { - thread: ForumThread; - onClose: () => void; - onDone: (message: string) => void; - onError: (message: string) => void; -}) { - const [choice, setChoice] = useState('NEW_CC'); - const [name, setName] = useState(thread.title); - const [predecessorId, setPredecessorId] = useState(null); - const [reviveId, setReviveId] = useState(null); - const [useKind, setUseKind] = useState<'REDESIGN_KULANZ' | 'REDESIGN_PAID'>('REDESIGN_KULANZ'); - const [characters, setCharacters] = useState([]); - const [inactive, setInactive] = useState([]); - const [busy, setBusy] = useState(false); - - // Für ein Redesign braucht der Admin die Liste der aktiven CCs des Spielers. - useEffect(() => { - if (!thread.playerId) return; - void (async () => { - try { - const detail = await api(`/api/players/${thread.playerId}`); - setCharacters(detail.characters.filter((c) => c.status === 'ACTIVE')); - setInactive(detail.characters.filter((c) => c.status === 'INACTIVE')); - } catch { - // Ohne Liste bleibt nur die Ablehnung - das Formular sagt es. - } - })(); - }, [thread.playerId]); - - const needsPlayer = choice === 'NEW_CC' || choice === 'REDESIGN' || choice === 'REACTIVATION'; - const needsName = choice === 'NEW_CC' || choice === 'REDESIGN'; - // Ein redesignter CC existiert im Original nicht mehr und kostet deshalb. - const gewaehlterCC = inactive.find((c) => c.id === reviveId); - const reaktivierungKostet = gewaehlterCC?.inactiveReason === 'REWORKED'; - - const submit = async (event: React.FormEvent) => { - event.preventDefault(); - setBusy(true); - try { - await api(`/api/forum/threads/${thread.threadId}/classify`, { - method: 'POST', - body: { - classification: choice, - ...(needsName ? { characterName: name.trim() } : {}), - ...(choice === 'REDESIGN' ? { predecessorId, useKind } : {}), - ...(choice === 'REACTIVATION' - ? { characterId: reviveId, ...(reaktivierungKostet ? { useKind } : {}) } - : {}), - }, - }); - onDone(`Antrag entschieden: ${CLASSIFICATION_LABEL[choice]}.`); - } catch (err) { - onError(err instanceof ApiError ? err.message : 'Entscheidung fehlgeschlagen'); - } finally { - setBusy(false); - } - }; +/** + * Was der Abgleich gerade tut. Der Umfang steht erst fest, wenn von jedem + * Board die erste Seite gelesen ist - bis dahin läuft der Balken durch, + * statt einen erfundenen Anteil zu behaupten. + */ +function ScanProgress({ state }: { state: ScanState | null }) { + const gelesen = state?.pagesRead ?? 0; + const gesamt = state?.totalPages ?? 0; + const bekannt = gesamt > 0; + const anteil = bekannt ? Math.min(100, Math.round((gelesen / gesamt) * 100)) : 0; + const letzte = state?.log.slice(-6) ?? []; return ( - -
- - {thread.title} -
- von {thread.authorName ?? 'unbekannt'} - {thread.player ? ` · ${thread.player.displayName}` : ' · kein Spieler zugeordnet'} - +
+
+ + {bekannt + ? `${gelesen} von ${gesamt} Seiten gelesen` + : `Umfang wird ermittelt … (${gelesen} Seiten)`} + + + {state?.currentBoard + ? `liest ${BOARD_PFAD[state.currentBoard] ?? state.currentBoard}` + : 'wird gespeichert'} + {bekannt && ` · ${anteil} %`} + +
-
- {( - [ - ['NEW_CC', 'Angenommen - neuer CC', 'verbraucht 1 CC-Guthaben'], - ['REDESIGN', 'Angenommen - Redesign', 'verbraucht 1 Redesign-Guthaben'], - ['REACTIVATION', 'Angenommen - Reaktivierung', 'ein inaktiver CC kehrt zurück'], - ['REJECTED', 'Abgelehnt', 'keine Buchung'], - ['IGNORE', 'Kein Antrag', 'keine Buchung'], - ] as const - ).map(([value, label, hint]) => ( - +
+
+
+ + {letzte.length > 0 && ( +
    + {letzte.map((zeile, index) => ( +
  • {zeile}
    • ))} -
+ + )} - {needsPlayer && !thread.playerId && ( - - Ohne zugeordneten Spieler lässt sich nichts buchen. Bitte erst „Spieler zuordnen". - - )} - - {needsName && thread.playerId && ( - <> - - setName(event.target.value)} - required - /> -

Vorbelegt mit dem Thread-Titel - bitte anpassen.

- - )} - - {choice === 'REACTIVATION' && thread.playerId && ( - <> - - - {inactive.length === 0 && ( -

Dieser Spieler hat keine inaktiven CCs.

- )} - - {gewaehlterCC && !reaktivierungKostet && ( - - Kommt gratis zurück - der CC existiert unverändert weiter. - - )} - - {reaktivierungKostet && ( - <> - - Dieser CC wurde redesignt und existiert im Original nicht mehr. Die Rückkehr - kostet ein Guthaben. - - -
- - -
- - )} - - )} - - {choice === 'REDESIGN' && thread.playerId && ( - <> - - - {characters.length === 0 && ( -

Dieser Spieler hat keine aktiven CCs.

- )} - - -
- - -
- - )} - -
- - -
- - - ); -} - -function AssignModal({ - thread, - onClose, - onDone, - onError, -}: { - thread: ForumThread; - onClose: () => void; - onDone: () => void; - onError: (message: string) => void; -}) { - const [query, setQuery] = useState(thread.authorName ?? ''); - const [results, setResults] = useState([]); - - useEffect(() => { - const timer = setTimeout(async () => { - try { - const params = new URLSearchParams({ q: query, take: '20' }); - const data = await api<{ items: PlayerSummary[] }>(`/api/players?${params}`); - setResults(data.items); - } catch { - // Suchfehler blockieren den Dialog nicht. - } - }, 250); - return () => clearTimeout(timer); - }, [query]); - - const assign = async (playerId: number) => { - try { - await api(`/api/forum/threads/${thread.threadId}/player`, { - method: 'POST', - body: { playerId }, - }); - onDone(); - } catch (err) { - onError(err instanceof ApiError ? err.message : 'Zuordnen fehlgeschlagen'); - } - }; - - return ( - - - Forumsname des Antragstellers: {thread.authorName ?? 'unbekannt'}. Passt - kein Eintrag, trag den Forumsnamen beim Spieler nach - dann findet der nächste Abgleich - ihn von allein. - - - - setQuery(event.target.value)} - autoFocus - /> - -
    - {results.map((player) => ( -
  • -
    - {player.displayName} - {player.forumName && · Forum: {player.forumName}} -
    -
    - -
    -
    • - ))} - {results.length === 0 &&

    Kein Treffer.

    } -
- +

+ Zwischen den Abrufen wird bewusst gewartet, damit das Forum den Zugriff nicht bremst. Der + Lauf geht im Hintergrund weiter, auch wenn diese Seite geschlossen wird. +

+
); } diff --git a/web/src/pages/PlayerDetail.tsx b/web/src/pages/PlayerDetail.tsx index 8831b3f..d163fc3 100644 --- a/web/src/pages/PlayerDetail.tsx +++ b/web/src/pages/PlayerDetail.tsx @@ -3,6 +3,8 @@ import { Link, useNavigate, useParams } from 'react-router-dom'; import BalanceCards from '../components/BalanceCards'; import UnmatchedBox from '../components/UnmatchedBox'; import AliasBox from '../components/AliasBox'; +import PendingRowsBox from '../components/PendingRowsBox'; +import ThreadsBox from '../components/ThreadsBox'; import Modal from '../components/Modal'; import Notice from '../components/Notice'; import { ApiError, api } from '../lib/api'; @@ -231,6 +233,17 @@ export default function PlayerDetail() { onResolved={() => void load()} /> + void load()} + onError={setError} + onFlash={(text) => { + setFlash(text); + window.setTimeout(() => setFlash(null), 6000); + }} + /> + {editor && (