Initial commit

Docker Backend/src/api/controllers/order-controller.js

@@ -0,0 +1,414 @@
+const fs = require('fs').promises;
+const fsSync = require('fs');
+const path = require('path');
+const config = require('../../config');
+const { scriptalizeBatch } = require('../../services/scriptalizer-service');
+const { generateLetterSVG, generateEnvelopeSVG } = require('../../lib/svg-generator');
+const { replacePlaceholders, generateAllCSVs } = require('../../services/placeholder-service');
+
+/**
+ * POST /api/order/finalize
+ * Finalize order by copying cached previews to output directory
+ */
+async function finalizeOrder(req, res, next) {
+  try {
+    const { sessionId, orderNumber } = req.body;
+
+    // Validation
+    if (!sessionId || !orderNumber) {
+      return res.status(400).json({
+        error: 'Invalid request',
+        message: 'sessionId and orderNumber are required'
+      });
+    }
+
+    console.log(`[Order] Finalizing order: ${orderNumber} from session: ${sessionId}`);
+    if (envelopes && envelopes.length > 0) {
+      console.log(`[Order] Envelope data provided: ${envelopes.length} envelopes`);
+    }
+
+    // Check if session cache exists
+    const sessionDir = path.join(config.paths.previews, sessionId);
+
+    try {
+      await fs.access(sessionDir);
+    } catch {
+      return res.status(404).json({
+        error: 'Session not found',
+        message: `Preview cache not found for session: ${sessionId}. Please generate previews first.`
+      });
+    }
+
+    // Check cache expiration
+    const metadataPath = path.join(sessionDir, '.metadata.json');
+    try {
+      const metadataContent = await fs.readFile(metadataPath, 'utf8');
+      const metadata = JSON.parse(metadataContent);
+
+      const expiresAt = new Date(metadata.expiresAt);
+      if (new Date() > expiresAt) {
+        return res.status(410).json({
+          error: 'Cache expired',
+          message: 'Preview cache has expired. Please regenerate previews.',
+          expiredAt: metadata.expiresAt
+        });
+      }
+    } catch (err) {
+      console.warn(`[Order] Metadata not found for session: ${sessionId}`);
+    }
+
+    // Create output directory and subdirectories
+    const outputDir = path.join(config.paths.output, orderNumber);
+    const envelopesDir = path.join(outputDir, 'umschlaege');
+    await fs.mkdir(outputDir, { recursive: true });
+    await fs.mkdir(envelopesDir, { recursive: true });
+
+    // Copy files from cache to output, separating letters and envelopes
+    const files = await fs.readdir(sessionDir);
+    const copiedLetters = [];
+    const copiedEnvelopes = [];
+    const copiedOther = [];
+
+    for (const file of files) {
+      // Skip metadata file
+      if (file === '.metadata.json') {
+        continue;
+      }
+
+      const sourcePath = path.join(sessionDir, file);
+
+      // Determine destination based on file type
+      if (file.startsWith('envelope_')) {
+        // Umschläge in Unterordner 'umschlaege'
+        const destPath = path.join(envelopesDir, file);
+        await fs.copyFile(sourcePath, destPath);
+        copiedEnvelopes.push(file);
+      } else if (file.startsWith('letter_')) {
+        // Briefe im Hauptordner
+        const destPath = path.join(outputDir, file);
+        await fs.copyFile(sourcePath, destPath);
+        copiedLetters.push(file);
+      } else {
+        // Andere Dateien (CSV, etc.) im Hauptordner
+        const destPath = path.join(outputDir, file);
+        await fs.copyFile(sourcePath, destPath);
+        copiedOther.push(file);
+      }
+    }
+
+    // Create order metadata
+    const orderMetadata = {
+      orderNumber,
+      sessionId,
+      finalizedAt: new Date().toISOString(),
+      letterCount: copiedLetters.length,
+      envelopeCount: copiedEnvelopes.length,
+      letters: copiedLetters,
+      envelopes: copiedEnvelopes,
+      other: copiedOther
+    };
+
+    const orderMetadataPath = path.join(outputDir, 'order-metadata.json');
+    await fs.writeFile(orderMetadataPath, JSON.stringify(orderMetadata, null, 2), 'utf8');
+
+    const totalFiles = copiedLetters.length + copiedEnvelopes.length + copiedOther.length;
+    console.log(`[Order] Finalized order ${orderNumber}: ${copiedLetters.length} letters, ${copiedEnvelopes.length} envelopes, ${copiedOther.length} other files`);
+
+    // Response
+    res.status(200).json({
+      orderNumber,
+      outputPath: outputDir,
+      letters: copiedLetters,
+      envelopes: copiedEnvelopes,
+      other: copiedOther,
+      totalFiles,
+      envelopesGenerated: 0,
+      timestamp: orderMetadata.finalizedAt
+    });
+
+  } catch (err) {
+    console.error('[Order] Error finalizing order:', err);
+    next(err);
+  }
+}
+
+/**
+ * POST /api/order/generate
+ * Generate order from scratch without using cache
+ */
+async function generateOrder(req, res, next) {
+  try {
+    const { orderNumber, letters } = req.body;
+
+    // Validation
+    if (!orderNumber) {
+      return res.status(400).json({
+        error: 'Invalid request',
+        message: 'orderNumber is required'
+      });
+    }
+
+    if (!letters || !Array.isArray(letters) || letters.length === 0) {
+      return res.status(400).json({
+        error: 'Invalid request',
+        message: 'Letters array is required and must not be empty'
+      });
+    }
+
+    console.log(`[Order] Generating order: ${orderNumber}`);
+    console.log(`[Order] Total documents: ${letters.length}`);
+
+    // Debug: Zeige welche Dokument-Typen ankommen
+    const letterCount = letters.filter(l => l.type !== 'envelope').length;
+    const envelopeCount = letters.filter(l => l.type === 'envelope').length;
+    console.log(`[Order] Letters: ${letterCount}, Envelopes: ${envelopeCount}`);
+    console.log(`[Order] Document types:`, letters.map(l => ({ index: l.index, type: l.type, envelopeType: l.envelopeType })));
+
+    // Create output directory and subdirectories
+    const outputDir = path.join(config.paths.output, orderNumber);
+    const envelopesDir = path.join(outputDir, 'umschlaege');
+    await fs.mkdir(outputDir, { recursive: true });
+    await fs.mkdir(envelopesDir, { recursive: true });
+
+    // Step 1: Prepare texts and replace placeholders
+    const processedLetters = letters.map((letter, loopIndex) => {
+      let text = letter.text || '';
+
+      // Replace placeholders if present
+      if (letter.placeholders && typeof letter.placeholders === 'object') {
+        text = replacePlaceholders(text, letter.placeholders);
+      }
+
+      return {
+        ...letter,
+        // Behalte den ursprünglichen Index vom Frontend, oder verwende loopIndex als Fallback
+        index: letter.index !== undefined ? letter.index : loopIndex,
+        loopIndex, // Für scriptalizedMap Zuordnung
+        processedText: text,
+        format: letter.format || 'a4',
+        font: letter.font || 'tilda',
+        type: letter.type || 'letter',
+        envelopeType: letter.envelopeType || 'recipient'
+      };
+    });
+
+    // Step 2: Group letters by font for batch scriptalization
+    const lettersByFont = {};
+
+    processedLetters.forEach(letter => {
+      const font = letter.font;
+      if (!lettersByFont[font]) {
+        lettersByFont[font] = [];
+      }
+      lettersByFont[font].push(letter);
+    });
+
+    // Step 3: Scriptalize texts by font
+    const scriptalizedMap = new Map();
+
+    for (const [font, fontLetters] of Object.entries(lettersByFont)) {
+      console.log(`[Order] Scriptalizing ${fontLetters.length} texts with font: ${font}`);
+
+      const textsToScriptalize = fontLetters.map(l => l.processedText);
+
+      try {
+        const scriptalizedTexts = await scriptalizeBatch(textsToScriptalize, font, config.scriptalizer.errFrequency);
+
+        fontLetters.forEach((letter, i) => {
+          // Verwende loopIndex für die Map-Zuordnung, da das der Index im processedLetters Array ist
+          scriptalizedMap.set(letter.loopIndex, scriptalizedTexts[i] || letter.processedText);
+        });
+      } catch (err) {
+        console.error(`[Order] Scriptalization failed for font ${font}:`, err.message);
+        return res.status(500).json({
+          error: 'Scriptalization failed',
+          message: `Failed to scriptalize texts with font ${font}: ${err.message}`
+        });
+      }
+    }
+
+    // Step 4: Generate SVG files - separate letters and envelopes
+    const generatedLetters = [];
+    const generatedEnvelopes = [];
+
+    for (let i = 0; i < processedLetters.length; i++) {
+      const letter = processedLetters[i];
+      // Verwende loopIndex für scriptalizedMap Zuordnung
+      const scriptalizedText = scriptalizedMap.get(letter.loopIndex) || letter.processedText;
+
+      let svgContent;
+
+      try {
+        if (letter.type === 'envelope') {
+          svgContent = generateEnvelopeSVG(
+            scriptalizedText,
+            letter.format,
+            letter.envelopeType,
+            { font: letter.font }
+          );
+        } else {
+          svgContent = generateLetterSVG(
+            scriptalizedText,
+            letter.format,
+            { font: letter.font }
+          );
+        }
+      } catch (err) {
+        console.error(`[Order] SVG generation failed for letter ${i}:`, err.message);
+        return res.status(500).json({
+          error: 'SVG generation failed',
+          message: `Failed to generate SVG for letter ${i}: ${err.message}`
+        });
+      }
+
+      // Save SVG file - unterscheide zwischen Briefen und Umschlägen
+      const absoluteIndex = letter.index !== undefined ? letter.index : i;
+
+      if (letter.type === 'envelope') {
+        const filename = `envelope_${String(absoluteIndex).padStart(3, '0')}.svg`;
+        const filepath = path.join(envelopesDir, filename);
+        await fs.writeFile(filepath, svgContent, 'utf8');
+        generatedEnvelopes.push(filename);
+      } else {
+        const filename = `letter_${String(absoluteIndex).padStart(3, '0')}.svg`;
+        const filepath = path.join(outputDir, filename);
+        await fs.writeFile(filepath, svgContent, 'utf8');
+        generatedLetters.push(filename);
+      }
+    }
+
+    console.log(`[Order] Generated ${generatedLetters.length} letters, ${generatedEnvelopes.length} envelopes`);
+
+    // Step 5: Generate all CSV files if placeholders are present
+    const hasPlaceholders = processedLetters.some(l => l.placeholders && Object.keys(l.placeholders).length > 0);
+    const csvFiles = [];
+
+    if (hasPlaceholders) {
+      try {
+        const csvs = generateAllCSVs(processedLetters);
+
+        // Brief-Platzhalter CSV
+        if (csvs.placeholders) {
+          const filename = 'brief_platzhalter.csv';
+          await fs.writeFile(path.join(outputDir, filename), csvs.placeholders, 'utf8');
+          csvFiles.push(filename);
+          console.log(`[Order] Generated brief_platzhalter.csv`);
+        }
+
+        // Empfänger CSV (für recipientData-Modus)
+        if (csvs.recipients) {
+          const filename = 'empfaenger.csv';
+          await fs.writeFile(path.join(outputDir, filename), csvs.recipients, 'utf8');
+          csvFiles.push(filename);
+          console.log(`[Order] Generated empfaenger.csv`);
+        }
+
+        // Umschlag-Platzhalter CSV (für customText-Modus)
+        if (csvs.envelopePlaceholders) {
+          const filename = 'umschlag_platzhalter.csv';
+          await fs.writeFile(path.join(outputDir, filename), csvs.envelopePlaceholders, 'utf8');
+          csvFiles.push(filename);
+          console.log(`[Order] Generated umschlag_platzhalter.csv`);
+        }
+      } catch (err) {
+        console.error('[Order] CSV generation failed:', err.message);
+        // Don't fail the request, CSV is optional
+      }
+    }
+
+    // Step 6: Create order metadata
+    const orderMetadata = {
+      orderNumber,
+      generatedAt: new Date().toISOString(),
+      letterCount: generatedLetters.length,
+      envelopeCount: generatedEnvelopes.length,
+      letters: generatedLetters,
+      envelopes: generatedEnvelopes,
+      fonts: Object.keys(lettersByFont),
+      hasPlaceholders,
+      csvFiles
+    };
+
+    const orderMetadataPath = path.join(outputDir, 'order-metadata.json');
+    await fs.writeFile(orderMetadataPath, JSON.stringify(orderMetadata, null, 2), 'utf8');
+
+    console.log(`[Order] Order ${orderNumber} generated successfully`);
+
+    // Response
+    res.status(200).json({
+      orderNumber,
+      outputPath: outputDir,
+      letters: generatedLetters,
+      envelopes: generatedEnvelopes,
+      csvFiles,
+      totalFiles: generatedLetters.length + generatedEnvelopes.length + csvFiles.length,
+      timestamp: orderMetadata.generatedAt
+    });
+
+  } catch (err) {
+    console.error('[Order] Error generating order:', err);
+    next(err);
+  }
+}
+
+/**
+ * POST /api/order/motif
+ * Upload a motif image for an order
+ */
+async function uploadMotif(req, res, next) {
+  try {
+    const { orderNumber } = req.body;
+
+    // Validation
+    if (!orderNumber) {
+      return res.status(400).json({
+        error: 'Invalid request',
+        message: 'orderNumber is required'
+      });
+    }
+
+    if (!req.file) {
+      return res.status(400).json({
+        error: 'Invalid request',
+        message: 'No file uploaded'
+      });
+    }
+
+    console.log(`[Order] Uploading motif for order: ${orderNumber}`);
+    console.log(`[Order] File: ${req.file.originalname}, Size: ${req.file.size} bytes, Type: ${req.file.mimetype}`);
+
+    // Create output directory if it doesn't exist
+    const outputDir = path.join(config.paths.output, orderNumber);
+    await fs.mkdir(outputDir, { recursive: true });
+
+    // Determine file extension
+    const originalExt = path.extname(req.file.originalname).toLowerCase() || '.png';
+    const filename = `motif${originalExt}`;
+    const filepath = path.join(outputDir, filename);
+
+    // Write file to disk
+    await fs.writeFile(filepath, req.file.buffer);
+
+    console.log(`[Order] Motif saved to: ${filepath}`);
+
+    // Response
+    res.status(200).json({
+      success: true,
+      orderNumber,
+      filename,
+      path: filepath,
+      size: req.file.size,
+      mimetype: req.file.mimetype
+    });
+
+  } catch (err) {
+    console.error('[Order] Error uploading motif:', err);
+    next(err);
+  }
+}
+
+module.exports = {
+  finalizeOrder,
+  generateOrder,
+  uploadMotif
+};

