Public-API, mehrseitige Schriftstücke, manuelle Aufträge & Mailer

Public-API (neu, directus-extension-skrift-api):
- Versionierter /v1-Namespace: POST /v1/orders, GET /v1/orders/:nr (Status
  pending/processing/shipped/cancelled), POST /v1/files (nur PDF, ≤80 MB).
- Auth über X-Api-Key (Authorization ist von Directus reserviert), SHA-256-Hash.
- Produkt-gebunden; Kuvert-only-Produkttyp; Kuvertformat automatisch (A4→DIN Lang, sonst C6);
  kein Platzhalter, kein Kunden-multipage/font_scale; Versandart englisch (single/bulk).
- Selbst gehostete Swagger-UI-Doku (/docs) + OpenAPI (/v1/openapi.json), englisch/technisch.
- Key-Hook (directus-extension-skrift-apikey): erzeugt Key automatisch, zeigt ihn
  einmalig in key_plain.

Mehrseitige Schriftstücke:
- generateLetterPages (Auto-Fluss, [[seitenumbruch]], Leerseiten-Filter).
- Preview/Order-Generierung schreiben letter_NNN_pM.svg; Seiten-Übersicht im Neuauftrag.
- Agent (skrift-agent): Seiten je Brief absteigend an den Plotter (Stapel-Reihenfolge).
- countLetterPages + /api/order/pagecount für die Seiten-Vorschau.

Manuelle Aufträge:
- Schriftgröße (Brief/Kuvert), Signatur auf dem Brief mit X/Y/Größe-Feinjustierung,
  realistische Handschrift bis in den finalen Druck durchgereicht.
- Spalten-Einfügen in der Empfängertabelle (Excel-Spalte je Zelle).

Mailer: Text-Alternative + Reply-To (Zustellbarkeit).

App: Freitext in Musteranfrage, Konfigurator-Reset, Lightbox-Seitenverhältnis +
Bild-Download, Sticky-Vorschau-Fix, Tab-Eingabe + Rechtsbündigkeit, Leerzeilen-Trim.

Bootstrap: neue Felder (font_scale_*, signatures_manual, multi_page, page_count,
realistic, shipping_day, api_client) + Collections api_clients, Produkttyp envelope.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
Lucas Orth
2026-08-18 10:01:53 +02:00
parent db419bf8eb
commit 1d5c1a14d4
24 changed files with 1327 additions and 121 deletions

View File

