From 4e613dd40dc7399f7911514da9efb89723f33dc3 Mon Sep 17 00:00:00 2001 From: D4rkst3r Date: Tue, 11 Aug 2026 19:39:16 +0200 Subject: [PATCH] feat: ein Einstellungen-Tab -- und die Sicherung meldet sich zurueck Die Zugangsdaten der Sicherung standen in einer Textdatei auf der Platte. Jetzt stehen sie im Panel, zusammen mit der Discord-Einrichtung, die vom Konto dorthin umgezogen ist. DER EIGENTLICHE GEWINN IST NICHT DIE BEQUEMLICHKEIT. Eine Textdatei sagt niemandem, ob die Sicherung heute Nacht gelaufen ist -- und eine Sicherung, die still aufhoert zu laufen, ist der eigentliche Schaden, nicht die eine Nacht, in der sie fehlt. Das Skript schreibt sein Ergebnis deshalb nach jedem Lauf in die Datenbank, und die Karte zeigt es als Erstes: wann, ob erfolgreich, wie viele Dateien, wie gross, und ob es in der Nextcloud gelandet ist oder nur lokal. Nachgemessen: {"dateien":228,"groesse":12063419,"hoch":false,"ok":true}. DAS PASSWORT GEHT NICHT UEBER DIE API. Das Skript laeuft auf dem Wirt, nicht im Dienst -- es liest die Werte per `docker exec` DIREKT aus media.db. Ueber HTTP geht das Passwort nur beim Eintragen im Browser, und das ueber TLS. Zurueck gibt die API nur "hatPasswort: true", wie beim Discord-Geheimnis. nextcloud.txt neben den Sicherungen gilt weiter und hat VORRANG: wer sie angelegt hat, soll nicht suchen muessen, warum sie ploetzlich ignoriert wird. Zwei Fussangeln beim Melden, beide beim Bauen aufgefallen: - Der JSON-Text geht ueber die STANDARDEINGABE in den Container und nicht als Argument -- Anfuehrungszeichen ueberleben den Weg durch zwei Shells nicht. - Auch dieses Hier-Dokument braucht das -replace "`r": dieselbe CRLF-Falle wie bei der Pruefung. Co-Authored-By: Claude Opus 5 --- server/src/routes/dash.ts | 75 +++++++++- server/src/settings.ts | 48 ++++++ server/ui/src/App.tsx | 3 + server/ui/src/api.ts | 22 +++ server/ui/src/pages/Einstellungen.tsx | 201 ++++++++++++++++++++++++++ server/ui/src/pages/Konto.tsx | 3 - tools/sichern.ps1 | 111 +++++++++++--- 7 files changed, 436 insertions(+), 27 deletions(-) create mode 100644 server/ui/src/pages/Einstellungen.tsx diff --git a/server/src/routes/dash.ts b/server/src/routes/dash.ts index 6d07ecc..a4ae8c0 100644 --- a/server/src/routes/dash.ts +++ b/server/src/routes/dash.ts @@ -33,7 +33,15 @@ import { } from '../auth.js' import { readdir, readFile, rm, stat } from 'node:fs/promises' import { join } from 'node:path' -import { DISCORD_KEYS, ausDatenbank, discordConfig, setSetting } from '../settings.js' +import { + DISCORD_KEYS, + SICHERUNG_KEYS, + ausDatenbank, + discordConfig, + getSetting, + setSetting, + sicherungConfig, +} from '../settings.js' import { discordRoutes, redirectUri } from './discord.js' import { absolutePath, @@ -701,6 +709,19 @@ dashRoutes.get('/settings', (c) => { !ausDatenbank(DISCORD_KEYS.roleIdAlt), }, }, + sicherung: (() => { + const sc = sicherungConfig() + let letzte: unknown = null + try { + const roh = getSetting(SICHERUNG_KEYS.letzte) + letzte = roh ? JSON.parse(roh) : null + } catch { + // Ein kaputter Eintrag ist kein Grund, die ganze Seite + // scheitern zu lassen -- dann steht dort eben "unbekannt". + letzte = null + } + return { ...sc, letzte } + })(), }) }) @@ -712,9 +733,61 @@ dashRoutes.post('/settings', async (c) => { guildId?: string roleIds?: string | string[] } + sicherung?: { + basis?: string + benutzer?: string + passwort?: string + ordner?: string + behalten?: number | string + } }>(c) if (!body) return c.json(KEIN_JSON, 400) + // -- Sicherung ---------------------------------------------------------- + if (body.sicherung) { + const sic = body.sicherung + if (sic.basis !== undefined) { + const v = sic.basis.trim().replace(/\/+$/, '') + if (v && !/^https?:\/\//.test(v)) { + return c.json({ error: 'Adresse muss mit http:// oder https:// anfangen' }, 400) + } + setSetting(SICHERUNG_KEYS.basis, v) + } + if (sic.benutzer !== undefined) setSetting(SICHERUNG_KEYS.benutzer, sic.benutzer.trim()) + if (sic.ordner !== undefined) { + // Kein fuehrender Schraegstrich: der Pfad haengt hinter der + // WebDAV-Wurzel, und "//Sicherungen" ergibt dort einen Ordner + // ohne Namen. + setSetting(SICHERUNG_KEYS.ordner, sic.ordner.trim().replace(/^\/+|\/+$/g, '')) + } + if (sic.behalten !== undefined) { + const n = Number(sic.behalten) + if (!Number.isFinite(n) || n < 1 || n > 365) { + return c.json({ error: 'Behalten: zwischen 1 und 365' }, 400) + } + setSetting(SICHERUNG_KEYS.behalten, String(Math.round(n))) + } + // Wie beim Discord-Geheimnis: leer heisst unveraendert, "-" entfernt. + if (sic.passwort !== undefined) { + const v = sic.passwort.trim() + if (v === '-') setSetting(SICHERUNG_KEYS.passwort, '') + else if (v) setSetting(SICHERUNG_KEYS.passwort, v) + } + + if (!body.discord) { + const jetzt = sicherungConfig() + return c.json({ + ok: true, + bereit: jetzt.bereit, + fehlt: [ + !jetzt.basis && 'Adresse', + !jetzt.benutzer && 'Benutzername', + !jetzt.hatPasswort && 'App-Passwort', + ].filter(Boolean), + }) + } + } + const d = body.discord if (!d) return c.json({ error: 'nichts zu speichern' }, 400) diff --git a/server/src/settings.ts b/server/src/settings.ts index 66a9184..3b2a9f9 100644 --- a/server/src/settings.ts +++ b/server/src/settings.ts @@ -44,6 +44,54 @@ export function ausDatenbank(key: string): boolean { return Boolean(zeile && zeile.value !== '') } +// ----------------------------------------------------------------- Sicherung +// +// Die Werte fuer die Sicherung stehen hier, obwohl das Skript sie braucht und +// nicht der Dienst. Der Grund ist die Rueckmeldung: eine Textdatei auf der +// Platte sagt niemandem, ob die Sicherung heute Nacht gelaufen ist. Ein +// Eintrag in der Datenbank kann das Panel anzeigen. +// +// tools/sichern.ps1 liest sie ueber `docker exec` DIREKT aus media.db und +// nicht ueber die API: so verlaesst das Passwort den Rechner nie -- ausser +// beim Eintragen im Browser, und das geht ueber TLS. + +export const SICHERUNG_KEYS = { + basis: 'sicherung.basis', + benutzer: 'sicherung.benutzer', + passwort: 'sicherung.passwort', + ordner: 'sicherung.ordner', + behalten: 'sicherung.behalten', + /** Schreibt das Skript nach jedem Lauf. JSON, damit das Panel es anzeigen + * kann, ohne dass hier eine weitere Tabelle noetig waere. */ + letzte: 'sicherung.letzte', +} as const + +export type SicherungConfig = { + basis: string + benutzer: string + ordner: string + behalten: number + hatPasswort: boolean + bereit: boolean +} + +export function sicherungConfig(): SicherungConfig { + const basis = getSetting(SICHERUNG_KEYS.basis) + const benutzer = getSetting(SICHERUNG_KEYS.benutzer) + const passwort = getSetting(SICHERUNG_KEYS.passwort) + const ordner = getSetting(SICHERUNG_KEYS.ordner) || 'Sicherungen/d4rk_media' + const behalten = Number(getSetting(SICHERUNG_KEYS.behalten)) || 14 + + return { + basis, + benutzer, + ordner, + behalten, + hatPasswort: Boolean(passwort), + bereit: Boolean(basis && benutzer && passwort), + } +} + // ------------------------------------------------------------------- Discord export const DISCORD_KEYS = { diff --git a/server/ui/src/App.tsx b/server/ui/src/App.tsx index f93ce39..97b0e59 100644 --- a/server/ui/src/App.tsx +++ b/server/ui/src/App.tsx @@ -7,6 +7,7 @@ import { KeyRound, LogOut, PieChart, + Settings, UserCog, } from 'lucide-react' import { run, useStore } from './store' @@ -16,6 +17,7 @@ import { Galerie } from './pages/Galerie' import { Speicher } from './pages/Speicher' import { Tokens } from './pages/Tokens' import { Konto } from './pages/Konto' +import { Einstellungen } from './pages/Einstellungen' import { Verlauf } from './pages/Verlauf' import { Meldungen } from './components/Meldungen' import { gehZu, usePfad } from './router' @@ -28,6 +30,7 @@ const seiten = [ { pfad: '/speicher', name: 'Speicher', kind: PieChart, Inhalt: Speicher }, { pfad: '/tokens', name: 'Token', kind: KeyRound, Inhalt: Tokens }, { pfad: '/konto', name: 'Konto', kind: UserCog, Inhalt: Konto }, + { pfad: '/einstellungen', name: 'Einstellungen', kind: Settings, Inhalt: Einstellungen }, ] as const export function App() { diff --git a/server/ui/src/api.ts b/server/ui/src/api.ts index 253f8bb..27b3144 100644 --- a/server/ui/src/api.ts +++ b/server/ui/src/api.ts @@ -182,7 +182,27 @@ export type Verwaiste = { vorschauOhneBild: { anzahl: number; beispiele: string[] } } +/** Was das Sicherungsskript nach jedem Lauf zurueckmeldet. */ +export type LetzteSicherung = { + at: number + ok: boolean + dateien?: number + groesse?: number + /** true = in der Nextcloud, false = nur lokal, undefined = unbekannt. */ + hoch?: boolean + fehler?: string +} | null + export type Einstellungen = { + sicherung: { + basis: string + benutzer: string + ordner: string + behalten: number + hatPasswort: boolean + bereit: boolean + letzte: LetzteSicherung + } discord: { clientId: string guildId: string @@ -301,6 +321,8 @@ export const api = { ), einstellungen: () => get('/api/dash/settings'), + sicherungSpeichern: (sicherung: Record) => + post<{ ok: true; bereit: boolean; fehlt: string[] }>('/api/dash/settings', { sicherung }), einstellungenSpeichern: (discord: Record) => post<{ ok: true; bereit: boolean; fehlt: string[] }>('/api/dash/settings', { discord }), diff --git a/server/ui/src/pages/Einstellungen.tsx b/server/ui/src/pages/Einstellungen.tsx new file mode 100644 index 0000000..2c097e9 --- /dev/null +++ b/server/ui/src/pages/Einstellungen.tsx @@ -0,0 +1,201 @@ +import { useEffect, useState } from 'react' +import { AlertTriangle, CheckCircle2, CloudUpload, Loader2, ShieldCheck, ShieldX } from 'lucide-react' +import { api, type Einstellungen as EinstellungenDaten } from '../api' +import { run, useStore } from '../store' +import { bytes, zeit } from '../format' +import { Feld, Karte, Knopf } from '../components/Bausteine' +import { DiscordKarte } from '../components/DiscordKarte' + +/** Alles, was sich einstellen lässt, an einer Stelle. + * + * Bisher lag die Discord-Karte beim Konto und die Zugangsdaten der Sicherung + * in einer Textdatei auf der Platte. Beides ist jetzt hier — und das ist mehr + * als Aufräumen: eine Textdatei sagt niemandem, ob die Sicherung heute Nacht + * gelaufen ist. Diese Seite tut es. */ +export function Einstellungen() { + return ( +
+ + +
+ ) +} + +function SicherungKarte() { + const note = useStore((s) => s.note) + const [daten, setDaten] = useState(null) + const [laedt, setLaedt] = useState(true) + const [speichert, setSpeichert] = useState(false) + + const [basis, setBasis] = useState('') + const [benutzer, setBenutzer] = useState('') + const [passwort, setPasswort] = useState('') + const [ordner, setOrdner] = useState('') + const [behalten, setBehalten] = useState('14') + + async function laden() { + setLaedt(true) + try { + const e = await api.einstellungen() + setDaten(e) + setBasis(e.sicherung.basis) + setBenutzer(e.sicherung.benutzer) + setOrdner(e.sicherung.ordner) + setBehalten(String(e.sicherung.behalten)) + } catch (err) { + note('fehler', err instanceof Error ? err.message : 'Unbekannt') + } finally { + setLaedt(false) + } + } + + useEffect(() => { + void laden() + // eslint-disable-next-line react-hooks/exhaustive-deps + }, []) + + async function speichern() { + setSpeichert(true) + const ergebnis = await run( + () => + api.sicherungSpeichern({ + basis, + benutzer, + ...(passwort ? { passwort } : {}), + ordner, + behalten: Number(behalten), + }), + (r) => + r.bereit + ? 'Gespeichert. Die nächste Sicherung geht in die Nextcloud.' + : `Gespeichert. Es fehlt noch: ${r.fehlt.join(', ')}.`, + ) + setSpeichert(false) + if (ergebnis) { + setPasswort('') + void laden() + } + } + + if (laedt) { + return ( + +
+ +
+ + ) + } + if (!daten) return null + + const s = daten.sicherung + const l = s.letzte + + return ( + + eingerichtet + + ) : ( + + nur lokal + + ) + } + > +
+ {/* Das Wichtigste zuerst: LIEF sie? Eine Sicherung, die still + aufhoert zu laufen, ist der eigentliche Schaden. */} +
+ {!l ? ( + + ) : l.ok ? ( + + ) : ( + + )} + + {!l ? ( + 'Noch keine Sicherung gemeldet. Sie läuft täglich um 04:30 als geplante Aufgabe.' + ) : ( + <> + Zuletzt {zeit(l.at)} — {l.ok ? 'erfolgreich' : 'FEHLGESCHLAGEN'} + {l.dateien != null && `, ${l.dateien} Dateien`} + {l.groesse != null && `, ${bytes(l.groesse)}`} + {l.hoch === true && ', in der Nextcloud'} + {l.hoch === false && ', nur lokal'} + {l.fehler && ( + {l.fehler} + )} + + )} + +
+ +
+ setBasis(e.target.value)} + /> + setBenutzer(e.target.value)} + /> + setPasswort(e.target.value)} + /> + setOrdner(e.target.value)} + /> + setBehalten(e.target.value)} + /> +
+ +