Docker Backend/src/api/controllers/paypal-controller.js

@@ -0,0 +1,200 @@
+const {
+  Client,
+  Environment,
+  LogLevel,
+  OrdersController
+} = require('@paypal/paypal-server-sdk');
+const config = require('../../config');
+
+// PayPal Client initialisieren
+let client = null;
+let ordersController = null;
+
+function initializePayPalClient() {
+  if (client) return;
+
+  const { clientId, clientSecret, environment } = config.paypal;
+
+  if (!clientId || !clientSecret) {
+    console.warn('[PayPal] Client ID oder Secret nicht konfiguriert');
+    return;
+  }
+
+  client = new Client({
+    clientCredentialsAuthCredentials: {
+      oAuthClientId: clientId,
+      oAuthClientSecret: clientSecret,
+    },
+    timeout: 0,
+    environment: environment === 'live' ? Environment.Production : Environment.Sandbox,
+    logging: {
+      logLevel: LogLevel.Info,
+      logRequest: { logBody: true },
+      logResponse: { logHeaders: true },
+    },
+  });
+
+  ordersController = new OrdersController(client);
+  console.log(`[PayPal] Client initialisiert (${environment})`);
+}
+
+// Initialisierung beim Laden des Moduls
+initializePayPalClient();
+
+/**
+ * Erstellt eine PayPal-Bestellung
+ * POST /api/paypal/orders
+ */
+async function createOrder(req, res) {
+  try {
+    if (!ordersController) {
+      return res.status(503).json({
+        error: 'PayPal nicht konfiguriert',
+        message: 'PayPal Client ID und Secret müssen in den Umgebungsvariablen gesetzt sein'
+      });
+    }
+
+    const { amount, currency = 'EUR', orderData } = req.body;
+
+    if (!amount || amount <= 0) {
+      return res.status(400).json({
+        error: 'Ungültiger Betrag',
+        message: 'Der Bestellbetrag muss größer als 0 sein'
+      });
+    }
+
+    // Betrag auf 2 Dezimalstellen formatieren
+    const formattedAmount = parseFloat(amount).toFixed(2);
+
+    // Produktbeschreibung erstellen
+    const productName = orderData?.product?.label || 'Skrift Handschriftservice';
+    const quantity = orderData?.quantity || 1;
+
+    const collect = {
+      body: {
+        intent: 'CAPTURE',
+        purchaseUnits: [
+          {
+            amount: {
+              currencyCode: currency,
+              value: formattedAmount,
+              breakdown: {
+                itemTotal: {
+                  currencyCode: currency,
+                  value: formattedAmount,
+                },
+              },
+            },
+            items: [
+              {
+                name: productName,
+                unitAmount: {
+                  currencyCode: currency,
+                  value: formattedAmount,
+                },
+                quantity: '1',
+                description: `${quantity}x ${productName}`,
+                sku: orderData?.product?.key || 'skrift-order',
+              },
+            ],
+          },
+        ],
+        paymentSource: {
+          paypal: {
+            experienceContext: {
+              userAction: 'PAY_NOW',
+              brandName: 'Skrift',
+              locale: 'de-DE',
+              landingPage: 'NO_PREFERENCE',
+              shippingPreference: 'NO_SHIPPING',
+            },
+          },
+        },
+      },
+      prefer: 'return=minimal',
+    };
+
+    console.log('[PayPal] Creating order:', { amount: formattedAmount, currency });
+
+    const { body, ...httpResponse } = await ordersController.createOrder(collect);
+    const jsonResponse = JSON.parse(body);
+
+    console.log('[PayPal] Order created:', jsonResponse.id);
+
+    res.status(httpResponse.statusCode).json(jsonResponse);
+  } catch (error) {
+    console.error('[PayPal] Create order error:', error.message);
+    res.status(500).json({
+      error: 'Bestellung konnte nicht erstellt werden',
+      message: error.message
+    });
+  }
+}
+
+/**
+ * Erfasst eine PayPal-Zahlung
+ * POST /api/paypal/orders/:orderID/capture
+ */
+async function captureOrder(req, res) {
+  try {
+    if (!ordersController) {
+      return res.status(503).json({
+        error: 'PayPal nicht konfiguriert',
+        message: 'PayPal Client ID und Secret müssen in den Umgebungsvariablen gesetzt sein'
+      });
+    }
+
+    const { orderID } = req.params;
+
+    if (!orderID) {
+      return res.status(400).json({
+        error: 'Order ID fehlt',
+        message: 'Die PayPal Order ID muss angegeben werden'
+      });
+    }
+
+    const collect = {
+      id: orderID,
+      prefer: 'return=minimal',
+    };
+
+    console.log('[PayPal] Capturing order:', orderID);
+
+    const { body, ...httpResponse } = await ordersController.captureOrder(collect);
+    const jsonResponse = JSON.parse(body);
+
+    console.log('[PayPal] Order captured:', {
+      id: jsonResponse.id,
+      status: jsonResponse.status
+    });
+
+    res.status(httpResponse.statusCode).json(jsonResponse);
+  } catch (error) {
+    console.error('[PayPal] Capture order error:', error.message);
+    res.status(500).json({
+      error: 'Zahlung konnte nicht erfasst werden',
+      message: error.message
+    });
+  }
+}
+
+/**
+ * Prüft den PayPal-Konfigurationsstatus
+ * GET /api/paypal/status
+ */
+function getStatus(req, res) {
+  const { clientId, environment } = config.paypal;
+
+  res.json({
+    configured: !!(clientId && config.paypal.clientSecret),
+    environment,
+    // Nur die ersten/letzten Zeichen der Client ID anzeigen
+    clientIdPreview: clientId ? `${clientId.substring(0, 8)}...${clientId.substring(clientId.length - 4)}` : null
+  });
+}
+
+module.exports = {
+  createOrder,
+  captureOrder,
+  getStatus
+};

