@flowselections/floriday-verkoop-module 1.0.55 → 1.0.57

package/dist-lib/lib/floriday-logistic-labels.functions.js

@@ -1,12 +1,32 @@
-// Server functions for Floriday logistic labels (afleverbrieven).
-// - Lazy fetch: PDF's worden opgehaald zodra iemand ze opent in de UI.
-// - Cache in Supabase Storage bucket "floriday-logistic-labels" (private).
-// - Metadata upsert in floriday_logistic_labels_cache.
+// Server functions voor afleverbrieven.
+//
+// Eén waarheid: public.delivery_notes. Elke afleverbrief hangt daar aan onze
+// eigen order (order_id + order_number, bijv. FO-2600033), ongeacht herkomst:
+//   - source 'floriday' : PDF opgehaald bij Floriday
+//     GET /fulfillment-orders/{fulfillmentOrderId}/logistic-labels  → één PDF
+//     per fulfillment order; die PDF hoort bij álle codes van die order.
+//   - source 'engine'   : PDF gegenereerd door onze logistieke engine
+//     (HO/handmatige en MO/mail-bestellingen) via registerDeliveryNote().
+//
+// PDF's staan in de private bucket "delivery-notes"; de UI krijgt een
+// signed URL. Fouten worden NIET stil geslikt: statuscode + leesbare tekst
+// komen mee naar de UI (423 = levering nog in concept, 404 = niet gevonden).
 import { createServerFn } from "@tanstack/react-start";
 import { z } from "zod";
 import { requireSupabaseAuth } from "../integrations/supabase/auth-middleware";
-import { apiBaseFor } from "./floriday-gateway.server";
-const BUCKET = "floriday-logistic-labels";
+import { florydayFetchBinary } from "./floriday-gateway.server";
+import { resolveOrderRow } from "./order-row.server";
+const BUCKET = "delivery-notes";
+function foutTekst(status, detail) {
+    if (status === 423) {
+        return "Levering staat nog in concept — bevestig de levering in Floriday, daarna is de afleverbrief beschikbaar.";
+    }
+    if (status === 404)
+        return "Afleverbrief niet gevonden bij Floriday (404).";
+    if (status === 401 || status === 403)
+        return `Geen toegang tot Floriday (${status}).`;
+    return `Ophalen bij Floriday mislukt (${status})${detail ? `: ${detail}` : ""}.`;
+}
 async function collectRefsForOrder(supabase, salesOrderId) {
     const { data, error } = await supabase
         .from("floriday_fulfillment_orders_cache")
@@ -14,7 +34,6 @@ async function collectRefsForOrder(supabase, salesOrderId) {
         .eq("is_deleted", false);
     if (error)
         throw new Error(`fulfillment orders lezen faalde: ${error.message}`);
-    // env per connection
     const connIds = Array.from(new Set((data ?? []).map((r) => r.connection_id).filter(Boolean)));
     const envByConn = new Map();
     if (connIds.length > 0) {
@@ -50,7 +69,6 @@ async function collectRefsForOrder(supabase, salesOrderId) {
             });
         }
     }
-    // dedupe on (fulfillmentOrderId, code) — keep first
     const seen = new Set();
     return refs.filter((r) => {
         const k = `${r.fulfillmentOrderId}:${r.code}`;
@@ -60,45 +78,29 @@ async function collectRefsForOrder(supabase, salesOrderId) {
         return true;
     });
 }
