dogfather-universe/server/mess-eingang-optik.mjs

/* =====================================================================
   WIE DER EINGANG AUSSIEHT (25.09.2026)

   Filipe zum Bildschirmfoto der Seite: „lass das bitte auch geiler
   aussehen bitte."

   SIE PRUEFT NICHTS und meldet keinen Fehlschlag -- sie macht Bilder,
   auf denen man nachsehen kann. Deshalb `mess-` und nicht `pruef-`.

   ZWEI BREITEN, und die kleinere ist die wichtigere: Ab 760 px steht
   das Bild neben dem Text, darunter untereinander. Wer nur die grosse
   ansieht, sieht die Haelfte der Regel nicht.

   EIGENE WEGWERF-DATENBANK: Es entsteht eine echte Meldung mit Bild.
   In einem laufenden System waeren das Testdaten, und die sind
   verboten. Hier liegt alles in einem `mktemp`-Ordner.

   Aufrufen mit:  node server/mess-eingang-optik.mjs
   ===================================================================== */
import { mkdtempSync, rmSync, readFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { execFileSync } from "node:child_process";
import { request as httpAnfrage } from "node:http";
import { createServer as httpsServer } from "node:https";

const PORT = 5401, HP = 5402;
const CREW = "crew.dogfather-universe.com";
const ordner = mkdtempSync(join(tmpdir(), "ws-eingang-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
process.env.PORT = String(PORT);
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";

const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) {
  return ec.call(this, n, w, { ...(o || {}), secure: false });
};
import { notbremse } from "./helfer-notbremse.mjs";
await import("./index.js");
notbremse(240_000, "mess-eingang-optik");
await new Promise((r) => setTimeout(r, 900));
process.on("uncaughtException", (f) => { console.error("ABSTURZ:", f); process.exit(7); });
process.on("unhandledRejection", (f) => { console.error("ABSTURZ (Versprechen):", f); process.exit(7); });

const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes, createHmac } = await import("node:crypto");
const d = new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();
const sch = randomBytes(32).toString("hex");
d.prepare("INSERT INTO einstellungen (schluessel, wert, geaendert, von)"
  + " VALUES (?,?,?,NULL) ON CONFLICT(schluessel) DO NOTHING")
  .run("code_kennung_schluessel", sch, jetzt);
const anlegen = (name, rolle, code) => {
  const s = randomBytes(16).toString("hex");
  const h = scryptSync(code, s, 64,
    { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
  return d.prepare("INSERT INTO personen"
    + " (name, rolle, code_hash, code_salt, code_n, code_kennung, aktiv, erstellt)"
    + " VALUES (?,?,?,?,?,?,1,?) RETURNING id")
    .get(name, rolle, h, s, 32768,
      createHmac("sha256", sch).update(code).digest("hex"), jetzt).id;
};
anlegen("Filipe", "admin", "CODE-DOGI-0001");
const idModi = anlegen("Miss", "modi", "CODE-MODI-0001");
const idM2 = anlegen("Marina", "modi", "CODE-MODI-0002");

/* Ein winziges PNG als Anhang -- es geht um die FORM der Karte, nicht
   um das Motiv. 1x1 Bildpunkt reicht dafuer nicht: Der Kasten waere
   dann zwei Pixel gross und man saehe die Spaltenaufteilung nicht.
   Deshalb ein hochkantes Rechteck, so wie ein Handy-Bildschirmfoto. */
const png = Buffer.from(
  "iVBORw0KGgoAAAANSUhEUgAAAGQAAADwCAYAAAB7ovsMAAAAWklEQVR42u3QMQEAAAjAoNu/"
  + "tBmeIAfpVoAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAAAQIECBAgQIAA"
  + "AQIECBAgQIAAAQIECBAgQIAAAe4W1H8B4aXvOgAAAABJRU5ErkJggg==", "base64");
d.prepare(`INSERT INTO support_meldungen
    (person_id, text, seite, bild_datei, bild_typ, bild_breite, bild_hoehe,
     stand, erstellt, geaendert)
  VALUES (?,?,?,?,?,?,?,?,?,?)`)
  .run(idModi,
    "Ich konnte da wieder nicht zurück gehen, musste die App schließen "
    + "damit ich wieder auf die Hauptseite kam",
    "/workspace/support.html", "probe.png", "image/png", 100, 240,
    "in_arbeit", jetzt, jetzt);
d.prepare(`INSERT INTO support_meldungen
    (person_id, text, seite, stand, erstellt, geaendert)
  VALUES (?,?,?,?,?,?)`)
  .run(idM2, "Der Kalender springt beim Wischen manchmal zwei Monate weiter.",
    "/workspace/kalender.html", "neu", jetzt, jetzt);
/* Die Bilddatei dort ablegen, wo die Route sie sucht. */
const { DATEN_ORDNER } = await import("./workspace.js");
try {
  const { mkdirSync, writeFileSync } = await import("node:fs");
  const ziel = join(DATEN_ORDNER, "support");
  mkdirSync(ziel, { recursive: true });
  writeFileSync(join(ziel, "probe.png"), png);
} catch (f) { console.log("Bild nicht abgelegt:", f?.message); }
d.close();

const anfrage = (pfad, art, koerper) => new Promise((fertig, schief) => {
  const a = httpAnfrage({
    host: "127.0.0.1", port: PORT, path: pfad, method: art,
    headers: { Host: CREW, "Content-Type": "application/json" },
  }, (r) => {
    let t = ""; r.on("data", (x) => { t += x; });
    r.on("end", () => fertig({ code: r.statusCode, kopf: r.headers, text: t }));
  });
  a.on("error", schief);
  if (koerper) a.write(JSON.stringify(koerper));
  a.end();
});
const an = await anfrage("/workspace/api/anmelden", "POST",
  { rolle: "admin", code: "CODE-DOGI-0001" });
if (an.code !== 200) { console.log(`ABBRUCH: Anmeldung ${an.code}`); process.exit(2); }
const keks = (an.kopf["set-cookie"] || []).map((x) => x.split(";")[0]).join("; ");

const schl = join(ordner, "b.key"), zert = join(ordner, "b.crt");
execFileSync("openssl", ["req", "-x509", "-newkey", "rsa:2048", "-nodes", "-keyout", schl,
  "-out", zert, "-days", "2", "-subj", `/CN=${CREW}`, "-addext", `subjectAltName=DNS:${CREW}`],
{ stdio: "ignore" });
const vorbau = httpsServer({ key: readFileSync(schl), cert: readFileSync(zert) },
  (von, nach) => {
    const w = httpAnfrage({
      host: "127.0.0.1", port: PORT, path: von.url, method: von.method,
      headers: { ...von.headers, host: `${CREW}:${HP}` },
    }, (a) => { nach.writeHead(a.statusCode || 502, a.headers); a.pipe(nach); });
    von.pipe(w);
  });
await new Promise((r) => vorbau.listen(HP, "127.0.0.1", r));

const pw = await import(
  "file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
const browser = await pw.chromium.launch({
  args: [`--host-resolver-rules=MAP ${CREW} 127.0.0.1`, "--ignore-certificate-errors"],
});
try {
  for (const [wie, breite, hoehe] of [["computer", 1280, 1100], ["handy", 412, 915]]) {
    const kontext = await browser.newContext({ viewport: { width: breite, height: hoehe } });
    await kontext.addCookies(keks.split("; ").map((k) => {
      const [n, ...r] = k.split("=");
      return { name: n, value: r.join("="), domain: CREW, path: "/" };
    }));
    const seite = await kontext.newPage();
    const konsole = [];
    seite.on("console", (e) => {
      if (e.type() === "error" && !/favicon|ERR_CERT|net::ERR/i.test(e.text())) {
        konsole.push(e.text().slice(0, 140));
      }
    });
    await seite.goto(`https://${CREW}:${HP}/workspace/support.html`, { waitUntil: "networkidle" });
    await seite.waitForTimeout(1400);
    const blick = await seite.evaluate(() => {
      const block = document.getElementById("eingang-block");
      const karten = [...document.querySelectorAll(".s-karte")];
      const mitBild = karten.find((k) => k.querySelector(".s-karte__bild"));
      const spalten = mitBild ? getComputedStyle(mitBild).gridTemplateColumns : "-";
      return {
        eingangSichtbar: !!(block && !block.hidden),
        karten: karten.length,
        mitBild: !!mitBild,
        spalten,
        felder: document.querySelectorAll(".s-bilanz__feld").length,
        leerMarkiert: document.querySelectorAll('.s-bilanz__feld[data-leer="ja"]').length,
      };
    });
    console.log(`\n=== Eingang, ${breite} x ${hoehe} (${wie}) ===`);
    for (const [k, v] of Object.entries(blick)) console.log(`  ${k.padEnd(16)} ${v}`);
    if (konsole.length) console.log("  FEHLER IN DER KONSOLE:", konsole);
    const ziel = seite.locator("#eingang-block");
    if (await ziel.count()) {
      await ziel.screenshot({ path: `server/mess-eingang-${wie}.png` }).catch(() => {});
      console.log(`  Bild: server/mess-eingang-${wie}.png`);
    }
    await kontext.close();
  }
} finally {
  await browser.close();
  vorbau.close();
  try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
  process.exit(0);
}