Docker Backend/src/api/controllers/preview-controller.js

@@ -0,0 +1,322 @@
+const fs = require("fs").promises;
+const fsSync = require("fs");
+const path = require("path");
+const { v4: uuidv4 } = require("uuid");
+const config = require("../../config");
+const { scriptalizeBatch } = require("../../services/scriptalizer-service");
+const {
+  generateLetterSVG,
+  generateEnvelopeSVG,
+} = require("../../lib/svg-generator");
+const {
+  replacePlaceholders,
+  generateAllCSVs,
+} = require("../../services/placeholder-service");
+
+/**
+ * POST /api/preview/batch
+ * Generate preview batch with rate limiting
+ */
+async function generateBatch(req, res, next) {
+  try {
+    const { sessionId, letters } = req.body;
+
+    // Validation
+    if (!letters || !Array.isArray(letters) || letters.length === 0) {
+      return res.status(400).json({
+        error: "Invalid request",
+        message: "Letters array is required and must not be empty",
+      });
+    }
+
+    // KEIN Limit mehr - Frontend sendet ALLE Dokumente auf einmal
+    // Backend teilt sie intern in 25er Batches für Scriptalizer auf
+    console.log(`[Preview] Received ${letters.length} letters (no limit)`);
+
+    // Optional: Warn if extremely large
+    if (letters.length > 1000) {
+      console.warn(`[Preview] Large batch detected: ${letters.length} letters`);
+    }
+
+    // Generate or validate sessionId
+    const finalSessionId = sessionId || uuidv4();
+
+    console.log(
+      `[Preview] Starting batch generation for session: ${finalSessionId}`
+    );
+    console.log(`[Preview] Batch size: ${letters.length} letters`);
+
+    // Create session cache directory
+    const sessionDir = path.join(config.paths.previews, finalSessionId);
+    await fs.mkdir(sessionDir, { recursive: true });
+
+    // Step 1: Prepare texts and replace placeholders
+    console.log(
+      "[Preview] Received indices from frontend:",
+      letters.map((l) => l.index)
+    );
+
+    const processedLetters = letters.map((letter, loopIndex) => {
+      let text = letter.text || "";
+
+      // Replace placeholders if present
+      if (letter.placeholders && typeof letter.placeholders === "object") {
+        text = replacePlaceholders(text, letter.placeholders);
+      }
+
+      return {
+        ...letter,
+        // Verwende den vom Frontend gesendeten Index, oder fallback auf loopIndex
+        index: letter.index !== undefined ? letter.index : loopIndex,
+        processedText: text,
+        format: letter.format || "a4",
+        font: letter.font || "tilda",
+        type: letter.type || "letter",
+        envelopeType: letter.envelopeType || "recipient",
+      };
+    });
+
+    console.log(
+      "[Preview] Final indices being used for files:",
+      processedLetters.map((l) => l.index)
+    );
+
+    // Step 2: Batch scriptalize texts
+    const textsToScriptalize = processedLetters.map((l) => l.processedText);
+    const font = processedLetters[0]?.font || "tilda";
+
+    console.log(
+      `[Preview] Scriptalizing ${textsToScriptalize.length} texts with font: ${font}`
+    );
+
+    let scriptalizedTexts;
+    try {
+      scriptalizedTexts = await scriptalizeBatch(
+        textsToScriptalize,
+        font,
+        config.scriptalizer.errFrequency
+      );
+    } catch (err) {
+      console.error("[Preview] Scriptalization failed:", err.message);
+      return res.status(500).json({
+        error: "Scriptalization failed",
+        message: err.message,
+      });
+    }
+
+    if (scriptalizedTexts.length !== processedLetters.length) {
+      console.warn(
+        `[Preview] Scriptalization mismatch: expected ${processedLetters.length}, got ${scriptalizedTexts.length}`
+      );
+    }
+
+    // Step 3: Generate SVG files
+    const files = [];
+    let hasOverflow = false;
+
+    for (let i = 0; i < processedLetters.length; i++) {
+      const letter = processedLetters[i];
+      const scriptalizedText = scriptalizedTexts[i] || letter.processedText;
+
+      let svgResult;
+
+      try {
+        if (letter.type === "envelope") {
+          // Umschläge haben keine Zeilenbegrenzung - nur SVG zurückgeben
+          const svgContent = generateEnvelopeSVG(
+            scriptalizedText,
+            letter.format,
+            letter.envelopeType,
+            { font: letter.font }
+          );
+          svgResult = { svg: svgContent, lineCount: 0, lineLimit: 0, overflow: false };
+        } else {
+          // Briefe: Zeileninfo mit zurückgeben
+          svgResult = generateLetterSVG(scriptalizedText, letter.format, {
+            font: letter.font,
+          });
+        }
+      } catch (err) {
+        console.error(
+          `[Preview] SVG generation failed for letter ${i}:`,
+          err.message
+        );
+        return res.status(500).json({
+          error: "SVG generation failed",
+          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`);
+
+    // Step 4: Generate all CSV files (placeholders, recipients, envelope placeholders, free addresses)
+    const csvUrls = {};
+    const hasPlaceholders = processedLetters.some((l) => l.placeholders && Object.keys(l.placeholders).length > 0);
+    const hasFreeAddresses = processedLetters.some((l) => l.type === 'envelope' && l.envelopeType === 'free');
+
+    if (hasPlaceholders || hasFreeAddresses) {
+      try {
+        const csvs = generateAllCSVs(processedLetters);
+
+        // Brief-Platzhalter CSV
+        if (csvs.placeholders) {
+          const filename = "brief_platzhalter.csv";
+          await fs.writeFile(path.join(sessionDir, filename), csvs.placeholders, "utf8");
+          csvUrls.placeholders = `/api/preview/${finalSessionId}/${filename}`;
+          console.log(`[Preview] Generated brief_platzhalter.csv`);
+        }
+
+        // Empfänger CSV (für recipientData-Modus)
+        if (csvs.recipients) {
+          const filename = "empfaenger.csv";
+          await fs.writeFile(path.join(sessionDir, filename), csvs.recipients, "utf8");
+          csvUrls.recipients = `/api/preview/${finalSessionId}/${filename}`;
+          console.log(`[Preview] Generated empfaenger.csv`);
+        }
+
+        // Umschlag-Platzhalter CSV (für customText-Modus)
+        if (csvs.envelopePlaceholders) {
+          const filename = "umschlag_platzhalter.csv";
+          await fs.writeFile(path.join(sessionDir, filename), csvs.envelopePlaceholders, "utf8");
+          csvUrls.envelopePlaceholders = `/api/preview/${finalSessionId}/${filename}`;
+          console.log(`[Preview] Generated umschlag_platzhalter.csv`);
+        }
+
+        // Freie Adressen CSV (für free-Modus)
+        if (csvs.freeAddresses) {
+          const filename = "freie_adressen.csv";
+          await fs.writeFile(path.join(sessionDir, filename), csvs.freeAddresses, "utf8");
+          csvUrls.freeAddresses = `/api/preview/${finalSessionId}/${filename}`;
+          console.log(`[Preview] Generated freie_adressen.csv`);
+        }
+      } catch (err) {
+        console.error("[Preview] CSV generation failed:", err.message);
+        // Don't fail the request, CSV is optional
+      }
+    }
+
+    // Step 5: Save session metadata (no expiration)
+    const metadataPath = path.join(sessionDir, ".metadata.json");
+    const metadata = {
+      sessionId: finalSessionId,
+      createdAt: new Date().toISOString(),
+      letterCount: files.length,
+      font,
+      hasPlaceholders,
+    };
+
+    await fs.writeFile(metadataPath, JSON.stringify(metadata, null, 2), "utf8");
+
+    console.log(
+      `[Preview] Batch generation complete for session: ${finalSessionId}`
+    );
+
+    // Response
+    res.status(200).json({
+      sessionId: finalSessionId,
+      files,
+      csvUrls,
+      hasOverflow,
+      overflowFiles: files.filter(f => f.overflow),
+    });
+  } catch (err) {
+    console.error("[Preview] Unexpected error:", err);
+    next(err);
+  }
+}
+
+/**
+ * GET /api/preview/:sessionId/:filename
+ * Serve cached preview files
+ */
+async function servePreview(req, res, next) {
+  try {
+    const { sessionId, filename } = req.params;
+
+    // Validate inputs
+    if (!sessionId || !filename) {
+      return res.status(400).json({
+        error: "Invalid request",
+        message: "sessionId and filename are required",
+      });
+    }
+
+    // Prevent directory traversal
+    const sanitizedFilename = path.basename(filename);
+    const filePath = path.join(
+      config.paths.previews,
+      sessionId,
+      sanitizedFilename
+    );
+
+    // Check if file exists
+    try {
+      await fs.access(filePath);
+    } catch {
+      return res.status(404).json({
+        error: "File not found",
+        message: `Preview file not found: ${sanitizedFilename}`,
+      });
+    }
+
+    // No cache expiration check - files are served until manually deleted
+
+    // Determine content type
+    const ext = path.extname(sanitizedFilename).toLowerCase();
+    let contentType = "application/octet-stream";
+
+    if (ext === ".svg") {
+      contentType = "image/svg+xml";
+    } else if (ext === ".csv") {
+      contentType = "text/csv";
+    }
+
+    // Serve file - NO CACHING
+    res.setHeader("Content-Type", contentType);
+    res.setHeader("Cache-Control", "no-store, no-cache, must-revalidate, proxy-revalidate");
+    res.setHeader("Pragma", "no-cache");
+    res.setHeader("Expires", "0");
+
+    const fileContent = await fs.readFile(filePath);
+    res.send(fileContent);
+  } catch (err) {
+    console.error("[Preview] Error serving file:", err);
+    next(err);
+  }
+}
+
+// No automatic cache cleanup - files are kept until manually deleted
+
+module.exports = {
+  generateBatch,
+  servePreview,
+};

Docker Backend/src/api/middleware/auth.js

@@ -0,0 +1,72 @@
+/**
+ * Authentication Middleware
+ * Validiert API-Token in Request-Headers
+ */
+
+const config = require('../../config');
+
+/**
+ * Middleware: API-Token validieren
+ */
+function authenticateApiToken(req, res, next) {
+  // API-Token aus Umgebungsvariablen
+  const validToken = config.auth.apiToken;
+
+  // Wenn kein Token konfiguriert ist, alle Requests erlauben (Development)
+  if (!validToken) {
+    console.warn('[Auth] WARNING: No API token configured - authentication disabled!');
+    return next();
+  }
+
+  // Token aus verschiedenen Quellen prüfen
+  const token =
+    req.headers['x-api-token'] ||           // Custom Header
+    req.headers['authorization']?.replace('Bearer ', '') ||  // Bearer Token
+    req.query.api_token;                    // Query Parameter (nur für Tests)
+
+  // Kein Token vorhanden
+  if (!token) {
+    return res.status(401).json({
+      error: 'Unauthorized',
+      message: 'API token required. Please provide X-API-Token header or Authorization: Bearer <token>',
+    });
+  }
+
+  // Token validieren
+  if (token !== validToken) {
+    return res.status(403).json({
+      error: 'Forbidden',
+      message: 'Invalid API token',
+    });
+  }
+
+  // Token ist gültig
+  next();
+}
+
+/**
+ * Optionale Authentifizierung - Warnung aber kein Fehler
+ */
+function optionalAuth(req, res, next) {
+  const validToken = config.auth.apiToken;
+
+  if (!validToken) {
+    return next();
+  }
+
+  const token =
+    req.headers['x-api-token'] ||
+    req.headers['authorization']?.replace('Bearer ', '') ||
+    req.query.api_token;
+
+  if (!token || token !== validToken) {
+    console.warn('[Auth] Unauthenticated request to', req.path);
+  }
+
+  next();
+}
+
+module.exports = {
+  authenticateApiToken,
+  optionalAuth,
+};

Docker Backend/src/api/middleware/error-handler.js

@@ -0,0 +1,13 @@
+module.exports = (err, req, res, next) => {
+  console.error('Error occurred:', err);
+
+  const statusCode = err.statusCode || 500;
+  const message = err.message || 'Internal Server Error';
+
+  res.status(statusCode).json({
+    error: {
+      message,
+      ...(process.env.NODE_ENV === 'development' && { stack: err.stack })
+    }
+  });
+};

Docker Backend/src/api/middleware/rate-limiter.js

@@ -0,0 +1,53 @@
+const config = require('../../config');
+
+// Simple in-memory rate limiter
+const rateLimitStore = new Map();
+
+// Cleanup old entries every minute
+setInterval(() => {
+  const now = Date.now();
+  const oneMinute = 60 * 1000;
+
+  for (const [key, data] of rateLimitStore.entries()) {
+    if (now - data.windowStart > oneMinute) {
+      rateLimitStore.delete(key);
+    }
+  }
+}, 60 * 1000);
+
+module.exports = (req, res, next) => {
+  const sessionId = req.body.sessionId || req.params.sessionId || 'anonymous';
+  const now = Date.now();
+  const oneMinute = 60 * 1000;
+
+  let rateData = rateLimitStore.get(sessionId);
+
+  if (!rateData || now - rateData.windowStart > oneMinute) {
+    // New window
+    rateData = {
+      windowStart: now,
+      requests: []
+    };
+    rateLimitStore.set(sessionId, rateData);
+  }
+
+  // Remove requests older than 1 minute
+  rateData.requests = rateData.requests.filter(timestamp => now - timestamp < oneMinute);
+
+  // Check limit
+  if (rateData.requests.length >= config.preview.rateLimitPerMinute) {
+    const oldestRequest = Math.min(...rateData.requests);
+    const retryAfter = Math.ceil((oneMinute - (now - oldestRequest)) / 1000);
+
+    return res.status(429).json({
+      error: 'Zu viele Vorschau-Anfragen. Bitte warten Sie.',
+      retryAfter,
+      message: `Limit: ${config.preview.rateLimitPerMinute} Anfragen pro Minute`
+    });
+  }
+
+  // Add current request
+  rateData.requests.push(now);
+
+  next();
+};

Docker Backend/src/api/middleware/request-logger.js

@@ -0,0 +1,14 @@
+module.exports = (req, res, next) => {
+  const start = Date.now();
+
+  res.on('finish', () => {
+    const duration = Date.now() - start;
+    const timestamp = new Date().toISOString();
+
+    console.log(
+      `[${timestamp}] ${req.method} ${req.path} - ${res.statusCode} (${duration}ms)`
+    );
+  });
+
+  next();
+};

Docker Backend/src/api/routes/health-routes.js

@@ -0,0 +1,34 @@
+const express = require('express');
+const router = express.Router();
+const fs = require('fs');
+const config = require('../../config');
+
+router.get('/', (req, res) => {
+  const health = {
+    status: 'healthy',
+    timestamp: new Date().toISOString(),
+    uptime: process.uptime(),
+    scriptalizer: config.scriptalizer.licenseKey ? 'configured' : 'missing',
+    storage: {
+      cache: fs.existsSync(config.paths.cache) && isWritable(config.paths.cache),
+      output: fs.existsSync(config.paths.output) && isWritable(config.paths.output)
+    }
+  };
+
+  const allHealthy = health.scriptalizer === 'configured' &&
+                     health.storage.cache &&
+                     health.storage.output;
+
+  res.status(allHealthy ? 200 : 503).json(health);
+});
+
+function isWritable(path) {
+  try {
+    fs.accessSync(path, fs.constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = router;

Docker Backend/src/api/routes/order-routes.js

@@ -0,0 +1,94 @@
+const express = require('express');
+const router = express.Router();
+const multer = require('multer');
+const orderController = require('../controllers/order-controller');
+const { authenticateApiToken } = require('../middleware/auth');
+
+// Multer konfigurieren für Datei-Uploads (temporär im Speicher)
+const upload = multer({
+  storage: multer.memoryStorage(),
+  limits: {
+    fileSize: 10 * 1024 * 1024, // 10MB max
+  },
+  fileFilter: (req, file, cb) => {
+    // Erlaubte Dateitypen
+    const allowedTypes = ['image/png', 'image/jpeg', 'image/webp', 'image/svg+xml', 'application/pdf'];
+    const allowedExts = ['.png', '.jpg', '.jpeg', '.webp', '.svg', '.pdf'];
+
+    const ext = file.originalname.toLowerCase().substring(file.originalname.lastIndexOf('.'));
+
+    if (allowedTypes.includes(file.mimetype) || allowedExts.includes(ext)) {
+      cb(null, true);
+    } else {
+      cb(new Error('Nur PNG, JPG, WEBP, SVG und PDF Dateien sind erlaubt'), false);
+    }
+  }
+});
+
+/**
+ * POST /api/order/finalize
+ * Finalize order by copying cached previews to output directory
+ *
+ * Request body:
+ * {
+ *   sessionId: string,
+ *   orderNumber: string
+ * }
+ *
+ * Response:
+ * {
+ *   orderNumber: string,
+ *   outputPath: string,
+ *   files: string[],
+ *   timestamp: string
+ * }
+ */
+router.post('/finalize', authenticateApiToken, orderController.finalizeOrder);
+
+/**
+ * POST /api/order/generate
+ * Generate order from scratch without using cache
+ *
+ * Request body:
+ * {
+ *   orderNumber: string,
+ *   letters: [
+ *     {
+ *       text: string,
+ *       format: 'a4' | 'a6p' | 'a6l' | 'c6' | 'din_lang',
+ *       font: 'tilda' | 'alva' | 'ellie',
+ *       type?: 'letter' | 'envelope',
+ *       envelopeType?: 'recipient' | 'custom',
+ *       placeholders?: { [key: string]: string }
+ *     }
+ *   ]
+ * }
+ *
+ * Response:
+ * {
+ *   orderNumber: string,
+ *   outputPath: string,
+ *   files: string[],
+ *   timestamp: string
+ * }
+ */
+router.post('/generate', authenticateApiToken, orderController.generateOrder);
+
+/**
+ * POST /api/order/motif
+ * Upload a motif image for an order
+ *
+ * Request: multipart/form-data
+ * - motif: file (PNG, JPG, WEBP, SVG, PDF)
+ * - orderNumber: string
+ *
+ * Response:
+ * {
+ *   success: boolean,
+ *   filename: string,
+ *   path: string
+ * }
+ */
+router.post('/motif', authenticateApiToken, upload.single('motif'), orderController.uploadMotif);
+
+module.exports = router;

Docker Backend/src/api/routes/paypal-routes.js

@@ -0,0 +1,14 @@
+const express = require('express');
+const router = express.Router();
+const paypalController = require('../controllers/paypal-controller');
+
+// PayPal-Konfigurationsstatus
+router.get('/status', paypalController.getStatus);
+
+// Bestellung erstellen
+router.post('/orders', paypalController.createOrder);
+
+// Zahlung erfassen
+router.post('/orders/:orderID/capture', paypalController.captureOrder);
+
+module.exports = router;

Docker Backend/src/api/routes/preview-routes.js

@@ -0,0 +1,47 @@
+const express = require('express');
+const router = express.Router();
+const previewController = require('../controllers/preview-controller');
+const { authenticateApiToken } = require('../middleware/auth');
+
+/**
+ * POST /api/preview/batch
+ * Generate preview batch (no rate limiting, no batch size limit)
+ * Backend automatically splits into 25-letter batches for Scriptalizer API
+ *
+ * Request body:
+ * {
+ *   sessionId: string,
+ *   letters: [
+ *     {
+ *       text: string,
+ *       format: 'a4' | 'a6p' | 'a6l' | 'c6' | 'din_lang',
+ *       font: 'tilda' | 'alva' | 'ellie',
+ *       type?: 'letter' | 'envelope',
+ *       envelopeType?: 'recipient' | 'custom',
+ *       placeholders?: { [key: string]: string }
+ *     }
+ *   ]
+ * }
+ *
+ * Response:
+ * {
+ *   sessionId: string,
+ *   files: [
+ *     {
+ *       index: number,
+ *       filename: string,
+ *       url: string
+ *     }
+ *   ],
+ *   csvUrl?: string
+ * }
+ */
+router.post('/batch', authenticateApiToken, previewController.generateBatch);
+
+/**
+ * GET /api/preview/:sessionId/:filename
+ * Serve cached preview SVG files
+ */
+router.get('/:sessionId/:filename', previewController.servePreview);
+
+module.exports = router;

Docker Backend/src/config/index.js

@@ -0,0 +1,53 @@
+require('dotenv').config();
+const path = require('path');
+
+const isProduction = process.env.NODE_ENV === 'production';
+
+module.exports = {
+  env: process.env.NODE_ENV || 'development',
+  port: parseInt(process.env.PORT, 10) || 4000,
+
+  scriptalizer: {
+    licenseKey: process.env.SCRIPTALIZER_LICENSE_KEY,
+    errFrequency: parseInt(process.env.SCRIPTALIZER_ERR_FREQUENCY, 10) || 0,
+    endpoint: 'https://www.scriptalizer.co.uk/QuantumScriptalize.asmx/Scriptalize',
+    fontMap: {
+      tilda: 'PremiumUltra79',
+      alva: 'PremiumUltra23',
+      ellie: 'PremiumUltra39'
+    },
+    separator: '|||',  // Triple pipe separator (tested and working)
+    maxInputSize: 48000  // 48KB limit
+  },
+
+  preview: {
+    // No batch size limit - frontend can send any number of letters
+    // Backend splits into 25-letter batches for Scriptalizer API internally
+    scriptalizerBatchSize: 25
+    // No cache lifetime - files are kept until manually cleaned
+    // No rate limiting
+  },
+
+  paths: {
+    cache: isProduction ? '/app/cache' : path.join(__dirname, '../../cache'),
+    previews: isProduction ? '/app/cache/previews' : path.join(__dirname, '../../cache/previews'),
+    output: isProduction ? '/app/output' : path.join(__dirname, '../../output'),
+    fonts: isProduction ? '/app/fonts' : path.join(__dirname, '../../fonts')
+  },
+
+  cors: {
+    origin: process.env.CORS_ORIGIN || '*',
+    credentials: true
+  },
+
+  auth: {
+    apiToken: process.env.API_TOKEN || null
+  },
+
+  paypal: {
+    clientId: process.env.PAYPAL_CLIENT_ID || '',
+    clientSecret: process.env.PAYPAL_CLIENT_SECRET || '',
+    // 'sandbox' oder 'live'
+    environment: process.env.PAYPAL_ENVIRONMENT || 'sandbox'
+  }
+};

Docker Backend/src/lib/page-layout.js

@@ -0,0 +1,122 @@
+const PX_PER_MM = 3.78; // 96dpi
+const FONT_SIZE_PX = 26;
+
+// Maximale Zeilenanzahl pro Format (für Textvalidierung)
+const LINE_LIMITS = {
+  a4: 27,
+  a6p: 14,
+  a6l: 9,
+};
+
+// Layout Konfiguration pro Format + Orientation
+const FORMAT_LAYOUTS = {
+  // A4 Hochformat
+  a4: {
+    marginTopMm: 25,
+    marginLeftMm: 20,
+    lineHeightFactor: 1.35,
+  },
+
+  // A6 Hochformat
+  a6p: {
+    marginTopMm: 12,
+    marginLeftMm: 10,
+    lineHeightFactor: 1.3,
+  },
+
+  // A6 Querformat (landscape)
+  a6l: {
+    marginTopMm: 10,
+    marginLeftMm: 8,
+    lineHeightFactor: 1.2,
+  },
+
+  // DIN Lang Kuvert (Querformat)
+  din_lang: {
+    marginTopMm: 50,
+    marginLeftMm: 10,  // Links unten in Ecke
+    lineHeightFactor: 1.2,
+  },
+
+  // C6 Kuvert (Querformat)
+  c6: {
+    marginTopMm: 60,
+    marginLeftMm: 10,  // Links unten in Ecke
+    lineHeightFactor: 1.2,
+  },
+};
+
+// Seiten-Dimensionen
+const PAGE_FORMATS = {
+  a4: { widthMm: 210, heightMm: 297 },
+  a6p: { widthMm: 105, heightMm: 148 },
+  a6l: { widthMm: 148, heightMm: 105 },  // Querformat: getauscht
+  din_lang: { widthMm: 220, heightMm: 110 },
+  c6: { widthMm: 162, heightMm: 114 },
+};
+
+// mm in Pixel umrechnen
+function mmToPx(mm) {
+  return mm * PX_PER_MM;
+}
+
+// Layout für Format holen
+function getLayoutForFormat(format) {
+  const normalizedFormat = String(format).toLowerCase();
+  const layoutConfig = FORMAT_LAYOUTS[normalizedFormat];
+
+  if (!layoutConfig) {
+    // Fallback auf a4
+    return {
+      marginTopPx: mmToPx(FORMAT_LAYOUTS.a4.marginTopMm),
+      marginLeftPx: mmToPx(FORMAT_LAYOUTS.a4.marginLeftMm),
+      lineHeightPx: FONT_SIZE_PX * FORMAT_LAYOUTS.a4.lineHeightFactor,
+    };
+  }
+
+  return {
+    marginTopPx: mmToPx(layoutConfig.marginTopMm),
+    marginLeftPx: mmToPx(layoutConfig.marginLeftMm),
+    lineHeightPx: FONT_SIZE_PX * layoutConfig.lineHeightFactor,
+  };
+}
+
+// Seiten-Dimensionen holen
+function getPageDimensions(format) {
+  const normalizedFormat = String(format).toLowerCase();
+  const dimensions = PAGE_FORMATS[normalizedFormat] || PAGE_FORMATS.a4;
+
+  return {
+    widthMm: dimensions.widthMm,
+    heightMm: dimensions.heightMm,
+    widthPx: mmToPx(dimensions.widthMm),
+    heightPx: mmToPx(dimensions.heightMm),
+  };
+}
+
+// XML Escaping
+function escapeXml(str) {
+  return String(str)
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+}
+
+// Zeilenlimit für Format holen
+function getLineLimit(format) {
+  const normalizedFormat = String(format).toLowerCase();
+  return LINE_LIMITS[normalizedFormat] || LINE_LIMITS.a4;
+}
+
+module.exports = {
+  PX_PER_MM,
+  FONT_SIZE_PX,
+  FORMAT_LAYOUTS,
+  PAGE_FORMATS,
+  LINE_LIMITS,
+  mmToPx,
+  getLayoutForFormat,
+  getPageDimensions,
+  getLineLimit,
+  escapeXml
+};

Docker Backend/src/lib/svg-font-engine.js

@@ -0,0 +1,212 @@
+const fs = require('fs');
+const path = require('path');
+const config = require('../config');
+
+// Cache je Fontdatei
+const FONT_CACHE = {};
+
+// Attribut aus einem Tag lesen (mit Wortgrenze, um z.B. 'd' vs 'id' zu unterscheiden)
+function getAttr(tag, name) {
+  const re = new RegExp(`\\b${name}="([^"]*)"`);
+  const m = tag.match(re);
+  return m ? m[1] : null;
+}
+
+// SVG-Font parsen und Metriken plus Glyphen extrahieren
+function parseSvgFont(fontFileName) {
+  if (FONT_CACHE[fontFileName]) return FONT_CACHE[fontFileName];
+
+  const fontPath = path.join(config.paths.fonts, fontFileName);
+  const svg = fs.readFileSync(fontPath, 'utf8');
+
+  const fontFaceMatch = svg.match(/<font-face[\s\S]*?>/);
+  if (!fontFaceMatch) {
+    throw new Error(`Kein <font-face> in ${fontFileName} gefunden`);
+  }
+
+  const fontFaceTag = fontFaceMatch[0];
+  const unitsPerEm = parseFloat(getAttr(fontFaceTag, 'units-per-em') || '1000');
+  const ascent = parseFloat(getAttr(fontFaceTag, 'ascent') || '0');
+  const descent = parseFloat(getAttr(fontFaceTag, 'descent') || '0');
+
+  const glyphRegex = /<glyph[\s\S]*?\/>/g;
+  const glyphs = {};
+  let m;
+
+  while ((m = glyphRegex.exec(svg)) !== null) {
+    const tag = m[0];
+    const unicode = getAttr(tag, 'unicode');
+    const d = getAttr(tag, 'd');
+    const adv = parseFloat(getAttr(tag, 'horiz-adv-x') || '0');
+
+    if (!unicode || !d) continue;
+
+    glyphs[unicode] = {
+      d,
+      adv,
+    };
+  }
+
+  const fontData = {
+    unitsPerEm,
+    ascent,
+    descent,
+    glyphs,
+  };
+
+  FONT_CACHE[fontFileName] = fontData;
+  return fontData;
+}
+
+/**
+ * Breite einer Textzeile in Pixeln messen.
+ */
+function measureTextWidthPx({ text, fontFileName, fontSizePx }) {
+  const { unitsPerEm, glyphs } = parseSvgFont(fontFileName);
+  const scale = fontSizePx / unitsPerEm;
+
+  let x = 0;
+
+  for (const ch of String(text || '')) {
+    const glyph = glyphs[ch];
+
+    if (!glyph) {
+      // Fallback für Leerzeichen / unbekannte Zeichen
+      const spacePx = fontSizePx * 0.4;
+      x += spacePx;
+      continue;
+    }
+
+    const advPx = (glyph.adv || unitsPerEm * 0.5) * scale;
+    x += advPx;
+  }
+
+  return x;
+}
+
+/**
+ * Text nach verfügbarer Breite umbrechen.
+ * Garantiert: keine Zeile wird breiter als maxWidthPx.
+ */
+function wrapTextToLinesByWidth({
+  text,
+  maxWidthPx,
+  fontFileName,
+  fontSizePx,
+}) {
+  const paragraphs = String(text || '').split(/\r?\n/);
+  const allLines = [];
+
+  const measure = (t) =>
+    measureTextWidthPx({ text: t, fontFileName, fontSizePx });
+
+  for (const para of paragraphs) {
+    const words = para.split(/\s+/).filter(Boolean);
+    if (words.length === 0) {
+      allLines.push('');
+      continue;
+    }
+
+    let currentLine = '';
+
+    for (const word of words) {
+      // Wort alleine zu breit → Zeichenweise brechen
+      if (measure(word) > maxWidthPx) {
+        if (currentLine) {
+          allLines.push(currentLine);
+          currentLine = '';
+        }
+
+        let buf = '';
+        for (const ch of word) {
+          const candidate = buf + ch;
+          if (measure(candidate) > maxWidthPx && buf) {
+            allLines.push(buf);
+            buf = ch;
+          } else {
+            buf = candidate;
+          }
+        }
+        if (buf) currentLine = buf;
+        continue;
+      }
+
+      if (!currentLine) {
+        currentLine = word;
+        continue;
+      }
+
+      const candidate = `${currentLine} ${word}`;
+      if (measure(candidate) <= maxWidthPx) {
+        currentLine = candidate;
+      } else {
+        allLines.push(currentLine);
+        currentLine = word;
+      }
+    }
+
+    if (currentLine) {
+      allLines.push(currentLine);
+    }
+  }
+
+  return allLines;
+}
+
+/**
+ * Textzeilen in Pfade mit Transform-Matrix umwandeln.
+ */
+function layoutTextToPaths({
+  lines,
+  fontFileName,
+  fontSizePx,
+  startX,
+  startY,
+  lineHeightPx,
+}) {
+  const { unitsPerEm, glyphs } = parseSvgFont(fontFileName);
+
+  const scale = fontSizePx / unitsPerEm;
+
+  const resultPaths = [];
+  let baselineY = startY;
+
+  for (const line of lines) {
+    let x = startX;
+
+    for (let i = 0; i < line.length; i++) {
+      const ch = line[i];
+      const glyph = glyphs[ch];
+
+      if (!glyph) {
+        // Leerzeichen mit festem Abstand
+        const spacePx = fontSizePx * 0.4;
+        x += spacePx;
+        continue;
+      }
+
+      const d = glyph.d;
+      const advPx = (glyph.adv || unitsPerEm * 0.5) * scale;
+
+      // Einfache Transform-Matrix ohne Rotation
+      const transform = `matrix(${scale},0,0,${-scale},${x},${baselineY})`;
+
+      resultPaths.push({
+        d,
+        transform,
+      });
+
+      x += advPx;
+    }
+
+    baselineY += lineHeightPx;
+  }
+
+  return resultPaths;
+}
+
+module.exports = {
+  measureTextWidthPx,
+  wrapTextToLinesByWidth,
+  layoutTextToPaths
+};

Docker Backend/src/lib/svg-generator.js

@@ -0,0 +1,213 @@
+const {
+  FONT_SIZE_PX,
+  getLayoutForFormat,
+  getPageDimensions,
+  getLineLimit,
+  escapeXml
+} = require('./page-layout');
+
+const {
+  layoutTextToPaths,
+  wrapTextToLinesByWidth,
+  measureTextWidthPx
+} = require('./svg-font-engine');
+
+// Mapping der Handschriften auf SVG-Font-Dateien
+const SVG_FONT_CONFIG = {
+  tilda: { file: 'tilda.svg' },
+  alva: { file: 'alva.svg' },
+  ellie: { file: 'ellie.svg' },
+};
+
+function normalizeFontKey(font) {
+  if (!font) return 'tilda';
+  const f = String(font).toLowerCase();
+  if (['tilda', 'alva', 'ellie'].includes(f)) return f;
+  return 'tilda';
+}
+
+/**
+ * Generiert ein Schriftstück (Brief/Postkarte) als SVG
+ * @param {string} text - Der scriptalisierte Text
+ * @param {string} format - Format: a4, a6p, a6l
+ * @param {object} options - { font: 'tilda', alignment: 'left' }
+ */
+function generateLetterSVG(text, format, options = {}) {
+  const fontKey = normalizeFontKey(options.font);
+  const fontConfig = SVG_FONT_CONFIG[fontKey];
+
+  const { widthPx, heightPx, widthMm, heightMm } = getPageDimensions(format);
+  const { marginTopPx, marginLeftPx, lineHeightPx } = getLayoutForFormat(format);
+
+  // Automatischer Zeilenumbruch
+  const maxWidthPx = widthPx - 2 * marginLeftPx;
+
+  const lines = wrapTextToLinesByWidth({
+    text: String(text || ''),
+    maxWidthPx,
+    fontFileName: fontConfig.file,
+    fontSizePx: FONT_SIZE_PX,
+  });
+
+  const firstBaselineY = marginTopPx + FONT_SIZE_PX;
+
+  const paths = layoutTextToPaths({
+    lines,
+    fontFileName: fontConfig.file,
+    fontSizePx: FONT_SIZE_PX,
+    startX: marginLeftPx,
+    startY: firstBaselineY,
+    lineHeightPx,
+  });
+
+  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  ');
+
+  const svg = `<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>`;
+
+  const lineLimit = getLineLimit(format);
+  const lineCount = lines.length;
+
+  return {
+    svg: svg.trim(),
+    lineCount,
+    lineLimit,
+    overflow: lineCount > lineLimit
+  };
+}
+
+/**
+ * Generiert einen Umschlag als SVG
+ * @param {string} text - Der scriptalisierte Text
+ * @param {string} format - Format: c6, din_lang
+ * @param {string} type - Typ: 'recipient' (links), 'free' (links, freie Adresse), 'custom' (mittig)
+ * @param {object} options - { font: 'tilda' }
+ */
+function generateEnvelopeSVG(text, format, type, options = {}) {
+  const fontKey = normalizeFontKey(options.font);
+  const fontConfig = SVG_FONT_CONFIG[fontKey];
+
+  const { widthPx, heightPx, widthMm, heightMm } = getPageDimensions(format);
+  const { marginTopPx, marginLeftPx, lineHeightPx } = getLayoutForFormat(format);
+
+  let lines;
+  let startX;
+  let startY;
+
+  if (type === 'custom') {
+    // Mittig zentriert, 70% der Umschlagsbreite
+    const maxWidthPx = widthPx * 0.7;
+
+    lines = wrapTextToLinesByWidth({
+      text: String(text || ''),
+      maxWidthPx,
+      fontFileName: fontConfig.file,
+      fontSizePx: FONT_SIZE_PX,
+    });
+
+    // Zentrierung berechnen
+    const totalTextHeight = lines.length * lineHeightPx;
+    startY = (heightPx - totalTextHeight) / 2 + FONT_SIZE_PX;
+
+    // Jede Zeile einzeln zentrieren
+    // startX wird später pro Zeile berechnet
+    startX = 0; // Dummy-Wert, wird für jede Zeile überschrieben
+
+  } else {
+    // type === 'recipient': Links unten in Ecke
+    const maxWidthPx = widthPx - marginLeftPx - 20;
+
+    lines = wrapTextToLinesByWidth({
+      text: String(text || ''),
+      maxWidthPx,
+      fontFileName: fontConfig.file,
+      fontSizePx: FONT_SIZE_PX,
+    });
+
+    startX = marginLeftPx;
+    startY = marginTopPx + FONT_SIZE_PX;
+  }
+
+  let paths = [];
+
+  if (type === 'custom') {
+    // Bei custom type: Jede Zeile einzeln zentrieren
+    let currentY = startY;
+    for (const line of lines) {
+      const lineWidth = measureTextWidthPx({
+        text: line,
+        fontFileName: fontConfig.file,
+        fontSizePx: FONT_SIZE_PX
+      });
+      const centeredX = (widthPx - lineWidth) / 2;
+
+      const linePaths = layoutTextToPaths({
+        lines: [line],
+        fontFileName: fontConfig.file,
+        fontSizePx: FONT_SIZE_PX,
+        startX: centeredX,
+        startY: currentY,
+        lineHeightPx,
+      });
+
+      paths.push(...linePaths);
+      currentY += lineHeightPx;
+    }
+  } else {
+    // Bei recipient type: Normal links ausrichten
+    paths = layoutTextToPaths({
+      lines,
+      fontFileName: fontConfig.file,
+      fontSizePx: FONT_SIZE_PX,
+      startX,
+      startY,
+      lineHeightPx,
+    });
+  }
+
+  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  ');
+
+  const svg = `<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>`;
+
+  return svg.trim();
+}
+
+module.exports = {
+  generateLetterSVG,
+  generateEnvelopeSVG
+};

Docker Backend/src/server.js

@@ -0,0 +1,55 @@
+const express = require('express');
+const cors = require('cors');
+const config = require('./config');
+
+const previewRoutes = require('./api/routes/preview-routes');
+const orderRoutes = require('./api/routes/order-routes');
+const healthRoutes = require('./api/routes/health-routes');
+const paypalRoutes = require('./api/routes/paypal-routes');
+
+const errorHandler = require('./api/middleware/error-handler');
+const requestLogger = require('./api/middleware/request-logger');
+
+const app = express();
+
+// Middleware
+app.use(cors(config.cors));
+app.use(express.json({ limit: '10mb' }));
+app.use(express.urlencoded({ extended: true, limit: '10mb' }));
+app.use(requestLogger);
+
+// Routes
+app.use('/health', healthRoutes);
+app.use('/api/preview', previewRoutes);
+app.use('/api/order', orderRoutes);
+app.use('/api/paypal', paypalRoutes);
+
+// Error handling
+app.use(errorHandler);
+
+// Start server
+app.listen(config.port, () => {
+  console.log('╔════════════════════════════════════════════════════════════╗');
+  console.log('║                  Skrift Backend Server                    ║');
+  console.log('╚════════════════════════════════════════════════════════════╝');
+  console.log(`Environment:       ${config.env}`);
+  console.log(`Port:              ${config.port}`);
+  console.log(`Batch Size:        Unlimited (auto-split to ${config.preview.scriptalizerBatchSize} for API)`);
+  console.log(`Cache:             Disabled`);
+  console.log(`Rate Limit:        Disabled`);
+  console.log(`Scriptalizer:      ${config.scriptalizer.licenseKey ? 'Configured ✓' : 'Missing ✗'}`);
+  console.log('════════════════════════════════════════════════════════════');
+  console.log(`Server running at http://localhost:${config.port}`);
+  console.log('════════════════════════════════════════════════════════════\n');
+});
+
+// Graceful shutdown
+process.on('SIGTERM', () => {
+  console.log('SIGTERM received, shutting down gracefully...');
+  process.exit(0);
+});
+
+process.on('SIGINT', () => {
+  console.log('\nSIGINT received, shutting down gracefully...');
+  process.exit(0);
+});

Docker Backend/src/services/placeholder-service.js

@@ -0,0 +1,283 @@
+/**
+ * Ersetzt Platzhalter im Text
+ * @param {string} text - Text mit Platzhaltern wie [[Vorname]]
+ * @param {object} placeholders - Objekt mit Platzhalter-Werten {Vorname: 'Max', ...}
+ * @returns {string} - Text mit ersetzten Platzhaltern
+ */
+function replacePlaceholders(text, placeholders) {
+  if (!placeholders || typeof placeholders !== 'object') {
+    return text;
+  }
+
+  let result = text;
+
+  for (const [key, value] of Object.entries(placeholders)) {
+    const placeholder = `[[${key}]]`;
+    // Case-insensitive replacement: 'i' flag
+    const regex = new RegExp(placeholder.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi');
+    result = result.replace(regex, value || '');
+  }
+
+  return result;
+}
+
+/**
+ * Escaped einen Wert für CSV
+ */
+function escapeCSV(value) {
+  const str = String(value || '');
+  if (str.includes(',') || str.includes('\n') || str.includes('"')) {
+    return `"${str.replace(/"/g, '""')}"`;
+  }
+  return str;
+}
+
+/**
+ * Generiert CSV aus Platzhalter-Daten (für Briefe)
+ * @param {Array} letters - Array von Letter-Objekten mit placeholders
+ * @returns {string} - CSV-String
+ */
+function generatePlaceholderCSV(letters) {
+  if (!Array.isArray(letters) || letters.length === 0) {
+    return '';
+  }
+
+  // Nur Briefe filtern (keine Umschläge)
+  const letterItems = letters.filter(l => l.type !== 'envelope');
+  if (letterItems.length === 0) {
+    return '';
+  }
+
+  // Sammle alle unique Keys
+  const allKeys = new Set();
+  letterItems.forEach(letter => {
+    if (letter.placeholders) {
+      Object.keys(letter.placeholders).forEach(key => allKeys.add(key));
+    }
+  });
+
+  if (allKeys.size === 0) {
+    return '';
+  }
+
+  const keys = ['BriefNr', ...Array.from(allKeys).sort()];
+
+  // Header
+  const header = keys.join(',');
+
+  // Rows
+  const rows = letterItems.map((letter, index) => {
+    const briefNr = String(letter.index !== undefined ? letter.index : index).padStart(3, '0');
+    const values = [briefNr];
+
+    for (let i = 1; i < keys.length; i++) {
+      const key = keys[i];
+      const value = letter.placeholders?.[key] || '';
+      values.push(escapeCSV(value));
+    }
+
+    return values.join(',');
+  });
+
+  return [header, ...rows].join('\n');
+}
+
+/**
+ * Generiert CSV für Empfängerdaten (Umschläge im recipientData-Modus)
+ * @param {Array} letters - Array von Letter-Objekten
+ * @returns {string} - CSV-String
+ */
+function generateRecipientCSV(letters) {
+  if (!Array.isArray(letters) || letters.length === 0) {
+    return '';
+  }
+
+  // Nur Umschläge im recipient-Modus filtern
+  const envelopes = letters.filter(l => l.type === 'envelope' && l.envelopeType === 'recipient');
+  if (envelopes.length === 0) {
+    return '';
+  }
+
+  // Prüfe ob Empfängerdaten vorhanden sind (vorname, name, strasse, etc.)
+  const recipientKeys = ['vorname', 'name', 'strasse', 'hausnummer', 'plz', 'ort', 'land'];
+  const hasRecipientData = envelopes.some(env =>
+    env.placeholders && recipientKeys.some(key => env.placeholders[key])
+  );
+
+  if (!hasRecipientData) {
+    return '';
+  }
+
+  const keys = ['UmschlagNr', ...recipientKeys];
+  const header = keys.join(',');
+
+  const rows = envelopes.map((envelope, index) => {
+    const umschlagNr = String(envelope.index !== undefined ? envelope.index : index).padStart(3, '0');
+    const values = [umschlagNr];
+
+    for (let i = 1; i < keys.length; i++) {
+      const key = keys[i];
+      const value = envelope.placeholders?.[key] || '';
+      values.push(escapeCSV(value));
+    }
+
+    return values.join(',');
+  });
+
+  return [header, ...rows].join('\n');
+}
+
+/**
+ * Generiert CSV für freie Adressen (Umschläge im free-Modus)
+ * @param {Array} letters - Array von Letter-Objekten
+ * @returns {string} - CSV-String
+ */
+function generateFreeAddressCSV(letters) {
+  if (!Array.isArray(letters) || letters.length === 0) {
+    return '';
+  }
+
+  // Nur Umschläge im free-Modus filtern
+  const envelopes = letters.filter(l => l.type === 'envelope' && l.envelopeType === 'free');
+  if (envelopes.length === 0) {
+    return '';
+  }
+
+  // Freie Adressen haben bis zu 5 Zeilen
+  const keys = ['UmschlagNr', 'Zeile1', 'Zeile2', 'Zeile3', 'Zeile4', 'Zeile5'];
+  const header = keys.join(',');
+
+  const rows = envelopes.map((envelope, index) => {
+    const umschlagNr = String(envelope.index !== undefined ? envelope.index : index).padStart(3, '0');
+
+    // Text in Zeilen aufteilen
+    const textLines = (envelope.text || '').split('\n');
+    const values = [umschlagNr];
+
+    for (let i = 0; i < 5; i++) {
+      values.push(escapeCSV(textLines[i] || ''));
+    }
+
+    return values.join(',');
+  });
+
+  return [header, ...rows].join('\n');
+}
+
+/**
+ * Generiert CSV für Umschlag-Platzhalter (Umschläge im customText-Modus)
+ * @param {Array} letters - Array von Letter-Objekten
+ * @returns {string} - CSV-String
+ */
+function generateEnvelopePlaceholderCSV(letters) {
+  if (!Array.isArray(letters) || letters.length === 0) {
+    console.log('[CSV] generateEnvelopePlaceholderCSV: No letters');
+    return '';
+  }
+
+  // Nur Umschläge im custom-Modus filtern
+  const envelopes = letters.filter(l => l.type === 'envelope' && l.envelopeType === 'custom');
+  console.log('[CSV] Found custom envelopes:', envelopes.length);
+  console.log('[CSV] Envelope details:', envelopes.map(e => ({ type: e.type, envelopeType: e.envelopeType, placeholders: e.placeholders })));
+
+  if (envelopes.length === 0) {
+    return '';
+  }
+
+  // Sammle alle unique Keys (außer Standard-Empfängerfelder)
+  const recipientKeys = ['vorname', 'name', 'strasse', 'hausnummer', 'plz', 'ort', 'land'];
+  const allKeys = new Set();
+  envelopes.forEach(envelope => {
+    if (envelope.placeholders) {
+      console.log('[CSV] Envelope placeholders keys:', Object.keys(envelope.placeholders));
+      Object.keys(envelope.placeholders).forEach(key => {
+        // Nur nicht-Empfängerfelder sammeln
+        if (!recipientKeys.includes(key.toLowerCase())) {
+          allKeys.add(key);
+          console.log('[CSV] Added key:', key);
+        } else {
+          console.log('[CSV] Skipped recipient key:', key);
+        }
+      });
+    }
+  });
+
+  console.log('[CSV] All collected keys:', Array.from(allKeys));
+
+  if (allKeys.size === 0) {
+    console.log('[CSV] No custom placeholder keys found for envelopes');
+    return '';
+  }
+
+  const keys = ['UmschlagNr', ...Array.from(allKeys).sort()];
+  const header = keys.join(',');
+
+  const rows = envelopes.map((envelope, index) => {
+    const umschlagNr = String(envelope.index !== undefined ? envelope.index : index).padStart(3, '0');
+    const values = [umschlagNr];
+
+    for (let i = 1; i < keys.length; i++) {
+      const key = keys[i];
+      const value = envelope.placeholders?.[key] || '';
+      values.push(escapeCSV(value));
+    }
+
+    return values.join(',');
+  });
+
+  return [header, ...rows].join('\n');
+}
+
+/**
+ * Generiert alle CSV-Dateien für eine Bestellung
+ * @param {Array} letters - Array von Letter-Objekten (Briefe und Umschläge)
+ * @returns {Object} - Objekt mit CSV-Inhalten { placeholders, recipients, envelopePlaceholders, freeAddresses }
+ */
+function generateAllCSVs(letters) {
+  const result = {
+    placeholders: null,           // Brief-Platzhalter
+    recipients: null,             // Empfängerdaten für Umschläge (recipientData-Modus)
+    envelopePlaceholders: null,   // Umschlag-Platzhalter (customText-Modus)
+    freeAddresses: null           // Freie Adressen für Umschläge (free-Modus)
+  };
+
+  if (!Array.isArray(letters) || letters.length === 0) {
+    return result;
+  }
+
+  // Brief-Platzhalter CSV
+  const placeholderCSV = generatePlaceholderCSV(letters);
+  if (placeholderCSV) {
+    result.placeholders = placeholderCSV;
+  }
+
+  // Empfänger CSV (für recipientData-Modus)
+  const recipientCSV = generateRecipientCSV(letters);
+  if (recipientCSV) {
+    result.recipients = recipientCSV;
+  }
+
+  // Umschlag-Platzhalter CSV (für customText-Modus)
+  const envelopePlaceholderCSV = generateEnvelopePlaceholderCSV(letters);
+  if (envelopePlaceholderCSV) {
+    result.envelopePlaceholders = envelopePlaceholderCSV;
+  }
+
+  // Freie Adressen CSV (für free-Modus)
+  const freeAddressCSV = generateFreeAddressCSV(letters);
+  if (freeAddressCSV) {
+    result.freeAddresses = freeAddressCSV;
+  }
+
+  return result;
+}
+
+module.exports = {
+  replacePlaceholders,
+  generatePlaceholderCSV,
+  generateRecipientCSV,
+  generateEnvelopePlaceholderCSV,
+  generateFreeAddressCSV,
+  generateAllCSVs,
+  escapeCSV
+};

Docker Backend/src/services/scriptalizer-service.js

@@ -0,0 +1,230 @@
+const https = require("https");
+const { parseStringPromise } = require("xml2js");
+const config = require("../config");
+
+// API Request Counter (resets daily)
+const stats = {
+  requestsToday: 0,
+  textsToday: 0,
+  lastResetDate: new Date().toDateString(),
+};
+
+/**
+ * Prüft ob der Zähler zurückgesetzt werden muss (neuer Tag)
+ */
+function checkAndResetDailyStats() {
+  const today = new Date().toDateString();
+  if (stats.lastResetDate !== today) {
+    console.log(`[Scriptalizer] 📅 New day detected, resetting counters`);
+    console.log(`[Scriptalizer] 📊 Yesterday's stats: ${stats.requestsToday} API calls, ${stats.textsToday} texts processed`);
+    stats.requestsToday = 0;
+    stats.textsToday = 0;
+    stats.lastResetDate = today;
+  }
+}
+
+/**
+ * Gibt die aktuellen Stats zurück
+ */
+function getStats() {
+  checkAndResetDailyStats();
+  return { ...stats };
+}
+
+/**
+ * Ruft die Scriptalizer API auf
+ * @param {string} inputText - Text zum Scriptalisieren
+ * @param {string} fontName - Font-Name (z.B. 'PremiumUltra79')
+ * @param {number} errFrequency - Fehlerfrequenz
+ * @returns {Promise<{status: string, outputText: string}>}
+ */
+async function callScriptalizer(inputText, fontName, errFrequency = 10) {
+  // Prüfe ob neuer Tag
+  checkAndResetDailyStats();
+
+  return new Promise((resolve, reject) => {
+    if (!config.scriptalizer.licenseKey) {
+      reject(new Error("Scriptalizer License Key fehlt in Konfiguration"));
+      return;
+    }
+
+    // Use x-www-form-urlencoded format
+    const params = new URLSearchParams();
+    params.append("LicenseKey", config.scriptalizer.licenseKey);
+    params.append("FontName", fontName);
+    params.append("ErrFrequency", String(errFrequency));
+    params.append("InputText", inputText);
+
+    const body = params.toString();
+
+    // Check input size (48KB limit)
+    if (Buffer.byteLength(body) > config.scriptalizer.maxInputSize) {
+      reject(
+        new Error(
+          `Input size exceeds 48KB limit (${Buffer.byteLength(body)} bytes)`
+        )
+      );
+      return;
+    }
+
+    const options = {
+      hostname: "www.scriptalizer.co.uk",
+      port: 443,
+      path: "/QuantumScriptalize.asmx/Scriptalize",
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded; charset=utf-8",
+        "Content-Length": Buffer.byteLength(body),
+      },
+      timeout: 30000, // 30 second timeout
+    };
+
+    const req = https.request(options, (res) => {
+      let data = "";
+
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+
+      res.on("end", async () => {
+        try {
+          const result = await parseStringPromise(data, {
+            explicitArray: false,
+          });
+          const response = result.ScriptalizerResponse;
+
+          if (!response || response.Status !== "OK") {
+            reject(new Error(response?.Status || "UNKNOWN_STATUS"));
+            return;
+          }
+
+          // Zähler erhöhen bei erfolgreichem Request
+          stats.requestsToday++;
+          console.log(`[Scriptalizer] 📊 API Request #${stats.requestsToday} today completed`);
+
+          resolve({ status: "OK", outputText: response.OutputText });
+        } catch (err) {
+          reject(
+            new Error(`Failed to parse Scriptalizer response: ${err.message}`)
+          );
+        }
+      });
+    });
+
+    req.on("error", (err) => {
+      reject(new Error(`Scriptalizer request failed: ${err.message}`));
+    });
+
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Scriptalizer request timed out"));
+    });
+
+    req.write(body);
+    req.end();
+  });
+}
+
+/**
+ * Scriptalisiert mehrere Texte in 25er Batches
+ * @param {string[]} texts - Array von Texten
+ * @param {string} font - Font-Key (tilda, alva, ellie)
+ * @param {number} errFrequency - Fehlerfrequenz
+ * @returns {Promise<string[]>} - Array von scriptalisierten Texten
+ */
+async function scriptalizeBatch(texts, font = "tilda", errFrequency = 10) {
+  if (!Array.isArray(texts) || texts.length === 0) {
+    return [];
+  }
+
+  const fontName =
+    config.scriptalizer.fontMap[font.toLowerCase()] ||
+    config.scriptalizer.fontMap.tilda;
+  const separator = config.scriptalizer.separator;
+  const BATCH_SIZE = 25; // 25 Texte pro Scriptalizer API Call
+
+  console.log(
+    `[Scriptalizer] Processing ${texts.length} texts in batches of ${BATCH_SIZE}`
+  );
+
+  const allScriptalized = [];
+
+  // Teile in 25er Batches auf
+  for (let i = 0; i < texts.length; i += BATCH_SIZE) {
+    const batch = texts.slice(i, i + BATCH_SIZE);
+    const batchNumber = Math.floor(i / BATCH_SIZE) + 1;
+    const totalBatches = Math.ceil(texts.length / BATCH_SIZE);
+
+    console.log(
+      `[Scriptalizer] Processing batch ${batchNumber}/${totalBatches} (${
+        batch.length
+      } texts, indices ${i}-${i + batch.length - 1})`
+    );
+
+    // Kombiniere Texte mit Separator
+    const combinedText = batch.join(separator);
+
+    try {
+      const result = await callScriptalizer(
+        combinedText,
+        fontName,
+        errFrequency
+      );
+
+      // Trenne Ergebnis wieder
+      const scriptalized = result.outputText.split(separator);
+
+      if (scriptalized.length !== batch.length) {
+        console.warn(
+          `[Scriptalizer] Batch ${batchNumber}: returned ${scriptalized.length} parts, expected ${batch.length}`
+        );
+      }
+
+      allScriptalized.push(...scriptalized);
+      console.log(
+        `[Scriptalizer] Batch ${batchNumber}/${totalBatches} completed successfully`
+      );
+    } catch (err) {
+      console.error(`[Scriptalizer] Batch ${batchNumber} failed:`, err.message);
+      throw err;
+    }
+  }
+
+  // Textzähler erhöhen
+  stats.textsToday += allScriptalized.length;
+
+  console.log(
+    `[Scriptalizer] All batches completed. Total scriptalized: ${allScriptalized.length}`
+  );
+  console.log(
+    `[Scriptalizer] 📊 Daily stats: ${stats.requestsToday} API calls, ${stats.textsToday} texts processed`
+  );
+  return allScriptalized;
+}
+
+/**
+ * Scriptalisiert einen einzelnen Text
+ * @param {string} text - Text zum Scriptalisieren
+ * @param {string} font - Font-Key (tilda, alva, ellie)
+ * @param {number} errFrequency - Fehlerfrequenz
+ * @returns {Promise<string>} - Scriptalisierter Text
+ */
+async function scriptalizeSingle(text, font = "tilda", errFrequency = 10) {
+  const fontName =
+    config.scriptalizer.fontMap[font.toLowerCase()] ||
+    config.scriptalizer.fontMap.tilda;
+
+  try {
+    const result = await callScriptalizer(text, fontName, errFrequency);
+    return result.outputText;
+  } catch (err) {
+    console.error("Scriptalizer single call failed:", err.message);
+    throw err;
+  }
+}
+
+module.exports = {
+  scriptalizeBatch,
+  scriptalizeSingle,
+  getStats,
+};