+ + + Nimm ein App-Passwort, nicht dein echtes: Nextcloud → + Einstellungen → Sicherheit → „Neues App-Passwort erstellen". Es lässt + sich einzeln zurückziehen. Das Skript liest die Werte direkt aus der + Datenbank des Dienstes — über HTTP geht das Passwort nur hier beim + Eintragen, und das über TLS. + +

+ +
+ +
+
+ + ) +} diff --git a/server/ui/src/pages/Konto.tsx b/server/ui/src/pages/Konto.tsx index 1ea0ff0..691460a 100644 --- a/server/ui/src/pages/Konto.tsx +++ b/server/ui/src/pages/Konto.tsx @@ -2,7 +2,6 @@ import { useState, type FormEvent } from 'react' import { api } from '../api' import { run, useStore } from '../store' import { Feld, Karte, Knopf } from '../components/Bausteine' -import { DiscordKarte } from '../components/DiscordKarte' import { Avatar } from '../components/Avatar' export function Konto() { @@ -105,8 +104,6 @@ export function Konto() { - - ) } diff --git a/tools/sichern.ps1 b/tools/sichern.ps1 index aefaf36..55d4be7 100644 --- a/tools/sichern.ps1 +++ b/tools/sichern.ps1 @@ -16,9 +16,12 @@ # 3. Das Archiv wird GEPRUEFT: ausgepackt, die Datenbank geoeffnet, die # Eintraege gezaehlt und mit dem laufenden Dienst verglichen. Eine # Sicherung, die niemand nachzaehlt, ist eine Vermutung. -# 4. Das Archiv geht in die NEXTCLOUD, wenn Zugangsdaten hinterlegt sind. -# Bis dahin lag die Sicherung auf derselben Platte wie die Daten — gegen -# einen Plattenausfall half sie damit gar nicht. +# 4. Das Archiv geht in die NEXTCLOUD, wenn im Panel Zugangsdaten stehen +# (Einstellungen → Sicherung). Bis dahin lag die Sicherung auf derselben +# Platte wie die Daten — gegen einen Plattenausfall half sie gar nicht. +# 4b. Und der Lauf MELDET SICH ZURUECK: das Ergebnis landet in der Datenbank +# und steht danach im Panel. Eine Sicherung, die still aufhoert zu laufen, +# ist der eigentliche Schaden — nicht die eine Nacht, in der sie fehlt. # 5. Alte Archive fliegen raus, hier wie dort, sobald mehr als -Behalten da # sind. # @@ -49,6 +52,36 @@ function Schritt($text) { Write-Host "==> $text" -ForegroundColor Cyan } function Gut($text) { Write-Host " $text" -ForegroundColor Green } function Schlecht($text) { Write-Host " $text" -ForegroundColor Red } +# Das Ergebnis in die Datenbank des Dienstes schreiben, damit es im Panel +# steht. Schlaegt DAS fehl, ist es kein Grund, die Sicherung als gescheitert zu +# behandeln — das Archiv liegt dann trotzdem richtig. +$inDerWolke = $false + +function Melde($ok, $dateien, $groesse, $hoch, $fehler) { + $eintrag = @{ + at = [long]([DateTimeOffset]::UtcNow.ToUnixTimeMilliseconds()) + ok = [bool]$ok + dateien = $dateien + groesse = $groesse + hoch = [bool]$hoch + } + if ($fehler) { $eintrag['fehler'] = "$fehler" } + $json = ($eintrag | ConvertTo-Json -Compress) + + # Ueber die Standardeingabe und nicht als Argument: der JSON-Text enthaelt + # Anfuehrungszeichen, und die ueberleben den Weg durch zwei Shells nicht. + $skript = @" +let roh = ''; +process.stdin.on('data', (d) => (roh += d)).on('end', () => { + const db = require('better-sqlite3')('/data/media.db'); + db.prepare('INSERT INTO settings (key, value, updated_at) VALUES (?, ?, ?) ' + + 'ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at') + .run('sicherung.letzte', roh.trim(), Date.now()); +}); +"@ -replace "`r", '' + $json | docker exec -i $Container node -e $skript 2>&1 | Out-Null +} + # -- Vorbedingungen ------------------------------------------------------------ $laeuft = docker ps --filter "name=^/$Container$" --format '{{.Names}}' @@ -157,22 +190,47 @@ Gut 'Datenbank in der Sicherung ist lesbar und vollstaendig.' # "Neues App-Passwort erstellen". Es laesst sich einzeln zurueckziehen, ohne # dass das eigene Passwort geaendert werden muss — genau dafuer gibt es sie. +# Die Werte kommen aus der Datenbank des Dienstes, eingetragen im Panel unter +# Einstellungen → Sicherung. Gelesen wird DIREKT ueber `docker exec` und nicht +# ueber die API: so verlaesst das Passwort den Rechner nie. +# +# nextcloud.txt neben den Sicherungen gilt weiterhin und hat VORRANG — wer sie +# angelegt hat, soll nicht suchen muessen, warum sie ploetzlich ignoriert wird. + +$z = @{} $zugangDatei = Join-Path $Ziel 'nextcloud.txt' -if (-not (Test-Path $zugangDatei)) { - Write-Host " Keine Nextcloud hinterlegt ($zugangDatei) — die Sicherung bleibt lokal." -ForegroundColor Yellow -} else { - $z = @{} +if (Test-Path $zugangDatei) { foreach ($zeile in Get-Content $zugangDatei) { if ($zeile -match '^\s*#') { continue } if ($zeile -match '^\s*([a-z]+)\s*=\s*(.+?)\s*$') { $z[$Matches[1]] = $Matches[2] } } - - $fehlend = @('basis', 'benutzer', 'passwort') | Where-Object { -not $z[$_] } - if ($fehlend) { - Schlecht "In $zugangDatei fehlt: $($fehlend -join ', ')" - exit 1 + Gut "Zugang aus $zugangDatei" +} else { + $roh = docker exec $Container node -e @" +const db = require('better-sqlite3')('/data/media.db', { readonly: true }); +const hol = (k) => { const r = db.prepare('SELECT value FROM settings WHERE key = ?').get(k); return r ? r.value : ''; }; +console.log(JSON.stringify({ + basis: hol('sicherung.basis'), + benutzer: hol('sicherung.benutzer'), + passwort: hol('sicherung.passwort'), + ordner: hol('sicherung.ordner'), + behalten: hol('sicherung.behalten'), +})); +"@ + if ($LASTEXITCODE -eq 0 -and $roh) { + $j = $roh | ConvertFrom-Json + foreach ($k in 'basis', 'benutzer', 'passwort', 'ordner', 'behalten') { + if ($j.$k) { $z[$k] = $j.$k } + } } +} + +if ($z['behalten']) { $Behalten = [int]$z['behalten'] } + +if (-not ($z['basis'] -and $z['benutzer'] -and $z['passwort'])) { + Write-Host ' Keine Nextcloud eingerichtet (Panel → Einstellungen → Sicherung) — die Sicherung bleibt lokal.' -ForegroundColor Yellow +} else { if (-not $z['ordner']) { $z['ordner'] = 'Sicherungen/d4rk_media' } $basis = $z['basis'].TrimEnd('/') @@ -191,42 +249,47 @@ if (-not (Test-Path $zugangDatei)) { # 201 = angelegt, 405 = gab es schon. Beides ist in Ordnung. $code = curl.exe -s -o NUL -w '%{http_code}' -u $auth -X MKCOL "$wurzel/$pfadBisher" if ($code -notin @('201', '405')) { - Schlecht "MKCOL $pfadBisher -> HTTP $code" - if ($code -eq '401') { Schlecht 'Benutzer oder App-Passwort stimmt nicht.' } + $fehlertext = "MKCOL $pfadBisher -> HTTP $code" + if ($code -eq '401') { $fehlertext += ' (Benutzer oder App-Passwort stimmt nicht)' } + Schlecht $fehlertext + Melde $false $zahlen.media $groesse $false $fehlertext exit 1 } } - $ziel = "$wurzel/$($z['ordner'])/$name" - $code = curl.exe -s -o NUL -w '%{http_code}' -u $auth -T $archiv $ziel + $fern = "$wurzel/$($z['ordner'])/$name" + $code = curl.exe -s -o NUL -w '%{http_code}' -u $auth -T $archiv $fern if ($code -notin @('201', '204')) { Schlecht "Hochladen fehlgeschlagen -> HTTP $code" + Melde $false $zahlen.media $groesse $false "Hochladen -> HTTP $code" exit 1 } Gut "hochgeladen ($code)" # NACHZAEHLEN, auch hier: zurueckholen und die Pruefsumme vergleichen. Ein - # PUT, der 201 sagt, hat noch nichts bewiesen — abgeschnittene Uebertragungen - # sehen genauso aus. Bei ein paar Megabyte taeglich ist das billig. + # PUT, der 201 sagt, hat noch nichts bewiesen — abgeschnittene + # Uebertragungen sehen genauso aus. Bei ein paar Megabyte ist das billig. $zurueck = Join-Path $env:TEMP "pruefe-$name" - curl.exe -s -u $auth -o $zurueck $ziel + curl.exe -s -u $auth -o $zurueck $fern $hierHash = (Get-FileHash $archiv -Algorithm SHA256).Hash - $dortHash = (Get-FileHash $zurueck -Algorithm SHA256).Hash + $dortHash = if (Test-Path $zurueck) { (Get-FileHash $zurueck -Algorithm SHA256).Hash } else { '' } Remove-Item $zurueck -Force -ErrorAction SilentlyContinue if ($hierHash -ne $dortHash) { Schlecht 'Die Kopie in der Nextcloud ist NICHT identisch.' + Melde $false $zahlen.media $groesse $false 'Pruefsumme der Kopie weicht ab' exit 1 } Gut "zurueckgeholt und verglichen: identisch ($($hierHash.Substring(0,12))…)" + $inDerWolke = $true # Auch draussen ausduennen. Sonst waechst die Nextcloud still voll, und das # faellt erst auf, wenn sie voll ist. $liste = curl.exe -s -u $auth -X PROPFIND -H 'Depth: 1' "$wurzel/$($z['ordner'])" - $fern = @([regex]::Matches($liste, 'd4rk_media-[\d-]+\.tar\.gz') | + $fernListe = @([regex]::Matches($liste, 'd4rk_media-[\d-]+\.tar\.gz') | ForEach-Object { $_.Value } | Sort-Object -Unique -Descending) - if ($fern.Count -gt $Behalten) { - foreach ($alt in $fern | Select-Object -Skip $Behalten) { + if ($fernListe.Count -gt $Behalten) { + foreach ($alt in $fernListe | Select-Object -Skip $Behalten) { $c = curl.exe -s -o NUL -w '%{http_code}' -u $auth -X DELETE "$wurzel/$($z['ordner'])/$alt" if ($c -in @('204', '200')) { Gut "in der Nextcloud entfernt: $alt" } else { Write-Host " konnte $alt nicht entfernen (HTTP $c)" -ForegroundColor Yellow } @@ -245,6 +308,8 @@ if ($alle.Count -gt $Behalten) { } } +Melde $true $zahlen.media $groesse $inDerWolke $null + Write-Host '' Gut "Fertig: $archiv" Write-Host " Zurueckspielen: tar xzf , dann media.db und files/ ins Volume legen," -ForegroundColor DarkGray