@flowselections/floriday-afhandeling-module 1.0.48 → 1.0.52

package/dist-lib/lib/floridayLoading.functions.js

@@ -0,0 +1,339 @@
+// Stap 3 — belading (ladingdragers) samenstellen voor een Floriday fulfillment-opdracht.
+// Bron van karren/regels: Engine `logistics_order_plan_coverage` (ook gedeelde bufferkarren).
+// Vaste kenmerken worden door deze module gemaakt en bewaard in
+// `floriday_loading_identifiers`; de Floriday-koppeling geeft ze ongewijzigd door.
+// Sets: Floriday knipt een set op in losse verkooporders → één regel per onderdeel.
+import { createServerFn } from "@tanstack/react-start";
+import { requireSupabaseAuth } from "../integrations/supabase/auth-middleware";
+const arr = (v) => (Array.isArray(v) ? v : []);
+const num = (v) => v == null || v === "" || !Number.isFinite(Number(v)) ? null : Number(v);
+async function ensureIds(supabase, scope, keys) {
+    const out = new Map();
+    const uniq = [...new Set(keys)];
+    if (!uniq.length)
+        return out;
+    const { error: insErr } = await supabase
+        .from("floriday_loading_identifiers")
+        .upsert(uniq.map((k) => ({ scope, natural_key: k })), { onConflict: "scope,natural_key", ignoreDuplicates: true });
+    if (insErr)
+        throw new Error(insErr.message);
+    const { data, error } = await supabase
+        .from("floriday_loading_identifiers")
+        .select("natural_key, identifier")
+        .eq("scope", scope)
+        .in("natural_key", uniq);
+    if (error)
+        throw new Error(error.message);
+    for (const r of data ?? [])
+        out.set(r.natural_key, r.identifier);
+    for (const k of uniq)
+        if (!out.has(k))
+            throw new Error("Vast kenmerk kon niet worden vastgelegd.");
+    return out;
+}
+// Auto-verwerking (1.0.64) neemt alleen aan; deze statussen betekenen dat de oude
+// route tóch al belading/verzendbrief heeft gedaan → nooit nog eens versturen.
+const AUTO_ALREADY_SENT = new Set(["sending_fulfillment", "generating_delivery_note", "done"]);
+const ACCEPTED = new Set(["created", "already_fulfilled"]);
+async function buildLoading(supabase, orderRef) {
+    if (!orderRef)
+        throw new Error("Geen order opgegeven.");
+    const blockers = [];
+    const loadOrder = async (ref) => {
+        const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(ref);
+        const q = supabase.from("orders").select("id, order_number, order_source, custom_fields, buffer_id").is("deleted_at", null);
+        const { data: row, error } = await (isUuid ? q.eq("id", ref) : q.eq("order_number", ref)).maybeSingle();
+        if (error)
+            throw new Error(error.message);
+        return row;
+    };
+    const coverage = new Map();
+    const queue = [orderRef];
+    const bufferIds = new Set();
+    while (queue.length && coverage.size < 200) {
+        const ref = queue.shift();
+        const o = await loadOrder(ref);
+        if (!o) {
+            blockers.push(`Order ${ref} niet gevonden.`);
+            continue;
+        }
+        if (coverage.has(o.id))
+            continue;
+        const { data: cov, error } = await supabase.rpc("logistics_order_plan_coverage", { p_order_id: o.id });
+        if (error)
+            throw new Error(error.message);
+        const cf = o.custom_fields ?? {};
+        const soId = typeof cf.floriday_sales_order_id === "string" ? cf.floriday_sales_order_id
+            : typeof cf.salesOrderId === "string" ? cf.salesOrderId : null;
+        coverage.set(o.id, { ref: o.order_number ?? o.id, source: o.order_source, salesOrderId: soId, cov: cov ?? {}, bufferId: o.buffer_id });
+        // Andere orders op dezelfde (gedeelde) kar.
+        for (const k of arr(cov?.carts)) {
+            for (const id of arr(k?.orderIds))
+                if (typeof id === "string" && !coverage.has(id))
+                    queue.push(id);
+            for (const r of arr(k?.orderRefs)) {
+                const s2 = String(r);
+                if (![...coverage.values()].some((c) => c.ref === s2))
+                    queue.push(s2);
+            }
+        }
+        // Alle orders van dezelfde buffer (koppeling op buffer-id van de Engine).
+        if (o.buffer_id && !bufferIds.has(o.buffer_id)) {
+            bufferIds.add(o.buffer_id);
+            const { data: sib, error: sErr } = await supabase.from("orders").select("id").eq("buffer_id", o.buffer_id).is("deleted_at", null);
+            if (sErr)
+                throw new Error(sErr.message);
+            for (const s of sib ?? [])
+                if (!coverage.has(s.id))
+                    queue.push(s.id);
+        }
+    }
+    // Gecontroleerd = elke kar van de order is bij de controlebalie afgemeld (scan of "Controle uitvoeren").
+    const orderIds = [...coverage.keys()].sort();
+    // Zelfde regel als Floriday-authenticatie: per Engine-kar (ook gedeeld) een rij in
+    // logistics_control_scan met approved_at gevuld (goedgekeurd op de Scan-controle).
+    const allCartIds = [...new Set([...coverage.values()].flatMap((c) => arr(c.cov.carts).map((k) => k?.cartId).filter((x) => typeof x === "string")))];
+    const approvedCarts = new Set();
+    if (allCartIds.length) {
+        const { data: sc, error } = await supabase
+            .from("logistics_control_scan").select("cart_id").in("cart_id", allCartIds).not("approved_at", "is", null);
+        if (error)
+            throw new Error(error.message);
+        for (const r of sc ?? [])
+            approvedCarts.add(r.cart_id);
+    }
+    // Vaste sleutel voor de opdracht: één buffer → buffer-id, anders de gesorteerde order-id's.
+    // Deterministisch: dubbele klik of herhaling geeft dezelfde fulfillmentOrderId.
+    const bufs = [...new Set([...coverage.values()].map((c) => c.bufferId))];
+    const foKey = bufs.length === 1 && bufs[0] ? `buffer:${bufs[0]}` : orderIds.join("|");
+    const baseFo = orderIds.length ? (await ensureIds(supabase, "fulfillment_order", [foKey])).get(foKey) : null;
+    // Statusoverzicht van Floriday-authenticatie: fulfillmentRequestId + deliveryOrderId per order.
+    const soIds = [...coverage.values()].map((c) => c.salesOrderId).filter((x) => !!x);
+    let status = new Map();
+    let statusFailed = false;
+    try {
+        const { fetchFulfillmentStatus } = await import("./floridayFulfillmentSend.server");
+        status = await fetchFulfillmentStatus(soIds, baseFo ? [baseFo] : []);
+    }
+    catch (e) {
+        statusFailed = true;
+        blockers.push(e instanceof Error ? e.message : "Statusoverzicht ophalen mislukt.");
+    }
+    // Oude auto-verwerking: laatste logregel per order.
+    const autoBySo = new Map();
+    if (soIds.length) {
+        const { data: logs } = await supabase
+            .from("floriday_auto_fulfillment_log")
+            .select("sales_order_id, status, fulfillment_order_id, updated_at")
+            .in("sales_order_id", soIds).order("updated_at", { ascending: false });
+        for (const l of logs ?? [])
+            if (!autoBySo.has(l.sales_order_id))
+                autoBySo.set(l.sales_order_id, { status: l.status, fo: l.fulfillment_order_id });
+    }
+    const orders = [];
+    for (const [id, { ref, salesOrderId, cov }] of coverage) {
+        const cartsTotal = arr(cov.carts).length;
+        const cartIds = arr(cov.carts).map((k) => k?.cartId);
+        const done = cartIds.filter((c) => typeof c === "string" && approvedCarts.has(c)).length;
+        const controlled = cartsTotal > 0 && done === cartsTotal;
+        const st = salesOrderId ? status.get(salesOrderId) : undefined;
+        const fr = st?.fulfillmentRequests ?? [];
+        const auto = salesOrderId ? autoBySo.get(salesOrderId) : undefined;
+        orders.push({
+            orderRef: ref, salesOrderId, pickStatus: cov.pickStatus ?? null, controlled,
+            cartsTotal, cartsControlled: done,
+            deliveryOrderId: fr.length === 1 ? fr[0].deliveryOrderId : null,
+            autoStatus: auto?.status ?? null,
+        });
+        if (!salesOrderId)
+            blockers.push(`Order ${ref} heeft geen Floriday-verkooporder.`);
+        // "Gepickt" = alle karren goedgekeurd op de Scan-controle (logistics_control_scan.approved_at).
+        if (!cartsTotal)
+            blockers.push(`Order ${ref} heeft geen karindeling.`);
+        else if (!controlled)
+            blockers.push(`Order ${ref}: ${done} van ${cartsTotal} karren goedgekeurd op de Scan-controle.`);
+        // Bij een mislukt statusoverzicht geen gevolgfouten per order tonen.
+        if (!statusFailed) {
+            if (salesOrderId && !st)
+                blockers.push(`Order ${ref} staat niet in het statusoverzicht van Floriday.`);
+            if (st && !st.found)
+                blockers.push(`Order ${ref} is niet gevonden in Floriday.`);
+            if (st && st.found && fr.length !== 1)
+                blockers.push(`Order ${ref}: ${fr.length === 0 ? "geen" : "meerdere"} fulfillmentRequest in het statusoverzicht.`);
+            if (fr.length === 1 && !fr[0].deliveryOrderId)
+                blockers.push(`Order ${ref}: nog geen levering (deliveryOrderId) in het statusoverzicht.`);
+        }
+        if (auto && (AUTO_ALREADY_SENT.has(auto.status) || auto.fo))
+            blockers.push(`Order ${ref} is al via de oude auto-verwerking verstuurd (${auto.status}); niet nogmaals versturen.`);
+    }
+    const orderInfo = new Map([...coverage.keys()].map((id, i) => [id, orders[i]]));
+    const carts = new Map();
+    for (const [orderId, { ref, salesOrderId, cov }] of coverage) {
+        const st = salesOrderId ? status.get(salesOrderId) : undefined;
+        const frs = st?.fulfillmentRequests ?? [];
+        arr(cov.carts).forEach((k, ci) => {
+            const cartKey = String(k?.cartId ?? `${orderId}:${ci}`);
+            const c = carts.get(cartKey) ?? { label: String(k?.label ?? k?.cartNumber ?? ci + 1), shared: k?.shared === true, layers: num(k?.additionalLayers ?? k?.numberOfAdditionalLayers), lines: [] };
+            arr(k?.lines).forEach((l, li) => {
+                c.lines.push({
+                    orderId, ref, so: salesOrderId,
+                    key: String(l?.orderItemId ?? l?.lineId ?? l?.salesOrderLineId ?? l?.id ?? li),
+                    packages: num(l?.crates),
+                    frId: frs.length === 1 ? frs[0].fulfillmentRequestId : null,
+                    dl: orderInfo.get(orderId)?.deliveryOrderId ?? null,
+                });
+            });
+            carts.set(cartKey, c);
+        });
+    }
+    const allLines = [...carts.values()].flatMap((c) => c.lines);
+    if (allLines.some((l) => !l.packages || l.packages <= 0))
+        blockers.push("Niet elke regel heeft een aantal fusten van de Engine.");
+    for (const [, c] of carts) {
+        if (new Set(c.lines.map((l) => l.dl ?? "")).size > 1)
+            blockers.push(`Kar ${c.label} bevat orders van verschillende leveringen; één kar kan maar in één opdracht.`);
+    }
+    // Opdrachten per levering. Eén levering → de vaste sleutel van de order of buffer.
+    const deliveries = [...new Set(orders.map((o) => o.deliveryOrderId ?? ""))];
+    const shipKey = (dl) => (deliveries.length <= 1 ? foKey : `${foKey}|${dl}`);
+    const [foIds, lcIds, itemIds] = await Promise.all([
+        ensureIds(supabase, "fulfillment_order", orderIds.length ? deliveries.map(shipKey) : []),
+        ensureIds(supabase, "load_carrier", [...carts.keys()]),
+        ensureIds(supabase, "load_carrier_item", [...carts].flatMap(([ck, c]) => c.lines.map((l) => `${ck}|${l.orderId}|${l.key}`))),
+    ]);
+    const carriers = [...carts].map(([ck, c], i) => ({
+        loadCarrierReference: lcIds.get(ck),
+        cartLabel: c.label,
+        sortIndex: i + 1,
+        additionalLayers: c.layers,
+        shared: c.shared || new Set(c.lines.map((l) => l.orderId)).size > 1,
+        items: c.lines.map((l, j) => ({
+            loadCarrierItemId: itemIds.get(`${ck}|${l.orderId}|${l.key}`),
+            orderRef: l.ref,
+            salesOrderId: l.so,
+            fulfillmentRequestId: l.frId,
+            numberOfPackages: l.packages ?? 0,
+            sortIndex: j + 1,
+        })),
+    }));
+    const cartDl = new Map([...carts].map(([ck, c]) => [lcIds.get(ck), c.lines[0]?.dl ?? ""]));
+    const shipments = orderIds.length ? deliveries.map((dl) => {
+        const os = orders.filter((o) => (o.deliveryOrderId ?? "") === dl);
+        return {
+            fulfillmentOrderId: foIds.get(shipKey(dl)),
+            deliveryOrderId: dl || null,
+            orderRefs: os.map((o) => o.orderRef),
+            salesOrderIds: os.map((o) => o.salesOrderId).filter((x) => !!x),
+            carriers: carriers.filter((c) => (cartDl.get(c.loadCarrierReference) ?? "") === dl),
+            ...(() => {
+                const fo = foIds.get(shipKey(dl));
+                const hit = os.flatMap((o) => (o.salesOrderId ? status.get(o.salesOrderId)?.fulfillmentOrders ?? [] : []))
+                    .find((x) => x.fulfillmentOrderId === fo);
+                return { floridayStatus: hit?.status ?? null, deliveryNoteReady: hit?.deliveryNoteReady ?? null };
+            })(),
+        };
+    }) : [];
+    if (!statusFailed) {
+        for (const ref of new Set(allLines.filter((l) => !l.frId).map((l) => l.ref))) {
+            blockers.push(`Order ${ref}: nog geen fulfillmentRequestId van Floriday.`);
+        }
+    }
+    let lastAttempts = [];
+    if (shipments.length) {
+        const { data: at } = await supabase.from("floriday_loading_attempts")
+            .select("fulfillment_order_id, step, code, message, created_at")
+            .in("fulfillment_order_id", shipments.map((s) => s.fulfillmentOrderId))
+            .order("created_at", { ascending: false }).limit(10);
+        lastAttempts = (at ?? []).map((a) => ({
+            fulfillmentOrderId: a.fulfillment_order_id, step: a.step, code: a.code, message: a.message,
+            createdAt: a.created_at,
+        }));
+    }
+    const uniqBlockers = [...new Set(blockers)];
+    return {
+        fulfillmentOrderId: shipments[0]?.fulfillmentOrderId ?? null,
+        orderRefs: orders.map((o) => o.orderRef),
+        carriers,
+        cartCount: carriers.length,
+        lineCount: carriers.reduce((s2, c) => s2 + c.items.length, 0),
+        orders,
+        shipments,
+        lastAttempts,
+        blockers: uniqBlockers,
+        canSend: uniqBlockers.length === 0 && shipments.length > 0,
+    };
+}
+/** Stelt de belading samen en toont de controles. Verstuurt niets. */
+export const prepareFloridayLoading = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((d) => ({ orderRef: String(d?.orderRef ?? "").trim() }))
+    .handler(async ({ data, context }) => buildLoading(context.supabase, data.orderRef));
+/**
+ * "Nu versturen": bouwt de belading opnieuw op (zelfde vaste kenmerken), controleert
+ * alles nogmaals op de server en verstuurt via fulfillment-order/send. Na acceptatie
+ * (created / already_fulfilled) volgt de verzendbrief via de Logistieke Engine. Elke poging komt in
+ * floriday_loading_attempts. Herhalen gebruikt altijd dezelfde fulfillmentOrderId.
+ */
+export const sendFloridayLoading = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((d) => ({ orderRef: String(d?.orderRef ?? "").trim() }))
+    .handler(async ({ data, context }) => {
+    const supabase = context.supabase;
+    const p = await buildLoading(supabase, data.orderRef);
+    if (!p.canSend)
+        throw new Error(`Niet verstuurd: ${p.blockers.join(" ") || "geen opdracht."}`);
+    const { sendFulfillmentOrder } = await import("./floridayFulfillmentSend.server");
+    const log = async (s, row) => {
+        const { error } = await supabase.from("floriday_loading_attempts").insert({
+            fulfillment_order_id: s.fulfillmentOrderId, delivery_order_id: s.deliveryOrderId,
+            sales_order_ids: s.salesOrderIds, order_refs: s.orderRefs, created_by: context.userId, ...row,
+        });
+        if (error)
+            console.warn("[belading] log mislukt", error.message);
+    };
+    const results = [];
+    for (const s of p.shipments) {
+        const payload = {
+            deliveryOrderId: s.deliveryOrderId,
+            fulfillmentOrderId: s.fulfillmentOrderId,
+            loadCarriers: s.carriers.map((c) => ({
+                loadCarrierReference: c.loadCarrierReference,
+                sortIndex: c.sortIndex,
+                // Floriday 2026v1 AddLoadCarrierConfiguration: alleen meesturen als de Engine het kent.
+                ...(c.additionalLayers != null ? { numberOfAdditionalLayers: c.additionalLayers } : {}),
+                items: c.items.map((it) => ({
+                    fulfillmentRequestId: it.fulfillmentRequestId,
+                    loadCarrierItemId: it.loadCarrierItemId,
+                    numberOfPackages: it.numberOfPackages,
+                    sortIndex: it.sortIndex,
+                })),
+            })),
+        };
+        const summary = { carts: s.carriers.length, lines: s.carriers.reduce((n, c) => n + c.items.length, 0) };
+        let httpStatus = null;
+        let body = null;
+        try {
+            const r = await sendFulfillmentOrder(payload);
+            httpStatus = r.httpStatus;
+            body = r.body;
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            await log(s, { step: "send", code: "no_response", message: `Uitkomst onbekend: ${msg}. Opnieuw proberen gebruikt dezelfde opdracht.`, request_summary: summary });
+            results.push({ fulfillmentOrderId: s.fulfillmentOrderId, code: "no_response", httpStatus: null, message: msg, deliveryNote: "—" });
+            continue;
+        }
+        const code = String(body?.code ?? (httpStatus && httpStatus < 400 ? "ok" : `http_${httpStatus}`));
+        const accepted = httpStatus === 200 && body?.ok === true && ACCEPTED.has(code);
+        const message = accepted ? (code === "created" ? "Belading verstuurd, verzendbrief volgt via de Engine." : "Belading was al verstuurd (niets dubbel aangemaakt), verzendbrief volgt via de Engine.")
+            : arr(body?.errors).map((e) => (typeof e === "string" ? e : e?.message ?? JSON.stringify(e))).join("; ") || body?.message || code;
+        await log(s, {
+            step: "send", http_status: httpStatus, code, message,
+            warnings: arr(body?.warnings), skipped_requests: arr(body?.skippedRequests), request_summary: summary,
+        });
+        // Verzendbrief: eigendom van de Logistieke Engine (runPdf delivery-note + herhalingen).
+        const deliveryNote = accepted ? "volgt via de Engine" : "—";
+        results.push({ fulfillmentOrderId: s.fulfillmentOrderId, code, httpStatus, message, deliveryNote });
+    }
+    return { ok: results.every((r) => ACCEPTED.has(r.code)), results };
+});

