diff --git a/CHANGELOG.md b/CHANGELOG.md index 91c4af7..b926fd1 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,11 @@ Neueste Version oben. Erste Zahl: großer Umbau, zweite: neue Funktionen, dritte: Fehlerbehebungen. +## 0.31.0 + +- Nextcloud-Zugang unter Daten (Henning, 23.10.2026): Neue Maske „Nextcloud (Projektordner)“ mit Adresse (WebDAV-Adresse oder nur Serveradresse), Benutzername, Ordner mit „01 Angebot“ bis „04 Archiv“ (Vorgabe „01 Projekte“) und App-Passwort. „Verbindung prüfen“ meldet, ob der Ordner erreichbar ist und welche Statusordner es schon gibt; „Alle Projektordner abgleichen“ übernimmt vorhandene Ordner mit gleicher Nummer, verschiebt sie in den passenden Statusordner und legt fehlende an. Der Zugang gilt sofort, ohne Neustart. +- Das App-Passwort steht nur in der Datenbank des Servers (eigene Tabelle), nicht in den Einstellungen, nicht in der Sicherungsdatei und nicht im Änderungsprotokoll; die Oberfläche zeigt nur, ob eines gespeichert ist. In der Testversion lassen sich Adresse, Benutzer und Ordner schon eintragen (sie ziehen mit der Sicherung um), das App-Passwort erst auf dem Server. + ## 0.30.2 - Handy (Henning, 22.10.2026): Projekte lassen sich am Handy nicht mehr löschen; „Löschen“ gibt es im Projekt nur noch am PC. diff --git a/demo/kern.ts b/demo/kern.ts index 53b43a5..a9cb409 100644 --- a/demo/kern.ts +++ b/demo/kern.ts @@ -25,6 +25,7 @@ import m020 from "../src/server/migrations/020_stundensaetze.sql"; import m021 from "../src/server/migrations/021_dokumente.sql"; import m022 from "../src/server/migrations/022_freitag_termine.sql"; import m023 from "../src/server/migrations/023_vierteltage.sql"; +import m024 from "../src/server/migrations/024_nextcloud_zugang.sql"; const MIGRATIONEN: [string, string][] = [ ["001_grundlage.sql", m001], ["002_v70_uebernahme.sql", m002], ["003_vorgangsnummer.sql", m003], ["004_besetzung.sql", m004], @@ -45,6 +46,7 @@ const MIGRATIONEN: [string, string][] = [ ["021_dokumente.sql", m021], ["022_freitag_termine.sql", m022], ["023_vierteltage.sql", m023], + ["024_nextcloud_zugang.sql", m024], ]; export async function starte(db: PGlite, v70?: unknown) { @@ -57,7 +59,7 @@ export async function starte(db: PGlite, v70?: unknown) { await t.query("insert into schema_version (name) values ($1)", [name]); }); } - const app = (await baueApp({ pool: alsPool(db) as any, anmeldung: "testversion" })) as unknown as { + const app = (await baueApp({ pool: alsPool(db) as any, anmeldung: "testversion", nextcloudEinrichtbar: false })) as unknown as { verarbeite(methode: string, adresse: string, body?: unknown, headers?: Record): Promise; }; if (v70 && (await db.query("select 1 from projekt limit 1")).rows.length === 0) { diff --git a/package.json b/package.json index d1a3ecd..e526f19 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "betrieb", - "version": "0.30.2", + "version": "0.31.0", "private": true, "description": "Betriebsführungsprogramm Schaarschmidt Holzbau", "type": "module", diff --git a/src/server/anmeldung.ts b/src/server/anmeldung.ts index 36048d8..7d6adeb 100644 --- a/src/server/anmeldung.ts +++ b/src/server/anmeldung.ts @@ -40,7 +40,7 @@ function recht(methode: string, muster: string | undefined, url: string): Recht if (OFFEN.has(k)) return "offen"; if (muster?.startsWith("/api/ich/") || muster === "/api/ich" || ALLE.has(k)) return "alle"; // Jahresplan und BWA (Stufe 5) und Stundensätze (Löhne, U2) nur für den Inhaber - if (muster?.startsWith("/api/benutzer") || muster?.startsWith("/api/jahresplan") || muster?.startsWith("/api/stundensaetze") || muster?.startsWith("/api/bwa") || muster?.startsWith("/api/finanzmonat") || INHABER.has(k)) return "inhaber"; + if (muster?.startsWith("/api/benutzer") || muster?.startsWith("/api/nextcloud") || muster?.startsWith("/api/jahresplan") || muster?.startsWith("/api/stundensaetze") || muster?.startsWith("/api/bwa") || muster?.startsWith("/api/finanzmonat") || INHABER.has(k)) return "inhaber"; return muster ? "buero" : "inhaber"; } diff --git a/src/server/app.ts b/src/server/app.ts index 37f11b6..aabe2b0 100644 --- a/src/server/app.ts +++ b/src/server/app.ts @@ -10,7 +10,7 @@ import { mitNeuplanung, pruefeVerknuepfung, terminplan } from "./terminplan.js"; import { legeZahlungsplanAn, restNachziehen, zahlungsplanFest, zahlungsplaeneAutomatisch } from "./zahlungsplan.js"; import { uebersicht } from "./uebersicht.js"; import { aufgabenKalender, baustellenKalender } from "./kalender.js"; -import { type Nextcloud, ordnerAbgleichen } from "./nextcloud.js"; +import { Nextcloud, STATUSORDNER, ordnerAbgleichen, webdavBasis } from "./nextcloud.js"; import { NUR_SICHERUNG, TABELLEN } from "./tabellen.js"; import { EinstellungenSchema, type Einstellungen } from "./einstellungen.js"; import { liquiditaet } from "../domain/liquiditaet.js"; @@ -36,8 +36,12 @@ import { formatDatum, plusTage } from "../domain/datum.js"; export interface Optionen { pool: Pool; - /** P10: Projektordner in der Nextcloud; ohne Zugang wird nichts angelegt */ + /** P10: Projektordner in der Nextcloud; ohne Zugang wird nichts angelegt. Fest vorgegeben (.env, Tests) geht vor der Maske unter Daten */ nextcloud?: Nextcloud; + /** Zugang über die Maske unter Daten; in der Browser-Testversion aus, weil sie die Nextcloud nicht erreicht */ + nextcloudEinrichtbar?: boolean; + /** nur für Tests: WebDAV-Anfragen abfangen */ + nextcloudAbruf?: typeof fetch; webOrdner?: string; logger?: boolean; /** passwort: Server; testversion: Browser-Testversion und Tests, ohne Passwörter */ @@ -85,10 +89,22 @@ export async function baueApp(o: Optionen): Promise { // P10: Ordner nach dem Speichern abgleichen. Ein Fehler in der Nextcloud macht die Änderung nicht // rückgängig; der Hinweis kommt mit zurück, und der Abgleich lässt sich wiederholen. + const einrichtbar = o.nextcloudEinrichtbar !== false; + /** Der Zugang gilt sofort nach dem Speichern unter Daten, ohne Neustart */ + async function nextcloud(): Promise { + if (o.nextcloud) return o.nextcloud; + if (!einrichtbar) return undefined; + const z = (await ladeEinstellungen()).nextcloud; + if (!z.adresse || !z.benutzer) return undefined; + const passwort = (await pool.query<{ passwort: string }>("select passwort from nextcloud_zugang")).rows[0]?.passwort; + return passwort ? new Nextcloud({ url: webdavBasis(z), benutzer: z.benutzer, passwort }, o.nextcloudAbruf) : undefined; + } + async function mitOrdner(p: Record, wer: string): Promise> { - if (!o.nextcloud) return p; + const nc = await nextcloud(); + if (!nc) return p; try { - const pfad = await ordnerAbgleichen(o.nextcloud, p as { nummer: string; bezeichnung: string; status: string }, p.nextcloud_link ?? null); + const pfad = await ordnerAbgleichen(nc, p as { nummer: string; bezeichnung: string; status: string }, p.nextcloud_link ?? null); if (pfad === p.nextcloud_link) return p; return await transaktion(pool, wer, async (c) => (await c.query("update projekt set nextcloud_link = $2 where id = $1 returning *", [p.id, pfad])).rows[0]); } catch (err) { @@ -106,10 +122,72 @@ export async function baueApp(o: Optionen): Promise { const { id } = IdParam.parse(req.params); const p = (await pool.query("select * from projekt where id = $1", [id])).rows[0]; if (!p) return reply.status(404).send({ fehler: "Nicht gefunden" }); - if (!o.nextcloud) return reply.status(409).send({ fehler: "Für die Projektordner ist kein Nextcloud-Zugang eingerichtet." }); + if (!(await nextcloud())) return reply.status(409).send({ fehler: "Für die Projektordner ist kein Nextcloud-Zugang eingerichtet." }); return mitOrdner(p, benutzer(req)); }); + // Maske unter Daten (Henning, 23.10.2026): Adresse, Benutzer, Ordner und App-Passwort eintragen und prüfen. + // Das Passwort geht nie zurück an die Oberfläche, nur ob eines gespeichert ist. + app.get("/api/nextcloud", async () => { + const z = (await ladeEinstellungen()).nextcloud; + const pw = (await pool.query("select geaendert_am from nextcloud_zugang")).rows[0]; + return { ...z, passwortGesetzt: !!pw, passwortGeaendert: pw?.geaendert_am ?? null, fest: !!o.nextcloud, einrichtbar, + webdav: z.adresse && z.benutzer ? webdavBasis(z) : null }; + }); + const ZugangEingabe = z.object({ + adresse: z.string().trim().max(300).refine((a) => !a || /^https:\/\/[^\s/]+/i.test(a), "Die Adresse muss mit https:// beginnen."), + benutzer: z.string().trim().max(100), + ordner: z.string().trim().max(300).refine((a) => !/^[a-z]:\\/i.test(a), "Bitte den Ordner in der Nextcloud angeben, nicht den Pfad auf dem PC (z. B. „01 Projekte“)."), + // leer = bisheriges Passwort behalten + passwort: z.string().max(200).optional(), + passwortLoeschen: z.boolean().optional(), + }); + app.put("/api/nextcloud", async (req, reply) => { + const d = ZugangEingabe.parse(req.body); + if ((d.passwort || d.passwortLoeschen) && !einrichtbar) { + return reply.status(409).send({ fehler: "Das App-Passwort trägst du erst auf dem Server ein. Adresse, Benutzer und Ordner sind gespeichert und ziehen mit der Sicherung um." }); + } + const e = await ladeEinstellungen(); + const neu = EinstellungenSchema.parse({ ...e, nextcloud: { adresse: d.adresse.replace(/\/+$/, ""), benutzer: d.benutzer, ordner: d.ordner.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "") } }); + await transaktion(pool, benutzer(req), async (c) => { + await c.query("update einstellungen set daten = $1", [neu]); + if (d.passwortLoeschen) await c.query("delete from nextcloud_zugang"); + else if (d.passwort) { + await c.query(`insert into nextcloud_zugang (id, passwort, geaendert_von) values (true, $1, $2) + on conflict (id) do update set passwort = excluded.passwort, geaendert_am = now(), geaendert_von = excluded.geaendert_von`, [d.passwort, benutzer(req)]); + } + }); + return reply.send({ ok: true }); + }); + // Verbindung prüfen: erreicht das Programm den Ordner, und welche Statusordner gibt es schon? + app.post("/api/nextcloud/pruefen", async (_req, reply) => { + const nc = await nextcloud(); + if (!nc) return reply.status(409).send({ fehler: einrichtbar || o.nextcloud ? "Bitte Adresse, Benutzer und App-Passwort eintragen." : "Die Verbindung zur Nextcloud geht erst auf dem Server." }); + try { + if (!(await nc.gibtEs(""))) return { ok: false, fehler: "Den Ordner gibt es unter dieser Adresse nicht. Bitte Adresse, Benutzer und Ordner prüfen." }; + const da = await nc.liste(""); + const statusordner = [...new Set(Object.values(STATUSORDNER))]; + return { ok: true, vorhanden: statusordner.filter((s) => da.includes(s)), fehlen: statusordner.filter((s) => !da.includes(s)), anzahl: da.length }; + } catch (err) { + const text = (err as Error).message; + if (/ 401 /.test(text)) return { ok: false, fehler: "Die Nextcloud lehnt die Anmeldung ab: Benutzer oder App-Passwort stimmt nicht." }; + return { ok: false, fehler: `Keine Verbindung: ${text}` }; + } + }); + // Alle Projekte einmal abgleichen: vorhandene Ordner mit gleicher Nummer übernehmen, fehlende anlegen, falsche verschieben + app.post("/api/nextcloud/abgleichen", async (req, reply) => { + if (!(await nextcloud())) return reply.status(409).send({ fehler: "Für die Projektordner ist kein Nextcloud-Zugang eingerichtet." }); + const projekte = (await pool.query("select * from projekt order by nummer")).rows; + let ok = 0; + const fehler: string[] = []; + for (const p of projekte) { + const r = await mitOrdner(p, benutzer(req)); + if (r.ordner_fehler) fehler.push(`${p.nummer}: ${String(r.ordner_fehler).replace(/^Projektordner in der Nextcloud: /, "")}`); + else ok++; + } + return { ok, fehler }; + }); + // Ablage auf der Projektseite (Henning, 20.10.2026): Inhalt des Nextcloud-Projektordners anzeigen und Dateien öffnen const AblageAnfrage = z.object({ pfad: z.string().max(500).default("") }) .refine((q) => !q.pfad.split("/").some((t) => t === ".." || t === "."), { message: "Pfad ungültig" }); @@ -124,11 +202,12 @@ export async function baueApp(o: Optionen): Promise { const { id } = IdParam.parse(req.params); const { pfad } = AblageAnfrage.parse(req.query); if (!(await ablageErlaubt(req, id))) return reply.status(403).send({ fehler: "Dafür fehlt dir die Berechtigung." }); - if (!o.nextcloud) return reply.status(409).send({ fehler: "Die Ablage zeigt den Projektordner in der Nextcloud. Das geht, sobald das Programm auf dem Server läuft." }); + const nc = await nextcloud(); + if (!nc) return reply.status(409).send({ fehler: einrichtbar ? "Die Ablage zeigt den Projektordner in der Nextcloud. Dafür unter Daten den Nextcloud-Zugang eintragen." : "Die Ablage zeigt den Projektordner in der Nextcloud. Das geht, sobald das Programm auf dem Server läuft." }); const p = (await pool.query("select nextcloud_link from projekt where id = $1", [id])).rows[0]; if (!p) return reply.status(404).send({ fehler: "Nicht gefunden" }); if (!p.nextcloud_link) return reply.status(409).send({ fehler: "Für dieses Projekt gibt es noch keinen Ordner in der Nextcloud." }); - const eintraege = await o.nextcloud.inhalt((await ablagePfad(id, pfad))!); + const eintraege = await nc.inhalt((await ablagePfad(id, pfad))!); if (!eintraege) return reply.status(404).send({ fehler: "Ordner nicht gefunden" }); return { ordner: p.nextcloud_link, pfad, eintraege }; }); @@ -136,10 +215,11 @@ export async function baueApp(o: Optionen): Promise { const { id } = IdParam.parse(req.params); const { pfad } = AblageAnfrage.parse(req.query); if (!(await ablageErlaubt(req, id))) return reply.status(403).send({ fehler: "Dafür fehlt dir die Berechtigung." }); - if (!o.nextcloud || !pfad) return reply.status(404).send({ fehler: "Nicht gefunden" }); + const nc = await nextcloud(); + if (!nc || !pfad) return reply.status(404).send({ fehler: "Nicht gefunden" }); const voll = await ablagePfad(id, pfad); if (!voll) return reply.status(404).send({ fehler: "Nicht gefunden" }); - const r = await o.nextcloud.datei(voll); + const r = await nc.datei(voll); const name = pfad.split("/").at(-1)!; reply.header("content-type", r.headers.get("content-type") ?? "application/octet-stream"); reply.header("content-disposition", `inline; filename*=UTF-8''${encodeURIComponent(name)}`); diff --git a/src/server/einstellungen.ts b/src/server/einstellungen.ts index 1fb7c93..0eb88e8 100644 --- a/src/server/einstellungen.ts +++ b/src/server/einstellungen.ts @@ -55,6 +55,14 @@ export const EinstellungenSchema = z.object({ pausenabzug: z.enum(["bis_grenze", "voll"]).default("voll"), // geheimer Teil der Kalender-Links (T11); Outlook classic kann sich nicht anmelden kalenderToken: z.string().min(20).nullable().default(null), + // P10: Nextcloud-Zugang für die Projektordner (Henning, 23.10.2026); das App-Passwort steht nicht hier, sondern in nextcloud_zugang + nextcloud: z + .object({ + adresse: z.string().trim().max(300).default(""), + benutzer: z.string().trim().max(100).default(""), + ordner: z.string().trim().max(300).default("01 Projekte"), + }) + .prefault({}), aufgabenVorlage: z.array(VorlageEintrag).max(50).default(STANDARD_VORLAGE), // Stufe 3a: Vorgaben der Angebotskalkulation. Stundensätze (EK, Cent) gelten, bis Hennings Stundensatz-Excel da ist kalkulation: z diff --git a/src/server/migrations/024_nextcloud_zugang.sql b/src/server/migrations/024_nextcloud_zugang.sql new file mode 100644 index 0000000..7a363e8 --- /dev/null +++ b/src/server/migrations/024_nextcloud_zugang.sql @@ -0,0 +1,9 @@ +-- P10: App-Passwort für die Nextcloud, im Programm eingetragen (Henning, 23.10.2026). +-- Adresse, Benutzer und Ordner stehen in den Einstellungen; das Passwort nur hier: +-- nicht in den Einstellungen, nicht in der Sicherungsdatei und ohne Änderungsprotokoll. +create table nextcloud_zugang ( + id boolean primary key default true check (id), + passwort text not null, + geaendert_am timestamptz not null default now(), + geaendert_von text +); diff --git a/src/server/nextcloud.ts b/src/server/nextcloud.ts index e47e373..4f50a20 100644 --- a/src/server/nextcloud.ts +++ b/src/server/nextcloud.ts @@ -36,6 +36,17 @@ export function zielPfad(p: { nummer: string; bezeichnung: string; status: strin return `${STATUSORDNER[p.status] ?? STATUSORDNER.anfrage}/${ordnerName(p.nummer, p.bezeichnung)}`; } +/** + * WebDAV-Adresse des Ordners mit „01 Angebot“ … „04 Archiv“. Die Adresse darf die volle WebDAV-Adresse aus den + * Dateien-Einstellungen sein (…/remote.php/dav/files/) oder nur die Serveradresse; dann wird sie ergänzt. + */ +export function webdavBasis(z: { adresse: string; benutzer: string; ordner: string }): string { + let a = z.adresse.trim().replace(/\/+$/, ""); + if (!/\/remote\.php\//.test(a)) a = `${a}/remote.php/dav/files/${encodeURIComponent(z.benutzer)}`; + const teile = z.ordner.split(/[\\/]/).filter(Boolean); + return teile.length ? `${a}/${teile.map(encodeURIComponent).join("/")}` : a; +} + const kodiert = (pfad: string) => pfad.split("/").map(encodeURIComponent).join("/"); export class Nextcloud { diff --git a/src/web/app.ts b/src/web/app.ts index 14418fb..c58cf6f 100644 --- a/src/web/app.ts +++ b/src/web/app.ts @@ -834,6 +834,63 @@ function einsatzHtml(e: Zeile): string { } // T11: Kalender-Abos für Outlook classic (nur lesen, Outlook holt Änderungen selbst ab) +// P10: Zugang zur Nextcloud für die Projektordner (Henning, 23.10.2026). Das App-Passwort kommt nie zurück, +// die Seite zeigt nur, ob eines gespeichert ist. +async function nextcloudZugang(meldung = ""): Promise { + const ziel = document.getElementById("nextcloud"); + if (!ziel) return; + const z = await api("nextcloud"); + const zeile = (titel: string, wert: string) => `${titel}${wert}`; + ziel.innerHTML = `