@@ -157,7 +157,7 @@ const collections = [
f('key', 'string', { interface: 'input', unique: true, required: true }), f('key', 'string', { interface: 'input', unique: true, required: true }),
f('name', 'string', { interface: 'input', required: true }), f('name', 'string', { interface: 'input', required: true }),
f('description', 'text', { interface: 'input-multiline' }), f('description', 'text', { interface: 'input-multiline' }),
dropdown('type', ['letter', 'postcard', 'sample', 'contact'], { required: true }), dropdown('type', ['letter', 'postcard', 'envelope', 'sample', 'contact'], { required: true }),
dropdown('visibility', ['alle', 'privat', 'unternehmen'], { default: 'alle', note: 'Für wen im Konfigurator sichtbar.' }), dropdown('visibility', ['alle', 'privat', 'unternehmen'], { default: 'alle', note: 'Für wen im Konfigurator sichtbar.' }),
dropdown('pricing_mode', ['formel', 'auf_anfrage'], { default: 'formel' }), dropdown('pricing_mode', ['formel', 'auf_anfrage'], { default: 'formel' }),
f('base_price', 'float', { interface: 'input', note: 'Basispreis (netto). Leer bei auf_anfrage.' }), f('base_price', 'float', { interface: 'input', note: 'Basispreis (netto). Leer bei auf_anfrage.' }),
@@ -249,7 +249,15 @@ const collections = [
m2o('format', 'formats'), m2o('format', 'formats'),
dropdown('person_type', ['privat', 'unternehmen'], { default: 'privat' }), dropdown('person_type', ['privat', 'unternehmen'], { default: 'privat' }),
dropdown('font', ['tilda', 'alva', 'ellie']), dropdown('font', ['tilda', 'alva', 'ellie']),
dropdown('source', ['configurator', 'portal', 'operator', 'extern'], { default: 'configurator', note: '„extern" = Bestellung über eine andere Plattform (z. B. Etsy), ohne Preis/Zahlung.' }), f('realistic', 'boolean', { interface: 'boolean', default: true, note: 'Natürliche Handschrift-Variation (Jitter/Neigung).' }),
m2o('api_client', 'api_clients', { onDelete: 'SET NULL', note: 'Gesetzt bei Aufträgen über die Public-API.' }),
dropdown('shipping_day', ['montag', 'dienstag', 'mittwoch', 'donnerstag', 'freitag', 'samstag', 'sonntag'], { note: 'Vom Kunden gewünschter Versandtag (optional, v. a. Public-API).' }),
f('font_scale_letter', 'float', { interface: 'input', default: 1, note: 'Relative Schriftgröße Brief (0.8–1.5, 1 = Standard).' }),
f('font_scale_envelope', 'float', { interface: 'input', default: 1, note: 'Relative Schriftgröße Kuvert (0.8–1.5, 1 = Standard).' }),
f('signatures_manual', 'json', { interface: 'input-code', note: 'Signatur(en) auf dem Brief bei manuellen Aufträgen: { signatures:{signatur1:svg}, offsets:{signatur1:{x,y,scale}} }.' }),
f('multi_page', 'boolean', { interface: 'boolean', default: false, note: 'Mehrseitiges Schriftstück (Auto-Fluss über mehrere A4-Seiten).' }),
f('page_count', 'integer', { interface: 'input', note: 'Seiten je Schriftstück (bei mehrseitig; wird bei der Generierung gesetzt).' }),
dropdown('source', ['configurator', 'portal', 'operator', 'extern', 'api'], { default: 'configurator', note: '„extern" = andere Plattform (z. B. Etsy); „api" = Public-API-Zugang.' }),
dropdown('status', ['entwurf', 'vorbereitet', 'wartet_auf_zahlung', 'bezahlt', 'material_erwartet', dropdown('status', ['entwurf', 'vorbereitet', 'wartet_auf_zahlung', 'bezahlt', 'material_erwartet',
'material_eingegangen', 'in_queue', 'in_produktion', 'gedruckt', 'versendet', 'abgeschlossen', 'storniert'], 'material_eingegangen', 'in_queue', 'in_produktion', 'gedruckt', 'versendet', 'abgeschlossen', 'storniert'],
{ default: 'entwurf' }), { default: 'entwurf' }),
@@ -438,6 +446,24 @@ const collections = [
{ field: 'timestamp', type: 'timestamp', meta: { interface: 'datetime', readonly: true, special: ['date-created'] }, schema: {} }, { field: 'timestamp', type: 'timestamp', meta: { interface: 'datetime', readonly: true, special: ['date-created'] }, schema: {} },
] }, ] },
// API-Zugänge für Kunden (Public-API). Keys werden nur als SHA-256-Hash gespeichert.
{ collection: 'api_clients', meta: { icon: 'vpn_key', note: 'API-Zugänge für Kunden (Public-API).' }, fields: [
f('name', 'string', { interface: 'input', required: true, note: 'Bezeichnung, z. B. Firmenname.' }),
f('key_plain', 'string', { interface: 'input', note: 'Wird beim Anlegen automatisch erzeugt und EINMALIG angezeigt – jetzt kopieren! Verschwindet bei der nächsten Änderung. Nur der Hash bleibt gespeichert.' }),
f('key_prefix', 'string', { interface: 'input', note: 'Erkennungspräfix des Keys (nur Anzeige).' }),
f('key_hash', 'string', { interface: 'input', note: 'SHA-256 des API-Keys – automatisch gesetzt. Nicht manuell ändern.' }),
m2o('customer', 'directus_users', { note: 'Verknüpftes Kundenkonto (optional).' }),
m2o('product', 'products', { nullable: false, note: 'Einziges Produkt, das dieser Zugang bestellen darf.' }),
f('active', 'boolean', { interface: 'boolean', default: true }),
f('webhook_url', 'string', { interface: 'input', note: 'Optionaler Webhook für Statusänderungen (derzeit ungenutzt – Kunde pollt).' }),
f('config', 'json', { interface: 'input-code', note: 'Kundenspezifische Konfiguration (optional).' }),
f('last_used', 'timestamp', { interface: 'datetime' }),
// AGB/Vertrag – einmalige Zustimmung beim Onboarding festhalten (Nachweis).
f('terms_version', 'string', { interface: 'input', note: 'Akzeptierte AGB-Version, z. B. „2026-01".' }),
f('terms_accepted_at', 'timestamp', { interface: 'datetime', note: 'Zeitpunkt der AGB-/Vertragszustimmung.' }),
f('contract_ref', 'string', { interface: 'input', note: 'Referenz zum unterschriebenen Vertrag (Aktenzeichen/Link).' }),
] },
// Unterschriften je Kunde (SVG-Datei). Wird am Kundenkonto als o2m gezeigt. // Unterschriften je Kunde (SVG-Datei). Wird am Kundenkonto als o2m gezeigt.
{ collection: 'signatures', meta: { icon: 'draw', note: 'Unterschriften je Kunde.' }, fields: [ { collection: 'signatures', meta: { icon: 'draw', note: 'Unterschriften je Kunde.' }, fields: [
m2o('customer', 'directus_users', { onDelete: 'CASCADE' }), m2o('customer', 'directus_users', { onDelete: 'CASCADE' }),

View File

@@ -0,0 +1,533 @@
/**
* Skrift – Public-API (v1) für Kunden
* ===========================================================================
* Eigener, versionierter API-Namespace, gedacht hinter einer eigenen Domain
* (z. B. api.skrift.de → NPM proxyt auf /skrift-api/*). Der Kunde sieht NIE das
* Directus-Dashboard.
*
* POST /v1/orders – Auftrag anlegen (Brief/Postkarte: Text ODER Datei)
* GET /v1/orders/:nummer – Status abfragen (wartend | in_bearbeitung | versendet)
* POST /v1/files – Druckdatei hochladen (Base64) → file_id
* GET /v1/openapi.json – OpenAPI-Spezifikation
* GET /docs – interaktive Doku (Scalar)
* POST /v1/clients – (Admin) neuen API-Zugang + Key erzeugen
*
* Auth: Header `X-Api-Key: <key>` (NICHT Authorization – den reserviert Directus).
* Gespeichert wird nur der SHA-256-Hash (api_clients). Jeder Zugang ist an GENAU
* EIN Produkt gebunden.
*/
import crypto from 'node:crypto';
import { Readable } from 'node:stream';
import fs from 'node:fs';
import path from 'node:path';
import { fileURLToPath } from 'node:url';
// Verzeichnis dieser Extension (für die selbst gehosteten Swagger-UI-Assets).
const EXT_DIR = path.dirname(fileURLToPath(import.meta.url));
const BACKEND_URL = (process.env.SKRIFT_BACKEND_URL || 'http://skrift-backend:4000').replace(/\/$/, '');
const BACKEND_TOKEN = process.env.SKRIFT_BACKEND_TOKEN || '';
const STORAGE = (process.env.STORAGE_LOCATIONS || 'local').split(',')[0].trim() || 'local';
const sha256 = (s) => crypto.createHash('sha256').update(String(s)).digest('hex');
const pad3 = (n) => String(n).padStart(3, '0');
const WOCHENTAGE = ['montag', 'dienstag', 'mittwoch', 'donnerstag', 'freitag', 'samstag', 'sonntag'];
/** Internal order status → public status (pending | processing | shipped | cancelled). */
function kundenStatus(status) {
const s = String(status || '');
if (s === 'versendet' || s === 'abgeschlossen') return 'shipped';
if (s === 'in_produktion' || s === 'gedruckt') return 'processing';
if (s === 'storniert') return 'cancelled';
return 'pending';
}
// Selbst ausgelieferte HTML-Doku (kein externes Script → CSP-sicher). Inline-CSS.
const DOCS_HTML = `<!doctype html>
<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
<title>Skrift API Reference</title>
<style>
*{box-sizing:border-box}
body{margin:0;font:16px/1.6 -apple-system,Segoe UI,Roboto,Helvetica,Arial,sans-serif;color:#1a1a1a;background:#f6f8fb}
.wrap{max-width:900px;margin:0 auto;padding:32px 20px 80px}
h1{font-size:30px;margin:0 0 4px}
h2{font-size:22px;margin:40px 0 12px;padding-top:14px;border-top:1px solid #e2e8f0}
h3{font-size:15px;margin:18px 0 6px}
code{background:#eef2f7;padding:2px 6px;border-radius:5px;font-family:ui-monospace,Menlo,Consolas,monospace;font-size:14px}
pre{background:#0f172a;color:#e6edf3;padding:16px;border-radius:10px;overflow:auto;font-family:ui-monospace,Menlo,Consolas,monospace;font-size:13px;line-height:1.5}
.card{background:#fff;border:1px solid #e2e8f0;border-radius:12px;padding:18px 20px;margin:14px 0}
.ep{display:flex;align-items:center;gap:10px;font-family:ui-monospace,monospace;font-size:15px;margin-bottom:6px}
.m{font-weight:700;color:#fff;border-radius:6px;padding:2px 8px;font-size:12px}
.post{background:#16a34a}.get{background:#2563eb}
table{border-collapse:collapse;width:100%;margin:8px 0;font-size:14px}
th,td{text-align:left;border-bottom:1px solid #e2e8f0;padding:7px 8px;vertical-align:top}
th{color:#64748b;font-weight:600}
.muted{color:#64748b}
.tag{display:inline-block;background:#eef2f7;border-radius:6px;padding:1px 8px;font-size:13px;margin:0 6px 4px 0}
a{color:#1E50A5}
</style></head>
<body><div class="wrap">
<h1>Skrift API Reference</h1>
<p class="muted">Handwritten mail as a service · API v1 · Base URL <code>https://dev.skrift.de</code></p>
<h2>Overview</h2>
<div class="card">
<p>REST API over HTTPS. Request and response bodies are JSON (<code>Content-Type: application/json</code>, UTF-8). An order yields one document and/or one envelope per recipient; the <b>quantity is derived from the number of recipients</b>. The product (letters, postcards or envelopes) is bound to the API key.</p>
</div>
<h2>Authentication</h2>
<div class="card">
<p>Every request must include your API key in the <code>X-Api-Key</code> header:</p>
<pre>X-Api-Key: &lt;API_KEY&gt;</pre>
<p class="muted">Each key is scoped to exactly one product. Keys are secrets — never expose them in client-side code.</p>
</div>
<h2>Errors</h2>
<div class="card">
<p>Errors use standard HTTP status codes and a uniform body:</p>
<pre>{ "error": "human-readable message" }</pre>
<table>
<tr><th>Status</th><th>Meaning</th></tr>
<tr><td>200 / 201</td><td>Success / order created</td></tr>
<tr><td>400</td><td>Invalid request (missing or invalid fields)</td></tr>
<tr><td>401</td><td>Missing or invalid API key</td></tr>
<tr><td>404</td><td>Resource not found</td></tr>
<tr><td>413</td><td>Payload too large (file &gt; 80 MB)</td></tr>
<tr><td>415</td><td>Unsupported media type (only PDF is accepted)</td></tr>
<tr><td>500</td><td>Internal error</td></tr>
</table>
</div>
<h2>Order status</h2>
<div class="card">
<p>The <code>status</code> field returns one of:</p>
<span class="tag">pending</span> received, not yet in production
<span class="tag">processing</span> being written / printed
<span class="tag">shipped</span> dispatched
<span class="tag">cancelled</span> cancelled
</div>
<h2>Create an order</h2>
<div class="card">
<div class="ep"><span class="m post">POST</span> /v1/orders</div>
<p>Creates an order and returns its order number.</p>
<h3>Request body</h3>
<table>
<tr><th>Field</th><th>Type</th><th>Description</th></tr>
<tr><td>recipients</td><td>array</td><td><b>Required.</b> One entry per recipient; count = quantity. Address as <code>free_text</code> (up to 5 lines, separated by <code>\\n</code>).</td></tr>
<tr><td>document_format</td><td>string</td><td>Document format: <code>a4</code>, <code>a6h</code> or <code>a6l</code>.</td></tr>
<tr><td>font</td><td>string</td><td><code>tilda</code>, <code>alva</code> or <code>ellie</code>.</td></tr>
<tr><td>realistic</td><td>boolean</td><td>Natural handwriting variation. Default <code>true</code>.</td></tr>
<tr><td>shipping_type</td><td>string</td><td><code>bulk</code> (consolidated shipment to you; default) or <code>single</code> (direct to each recipient).</td></tr>
<tr><td>shipping_day</td><td>string</td><td>Preferred dispatch weekday, e.g. <code>montag</code> (optional).</td></tr>
<tr><td>letter.text</td><td>string</td><td>Letter body, <b>fully written out — no placeholders</b>. Long text flows across multiple pages automatically; <code>[[seitenumbruch]]</code> forces a page break.</td></tr>
<tr><td>letter.files</td><td>array</td><td><code>file_id</code>(s) from <code>POST /v1/files</code> (file / PDF products).</td></tr>
<tr><td>envelope.mode</td><td>string</td><td><code>none</code> (no envelope) or <code>recipient</code> (recipient address on the envelope). Envelope size is selected automatically: A4 → DIN Lang, otherwise C6.</td></tr>
</table>
<h3>Example — text letter</h3>
<pre>curl -X POST https://dev.skrift.de/v1/orders \\
-H "X-Api-Key: &lt;KEY&gt;" -H "Content-Type: application/json" \\
-d '{
"document_format":"a4","font":"tilda","realistic":true,
"shipping_type":"bulk","shipping_day":"montag",
"letter":{"text":"Dear Anna,\\n\\nthank you for ..."},
"envelope":{"mode":"recipient"},
"recipients":[
{"free_text":"Anna Meier\\nMusterstr. 1\\n12345 Musterstadt"}
]
}'</pre>
<h3>Example — print uploaded PDFs (file product)</h3>
<pre>curl -X POST https://dev.skrift.de/v1/orders \\
-H "X-Api-Key: &lt;KEY&gt;" -H "Content-Type: application/json" \\
-d '{"document_format":"a4","letter":{"files":["&lt;file_id&gt;"]},
"envelope":{"mode":"recipient"},
"recipients":[{"free_text":"Anna Meier\\nMusterstr. 1\\n12345 Musterstadt"}]}'</pre>
<h3>Example — address envelopes only</h3>
<pre>curl -X POST https://dev.skrift.de/v1/orders \\
-H "X-Api-Key: &lt;KEY&gt;" -H "Content-Type: application/json" \\
-d '{"envelope":{"mode":"recipient"},
"recipients":[{"free_text":"Anna Meier\\nMusterstr. 1\\n12345 Musterstadt"}]}'</pre>
<h3>Response <span class="muted">· 201</span></h3>
<pre>{ "order_number": "18-08-26-001", "status": "pending" }</pre>
</div>
<h2>Retrieve order status</h2>
<div class="card">
<div class="ep"><span class="m get">GET</span> /v1/orders/{order_number}</div>
<p>Returns the current status of one of your orders.</p>
<pre>curl https://dev.skrift.de/v1/orders/18-08-26-001 -H "X-Api-Key: &lt;KEY&gt;"
{ "order_number":"18-08-26-001", "status":"processing", "recipients":1 }</pre>
</div>
<h2>Upload a PDF</h2>
<div class="card">
<div class="ep"><span class="m post">POST</span> /v1/files</div>
<p>Uploads a base64-encoded print file. <b>PDF only</b>, max. 80 MB. Returns a <code>file_id</code> to reference in <code>letter.files</code>.</p>
<pre>curl -X POST https://dev.skrift.de/v1/files \\
-H "X-Api-Key: &lt;KEY&gt;" -H "Content-Type: application/json" \\
-d '{"filename":"letter.pdf","content_base64":"&lt;BASE64&gt;"}'
{ "file_id": "..." }</pre>
</div>
<p class="muted" style="margin-top:30px">Machine-readable specification: <a href="v1/openapi.json">OpenAPI (JSON)</a> — import into Postman, Insomnia, or any OpenAPI client.</p>
</div></body></html>`;
// Swagger UI (selbst gehostet). Assets liegen als swagger-ui.css + swagger-ui-bundle.js
// im Extension-Ordner; init.js wird generiert. Kein CDN → CSP-/Brave-sicher.
const SWAGGER_HTML = `<!doctype html>
<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
<title>Skrift API Reference</title>
<link rel="stylesheet" href="docs-assets/swagger-ui.css">
<style>body{margin:0;background:#fafafa}.swagger-ui .topbar{display:none}</style>
</head><body>
<div id="swagger-ui"></div>
<script src="docs-assets/swagger-ui-bundle.js"></script>
<script src="docs-assets/init.js"></script>
</body></html>`;
const INIT_JS = "window.addEventListener('DOMContentLoaded',function(){window.ui=SwaggerUIBundle({url:'v1/openapi.json',dom_id:'#swagger-ui',deepLinking:true,presets:[SwaggerUIBundle.presets.apis],layout:'BaseLayout'});});";
const handler = (router, { services, getSchema, logger }) => {
const { ItemsService, FilesService } = services;
const svcFactory = (schema) => (c) => new ItemsService(c, { schema, accountability: null });
/** Zeichen-Whitelist (wie im übrigen System) als Sanitizer laden. */
async function ladeClean(schema) {
try {
const ps = await new ItemsService('pricing_settings', { schema, accountability: null })
.readSingleton({ fields: ['char_whitelist'] });
const wl = ps?.char_whitelist;
const re = wl ? new RegExp(`[^${wl}\\n\\r\\t]`, 'g') : null;
return (v) => (typeof v === 'string' && re ? v.replace(re, '') : v);
} catch { return (v) => v; }
}
/** API-Key aus dem X-Api-Key-Header lesen und den aktiven Zugang finden.
* (NICHT Authorization: Bearer – den reserviert Directus für eigene Tokens
* und lehnt fremde Werte global mit INVALID_CREDENTIALS ab.) */
async function authClient(req) {
const raw = String(req.headers['x-api-key'] || '').trim();
if (!raw) return null;
const schema = await getSchema();
const rows = await new ItemsService('api_clients', { schema, accountability: null }).readByQuery({
filter: { key_hash: { _eq: sha256(raw) }, active: { _eq: true } },
limit: 1,
fields: ['id', 'name', 'customer', 'webhook_url', 'config', 'product.id', 'product.key', 'product.type', 'product.input_mode'],
});
const client = rows?.[0] || null;
if (client) {
// Letzte Nutzung vermerken (best effort, nicht blockierend).
new ItemsService('api_clients', { schema, accountability: null })
.updateOne(client.id, { last_used: new Date().toISOString() }).catch(() => {});
}
return client;
}
const fehler = (res, code, msg) => res.status(code).json({ error: msg });
// ── POST /v1/files ─────────────────────────────────────────────────────────
// Body: { filename, content_base64 } → { file_id }. NUR PDF (Sicherheit).
router.post('/v1/files', async (req, res) => {
const client = await authClient(req);
if (!client) return fehler(res, 401, 'Missing or invalid API key.');
const { filename, content_base64 } = req.body || {};
if (!filename || !content_base64) return fehler(res, 400, 'filename and content_base64 are required.');
if (!/\.pdf$/i.test(String(filename))) return fehler(res, 415, 'Only PDF files are accepted (filename must end in .pdf).');
let buf;
try { buf = Buffer.from(String(content_base64), 'base64'); } catch { return fehler(res, 400, 'content_base64 is not valid base64.'); }
if (!buf.length) return fehler(res, 400, 'File is empty.');
if (buf.length > 80 * 1024 * 1024) return fehler(res, 413, 'File too large (max. 80 MB).');
// Inhalts-Prüfung: echte PDF-Signatur, nicht nur die Endung.
if (buf.slice(0, 5).toString('latin1') !== '%PDF-') return fehler(res, 415, 'File is not a valid PDF.');
try {
const schema = await getSchema();
const filesSvc = new FilesService({ schema, accountability: null });
const id = await filesSvc.uploadOne(Readable.from(buf), {
storage: STORAGE,
filename_download: String(filename),
title: String(filename),
type: 'application/pdf',
});
return res.json({ file_id: id });
} catch (err) {
logger.error(`[skrift-api] files: ${err.stack || err.message}`);
return fehler(res, 500, 'File upload failed.');
}
});
// ── POST /v1/orders ─────────────────────────────────────────────────────────
router.post('/v1/orders', async (req, res) => {
const client = await authClient(req);
if (!client) return fehler(res, 401, 'Missing or invalid API key.');
const product = client.product;
if (!product?.id) return fehler(res, 409, 'No product is assigned to this API key.');
const body = req.body || {};
const recipients = Array.isArray(body.recipients) ? body.recipients : [];
if (!recipients.length) return fehler(res, 400, 'At least one recipient is required.');
if (recipients.length > 5000) return fehler(res, 400, 'Too many recipients (max. 5000).');
const istKuvertOnly = product.type === 'envelope';
const istDatei = product.input_mode === 'datei';
const letter = body.letter || {};
const files = Array.isArray(letter.files) ? letter.files.filter(Boolean) : [];
// Kuvert-only: kein Brief nötig (nur adressierte Kuverts); PDF-Dateien optional.
if (!istKuvertOnly) {
if (istDatei && !files.length) return fehler(res, 400, 'This product requires uploaded print files (letter.files).');
if (!istDatei && !String(letter.text || '').trim()) return fehler(res, 400, 'letter.text is required.');
}
try {
const schema = await getSchema();
const svc = svcFactory(schema);
const clean = await ladeClean(schema);
// Schriftstückformat: nur A4 / A6H / A6L (freundliche Werte → interne Keys).
const FORMAT_MAP = { a4: 'a4', a6h: 'a6_hoch', a6l: 'a6_quer', a6_hoch: 'a6_hoch', a6_quer: 'a6_quer' };
const fmtKey = FORMAT_MAP[String(body.document_format || '').trim().toLowerCase()] || null;
if (!fmtKey && !istKuvertOnly) return fehler(res, 400, 'document_format must be a4, a6h or a6l.');
let formatId = null;
if (fmtKey) {
const fr = await svc('formats').readByQuery({ filter: { key: { _eq: fmtKey } }, limit: 1, fields: ['id'] });
formatId = fr?.[0]?.id ?? null;
if (!formatId) return fehler(res, 400, `Format ${fmtKey} is not active.`);
}
// Kuvert: NUR "recipient" (Empfängeradresse) oder "none" (gar kein Kuvert).
const envMode = String((body.envelope || {}).mode || '').toLowerCase() === 'recipient'
? 'recipient' : (istKuvertOnly ? 'recipient' : 'none');
// Kuvertformat automatisch aus dem Dokumentformat: A4 → DIN Lang, sonst C6.
const envFormat = envMode === 'none' ? null : (fmtKey === 'a4' ? 'dinlang' : 'c6');
const hatDateien = files.length > 0;
const font = ['tilda', 'alva', 'ellie'].includes(body.font) ? body.font : 'tilda';
// Versandart nur Englisch: "single" (direkt an Empfänger) / "bulk" (Sammelversand an dich).
const shippingType = String(body.shipping_type || '').toLowerCase() === 'single' ? 'einzeln' : 'sammel';
// Gewünschter Versandtag (optional), z. B. "montag".
const shippingDay = WOCHENTAGE.includes(String(body.shipping_day || '').toLowerCase())
? String(body.shipping_day).toLowerCase() : null;
const orderData = {
api_client: client.id,
customer: client.customer || null,
customer_email: (client.config && client.config.email) || null,
product: product.id,
format: formatId,
person_type: 'unternehmen',
font,
realistic: body.realistic !== false,
source: 'api',
status: 'in_queue',
production_status: 'eingegangen',
payment_status: 'offen',
payment_method: 'rechnung',
shipping_type: shippingType,
needs_envelope: envMode === 'recipient',
envelope_labeling: envMode === 'recipient' ? 'empfaenger' : 'keine',
envelope_text: null,
envelope_format: envFormat,
// Kein Brieftext bei Datei- oder Kuvert-only-Produkten.
text_template: (istDatei || istKuvertOnly) ? null : clean(String(letter.text || '')),
// Hochgeladene PDF-Briefe (Datei-Produkt ODER optional bei Kuvert-only).
source_files: (istDatei || (istKuvertOnly && hatDateien)) ? files : null,
source_file: (istDatei || (istKuvertOnly && hatDateien)) ? (files[0] || null) : null,
entries_count: recipients.length,
shipping_day: shippingDay,
// Mehrseitigkeit läuft selbstständig (Auto-Fluss); nicht vom Kunden wählbar.
multi_page: true,
// Schriftgröße nicht vom Kunden wählbar.
font_scale_letter: 1,
font_scale_envelope: 1,
};
// Auftragsnummer (Tages-Präfix) mit Kollisions-Wiederholung.
const jt = new Date();
const praefix = `${String(jt.getDate()).padStart(2, '0')}-${String(jt.getMonth() + 1).padStart(2, '0')}-${String(jt.getFullYear()).slice(2)}`;
const naechsteNummer = async () => {
const heutige = await svc('orders').readByQuery({ filter: { order_number: { _starts_with: `${praefix}-` } }, limit: -1, fields: ['id'] });
return `${praefix}-${pad3((heutige?.length ?? 0) + 1)}`;
};
let orderId, orderNumber;
for (let v = 0; v < 6; v += 1) {
orderNumber = await naechsteNummer();
try { orderId = await svc('orders').createOne({ order_number: orderNumber, ...orderData }); break; }
catch (e) { if (v === 5 || !/unique|duplicate|bereits|exists/i.test(String(e?.message || ''))) throw e; }
}
// Empfängerzeilen – Briefnummer wird vom System vergeben.
const entriesSvc = svc('order_entries');
let n = 0;
for (const e of recipients) {
n += 1;
await entriesSvc.createOne({
order: orderId, letter_number: n,
salutation: clean(e.salutation ?? null), first_name: clean(e.first_name ?? null), last_name: clean(e.last_name ?? null),
street: clean(e.street ?? null), house_no: clean(e.house_no ?? null), zip: clean(e.zip ?? null),
city: clean(e.city ?? null), country: clean(e.country ?? null), free_text: clean(e.free_text ?? null),
// Keine Platzhalter über die API – der Brieftext wird 1:1 verwendet.
placeholders: null,
});
}
await svc('status_history').createOne({ order: orderId, status: 'eingegangen', note: 'Über die Public-API angelegt.' }).catch(() => {});
// Generierung anstoßen (fire-and-forget) – identisch zum manuellen Auftrag.
if (['letter', 'postcard', 'envelope'].includes(product.type)) {
fetch(`${BACKEND_URL}/api/order/from-directus`, {
method: 'POST', headers: { 'Content-Type': 'application/json', 'X-API-Token': BACKEND_TOKEN },
body: JSON.stringify({ orderId }),
}).catch((e) => logger.warn(`[skrift-api] Generierung nicht gestartet: ${e.message}`));
}
return res.status(201).json({ order_number: orderNumber, status: 'pending' });
} catch (err) {
logger.error(`[skrift-api] orders: ${err.stack || err.message}`);
return fehler(res, 500, 'Order could not be created.');
}
});
// ── GET /v1/orders/:nummer ──────────────────────────────────────────────────
router.get('/v1/orders/:nummer', async (req, res) => {
const client = await authClient(req);
if (!client) return fehler(res, 401, 'Missing or invalid API key.');
try {
const schema = await getSchema();
const rows = await new ItemsService('orders', { schema, accountability: null }).readByQuery({
// Nur eigene Aufträge des Zugangs.
filter: { order_number: { _eq: String(req.params.nummer) }, api_client: { _eq: client.id } },
limit: 1, fields: ['order_number', 'status', 'entries_count', 'date_created'],
});
const order = rows?.[0];
if (!order) return fehler(res, 404, 'Order not found.');
return res.json({
order_number: order.order_number,
status: kundenStatus(order.status),
recipients: order.entries_count ?? null,
created_at: order.date_created ?? null,
});
} catch (err) {
logger.error(`[skrift-api] status: ${err.stack || err.message}`);
return fehler(res, 500, 'Failed to retrieve order status.');
}
});
// ── POST /v1/clients (Admin) – neuen Zugang + Key erzeugen ───────────────────
// Nur mit Directus-Admin-Token/Session. Der Klartext-Key wird EINMALIG geliefert.
router.post('/v1/clients', async (req, res) => {
if (!req.accountability || req.accountability.admin !== true) return fehler(res, 403, 'Administrators only.');
const { name, product, customer, webhook_url } = req.body || {};
if (!name || !product) return fehler(res, 400, 'name and product (product ID) are required.');
try {
const schema = await getSchema();
const key = `sk_live_${crypto.randomBytes(24).toString('base64url')}`;
const id = await new ItemsService('api_clients', { schema, accountability: null }).createOne({
name: String(name), product, customer: customer || null, webhook_url: webhook_url || null,
key_hash: sha256(key), key_prefix: key.slice(0, 14), active: true,
});
// Klartext-Key nur JETZT – wird nirgends gespeichert.
return res.status(201).json({ id, name, api_key: key, note: 'Store this key securely — it will not be shown again.' });
} catch (err) {
logger.error(`[skrift-api] clients: ${err.stack || err.message}`);
return fehler(res, 500, 'API client could not be created.');
}
});
// ── OpenAPI + Doku ──────────────────────────────────────────────────────────
const OPENAPI = {
openapi: '3.0.3',
info: { title: 'Skrift API', version: '1.0.0', description: 'Handwritten mail as a service. Authentication: API key in the X-Api-Key header. Bodies are JSON (UTF-8).' },
servers: [{ url: 'https://dev.skrift.de' }],
components: {
securitySchemes: { ApiKey: { type: 'apiKey', in: 'header', name: 'X-Api-Key' } },
schemas: {
Recipient: {
type: 'object',
properties: {
free_text: { type: 'string', description: 'Recipient address as free text, up to 5 lines separated by \\n.' },
salutation: { type: 'string' }, first_name: { type: 'string' }, last_name: { type: 'string' },
street: { type: 'string' }, house_no: { type: 'string' }, zip: { type: 'string' }, city: { type: 'string' }, country: { type: 'string' },
},
},
OrderRequest: {
type: 'object', required: ['recipients'],
properties: {
document_format: { type: 'string', enum: ['a4', 'a6h', 'a6l'], description: 'Document format.' },
font: { type: 'string', enum: ['tilda', 'alva', 'ellie'] },
realistic: { type: 'boolean', default: true, description: 'Natural handwriting variation.' },
shipping_type: { type: 'string', enum: ['single', 'bulk'], default: 'bulk', description: 'single = direct to each recipient; bulk = consolidated shipment to you.' },
shipping_day: { type: 'string', enum: ['montag', 'dienstag', 'mittwoch', 'donnerstag', 'freitag', 'samstag', 'sonntag'], description: 'Preferred dispatch weekday (optional).' },
letter: {
type: 'object',
properties: {
text: { type: 'string', description: 'Letter body, fully written out (no placeholders). Long text flows across multiple pages automatically; [[seitenumbruch]] forces a page break.' },
files: { type: 'array', items: { type: 'string' }, description: 'file_id(s) from POST /v1/files (file / PDF products).' },
},
},
envelope: {
type: 'object',
properties: {
mode: { type: 'string', enum: ['none', 'recipient'], default: 'none', description: 'none = no envelope; recipient = recipient address on the envelope. Envelope size is selected automatically (A4 → DIN Lang, otherwise C6).' },
},
},
recipients: { type: 'array', items: { $ref: '#/components/schemas/Recipient' } },
},
},
},
},
security: [{ ApiKey: [] }],
paths: {
'/v1/orders': {
post: {
summary: 'Create an order', description: 'Quantity equals the number of recipients. Returns the order number.',
requestBody: { required: true, content: { 'application/json': { schema: { $ref: '#/components/schemas/OrderRequest' } } } },
responses: { 201: { description: 'Order created', content: { 'application/json': { schema: { type: 'object', properties: { order_number: { type: 'string' }, status: { type: 'string' } } } } } } },
},
},
'/v1/orders/{order_number}': {
get: {
summary: 'Retrieve order status', parameters: [{ name: 'order_number', in: 'path', required: true, schema: { type: 'string' } }],
responses: { 200: { description: 'Order status', content: { 'application/json': { schema: { type: 'object', properties: { order_number: { type: 'string' }, status: { type: 'string', enum: ['pending', 'processing', 'shipped', 'cancelled'] } } } } } } },
},
},
'/v1/files': {
post: {
summary: 'Upload a PDF (PDF only, max. 80 MB)',
requestBody: { required: true, content: { 'application/json': { schema: { type: 'object', required: ['filename', 'content_base64'], properties: { filename: { type: 'string', description: 'Must end in .pdf.' }, content_base64: { type: 'string', description: 'PDF as base64.' } } } } } },
responses: { 200: { description: 'Uploaded', content: { 'application/json': { schema: { type: 'object', properties: { file_id: { type: 'string' } } } } } } },
},
},
},
};
router.get('/v1/openapi.json', (_req, res) => res.json(OPENAPI));
router.get('/docs', (_req, res) => {
// Swagger UI, wenn die Assets im Extension-Ordner liegen; sonst die statische
// HTML-Doku als Fallback (nie leer). Beides CSP-/Brave-sicher (kein CDN).
let hasSwagger = false;
try { hasSwagger = fs.existsSync(path.join(EXT_DIR, 'swagger-ui-bundle.js')); } catch { /* ignore */ }
res.type('html').send(hasSwagger ? SWAGGER_HTML : DOCS_HTML);
});
// Statische Doku-Assets (Swagger UI) – von der eigenen Domain, whitelisted.
router.get('/docs-assets/:file', (req, res) => {
const name = String(req.params.file || '');
if (name === 'init.js') { res.type('application/javascript').send(INIT_JS); return; }
const TYPES = { 'swagger-ui.css': 'text/css', 'swagger-ui-bundle.js': 'application/javascript' };
if (!TYPES[name]) return res.status(404).json({ error: 'Not found.' });
try {
const buf = fs.readFileSync(path.join(EXT_DIR, name));
res.setHeader('Content-Type', TYPES[name]);
res.setHeader('Cache-Control', 'public, max-age=86400');
return res.send(buf);
} catch {
return res.status(404).json({ error: 'Docs asset missing – place swagger-ui.css and swagger-ui-bundle.js in the extension folder.' });
}
});
};
// Objekt-Form mit fester id → Mount unter /skrift-api (wie skrift-orders).
export default { id: 'skrift-api', handler };

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

View File

@@ -0,0 +1,13 @@
{
"name": "directus-extension-skrift-api",
"version": "1.0.0",
"private": true,
"type": "module",
"description": "Public-API für Kunden (v1): Aufträge anlegen, Status abfragen, Datei-Upload. Key-Auth über api_clients (SHA-256).",
"directus:extension": {
"type": "endpoint",
"path": "dist/index.js",
"source": "dist/index.js",
"host": "^11.0.0"
}
}

View File

@@ -0,0 +1,37 @@
/**
* Skrift – API-Key-Hook
* ---------------------------------------------------------------------------
* Beim Anlegen eines api_clients-Eintrags wird automatisch ein API-Key erzeugt:
* - key_hash = SHA-256 des Keys (dauerhaft; nur damit authentifiziert die API)
* - key_prefix = Erkennungspräfix (Anzeige)
* - key_plain = Klartext-Key, EINMALIG sichtbar (jetzt kopieren)
*
* Bei der nächsten Änderung des Eintrags wird key_plain wieder geleert
* („reveal once"). Der Klartext wird also nie dauerhaft gespeichert.
*/
import crypto from 'node:crypto';
const sha256 = (s) => crypto.createHash('sha256').update(String(s)).digest('hex');
export default (register) => {
// Anlegen: Key erzeugen, sofern noch keiner gesetzt ist.
register.filter('api_clients.items.create', (payload) => {
if (payload && typeof payload === 'object' && !payload.key_hash) {
const key = `sk_live_${crypto.randomBytes(24).toString('base64url')}`;
payload.key_hash = sha256(key);
payload.key_prefix = key.slice(0, 14);
payload.key_plain = key; // einmalige Anzeige
if (payload.active === undefined) payload.active = true;
}
return payload;
});
// Jede spätere Änderung entfernt den Klartext (nur direkt nach Anlage sichtbar),
// außer er wird gerade explizit gesetzt.
register.filter('api_clients.items.update', (payload) => {
if (payload && typeof payload === 'object' && payload.key_plain === undefined) {
payload.key_plain = null;
}
return payload;
});
};

View File

@@ -0,0 +1,13 @@
{
"name": "directus-extension-skrift-apikey",
"version": "1.0.0",
"private": true,
"type": "module",
"description": "Erzeugt beim Anlegen eines api_clients automatisch einen API-Key (SHA-256 gespeichert, Klartext einmalig in key_plain).",
"directus:extension": {
"type": "hook",
"path": "dist/index.js",
"source": "dist/index.js",
"host": "^11.0.0"
}
}

View File

@@ -61,6 +61,21 @@ const render = (str, vars) =>
const eur = (n) => (Number(n) || 0).toFixed(2).replace('.', ','); const eur = (n) => (Number(n) || 0).toFixed(2).replace('.', ',');
const esc = (s) => String(s == null ? '' : s).replace(/[<>&]/g, (c) => ({ '<': '&lt;', '>': '&gt;', '&': '&amp;' }[c])); const esc = (s) => String(s == null ? '' : s).replace(/[<>&]/g, (c) => ({ '<': '&lt;', '>': '&gt;', '&': '&amp;' }[c]));
// Antwortadresse für Kundenmails – echte, überwachte Adresse statt „noreply".
const REPLY_TO = 'hello@skrift.de';
/** Grobe Text-Alternative aus dem HTML. Reine HTML-Mails ohne Text-Teil kosten
* bei Spamfiltern (SpamAssassin) sichere Punkte – der Text-Part senkt die Wertung. */
const htmlZuText = (html) => String(html || '')
.replace(/<\s*br\s*\/?>/gi, '\n')
.replace(/<\/(p|div|tr|h[1-6]|li|table)>/gi, '\n')
.replace(/<[^>]+>/g, '')
.replace(/&nbsp;/gi, ' ')
.replace(/&amp;/gi, '&').replace(/&lt;/gi, '<').replace(/&gt;/gi, '>')
.replace(/[ \t]+\n/g, '\n')
.replace(/\n{3,}/g, '\n\n')
.trim();
/** Formatiert einen Adress-Snapshot (billing/shipping) als HTML. */ /** Formatiert einen Adress-Snapshot (billing/shipping) als HTML. */
function adresseHtml(a) { function adresseHtml(a) {
if (!a || typeof a !== 'object') return ''; if (!a || typeof a !== 'object') return '';
@@ -114,10 +129,13 @@ export default (register, { services, getSchema, logger }) => {
const order = await new ItemsService('orders', { schema, accountability: null }) const order = await new ItemsService('orders', { schema, accountability: null })
.readOne(orderId, { fields: ['order_number', 'product.name'] }); .readOne(orderId, { fields: ['order_number', 'product.name'] });
if (!order) return; if (!order) return;
const html = `<p>Neue Bestellung <strong>${order.order_number}</strong>${order.product?.name ? ` (${order.product.name})` : ''} – im Produktions-Board unter „Neu".</p>`;
const nachricht = { const nachricht = {
to, to,
subject: `Neue Bestellung ${order.order_number}`, subject: `Neue Bestellung ${order.order_number}`,
html: `<p>Neue Bestellung <strong>${order.order_number}</strong>${order.product?.name ? ` (${order.product.name})` : ''} – im Produktions-Board unter „Neu".</p>`, html,
text: htmlZuText(html),
replyTo: REPLY_TO,
}; };
if (settings.sender_email) { if (settings.sender_email) {
nachricht.from = settings.sender_name ? `${settings.sender_name} <${settings.sender_email}>` : settings.sender_email; nachricht.from = settings.sender_name ? `${settings.sender_name} <${settings.sender_email}>` : settings.sender_email;
@@ -198,7 +216,7 @@ export default (register, { services, getSchema, logger }) => {
let html = render(tpl.body, vars); let html = render(tpl.body, vars);
if (tpl.append_signature !== false && settings.signature) html += render(settings.signature, vars); if (tpl.append_signature !== false && settings.signature) html += render(settings.signature, vars);
const nachricht = { to: order.customer_email, subject: render(tpl.subject, vars), html }; const nachricht = { to: order.customer_email, subject: render(tpl.subject, vars), html, text: htmlZuText(html), replyTo: REPLY_TO };
// Absender aus den Einstellungen (z. B. „Skrift <noreply@skrift.de>"). // Absender aus den Einstellungen (z. B. „Skrift <noreply@skrift.de>").
if (settings.sender_email) { if (settings.sender_email) {
nachricht.from = settings.sender_name ? `${settings.sender_name} <${settings.sender_email}>` : settings.sender_email; nachricht.from = settings.sender_name ? `${settings.sender_name} <${settings.sender_email}>` : settings.sender_email;

View File

@@ -48,6 +48,8 @@ const NeuAuftrag = defineComponent({
const musterTexte = ref({ text_du: '', text_sie: '' }); const musterTexte = ref({ text_du: '', text_sie: '' });
// Frei anlegbare Mustertexte (Collection muster_texts). Fallback: Du/Sie aus muster_settings. // Frei anlegbare Mustertexte (Collection muster_texts). Fallback: Du/Sie aus muster_settings.
const musterListe = ref([]); const musterListe = ref([]);
// Vorhandene Kundensignaturen (für „Unterschrift auf den Brief setzen").
const signaturListe = ref([]);
const geladen = ref(false); const geladen = ref(false);
// Aktives Unterwerkzeug: 'neu' (manueller Druck) oder 'signatur' (Unterschriftenservice). // Aktives Unterwerkzeug: 'neu' (manueller Druck) oder 'signatur' (Unterschriftenservice).
const ansicht = ref('neu'); const ansicht = ref('neu');
@@ -69,6 +71,12 @@ const NeuAuftrag = defineComponent({
const leereZeile = () => ({ free_text: '', placeholders: {} }); const leereZeile = () => ({ free_text: '', placeholders: {} });
const neu = reactive({ const neu = reactive({
product: '', format: '', font: 'tilda', product: '', format: '', font: 'tilda',
// Relative Schriftgröße in % (getrennt Brief/Kuvert); 100 = Standard.
fontSizeLetter: 100, fontSizeEnvelope: 100,
// Unterschrift auf dem Brief ([[signatur1]]): SVG-Inhalt + Feinjustierung.
sigSvg: '', sigLabel: '', sigX: 0, sigY: 0, sigScale: 100,
// Mehrseitiges Schriftstück (Auto-Fluss über mehrere A4-Seiten).
mehrseitig: false, seitenInfo: '',
// Kuvert-Adresse je Empfänger: '5zeilen' (5 Zeilen) oder 'individuell' (einzeilig). // Kuvert-Adresse je Empfänger: '5zeilen' (5 Zeilen) oder 'individuell' (einzeilig).
adressModus: '5zeilen', kuverts: false, realistic: true, customer_email: '', text: '', rows: [leereZeile()], adressModus: '5zeilen', kuverts: false, realistic: true, customer_email: '', text: '', rows: [leereZeile()],
importOpen: false, importText: '', importOpen: false, importText: '',
@@ -81,17 +89,19 @@ const NeuAuftrag = defineComponent({
async function laden() { async function laden() {
try { try {
const [p, f, ps, mt, mtx] = await Promise.all([ const [p, f, ps, mt, mtx, sg] = await Promise.all([
api.get('/items/products', { params: { limit: -1, filter: { active: { _eq: true }, type: { _in: ['letter', 'postcard'] } }, fields: 'key,name,type' } }), api.get('/items/products', { params: { limit: -1, filter: { active: { _eq: true }, type: { _in: ['letter', 'postcard'] } }, fields: 'key,name,type' } }),
api.get('/items/formats', { params: { limit: -1, filter: { active: { _eq: true } }, fields: 'key,name,product.key' } }), api.get('/items/formats', { params: { limit: -1, filter: { active: { _eq: true } }, fields: 'key,name,product.key' } }),
api.get('/items/pricing_settings', { params: { fields: 'char_whitelist' } }).catch(() => ({ data: { data: {} } })), api.get('/items/pricing_settings', { params: { fields: 'char_whitelist' } }).catch(() => ({ data: { data: {} } })),
api.get('/items/muster_settings', { params: { fields: 'text_du,text_sie' } }).catch(() => ({ data: { data: {} } })), api.get('/items/muster_settings', { params: { fields: 'text_du,text_sie' } }).catch(() => ({ data: { data: {} } })),
api.get('/items/muster_texts', { params: { limit: -1, filter: { active: { _eq: true } }, sort: 'sort', fields: 'id,label,text' } }).catch(() => ({ data: { data: [] } })), api.get('/items/muster_texts', { params: { limit: -1, filter: { active: { _eq: true } }, sort: 'sort', fields: 'id,label,text' } }).catch(() => ({ data: { data: [] } })),
api.get('/items/signatures', { params: { limit: -1, sort: '-date_created', fields: 'id,label,file,customer.first_name,customer.last_name' } }).catch(() => ({ data: { data: [] } })),
]); ]);
produkte.value = p.data?.data || []; produkte.value = p.data?.data || [];
formate.value = f.data?.data || []; formate.value = f.data?.data || [];
musterTexte.value = mt.data?.data || { text_du: '', text_sie: '' }; musterTexte.value = mt.data?.data || { text_du: '', text_sie: '' };
musterListe.value = mtx.data?.data || []; musterListe.value = mtx.data?.data || [];
signaturListe.value = sg.data?.data || [];
const wl = ps.data?.data?.char_whitelist; const wl = ps.data?.data?.char_whitelist;
// Zeilenumbrüche immer erlauben (Brieftext ist mehrzeilig). Einzeilige // Zeilenumbrüche immer erlauben (Brieftext ist mehrzeilig). Einzeilige
// Felder entfernen \n/\r ohnehin separat, daher hier gefahrlos. Tabs (\t) // Felder entfernen \n/\r ohnehin separat, daher hier gefahrlos. Tabs (\t)
@@ -133,6 +143,19 @@ const NeuAuftrag = defineComponent({
neu.rows[i].placeholders = { ...(neu.rows[i].placeholders || {}), [name]: saeubere(v) }; neu.rows[i].placeholders = { ...(neu.rows[i].placeholders || {}), [name]: saeubere(v) };
neu.previewSession = null; neu.previewSession = null;
}; };
// Spalten-Einfügen: eine ganze Excel-Spalte (Strg+V) in EINE Zelle einfügen.
// Zeilenumbrüche trennen die Empfänger; Kommata bleiben Teil des Werts (kein
// Trennzeichen). Legt automatisch so viele Empfänger an wie eingefügte Zeilen
// und füllt die Spalte ab der aktuellen Zeile nach unten.
// Rückgabe true = mehrzeilig eingefügt (Default-Paste unterdrücken).
const spalteEinfuegen = (startI, apply, text) => {
const werte = String(text || '').replace(/\r\n?/g, '\n').split('\n');
while (werte.length > 1 && werte[werte.length - 1].trim() === '') werte.pop();
if (werte.length <= 1) return false; // Einzelwert → normales Einfügen zulassen
while (neu.rows.length < startI + werte.length) neu.rows.push(leereZeile());
werte.forEach((w, k) => apply(startI + k, w));
return true;
};
// Platzhalter aus dem Brieftext ziehen (ohne den automatischen [[Briefnummer]]). // Platzhalter aus dem Brieftext ziehen (ohne den automatischen [[Briefnummer]]).
const customPlaceholders = () => { const customPlaceholders = () => {
const set = new Set(); const set = new Set();
@@ -166,6 +189,43 @@ const NeuAuftrag = defineComponent({
neu.importText = ''; neu.importOpen = false; neu.previewSession = null; neu.importText = ''; neu.importOpen = false; neu.previewSession = null;
} }
// ── Unterschrift auf dem Brief ([[signatur1]]) ────────────────────────────
// Sorgt dafür, dass der Platzhalter im Text steht (sonst rendert keine Signatur).
function sigEinfuegen() {
if (!neu.text.includes('[[signatur1]]')) neu.text = `${neu.text.trimEnd()}\n[[signatur1]]`;
neu.previewSession = null;
}
async function sigWaehlen(id) {
neu.sigSvg = ''; neu.sigLabel = '';
if (!id) { neu.previewSession = null; return; }
const s = signaturListe.value.find((x) => String(x.id) === String(id));
if (!s?.file) { neu.err = 'Diese Signatur hat keine SVG-Datei.'; return; }
try {
const res = await api.get(`/assets/${s.file}`, { responseType: 'text' });
neu.sigSvg = typeof res.data === 'string' ? res.data : String(res.data || '');
neu.sigLabel = s.label || 'Unterschrift';
sigEinfuegen();
} catch { neu.err = 'Signatur konnte nicht geladen werden.'; }
}
function sigDatei(e) {
const file = e.target.files && e.target.files[0];
if (!file) return;
const r = new FileReader();
r.onload = () => { neu.sigSvg = String(r.result || ''); neu.sigLabel = file.name; sigEinfuegen(); };
r.readAsText(file);
}
function sigEntfernen() {
neu.sigSvg = ''; neu.sigLabel = '';
neu.text = neu.text.replace(/\n?\[\[signatur1\]\]/g, '');
neu.previewSession = null;
}
// Signatur-Anteil der Payloads (Vorschau + Anlage). „brief"-Präfix, weil es
// bereits ein sigPayload() für den Unterschriften-Service (PDF) gibt.
const briefSigPayload = () => (neu.sigSvg
? { signatures: { signatur1: neu.sigSvg },
signature_offsets: { signatur1: { x: Number(neu.sigX) || 0, y: Number(neu.sigY) || 0, scale: (Number(neu.sigScale) || 100) / 100 } } }
: {});
async function preview() { async function preview() {
// Vorschau ohne Empfänger erlaubt – das Backend nutzt dann eine Blankozeile. // Vorschau ohne Empfänger erlaubt – das Backend nutzt dann eine Blankozeile.
if (!neu.text.trim()) { neu.err = 'Bitte zuerst einen Text eingeben.'; return; } if (!neu.text.trim()) { neu.err = 'Bitte zuerst einen Text eingeben.'; return; }
@@ -175,14 +235,46 @@ const NeuAuftrag = defineComponent({
const res = await api.post('/skrift-orders/preview', { const res = await api.post('/skrift-orders/preview', {
text: neu.text, font: neu.font, format: neu.format, realistic: neu.realistic, text: neu.text, font: neu.font, format: neu.format, realistic: neu.realistic,
envelope_labeling: kv.envelope_labeling, envelope_text: kv.envelope_text, envelope_labeling: kv.envelope_labeling, envelope_text: kv.envelope_text,
font_scale_letter: neu.fontSizeLetter / 100, font_scale_envelope: neu.fontSizeEnvelope / 100,
multi_page: neu.mehrseitig,
...briefSigPayload(),
entries: entries().slice(0, 3), entries: entries().slice(0, 3),
}); });
const d = res.data || {}; const d = res.data || {};
if (d.has_overflow) { neu.err = 'Text ist zu lang für das Format – bitte kürzen.'; neu.docs = []; neu.previewSession = null; } if (d.has_overflow) {
else { neu.docs = d.docs || d.previews || []; neu.previewSession = d.session || d.sessionId || null; } // Zeigen, wie viele Zeilen zu lang (aus dem ersten überlaufenden Schriftstück).
const of = (d.overflow || [])[0];
const zuViel = of ? Math.max(1, (Number(of.lineCount) || 0) - (Number(of.lineLimit) || 0)) : 0;
neu.err = of
? `Text ist ${zuViel} Zeile${zuViel === 1 ? '' : 'n'} zu lang – ${of.lineCount} statt max. ${of.lineLimit} Zeilen. Bitte kürzen.`
: 'Text ist zu lang für das Format – bitte kürzen.';
neu.docs = []; neu.previewSession = null;
} else { neu.docs = d.docs || d.previews || []; neu.previewSession = d.session || d.sessionId || null; }
} catch (e) { neu.err = e?.response?.data?.detail || e?.response?.data?.error || e?.message || 'Vorschau fehlgeschlagen.'; } } catch (e) { neu.err = e?.response?.data?.detail || e?.response?.data?.error || e?.message || 'Vorschau fehlgeschlagen.'; }
finally { neu.pLaedt = false; } finally { neu.pLaedt = false; }
} }
// Seiten je Schriftstück berechnen (mehrseitig) und nach Seitenzahl gruppieren:
// „2 Seiten: 1, 3, 4" · „3 Seiten: 2, 6, 7" …
async function seitenBerechnen() {
if (!neu.text.trim()) { neu.err = 'Bitte zuerst einen Text eingeben.'; return; }
neu.seitenInfo = 'Berechne …';
try {
const res = await api.post('/skrift-orders/pagecount', {
text: neu.text, format: neu.format,
font_scale_letter: neu.fontSizeLetter / 100,
entries: entries(),
});
const counts = res.data?.counts || [];
const gruppen = new Map();
counts.forEach((c) => { const g = gruppen.get(c.pages) || []; g.push(c.index); gruppen.set(c.pages, g); });
const zeilen = [...gruppen.keys()].sort((a, b) => a - b)
.map((p) => `${p} Seite${p === 1 ? '' : 'n'}: ${gruppen.get(p).join(', ')}`);
neu.seitenInfo = zeilen.join('\n') || 'Keine Schriftstücke.';
} catch (e) {
neu.seitenInfo = '';
neu.err = e?.response?.data?.error || e?.message || 'Seitenzählung fehlgeschlagen.';
}
}
async function absenden() { async function absenden() {
// Empfänger sind optional – ohne Empfänger genau ein Schriftstück (Blankozeile). // Empfänger sind optional – ohne Empfänger genau ein Schriftstück (Blankozeile).
const ent = entries(); const ent = entries();
@@ -192,6 +284,10 @@ const NeuAuftrag = defineComponent({
const kv = kuvertPayload(); const kv = kuvertPayload();
const res = await api.post('/skrift-orders/manual-order', { const res = await api.post('/skrift-orders/manual-order', {
product: neu.product, format: neu.format, font: neu.font, product: neu.product, format: neu.format, font: neu.font,
realistic: neu.realistic,
font_scale_letter: neu.fontSizeLetter / 100, font_scale_envelope: neu.fontSizeEnvelope / 100,
multi_page: neu.mehrseitig,
...briefSigPayload(),
needs_envelope: kv.needs_envelope, envelope_labeling: kv.envelope_labeling, envelope_text: kv.envelope_text, needs_envelope: kv.needs_envelope, envelope_labeling: kv.envelope_labeling, envelope_text: kv.envelope_text,
shipping_type: 'sammel', shipping_type: 'sammel',
customer_email: neu.customer_email.trim() || undefined, customer_email: neu.customer_email.trim() || undefined,
@@ -207,6 +303,8 @@ const NeuAuftrag = defineComponent({
function zuruecksetzen() { function zuruecksetzen() {
Object.assign(neu, { Object.assign(neu, {
product: produkte.value[0]?.key || 'briefe', format: neuFormate()[0]?.key || '', font: 'tilda', product: produkte.value[0]?.key || 'briefe', format: neuFormate()[0]?.key || '', font: 'tilda',
fontSizeLetter: 100, fontSizeEnvelope: 100,
sigSvg: '', sigLabel: '', sigX: 0, sigY: 0, sigScale: 100, mehrseitig: false, seitenInfo: '',
adressModus: '5zeilen', kuverts: false, realistic: true, customer_email: '', text: '', rows: [leereZeile()], adressModus: '5zeilen', kuverts: false, realistic: true, customer_email: '', text: '', rows: [leereZeile()],
importOpen: false, importText: '', importOpen: false, importText: '',
docs: [], previewSession: null, pLaedt: false, msg: '', err: '', hinweis: '', lb: '', docs: [], previewSession: null, pLaedt: false, msg: '', err: '', hinweis: '', lb: '',
@@ -229,7 +327,8 @@ const NeuAuftrag = defineComponent({
const docBild = (d) => { const docBild = (d) => {
const svg = d && typeof d.svg === 'string' ? d.svg : null; const svg = d && typeof d.svg === 'string' ? d.svg : null;
const src = svg ? svgUri(svg) : (typeof d === 'string' ? d : (d?.dataUrl || d?.url || d?.image || null)); const src = svg ? svgUri(svg) : (typeof d === 'string' ? d : (d?.dataUrl || d?.url || d?.image || null));
const txt = (d?.art === 'umschlag' ? '✉ Kuvert' : '📄 Schriftstück'); const seite = (d?.page && d?.pageCount) ? ` · Seite ${d.page}/${d.pageCount}` : '';
const txt = (d?.art === 'umschlag' ? '✉ Kuvert' : '📄 Schriftstück') + seite;
return h('div', { style: 'display:flex;flex-direction:column;align-items:center;gap:4px;' }, [ return h('div', { style: 'display:flex;flex-direction:column;align-items:center;gap:4px;' }, [
src ? h('img', { src, onClick: () => { neu.lb = src; }, style: 'width:100%;max-height:260px;object-fit:contain;border-radius:6px;background:#fff;cursor:zoom-in;box-shadow:0 1px 3px rgba(0,0,0,.12);' }) src ? h('img', { src, onClick: () => { neu.lb = src; }, style: 'width:100%;max-height:260px;object-fit:contain;border-radius:6px;background:#fff;cursor:zoom-in;box-shadow:0 1px 3px rgba(0,0,0,.12);' })
: h('div', { style: 'width:100%;height:200px;border-radius:6px;display:flex;align-items:center;justify-content:center;background:#fff;color:var(--foreground-subdued);' }, 'Dok.'), : h('div', { style: 'width:100%;height:200px;border-radius:6px;display:flex;align-items:center;justify-content:center;background:#fff;color:var(--foreground-subdued);' }, 'Dok.'),
@@ -237,16 +336,18 @@ const NeuAuftrag = defineComponent({
]); ]);
}; };
// Weißes, einzeiliges Zellenfeld (feste Breite → Zeile scrollt bei Bedarf). // Weißes, einzeiliges Zellenfeld (feste Breite → Zeile scrollt bei Bedarf).
const feld = (lbl, val, on, ph) => h('div', { style: 'display:flex;flex-direction:column;gap:3px;flex:1 1 0;min-width:90px;' }, [ const feld = (lbl, val, on, ph, onPaste) => h('div', { style: 'display:flex;flex-direction:column;gap:3px;flex:1 1 0;min-width:90px;' }, [
h('label', { style: 'font-size:10px;text-transform:uppercase;letter-spacing:.04em;color:var(--foreground-subdued);' }, lbl), h('label', { style: 'font-size:10px;text-transform:uppercase;letter-spacing:.04em;color:var(--foreground-subdued);' }, lbl),
h('input', { value: val, placeholder: ph || '', style: WFELD + 'width:100%;padding:7px 9px;font-size:13px;', onInput: on }), h('input', { value: val, placeholder: ph || '', style: WFELD + 'width:100%;padding:7px 9px;font-size:13px;', onInput: on, onPaste }),
]); ]);
function formular() { function formular() {
// Empfängerzeile: erst individuelle Platzhalter, dann die Adresszeilen. // Empfängerzeile: erst individuelle Platzhalter, dann die Adresszeilen.
const zeile = (e, i) => [ const zeile = (e, i) => [
...customPlaceholders().map((name) => feld(name, e.placeholders?.[name] || '', (ev) => setPlatzhalter(i, name, ev.target.value))), ...customPlaceholders().map((name) => feld(name, e.placeholders?.[name] || '', (ev) => setPlatzhalter(i, name, ev.target.value), '',
...Array.from({ length: zeilenAnzahl() }, (_, z) => feld('Zeile ' + (z + 1), freitext(e, z), (ev) => setFreitext(i, z, ev.target.value))), (ev) => { if (spalteEinfuegen(i, (ri, v) => setPlatzhalter(ri, name, v), ev.clipboardData && ev.clipboardData.getData('text'))) ev.preventDefault(); })),
...Array.from({ length: zeilenAnzahl() }, (_, z) => feld('Zeile ' + (z + 1), freitext(e, z), (ev) => setFreitext(i, z, ev.target.value), '',
(ev) => { if (spalteEinfuegen(i, (ri, v) => setFreitext(ri, z, v), ev.clipboardData && ev.clipboardData.getData('text'))) ev.preventDefault(); })),
]; ];
// Bereich 1 – Produkt // Bereich 1 – Produkt
@@ -257,10 +358,25 @@ const NeuAuftrag = defineComponent({
h('div', {}, [label('Format'), sel(neu.format, neuFormate().map((f) => ({ v: f.key, t: f.name })), (e) => { neu.format = e.target.value; neu.previewSession = null; })]), h('div', {}, [label('Format'), sel(neu.format, neuFormate().map((f) => ({ v: f.key, t: f.name })), (e) => { neu.format = e.target.value; neu.previewSession = null; })]),
h('div', {}, [label('Schrift'), sel(neu.font, [['tilda', 'Tilda'], ['alva', 'Alva'], ['ellie', 'Ellie']].map(([v, t]) => ({ v, t })), (e) => { neu.font = e.target.value; neu.previewSession = null; })]), h('div', {}, [label('Schrift'), sel(neu.font, [['tilda', 'Tilda'], ['alva', 'Alva'], ['ellie', 'Ellie']].map(([v, t]) => ({ v, t })), (e) => { neu.font = e.target.value; neu.previewSession = null; })]),
]), ]),
h('div', { style: 'display:grid;grid-template-columns:1fr 1fr;gap:12px;margin-top:12px;' }, [
h('div', {}, [label('Schriftgröße Brief (%)'),
// Frei tippbar; erst beim Verlassen des Feldes auf 80–150 begrenzen.
h('input', { type: 'number', min: 80, max: 150, step: 5, value: neu.fontSizeLetter, style: WFELD + 'width:100%;',
onInput: (e) => { neu.fontSizeLetter = e.target.value; neu.previewSession = null; },
onBlur: (e) => { const n = Math.round(Number(e.target.value)); neu.fontSizeLetter = (Number.isFinite(n) && n) ? Math.max(80, Math.min(150, n)) : 100; } })]),
h('div', {}, [label('Schriftgröße Kuvert (%)'),
h('input', { type: 'number', min: 80, max: 150, step: 5, value: neu.fontSizeEnvelope, style: WFELD + 'width:100%;',
onInput: (e) => { neu.fontSizeEnvelope = e.target.value; neu.previewSession = null; },
onBlur: (e) => { const n = Math.round(Number(e.target.value)); neu.fontSizeEnvelope = (Number.isFinite(n) && n) ? Math.max(80, Math.min(150, n)) : 100; } })]),
]),
h('label', { style: 'display:flex;align-items:center;gap:8px;font-size:14px;margin-top:12px;cursor:pointer;' }, [ h('label', { style: 'display:flex;align-items:center;gap:8px;font-size:14px;margin-top:12px;cursor:pointer;' }, [
h('input', { type: 'checkbox', checked: neu.realistic, onChange: (e) => { neu.realistic = e.target.checked; neu.previewSession = null; }, style: 'width:16px;height:16px;' }), h('input', { type: 'checkbox', checked: neu.realistic, onChange: (e) => { neu.realistic = e.target.checked; neu.previewSession = null; }, style: 'width:16px;height:16px;' }),
'Natürliche Handschrift (leichte Variation)', 'Natürliche Handschrift (leichte Variation)',
]), ]),
h('label', { style: 'display:flex;align-items:center;gap:8px;font-size:14px;margin-top:8px;cursor:pointer;' }, [
h('input', { type: 'checkbox', checked: neu.mehrseitig, onChange: (e) => { neu.mehrseitig = e.target.checked; neu.previewSession = null; }, style: 'width:16px;height:16px;' }),
'Mehrseitiges Schriftstück (Text fließt automatisch über mehrere A4-Seiten)',
]),
]); ]);
// Bereich 2 – Kuvert (Empfängertabelle) // Bereich 2 – Kuvert (Empfängertabelle)
@@ -312,6 +428,34 @@ const NeuAuftrag = defineComponent({
neu.previewSession = null; neu.previewSession = null;
requestAnimationFrame(() => { try { ta.selectionStart = ta.selectionEnd = s + 1; } catch {} }); requestAnimationFrame(() => { try { ta.selectionStart = ta.selectionEnd = s + 1; } catch {} });
} }), } }),
// ── Unterschrift auf den Brief ─────────────────────────────────────
h('div', { style: 'margin-top:16px;border-top:1px solid rgba(30,80,165,.15);padding-top:14px;' }, [
label('Unterschrift auf den Brief (optional) · Platzhalter [[signatur1]]'),
h('div', { style: 'display:grid;grid-template-columns:1fr auto;gap:10px;align-items:center;' }, [
h('select', { style: WSELECT + 'width:100%;', onChange: (e) => sigWaehlen(e.target.value) },
[h('option', { value: '' }, 'Vorhandene Unterschrift wählen …')].concat(
signaturListe.value.map((s) => {
const kunde = [s.customer?.first_name, s.customer?.last_name].filter(Boolean).join(' ');
return h('option', { value: s.id }, (s.label || `Signatur ${s.id}`) + (kunde ? ` · ${kunde}` : ''));
}))),
h('label', { style: 'cursor:pointer;border-radius:8px;padding:8px 16px;font:inherit;font-size:14px;border:none;background:#fff;color:' + ACCENT + ';box-shadow:0 1px 2px rgba(0,0,0,.1);white-space:nowrap;' }, [
'⇪ SVG hochladen',
h('input', { type: 'file', accept: '.svg,image/svg+xml', style: 'display:none;', onChange: sigDatei }),
]),
]),
neu.sigSvg ? h('div', { style: 'margin-top:12px;' }, [
h('div', { style: 'display:flex;align-items:center;gap:10px;flex-wrap:wrap;margin-bottom:10px;' }, [
h('span', { style: `color:${ACCENT};font-size:13px;font-weight:600;` }, `✓ ${neu.sigLabel} – als [[signatur1]] im Text`),
btn('Entfernen', sigEntfernen),
]),
h('div', { style: 'display:grid;grid-template-columns:1fr 1fr 1fr;gap:12px;' }, [
h('div', {}, [label('Versatz X (mm)'), h('input', { type: 'number', step: 1, value: neu.sigX, style: WFELD + 'width:100%;', onInput: (e) => { neu.sigX = e.target.value; neu.previewSession = null; } })]),
h('div', {}, [label('Versatz Y (mm)'), h('input', { type: 'number', step: 1, value: neu.sigY, style: WFELD + 'width:100%;', onInput: (e) => { neu.sigY = e.target.value; neu.previewSession = null; } })]),
h('div', {}, [label('Größe (%)'), h('input', { type: 'number', step: 5, value: neu.sigScale, style: WFELD + 'width:100%;', onInput: (e) => { neu.sigScale = e.target.value; neu.previewSession = null; } })]),
]),
subdued('Positiv X = nach rechts, positiv Y = nach unten. Nach dem Anpassen „Aktualisieren" in der Vorschau klicken.', 'margin-top:8px;'),
]) : null,
]),
]); ]);
// Bereich 4 – Kunde // Bereich 4 – Kunde
@@ -341,8 +485,17 @@ const NeuAuftrag = defineComponent({
btn(neu.pLaedt ? '…' : 'Aktualisieren', preview), btn(neu.pLaedt ? '…' : 'Aktualisieren', preview),
]), ]),
neu.pLaedt ? subdued('Wird erzeugt …') neu.pLaedt ? subdued('Wird erzeugt …')
: neu.docs.length ? h('div', { style: 'display:flex;flex-direction:column;gap:12px;' }, neu.docs.slice(0, 4).map(docBild)) : neu.docs.length ? h('div', { style: 'display:flex;flex-direction:column;gap:12px;' }, neu.docs.slice(0, 12).map(docBild))
: subdued('Noch keine Vorschau. „Aktualisieren" klicken (Klick aufs Bild = groß).'), : subdued('Noch keine Vorschau. „Aktualisieren" klicken (Klick aufs Bild = groß).'),
neu.mehrseitig ? h('div', { style: 'margin-top:14px;border-top:1px solid rgba(30,80,165,.15);padding-top:12px;' }, [
h('div', { style: 'display:flex;justify-content:space-between;align-items:center;gap:8px;margin-bottom:8px;' }, [
h('div', { style: `font-size:13px;font-weight:700;color:${ACCENT};` }, 'Seiten je Schriftstück'),
btn('Berechnen', seitenBerechnen),
]),
neu.seitenInfo
? h('pre', { style: 'margin:0;white-space:pre-wrap;font:inherit;font-size:13px;color:var(--foreground);' }, neu.seitenInfo)
: subdued('„Berechnen" klicken – zeigt, wie viele Seiten je Empfänger entstehen.'),
]) : null,
]); ]);
return h('div', { style: 'display:flex;gap:20px;align-items:flex-start;flex-wrap:wrap;' }, [links, rechts]); return h('div', { style: 'display:flex;gap:20px;align-items:flex-start;flex-wrap:wrap;' }, [links, rechts]);

View File

@@ -545,6 +545,15 @@ const handler = (router, { services, getSchema, logger }) => {
return clean([name, strasse, ort].filter(Boolean).join('\n')); return clean([name, strasse, ort].filter(Boolean).join('\n'));
}; };
// Relative Schriftgröße (manuelle Aufträge), getrennt für Brief/Kuvert. 1 = Standard.
const skala = (v) => { const n = Number(v); return Number.isFinite(n) ? Math.max(0.8, Math.min(1.5, n)) : 1; };
const fsLetter = skala(body.font_scale_letter);
const fsEnv = skala(body.font_scale_envelope);
// Signaturen (SVG je [[signaturN]]) + Feinjustierung – nur Brief, nicht Kuvert.
const sigMap = (body.signatures && typeof body.signatures === 'object') ? body.signatures : {};
const sigOff = (body.signature_offsets && typeof body.signature_offsets === 'object') ? body.signature_offsets : {};
// Mehrseitiges Schriftstück: Text fließt über mehrere Seiten (kein Überlauf-Fehler).
const mehrseitig = body.multi_page === true;
const basis = entries.length ? entries : [{}]; const basis = entries.length ? entries : [{}];
const letters = []; const letters = [];
basis.forEach((e, i) => { basis.forEach((e, i) => {
@@ -555,7 +564,8 @@ const handler = (router, { services, getSchema, logger }) => {
letters.push({ letters.push({
index: nr, type: 'letter', text: clean(briefText), index: nr, type: 'letter', text: clean(briefText),
format: briefFormat, font, realisticHandwriting: realistisch, format: briefFormat, font, realisticHandwriting: realistisch,
placeholders: platzhalterVon(e, i), placeholders: platzhalterVon(e, i), fontScale: fsLetter,
signatures: sigMap, signatureOffsets: sigOff, multiPage: mehrseitig,
}); });
// Umschlag nur, wenn er auch beschriftet wird. // Umschlag nur, wenn er auch beschriftet wird.
@@ -566,7 +576,7 @@ const handler = (router, { services, getSchema, logger }) => {
envelopeType: istFreitext ? 'custom' : 'recipient', envelopeType: istFreitext ? 'custom' : 'recipient',
text: istFreitext ? clean(String(body.envelope_text || '')) : adressBlock(e), text: istFreitext ? clean(String(body.envelope_text || '')) : adressBlock(e),
format: umschlagFormat, font, realisticHandwriting: realistisch, format: umschlagFormat, font, realisticHandwriting: realistisch,
placeholders: platzhalterVon(e, i), placeholders: platzhalterVon(e, i), fontScale: fsEnv,
}); });
} }
}); });
@@ -610,7 +620,7 @@ const handler = (router, { services, getSchema, logger }) => {
const r = await fetch(`${BACKEND_URL}${datei.url}`, { headers: { 'X-API-Token': BACKEND_TOKEN } }); const r = await fetch(`${BACKEND_URL}${datei.url}`, { headers: { 'X-API-Token': BACKEND_TOKEN } });
if (r.ok) { if (r.ok) {
const istUmschlag = /(^|\/)envelope/.test(datei.filename || datei.url || ''); const istUmschlag = /(^|\/)envelope/.test(datei.filename || datei.url || '');
docs.push({ art: istUmschlag ? 'umschlag' : 'brief', svg: await r.text() }); docs.push({ art: istUmschlag ? 'umschlag' : 'brief', svg: await r.text(), page: datei.page, pageCount: datei.pageCount });
} }
} }
@@ -633,6 +643,35 @@ const handler = (router, { services, getSchema, logger }) => {
} }
}); });
/** Seitenzahl je Schriftstück (mehrseitig) – schlank, ohne Scriptalizer/SVG. */
router.post('/pagecount', async (req, res) => {
const body = req.body || {};
if (!body.text || !String(body.text).trim()) return res.status(400).json({ error: 'Text fehlt.' });
try {
const schema = await getSchema();
const { settings } = await loadPricingContext(schema);
const clean = makeSanitizer(settings.char_whitelist || '\\x20-\\x7E');
const LETTER_FORMAT = { a4: 'a4', a6_hoch: 'a6p', a6_quer: 'a6l' };
const briefFormat = LETTER_FORMAT[body.format] || body.format || 'a4';
const scale = Math.max(0.8, Math.min(1.5, Number(body.font_scale_letter) || 1));
const entries = (Array.isArray(body.entries) ? body.entries : []).map((e) => ({
placeholders: (e && typeof e.placeholders === 'object')
? Object.fromEntries(Object.entries(e.placeholders).map(([k, v]) => [k, clean(String(v))]))
: {},
}));
const r = await fetch(`${BACKEND_URL}/api/order/pagecount`, {
method: 'POST',
headers: { 'Content-Type': 'application/json', 'X-API-Token': BACKEND_TOKEN },
body: JSON.stringify({ text: clean(String(body.text)), format: briefFormat, fontScale: scale, entries }),
});
if (!r.ok) return res.status(502).json({ error: 'Seitenzählung fehlgeschlagen.' });
return res.json(await r.json());
} catch (err) {
logger.error(`[skrift-orders] pagecount: ${err.stack || err.message}`);
return res.status(500).json({ error: 'Seitenzählung fehlgeschlagen.' });
}
});
/** Aktuelles Kontingent abfragen, ohne etwas zu verbrauchen. */ /** Aktuelles Kontingent abfragen, ohne etwas zu verbrauchen. */
router.get('/preview/quota', async (req, res) => { router.get('/preview/quota', async (req, res) => {
try { try {
@@ -1176,7 +1215,7 @@ const handler = (router, { services, getSchema, logger }) => {
email, email,
phone: clean(String(body.phone || '').trim()) || null, phone: clean(String(body.phone || '').trim()) || null,
product: clean(String(body.product)), product: clean(String(body.product)),
message: null, message: clean(String(body.message || '').trim().slice(0, 1000)) || null,
address: { address: {
street: clean(String(body.street || '')), street: clean(String(body.street || '')),
zip: clean(String(body.zip || '')), zip: clean(String(body.zip || '')),
@@ -1187,9 +1226,11 @@ const handler = (router, { services, getSchema, logger }) => {
customer: customer?.id ?? null, customer: customer?.id ?? null,
}); });
const musterNachricht = clean(String(body.message || '').trim().slice(0, 1000));
await teamMail(schema, `Neue Musteranfrage: ${clean(String(body.name))}`, await teamMail(schema, `Neue Musteranfrage: ${clean(String(body.name))}`,
`<p>Neue Musteranfrage von <strong>${clean(String(body.name))}</strong> (${email}${body.phone ? `, ${clean(String(body.phone))}` : ''})` `<p>Neue Musteranfrage von <strong>${clean(String(body.name))}</strong> (${email}${body.phone ? `, ${clean(String(body.phone))}` : ''})`
+ ` · Produkt: ${clean(String(body.product))} – im Board unter „Neu".</p>`); + ` · Produkt: ${clean(String(body.product))} – im Board unter „Neu".</p>`
+ (musterNachricht ? `<p><strong>Nachricht:</strong><br>${musterNachricht.replace(/\n/g, '<br>')}</p>` : ''));
return res.json({ ok: true }); return res.json({ ok: true });
} catch (err) { } catch (err) {
@@ -1371,6 +1412,16 @@ const handler = (router, { services, getSchema, logger }) => {
product: product.id, format: formatId, product: product.id, format: formatId,
person_type: body.person_type === 'unternehmen' ? 'unternehmen' : 'privat', person_type: body.person_type === 'unternehmen' ? 'unternehmen' : 'privat',
font: ['tilda', 'alva', 'ellie'].includes(body.font) ? body.font : 'tilda', font: ['tilda', 'alva', 'ellie'].includes(body.font) ? body.font : 'tilda',
realistic: body.realistic !== false,
// Relative Schriftgröße (getrennt Brief/Kuvert), 1 = Standard.
font_scale_letter: Math.max(0.8, Math.min(1.5, Number(body.font_scale_letter) || 1)),
font_scale_envelope: Math.max(0.8, Math.min(1.5, Number(body.font_scale_envelope) || 1)),
// Signatur(en) auf dem Brief (SVG je [[signaturN]]) + Feinjustierung, für die finale Generierung.
signatures_manual: (body.signatures && typeof body.signatures === 'object' && Object.keys(body.signatures).length)
? { signatures: body.signatures, offsets: (body.signature_offsets && typeof body.signature_offsets === 'object') ? body.signature_offsets : {} }
: null,
// Mehrseitiges Schriftstück (Auto-Fluss). Seiten werden bei der Generierung erzeugt.
multi_page: body.multi_page === true,
source: 'operator', status: 'in_queue', production_status: 'eingegangen', source: 'operator', status: 'in_queue', production_status: 'eingegangen',
payment_status: 'bezahlt', payment_method: 'rechnung', payment_status: 'bezahlt', payment_method: 'rechnung',
shipping_type: body.shipping_type === 'einzeln' ? 'einzeln' : 'sammel', shipping_type: body.shipping_type === 'einzeln' ? 'einzeln' : 'sammel',
@@ -1532,6 +1583,9 @@ const handler = (router, { services, getSchema, logger }) => {
format: formatId, format: formatId,
person_type: body.person_type === 'unternehmen' ? 'unternehmen' : 'privat', person_type: body.person_type === 'unternehmen' ? 'unternehmen' : 'privat',
font: ['tilda', 'alva', 'ellie'].includes(body.font) ? body.font : 'tilda', font: ['tilda', 'alva', 'ellie'].includes(body.font) ? body.font : 'tilda',
// Relative Schriftgröße (v.a. manuelle Aufträge), getrennt Brief/Kuvert. 1 = Standard.
font_scale_letter: Math.max(0.8, Math.min(1.5, Number(body.font_scale_letter) || 1)),
font_scale_envelope: Math.max(0.8, Math.min(1.5, Number(body.font_scale_envelope) || 1)),
source: ['operator', 'portal', 'extern'].includes(body.source) ? body.source : 'configurator', source: ['operator', 'portal', 'extern'].includes(body.source) ? body.source : 'configurator',
// Extern (z. B. Etsy) wird über die Plattform bezahlt → nicht auf Zahlung warten. // Extern (z. B. Etsy) wird über die Plattform bezahlt → nicht auf Zahlung warten.
status: body.source === 'extern' ? 'bezahlt' : 'wartet_auf_zahlung', status: body.source === 'extern' ? 'bezahlt' : 'wartet_auf_zahlung',

View File

@@ -19,7 +19,7 @@
* *
* Bewusst von Hand als ESM (kein Build-Schritt) – Vue + SDK stellt Directus bereit. * Bewusst von Hand als ESM (kein Build-Schritt) – Vue + SDK stellt Directus bereit.
*/ */
import { defineComponent, ref, reactive, computed, onMounted, h, Teleport, resolveComponent } from 'vue'; import { defineComponent, ref, reactive, computed, onMounted, onUnmounted, h, Teleport, resolveComponent } from 'vue';
import { useApi } from '@directus/extensions-sdk'; import { useApi } from '@directus/extensions-sdk';
// Auftragsformat → Standard-Template-Schlüssel (wie im Backend /enqueue). // Auftragsformat → Standard-Template-Schlüssel (wie im Backend /enqueue).
@@ -180,8 +180,9 @@ const Board = defineComponent({
return api.get('/items/machines', { params: { limit: -1, fields: 'id,name,active,status,last_seen' } }); return api.get('/items/machines', { params: { limit: -1, fields: 'id,name,active,status,last_seen' } });
} }
} }
async function laden() { async function laden(leise = false) {
loading.value = true; fehler.value = ''; // leise = Hintergrund-Aktualisierung: kein Spinner, kein Fehlerbanner.
if (!leise) { loading.value = true; fehler.value = ''; }
try { try {
const [o, r, j, m, t, ms] = await Promise.all([ const [o, r, j, m, t, ms] = await Promise.all([
ladeOrders(), ladeOrders(),
@@ -202,11 +203,25 @@ const Board = defineComponent({
templates.value = t.data?.data || []; templates.value = t.data?.data || [];
muster.value = ms.data?.data || { text_du: '', text_sie: '' }; muster.value = ms.data?.data || { text_du: '', text_sie: '' };
} catch (e) { } catch (e) {
fehler.value = e?.response?.data?.errors?.[0]?.message || e?.message || 'Laden fehlgeschlagen.'; if (!leise) fehler.value = e?.response?.data?.errors?.[0]?.message || e?.message || 'Laden fehlgeschlagen.';
} finally { loading.value = false; } } finally { if (!leise) loading.value = false; }
} }
onMounted(laden); onMounted(laden);
// Auto-Refresh: hält das Board aktuell, ohne dass man die Seite neu laden muss.
// Pausiert bei offenem Sammel-Dialog, im Hintergrund-Tab und während bereits
// geladen wird – damit laufende Bedienung nicht gestört wird.
let refreshTimer = null;
onMounted(() => {
refreshTimer = setInterval(() => {
// Bei offenem Dialog oder im Hintergrund-Tab nicht aktualisieren.
const dialogOffen = bulk.open || druck.open || manuell.open || empf.open || dateien.open;
if (loading.value || dialogOffen || (typeof document !== 'undefined' && document.hidden)) return;
laden(true);
}, 15000);
});
onUnmounted(() => { if (refreshTimer) clearInterval(refreshTimer); });
const aktiveMaschinen = computed(() => machines.value.filter((m) => m.active !== false)); const aktiveMaschinen = computed(() => machines.value.filter((m) => m.active !== false));
const maschineBusy = (id) => jobs.value.some((j) => j.status === 'printing' && String(j.machine?.id) === String(id)); const maschineBusy = (id) => jobs.value.some((j) => j.status === 'printing' && String(j.machine?.id) === String(id));

View File

@@ -11,6 +11,8 @@
const { runGeneration } = require('./order-controller'); const { runGeneration } = require('./order-controller');
const directus = require('../../services/directus-service'); const directus = require('../../services/directus-service');
const { countLetterPages } = require('../../lib/svg-generator');
const { replacePlaceholders } = require('../../services/placeholder-service');
// Directus-Formatschlüssel → Backend-Formate // Directus-Formatschlüssel → Backend-Formate
const LETTER_FORMAT = { a4: 'a4', a6_hoch: 'a6p', a6_quer: 'a6l' }; const LETTER_FORMAT = { a4: 'a4', a6_hoch: 'a6p', a6_quer: 'a6l' };
@@ -53,6 +55,20 @@ function buildDocuments(order, entries) {
// Datei-Produkte (z. B. Unterschriftenservice): das „Schriftstück" ist das vom // Datei-Produkte (z. B. Unterschriftenservice): das „Schriftstück" ist das vom
// Kunden hochgeladene Dokument – es wird NICHT generiert. Kuverts hingegen schon. // Kunden hochgeladene Dokument – es wird NICHT generiert. Kuverts hingegen schon.
const istDatei = order.product?.input_mode === 'datei'; const istDatei = order.product?.input_mode === 'datei';
// Kuvert-only-Produkt: es wird KEIN Schriftstück generiert, nur die (adressierten)
// Kuverts. Etwaige hochgeladene PDF-Briefe liegen als source_files am Auftrag.
const istKuvertOnly = order.product?.type === 'envelope';
// Natürliche Handschrift-Variation (Default an), am Auftrag gespeichert.
const realistisch = order.realistic !== false;
// Relative Schriftgröße (getrennt Brief/Kuvert), aus dem Auftrag. 1 = Standard.
const fontScaleLetter = Number(order.font_scale_letter) || 1;
const fontScaleEnv = Number(order.font_scale_envelope) || 1;
// Signatur(en) auf dem Brief (manuelle Aufträge): SVG je [[signaturN]] + Feinjustierung.
const sigManual = order.signatures_manual && typeof order.signatures_manual === 'object' ? order.signatures_manual : null;
const sigMap = sigManual?.signatures || {};
const sigOff = sigManual?.offsets || {};
// Mehrseitiges Schriftstück (Auto-Fluss über N Seiten) – nur wenn am Auftrag gesetzt.
const istMehrseitig = !!order.multi_page;
const documents = []; const documents = [];
@@ -62,7 +78,7 @@ function buildDocuments(order, entries) {
// Briefnummer 1 gehört. Vorschau nummeriert identisch (siehe skrift-orders). // Briefnummer 1 gehört. Vorschau nummeriert identisch (siehe skrift-orders).
const nr = Number(entry.letter_number) || (i + 1); const nr = Number(entry.letter_number) || (i + 1);
if (!istDatei) { if (!istDatei && !istKuvertOnly) {
// Abweichender Text je Schriftstück (#5) hat Vorrang; sonst Standardtext. // Abweichender Text je Schriftstück (#5) hat Vorrang; sonst Standardtext.
const briefText = (entry.text && String(entry.text).trim()) ? entry.text : (order.text_template || ''); const briefText = (entry.text && String(entry.text).trim()) ? entry.text : (order.text_template || '');
documents.push({ documents.push({
@@ -72,6 +88,11 @@ function buildDocuments(order, entries) {
format: letterFormat, format: letterFormat,
font, font,
placeholders, placeholders,
fontScale: fontScaleLetter,
signatures: sigMap,
signatureOffsets: sigOff,
multiPage: istMehrseitig,
realisticHandwriting: realistisch,
}); });
} }
@@ -84,6 +105,8 @@ function buildDocuments(order, entries) {
format: envFormat, format: envFormat,
font, font,
placeholders, placeholders,
fontScale: fontScaleEnv,
realisticHandwriting: realistisch,
}); });
} }
}); });
@@ -176,4 +199,27 @@ async function generateFromDirectus(req, res, next) {
} }
} }
module.exports = { generateFromDirectus }; /**
* POST /api/order/pagecount
* Body: { text, format, fontScale, entries: [{ placeholders }] }
* Liefert je Dokument die Seitenzahl (nur Umbruch-Zählung, kein Scriptalizer/SVG).
*/
function pageCounts(req, res) {
const { text, format, fontScale, entries } = req.body || {};
if (!text || !String(text).trim()) {
return res.status(400).json({ error: 'Invalid request', message: 'text is required' });
}
const fmt = format || 'a4';
const scale = Number(fontScale) || 1;
const list = Array.isArray(entries) && entries.length ? entries : [{}];
const counts = list.map((e, i) => {
const ph = { ...(e && typeof e.placeholders === 'object' ? e.placeholders : {}), Briefnummer: String(i + 1) };
let pages = 1;
try { pages = countLetterPages(replacePlaceholders(String(text), ph), fmt, { fontScale: scale }); }
catch { pages = 1; }
return { index: i + 1, pages };
});
return res.json({ counts });
}
module.exports = { generateFromDirectus, pageCounts };

View File

@@ -3,7 +3,7 @@ const fsSync = require('fs');
const path = require('path'); const path = require('path');
const config = require('../../config'); const config = require('../../config');
const { scriptalizeBatch } = require('../../services/scriptalizer-service'); const { scriptalizeBatch } = require('../../services/scriptalizer-service');
const { generateLetterSVG, generateEnvelopeSVG } = require('../../lib/svg-generator'); const { generateLetterSVG, generateEnvelopeSVG, generateLetterPages } = require('../../lib/svg-generator');
const { replacePlaceholders, generateAllCSVs } = require('../../services/placeholder-service'); const { replacePlaceholders, generateAllCSVs } = require('../../services/placeholder-service');
const { TAB_MARKER } = require('../../lib/svg-font-engine'); const { TAB_MARKER } = require('../../lib/svg-font-engine');
@@ -188,7 +188,8 @@ async function runGeneration({ orderNumber, letters, metadata }) {
index: letter.index !== undefined ? letter.index : loopIndex, index: letter.index !== undefined ? letter.index : loopIndex,
loopIndex, loopIndex,
processedText: text, processedText: text,
signatures: sigPlaceholders, // Signaturen aus Platzhaltern UND direkt übergebene (manuelle Aufträge).
signatures: { ...(letter.signatures || {}), ...sigPlaceholders },
format: letter.format || 'a4', format: letter.format || 'a4',
font: letter.font || 'tilda', font: letter.font || 'tilda',
type: letter.type || 'letter', type: letter.type || 'letter',
@@ -219,7 +220,7 @@ async function runGeneration({ orderNumber, letters, metadata }) {
for (const letter of fontLetters) { for (const letter of fontLetters) {
const raw = letter.processedText; const raw = letter.processedText;
const parts = raw.split(/(\t|\[\[signatur\d+\]\]|[&|])/gi); const parts = raw.split(/(\t|\[\[signatur\d+\]\]|\[\[seitenumbruch\]\]|[&|])/gi);
const segments = [], markers = []; const segments = [], markers = [];
for (let i = 0; i < parts.length; i++) { for (let i = 0; i < parts.length; i++) {
if (i % 2 === 0) segments.push(parts[i]); if (i % 2 === 0) segments.push(parts[i]);
@@ -271,7 +272,42 @@ async function runGeneration({ orderNumber, letters, metadata }) {
const letter = processedLetters[i]; const letter = processedLetters[i];
const absoluteIndex = letter.index !== undefined ? letter.index : i; const absoluteIndex = letter.index !== undefined ? letter.index : i;
const isEnv = letter.type === 'envelope'; const isEnv = letter.type === 'envelope';
const filename = `${isEnv ? 'envelope' : 'letter'}_${String(absoluteIndex).padStart(3, '0')}.svg`; const pad = String(absoluteIndex).padStart(3, '0');
// Mehrseitiger Brief → N Seiten-Dateien letter_NNN_pM.svg (Seite 1..N).
if (!isEnv && letter.multiPage) {
const scriptalizedText = scriptalizedMap.get(letter.loopIndex) || letter.processedText;
let pages;
try {
({ pages } = generateLetterPages(scriptalizedText, letter.format, {
font: letter.font, realisticHandwriting: letter.realisticHandwriting ?? false, fontScale: letter.fontScale,
}));
} catch (err) {
const e = new Error(`Failed to generate SVG for letter ${i}: ${err.message}`);
e.status = 500; e.label = 'SVG generation failed'; throw e;
}
// Entweder ALLE Seiten aus der Vorschau übernehmen oder ALLE neu rendern –
// nicht mischen, sonst unterschiedliche Handschrift-Variation je Seite.
let alleInVorschau = false;
if (previewSession) {
alleInVorschau = true;
for (let p = 0; p < pages.length; p++) {
try { await fs.access(path.join(previewsRoot, previewSession, `letter_${pad}_p${p + 1}.svg`)); }
catch { alleInVorschau = false; break; }
}
}
for (let p = 0; p < pages.length; p++) {
const fn = `letter_${pad}_p${p + 1}.svg`;
const fp = path.join(outputDir, fn);
if (alleInVorschau) await fs.copyFile(path.join(previewsRoot, previewSession, fn), fp);
else await fs.writeFile(fp, pages[p], 'utf8');
generatedLetters.push(fn);
}
console.log(`[Order] letter_${pad}: ${pages.length} Seiten${alleInVorschau ? ' (aus Vorschau)' : ''}.`);
continue;
}
const filename = `${isEnv ? 'envelope' : 'letter'}_${pad}.svg`;
const filepath = isEnv ? path.join(envelopesDir, filename) : path.join(outputDir, filename); const filepath = isEnv ? path.join(envelopesDir, filename) : path.join(outputDir, filename);
// 1:1 aus der Vorschau übernehmen, wenn für dieses Dokument eine // 1:1 aus der Vorschau übernehmen, wenn für dieses Dokument eine
@@ -293,12 +329,12 @@ async function runGeneration({ orderNumber, letters, metadata }) {
if (isEnv) { if (isEnv) {
svgResult = generateEnvelopeSVG( svgResult = generateEnvelopeSVG(
scriptalizedText, letter.format, letter.envelopeType, scriptalizedText, letter.format, letter.envelopeType,
{ font: letter.font, realisticHandwriting: letter.realisticHandwriting ?? false } { font: letter.font, realisticHandwriting: letter.realisticHandwriting ?? false, fontScale: letter.fontScale }
); );
} else { } else {
svgResult = generateLetterSVG( svgResult = generateLetterSVG(
scriptalizedText, letter.format, scriptalizedText, letter.format,
{ font: letter.font, realisticHandwriting: letter.realisticHandwriting ?? false, signatures: letter.signatures || {} } { font: letter.font, realisticHandwriting: letter.realisticHandwriting ?? false, signatures: letter.signatures || {}, signatureOffsets: letter.signatureOffsets || {}, fontScale: letter.fontScale }
); );
} }
} catch (err) { } catch (err) {

View File

@@ -7,6 +7,7 @@ const { scriptalizeBatch } = require("../../services/scriptalizer-service");
const { const {
generateLetterSVG, generateLetterSVG,
generateEnvelopeSVG, generateEnvelopeSVG,
generateLetterPages,
} = require("../../lib/svg-generator"); } = require("../../lib/svg-generator");
const { const {
replacePlaceholders, replacePlaceholders,
@@ -75,7 +76,8 @@ async function generateBatch(req, res, next) {
...letter, ...letter,
index: letter.index !== undefined ? letter.index : loopIndex, index: letter.index !== undefined ? letter.index : loopIndex,
processedText: text, processedText: text,
signatures: sigPlaceholders, // Signaturen aus Platzhaltern UND direkt mitgeschickte (manuelle Aufträge).
signatures: { ...(letter.signatures || {}), ...sigPlaceholders },
format: letter.format || "a4", format: letter.format || "a4",
font: letter.font || "tilda", font: letter.font || "tilda",
type: letter.type || "letter", type: letter.type || "letter",
@@ -99,7 +101,7 @@ async function generateBatch(req, res, next) {
for (const letter of processedLetters) { for (const letter of processedLetters) {
const raw = letter.processedText; const raw = letter.processedText;
// Splitten an \t UND [[signaturN]] (mit capture-Gruppe → Marker bleiben erhalten) // Splitten an \t UND [[signaturN]] (mit capture-Gruppe → Marker bleiben erhalten)
const parts = raw.split(/(\t|\[\[signatur\d+\]\]|[&|])/gi); const parts = raw.split(/(\t|\[\[signatur\d+\]\]|\[\[seitenumbruch\]\]|[&|])/gi);
const segments = [], markers = []; const segments = [], markers = [];
for (let i = 0; i < parts.length; i++) { for (let i = 0; i < parts.length; i++) {
if (i % 2 === 0) segments.push(parts[i]); if (i % 2 === 0) segments.push(parts[i]);
@@ -157,63 +159,62 @@ async function generateBatch(req, res, next) {
for (let i = 0; i < processedLetters.length; i++) { for (let i = 0; i < processedLetters.length; i++) {
const letter = processedLetters[i]; const letter = processedLetters[i];
const scriptalizedText = scriptalizedTexts[i] || letter.processedText; const scriptalizedText = scriptalizedTexts[i] || letter.processedText;
const absoluteIndex = letter.index !== undefined ? letter.index : i;
let svgResult; const pad = String(absoluteIndex).padStart(3, "0");
const recipientName = letter.placeholders?.name || letter.placeholders?.vorname || `Brief ${absoluteIndex + 1}`;
try { try {
if (letter.type === "envelope") { if (letter.type === "envelope") {
svgResult = generateEnvelopeSVG( const svgResult = generateEnvelopeSVG(
scriptalizedText, scriptalizedText, letter.format, letter.envelopeType,
letter.format, { font: letter.font, realisticHandwriting: letter.realisticHandwriting ?? false, fontScale: letter.fontScale }
letter.envelopeType,
{ font: letter.font, realisticHandwriting: letter.realisticHandwriting ?? false }
); );
if (svgResult.overflow) hasOverflow = true;
const filename = `envelope_${pad}.svg`;
await fs.writeFile(path.join(sessionDir, filename), svgResult.svg, "utf8");
files.push({
index: absoluteIndex, filename, url: `/api/preview/${finalSessionId}/${filename}`,
lineCount: svgResult.lineCount, lineLimit: svgResult.lineLimit, overflow: svgResult.overflow,
recipientName: null,
});
} else if (letter.multiPage) {
// Mehrseitiger Brief: Text fließt über N Seiten – kein Überlauf-Fehler.
const { pages } = generateLetterPages(scriptalizedText, letter.format, {
font: letter.font, realisticHandwriting: letter.realisticHandwriting ?? false, fontScale: letter.fontScale,
});
for (let p = 0; p < pages.length; p++) {
const filename = `letter_${pad}_p${p + 1}.svg`;
await fs.writeFile(path.join(sessionDir, filename), pages[p], "utf8");
files.push({
index: absoluteIndex, page: p + 1, pageCount: pages.length, filename,
url: `/api/preview/${finalSessionId}/${filename}`, recipientName,
});
}
} else { } else {
// Briefe: Zeileninfo mit zurückgeben const svgResult = generateLetterSVG(scriptalizedText, letter.format, {
svgResult = generateLetterSVG(scriptalizedText, letter.format, { font: letter.font, realisticHandwriting: letter.realisticHandwriting ?? false,
font: letter.font, signatures: letter.signatures || {}, signatureOffsets: letter.signatureOffsets || {},
realisticHandwriting: letter.realisticHandwriting ?? false, fontScale: letter.fontScale,
signatures: letter.signatures || {}, });
if (svgResult.overflow) {
hasOverflow = true;
console.log(`[Preview] Letter ${i} has overflow: ${svgResult.lineCount}/${svgResult.lineLimit} lines`);
}
const filename = `letter_${pad}.svg`;
await fs.writeFile(path.join(sessionDir, filename), svgResult.svg, "utf8");
files.push({
index: absoluteIndex, filename, url: `/api/preview/${finalSessionId}/${filename}`,
lineCount: svgResult.lineCount, lineLimit: svgResult.lineLimit, overflow: svgResult.overflow,
recipientName,
}); });
} }
} catch (err) { } catch (err) {
console.error( console.error(`[Preview] SVG generation failed for letter ${i}:`, err.message);
`[Preview] SVG generation failed for letter ${i}:`,
err.message
);
return res.status(500).json({ return res.status(500).json({
error: "SVG generation failed", error: "SVG generation failed",
message: `Failed to generate SVG for letter ${i}: ${err.message}`, message: `Failed to generate SVG for letter ${i}: ${err.message}`,
}); });
} }
// Track overflow
if (svgResult.overflow) {
hasOverflow = true;
console.log(`[Preview] Letter ${i} has overflow: ${svgResult.lineCount}/${svgResult.lineLimit} lines`);
}
// Save SVG file - verwende den absoluten Index aus letter
// Unterscheide zwischen Briefen und Umschlägen im Dateinamen
const absoluteIndex = letter.index !== undefined ? letter.index : i;
const prefix = letter.type === 'envelope' ? 'envelope' : 'letter';
const filename = `${prefix}_${String(absoluteIndex).padStart(3, "0")}.svg`;
const filepath = path.join(sessionDir, filename);
await fs.writeFile(filepath, svgResult.svg, "utf8");
// Empfänger-Info für bessere Fehlermeldung
const recipientName = letter.placeholders?.name || letter.placeholders?.vorname || `Brief ${absoluteIndex + 1}`;
files.push({
index: absoluteIndex,
filename,
url: `/api/preview/${finalSessionId}/${filename}`,
lineCount: svgResult.lineCount,
lineLimit: svgResult.lineLimit,
overflow: svgResult.overflow,
recipientName: letter.type !== 'envelope' ? recipientName : null,
});
} }
console.log(`[Preview] Generated ${files.length} SVG files`); console.log(`[Preview] Generated ${files.length} SVG files`);

View File

@@ -144,4 +144,11 @@ router.post('/register', authenticateApiToken, orderController.registerOrder);
*/ */
router.post('/from-directus', authenticateApiToken, directusController.generateFromDirectus); router.post('/from-directus', authenticateApiToken, directusController.generateFromDirectus);
/**
* POST /api/order/pagecount
* Seitenzahl je Dokument (mehrseitig) – ohne Scriptalizer/SVG, nur Umbruch-Zählung.
* Body: { text, format, fontScale, entries: [{ placeholders }] }
*/
router.post('/pagecount', authenticateApiToken, directusController.pageCounts);
module.exports = router; module.exports = router;

View File

@@ -3,13 +3,15 @@ const {
getLayoutForFormat, getLayoutForFormat,
getPageDimensions, getPageDimensions,
getLineLimit, getLineLimit,
escapeXml escapeXml,
mmToPx
} = require('./page-layout'); } = require('./page-layout');
const { const {
layoutTextToPaths, layoutTextToPaths,
wrapTextToLinesByWidth, wrapTextToLinesByWidth,
measureTextWidthPx measureTextWidthPx,
TAB_MARKER
} = require('./svg-font-engine'); } = require('./svg-font-engine');
// Höhe einer Signatur in Seiten-Pixeln (Signatur-Canvas war 600×160; wir reservieren 160px * scale) // Höhe einer Signatur in Seiten-Pixeln (Signatur-Canvas war 600×160; wir reservieren 160px * scale)
@@ -65,11 +67,22 @@ function generateLetterSVG(text, format, options = {}) {
const fontKey = normalizeFontKey(options.font); const fontKey = normalizeFontKey(options.font);
const fontConfig = SVG_FONT_CONFIG[fontKey]; const fontConfig = SVG_FONT_CONFIG[fontKey];
const signatures = options.signatures || {}; const signatures = options.signatures || {};
// Feinjustierung je Signatur: { signatur1: { x: mm, y: mm, scale: Faktor } }.
const signatureOffsets = options.signatureOffsets || {};
// Einseitig: Seitenumbruch-Marker gibt es hier nicht – als Zeilenumbruch behandeln,
// damit er nie wörtlich gedruckt wird (falls „Mehrseitig" nicht aktiv ist).
text = String(text || '').replace(/\[\[seitenumbruch\]\]/gi, '\n');
const { widthPx, heightPx, widthMm, heightMm } = getPageDimensions(format); const { widthPx, heightPx, widthMm, heightMm } = getPageDimensions(format);
const { marginTopPx, marginLeftPx, marginRightPx, lineHeightPx } = getLayoutForFormat(format); const { marginTopPx, marginLeftPx, marginRightPx, lineHeightPx: baseLineHeightPx } = getLayoutForFormat(format);
const maxWidthPx = widthPx - marginLeftPx - (marginRightPx ?? marginLeftPx); const maxWidthPx = widthPx - marginLeftPx - (marginRightPx ?? marginLeftPx);
// Relative Schriftgröße (nur manuelle Aufträge setzen ≠ 1). Schrift UND Zeilenhöhe
// skalieren mit, damit sich Zeilen nicht überlappen. Default 1 = unverändert.
const fontScale = Math.max(0.8, Math.min(1.5, Number(options.fontScale) || 1));
const fontSizePx = FONT_SIZE_PX * fontScale;
const lineHeightPx = baseLineHeightPx * fontScale;
// ── Signatur-Marker aus Text extrahieren ────────────────────────────────── // ── Signatur-Marker aus Text extrahieren ──────────────────────────────────
const sigMarkerRe = /\[\[(signatur\d+)\]\]/gi; const sigMarkerRe = /\[\[(signatur\d+)\]\]/gi;
const hasSigMarkers = sigMarkerRe.test(String(text || '')); const hasSigMarkers = sigMarkerRe.test(String(text || ''));
@@ -80,14 +93,14 @@ function generateLetterSVG(text, format, options = {}) {
text: String(text || ''), text: String(text || ''),
maxWidthPx, maxWidthPx,
fontFileName: fontConfig.file, fontFileName: fontConfig.file,
fontSizePx: FONT_SIZE_PX, fontSizePx,
}); });
const firstBaselineY = marginTopPx + FONT_SIZE_PX; const firstBaselineY = marginTopPx + fontSizePx;
const paths = layoutTextToPaths({ const paths = layoutTextToPaths({
lines, lines,
fontFileName: fontConfig.file, fontFileName: fontConfig.file,
fontSizePx: FONT_SIZE_PX, fontSizePx,
startX: marginLeftPx, startX: marginLeftPx,
startY: firstBaselineY, startY: firstBaselineY,
lineHeightPx, lineHeightPx,
@@ -103,7 +116,8 @@ function generateLetterSVG(text, format, options = {}) {
vector-effect="non-scaling-stroke"/>`) vector-effect="non-scaling-stroke"/>`)
.join('\n '); .join('\n ');
const lineLimit = getLineLimit(format); // Größere Schrift → weniger Zeilen passen aufs Blatt (Limit gegenläufig skalieren).
const lineLimit = Math.max(1, Math.round(getLineLimit(format) / fontScale));
return { return {
svg: `<svg xmlns="http://www.w3.org/2000/svg" svg: `<svg xmlns="http://www.w3.org/2000/svg"
width="${widthMm}mm" height="${heightMm}mm" width="${widthMm}mm" height="${heightMm}mm"
@@ -143,9 +157,9 @@ function generateLetterSVG(text, format, options = {}) {
} }
const allSvgElements = []; const allSvgElements = [];
let currentY = marginTopPx + FONT_SIZE_PX; let currentY = marginTopPx + fontSizePx;
let totalLineCount = 0; let totalLineCount = 0;
const lineLimit = getLineLimit(format); const lineLimit = Math.max(1, Math.round(getLineLimit(format) / fontScale));
let si = 0; let si = 0;
while (si < segments.length) { while (si < segments.length) {
@@ -158,12 +172,12 @@ function generateLetterSVG(text, format, options = {}) {
text: seg.content, text: seg.content,
maxWidthPx, maxWidthPx,
fontFileName: fontConfig.file, fontFileName: fontConfig.file,
fontSizePx: FONT_SIZE_PX, fontSizePx,
}); });
const paths = layoutTextToPaths({ const paths = layoutTextToPaths({
lines, lines,
fontFileName: fontConfig.file, fontFileName: fontConfig.file,
fontSizePx: FONT_SIZE_PX, fontSizePx,
startX: marginLeftPx, startX: marginLeftPx,
startY: currentY, startY: currentY,
lineHeightPx, lineHeightPx,
@@ -190,8 +204,13 @@ function generateLetterSVG(text, format, options = {}) {
sigRow.forEach((sigSeg, slotIdx) => { sigRow.forEach((sigSeg, slotIdx) => {
const svgString = signatures[sigSeg.key] || null; const svgString = signatures[sigSeg.key] || null;
if (svgString) { if (svgString) {
const sigX = marginLeftPx + slotIdx * sigSlotW; // Feinjustierung: Versatz in mm + Größen-Faktor relativ zur Auto-Position.
const sigEl = buildSignatureElement(svgString, sigX, currentY, sigScale); const off = signatureOffsets[sigSeg.key] || {};
const dx = mmToPx(Number(off.x) || 0);
const dy = mmToPx(Number(off.y) || 0);
const sc = Number(off.scale) > 0 ? Number(off.scale) : 1;
const sigX = marginLeftPx + slotIdx * sigSlotW + dx;
const sigEl = buildSignatureElement(svgString, sigX, currentY + dy, sigScale * sc);
if (sigEl) allSvgElements.push(sigEl); if (sigEl) allSvgElements.push(sigEl);
} }
}); });
@@ -225,7 +244,12 @@ function generateEnvelopeSVG(text, format, type, options = {}) {
const fontConfig = SVG_FONT_CONFIG[fontKey]; const fontConfig = SVG_FONT_CONFIG[fontKey];
const { widthPx, heightPx, widthMm, heightMm } = getPageDimensions(format); const { widthPx, heightPx, widthMm, heightMm } = getPageDimensions(format);
const { marginTopPx, marginLeftPx, lineHeightPx } = getLayoutForFormat(format); const { marginTopPx, marginLeftPx, lineHeightPx: baseLineHeightPx } = getLayoutForFormat(format);
// Relative Schriftgröße (getrennt vom Brief einstellbar). Default 1 = unverändert.
const fontScale = Math.max(0.8, Math.min(1.5, Number(options.fontScale) || 1));
const fontSizePx = FONT_SIZE_PX * fontScale;
const lineHeightPx = baseLineHeightPx * fontScale;
let lines; let lines;
let startX; let startX;
@@ -239,12 +263,12 @@ function generateEnvelopeSVG(text, format, type, options = {}) {
text: String(text || ''), text: String(text || ''),
maxWidthPx, maxWidthPx,
fontFileName: fontConfig.file, fontFileName: fontConfig.file,
fontSizePx: FONT_SIZE_PX, fontSizePx,
}); });
// Zentrierung berechnen // Zentrierung berechnen
const totalTextHeight = lines.length * lineHeightPx; const totalTextHeight = lines.length * lineHeightPx;
startY = (heightPx - totalTextHeight) / 2 + FONT_SIZE_PX; startY = (heightPx - totalTextHeight) / 2 + fontSizePx;
// Jede Zeile einzeln zentrieren // Jede Zeile einzeln zentrieren
// startX wird später pro Zeile berechnet // startX wird später pro Zeile berechnet
@@ -258,11 +282,11 @@ function generateEnvelopeSVG(text, format, type, options = {}) {
text: String(text || ''), text: String(text || ''),
maxWidthPx, maxWidthPx,
fontFileName: fontConfig.file, fontFileName: fontConfig.file,
fontSizePx: FONT_SIZE_PX, fontSizePx,
}); });
startX = marginLeftPx; startX = marginLeftPx;
startY = marginTopPx + FONT_SIZE_PX; startY = marginTopPx + fontSizePx;
} }
let paths = []; let paths = [];
@@ -274,14 +298,14 @@ function generateEnvelopeSVG(text, format, type, options = {}) {
const lineWidth = measureTextWidthPx({ const lineWidth = measureTextWidthPx({
text: line, text: line,
fontFileName: fontConfig.file, fontFileName: fontConfig.file,
fontSizePx: FONT_SIZE_PX fontSizePx
}); });
const centeredX = (widthPx - lineWidth) / 2; const centeredX = (widthPx - lineWidth) / 2;
const linePaths = layoutTextToPaths({ const linePaths = layoutTextToPaths({
lines: [line], lines: [line],
fontFileName: fontConfig.file, fontFileName: fontConfig.file,
fontSizePx: FONT_SIZE_PX, fontSizePx,
startX: centeredX, startX: centeredX,
startY: currentY, startY: currentY,
lineHeightPx, lineHeightPx,
@@ -296,7 +320,7 @@ function generateEnvelopeSVG(text, format, type, options = {}) {
paths = layoutTextToPaths({ paths = layoutTextToPaths({
lines, lines,
fontFileName: fontConfig.file, fontFileName: fontConfig.file,
fontSizePx: FONT_SIZE_PX, fontSizePx,
startX, startX,
startY, startY,
lineHeightPx, lineHeightPx,
@@ -328,16 +352,110 @@ function generateEnvelopeSVG(text, format, type, options = {}) {
// Overflow-Erkennung: zu viele Zeilen für die verfügbare Fläche // Overflow-Erkennung: zu viele Zeilen für die verfügbare Fläche
const overflowStartY = (type === 'custom') const overflowStartY = (type === 'custom')
? (heightPx - lines.length * lineHeightPx) / 2 + FONT_SIZE_PX ? (heightPx - lines.length * lineHeightPx) / 2 + fontSizePx
: marginTopPx + FONT_SIZE_PX; : marginTopPx + fontSizePx;
const available = heightPx - overflowStartY - FONT_SIZE_PX * 0.5; const available = heightPx - overflowStartY - fontSizePx * 0.5;
const lineLimit = Math.max(1, Math.floor(available / lineHeightPx) + 1); const lineLimit = Math.max(1, Math.floor(available / lineHeightPx) + 1);
const lineCount = lines.length; const lineCount = lines.length;
return { svg: svg.trim(), overflow: lineCount > lineLimit, lineCount, lineLimit }; return { svg: svg.trim(), overflow: lineCount > lineLimit, lineCount, lineLimit };
} }
/**
* Mehrseitiges Schriftstück: Der Text fließt automatisch über so viele Seiten,
* wie nötig (linesPerPage = Zeilenlimit des Formats). Ein erzwungener Umbruch ist
* über den Marker [[seitenumbruch]] möglich – jeder so getrennte Block beginnt auf
* einer neuen Seite. Gibt die Seiten in natürlicher Reihenfolge (Seite 1..N) zurück.
*
* Bewusst OHNE Signatur-Unterstützung (kommt als eigener Schritt). Tab-/Rechts-
* bündig-Logik und relative Schriftgröße greifen pro Seite wie beim Einzelbrief.
*/
function generateLetterPages(text, format, options = {}) {
const fontKey = normalizeFontKey(options.font);
const fontConfig = SVG_FONT_CONFIG[fontKey];
const { widthPx, heightPx, widthMm, heightMm } = getPageDimensions(format);
const { marginTopPx, marginLeftPx, marginRightPx, lineHeightPx: baseLineHeightPx } = getLayoutForFormat(format);
const maxWidthPx = widthPx - marginLeftPx - (marginRightPx ?? marginLeftPx);
const fontScale = Math.max(0.8, Math.min(1.5, Number(options.fontScale) || 1));
const fontSizePx = FONT_SIZE_PX * fontScale;
const lineHeightPx = baseLineHeightPx * fontScale;
const linesPerPage = Math.max(1, Math.round(getLineLimit(format) / fontScale));
// Erzwungene Seitenumbrüche zuerst; danach jeden Block nach Zeilen auto-fließen.
const bloecke = String(text || '').split(/\[\[seitenumbruch\]\]/gi);
const seitenZeilen = [];
for (const block of bloecke) {
const lines = wrapTextToLinesByWidth({ text: block, maxWidthPx, fontFileName: fontConfig.file, fontSizePx });
for (let i = 0; i < lines.length; i += linesPerPage) {
seitenZeilen.push(lines.slice(i, i + linesPerPage));
}
}
if (seitenZeilen.length === 0) seitenZeilen.push(['']);
// Leere Seiten verwerfen: enthält eine Seite kein sichtbares Zeichen (nur
// Leerzeichen, Tabs, Umbrüche), wird sie weder generiert noch gedruckt.
// Bleibt nichts übrig (komplett leerer Text), eine einzige Seite behalten.
const istLeer = (lines) => lines.join('').split(TAB_MARKER).join('').replace(/\s/g, '') === '';
let seiten = seitenZeilen.filter((lines) => !istLeer(lines));
if (seiten.length === 0) seiten = [['']];
const pages = seiten.map((lines) => {
const paths = layoutTextToPaths({
lines,
fontFileName: fontConfig.file,
fontSizePx,
startX: marginLeftPx,
startY: marginTopPx + fontSizePx,
lineHeightPx,
realisticHandwriting: options.realisticHandwriting ?? false,
maxWidthPx,
});
const pathElements = paths
.map(p => `<path d="${escapeXml(p.d)}"
transform="${p.transform}"
stroke="#000000" stroke-width="0.6" fill="none"
stroke-linecap="round" stroke-linejoin="round"
vector-effect="non-scaling-stroke"/>`)
.join('\n ');
return `<svg xmlns="http://www.w3.org/2000/svg"
width="${widthMm}mm" height="${heightMm}mm"
viewBox="0 0 ${widthPx} ${heightPx}">
<rect x="0" y="0" width="${widthPx}" height="${heightPx}" fill="#FFFFFF"/>
${pathElements}
</svg>`.trim();
});
return { pages, pageCount: pages.length, lineCount: seiten.reduce((a, l) => a + l.length, 0) };
}
/**
* Zählt, wie viele Seiten ein Text ergäbe (gleiche Logik wie generateLetterPages,
* aber ohne SVG/Scriptalizer) – für die Seiten-Übersicht je Schriftstück.
*/
function countLetterPages(text, format, options = {}) {
const fontConfig = SVG_FONT_CONFIG[normalizeFontKey(options.font)];
const { widthPx } = getPageDimensions(format);
const { marginLeftPx, marginRightPx } = getLayoutForFormat(format);
const maxWidthPx = widthPx - marginLeftPx - (marginRightPx ?? marginLeftPx);
const fontScale = Math.max(0.8, Math.min(1.5, Number(options.fontScale) || 1));
const fontSizePx = FONT_SIZE_PX * fontScale;
const linesPerPage = Math.max(1, Math.round(getLineLimit(format) / fontScale));
const seitenZeilen = [];
for (const block of String(text || '').split(/\[\[seitenumbruch\]\]/gi)) {
const lines = wrapTextToLinesByWidth({ text: block, maxWidthPx, fontFileName: fontConfig.file, fontSizePx });
for (let i = 0; i < lines.length; i += linesPerPage) seitenZeilen.push(lines.slice(i, i + linesPerPage));
}
const istLeer = (lines) => lines.join('').split(TAB_MARKER).join('').replace(/\s/g, '') === '';
const seiten = seitenZeilen.filter((lines) => !istLeer(lines));
return Math.max(1, seiten.length);
}
module.exports = { module.exports = {
generateLetterSVG, generateLetterSVG,
generateEnvelopeSVG generateEnvelopeSVG,
generateLetterPages,
countLetterPages
}; };

View File

@@ -44,6 +44,7 @@ async function fetchOrder(orderId) {
'needs_envelope', 'envelope_labeling', 'envelope_text', 'envelope_format', 'needs_envelope', 'envelope_labeling', 'envelope_text', 'envelope_format',
'text_template', 'motif_mode', 'own_cards', 'entries_count', 'preview_session', 'text_template', 'motif_mode', 'own_cards', 'entries_count', 'preview_session',
'source_file', 'product.key', 'product.type', 'product.input_mode', 'format.key', 'source_file', 'product.key', 'product.type', 'product.input_mode', 'format.key',
'font_scale_letter', 'font_scale_envelope', 'signatures_manual', 'multi_page', 'realistic',
].join(','); ].join(',');
const order = await directusFetch(`/items/orders/${encodeURIComponent(orderId)}?fields=${fields}`); const order = await directusFetch(`/items/orders/${encodeURIComponent(orderId)}?fields=${fields}`);

View File

@@ -159,6 +159,31 @@ def parse_nummern(spec):
return treffer or None return treffer or None
def seiten_reihenfolge(files):
"""Seiten je Brief ABSTEIGEND (…p3, p2, p1), Briefe aufsteigend.
Der Plotter stapelt face-up: zuletzt gedruckt liegt oben. Damit am Ende
Seite 1 obenauf liegt, muss je Brief die letzte Seite zuerst gedruckt werden.
Ergebnis: 1.3, 1.2, 1.1, 2.3, 2.2, 2.1, … Einseitige Briefe (ohne _pN) und
andere Typen (Kuvert/Signatur) bleiben unverändert.
"""
def key(f):
name = str(f.get("name", "")).lower()
brief, seite = 0, 1
if name.startswith("letter_"):
rest = name[7:]
if rest.endswith(".svg"):
rest = rest[:-4]
if "_p" in rest:
a, _, b = rest.partition("_p")
brief = int(a) if a.isdigit() else 0
seite = int(b) if b.isdigit() else 1
elif rest.isdigit():
brief = int(rest)
return (brief, -seite)
return sorted(files, key=key)
def main(): def main():
cfg = lade_config() cfg = lade_config()
dx = Directus(cfg["directus_url"], cfg["directus_token"]) dx = Directus(cfg["directus_url"], cfg["directus_token"])
@@ -326,6 +351,10 @@ def _sende(dx, plotter, job, KIND):
if not passende: if not passende:
raise RuntimeError(f"Keine Dateien vom Typ '{gewuenscht}' für {order_nr} gefunden.") raise RuntimeError(f"Keine Dateien vom Typ '{gewuenscht}' für {order_nr} gefunden.")
# Mehrseitige Briefe: Seiten je Brief absteigend an den Plotter (Stapel-
# Reihenfolge, damit Seite 1 am Ende oben liegt). Einseitige unverändert.
passende = seiten_reihenfolge(passende)
dateien = [] dateien = []
for f in passende: for f in passende:
inhalt = dx.download(f"/skrift-orders/files/{order_nr}/download", {"rel": f["rel"]}) inhalt = dx.download(f"/skrift-orders/files/{order_nr}/download", {"rel": f["rel"]})

View File

@@ -123,6 +123,17 @@ function Dialog({ title, onClose, children }: { title: string; onClose: () => vo
); );
} }
/** Konfigurator samt lokalem Cache zurücksetzen (Login bleibt erhalten). */
function konfiguratorZuruecksetzen() {
if (!window.confirm('Konfigurator zurücksetzen? Alle Eingaben und der lokale Zwischenspeicher werden gelöscht (die Anmeldung bleibt bestehen).')) return;
try {
Object.keys(localStorage)
.filter((k) => k.startsWith('skrift.') && k !== 'skrift.session')
.forEach((k) => localStorage.removeItem(k));
} catch { /* localStorage nicht verfügbar – dann reicht der Reload */ }
window.location.reload();
}
function Hilfe({ onClose }: { onClose: () => void }) { function Hilfe({ onClose }: { onClose: () => void }) {
return ( return (
<Dialog title="Hilfe & Kontakt" onClose={onClose}> <Dialog title="Hilfe & Kontakt" onClose={onClose}>
@@ -138,6 +149,14 @@ function Hilfe({ onClose }: { onClose: () => void }) {
</a> </a>
</div> </div>
{/* Rettungsanker bei hängengebliebenem Zustand (z. B. falscher Zeilen-Hinweis). */}
<div className="sk-help-reset">
<p className="sk-note">Zeigt der Konfigurator unerwartetes Verhalten (z. B. einen falschen Zeilen-Hinweis)? Setzen Sie ihn hier zurück:</p>
<button type="button" className="sk-btn sk-btn--ghost" onClick={konfiguratorZuruecksetzen}>
Konfigurator zurücksetzen
</button>
</div>
<div className="sk-legal-links"> <div className="sk-legal-links">
<a href="https://skrift.de/agb" target="_blank" rel="noreferrer">AGB</a> <a href="https://skrift.de/agb" target="_blank" rel="noreferrer">AGB</a>
<a href="https://skrift.de/datenschutz" target="_blank" rel="noreferrer">Datenschutz</a> <a href="https://skrift.de/datenschutz" target="_blank" rel="noreferrer">Datenschutz</a>
@@ -162,7 +181,7 @@ export function Muster({ onClose = () => {}, variant = 'dialog' }: { onClose?: (
const [produkte, setProdukte] = useState<Product[]>([]); const [produkte, setProdukte] = useState<Product[]>([]);
const [form, setForm] = useState({ const [form, setForm] = useState({
product: '', name: '', email: '', phone: '', product: '', name: '', email: '', phone: '',
street: '', zip: '', city: '', country: 'Deutschland', street: '', zip: '', city: '', country: 'Deutschland', message: '',
}); });
const [datenschutz, setDatenschutz] = useState(false); const [datenschutz, setDatenschutz] = useState(false);
const [status, setStatus] = useState<'formular' | 'sendet' | 'fertig'>('formular'); const [status, setStatus] = useState<'formular' | 'sendet' | 'fertig'>('formular');
@@ -184,7 +203,7 @@ export function Muster({ onClose = () => {}, variant = 'dialog' }: { onClose?: (
} }
}, []); }, []);
const set = (k: keyof typeof form) => (e: React.ChangeEvent<HTMLInputElement | HTMLSelectElement>) => { const set = (k: keyof typeof form) => (e: React.ChangeEvent<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>) => {
const roh = e.target.value; const roh = e.target.value;
setForm({ ...form, [k]: k === 'phone' ? roh.replace(/[^0-9+ ]/g, '') : k === 'zip' ? roh.replace(/[^0-9]/g, '') : roh }); setForm({ ...form, [k]: k === 'phone' ? roh.replace(/[^0-9+ ]/g, '') : k === 'zip' ? roh.replace(/[^0-9]/g, '') : roh });
}; };
@@ -204,6 +223,7 @@ export function Muster({ onClose = () => {}, variant = 'dialog' }: { onClose?: (
zip: form.zip.trim(), zip: form.zip.trim(),
city: form.city.trim(), city: form.city.trim(),
country: form.country, country: form.country,
message: form.message.trim() || undefined,
}); });
setStatus('fertig'); setStatus('fertig');
} catch (err) { } catch (err) {
@@ -267,6 +287,14 @@ export function Muster({ onClose = () => {}, variant = 'dialog' }: { onClose?: (
{LAENDER.map((l) => <option key={l} value={l}>{l}</option>)} {LAENDER.map((l) => <option key={l} value={l}>{l}</option>)}
</select> </select>
</div> </div>
<div className="sk-field">
<label className="sk-label" htmlFor="m-message">
Nachricht <span className="sk-note" style={{ fontWeight: 400 }}>(optional)</span>
</label>
<textarea id="m-message" className="sk-input" rows={3} maxLength={1000}
placeholder="Wünsche oder Fragen zum Muster?"
value={form.message} onChange={set('message')} />
</div>
<label className="sk-check" style={{ marginBottom: 'var(--sk-space-4)' }}> <label className="sk-check" style={{ marginBottom: 'var(--sk-space-4)' }}>
<input type="checkbox" checked={datenschutz} onChange={(e) => setDatenschutz(e.target.checked)} /> <input type="checkbox" checked={datenschutz} onChange={(e) => setDatenschutz(e.target.checked)} />

View File

@@ -69,6 +69,48 @@ export default function PreviewPanel({
} }
function openZoom(svg: string) { setZoomBox(messeBox()); setZoomSvg(svg); } function openZoom(svg: string) { setZoomBox(messeBox()); setZoomSvg(svg); }
/** Seitenverhältnis (Breite/Höhe) aus der viewBox – sperrt die Lightbox-Abmessungen. */
function seitenverhaeltnis(svg: string): string {
const m = svg.match(/viewBox="0 0 ([\d.]+) ([\d.]+)"/);
return m ? `${m[1]} / ${m[2]}` : '210 / 297';
}
/** Musterbild der großen Vorschau als PNG herunterladen (SVG → Canvas). */
function bildSpeichern() {
if (!zoomSvg) return;
const m = zoomSvg.match(/viewBox="0 0 ([\d.]+) ([\d.]+)"/);
const w = Math.round(m ? Number(m[1]) : 794);
const h = Math.round(m ? Number(m[2]) : 1123);
const scale = 2; // für ein scharfes Musterbild
const url = URL.createObjectURL(new Blob([zoomSvg], { type: 'image/svg+xml;charset=utf-8' }));
const img = new Image();
img.onload = () => {
const canvas = document.createElement('canvas');
canvas.width = w * scale;
canvas.height = h * scale;
const ctx = canvas.getContext('2d');
if (ctx) {
ctx.fillStyle = '#ffffff';
ctx.fillRect(0, 0, canvas.width, canvas.height);
ctx.drawImage(img, 0, 0, canvas.width, canvas.height);
canvas.toBlob((png) => {
if (png) {
const a = document.createElement('a');
a.href = URL.createObjectURL(png);
a.download = 'skrift-musterbild.png';
a.click();
URL.revokeObjectURL(a.href);
}
URL.revokeObjectURL(url);
}, 'image/png');
} else {
URL.revokeObjectURL(url);
}
};
img.onerror = () => URL.revokeObjectURL(url);
img.src = url;
}
// Nach einer neuen Generierung wieder vorn beginnen. // Nach einer neuen Generierung wieder vorn beginnen.
useEffect(() => { setIndex(0); }, [docs]); useEffect(() => { setIndex(0); }, [docs]);
@@ -152,11 +194,17 @@ export default function PreviewPanel({
{zoomSvg && ( {zoomSvg && (
<div className="sk-lightbox" style={zoomBox} onClick={() => setZoomSvg(null)} role="dialog" aria-modal="true" <div className="sk-lightbox" style={zoomBox} onClick={() => setZoomSvg(null)} role="dialog" aria-modal="true"
aria-label="Vergrößerte Vorschau"> aria-label="Vergrößerte Vorschau">
<div className="sk-lightbox-sheet" onClick={(e) => e.stopPropagation()} <div className="sk-lightbox-sheet" style={{ aspectRatio: seitenverhaeltnis(zoomSvg) }}
onClick={(e) => e.stopPropagation()}
dangerouslySetInnerHTML={{ __html: zoomSvg }} /> dangerouslySetInnerHTML={{ __html: zoomSvg }} />
<button className="sk-lightbox-close" onClick={() => setZoomSvg(null)} aria-label="Schließen"> <div className="sk-lightbox-actions">
Schließen <button className="sk-lightbox-close" onClick={(e) => { e.stopPropagation(); bildSpeichern(); }}>
</button> Bild speichern
</button>
<button className="sk-lightbox-close" onClick={() => setZoomSvg(null)} aria-label="Schließen">
Schließen
</button>
</div>
</div> </div>
)} )}
</aside> </aside>

View File

@@ -521,6 +521,7 @@ export type SampleRequest = {
zip: string; zip: string;
city: string; city: string;
country: string; country: string;
message?: string;
}; };
export async function sendSampleRequest(input: SampleRequest) { export async function sendSampleRequest(input: SampleRequest) {

View File

@@ -1684,6 +1684,12 @@ export default function Configurator({ vorwahlProdukt }: { vorwahlProdukt?: stri
const en = ta.selectionEnd ?? s; const en = ta.selectionEnd ?? s;
setDocText(aktDocText.slice(0, s) + '\t' + aktDocText.slice(en)); setDocText(aktDocText.slice(0, s) + '\t' + aktDocText.slice(en));
requestAnimationFrame(() => { ta.selectionStart = ta.selectionEnd = s + 1; }); requestAnimationFrame(() => { ta.selectionStart = ta.selectionEnd = s + 1; });
}}
onBlur={() => {
// Leerzeilen am Ende automatisch entfernen (zählen sonst als
// Zeilen mit und können das Zeilenlimit fälschlich sprengen).
const beschnitten = aktDocText.replace(/(?:\r?\n[ \t]*)+$/, '');
if (beschnitten !== aktDocText) setDocText(beschnitten);
}} /> }} />
<p className={textZuLang ? 'sk-error' : 'sk-note'} style={{ marginTop: 'var(--sk-space-2)' }}> <p className={textZuLang ? 'sk-error' : 'sk-note'} style={{ marginTop: 'var(--sk-space-2)' }}>
{aktDocText.length}/{maxText} Zeichen {aktDocText.length}/{maxText} Zeichen

View File

@@ -366,7 +366,9 @@ button { font-family: inherit; }
.sk-pricebar { .sk-pricebar {
position: sticky; position: sticky;
top: 0; top: 0;
z-index: 10; /* Muss ÜBER der (ebenfalls sticky) Vorschau liegen, sonst schiebt sich die
Vorschau beim Scrollen über die Preiszeile (Kopfzeile). */
z-index: 30;
background: var(--sk-white); background: var(--sk-white);
border-bottom: 1px solid var(--sk-border); border-bottom: 1px solid var(--sk-border);
padding: var(--sk-space-3) var(--sk-space-6); padding: var(--sk-space-3) var(--sk-space-6);
@@ -416,13 +418,14 @@ button { font-family: inherit; }
.sk-preview { .sk-preview {
position: sticky; position: sticky;
top: calc(var(--sk-space-6) + 40px); /* Unterhalb der sticky Preisleiste parken, damit beide sich nicht überlagern. */
top: 84px;
border: 1px solid var(--sk-border); border: 1px solid var(--sk-border);
border-radius: var(--sk-radius-lg); border-radius: var(--sk-radius-lg);
padding: var(--sk-space-4); padding: var(--sk-space-4);
background: var(--sk-white); background: var(--sk-white);
/* Über den (sticky) Tabellenzellen, damit die Platzhalter-Tabelle nicht in /* Über den (sticky) Tabellenzellen, damit die Platzhalter-Tabelle nicht in
die Vorschau-Spalte hineinmalt. */ die Vorschau-Spalte hineinmalt – aber UNTER der Preisleiste (z-index 30). */
z-index: 20; z-index: 20;
} }
.sk-preview-head { .sk-preview-head {
@@ -691,22 +694,25 @@ button { font-family: inherit; }
background: var(--sk-white); background: var(--sk-white);
border-radius: var(--sk-radius); border-radius: var(--sk-radius);
padding: var(--sk-space-4); padding: var(--sk-space-4);
/* Auf den Inhalt schrumpfen, damit die Seite als klar abgesetztes Blatt box-sizing: border-box;
schwebt und nicht über die halbe Fläche „ausläuft". */ /* Das Seitenverhältnis wird inline aus der viewBox gesetzt (aspectRatio).
Zusammen mit beiden Grenzen skaliert das Blatt IMMER proportional in die
jeweils kleinere Grenze – nie verzerrt, egal welche Fenstergröße. */
max-width: min(92vw, 720px); max-width: min(92vw, 720px);
max-height: 80vh;
width: auto;
height: auto;
overflow: hidden; overflow: hidden;
box-shadow: 0 24px 64px rgba(0, 0, 0, 0.45); box-shadow: 0 24px 64px rgba(0, 0, 0, 0.45);
} }
/* Über die Höhe begrenzen: Das SVG trägt sein A4-Seitenverhältnis (mm) selbst,
daher skaliert es proportional und die ganze Seite bleibt sichtbar – kein
Überlaufen mehr wie bei width:100%. */
.sk-lightbox-sheet svg { .sk-lightbox-sheet svg {
display: block; display: block;
width: auto; width: 100%;
height: auto; height: 100%;
max-width: 100%; object-fit: contain;
max-height: 78vh;
} }
/* Aktionszeile (Bild speichern / Schließen) unter dem Blatt. */
.sk-lightbox-actions { display: flex; gap: var(--sk-space-3); }
.sk-lightbox-close { .sk-lightbox-close {
font: inherit; font: inherit;
font-size: var(--sk-size-sm); font-size: var(--sk-size-sm);
@@ -1085,6 +1091,18 @@ textarea.sk-input { resize: vertical; }
font-size: 13px; font-size: 13px;
} }
/* Reset-Hinweis + Button: eigener, abgesetzter Block mit Luft (sonst gequetscht). */
.sk-help-reset {
display: flex;
flex-direction: column;
align-items: flex-start;
gap: var(--sk-space-3);
margin-top: var(--sk-space-5);
padding-top: var(--sk-space-4);
border-top: 1px solid var(--sk-border);
}
.sk-help-reset .sk-note { margin: 0; }
/* Kontakt-Produkt: sieht aus wie eine Option, führt aber zum Angebot. */ /* Kontakt-Produkt: sieht aus wie eine Option, führt aber zum Angebot. */
.sk-option--contact { cursor: pointer; } .sk-option--contact { cursor: pointer; }
.sk-option--contact .sk-option-price-unit { color: var(--sk-accent); font-weight: 600; } .sk-option--contact .sk-option-price-unit { color: var(--sk-accent); font-weight: 600; }

View File

@@ -1 +1 @@
{"root":["./src/app.tsx","./src/main.tsx","./src/vite-env.d.ts","./src/components/appshell.tsx","./src/components/icons.tsx","./src/components/offerform.tsx","./src/components/previewpanel.tsx","./src/lib/api.ts","./src/lib/dialogs.tsx","./src/lib/excel.ts","./src/lib/paypal.ts","./src/lib/status.ts","./src/lib/wizard.tsx","./src/routes/auftraege.tsx","./src/routes/configurator.tsx","./src/routes/login.tsx","./src/routes/stammdaten.tsx"],"version":"5.9.3"} {"root":["./src/app.tsx","./src/main.tsx","./src/vite-env.d.ts","./src/components/appshell.tsx","./src/components/icons.tsx","./src/components/offerform.tsx","./src/components/previewpanel.tsx","./src/lib/api.ts","./src/lib/dialogs.tsx","./src/lib/excel.ts","./src/lib/paypal.ts","./src/lib/status.ts","./src/lib/wizard.tsx","./src/routes/auftraege.tsx","./src/routes/configurator.tsx","./src/routes/login.tsx","./src/routes/muster.tsx","./src/routes/stammdaten.tsx"],"version":"5.9.3"}