package/dist-lib/lib/orderFulfilment.functions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orderFulfilment.functions.d.ts","sourceRoot":"","sources":["../../src/lib/orderFulfilment.functions.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,qBAAqB;IACpC,oEAAoE;IACpE,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,sBAAsB;IACrC,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;;;;8CAEH,qBAAqB;;mCAsB3C,CAAC"}
+{"version":3,"file":"orderFulfilment.functions.d.ts","sourceRoot":"","sources":["../../src/lib/orderFulfilment.functions.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,qBAAqB;IACpC,oEAAoE;IACpE,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,sBAAsB;IACrC,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;;;;8CAEH,qBAAqB;;mCAoC3C,CAAC"}

package/dist-lib/lib/orderFulfilment.functions.js

@@ -17,6 +17,23 @@ export const markOrderShipped = createServerFn({ method: "POST" })
 })
     .handler(async ({ data, context }) => {
     const { supabase } = context;
+    // Floriday-orders: "Verzonden" pas nadat Floriday de belading heeft geaccepteerd.
+    const { data: ord, error: oErr } = await supabase
+        .from("orders").select("id, order_source").eq("order_number", data.orderRef).is("deleted_at", null).maybeSingle();
+    if (oErr)
+        throw new Error(oErr.message);
+    if (!ord)
+        throw new Error(`Bestelling ${data.orderRef} niet gevonden in de orderadministratie.`);
+    if (ord.order_source === "floriday") {
+        const { data: acc, error: aErr } = await supabase
+            .from("floriday_loading_attempts").select("id")
+            .contains("order_refs", [data.orderRef]).in("code", ["created", "already_fulfilled"]).limit(1);
+        if (aErr)
+            throw new Error(aErr.message);
+        if (!acc?.length) {
+            throw new Error(`${data.orderRef}: nog niet door Floriday geaccepteerd. Verstuur eerst de belading met "Nu versturen".`);
+        }
+    }
     const { data: rows, error } = await supabase
         .from("orders")
         .update({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowselections/floriday-afhandeling-module",
-  "version": "1.0.48",
+  "version": "1.0.52",
   "private": false,
   "sideEffects": false,
   "type": "module",
@@ -49,7 +49,7 @@
     "@cloudflare/vite-plugin": "^1.25.5",
     "@eslint/js": "^9.32.0",
     "@flowselections/core": "1.0.29",
-    "@lovable.dev/vite-tanstack-config": "2.23.1",
+    "@lovable.dev/vite-tanstack-config": "2.25.3",
     "@rsbuild/core": "^1.0.0",
     "@tailwindcss/vite": "^4.2.1",
     "@tanstack/react-query": "^5.83.0",