0.31.0: Nextcloud-Zugang als Maske unter Daten (P10)
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
This commit is contained in:
@@ -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";
|
||||
}
|
||||
|
||||
|
||||
@@ -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<FastifyInstance> {
|
||||
|
||||
// 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<Nextcloud | undefined> {
|
||||
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<string, any>, wer: string): Promise<Record<string, unknown>> {
|
||||
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<FastifyInstance> {
|
||||
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<FastifyInstance> {
|
||||
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<FastifyInstance> {
|
||||
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)}`);
|
||||
|
||||
@@ -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
|
||||
|
||||
9
src/server/migrations/024_nextcloud_zugang.sql
Normal file
9
src/server/migrations/024_nextcloud_zugang.sql
Normal file
@@ -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
|
||||
);
|
||||
@@ -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/<benutzer>) 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 {
|
||||
|
||||
@@ -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<void> {
|
||||
const ziel = document.getElementById("nextcloud");
|
||||
if (!ziel) return;
|
||||
const z = await api<Zeile>("nextcloud");
|
||||
const zeile = (titel: string, wert: string) => `<tr><th>${titel}</th><td>${wert}</td></tr>`;
|
||||
ziel.innerHTML = `<p class="hinweis">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.</p>
|
||||
${z.fest ? '<p class="hinweis">Der Zugang ist auf dem Server fest eingetragen und gilt vor den Angaben hier.</p>' : ""}
|
||||
<table class="nc-zugang"><tbody>
|
||||
${zeile("Adresse", z.adresse ? esc(z.adresse) : '<span class="leise">noch nicht eingetragen</span>')}
|
||||
${zeile("Benutzer", z.benutzer ? esc(z.benutzer) : '<span class="leise">–</span>')}
|
||||
${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 ? '<span class="leise">fehlt</span>' : '<span class="leise">wird auf dem Server eingetragen</span>')}
|
||||
${z.webdav ? zeile("WebDAV", `<small>${esc(z.webdav)}</small>`) : ""}
|
||||
</tbody></table>
|
||||
${meldung}
|
||||
<p class="knopfzeile"><button class="neben" data-nc="bearbeiten">Zugang eintragen</button>
|
||||
${z.einrichtbar || z.fest ? `<button class="neben" data-nc="pruefen">Verbindung prüfen</button>
|
||||
<button class="neben" data-nc="abgleichen">Alle Projektordner abgleichen</button>` : ""}</p>
|
||||
${z.einrichtbar ? "" : '<p class="hinweis">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.</p>'}`;
|
||||
ziel.onclick = async (ev) => {
|
||||
const a = (ev.target as HTMLElement).closest<HTMLElement>("[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('<p class="erfolg">Gespeichert.</p>');
|
||||
} catch (err) { return nextcloudZugang(`<p class="fehler">${esc((err as Error).message)}</p>`); }
|
||||
}
|
||||
if (a === "pruefen") {
|
||||
try {
|
||||
const p = await api<Zeile>("nextcloud/pruefen", "POST");
|
||||
return nextcloudZugang(p.ok
|
||||
? `<p class="erfolg">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(", ")}.` : ""}</p>`
|
||||
: `<p class="fehler">${esc(p.fehler)}</p>`);
|
||||
} catch (err) { return nextcloudZugang(`<p class="fehler">${esc((err as Error).message)}</p>`); }
|
||||
}
|
||||
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(`<p class="${r.fehler.length ? "warnung" : "erfolg"}">${r.ok} Projektordner abgeglichen.${r.fehler.length ? ` Nicht geklappt: ${r.fehler.map(esc).join("; ")}` : ""}</p>`);
|
||||
} catch (err) { return nextcloudZugang(`<p class="fehler">${esc((err as Error).message)}</p>`); }
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
function kalenderLinks(token: string | null): void {
|
||||
const ziel = document.getElementById("kalender")!;
|
||||
const neu = async () => {
|
||||
@@ -881,6 +938,8 @@ async function daten(): Promise<void> {
|
||||
<p class="hinweis">Sicherungsdatei aus V70 wählen (projektplaner-sicherung-….json). Geht nur, solange noch nichts erfasst ist.</p>
|
||||
<p><input type="file" id="v70-datei" accept=".json,application/json"></p>
|
||||
<div id="v70-ergebnis"></div>
|
||||
<h2>Nextcloud (Projektordner)</h2>
|
||||
<div id="nextcloud"></div>
|
||||
<h2>Kalender in Outlook</h2>
|
||||
<div id="kalender"></div>
|
||||
<h2>Einstellungen</h2>`);
|
||||
@@ -891,6 +950,7 @@ async function daten(): Promise<void> {
|
||||
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];
|
||||
|
||||
@@ -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; }
|
||||
|
||||
Reference in New Issue
Block a user