-async function fetchPdfFromFloriday(supabase, ref) {
+/** Haalt de gecombineerde PDF van één fulfillment order op bij Floriday. */
+async function fetchPdfForFulfillmentOrder(supabase, connectionId, fulfillmentOrderId) {
     const { data: conn, error } = await supabase
         .from("floriday_connections")
         .select("id, environment, api_key")
-        .eq("id", ref.connectionId)
+        .eq("id", connectionId)
         .maybeSingle();
     if (error || !conn) {
-        return { ok: false, status: 0, error: `connectie ${ref.connectionId} niet gevonden` };
+        return { ok: false, status: 0, error: `Floriday-connectie ${connectionId} niet gevonden.` };
     }
-    // Eigen central-call: elke resource haalt haar eigen vers token op.
-    const { getFlorydayTokenFromCentral } = await import("./floriday-central-token.server");
-    const tokenRes = await getFlorydayTokenFromCentral(conn.environment ?? "staging");
-    if (!tokenRes.ok) {
-        return {
-            ok: false,
-            status: tokenRes.status,
-            error: `central token faalde: ${tokenRes.raw.slice(0, 200)}`,
-        };
-    }
-    const base = apiBaseFor(conn.environment);
-    // Floriday endpoint: GET /logistic-labels/{fulfillmentOrderId}/{code} → application/pdf
-    const url = `${base}/logistic-labels/${encodeURIComponent(ref.fulfillmentOrderId)}/${encodeURIComponent(ref.code)}`;
-    const res = await fetch(url, {
+    const res = await florydayFetchBinary(supabase, conn, {
         method: "GET",
-        headers: {
-            Accept: "application/pdf",
-            Authorization: `Bearer ${tokenRes.access_token}`,
-            ...(conn.api_key ? { "x-api-key": conn.api_key } : {}),
-        },
+        path: `/fulfillment-orders/${encodeURIComponent(fulfillmentOrderId)}/logistic-labels`,
+        accept: "application/pdf",
     });
     if (!res.ok) {
-        return { ok: false, status: res.status, error: `Floriday ${res.status}` };
+        return { ok: false, status: res.status, error: foutTekst(res.status, res.rawText) };
     }
-    const buf = new Uint8Array(await res.arrayBuffer());
     return {
         ok: true,
         status: res.status,
-        bytes: buf,
-        contentType: res.headers.get("content-type") ?? "application/pdf",
+        bytes: res.bytes ?? undefined,
+        contentType: res.contentType ?? "application/pdf",
     };
 }
 const ListSchema = z.object({ salesOrderId: z.string().min(1) });
@@ -107,75 +109,192 @@ export const listLogisticLabelsForOrder = createServerFn({ method: "POST" })
     .inputValidator((d) => ListSchema.parse(d))
     .handler(async ({ data, context }) => {
     const supabase = context.supabase;
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    // 1. Onze eigen order erbij zoeken (lokaal ordernummer koppelen).
+    let orderId = null;
+    let orderNumber = null;
+    try {
+        const row = await resolveOrderRow(supabase, data.salesOrderId);
+        orderId = row.id;
+        orderNumber = row.order_number;
+    }
+    catch {
+        /* order (nog) niet bekend — brief blijft dan zonder koppeling */
+    }
+    // 2. Al opgeslagen briefjes bij deze order.
+    const stored = new Map();
+    if (orderId) {
+        const { data: rows } = await supabase
+            .from("delivery_notes")
+            .select("*")
+            .eq("order_id", orderId);
+        for (const r of rows ?? []) {
+            stored.set(`${r.source}:${r.fulfillment_order_id ?? ""}:${r.label_code ?? ""}`, r);
+        }
+    }
+    // 3. Floriday-referenties bepalen en per fulfillment order één keer ophalen.
     const refs = await collectRefsForOrder(supabase, data.salesOrderId);
-    if (refs.length === 0)
-        return { labels: [] };
-    // Load existing cache rows
-    const keys = refs.map((r) => ({ fo: r.fulfillmentOrderId, code: r.code }));
-    const { data: cacheRows } = await supabase
-        .from("floriday_logistic_labels_cache")
-        .select("fulfillment_order_id, logistic_label_code, storage_path, content_type, byte_size")
-        .in("fulfillment_order_id", Array.from(new Set(keys.map((k) => k.fo))));
-    const cacheMap = new Map();
-    for (const c of cacheRows ?? []) {
-        cacheMap.set(`${c.fulfillment_order_id}:${c.logistic_label_code}`, c);
+    const perFo = new Map();
+    for (const ref of refs) {
+        const key = `floriday:${ref.fulfillmentOrderId}:${ref.code}`;
+        const existing = stored.get(key);
+        if (existing?.storage_path)
+            continue; // al gecached
+        if (perFo.has(ref.fulfillmentOrderId))
+            continue; // deze order al geprobeerd
+        const res = await fetchPdfForFulfillmentOrder(supabase, ref.connectionId, ref.fulfillmentOrderId);
+        if (!res.ok || !res.bytes) {
+            perFo.set(ref.fulfillmentOrderId, { ok: false, status: res.status, error: res.error });
+            continue;
+        }
+        const path = `floriday/${ref.connectionId}/${ref.fulfillmentOrderId}.pdf`;
+        const { error: upErr } = await supabaseAdmin.storage.from(BUCKET).upload(path, res.bytes, {
+            contentType: res.contentType ?? "application/pdf",
+            upsert: true,
+        });
+        if (upErr) {
+            perFo.set(ref.fulfillmentOrderId, { ok: false, status: 0, error: `Opslaan van de PDF mislukt: ${upErr.message}` });
+            continue;
+        }
+        perFo.set(ref.fulfillmentOrderId, {
+            ok: true,
+            status: res.status,
+            storagePath: path,
+            contentType: res.contentType ?? "application/pdf",
+            byteSize: res.bytes.byteLength,
+        });
     }
-    // For refs without cache row → fetch PDF now (lazy) using service role client.
-    const missing = refs.filter((r) => !cacheMap.get(`${r.fulfillmentOrderId}:${r.code}`));
-    if (missing.length > 0) {
-        const { supabaseAdmin } = await import("../integrations/supabase/client.server");
-        for (const ref of missing) {
-            const res = await fetchPdfFromFloriday(supabase, ref);
-            if (!res.ok || !res.bytes)
-                continue; // silently skip; label may not be ready yet
-            const path = `${ref.connectionId}/${ref.fulfillmentOrderId}/${ref.code}.pdf`;
-            const { error: upErr } = await supabaseAdmin.storage
-                .from(BUCKET)
-                .upload(path, res.bytes, {
-                contentType: res.contentType ?? "application/pdf",
-                upsert: true,
-            });
-            if (upErr)
-                continue;
-            const row = {
-                connection_id: ref.connectionId,
-                fulfillment_order_id: ref.fulfillmentOrderId,
-                logistic_label_code: ref.code,
-                storage_path: path,
-                content_type: res.contentType ?? "application/pdf",
-                byte_size: res.bytes.byteLength,
+    // 4. delivery_notes bijwerken per code (dus per afleverbrief-regel).
+    for (const ref of refs) {
+        const key = `floriday:${ref.fulfillmentOrderId}:${ref.code}`;
+        const fetched = perFo.get(ref.fulfillmentOrderId);
+        const existing = stored.get(key);
+        const row = {
+            order_id: orderId,
+            order_number: orderNumber,
+            source: "floriday",
+            connection_id: ref.connectionId,
+            fulfillment_order_id: ref.fulfillmentOrderId,
+            label_code: ref.code,
+            letter: ref.letter,
+            load_carrier_index: ref.loadCarrierIndex,
+            load_carrier_type: ref.loadCarrierType,
+            packages: ref.packages,
+            storage_bucket: BUCKET,
+        };
+        if (fetched?.ok) {
+            Object.assign(row, {
+                storage_path: fetched.storagePath,
+                content_type: fetched.contentType,
+                byte_size: fetched.byteSize,
+                status: "available",
+                http_status: fetched.status,
+                error_message: null,
                 fetched_at: new Date().toISOString(),
-            };
-            await supabaseAdmin
-                .from("floriday_logistic_labels_cache")
-                .upsert(row, { onConflict: "fulfillment_order_id,logistic_label_code" });
-            cacheMap.set(`${ref.fulfillmentOrderId}:${ref.code}`, row);
+            });
+        }
+        else if (fetched) {
+            Object.assign(row, {
+                storage_path: existing?.storage_path ?? null,
+                status: existing?.storage_path ? "available" : "error",
+                http_status: fetched.status,
+                error_message: fetched.error ?? null,
+            });
+        }
+        else if (existing) {
+            Object.assign(row, {
+                storage_path: existing.storage_path,
+                content_type: existing.content_type,
+                byte_size: existing.byte_size,
+                status: "available",
+            });
         }
+        const { data: saved } = await supabaseAdmin
+            .from("delivery_notes")
+            .upsert(row, { onConflict: "fulfillment_order_id,label_code" })
+            .select("*")
+            .maybeSingle();
+        stored.set(key, saved ?? { ...existing, ...row });
     }
-    // Build signed URLs and result
-    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    // 5. Resultaat opbouwen (Floriday + engine-brieven van deze order).
     const labels = [];
-    for (const ref of refs) {
-        const cache = cacheMap.get(`${ref.fulfillmentOrderId}:${ref.code}`);
+    for (const r of stored.values()) {
         let signedUrl = null;
-        if (cache?.storage_path) {
+        if (r.storage_path) {
             const { data: signed } = await supabaseAdmin.storage
-                .from(BUCKET)
-                .createSignedUrl(cache.storage_path, 600);
+                .from(r.storage_bucket ?? BUCKET)
+                .createSignedUrl(r.storage_path, 600);
             signedUrl = signed?.signedUrl ?? null;
         }
         labels.push({
-            code: ref.code,
-            letter: ref.letter,
-            loadCarrierIndex: ref.loadCarrierIndex,
-            loadCarrierType: ref.loadCarrierType,
-            packages: ref.packages,
-            fulfillmentOrderId: ref.fulfillmentOrderId,
+            source: (r.source ?? "floriday"),
+            code: r.label_code ?? null,
+            letter: r.letter ?? null,
+            loadCarrierIndex: Number(r.load_carrier_index ?? 0),
+            loadCarrierType: r.load_carrier_type ?? null,
+            packages: Number(r.packages ?? 0),
+            fulfillmentOrderId: r.fulfillment_order_id ?? null,
+            orderNumber: r.order_number ?? orderNumber,
             hasPdf: !!signedUrl,
             signedUrl,
+            status: signedUrl ? "available" : (r.status ?? "pending"),
+            httpStatus: r.http_status ?? null,
+            errorMessage: signedUrl ? null : (r.error_message ?? null),
         });
     }
-    labels.sort((a, b) => a.loadCarrierIndex - b.loadCarrierIndex ||
-        (a.letter ?? "").localeCompare(b.letter ?? ""));
-    return { labels };
+    labels.sort((a, b) => a.loadCarrierIndex - b.loadCarrierIndex || (a.letter ?? "").localeCompare(b.letter ?? ""));
+    return { labels, orderNumber };
+});
+/**
+ * Registreert een afleverbrief die buiten Floriday is gemaakt
+ * (HO/handmatige en MO/mail-bestellingen, gegenereerd door de logistieke engine).
+ * De PDF wordt in dezelfde bucket opgeslagen en aan ons ordernummer gekoppeld.
+ */
+const RegisterSchema = z.object({
+    orderId: z.string().min(1),
+    pdfBase64: z.string().min(1),
+    code: z.string().min(1).optional(),
+    letter: z.string().optional(),
+    loadCarrierIndex: z.number().int().optional(),
+    loadCarrierType: z.string().optional(),
+    packages: z.number().int().optional(),
+});
+export const registerDeliveryNote = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((d) => RegisterSchema.parse(d))
+    .handler(async ({ data, context }) => {
+    const supabase = context.supabase;
+    const order = await resolveOrderRow(supabase, data.orderId);
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    const binair = atob(data.pdfBase64);
+    const bytes = new Uint8Array(binair.length);
+    for (let i = 0; i < binair.length; i++)
+        bytes[i] = binair.charCodeAt(i);
+    const code = data.code ?? order.order_number ?? order.id;
+    const path = `engine/${order.id}/${code}.pdf`;
+    const { error: upErr } = await supabaseAdmin.storage.from(BUCKET).upload(path, bytes, {
+        contentType: "application/pdf",
+        upsert: true,
+    });
+    if (upErr)
+        throw new Error(`Opslaan van de afleverbrief mislukt: ${upErr.message}`);
+    const { error } = await supabaseAdmin.from("delivery_notes").insert({
+        order_id: order.id,
+        order_number: order.order_number,
+        source: "engine",
+        label_code: code,
+        letter: data.letter ?? null,
+        load_carrier_index: data.loadCarrierIndex ?? 0,
+        load_carrier_type: data.loadCarrierType ?? null,
+        packages: data.packages ?? 0,
+        storage_bucket: BUCKET,
+        storage_path: path,
+        content_type: "application/pdf",
+        byte_size: bytes.byteLength,
+        status: "available",
+        fetched_at: new Date().toISOString(),
+    });
+    if (error)
+        throw new Error(`Afleverbrief opslaan mislukt: ${error.message}`);
+    return { ok: true, orderNumber: order.order_number, storagePath: path };
 });