实现报销材料连续预览（07-27-yang-jun-reimbursement-readiness）

server/src/services/invoiceDocumentMeta.js

@@ -0,0 +1,22 @@
+const SAFE_DOCUMENT_CATEGORIES = new Set([
+  "vat_invoice",
+  "full_vat_invoice",
+  "electronic_train_ticket",
+]);
+
+function normalizeSafeMetaString(value, maxLength = 64) {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim();
+  return normalized ? normalized.slice(0, maxLength) : null;
+}
+
+function mapInvoiceDocumentMeta(invoice) {
+  const result = invoice?.ocr_result?.result_json;
+  const category = normalizeSafeMetaString(result?.documentCategory);
+  return {
+    documentCategory: SAFE_DOCUMENT_CATEGORIES.has(category) ? category : null,
+    documentSubtype: normalizeSafeMetaString(result?.documentSubtype),
+  };
+}
+
+module.exports = { mapInvoiceDocumentMeta };

server/src/services/reimbursementMaterialPreview.js

@@ -0,0 +1,210 @@
+const crypto = require("node:crypto");
+const fs = require("node:fs/promises");
+const os = require("node:os");
+const path = require("node:path");
+const { promisify } = require("node:util");
+const { execFile } = require("node:child_process");
+const sharp = require("sharp");
+
+const execFileAsync = promisify(execFile);
+
+const MATERIAL_PREVIEW_LIMITS = Object.freeze({
+  maxMaterials: 20,
+  maxSourceBytes: 50 * 1024 * 1024,
+  maxPages: 40,
+  maxPageWidth: 1800,
+  maxPagePixels: 40_000_000,
+  maxOutputBytes: 40 * 1024 * 1024,
+  maxCacheBytes: 80 * 1024 * 1024,
+  rasterDpi: 144,
+  rasterTimeoutMs: 20_000,
+});
+
+class MaterialPreviewError extends Error {
+  constructor(code) {
+    super(code);
+    this.name = "MaterialPreviewError";
+    this.code = code;
+  }
+}
+
+function pageNumberFromName(fileName) {
+  const matched = fileName.match(/-(\d+)\.png$/i);
+  return matched ? Number(matched[1]) : Number.MAX_SAFE_INTEGER;
+}
+
+async function normalizePreviewImage(buffer, limits = MATERIAL_PREVIEW_LIMITS) {
+  try {
+    return await sharp(buffer, { failOn: "error", limitInputPixels: limits.maxPagePixels })
+      .rotate()
+      .resize({ width: limits.maxPageWidth, withoutEnlargement: true })
+      .png({ compressionLevel: 8, adaptiveFiltering: true })
+      .toBuffer();
+  } catch {
+    throw new MaterialPreviewError("material_preview_image_invalid");
+  }
+}
+
+async function rasterizePdfWithPoppler(buffer, limits = MATERIAL_PREVIEW_LIMITS) {
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "hyb-oa-material-preview-"));
+  const sourcePath = path.join(tempDir, "source.pdf");
+  const outputPrefix = path.join(tempDir, "page");
+
+  try {
+    await fs.writeFile(sourcePath, buffer, { flag: "wx" });
+    try {
+      await execFileAsync(
+        "pdftoppm",
+        [
+          "-png",
+          "-r",
+          String(limits.rasterDpi),
+          "-f",
+          "1",
+          "-l",
+          String(limits.maxPages + 1),
+          "-scale-to-x",
+          String(limits.maxPageWidth),
+          "-scale-to-y",
+          "-1",
+          sourcePath,
+          outputPrefix,
+        ],
+        {
+          timeout: limits.rasterTimeoutMs,
+          maxBuffer: 1024 * 1024,
+          windowsHide: true,
+        },
+      );
+    } catch (error) {
+      if (error?.code === "ENOENT") {
+        throw new MaterialPreviewError("material_preview_rasterizer_unavailable");
+      }
+      if (error?.killed || error?.signal) {
+        throw new MaterialPreviewError("material_preview_raster_timeout");
+      }
+      throw new MaterialPreviewError("material_preview_pdf_invalid");
+    }
+
+    const fileNames = (await fs.readdir(tempDir))
+      .filter((fileName) => /^page-\d+\.png$/i.test(fileName))
+      .sort((left, right) => pageNumberFromName(left) - pageNumberFromName(right));
+    if (!fileNames.length) {
+      throw new MaterialPreviewError("material_preview_pdf_empty");
+    }
+
+    const pages = [];
+    for (const fileName of fileNames) {
+      pages.push(await normalizePreviewImage(await fs.readFile(path.join(tempDir, fileName)), limits));
+    }
+    return pages;
+  } finally {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  }
+}
+
+function createReimbursementMaterialPreviewStore(options = {}) {
+  const limits = { ...MATERIAL_PREVIEW_LIMITS, ...(options.limits ?? {}) };
+  const rasterizePdf = options.rasterizePdf ?? ((buffer) => rasterizePdfWithPoppler(buffer, limits));
+  const normalizeImage = options.normalizeImage ?? ((buffer) => normalizePreviewImage(buffer, limits));
+  const now = options.now ?? (() => Date.now());
+  const randomUUID = options.randomUUID ?? (() => crypto.randomUUID());
+  const bundles = new Map();
+  let cachedBytes = 0;
+
+  function deleteBundle(bundleId) {
+    const bundle = bundles.get(bundleId);
+    if (!bundle) return;
+    cachedBytes -= bundle.outputBytes;
+    bundles.delete(bundleId);
+  }
+
+  function pruneExpired() {
+    const current = now();
+    for (const [bundleId, bundle] of bundles) {
+      if (bundle.expiresAt <= current) deleteBundle(bundleId);
+    }
+  }
+
+  async function createBundle({ actorId, reimbursementId, materials, expiresAt, readSource }) {
+    pruneExpired();
+    if (!Array.isArray(materials) || materials.length === 0) {
+      throw new MaterialPreviewError("material_preview_empty");
+    }
+    if (materials.length > limits.maxMaterials) {
+      throw new MaterialPreviewError("material_preview_material_limit");
+    }
+    const sourceBytes = materials.reduce((sum, material) => sum + Number(material.fileSize ?? 0), 0);
+    if (!Number.isSafeInteger(sourceBytes) || sourceBytes <= 0 || sourceBytes > limits.maxSourceBytes) {
+      throw new MaterialPreviewError("material_preview_source_size_limit");
+    }
+
+    const pages = [];
+    let outputBytes = 0;
+    let actualSourceBytes = 0;
+    for (const material of materials) {
+      const source = await readSource(material);
+      if (!Buffer.isBuffer(source) || source.length === 0) {
+        throw new MaterialPreviewError("material_preview_source_missing");
+      }
+      actualSourceBytes += source.length;
+      if (actualSourceBytes > limits.maxSourceBytes) {
+        throw new MaterialPreviewError("material_preview_source_size_limit");
+      }
+      const renderedPages = material.mimeType === "application/pdf"
+        ? await rasterizePdf(source)
+        : [await normalizeImage(source)];
+      for (let index = 0; index < renderedPages.length; index += 1) {
+        if (pages.length >= limits.maxPages) {
+          throw new MaterialPreviewError("material_preview_page_limit");
+        }
+        const image = renderedPages[index];
+        outputBytes += image.length;
+        if (outputBytes > limits.maxOutputBytes) {
+          throw new MaterialPreviewError("material_preview_output_size_limit");
+        }
+        pages.push({
+          buffer: image,
+          materialId: material.id,
+          materialType: material.materialType,
+          materialIndex: material.materialIndex,
+          pageNumber: index + 1,
+        });
+      }
+    }
+
+    if (cachedBytes + outputBytes > limits.maxCacheBytes) {
+      pruneExpired();
+      if (cachedBytes + outputBytes > limits.maxCacheBytes) {
+        throw new MaterialPreviewError("material_preview_cache_limit");
+      }
+    }
+
+    const bundleId = randomUUID();
+    const bundle = { actorId, reimbursementId, expiresAt, outputBytes, pages };
+    bundles.set(bundleId, bundle);
+    cachedBytes += outputBytes;
+    const timer = setTimeout(() => deleteBundle(bundleId), Math.max(1, expiresAt - now()));
+    timer.unref?.();
+    return { bundleId, bundle };
+  }
+
+  function getPage({ bundleId, pageIndex }) {
+    pruneExpired();
+    const bundle = bundles.get(bundleId);
+    if (!bundle || !Number.isInteger(pageIndex) || pageIndex < 0 || pageIndex >= bundle.pages.length) {
+      return null;
+    }
+    return { bundle, page: bundle.pages[pageIndex] };
+  }
+
+  return { createBundle, getPage, deleteBundle };
+}
+
+module.exports = {
+  MATERIAL_PREVIEW_LIMITS,
+  MaterialPreviewError,
+  createReimbursementMaterialPreviewStore,
+  normalizePreviewImage,
+  rasterizePdfWithPoppler,
+};