saltcorn-samba 0.4.14 → 0.4.16

package/i18n.js

@@ -0,0 +1,155 @@
+/**
+ * saltcorn-samba – Minimales i18n-Modul (Server-Seite).
+ *
+ * Design-Ziele:
+ *   - Keine externe Dependency (kein i18next, keine intl-messageformat).
+ *   - JSON-Kataloge unter ./i18n/<locale>.json.
+ *   - Lazy load + Cache; unbekannte Locales fallen automatisch auf `en`.
+ *   - Placeholder-Syntax {name} wird durch die übergebenen Werte ersetzt.
+ *
+ * Locale-Auflösung (in dieser Reihenfolge):
+ *   1. Explizit übergebener Wert (Request-Query ?locale=de).
+ *   2. `req.getLocale()` (Saltcorn setzt das aus Cookie / Accept-Language).
+ *   3. `req.headers["accept-language"]`  – erste passende Locale.
+ *   4. Fallback = `en`.
+ *
+ * Die Client-Seite bekommt den passenden Katalog via Route
+ *   GET /samba-i18n.json?locale=xx
+ * (siehe index.js). Dort ruft samba-common.js `SambaCommon.setCatalog(...)` auf.
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const CATALOG_DIR = path.join(__dirname, "i18n");
+const DEFAULT_LOCALE = "en";
+const catalogs = Object.create(null);       // locale -> { key: str }
+const availableLocales = new Set(["de", "en"]);
+
+/**
+ * Load a catalogue from disk. Cached forever (plugin restart to reload).
+ * Missing files silently return {} — the caller falls back to the key itself.
+ */
+function loadCatalog(locale) {
+  if (catalogs[locale]) return catalogs[locale];
+  const file = path.join(CATALOG_DIR, locale + ".json");
+  try {
+    const raw = fs.readFileSync(file, "utf8");
+    const parsed = JSON.parse(raw);
+    delete parsed.$meta;   // metadata is not a translation
+    catalogs[locale] = parsed;
+  } catch (_) {
+    catalogs[locale] = {};
+  }
+  return catalogs[locale];
+}
+
+/**
+ * Resolve a locale string to one we actually ship a catalogue for.
+ * Accepts full IETF tags ("de-DE", "en-US") and language-only ("de", "en").
+ */
+function normaliseLocale(raw) {
+  if (!raw) return DEFAULT_LOCALE;
+  const lc = String(raw).toLowerCase().trim();
+  if (availableLocales.has(lc)) return lc;
+  const short = lc.split(/[-_]/)[0];
+  if (availableLocales.has(short)) return short;
+  return DEFAULT_LOCALE;
+}
+
+/**
+ * Extract the caller's preferred locale from an Express-like request object.
+ * Never throws; falls back to DEFAULT_LOCALE.
+ */
+function resolveLocaleFromReq(req, explicit) {
+  if (explicit) return normaliseLocale(explicit);
+  try {
+    if (req) {
+      // Saltcorn / i18next-express-middleware
+      if (typeof req.getLocale === "function") {
+        const l = req.getLocale();
+        if (l) return normaliseLocale(l);
+      }
+      // Explicit query ?locale=de
+      if (req.query && req.query.locale) {
+        return normaliseLocale(req.query.locale);
+      }
+      // Accept-Language header – take the first tag we understand.
+      const hdr = req.headers && req.headers["accept-language"];
+      if (hdr) {
+        const first = String(hdr).split(",")[0].split(";")[0];
+        return normaliseLocale(first);
+      }
+    }
+  } catch (_) {
+    // fall through
+  }
+  return DEFAULT_LOCALE;
+}
+
+/**
+ * Substitute {placeholder} tokens in the message. Missing values render as "".
+ */
+function interpolate(msg, params) {
+  if (!params) return msg;
+  return String(msg).replace(/\{(\w+)\}/g, (_, key) =>
+    Object.prototype.hasOwnProperty.call(params, key) ? String(params[key]) : ""
+  );
+}
+
+/**
+ * Translate a single key. Falls back to English, then to the key itself so
+ * a missing translation never breaks the UI.
+ *
+ *   t("fm.upload.button", { locale: "de" })                → "Hochladen"
+ *   t("fm.deleted_ok", { locale: "de", name: "foo.txt" }) → "„foo.txt\" gelöscht"
+ */
+function t(key, params) {
+  const opts = params || {};
+  const locale = normaliseLocale(opts.locale);
+  const primary = loadCatalog(locale);
+  if (Object.prototype.hasOwnProperty.call(primary, key)) {
+    return interpolate(primary[key], opts);
+  }
+  if (locale !== DEFAULT_LOCALE) {
+    const fallback = loadCatalog(DEFAULT_LOCALE);
+    if (Object.prototype.hasOwnProperty.call(fallback, key)) {
+      return interpolate(fallback[key], opts);
+    }
+  }
+  return key;
+}
+
+/**
+ * Bind a locale so callers can write `const _ = tFor("de"); _("ui.close")`.
+ */
+function tFor(locale) {
+  const loc = normaliseLocale(locale);
+  return function boundTranslate(key, params) {
+    return t(key, Object.assign({}, params || {}, { locale: loc }));
+  };
+}
+
+/**
+ * Return the raw catalogue for a locale, merged over the English defaults.
+ * Used to ship a single JSON blob to the browser.
+ */
+function catalogFor(locale) {
+  const loc = normaliseLocale(locale);
+  const en = loadCatalog(DEFAULT_LOCALE);
+  if (loc === DEFAULT_LOCALE) return Object.assign({}, en);
+  const merged = Object.assign({}, en, loadCatalog(loc));
+  return merged;
+}
+
+module.exports = {
+  DEFAULT_LOCALE,
+  availableLocales: Array.from(availableLocales),
+  t,
+  tFor,
+  catalogFor,
+  resolveLocaleFromReq,
+  normaliseLocale,
+};