Damit legt das Programm zu jedem Projekt einen Ordner an und verschiebt ihn bei jeder Statusänderung in „01 Angebot“, „02 laufende Projekte“, „03 Gewährl.-Projekte“ oder „04 Archiv“. Die Ablage auf der Projektseite zeigt seinen Inhalt.

+ ${z.fest ? '

Der Zugang ist auf dem Server fest eingetragen und gilt vor den Angaben hier.

' : ""} + + ${zeile("Adresse", z.adresse ? esc(z.adresse) : 'noch nicht eingetragen')} + ${zeile("Benutzer", z.benutzer ? esc(z.benutzer) : '–')} + ${zeile("Ordner in der Nextcloud", esc(z.ordner || "(oberste Ebene)"))} + ${zeile("App-Passwort", z.passwortGesetzt ? `gespeichert${z.passwortGeaendert ? ` am ${dat(String(z.passwortGeaendert).slice(0, 10))}` : ""}` : z.einrichtbar ? 'fehlt' : 'wird auf dem Server eingetragen')} + ${z.webdav ? zeile("WebDAV", `${esc(z.webdav)}`) : ""} +
+ ${meldung} +

+ ${z.einrichtbar || z.fest ? ` + ` : ""}

+ ${z.einrichtbar ? "" : '

Testversion: Adresse, Benutzer und Ordner kannst du schon eintragen, sie ziehen mit der Sicherung auf den Server um. Das App-Passwort und die Verbindung gehen erst dort.

'}`; + ziel.onclick = async (ev) => { + const a = (ev.target as HTMLElement).closest("[data-nc]")?.dataset.nc; + if (a === "bearbeiten") { + const felder: Feld[] = [ + { name: "adresse", titel: "Adresse der Nextcloud", hilfe: "Aus der Nextcloud: Dateien → unten links Dateien-Einstellungen → WebDAV. Es reicht auch die Serveradresse, z. B. https://cloud.beispiel.de." }, + { name: "benutzer", titel: "Benutzername in der Nextcloud" }, + { name: "ordner", titel: "Ordner mit „01 Angebot“ bis „04 Archiv“", hilfe: "So, wie er in der Nextcloud heißt, z. B. 01 Projekte (nicht C:\\Nc\\…)." }, + ...(z.einrichtbar ? [{ name: "passwort", titel: "App-Passwort", art: "passwort" as const, + hilfe: `${z.passwortGesetzt ? "Leer lassen, um das gespeicherte zu behalten. " : ""}Anlegen in der Nextcloud unter Persönliche Einstellungen → Sicherheit → Neues App-Passwort, Name z. B. „Betrieb“.` }] : []), + ]; + const r = await dialog("Nextcloud-Zugang", felder, { adresse: z.adresse, benutzer: z.benutzer, ordner: z.ordner, passwort: "" }, false); + if (r?.aktion !== "speichern") return; + try { + await api("nextcloud", "PUT", { adresse: String(r.daten.adresse ?? ""), benutzer: String(r.daten.benutzer ?? ""), ordner: String(r.daten.ordner ?? ""), + ...(r.daten.passwort ? { passwort: String(r.daten.passwort) } : {}) }); + return nextcloudZugang('

Gespeichert.

'); + } catch (err) { return nextcloudZugang(`

${esc((err as Error).message)}

`); } + } + if (a === "pruefen") { + try { + const p = await api("nextcloud/pruefen", "POST"); + return nextcloudZugang(p.ok + ? `

Verbindung steht.${p.vorhanden.length ? ` Vorhanden: ${p.vorhanden.map(esc).join(", ")}.` : ""}${p.fehlen.length ? ` Noch nicht da (legt das Programm bei Bedarf an): ${p.fehlen.map(esc).join(", ")}.` : ""}

` + : `

${esc(p.fehler)}

`); + } catch (err) { return nextcloudZugang(`

${esc((err as Error).message)}

`); } + } + if (a === "abgleichen") { + if (!(await bestaetigen("Alle Projektordner jetzt abgleichen?", { hinweis: "Vorhandene Ordner mit derselben Projektnummer werden übernommen und in den passenden Statusordner verschoben. Fehlende Ordner legt das Programm mit den Unterordnern an.", ja: "Abgleichen" }))) return; + try { + const r = await api<{ ok: number; fehler: string[] }>("nextcloud/abgleichen", "POST"); + return nextcloudZugang(`

${r.ok} Projektordner abgeglichen.${r.fehler.length ? ` Nicht geklappt: ${r.fehler.map(esc).join("; ")}` : ""}

`); + } catch (err) { return nextcloudZugang(`

${esc((err as Error).message)}

`); } + } + }; +} + function kalenderLinks(token: string | null): void { const ziel = document.getElementById("kalender")!; const neu = async () => { @@ -881,6 +938,8 @@ async function daten(): Promise {

Sicherungsdatei aus V70 wählen (projektplaner-sicherung-….json). Geht nur, solange noch nichts erfasst ist.

+

Nextcloud (Projektordner)

+

Kalender in Outlook

Einstellungen

`); @@ -891,6 +950,7 @@ async function daten(): Promise { try { ergebnis.textContent = await testversion.sichern(); } catch (err) { ergebnis.textContent = (err as Error).message; } }; } else kalenderLinks(e.kalenderToken); + void nextcloudZugang(); const stand = document.getElementById("stand-datei") as HTMLInputElement; stand.onchange = async () => { const f = stand.files?.[0]; diff --git a/src/web/styles.css b/src/web/styles.css index 5da8c7e..eaeeb3c 100644 --- a/src/web/styles.css +++ b/src/web/styles.css @@ -1898,3 +1898,10 @@ table.ss-t select { font: inherit; font-size: 12.5px; padding: 2px 4px; } table.ss-t .optional { display: none; } } table.ss-t input.ungueltig, .ss-umsatz input.ungueltig, .ss-einstellungen input.ungueltig { background: var(--warnung-bg); color: var(--warnung-text); border-color: var(--warn); } + +/* Daten: Nextcloud-Zugang (P10) */ +table.nc-zugang { border-collapse: collapse; margin: 6px 0 10px; width: auto; max-width: 100%; font-size: 14px; } +table.nc-zugang th { text-align: left; font-weight: 500; color: var(--leise); padding: 3px 16px 3px 0; vertical-align: top; white-space: nowrap; } +table.nc-zugang td { padding: 3px 0; overflow-wrap: anywhere; } +table.nc-zugang .leise { color: var(--leise); } +#nextcloud .knopfzeile { display: flex; flex-wrap: wrap; gap: 8px; } diff --git a/test/api.test.ts b/test/api.test.ts index 1449d1c..cec8005 100644 --- a/test/api.test.ts +++ b/test/api.test.ts @@ -381,6 +381,67 @@ describe.skipIf(!url)("Projektordner in der Nextcloud über die API", () => { }); }); +describe.skipIf(!url)("Nextcloud-Zugang über die Maske unter Daten", () => { + let pool: Pool; + let app: FastifyInstance; + const f = falscheNextcloud("https://cloud.test/remote.php/dav/files/henning/01 Projekte"); + + beforeAll(async () => { + pool = erstellePool(url!); + await pool.query("drop schema public cascade; create schema public;"); + await migriere(pool); + app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", nextcloudAbruf: f.abruf, anmeldung: "testversion" }); + }); + afterAll(async () => { + await app?.close(); + await pool?.end(); + }); + + it("speichert Adresse und App-Passwort, gibt das Passwort nie zurück und legt danach Ordner an", async () => { + expect((await app.inject("/api/nextcloud")).json()).toMatchObject({ adresse: "", ordner: "01 Projekte", passwortGesetzt: false, einrichtbar: true }); + expect((await app.inject({ method: "POST", url: "/api/nextcloud/pruefen" })).statusCode).toBe(409); + // ohne Zugang: Projekt speichert ohne Ordner + const ohne = (await app.inject({ method: "POST", url: "/api/projekte", payload: { nummer: "A-26-150", bezeichnung: "Vordach", status: "angebot" } })).json(); + expect(ohne.nextcloud_link).toBeNull(); + // Pfad vom PC statt Ordner in der Nextcloud + expect((await app.inject({ method: "PUT", url: "/api/nextcloud", payload: { adresse: "https://cloud.test", benutzer: "henning", ordner: "C:\\Nc\\01 Projekte" } })).statusCode).toBe(400); + const r = await app.inject({ method: "PUT", url: "/api/nextcloud", payload: { adresse: "https://cloud.test/", benutzer: "henning", ordner: "01 Projekte", passwort: "app-passwort-123" } }); + expect(r.statusCode, r.body).toBe(200); + const z = (await app.inject("/api/nextcloud")).json(); + expect(z).toMatchObject({ adresse: "https://cloud.test", passwortGesetzt: true, webdav: "https://cloud.test/remote.php/dav/files/henning/01%20Projekte" }); + expect(JSON.stringify(z)).not.toContain("app-passwort-123"); + expect((await app.inject("/api/export")).body).not.toContain("app-passwort-123"); + expect((await app.inject("/api/einstellungen")).body).not.toContain("app-passwort-123"); + // Prüfen: Ordner erreichbar, Statusordner fehlen noch + let p = (await app.inject({ method: "POST", url: "/api/nextcloud/pruefen" })).json(); + expect(p).toMatchObject({ ok: true, vorhanden: [], fehlen: ["01 Angebot", "02 laufende Projekte", "03 Gewährl.-Projekte", "04 Archiv"] }); + f.ordner.add(`${f.wurzel}/02 laufende Projekte`); + f.ordner.add(`${f.wurzel}/02 laufende Projekte/P-26-151 Dachgaube`); + p = (await app.inject({ method: "POST", url: "/api/nextcloud/pruefen" })).json(); + expect(p.vorhanden).toEqual(["02 laufende Projekte"]); + // alle Projekte abgleichen: vorhandener Ordner wird übernommen, fehlender angelegt + await app.inject({ method: "POST", url: "/api/projekte", payload: { nummer: "P-26-151", bezeichnung: "Dachgaube", status: "auftrag" } }); + const a = (await app.inject({ method: "POST", url: "/api/nextcloud/abgleichen" })).json(); + expect(a).toEqual({ ok: 2, fehler: [] }); + expect(f.relativ()).toContain("01 Angebot/A-26-150 Vordach/03 Bilder"); + expect(f.relativ().filter((o) => o.startsWith("02 laufende Projekte/P-26-151"))).toContain("02 laufende Projekte/P-26-151 Dachgaube"); + // leeres Passwort behält das alte; löschen schaltet den Zugang ab + await app.inject({ method: "PUT", url: "/api/nextcloud", payload: { adresse: "https://cloud.test", benutzer: "henning", ordner: "01 Projekte", passwort: "" } }); + expect((await app.inject("/api/nextcloud")).json().passwortGesetzt).toBe(true); + await app.inject({ method: "PUT", url: "/api/nextcloud", payload: { adresse: "https://cloud.test", benutzer: "henning", ordner: "01 Projekte", passwortLoeschen: true } }); + expect((await app.inject("/api/nextcloud")).json().passwortGesetzt).toBe(false); + }); + + it("Browser-Testversion: Adresse ja, App-Passwort erst auf dem Server", async () => { + const t = await baueApp({ pool, webOrdner: "/gibt-es-nicht", nextcloudEinrichtbar: false, anmeldung: "testversion" }); + const r = await t.inject({ method: "PUT", url: "/api/nextcloud", payload: { adresse: "https://cloud.test", benutzer: "henning", ordner: "01 Projekte", passwort: "x" } }); + expect(r.statusCode).toBe(409); + expect((await t.inject({ method: "PUT", url: "/api/nextcloud", payload: { adresse: "https://cloud.test", benutzer: "henning", ordner: "01 Projekte" } })).statusCode).toBe(200); + expect((await t.inject({ method: "POST", url: "/api/nextcloud/pruefen" })).json().fehler).toMatch(/erst auf dem Server/); + await t.close(); + }); +}); + describe.skipIf(!url)("Sicherung einspielen (Umzug aus der Testversion)", () => { let pool: Pool; let app: FastifyInstance; diff --git a/test/falsche-nextcloud.ts b/test/falsche-nextcloud.ts index 2d351f4..2a927ef 100644 --- a/test/falsche-nextcloud.ts +++ b/test/falsche-nextcloud.ts @@ -39,5 +39,5 @@ export function falscheNextcloud(basis = "https://cloud.test/remote.php/dav/file return new Response(null, { status: 400 }); }) as typeof fetch; const relativ = () => [...ordner].filter((o) => o !== wurzel).map((o) => o.slice(wurzel.length + 1)).sort(); - return { nc: new Nextcloud({ url: basis, benutzer: "henning", passwort: "geheim" }, abruf), ordner, dateien, wurzel, relativ }; + return { nc: new Nextcloud({ url: basis, benutzer: "henning", passwort: "geheim" }, abruf), abruf, ordner, dateien, wurzel, relativ }; }