From 83c9afca90e4387427e83499fabcefd18c0d8137 Mon Sep 17 00:00:00 2001 From: Sucukdeluxe Date: Sat, 15 Aug 2026 04:23:14 +0200 Subject: [PATCH] feat(statistics): persist ranges and align history columns Persist per-day download volume, outcomes, active transfer time, and provider results so today, seven-day, and 30-day views use real partial-window data. Preserve existing all-time counters while extending totals with newly recorded result metrics. Rebuild the history table around one resizable persisted grid shared by headers and rows, with synchronized overflow and consistent alignment across window sizes. --- src/main/app-controller.ts | 10 +- src/main/backup-payload.ts | 13 +- src/main/download-manager.ts | 125 +++++-- src/main/statistics-ledger.ts | 340 ++++++++++++++++++ src/main/storage.ts | 6 +- src/renderer/views/history/HistoryView.tsx | 140 +++++++- src/renderer/views/history/history-model.ts | 38 ++ src/renderer/views/history/history.css | 115 +++--- .../views/statistics/StatisticsView.tsx | 21 +- .../views/statistics/statistics-model.ts | 106 +++--- src/shared/statistics-aggregation.ts | 66 ++++ src/shared/types.ts | 35 +- tests/backup-payload.test.ts | 15 +- tests/history-view.test.tsx | 48 ++- tests/statistics-ledger.test.ts | 163 +++++++++ tests/statistics-view.test.tsx | 99 +++-- tests/visual/fixtures.ts | 34 +- 17 files changed, 1157 insertions(+), 217 deletions(-) create mode 100644 src/main/statistics-ledger.ts create mode 100644 src/shared/statistics-aggregation.ts create mode 100644 tests/statistics-ledger.test.ts diff --git a/src/main/app-controller.ts b/src/main/app-controller.ts index 0be6d5c..04e6650 100644 --- a/src/main/app-controller.ts +++ b/src/main/app-controller.ts @@ -71,6 +71,7 @@ import type { DebugSetupCheckResult, SupportTraceConfig } from "../shared/types" import { createOnlineBackup, downloadOnlineBackup, uploadOnlineBackup } from "./online-backup"; import { overlayLiveUsageCounters } from "./settings-live-overlay"; import { getLegacyDesktopLogDirectory, migrateLogDirectories, prepareLogDirectory, resolveLogDirectory } from "./log-storage"; +import { normalizeStatisticsLedger, saveStatisticsLedger } from "./statistics-ledger"; function sanitizeSettingsPatch(partial: Partial): Partial { const entries = Object.entries(partial || {}).filter(([, value]) => value !== undefined); @@ -882,7 +883,8 @@ export class AppController { appVersion: APP_VERSION, exportedAt: new Date().toISOString(), session: this.manager.getSession(), - history: loadHistoryForRetention(this.storagePaths, this.settings.historyRetentionMode, this.historyLimits()), + history: loadHistoryForRetention(this.storagePaths, this.settings.historyRetentionMode, this.historyLimits()), + statistics: this.manager.getStats().statistics!, remoteDiagnostics }); const encrypted = encryptBackup(JSON.stringify(payloadObj), passphrase); @@ -1001,7 +1003,11 @@ export class AppController { const restoredSession = normalizeLoadedSessionTransientFields( normalizeLoadedSession(parsed.session) ); - saveSession(this.storagePaths, restoredSession); + saveSession(this.storagePaths, restoredSession); + + if (parsed.statistics) { + saveStatisticsLedger(this.storagePaths.statisticsFile, normalizeStatisticsLedger(parsed.statistics)); + } if (Array.isArray(parsed.history) && parsed.history.length > 0) { const normalizedHistory = (parsed.history as unknown[]) diff --git a/src/main/backup-payload.ts b/src/main/backup-payload.ts index 9abc2b4..fca4141 100644 --- a/src/main/backup-payload.ts +++ b/src/main/backup-payload.ts @@ -1,4 +1,4 @@ -import type { AppSettings, SessionState, HistoryEntry } from "../shared/types"; +import type { AppSettings, SessionState, HistoryEntry, StatisticsLedger } from "../shared/types"; export type BackupKind = "full" | "settings-only"; @@ -15,7 +15,8 @@ export interface BackupPayload { exportedAt: string; settings: AppSettings; session?: SessionState; - history?: HistoryEntry[]; + history?: HistoryEntry[]; + statistics?: StatisticsLedger; remoteDiagnostics?: BackupRemoteDiagnostics; } @@ -25,7 +26,8 @@ export interface BuildBackupInput { exportedAt: string; /** Only bundled when includeDownloads is true. */ session: SessionState; - history: HistoryEntry[]; + history: HistoryEntry[]; + statistics?: StatisticsLedger; remoteDiagnostics?: BackupRemoteDiagnostics; } @@ -46,7 +48,10 @@ export function buildBackupPayload(input: BuildBackupInput): BackupPayload { }; if (includeDownloads) { base.session = input.session; - base.history = input.history; + base.history = input.history; + if (input.statistics) { + base.statistics = input.statistics; + } } if (Boolean(input.settings.backupIncludeRemoteDiagnostics) && input.remoteDiagnostics) { base.remoteDiagnostics = sanitizeBackupRemoteDiagnostics(input.remoteDiagnostics); diff --git a/src/main/download-manager.ts b/src/main/download-manager.ts index eb0756f..862233e 100644 --- a/src/main/download-manager.ts +++ b/src/main/download-manager.ts @@ -17,8 +17,9 @@ import { PackageEntry, PackagePriority, ParsedPackageInput, - SessionState, - StartConflictEntry, + SessionState, + StatisticsLedger, + StartConflictEntry, StartConflictResolutionResult, UiSnapshot, DebridAccountStatus } from "../shared/types"; import { parseDebridLinkApiKeys } from "../shared/debrid-link-keys"; @@ -73,6 +74,16 @@ import { compactErrorText, ensureDirPath, filenameFromUrl, formatEta, humanSize, import { mergeKnownTotalBytes } from "./download-size"; import { DiskCapacityError, DiskReservationCoordinator, type DiskReservationLease } from "./disk-space"; import { createRendererState } from "./renderer-state"; +import { + addStatisticsActiveIntervalInPlace, + addStatisticsBytesInPlace, + addStatisticsOutcomeInPlace, + createStatisticsLedger, + loadStatisticsLedger, + normalizeStatisticsLedger, + saveStatisticsLedger, + seedStatisticsDayProviderBytes +} from "./statistics-ledger"; type ActiveTask = { itemId: string; @@ -1769,7 +1780,19 @@ export class DownloadManager extends EventEmitter { private statsCache: DownloadStats | null = null; - private statsCacheAt = 0; + private statsCacheAt = 0; + + private statisticsLedger: StatisticsLedger; + + private statisticsDirty = false; + + private statisticsUrgent = false; + + private lastStatisticsPersistAt = 0; + + private statisticsActivityAt = 0; + + private statisticsActivityWasActive = false; private settingsSnapshotCache: ReturnType | null = null; private settingsSnapshotCacheAt = 0; @@ -1898,7 +1921,12 @@ export class DownloadManager extends EventEmitter { this.runtimePersistedAt = startedAt; this.session = session; this.itemCount = Object.keys(this.session.items).length; - this.storagePaths = storagePaths; + this.storagePaths = storagePaths; + this.statisticsLedger = seedStatisticsDayProviderBytes( + loadStatisticsLedger(storagePaths.statisticsFile, startedAt), + settings.providerDailyUsageBytes, + startedAt + ); this.protectAgainstEmptyClobber = Boolean(options.protectEmptyClobber); if (this.protectAgainstEmptyClobber) { logger.warn("Session-Schutz aktiv: Start mit unlesbarer Session — leere Speicherungen blockiert, bis echte Daten vorliegen"); @@ -2544,8 +2572,9 @@ export class DownloadManager extends EventEmitter { sessionStartedAt: this.session.runStartedAt, appSessionStartedAt: this.appSessionStartedAt, sessionRuntimeMs: this.getAppSessionRuntimeMs(now), - totalRuntimeMs: this.getLiveTotalRuntimeMs(now), - runtimeMeasuredAt: now + totalRuntimeMs: this.getLiveTotalRuntimeMs(now), + runtimeMeasuredAt: now, + statistics: normalizeStatisticsLedger(this.statisticsLedger, now) }; this.statsCache = stats; this.statsCacheAt = now; @@ -2744,11 +2773,15 @@ export class DownloadManager extends EventEmitter { this.emitState(true); } - public resetDownloadStats(): void { + public resetDownloadStats(): void { this.settings.totalDownloadedAllTime = 0; this.settings.totalCompletedFilesAllTime = 0; this.settings.providerTotalUsageBytes = {}; - this.settings.debridLinkApiKeyTotalUsageBytes = {}; + this.settings.debridLinkApiKeyTotalUsageBytes = {}; + this.statisticsLedger = createStatisticsLedger(); + this.statisticsDirty = false; + this.statisticsUrgent = false; + saveStatisticsLedger(this.storagePaths.statisticsFile, this.statisticsLedger); this.lastSettingsPersistAt = nowMs(); saveSettings(this.storagePaths, this.settings); this.invalidateStatsCache(); @@ -5992,8 +6025,9 @@ export class DownloadManager extends EventEmitter { this.emitState(true); } - public prepareForShutdown(): void { - logger.info(`Shutdown-Vorbereitung gestartet: active=${this.activeTasks.size}, running=${this.session.running}, paused=${this.session.paused}`); + public prepareForShutdown(): void { + logger.info(`Shutdown-Vorbereitung gestartet: active=${this.activeTasks.size}, running=${this.session.running}, paused=${this.session.paused}`); + this.updateStatisticsActivity(nowMs()); this.rotationListenerActive = false; this.clearPersistTimer(); if (this.stateEmitTimer) { @@ -6070,7 +6104,8 @@ export class DownloadManager extends EventEmitter { if (!this.guardBlocksSessionSave()) { saveSession(this.storagePaths, this.session); } - saveSettings(this.storagePaths, this.settings); + saveSettings(this.storagePaths, this.settings); + saveStatisticsLedger(this.storagePaths.statisticsFile, this.statisticsLedger); } else { logger.info(`Shutdown-Save übersprungen: skipShutdownPersist=${this.skipShutdownPersist}, blockAllPersistence=${this.blockAllPersistence}`); } @@ -6398,11 +6433,22 @@ export class DownloadManager extends EventEmitter { if (!this.guardBlocksSessionSave()) { void saveSessionAsync(this.storagePaths, this.session).catch((err) => logger.warn(`saveSessionAsync Fehler: ${compactErrorText(err)}`)); } - if (now - this.lastSettingsPersistAt >= 30000) { + if (now - this.lastSettingsPersistAt >= 30000) { this.foldRuntimeIntoSettings(now); this.lastSettingsPersistAt = now; - void saveSettingsAsync(this.storagePaths, this.settings).catch((err) => logger.warn(`saveSettingsAsync Fehler: ${compactErrorText(err as Error)}`)); - } + void saveSettingsAsync(this.storagePaths, this.settings).catch((err) => logger.warn(`saveSettingsAsync Fehler: ${compactErrorText(err as Error)}`)); + } + if (this.statisticsDirty && (this.statisticsUrgent || now - this.lastStatisticsPersistAt >= 10000)) { + this.lastStatisticsPersistAt = now; + this.statisticsDirty = false; + this.statisticsUrgent = false; + try { + saveStatisticsLedger(this.storagePaths.statisticsFile, this.statisticsLedger); + } catch (error) { + this.statisticsDirty = true; + logger.warn(`Statistik konnte nicht gespeichert werden: ${compactErrorText(error)}`); + } + } } public persistNowSync(): void { @@ -6414,7 +6460,8 @@ export class DownloadManager extends EventEmitter { if (!this.guardBlocksSessionSave()) { saveSession(this.storagePaths, this.session); } - saveSettings(this.storagePaths, this.settings); + saveSettings(this.storagePaths, this.settings); + saveStatisticsLedger(this.storagePaths.statisticsFile, this.statisticsLedger); } private emitState(force = false): void { @@ -6507,8 +6554,15 @@ export class DownloadManager extends EventEmitter { if (!this.runItemIds.has(itemId)) { return; } - const previous = this.runOutcomes.get(itemId); - this.runOutcomes.set(itemId, status); + const previous = this.runOutcomes.get(itemId); + this.runOutcomes.set(itemId, status); + const item = this.session.items[itemId]; + const provider = item?.provider ? resolveMegaDebridProvider(this.settings, item.provider) : null; + if ((status === "completed" || status === "failed") && previous !== status) { + addStatisticsOutcomeInPlace(this.statisticsLedger, provider, status); + this.statisticsDirty = true; + this.statisticsUrgent = true; + } if (status === "completed" && previous !== "completed") { this.sessionCompletedFiles += 1; this.settings.totalCompletedFilesAllTime = Math.max(0, Number(this.settings.totalCompletedFilesAllTime || 0)) + 1; @@ -8105,7 +8159,9 @@ export class DownloadManager extends EventEmitter { if (!provider) { return; } - const effectiveProvider = resolveMegaDebridProvider(this.settings, provider) || provider; + const effectiveProvider = resolveMegaDebridProvider(this.settings, provider) || provider; + addStatisticsBytesInPlace(this.statisticsLedger, effectiveProvider, byteDelta); + this.statisticsDirty = true; const nextUsage = addProviderDailyUsageBytes(this.settings, effectiveProvider, byteDelta); const nextTotalUsage = addProviderTotalUsageBytes(this.settings, effectiveProvider, byteDelta); this.settings.providerDailyUsageDay = nextUsage.providerDailyUsageDay; @@ -8169,6 +8225,17 @@ export class DownloadManager extends EventEmitter { return false; } + private updateStatisticsActivity(now: number): void { + if (this.statisticsActivityAt > 0 && this.statisticsActivityWasActive && now > this.statisticsActivityAt) { + addStatisticsActiveIntervalInPlace(this.statisticsLedger, this.statisticsActivityAt, now); + this.statisticsDirty = true; + } + this.statisticsActivityAt = now; + this.statisticsActivityWasActive = this.session.running + && !this.session.paused + && [...this.activeTasks.values()].some((task) => this.session.items[task.itemId]?.status === "downloading"); + } + private hasUsableDownloadAccount(): boolean { return DOWNLOAD_ACCOUNT_PROVIDERS.some((provider) => this.isProviderConfigured(provider)); } @@ -8590,8 +8657,9 @@ export class DownloadManager extends EventEmitter { const myGeneration = this.schedulerGeneration; logger.info(`Scheduler gestartet (gen=${myGeneration})`); try { - while (this.session.running && this.schedulerGeneration === myGeneration) { - const now = nowMs(); + while (this.session.running && this.schedulerGeneration === myGeneration) { + const now = nowMs(); + this.updateStatisticsActivity(now); if (now - this.lastSchedulerHeartbeatAt >= 60000) { this.lastSchedulerHeartbeatAt = now; logger.info(`Scheduler Heartbeat: active=${this.activeTasks.size}, queued=${this.countQueuedItems()}, reconnect=${this.reconnectActive()}, paused=${this.session.paused}, postProcess=${this.packagePostProcessTasks.size}`); @@ -8624,10 +8692,12 @@ export class DownloadManager extends EventEmitter { if (!next) { break; } - this.startItem(next.packageId, next.itemId); - } - - this.runGlobalStallWatchdog(now); + this.startItem(next.packageId, next.itemId); + } + + this.updateStatisticsActivity(nowMs()); + + this.runGlobalStallWatchdog(now); const queuePresence = this.activeTasks.size === 0 ? this.getQueuePresence(now) : { hasImmediate: true, hasDelayed: false }; const downloadsComplete = this.activeTasks.size === 0 && !queuePresence.hasImmediate && !queuePresence.hasDelayed; @@ -8640,9 +8710,10 @@ export class DownloadManager extends EventEmitter { const maxParallel = Math.max(1, this.settings.maxParallel); const schedulerSleepMs = this.activeTasks.size >= maxParallel ? 170 : 120; await sleep(schedulerSleepMs); - } - } finally { - this.scheduleRunning = false; + } + } finally { + this.updateStatisticsActivity(nowMs()); + this.scheduleRunning = false; logger.info(`Scheduler beendet (gen=${myGeneration})`); // Stop->Start race: a new run can begin while this loop sleeps (start()'s // ensureScheduler early-returns on scheduleRunning, then this loop exits on diff --git a/src/main/statistics-ledger.ts b/src/main/statistics-ledger.ts new file mode 100644 index 0000000..ff696f7 --- /dev/null +++ b/src/main/statistics-ledger.ts @@ -0,0 +1,340 @@ +import fs from "node:fs"; +import fsp from "node:fs/promises"; +import path from "node:path"; +import { getProviderUsageDayKey } from "../shared/provider-daily-limits"; +import type { + DebridProvider, + StatisticsDayBucket, + StatisticsLedger, + StatisticsProviderBucket +} from "../shared/types"; +export { aggregateStatisticsRange } from "../shared/statistics-aggregation"; + +const providers = new Set([ + "realdebrid", + "megadebrid", + "megadebrid-api", + "megadebrid-web", + "bestdebrid", + "alldebrid", + "ddownload", + "onefichier", + "debridlink", + "linksnappy" +]); + +const renameRetryDelaysMs = [15, 40, 90]; + +function finiteNonNegative(value: unknown): number { + const number = Number(value); + return Number.isFinite(number) ? Math.max(0, Math.floor(number)) : 0; +} + +function asRecord(value: unknown): Record | null { + return value && typeof value === "object" && !Array.isArray(value) + ? value as Record + : null; +} + +function emptyProviderBucket(): StatisticsProviderBucket { + return { bytes: 0, completed: 0, failed: 0 }; +} + +function emptyDay(day: string): StatisticsDayBucket { + return { + day, + downloadedBytes: 0, + measuredBytes: 0, + completedFiles: 0, + failedFiles: 0, + activeDownloadMs: 0, + providers: {} + }; +} + +function normalizeProviderBucket(value: unknown): StatisticsProviderBucket { + const record = asRecord(value); + return { + bytes: finiteNonNegative(record?.bytes), + completed: finiteNonNegative(record?.completed), + failed: finiteNonNegative(record?.failed) + }; +} + +function normalizeDay(value: unknown): StatisticsDayBucket | null { + const record = asRecord(value); + const day = String(record?.day || ""); + if (!/^\d{4}-\d{2}-\d{2}$/.test(day)) { + return null; + } + const rawProviders = asRecord(record?.providers); + const normalizedProviders: Partial> = {}; + for (const [provider, bucket] of Object.entries(rawProviders ?? {})) { + if (providers.has(provider as DebridProvider)) { + normalizedProviders[provider as DebridProvider] = normalizeProviderBucket(bucket); + } + } + return { + day, + downloadedBytes: finiteNonNegative(record?.downloadedBytes), + measuredBytes: finiteNonNegative(record?.measuredBytes), + completedFiles: finiteNonNegative(record?.completedFiles), + failedFiles: finiteNonNegative(record?.failedFiles), + activeDownloadMs: finiteNonNegative(record?.activeDownloadMs), + providers: normalizedProviders + }; +} + +export function createStatisticsLedger(now = Date.now()): StatisticsLedger { + return { version: 1, startedAt: now, days: [] }; +} + +export function normalizeStatisticsLedger(value: unknown, now = Date.now()): StatisticsLedger { + const record = asRecord(value); + if (!record) { + return createStatisticsLedger(now); + } + const byDay = new Map(); + for (const value of Array.isArray(record.days) ? record.days : []) { + const day = normalizeDay(value); + if (day) { + byDay.set(day.day, day); + } + } + return { + version: 1, + startedAt: finiteNonNegative(record.startedAt) || now, + days: [...byDay.values()].sort((left, right) => left.day.localeCompare(right.day)) + }; +} + +function updateDay( + ledger: StatisticsLedger, + epochMs: number, + update: (day: StatisticsDayBucket) => void +): StatisticsLedger { + const normalized = normalizeStatisticsLedger(ledger, epochMs); + const key = getProviderUsageDayKey(epochMs); + const days = normalized.days.map((day) => ({ ...day, providers: { ...day.providers } })); + let day = days.find((entry) => entry.day === key); + if (!day) { + day = emptyDay(key); + days.push(day); + days.sort((left, right) => left.day.localeCompare(right.day)); + } + update(day); + return { ...normalized, days }; +} + +function mutableDay(ledger: StatisticsLedger, epochMs: number): StatisticsDayBucket { + const key = getProviderUsageDayKey(epochMs); + let day = ledger.days.find((entry) => entry.day === key); + if (!day) { + day = emptyDay(key); + ledger.days.push(day); + ledger.days.sort((left, right) => left.day.localeCompare(right.day)); + } + return day; +} + +export function seedStatisticsDayProviderBytes( + ledger: StatisticsLedger, + usage: Partial>, + epochMs = Date.now() +): StatisticsLedger { + return updateDay(ledger, epochMs, (day) => { + for (const [provider, rawBytes] of Object.entries(usage) as Array<[DebridProvider, number | undefined]>) { + if (!providers.has(provider)) continue; + const bytes = finiteNonNegative(rawBytes); + const existing = day.providers[provider] ?? emptyProviderBucket(); + existing.bytes = Math.max(existing.bytes, bytes); + day.providers[provider] = existing; + } + day.downloadedBytes = Math.max( + day.downloadedBytes, + Object.values(day.providers).reduce((total, bucket) => total + finiteNonNegative(bucket?.bytes), 0) + ); + }); +} + +export function recordStatisticsBytes( + ledger: StatisticsLedger, + provider: DebridProvider, + byteDelta: number, + epochMs = Date.now() +): StatisticsLedger { + const bytes = finiteNonNegative(byteDelta); + if (bytes <= 0 || !providers.has(provider)) { + return normalizeStatisticsLedger(ledger, epochMs); + } + return updateDay(ledger, epochMs, (day) => { + day.downloadedBytes += bytes; + day.measuredBytes += bytes; + const bucket = day.providers[provider] ?? emptyProviderBucket(); + bucket.bytes += bytes; + day.providers[provider] = bucket; + }); +} + +export function addStatisticsBytesInPlace( + ledger: StatisticsLedger, + provider: DebridProvider, + byteDelta: number, + epochMs = Date.now() +): void { + const bytes = finiteNonNegative(byteDelta); + if (bytes <= 0 || !providers.has(provider)) return; + const day = mutableDay(ledger, epochMs); + day.downloadedBytes += bytes; + day.measuredBytes += bytes; + const bucket = day.providers[provider] ?? emptyProviderBucket(); + bucket.bytes += bytes; + day.providers[provider] = bucket; +} + +export function recordStatisticsOutcome( + ledger: StatisticsLedger, + provider: DebridProvider | null | undefined, + outcome: "completed" | "failed", + epochMs = Date.now() +): StatisticsLedger { + return updateDay(ledger, epochMs, (day) => { + if (outcome === "completed") { + day.completedFiles += 1; + } else { + day.failedFiles += 1; + } + if (!provider || !providers.has(provider)) { + return; + } + const bucket = day.providers[provider] ?? emptyProviderBucket(); + bucket[outcome] += 1; + day.providers[provider] = bucket; + }); +} + +export function addStatisticsOutcomeInPlace( + ledger: StatisticsLedger, + provider: DebridProvider | null | undefined, + outcome: "completed" | "failed", + epochMs = Date.now() +): void { + const day = mutableDay(ledger, epochMs); + day[outcome === "completed" ? "completedFiles" : "failedFiles"] += 1; + if (!provider || !providers.has(provider)) return; + const bucket = day.providers[provider] ?? emptyProviderBucket(); + bucket[outcome] += 1; + day.providers[provider] = bucket; +} + +function startOfNextLocalDay(epochMs: number): number { + const date = new Date(epochMs); + date.setHours(24, 0, 0, 0); + return date.getTime(); +} + +export function recordStatisticsActiveInterval( + ledger: StatisticsLedger, + startMs: number, + endMs: number +): StatisticsLedger { + let next = normalizeStatisticsLedger(ledger, startMs); + let cursor = finiteNonNegative(startMs); + const end = finiteNonNegative(endMs); + while (cursor < end) { + const boundary = Math.min(end, startOfNextLocalDay(cursor)); + const duration = Math.max(0, boundary - cursor); + next = updateDay(next, cursor, (day) => { + day.activeDownloadMs += duration; + }); + cursor = boundary; + } + return next; +} + +export function addStatisticsActiveIntervalInPlace( + ledger: StatisticsLedger, + startMs: number, + endMs: number +): void { + let cursor = finiteNonNegative(startMs); + const end = finiteNonNegative(endMs); + while (cursor < end) { + const boundary = Math.min(end, startOfNextLocalDay(cursor)); + mutableDay(ledger, cursor).activeDownloadMs += Math.max(0, boundary - cursor); + cursor = boundary; + } +} + +export function loadStatisticsLedger(filePath: string, now = Date.now()): StatisticsLedger { + try { + if (!fs.existsSync(filePath)) { + return createStatisticsLedger(now); + } + return normalizeStatisticsLedger(JSON.parse(fs.readFileSync(filePath, "utf8")), now); + } catch { + return createStatisticsLedger(now); + } +} + +function statisticsPayload(ledger: StatisticsLedger): string { + return JSON.stringify(normalizeStatisticsLedger(ledger), null, 2); +} + +function renameErrorCode(error: unknown): string { + return error && typeof error === "object" && "code" in error + ? String((error as NodeJS.ErrnoException).code || "") + : ""; +} + +function isTransientRenameError(error: unknown): boolean { + return ["EPERM", "EACCES", "EBUSY"].includes(renameErrorCode(error)); +} + +function renameStatisticsFileSync(tempPath: string, filePath: string): void { + for (let attempt = 0; ; attempt += 1) { + try { + fs.renameSync(tempPath, filePath); + return; + } catch (error) { + if (!isTransientRenameError(error) || attempt >= renameRetryDelaysMs.length) throw error; + Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, renameRetryDelaysMs[attempt]); + } + } +} + +async function renameStatisticsFile(tempPath: string, filePath: string): Promise { + for (let attempt = 0; ; attempt += 1) { + try { + await fsp.rename(tempPath, filePath); + return; + } catch (error) { + if (!isTransientRenameError(error) || attempt >= renameRetryDelaysMs.length) throw error; + await new Promise((resolve) => setTimeout(resolve, renameRetryDelaysMs[attempt])); + } + } +} + +export function saveStatisticsLedger(filePath: string, ledger: StatisticsLedger): void { + fs.mkdirSync(path.dirname(filePath), { recursive: true }); + const tempPath = `${filePath}.tmp`; + try { + fs.writeFileSync(tempPath, statisticsPayload(ledger), "utf8"); + renameStatisticsFileSync(tempPath, filePath); + } catch (error) { + try { fs.rmSync(tempPath, { force: true }); } catch {} + throw error; + } +} + +export async function saveStatisticsLedgerAsync(filePath: string, ledger: StatisticsLedger): Promise { + await fsp.mkdir(path.dirname(filePath), { recursive: true }); + const tempPath = `${filePath}.async.tmp`; + try { + await fsp.writeFile(tempPath, statisticsPayload(ledger), "utf8"); + await renameStatisticsFile(tempPath, filePath); + } catch (error) { + try { await fsp.rm(tempPath, { force: true }); } catch {} + throw error; + } +} diff --git a/src/main/storage.ts b/src/main/storage.ts index 0c1b1ff..8cfeddb 100644 --- a/src/main/storage.ts +++ b/src/main/storage.ts @@ -632,7 +632,8 @@ export interface StoragePaths { baseDir: string; configFile: string; sessionFile: string; - historyFile: string; + historyFile: string; + statisticsFile: string; } export function createStoragePaths(baseDir: string): StoragePaths { @@ -640,7 +641,8 @@ export function createStoragePaths(baseDir: string): StoragePaths { baseDir, configFile: path.join(baseDir, "rd_downloader_config.json"), sessionFile: path.join(baseDir, "rd_session_state.json"), - historyFile: path.join(baseDir, "rd_history.json") + historyFile: path.join(baseDir, "rd_history.json"), + statisticsFile: path.join(baseDir, "rd_statistics.json") }; } diff --git a/src/renderer/views/history/HistoryView.tsx b/src/renderer/views/history/HistoryView.tsx index 1e2796b..4601aa5 100644 --- a/src/renderer/views/history/HistoryView.tsx +++ b/src/renderer/views/history/HistoryView.tsx @@ -1,4 +1,13 @@ -import { useEffect, useState, type ChangeEvent, type MouseEvent, type ReactElement } from "react"; +import { + useEffect, + useState, + type ChangeEvent, + type KeyboardEvent, + type MouseEvent, + type PointerEvent, + type ReactElement, + type UIEvent +} from "react"; import { DataTable, DataTableBody, @@ -7,7 +16,20 @@ import { } from "../../ui/DataTable"; import { Toolbar, ToolbarGroup, ToolbarSearch } from "../../ui/Toolbar"; import { SlidingSelection } from "../../ui/SlidingSelection"; -import { paginateHistoryRows, type HistoryFilter, type HistoryPage, type HistoryRow, type HistoryViewModel } from "./history-model"; +import { + createHistoryTableColumnWidths, + getHistoryTableGridTemplate, + getHistoryTableMinWidth, + HISTORY_TABLE_COLUMN_IDS, + paginateHistoryRows, + resizeHistoryTableColumn, + type HistoryFilter, + type HistoryPage, + type HistoryRow, + type HistoryTableColumnId, + type HistoryTableColumnWidths, + type HistoryViewModel +} from "./history-model"; import "./history.css"; export interface HistoryViewActions { @@ -29,7 +51,7 @@ export interface HistoryViewProps { actions: HistoryViewActions; } -const filterItems: Array<{ id: HistoryFilter; label: string }> = [ +const filterItems: Array<{ id: HistoryFilter; label: string }> = [ { id: "all", label: "Alle Einträge" }, { id: "today", label: "Heute" }, { id: "week", label: "Letzte 7 Tage" }, @@ -37,11 +59,51 @@ const filterItems: Array<{ id: HistoryFilter; label: string }> = [ { id: "completed", label: "Fertig" }, { id: "deleted", label: "Gelöscht" }, { id: "failed", label: "Fehlgeschlagen" } -]; +]; + +const HISTORY_TABLE_COLUMNS = ["Paket / Datei", "Status", "Größe", "Hoster", "Gestartet", "Beendet"] as const; +const HISTORY_TABLE_COLUMN_STORAGE_KEY = "mdd.history-table-columns.v1"; +let historyTableResizeSession: { column: HistoryTableColumnId; startX: number; initial: HistoryTableColumnWidths } | null = null; + +function loadHistoryTableColumnWidths(): HistoryTableColumnWidths { + try { + const stored = typeof window === "undefined" ? null : window.localStorage.getItem(HISTORY_TABLE_COLUMN_STORAGE_KEY); + return createHistoryTableColumnWidths(stored ? JSON.parse(stored) : undefined); + } catch { + return createHistoryTableColumnWidths(); + } +} + +function applyHistoryTableColumnWidths(source: HTMLElement, widths: HistoryTableColumnWidths): void { + const table = source.closest(".history-table"); + if (!table) return; + const template = getHistoryTableGridTemplate(widths); + const minWidth = `${getHistoryTableMinWidth(widths)}px`; + table.querySelectorAll(".history-table-header-row, .history-row, .history-detail-row").forEach((row) => { + if (!row.classList.contains("history-detail-row")) { + row.style.gridTemplateColumns = template; + } + row.style.minWidth = minWidth; + }); +} + +function persistHistoryTableColumnWidths(widths: HistoryTableColumnWidths): void { + try { + window.localStorage.setItem(HISTORY_TABLE_COLUMN_STORAGE_KEY, JSON.stringify(widths)); + } catch { + } +} + +function syncHistoryTableScroll(event: UIEvent): void { + const header = event.currentTarget.parentElement?.querySelector(".history-table-header"); + if (header) { + header.scrollLeft = event.currentTarget.scrollLeft; + } +} -function HistoryRowDetails({ row }: { row: HistoryRow }): ReactElement { +function HistoryRowDetails({ row, minWidth }: { row: HistoryRow; minWidth: number }): ReactElement { return ( -
+
Provider
{row.providerLabel}
@@ -159,18 +221,47 @@ export function HistoryContentPage({ model, actions, page, onPageChange }: Histo const emptyTitle = model.totalCount === 0 && !model.query && model.filter === "all" ? "Noch kein Verlauf" : "Keine passenden Einträge"; - const announcement = model.loading + const announcement = model.loading ? { role: "status" as const, live: "polite" as const, message: "Verlauf wird geladen. Die gespeicherten Einträge werden geladen." } : model.error ? { role: "alert" as const, live: "assertive" as const, message: `${model.error}. Öffne die Ansicht erneut, um es noch einmal zu versuchen.` } - : null; + : null; + const columnWidths = loadHistoryTableColumnWidths(); + const gridTemplateColumns = getHistoryTableGridTemplate(columnWidths); + const minWidth = getHistoryTableMinWidth(columnWidths); + const beginResize = (event: PointerEvent, column: HistoryTableColumnId): void => { + event.preventDefault(); + event.stopPropagation(); + event.currentTarget.setPointerCapture?.(event.pointerId); + historyTableResizeSession = { column, startX: event.clientX, initial: loadHistoryTableColumnWidths() }; + }; + const continueResize = (event: PointerEvent): void => { + const active = historyTableResizeSession; + if (!active) return; + const next = resizeHistoryTableColumn(active.initial, active.column, event.clientX - active.startX); + applyHistoryTableColumnWidths(event.currentTarget, next); + persistHistoryTableColumnWidths(next); + }; + const finishResize = (event: PointerEvent): void => { + if (!historyTableResizeSession) return; + event.currentTarget.releasePointerCapture?.(event.pointerId); + historyTableResizeSession = null; + }; + const resizeWithKeyboard = (event: KeyboardEvent, column: HistoryTableColumnId): void => { + if (event.key !== "ArrowLeft" && event.key !== "ArrowRight") return; + event.preventDefault(); + event.stopPropagation(); + const next = resizeHistoryTableColumn(loadHistoryTableColumnWidths(), column, event.key === "ArrowRight" ? 16 : -16); + applyHistoryTableColumnWidths(event.currentTarget, next); + persistHistoryTableColumnWidths(next); + }; return (

Verlauf

-
+
- Paket / Datei - Status - Größe - Hoster - Gestartet - Beendet + {HISTORY_TABLE_COLUMNS.map((column, index) => ( + + {column} +
- + {model.loading ? ( ) : model.error ? ( @@ -212,7 +315,8 @@ export function HistoryContentPage({ model, actions, page, onPageChange }: Histo className={`history-row${isSelected ? " is-selected" : ""}`} data-history-row-id={row.id} onContextMenu={onContextMenu} - role="row" + role="row" + style={{ gridTemplateColumns, minWidth }} > ⋮
- {isExpanded ? : null} + {isExpanded ? : null}
); }) diff --git a/src/renderer/views/history/history-model.ts b/src/renderer/views/history/history-model.ts index 817497f..81cf4fa 100644 --- a/src/renderer/views/history/history-model.ts +++ b/src/renderer/views/history/history-model.ts @@ -49,6 +49,44 @@ export interface HistoryPage { export const HISTORY_PAGE_SIZE = 100; +export const HISTORY_TABLE_COLUMN_IDS = ["name", "status", "size", "hoster", "started", "completed"] as const; +export type HistoryTableColumnId = typeof HISTORY_TABLE_COLUMN_IDS[number]; +export type HistoryTableColumnWidths = Record; + +const HISTORY_TABLE_COLUMN_LIMITS: Record = { + name: { initial: 320, min: 220, max: 680 }, + status: { initial: 150, min: 120, max: 280 }, + size: { initial: 190, min: 140, max: 320 }, + hoster: { initial: 180, min: 120, max: 360 }, + started: { initial: 185, min: 150, max: 280 }, + completed: { initial: 185, min: 150, max: 280 } +}; + +export function createHistoryTableColumnWidths(value?: unknown): HistoryTableColumnWidths { + const raw = value && typeof value === "object" && !Array.isArray(value) ? value as Record : {}; + return Object.fromEntries(HISTORY_TABLE_COLUMN_IDS.map((id) => { + const limits = HISTORY_TABLE_COLUMN_LIMITS[id]; + const candidate = typeof raw[id] === "number" && Number.isFinite(raw[id]) ? Math.round(raw[id]) : limits.initial; + return [id, Math.max(limits.min, Math.min(limits.max, candidate))]; + })) as HistoryTableColumnWidths; +} + +export function resizeHistoryTableColumn( + widths: HistoryTableColumnWidths, + column: HistoryTableColumnId, + delta: number +): HistoryTableColumnWidths { + return createHistoryTableColumnWidths({ ...widths, [column]: widths[column] + delta }); +} + +export function getHistoryTableGridTemplate(widths: HistoryTableColumnWidths): string { + return `48px ${HISTORY_TABLE_COLUMN_IDS.map((id) => `${widths[id]}px`).join(" ")} minmax(72px, 1fr)`; +} + +export function getHistoryTableMinWidth(widths: HistoryTableColumnWidths): number { + return 48 + 72 + HISTORY_TABLE_COLUMN_IDS.reduce((sum, id) => sum + widths[id], 0); +} + const providerLabels: Record = { realdebrid: "Real-Debrid", megadebrid: "Mega-Debrid", diff --git a/src/renderer/views/history/history.css b/src/renderer/views/history/history.css index 635319a..41c1762 100644 --- a/src/renderer/views/history/history.css +++ b/src/renderer/views/history/history.css @@ -145,25 +145,21 @@ width: 1px; } -.history-content .history-table { +.history-content .history-table { height: 100%; min-height: 0; - overflow: auto; + overflow: hidden; } .history-table-header-row, .history-row { align-items: center; - display: grid; - grid-template-columns: 48px minmax(190px, 1.45fr) minmax(112px, 0.75fr) minmax(150px, 1fr) minmax(130px, 0.9fr) minmax(135px, 0.9fr) minmax(135px, 0.9fr) 72px; - min-width: 1080px; -} + display: grid; +} .history-table > .history-table-header { height: 41px; - position: sticky; - top: 0; - z-index: 1; + overflow: hidden; } .history-table-header-row { @@ -175,12 +171,21 @@ text-transform: uppercase; } -.history-table-header-row > span { +.history-table-header-row > span, +.history-row > span { + text-align: left; +} + +.history-table-header-row > span:first-child, +.history-table-header-row > span:last-child, +.history-row > span:first-child, +.history-row > span:last-child { text-align: center; } -.history-table-header-row > span:nth-child(2) { - text-align: left; +.history-table-header-row > span:nth-child(4), +.history-row > span:nth-child(4) { + text-align: right; } .history-table-header-row > span, @@ -189,13 +194,57 @@ padding: 0 10px; } -.history-table > .history-table-body { - overflow: visible; -} - -.history-row-group { - min-width: 1080px; -} +.history-table > .history-table-body { + overflow: auto; +} + +.history-row-group { + min-width: 100%; + width: max-content; +} + +.history-resizable-header { + align-items: center; + display: flex; + height: 100%; + position: relative; +} + +.history-table-header-row > .history-resizable-header:nth-child(4) { + justify-content: flex-end; +} + +.history-column-resizer { + background: transparent; + border: 0; + bottom: 7px; + cursor: col-resize; + outline: 0; + padding: 0; + position: absolute; + right: -4px; + top: 7px; + touch-action: none; + width: 9px; + z-index: 2; +} + +.history-column-resizer::after { + background: var(--ui-border); + bottom: 0; + content: ""; + left: 4px; + opacity: 0; + position: absolute; + top: 0; + width: 1px; +} + +.history-column-resizer:hover::after, +.history-column-resizer:focus-visible::after { + background: var(--ui-accent); + opacity: 1; +} .history-row { border-bottom: 1px solid var(--ui-border); @@ -314,10 +363,9 @@ place-items: center; } -.history-detail-row { +.history-detail-row { border-bottom: 1px solid var(--ui-border); background: var(--ui-input); - min-width: 1080px; } .history-detail-cell { @@ -426,27 +474,4 @@ padding: 0 9px; } - .history-table-header-row, - .history-row { - grid-template-columns: 44px minmax(170px, 1.25fr) minmax(108px, 0.7fr) minmax(140px, 0.9fr) minmax(120px, 0.8fr) minmax(125px, 0.8fr) minmax(125px, 0.8fr) 64px; - min-width: 996px; - } - - .history-row-group, - .history-detail-row { - min-width: 996px; - } -} - -@media (max-width: 1120px) { - .history-table-header-row, - .history-row { - grid-template-columns: 44px minmax(154px, 1.2fr) minmax(102px, 0.7fr) minmax(128px, 0.9fr) minmax(112px, 0.8fr) minmax(116px, 0.8fr) minmax(116px, 0.8fr) 60px; - min-width: 932px; - } - - .history-row-group, - .history-detail-row { - min-width: 932px; - } -} +} diff --git a/src/renderer/views/statistics/StatisticsView.tsx b/src/renderer/views/statistics/StatisticsView.tsx index c609ce0..50524f6 100644 --- a/src/renderer/views/statistics/StatisticsView.tsx +++ b/src/renderer/views/statistics/StatisticsView.tsx @@ -66,9 +66,15 @@ function providerScopeLabel(scope: StatisticsProviderScope | null): string { if (scope === "current-queue") { return "Aktuelle Queue"; } - if (scope === "today") { - return "Heute"; - } + if (scope === "today") { + return "Heute"; + } + if (scope === "week") { + return "Sieben Tage"; + } + if (scope === "month") { + return "30 Tage"; + } if (scope === "all") { return "Gesamt"; } @@ -79,9 +85,12 @@ function emptyProviderMessage(model: StatisticsViewModel): string { if (model.coverage === "unavailable") { return model.message; } - if (model.providerScope === "today") { - return "Heute wurden noch keine Providerbytes erfasst."; - } + if (model.providerScope === "today") { + return "Heute wurden noch keine Providerbytes erfasst."; + } + if (model.providerScope === "week" || model.providerScope === "month") { + return "In diesem Zeitraum wurden noch keine Providerwerte erfasst."; + } if (model.providerScope === "all") { return "Noch keine gespeicherten Providerbytes vorhanden."; } diff --git a/src/renderer/views/statistics/statistics-model.ts b/src/renderer/views/statistics/statistics-model.ts index 571423c..1185b06 100644 --- a/src/renderer/views/statistics/statistics-model.ts +++ b/src/renderer/views/statistics/statistics-model.ts @@ -1,10 +1,10 @@ -import { getProviderUsageDayKey } from "../../../shared/provider-daily-limits"; -import type { DebridProvider, DownloadItem, DownloadSummary, UiSnapshot } from "../../../shared/types"; +import { aggregateStatisticsRange, type StatisticsAggregate } from "../../../shared/statistics-aggregation"; +import type { DebridProvider, DownloadItem, DownloadSummary, StatisticsProviderBucket, UiSnapshot } from "../../../shared/types"; export type StatisticsRange = "session" | "today" | "week" | "month" | "all"; export type StatisticsCoverage = "partial" | "unavailable"; export type StatisticsSessionState = "empty" | "idle" | "active" | "paused"; -export type StatisticsProviderScope = "current-queue" | "today" | "all"; +export type StatisticsProviderScope = "current-queue" | "today" | "week" | "month" | "all"; export type StatisticsMetricTone = "danger"; export interface StatisticsMetric { @@ -54,8 +54,6 @@ const providerLabels: Record = { linksnappy: "LinkSnappy" }; -const historicalUnavailableMessage = "Für diesen Zeitraum werden noch keine historischen Daten gespeichert."; - function normalizeNonNegative(value: number): number { return Number.isFinite(value) ? Math.max(0, value) : 0; } @@ -153,36 +151,53 @@ function deriveQueueProviders(items: DownloadItem[]): StatisticsProviderRow[] { return sortProviderRows([...providers.values()]); } -function deriveUsageProviders(usage: Partial>): StatisticsProviderRow[] { +function deriveUsageProviders( + usage: Partial>, + outcomes: Partial> = {} +): StatisticsProviderRow[] { const rows: StatisticsProviderRow[] = []; - for (const [id, rawBytes] of Object.entries(usage) as Array<[DebridProvider, number | undefined]>) { + const providerIds = new Set([ + ...(Object.keys(usage) as DebridProvider[]), + ...(Object.keys(outcomes) as DebridProvider[]) + ]); + for (const id of providerIds) { + const rawBytes = usage[id]; const bytes = normalizeNonNegative(rawBytes ?? 0); - if (bytes <= 0 || !providerLabels[id]) { + const completed = normalizeCount(outcomes[id]?.completed ?? 0); + const failed = normalizeCount(outcomes[id]?.failed ?? 0); + if ((bytes <= 0 && completed <= 0 && failed <= 0) || !providerLabels[id]) { continue; } rows.push({ id, label: providerLabels[id], bytes, - completed: null, - failed: null + completed, + failed }); } return sortProviderRows(rows); } -function sumProviderBytes(rows: StatisticsProviderRow[]): number { - return rows.reduce((total, row) => total + row.bytes, 0); +function aggregateMetrics(aggregate: StatisticsAggregate, sourceLabel: string): StatisticsMetrics { + return { + downloadedBytes: availableMetric(aggregate.downloadedBytes, sourceLabel), + files: availableMetric(aggregate.completedFiles, sourceLabel), + successRate: successRateMetric(aggregate.completedFiles, aggregate.failedFiles, sourceLabel), + averageSpeedBps: aggregate.averageSpeedBps === null + ? unavailableMetric("Noch keine aktive Downloadzeit mit übertragenen Daten erfasst") + : availableMetric(aggregate.averageSpeedBps, sourceLabel), + errors: availableMetric( + aggregate.failedFiles, + sourceLabel, + aggregate.failedFiles > 0 ? "danger" : undefined + ) + }; } -function buildUnavailableMetrics(): StatisticsMetrics { - return { - downloadedBytes: unavailableMetric(historicalUnavailableMessage), - files: unavailableMetric(historicalUnavailableMessage), - successRate: unavailableMetric(historicalUnavailableMessage), - averageSpeedBps: unavailableMetric(historicalUnavailableMessage), - errors: unavailableMetric(historicalUnavailableMessage) - }; +function recordedDaysMessage(label: string, coveredDays: number): string { + const days = coveredDays === 1 ? "1 erfasster Tag" : `${coveredDays} erfasste Tage`; + return `${label}: ${days} werden bis heute zusammengefasst.`; } export function buildStatisticsViewModel( @@ -192,53 +207,42 @@ export function buildStatisticsViewModel( ): StatisticsViewModel { const sessionState = deriveSessionState(snapshot); - if (range === "week" || range === "month") { - return { - range, - coverage: "unavailable", - message: historicalUnavailableMessage, - sessionState, - metrics: buildUnavailableMetrics(), - providerScope: null, - providers: [], - errorResetAvailable: false - }; - } - - if (range === "today") { - const isCurrentDay = snapshot.settings.providerDailyUsageDay === getProviderUsageDayKey(nowMs); - const providers = isCurrentDay ? deriveUsageProviders(snapshot.settings.providerDailyUsageBytes) : []; + if (range === "today" || range === "week" || range === "month") { + const days = range === "today" ? 1 : range === "week" ? 7 : 30; + const aggregate = aggregateStatisticsRange(snapshot.stats.statistics, days, nowMs); + const label = range === "today" ? "Heute" : range === "week" ? "Letzte sieben Tage" : "Letzte 30 Tage"; return { range, coverage: "partial", - message: "Heutige Daten stammen aus den lokalen Provider-Nutzungszählern des aktuellen Kalendertags.", + message: range === "today" + ? "Heutige Werte stammen aus der lokalen Statistikaufzeichnung." + : recordedDaysMessage(label, aggregate.coveredDays), sessionState, - metrics: { - downloadedBytes: availableMetric(sumProviderBytes(providers), "Provider-Nutzung heute"), - files: unavailableMetric("Dateianzahlen werden nicht tagesweise gespeichert"), - successRate: unavailableMetric("Ergebnisse werden nicht tagesweise gespeichert"), - averageSpeedBps: unavailableMetric("Durchschnittsgeschwindigkeit wird nicht tagesweise gespeichert"), - errors: unavailableMetric("Fehler werden nicht tagesweise gespeichert") - }, - providerScope: "today", - providers, + metrics: aggregateMetrics(aggregate, label), + providerScope: range, + providers: deriveUsageProviders( + Object.fromEntries(Object.entries(aggregate.providers).map(([provider, bucket]) => [provider, bucket?.bytes ?? 0])), + aggregate.providers + ), errorResetAvailable: false }; } if (range === "all") { - const providers = deriveUsageProviders(snapshot.settings.providerTotalUsageBytes); + const aggregate = aggregateStatisticsRange(snapshot.stats.statistics, null, nowMs); + const providers = deriveUsageProviders(snapshot.settings.providerTotalUsageBytes, aggregate.providers); + const recordedMetrics = aggregateMetrics(aggregate, "Seit Beginn der Statistikaufzeichnung"); return { range, coverage: "partial", - message: "Gesamtwerte stammen aus dauerhaft gespeicherten Zählern. Ergebnisse und Geschwindigkeiten werden nicht historisch gespeichert.", + message: "Datenmenge und Dateien stammen aus den Gesamtzählern; Ergebnisse und Durchschnitt seit Beginn der Statistikaufzeichnung.", sessionState, metrics: { downloadedBytes: availableMetric(snapshot.stats.totalDownloadedAllTime, "Gesamtzähler"), files: availableMetric(snapshot.stats.totalFilesAllTime, "Gesamtzähler"), - successRate: unavailableMetric("Ergebnisse werden nicht dauerhaft gespeichert"), - averageSpeedBps: unavailableMetric("Durchschnittsgeschwindigkeit wird nicht dauerhaft gespeichert"), - errors: unavailableMetric("Fehler werden nicht dauerhaft gespeichert") + successRate: recordedMetrics.successRate, + averageSpeedBps: recordedMetrics.averageSpeedBps, + errors: recordedMetrics.errors }, providerScope: "all", providers, diff --git a/src/shared/statistics-aggregation.ts b/src/shared/statistics-aggregation.ts new file mode 100644 index 0000000..48be6da --- /dev/null +++ b/src/shared/statistics-aggregation.ts @@ -0,0 +1,66 @@ +import { getProviderUsageDayKey } from "./provider-daily-limits"; +import type { DebridProvider, StatisticsLedger, StatisticsProviderBucket } from "./types"; + +export interface StatisticsAggregate { + downloadedBytes: number; + measuredBytes: number; + completedFiles: number; + failedFiles: number; + activeDownloadMs: number; + averageSpeedBps: number | null; + coveredDays: number; + startedAt: number; + providers: Partial>; +} + +function emptyProviderBucket(): StatisticsProviderBucket { + return { bytes: 0, completed: 0, failed: 0 }; +} + +function localWindowStart(nowMs: number, days: number): string { + const date = new Date(nowMs); + date.setHours(0, 0, 0, 0); + date.setDate(date.getDate() - Math.max(0, Math.floor(days) - 1)); + return getProviderUsageDayKey(date.getTime()); +} + +export function aggregateStatisticsRange( + ledger: StatisticsLedger | null | undefined, + days: number | null, + nowMs = Date.now() +): StatisticsAggregate { + const endKey = getProviderUsageDayKey(nowMs); + const startKey = days === null ? "0000-00-00" : localWindowStart(nowMs, days); + const aggregate: StatisticsAggregate = { + downloadedBytes: 0, + measuredBytes: 0, + completedFiles: 0, + failedFiles: 0, + activeDownloadMs: 0, + averageSpeedBps: null, + coveredDays: 0, + startedAt: Math.max(0, Number(ledger?.startedAt) || nowMs), + providers: {} + }; + for (const day of ledger?.days ?? []) { + if (day.day < startKey || day.day > endKey) continue; + aggregate.coveredDays += 1; + aggregate.downloadedBytes += day.downloadedBytes; + aggregate.measuredBytes += day.measuredBytes; + aggregate.completedFiles += day.completedFiles; + aggregate.failedFiles += day.failedFiles; + aggregate.activeDownloadMs += day.activeDownloadMs; + for (const [provider, bucket] of Object.entries(day.providers) as Array<[DebridProvider, StatisticsProviderBucket | undefined]>) { + if (!bucket) continue; + const target = aggregate.providers[provider] ?? emptyProviderBucket(); + target.bytes += bucket.bytes; + target.completed += bucket.completed; + target.failed += bucket.failed; + aggregate.providers[provider] = target; + } + } + if (aggregate.activeDownloadMs > 0 && aggregate.measuredBytes > 0) { + aggregate.averageSpeedBps = Math.floor(aggregate.measuredBytes * 1000 / aggregate.activeDownloadMs); + } + return aggregate; +} diff --git a/src/shared/types.ts b/src/shared/types.ts index 6202d48..fd3d981 100644 --- a/src/shared/types.ts +++ b/src/shared/types.ts @@ -33,15 +33,37 @@ export type ExtractCpuPriority = "high" | "middle" | "low"; export type HistoryRetentionMode = "never" | "session" | "permanent"; export type LogStorageLocation = "appdata" | "desktop"; -export interface BandwidthScheduleEntry { +export interface BandwidthScheduleEntry { id: string; startHour: number; endHour: number; speedLimitKbps: number; enabled: boolean; -} - -export interface DownloadStats { +} + +export interface StatisticsProviderBucket { + bytes: number; + completed: number; + failed: number; +} + +export interface StatisticsDayBucket { + day: string; + downloadedBytes: number; + measuredBytes: number; + completedFiles: number; + failedFiles: number; + activeDownloadMs: number; + providers: Partial>; +} + +export interface StatisticsLedger { + version: 1; + startedAt: number; + days: StatisticsDayBucket[]; +} + +export interface DownloadStats { totalDownloaded: number; totalDownloadedAllTime: number; totalFiles?: number; @@ -52,8 +74,9 @@ export interface DownloadStats { appSessionStartedAt: number; sessionRuntimeMs: number; totalRuntimeMs: number; - runtimeMeasuredAt: number; -} + runtimeMeasuredAt: number; + statistics?: StatisticsLedger; +} export interface DebridAccountStatus { accountId: string; diff --git a/tests/backup-payload.test.ts b/tests/backup-payload.test.ts index 2b115cd..aaa0813 100644 --- a/tests/backup-payload.test.ts +++ b/tests/backup-payload.test.ts @@ -1,6 +1,6 @@ import { describe, expect, it } from "vitest"; import { buildBackupPayload, planBackupImport } from "../src/main/backup-payload"; -import type { AppSettings, SessionState, HistoryEntry } from "../src/shared/types"; +import type { AppSettings, SessionState, HistoryEntry, StatisticsLedger } from "../src/shared/types"; function settings(overrides: Partial = {}): AppSettings { return { backupIncludeDownloads: false, token: "secret", outputDir: "C:\\dl" } as unknown as AppSettings; @@ -11,16 +11,18 @@ const session: SessionState = { runStartedAt: 0, totalDownloadedBytes: 0, summaryText: "", reconnectUntil: 0, reconnectReason: "", paused: false, running: true, updatedAt: 0 }; -const history: HistoryEntry[] = [{ id: "h1" } as unknown as HistoryEntry]; - -const baseInput = { appVersion: "1.7.183", exportedAt: "2026-06-07T00:00:00Z", session, history }; +const history: HistoryEntry[] = [{ id: "h1" } as unknown as HistoryEntry]; +const statistics: StatisticsLedger = { version: 1, startedAt: 1, days: [] }; + +const baseInput = { appVersion: "1.7.183", exportedAt: "2026-06-07T00:00:00Z", session, history, statistics }; describe("buildBackupPayload — default is settings-only", () => { it("omits session AND history when backupIncludeDownloads is false (default)", () => { const p = buildBackupPayload({ ...baseInput, settings: { backupIncludeDownloads: false } as AppSettings }); expect(p.kind).toBe("settings-only"); expect(p.session).toBeUndefined(); - expect(p.history).toBeUndefined(); + expect(p.history).toBeUndefined(); + expect(p.statistics).toBeUndefined(); expect(p.settings).toBeDefined(); }); @@ -28,7 +30,8 @@ describe("buildBackupPayload — default is settings-only", () => { const p = buildBackupPayload({ ...baseInput, settings: { backupIncludeDownloads: true } as AppSettings }); expect(p.kind).toBe("full"); expect(p.session).toBe(session); - expect(p.history).toBe(history); + expect(p.history).toBe(history); + expect(p.statistics).toBe(statistics); }); it("treats a missing flag as settings-only (safe default)", () => { diff --git a/tests/history-view.test.tsx b/tests/history-view.test.tsx index c653b3e..fd642d4 100644 --- a/tests/history-view.test.tsx +++ b/tests/history-view.test.tsx @@ -6,11 +6,15 @@ import type { HistoryEntry } from "../src/shared/types"; import { buildHistoryViewModel, deriveHistoryHoster, - deriveHistoryStartAt, - filterHistoryRows, + deriveHistoryStartAt, + filterHistoryRows, + createHistoryTableColumnWidths, + getHistoryTableGridTemplate, + getHistoryTableMinWidth, HISTORY_PAGE_SIZE, paginateHistoryRows, - pruneHistoryIds, + pruneHistoryIds, + resizeHistoryTableColumn, selectVisibleHistoryIds, type HistoryFilter, type HistoryViewEntry @@ -234,6 +238,28 @@ describe("history model", () => { }); describe("HistoryView", () => { + it("uses bounded persistent widths and one exact grid for history headers and rows", () => { + const defaults = createHistoryTableColumnWidths(); + const resized = resizeHistoryTableColumn(defaults, "status", 80); + const clamped = createHistoryTableColumnWidths({ ...defaults, name: -500, completed: 9000 }); + + expect(resized.status).toBe(defaults.status + 80); + expect(clamped.name).toBeGreaterThan(0); + expect(clamped.completed).toBeLessThan(9000); + expect(getHistoryTableGridTemplate(resized)).toContain(`${resized.status}px`); + expect(getHistoryTableMinWidth(resized)).toBeGreaterThan(getHistoryTableMinWidth(defaults)); + + const html = renderToStaticMarkup( + + ); + const template = getHistoryTableGridTemplate(defaults).replaceAll(" ", " "); + expect(html.match(new RegExp(`grid-template-columns:${template.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`, "g"))).toHaveLength(3); + expect(html.match(/Spaltenbreite ändern/g)).toHaveLength(6); + }); + it("builds the complete page status as one localizable text value", () => { expect(historyPageStatusLabel({ page: 2, pageSize: 100, rangeLabel: "101–200 von 250", rows: [], totalItems: 250, totalPages: 3 })) .toBe("Seite 2 von 3"); @@ -320,7 +346,7 @@ describe("HistoryView", () => { expect(html.match(/data-sliding-selection-active="true"/g)).toHaveLength(1); }); - it("keeps the header and rows inside the same internal horizontal scroll context", () => { + it("keeps one clipped header synchronized with the scrollable history rows", () => { const html = renderToStaticMarkup( { expect(tableStart).toBeGreaterThan(-1); expect(headerStart).toBeGreaterThan(tableStart); expect(bodyStart).toBeGreaterThan(headerStart); - expect(css).toMatch(/\.history-content \.history-table\s*\{[^}]*overflow:\s*auto;/s); - expect(css).toMatch(/\.history-table > \.history-table-header\s*\{[^}]*position:\s*sticky;[^}]*top:\s*0;/s); - expect(css).toMatch(/\.history-table > \.history-table-body\s*\{[^}]*overflow:\s*visible;/s); - expect(css).not.toMatch(/\.history-table > \.history-table-body\s*\{[^}]*overflow:\s*auto;/s); + expect(css).toMatch(/\.history-content \.history-table\s*\{[^}]*overflow:\s*hidden;/s); + expect(css).toMatch(/\.history-table > \.history-table-header\s*\{[^}]*overflow:\s*hidden;/s); + expect(css).toMatch(/\.history-table > \.history-table-body\s*\{[^}]*overflow:\s*auto;/s); }); it("keeps every real AppShell history surface non-selectable while allowing text selection only for detail values", () => { @@ -393,7 +418,7 @@ describe("HistoryView", () => { expect(html).not.toMatch(/>Start<|>Pause<|>Stop<|Priorität/); }); - it("matches the download action control and centers every header except package and file", () => { + it("matches the download action control and aligns every header with its data column", () => { const model = buildHistoryViewModel(entries.slice(0, 1), "all", "", [], [], false, "", now); const content = HistoryContentPage({ actions: createActions(), @@ -406,8 +431,9 @@ describe("HistoryView", () => { expect(actionCell.props.children.props.children).toBe("⋮"); expect(styles).toMatch(/\.history-row-action button\s*\{[^}]*background:\s*var\(--ui-input\);[^}]*border:\s*1px solid var\(--ui-border\);[^}]*height:\s*30px;[^}]*width:\s*30px;/s); - expect(styles).toMatch(/\.history-table-header-row > span\s*\{[^}]*text-align:\s*center;/s); - expect(styles).toMatch(/\.history-table-header-row > span:nth-child\(2\)\s*\{[^}]*text-align:\s*left;/s); + expect(styles).toMatch(/\.history-table-header-row > span,\s*\.history-row > span\s*\{[^}]*text-align:\s*left;/s); + expect(styles).toMatch(/\.history-table-header-row > span:nth-child\(4\),\s*\.history-row > span:nth-child\(4\)\s*\{[^}]*text-align:\s*right;/s); + expect(styles).toMatch(/\.history-row-action\s*\{[^}]*place-items:\s*center;/s); }); it("renders each visual marker once, occupied main rows separately from closed detail rows and an honest footer", () => { diff --git a/tests/statistics-ledger.test.ts b/tests/statistics-ledger.test.ts new file mode 100644 index 0000000..6385576 --- /dev/null +++ b/tests/statistics-ledger.test.ts @@ -0,0 +1,163 @@ +import fs from "node:fs"; +import os from "node:os"; +import path from "node:path"; +import { afterEach, describe, expect, it, vi } from "vitest"; +import { defaultSettings } from "../src/main/constants"; +import { DownloadManager } from "../src/main/download-manager"; +import { createStoragePaths, emptySession } from "../src/main/storage"; +import { + aggregateStatisticsRange, + createStatisticsLedger, + loadStatisticsLedger, + recordStatisticsActiveInterval, + recordStatisticsBytes, + recordStatisticsOutcome, + saveStatisticsLedger +} from "../src/main/statistics-ledger"; + +const roots: string[] = []; + +afterEach(() => { + for (const root of roots.splice(0)) { + fs.rmSync(root, { recursive: true, force: true }); + } +}); + +function localTime(day: number, hour = 12): number { + return new Date(2026, 7, day, hour, 0, 0, 0).getTime(); +} + +describe("statistics ledger", () => { + it("aggregates every available day inside a rolling seven-day window without requiring seven complete days", () => { + let ledger = createStatisticsLedger(localTime(10)); + ledger = recordStatisticsBytes(ledger, "realdebrid", 100, localTime(7)); + ledger = recordStatisticsOutcome(ledger, "realdebrid", "completed", localTime(7)); + ledger = recordStatisticsBytes(ledger, "debridlink", 200, localTime(8)); + ledger = recordStatisticsOutcome(ledger, "debridlink", "failed", localTime(8)); + ledger = recordStatisticsBytes(ledger, "realdebrid", 300, localTime(10)); + ledger = recordStatisticsOutcome(ledger, "realdebrid", "completed", localTime(10)); + + const aggregate = aggregateStatisticsRange(ledger, 7, localTime(10)); + + expect(aggregate).toMatchObject({ + downloadedBytes: 600, + completedFiles: 2, + failedFiles: 1, + coveredDays: 3 + }); + expect(aggregate.providers).toEqual({ + debridlink: { bytes: 200, completed: 0, failed: 1 }, + realdebrid: { bytes: 400, completed: 2, failed: 0 } + }); + }); + + it("excludes data outside the requested calendar window and computes average speed from measured active time", () => { + let ledger = createStatisticsLedger(localTime(10)); + ledger = recordStatisticsBytes(ledger, "realdebrid", 8_000, localTime(10)); + ledger = recordStatisticsActiveInterval(ledger, localTime(10, 10), localTime(10, 10) + 2_000); + ledger = recordStatisticsBytes(ledger, "debridlink", 99_000, localTime(3)); + ledger = recordStatisticsActiveInterval(ledger, localTime(3, 10), localTime(3, 10) + 1_000); + + const today = aggregateStatisticsRange(ledger, 1, localTime(10)); + const week = aggregateStatisticsRange(ledger, 7, localTime(10)); + const month = aggregateStatisticsRange(ledger, 30, localTime(10)); + + expect(today).toMatchObject({ downloadedBytes: 8_000, activeDownloadMs: 2_000, averageSpeedBps: 4_000 }); + expect(week.downloadedBytes).toBe(8_000); + expect(month).toMatchObject({ downloadedBytes: 107_000, activeDownloadMs: 3_000 }); + }); + + it("splits active intervals across local calendar days", () => { + const start = new Date(2026, 7, 9, 23, 59, 59, 500).getTime(); + const end = new Date(2026, 7, 10, 0, 0, 0, 500).getTime(); + const ledger = recordStatisticsActiveInterval(createStatisticsLedger(start), start, end); + + expect(aggregateStatisticsRange(ledger, 1, localTime(10)).activeDownloadMs).toBe(500); + expect(aggregateStatisticsRange(ledger, 1, localTime(9)).activeDownloadMs).toBe(500); + }); + + it("persists normalized statistics and recovers safely from malformed files", () => { + const root = fs.mkdtempSync(path.join(os.tmpdir(), "mdd-statistics-ledger-")); + roots.push(root); + const filePath = path.join(root, "rd_statistics.json"); + const ledger = recordStatisticsOutcome( + recordStatisticsBytes(createStatisticsLedger(localTime(10)), "realdebrid", 4_096, localTime(10)), + "realdebrid", + "completed", + localTime(10) + ); + + saveStatisticsLedger(filePath, ledger); + expect(loadStatisticsLedger(filePath, localTime(10))).toEqual(ledger); + + fs.writeFileSync(filePath, "{broken", "utf8"); + expect(loadStatisticsLedger(filePath, localTime(11))).toEqual(createStatisticsLedger(localTime(11))); + }); + + it("retries transient Windows rename failures while preserving the statistics file", () => { + const root = fs.mkdtempSync(path.join(os.tmpdir(), "mdd-statistics-rename-")); + roots.push(root); + const filePath = path.join(root, "rd_statistics.json"); + const ledger = recordStatisticsBytes(createStatisticsLedger(localTime(10)), "realdebrid", 8_192, localTime(10)); + const rename = fs.renameSync.bind(fs); + let attempts = 0; + const spy = vi.spyOn(fs, "renameSync").mockImplementation((source, target) => { + attempts += 1; + if (attempts < 3) { + throw Object.assign(new Error("busy"), { code: "EPERM" }); + } + return rename(source, target); + }); + + saveStatisticsLedger(filePath, ledger); + + expect(attempts).toBe(3); + expect(loadStatisticsLedger(filePath, localTime(10))).toEqual(ledger); + spy.mockRestore(); + }); + + it("records provider bytes and terminal outcomes through the download manager and restores them after restart", () => { + const root = fs.mkdtempSync(path.join(os.tmpdir(), "mdd-statistics-manager-")); + roots.push(root); + const paths = createStoragePaths(root); + const session = emptySession(); + session.items.item = { + id: "item", + packageId: "package", + url: "https://example.test/file", + provider: "realdebrid", + providerLabel: "Real-Debrid", + status: "completed", + retries: 0, + speedBps: 0, + downloadedBytes: 4_096, + totalBytes: 4_096, + progressPercent: 100, + fileName: "file.bin", + targetPath: path.join(root, "file.bin"), + resumable: true, + attempts: 1, + lastError: "", + fullStatus: "Fertig", + createdAt: Date.now(), + updatedAt: Date.now() + }; + const manager = new DownloadManager(defaultSettings(), session, paths); + + (manager as any).runItemIds.add("item"); + (manager as any).recordProviderDownloadedBytes("realdebrid", 4_096); + (manager as any).recordRunOutcome("item", "completed"); + manager.persistNowSync(); + + const current = aggregateStatisticsRange(manager.getStats().statistics, 1); + expect(current).toMatchObject({ downloadedBytes: 4_096, completedFiles: 1, failedFiles: 0 }); + expect(current.providers.realdebrid).toEqual({ bytes: 4_096, completed: 1, failed: 0 }); + expect(fs.existsSync(paths.statisticsFile)).toBe(true); + + const restored = new DownloadManager(defaultSettings(), emptySession(), paths); + expect(aggregateStatisticsRange(restored.getStats().statistics, 1)).toMatchObject({ + downloadedBytes: 4_096, + completedFiles: 1 + }); + }); +}); diff --git a/tests/statistics-view.test.tsx b/tests/statistics-view.test.tsx index 3f5c100..16faf0d 100644 --- a/tests/statistics-view.test.tsx +++ b/tests/statistics-view.test.tsx @@ -5,9 +5,8 @@ import { describe, expect, it } from "vitest"; import type { DownloadItem, DownloadStatus, UiSnapshot } from "../src/shared/types"; import { appendBandwidthSample, readBandwidthChartPalette, readDownloadSpeedSparklinePalette } from "../src/renderer/App"; import { - buildStatisticsViewModel, - type StatisticsMetric, - type StatisticsRange + buildStatisticsViewModel, + type StatisticsMetric } from "../src/renderer/views/statistics/statistics-model"; import { StatisticsContent, @@ -15,7 +14,13 @@ import { StatisticsView, type StatisticsViewActions } from "../src/renderer/views/statistics/StatisticsView"; -import { createVisualFixture } from "./visual/fixtures"; +import { createVisualFixture } from "./visual/fixtures"; +import { + createStatisticsLedger, + recordStatisticsActiveInterval, + recordStatisticsBytes, + recordStatisticsOutcome +} from "../src/main/statistics-ledger"; const now = new Date(2026, 7, 10, 12, 0, 0, 0).getTime(); @@ -183,23 +188,28 @@ describe("statistics model", () => { expect(model.providers.some((row) => row.id.includes("host"))).toBe(false); }); - it("uses daily provider usage only for the matching local day", () => { - const snapshot = createSnapshot(); - snapshot.stats.totalDownloaded = 999_999; - snapshot.settings.providerDailyUsageDay = "2026-08-10"; - snapshot.settings.providerDailyUsageBytes = { realdebrid: 500, alldebrid: 1_500 }; + it("uses persisted daily bytes, results and active time for every statistic shown today", () => { + const snapshot = createSnapshot(); + let ledger = createStatisticsLedger(now); + ledger = recordStatisticsBytes(ledger, "realdebrid", 500, now); + ledger = recordStatisticsOutcome(ledger, "realdebrid", "completed", now); + ledger = recordStatisticsBytes(ledger, "alldebrid", 1_500, now); + ledger = recordStatisticsOutcome(ledger, "alldebrid", "failed", now); + ledger = recordStatisticsActiveInterval(ledger, now - 2_000, now); + snapshot.stats.statistics = ledger; const model = buildStatisticsViewModel(snapshot, "today", now); - expect(model.metrics.downloadedBytes).toMatchObject({ value: 2_000, available: true }); + expect(model.metrics.downloadedBytes).toMatchObject({ value: 2_000, available: true }); + expect(model.metrics.files).toMatchObject({ value: 1, available: true }); + expect(model.metrics.successRate).toMatchObject({ value: 50, available: true }); + expect(model.metrics.errors).toMatchObject({ value: 1, available: true }); + expect(model.metrics.averageSpeedBps).toMatchObject({ value: 1_000, available: true }); expect(model.providers.map((row) => [row.id, row.bytes])).toEqual([ ["alldebrid", 1_500], ["realdebrid", 500] ]); - expectUnavailable(model.metrics.files); - expectUnavailable(model.metrics.successRate); - expectUnavailable(model.metrics.errors); - expectUnavailable(model.metrics.averageSpeedBps); + expect(model.providers.map((row) => [row.completed, row.failed])).toEqual([[0, 1], [1, 0]]); }); it("treats a stale daily key as a genuine zero today without stale provider rows", () => { @@ -213,28 +223,42 @@ describe("statistics model", () => { expect(model.providers).toEqual([]); }); - it.each(["week", "month"] satisfies StatisticsRange[])("keeps %s unavailable without inventing historical buckets", (range) => { - const snapshot = createSnapshot(); - snapshot.stats.totalDownloaded = 5_000; - snapshot.stats.totalDownloadedAllTime = 50_000; - snapshot.settings.providerDailyUsageDay = "2026-08-10"; - snapshot.settings.providerDailyUsageBytes = { realdebrid: 4_000 }; - snapshot.settings.providerTotalUsageBytes = { realdebrid: 40_000 }; - - const model = buildStatisticsViewModel(snapshot, range, now); - - expect(model.coverage).toBe("unavailable"); - expect(model.message).toBe("Für diesen Zeitraum werden noch keine historischen Daten gespeichert."); - expect(model.providers).toEqual([]); - expect(model.providerScope).toBeNull(); - Object.values(model.metrics).forEach(expectUnavailable); - }); - - it("uses all-time counters and provider totals without inventing historical outcomes", () => { + it("sums every available day in seven-day and 30-day windows without waiting for a full period", () => { + const snapshot = createSnapshot(); + let ledger = createStatisticsLedger(new Date(2026, 7, 3, 12).getTime()); + ledger = recordStatisticsBytes(ledger, "realdebrid", 300, new Date(2026, 7, 3, 12).getTime()); + ledger = recordStatisticsOutcome(ledger, "realdebrid", "completed", new Date(2026, 7, 3, 12).getTime()); + ledger = recordStatisticsBytes(ledger, "debridlink", 700, new Date(2026, 7, 8, 12).getTime()); + ledger = recordStatisticsOutcome(ledger, "debridlink", "failed", new Date(2026, 7, 8, 12).getTime()); + ledger = recordStatisticsBytes(ledger, "realdebrid", 500, now); + ledger = recordStatisticsOutcome(ledger, "realdebrid", "completed", now); + snapshot.stats.statistics = ledger; + + const week = buildStatisticsViewModel(snapshot, "week", now); + const month = buildStatisticsViewModel(snapshot, "month", now); + + expect(week.metrics.downloadedBytes.value).toBe(1_200); + expect(week.metrics.files.value).toBe(1); + expect(week.metrics.errors.value).toBe(1); + expect(week.message).toContain("2 erfasste Tage"); + expect(month.metrics.downloadedBytes.value).toBe(1_500); + expect(month.metrics.files.value).toBe(2); + expect(month.metrics.errors.value).toBe(1); + expect(month.message).toContain("3 erfasste Tage"); + }); + + it("combines existing all-time counters with persisted outcomes, provider results and measured average speed", () => { const snapshot = createSnapshot(); snapshot.stats.totalDownloadedAllTime = 25_000; snapshot.stats.totalFilesAllTime = 42; - snapshot.settings.providerTotalUsageBytes = { realdebrid: 5_000, debridlink: 20_000 }; + snapshot.settings.providerTotalUsageBytes = { realdebrid: 5_000, debridlink: 20_000 }; + let ledger = createStatisticsLedger(now - 10_000); + ledger = recordStatisticsBytes(ledger, "realdebrid", 2_000, now); + ledger = recordStatisticsActiveInterval(ledger, now - 2_000, now); + ledger = recordStatisticsOutcome(ledger, "realdebrid", "completed", now); + ledger = recordStatisticsOutcome(ledger, "realdebrid", "completed", now); + ledger = recordStatisticsOutcome(ledger, "debridlink", "failed", now); + snapshot.stats.statistics = ledger; snapshot.summary = { total: 10, success: 9, @@ -253,10 +277,11 @@ describe("statistics model", () => { ["debridlink", 20_000], ["realdebrid", 5_000] ]); - expect(model.providers.every((row) => row.completed === null && row.failed === null)).toBe(true); - expectUnavailable(model.metrics.successRate); - expectUnavailable(model.metrics.errors); - expectUnavailable(model.metrics.averageSpeedBps); + expect(model.providers.map((row) => [row.completed, row.failed])).toEqual([[0, 1], [2, 0]]); + expect(model.metrics.successRate.available).toBe(true); + expect(model.metrics.successRate.value).toBeCloseTo(200 / 3); + expect(model.metrics.errors).toMatchObject({ value: 1, available: true }); + expect(model.metrics.averageSpeedBps).toMatchObject({ value: 1_000, available: true }); }); it("prefers live queue outcomes over an old summary and uses the summary only after the run ends", () => { diff --git a/tests/visual/fixtures.ts b/tests/visual/fixtures.ts index 1d61e4e..3af8ac8 100644 --- a/tests/visual/fixtures.ts +++ b/tests/visual/fixtures.ts @@ -458,8 +458,38 @@ function createDenseSnapshot(): UiSnapshot { sessionStartedAt: 1786309200000, appSessionStartedAt: 1786309200000, sessionRuntimeMs: 3600000, - totalRuntimeMs: 172800000, - runtimeMeasuredAt: 1786312800000 + totalRuntimeMs: 172800000, + runtimeMeasuredAt: 1786312800000, + statistics: { + version: 1, + startedAt: 1786053600000, + days: [ + { + day: "2026-08-08", + downloadedBytes: 182536110080, + measuredBytes: 182536110080, + completedFiles: 124, + failedFiles: 3, + activeDownloadMs: 21600000, + providers: { + realdebrid: { bytes: 123480309760, completed: 86, failed: 1 }, + debridlink: { bytes: 59055800320, completed: 38, failed: 2 } + } + }, + { + day: "2026-08-10", + downloadedBytes: 541165879488, + measuredBytes: 541165879488, + completedFiles: 310, + failedFiles: 2, + activeDownloadMs: 32400000, + providers: { + realdebrid: { bytes: 328565653504, completed: 192, failed: 1 }, + debridlink: { bytes: 212600225984, completed: 118, failed: 1 } + } + } + ] + } }; snapshot.speedText = "12,0 MB/s"; snapshot.etaText = "00:17:24";