package/index.js

@@ -50,6 +50,11 @@ const {
 } = require("./smb-client");
 const treeView = require("./tree-view");
 const fileManagerView = require("./filemanager-view");
+const {
+  catalogFor,
+  resolveLocaleFromReq,
+  availableLocales,
+} = require("./i18n");
 // pdf-view is intentionally NOT wired into the manifest (see note at bottom).
 // The file is kept in the package so the DB-linkage release can revive it.
 
@@ -519,22 +524,18 @@ function jsonOk(res, extra) {
 }
 
 /**
- * Validate that the request carries a CSRF token matching the session.
- * Saltcorn injects `req.csrfToken()` when the CSRF middleware is active;
- * we accept either the `_csrf` body field or the `x-csrf-token` header.
+ * CSRF verification is handled by Saltcorn's global csurf middleware
+ * (packages/server/app.js). By the time our route handler runs, csurf
+ * has already validated req.body._csrf / X-CSRF-Token / csrf-token /
+ * xsrf-token headers against the session secret. A manual re-check
+ * here would be wrong: csrf-tokens returns a NEW salted token on
+ * every call to req.csrfToken(), so `provided !== req.csrfToken()`
+ * would fail even for perfectly valid requests.
+ *
+ * We keep this stub as the single documented spot to attach future
+ * pre-flight authorisation checks if ever needed.
  */
-function checkCsrf(req, res) {
-  if (typeof req.csrfToken !== "function") return true; // CSRF disabled globally
-  const expected = req.csrfToken();
-  const provided =
-    (req.body && req.body._csrf) ||
-    req.headers["x-csrf-token"] ||
-    req.headers["csrf-token"] ||
-    req.query._csrf;
-  if (!provided || provided !== expected) {
-    jsonError(res, 403, "Invalid CSRF token");
-    return false;
-  }
+function checkCsrf(_req, _res) {
   return true;
 }
 
@@ -1267,6 +1268,35 @@ code{background:#f4f4f4;padding:2px 6px;border-radius:3px;word-break:break-all}<
     },
   },
 
+  {
+    // GET /samba-i18n.json?locale=xx
+    //
+    // Liefert den vollen \u00dcbersetzungskatalog f\u00fcr die Client-Seite. Wird
+    // aktuell NICHT vom Standard-Bootstrap benutzt (die View-Shells injizieren
+    // den Katalog inline, spart einen Roundtrip). Die Route ist f\u00fcr
+    // externe Consumer / Debugging / dynamisches Nachladen einer anderen
+    // Sprache im Browser gedacht.
+    //
+    // Keine Authentifizierung: Katalog enth\u00e4lt nur \u00dcbersetzungstext,
+    // keine Konfiguration und keine share-spezifischen Daten.
+    url: "/samba-i18n.json",
+    method: "get",
+    callback: async (req, res) => {
+      try {
+        const locale = resolveLocaleFromReq(req, req.query && req.query.locale);
+        const catalog = catalogFor(locale);
+        res.setHeader("Content-Type", "application/json; charset=utf-8");
+        // Kurzer Cache: Katalog \u00e4ndert sich nur bei Plugin-Release.
+        res.setHeader("Cache-Control", "public, max-age=300");
+        res.setHeader("X-Samba-Locale", locale);
+        res.setHeader("X-Samba-Available-Locales", availableLocales.join(","));
+        res.json(catalog);
+      } catch (e) {
+        res.status(500).json({ error: "i18n: " + (e.message || String(e)) });
+      }
+    },
+  },
+
   {
     url: "/sambamkdir",
     method: "post",

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "saltcorn-samba",
-  "version": "0.4.14",
+  "version": "0.4.16",
   "description": "Saltcorn plugin: browse, upload, rename and delete files on a Samba/CIFS share via SMB 3.1.1 (AES-CMAC signing, optional encryption). File-manager view, directory tree, inline PDF viewer, external-app open (smb://).",
   "main": "index.js",
   "scripts": {
     "test": "node test/sanitize.test.js",
-    "lint": "node --check index.js && node --check smb-client.js && node --check readdir-compat.js && node --check tree-view.js && node --check filemanager-view.js && node --check pdf-view.js && node --check public/samba-tree.js && node --check public/samba-filemanager.js",
+    "lint": "node --check index.js && node --check smb-client.js && node --check readdir-compat.js && node --check tree-view.js && node --check filemanager-view.js && node --check pdf-view.js && node --check i18n.js && node --check public/samba-tree.js && node --check public/samba-filemanager.js && node --check public/samba-common.js",
     "prepublishOnly": "npm run lint && npm test"
   },
   "keywords": [
@@ -43,6 +43,8 @@
     "tree-view.js",
     "filemanager-view.js",
     "pdf-view.js",
+    "i18n.js",
+    "i18n/",
     "public/",
     "tools/",
     "README.md",

package/pdf-view.js

@@ -20,6 +20,7 @@ const {
   button,
 } = require("@saltcorn/markup/tags");
 const { text } = require("@saltcorn/markup");
+const { tFor, resolveLocaleFromReq } = require("./i18n");
 
 /** Extract the file extension in lowercase, without the dot. */
 function extOf(name) {
@@ -88,7 +89,9 @@ const samba_pdf = {
     },
   ],
   run: (value, req, options = {}) => {
-    if (!value) return span({ class: "text-muted" }, "—");
+    // Locale aus dem Saltcorn-Request; bei fehlendem req greift automatisch "en".
+    const _t = tFor(resolveLocaleFromReq(req));
+    if (!value) return span({ class: "text-muted" }, _t("pdf.empty"));
     const safeVal = text(String(value));
     const height = Number(options.height) > 0 ? Number(options.height) : 700;
 
@@ -101,7 +104,7 @@ const samba_pdf = {
             class: "btn btn-sm btn-outline-secondary me-2",
           },
           i({ class: "fas fa-download me-1" }),
-          "Download"
+          _t("pdf.download")
         )
       );
     }
@@ -111,10 +114,10 @@ const samba_pdf = {
           {
             href: smbUrl(safeVal),
             class: "btn btn-sm btn-outline-primary me-2",
-            title: "Open in Nemo/Nautilus/Explorer",
+            title: _t("pdf.open_in_fm_title"),
           },
           i({ class: "fas fa-external-link-alt me-1" }),
-          "Open in file manager"
+          _t("pdf.open_in_fm")
         )
       );
     }
@@ -126,7 +129,7 @@ const samba_pdf = {
           class: "btn btn-sm btn-outline-secondary",
         },
         i({ class: "fas fa-eye me-1" }),
-        "Open in new tab"
+        _t("pdf.open_new_tab")
       )
     );
 

package/public/samba-common.js

@@ -0,0 +1,175 @@
+/**
+ * saltcorn-samba – Gemeinsame Client-Utilities für den Browser.
+ *
+ * Wird von samba-filemanager.js und samba-tree.js benutzt. Enthält:
+ *   - iconFor(item)             : Emoji-Icon für Verzeichnisse/Dateien
+ *                                 (früher in beiden JS-Dateien dupliziert)
+ *   - extOf(name)               : Extension in lower-case, ohne Punkt
+ *   - joinPath(a, b), parentOf  : simple posix-artige Pfad-Helfer
+ *   - fmtSize(bytes), fmtDate(v): menschenlesbare Formatierung
+ *   - isViewable(name)          : PDFs, Bilder, Text-artige Dateien
+ *   - mediaTypeFor(item)        : grober MIME-Typ (auch nur für File-Manager)
+ *   - t(key, params)            : i18n-Übersetzung. Katalog wird nach dem
+ *                                 Laden asynchron nachgeschoben; solange nur
+ *                                 der Key nicht auffindbar ist, gilt der Key
+ *                                 selbst als Rückfalltext.
+ *   - setCatalog(obj)           : setzt den i18n-Katalog (aus dem Server-JSON)
+ *   - loadCatalog(url)          : lädt einen JSON-Katalog per fetch()
+ *
+ * Alles wird an `window.SambaCommon` gehängt. Die Datei ist absichtlich in
+ * ES5 gehalten (kein Bundler-Zwang, funktioniert in älteren Browsern).
+ */
+(function () {
+  "use strict";
+
+  // ---- i18n-State ---------------------------------------------------------
+  var catalog = {};
+
+  function setCatalog(obj) {
+    catalog = obj && typeof obj === "object" ? obj : {};
+  }
+
+  /** Löst {name}-Platzhalter im Muster auf. */
+  function interpolate(msg, params) {
+    if (!params) return msg;
+    return String(msg).replace(/\{(\w+)\}/g, function (_, k) {
+      return Object.prototype.hasOwnProperty.call(params, k) ? String(params[k]) : "";
+    });
+  }
+
+  /** Übersetzt einen Key. Fällt auf den Key selbst zurück, falls kein Eintrag. */
+  function t(key, params) {
+    if (Object.prototype.hasOwnProperty.call(catalog, key)) {
+      return interpolate(catalog[key], params);
+    }
+    return interpolate(key, params);
+  }
+
+  /**
+   * Lädt den Katalog von der übergebenen URL (z. B. /samba-i18n.json?locale=de).
+   * Ergebnis wird gecacht; scheitert der Fetch, bleibt der aktuelle Katalog stehen.
+   */
+  function loadCatalog(url) {
+    return fetch(url, { credentials: "same-origin" })
+      .then(function (r) { return r.ok ? r.json() : {}; })
+      .then(function (data) { setCatalog(data); return data; })
+      .catch(function () { return {}; });
+  }
+
+  // ---- reine Utilities ---------------------------------------------------
+  /** Extension in lower-case, ohne führenden Punkt. */
+  function extOf(name) {
+    var s = String(name || "");
+    var dot = s.lastIndexOf(".");
+    return dot >= 0 ? s.slice(dot + 1).toLowerCase() : "";
+  }
+
+  /**
+   * Einheitliches Icon für Verzeichnisse und Dateien.
+   * Die Kategorien decken die häufigsten Office-, Bild-, Archiv-, Audio- und
+   * Video-Formate ab. Alles Unbekannte bekommt 📎.
+   */
+  function iconFor(item) {
+    if (item && item.isDir) return "📁";
+    var e = extOf(item && item.name);
+    if (e === "pdf") return "📄";
+    if (["png", "jpg", "jpeg", "gif", "webp", "svg", "bmp"].indexOf(e) >= 0) return "🖼️";
+    if (["doc", "docx", "odt", "rtf", "txt", "md"].indexOf(e) >= 0) return "📝";
+    if (["xls", "xlsx", "ods", "csv"].indexOf(e) >= 0) return "📊";
+    if (["ppt", "pptx", "odp"].indexOf(e) >= 0) return "📽️";
+    if (["zip", "tar", "gz", "7z", "rar"].indexOf(e) >= 0) return "🗜️";
+    if (["mp3", "wav", "ogg", "flac", "m4a"].indexOf(e) >= 0) return "🎵";
+    if (["mp4", "mkv", "mov", "avi", "webm"].indexOf(e) >= 0) return "🎬";
+    return "📎";
+  }
+
+  /** Erlaubt inline-Anzeige im integrierten Viewer (PDF, Bilder, Text). */
+  function isViewable(name) {
+    var n = String(name || "").toLowerCase();
+    return (
+      n.endsWith(".pdf") ||
+      /\.(png|jpe?g|gif|webp|svg|bmp)$/.test(n) ||
+      /\.(txt|md|json|xml|csv|html?)$/.test(n)
+    );
+  }
+
+  /**
+   * Grober MIME-Typ nur anhand der Extension – ausreichend zum Sortieren und
+   * für die "Media type"-Spalte. Der Server liefert für den echten Stream
+   * seinen eigenen (genaueren) Content-Type.
+   */
+  function mediaTypeFor(item) {
+    if (item && item.isDir) return "folder";
+    var e = extOf(item && item.name);
+    var map = {
+      pdf: "application/pdf",
+      png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg",
+      gif: "image/gif", webp: "image/webp", svg: "image/svg+xml",
+      txt: "text/plain", md: "text/markdown", csv: "text/csv",
+      json: "application/json", xml: "application/xml",
+      html: "text/html", htm: "text/html",
+      zip: "application/zip", doc: "application/msword",
+      docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+      xls: "application/vnd.ms-excel",
+      xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+      ppt: "application/vnd.ms-powerpoint",
+      pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+      mp3: "audio/mpeg", mp4: "video/mp4", mkv: "video/x-matroska",
+      mov: "video/quicktime", avi: "video/x-msvideo",
+    };
+    return map[e] || (e ? "application/" + e : "application/octet-stream");
+  }
+
+  /** Größe in KiB/MiB/GiB. Kompakter Format-String für Tabellen und Bäume. */
+  function fmtSize(n) {
+    if (!n || n < 0) return "";
+    if (n < 1024) return n + " B";
+    var kib = n / 1024;
+    if (kib < 1024) return kib.toFixed(kib < 10 ? 1 : 0) + " KiB";
+    var mib = kib / 1024;
+    if (mib < 1024) return mib.toFixed(mib < 10 ? 1 : 0) + " MiB";
+    return (mib / 1024).toFixed(2) + " GiB";
+  }
+
+  /** ISO-artig, ohne Sekunden ("2026-07-08 22:31"). Leere/ungültige Werte → "". */
+  function fmtDate(v) {
+    if (!v) return "";
+    var d = new Date(v);
+    if (isNaN(d.getTime())) return "";
+    var pad = function (x) { return String(x).padStart(2, "0"); };
+    return d.getFullYear() + "-" + pad(d.getMonth() + 1) + "-" + pad(d.getDate()) +
+      " " + pad(d.getHours()) + ":" + pad(d.getMinutes());
+  }
+
+  /** Fügt zwei Pfad-Fragmente mit genau einem "/" zusammen. */
+  function joinPath(a, b) {
+    if (!a) return b;
+    if (!b) return a;
+    return (a.replace(/\/+$/, "") + "/" + b.replace(/^\/+/, "")).replace(/\/+/g, "/");
+  }
+
+  /** Übergeordneter Pfad. `parentOf("a/b/c")` = "a/b", `parentOf("a")` = "". */
+  function parentOf(p) {
+    if (!p) return "";
+    var i = p.lastIndexOf("/");
+    return i < 0 ? "" : p.slice(0, i);
+  }
+
+  // ---- Export -------------------------------------------------------------
+  window.SambaCommon = {
+    // i18n
+    t: t,
+    setCatalog: setCatalog,
+    loadCatalog: loadCatalog,
+    // icons / classification
+    iconFor: iconFor,
+    isViewable: isViewable,
+    mediaTypeFor: mediaTypeFor,
+    // strings & paths
+    extOf: extOf,
+    fmtSize: fmtSize,
+    fmtDate: fmtDate,
+    joinPath: joinPath,
+    parentOf: parentOf,
+  };
+})();