@flowselections/floriday-verkoop-module 1.0.60 → 1.0.61

package/dist-lib/lib/floriday-mirror.functions.js

@@ -81,8 +81,9 @@ async function mirrorInternal(limit) {
     }
     const { data: existing } = await supabaseAdmin
         .from("orders")
-        .select("id, floriday_sales_order_id, updated_at, custom_fields, status")
-        .in("floriday_sales_order_id", foIds);
+        .select("id, order_number, floriday_sales_order_id, floriday_order_group_key, updated_at, custom_fields, status, plan_locked_at, buffer_id")
+        .in("floriday_sales_order_id", foIds)
+        .is("deleted_at", null);
     const existingByFoId = new Map();
     for (const o of existing ?? []) {
         existingByFoId.set(String(o.floriday_sales_order_id), o);
@@ -143,23 +144,38 @@ async function mirrorInternal(limit) {
     let inserted = 0, updated = 0, skipped = 0, failed = 0;
     const errors = [];
     const affectedOrderIds = [];
-    for (const row of rows) {
+    // Statusmapping Floriday -> onze pickstatus. "gemeten" = feitelijk
+    // aangetroffen in floriday_salesorders_cache; "uit code" = staat wel in de
+    // Floriday-types/onze code, maar is nooit in de data gezien.
+    const FLORIDAY_STATUS_MAP = {
+        open: "Nog te picken", // uit code
+        new: "Nog te picken", // uit code
+        nieuw: "Nog te picken", // uit code
+        committed: "Nog te picken", // GEMETEN
+        confirmed: "Nog te picken", // uit code
+        accepted: "Nog te picken", // uit code
+        processing: "Nog te picken", // uit code
+        shipped: "Nog te picken", // uit code — Floriday-shipped is voor ons geen
+        delivered: "Nog te picken", // uit code — bewijs van vertrek; de karren-/
+        // shipmentroute bepaalt onze "Verzonden".
+        pending: "Nog te picken", // uit code
+        cancelled: "geannuleerd", // uit code
+        canceled: "geannuleerd", // uit code
+        rejected: "geannuleerd", // uit code
+        expired: "geannuleerd", // uit code
+        unfulfillable: "geannuleerd", // uit code
+    };
+    /** Eén Floriday-verkooporder = één toekomstige orderregel. */
+    function buildLine(row) {
         const foId = String(row.floriday_id);
         const d = row.data ?? {};
         const orgId = String(d?.customerOrganizationId ?? "");
         const cust = customerByOrgId.get(orgId);
         const floCust = floCustByOrgId.get(orgId) ?? {};
-        const customerName = cust?.name ??
-            floCust?.commercialName ??
-            floCust?.name ??
-            "Onbekende klant";
+        const customerName = cust?.name ?? floCust?.commercialName ?? floCust?.name ?? "Onbekende klant";
         const delivery = d?.delivery ?? {};
         const deliveryIso = delivery?.latestDeliveryDateTime ?? "";
         const orderDateIso = d?.orderDateTime ?? d?.creationDateTime ?? new Date().toISOString();
-        // Uitsluitend uit de map: dat nummer is het ERP-nummer dat overal (lijst,
-        // detail, pickstation) getoond wordt. Ontbreekt het, dan slaan we de order
-        // over — nooit zelf een nummer verzinnen.
-        const orderNumber = orderNumberByFoId.get(foId) ?? null;
         const pickupLocation = pickString(d?.despatchWarehouseId ?? delivery?.pickupLocation);
         const deliveryLocation = pickString(delivery?.location?.gln ??
             delivery?.locationGln ??
@@ -196,126 +212,280 @@ async function mirrorInternal(limit) {
             ? Boolean(ff.received) || isFullyFulfilled(ff, expectedPackagesFromSalesOrder(d))
             : false;
         const rawStatus = String(d?.status ?? "").toLowerCase() || "open";
-        // Statusmapping Floriday -> onze pickstatus.
-        // "gemeten" = feitelijk aangetroffen in floriday_salesorders_cache (meting
-        // 2026-08-25: 1143 van 1143 rijen COMMITTED). "uit code" = staat wel in de
-        // Floriday-types/onze code, maar is nooit in de data gezien; daar houdt de
-        // zekerheid op.
-        const FLORIDAY_STATUS_MAP = {
-            open: "Nog te picken", // uit code
-            new: "Nog te picken", // uit code
-            nieuw: "Nog te picken", // uit code
-            committed: "Nog te picken", // GEMETEN (1143/1143)
-            confirmed: "Nog te picken", // uit code
-            accepted: "Nog te picken", // uit code
-            processing: "Nog te picken", // uit code
-            shipped: "Nog te picken", // uit code — Floriday-shipped is voor ons geen
-            delivered: "Nog te picken", // uit code — bewijs van vertrek; de karren-/
-            // shipmentroute bepaalt onze "Verzonden".
-            pending: "Nog te picken", // uit code
-            cancelled: "geannuleerd", // uit code
-            canceled: "geannuleerd", // uit code
-            rejected: "geannuleerd", // uit code
-            expired: "geannuleerd", // uit code
-            unfulfillable: "geannuleerd", // uit code
-        };
         const mapped = FLORIDAY_STATUS_MAP[rawStatus];
         if (!mapped) {
-            // Nooit stilzwijgend doorzetten: een onbekende waarde kan anders de
-            // consumptietrigger raken. Loggen met ruwe waarde zodat we hem kunnen
-            // toevoegen aan de mapping.
             console.warn(`[floriday-mirror] onbekende Floriday-status "${rawStatus}" voor order ${foId} — val terug op "Nog te picken"`);
         }
-        // fullyFulfilled betekent in Floriday alleen dat de beladingindeling is
-        // doorgegeven; niet dat de order de kwekerij heeft verlaten. Daarom raakt
-        // het de orderstatus niet meer, alleen custom_fields.
         const status = mapped ?? "Nog te picken";
-        const custom_fields = {
-            source: "floriday",
-            pickup_location: pickupLocation,
-            delivery_location: deliveryLocation,
-            delivery_location_gln: delivery?.location?.gln ?? null,
-            region_gln: delivery?.regionGln ?? null,
-            floriday_sales_order_id: foId,
-            floriday_status: d?.status ?? null,
-            floriday_trade_item_id: tradeItemId || null,
-            floriday_fulfilled: fullyFulfilled,
-            // Betekenis ongewijzigd: fulfilled zonder dat wíj de fulfillment-order
-            // aanmaakten. Nu wij zelf pushen klopt de naam alleen nog met die
-            // createdByErp-check; daarom expliciet ook de tegenhanger vastleggen.
-            floriday_fulfilled_externally: fullyFulfilled && !ff?.createdByErp,
-            floriday_fulfilled_by_erp: fullyFulfilled && Boolean(ff?.createdByErp),
-            floriday_delivery_notes: ff?.deliveryNoteCodes ?? [],
-            floriday_received_at: ff?.receivedAt ?? null,
-            floriday_packing: {
-                pieces_per_package: piecesPerPackage,
-                packages_per_layer: packagesPerLayer,
-                layers_per_load_carrier: layersPerLoadCarrier,
-                // Fustcode en ladingdrager volgen dezelfde bronvolgorde: de order
-                // wint, het trade item is enkel terugval. Ontbreekt de code, dan
-                // blijft hij leeg — nooit een verzonnen waarde (800/999 zijn
-                // beweringen over de aanvoer, geen "onbekend").
-                vbn_package_code: d?.packingConfiguration?.package?.vbnPackageCode ??
-                    (d?.packingConfiguration ? null : (packingCache?.package?.vbnPackageCode ?? null)),
-                custom_package_id: d?.packingConfiguration?.package?.customPackageId ??
-                    (d?.packingConfiguration ? null : (packingCache?.package?.customPackageId ?? null)),
-                load_carrier: d?.packingConfiguration?.loadCarrier ??
-                    (d?.packingConfiguration ? null : (packingCache?.loadCarrier ?? null)),
-                source: d?.packingConfiguration ? "order" : packingCache ? "trade-item" : null,
-            },
+        const packing = {
+            pieces_per_package: piecesPerPackage,
+            packages_per_layer: packagesPerLayer,
+            layers_per_load_carrier: layersPerLoadCarrier,
+            // Fustcode en ladingdrager volgen dezelfde bronvolgorde: de order wint,
+            // het trade item is enkel terugval. Ontbreekt de code, dan blijft hij
+            // leeg — nooit een verzonnen waarde.
+            vbn_package_code: d?.packingConfiguration?.package?.vbnPackageCode ??
+                (d?.packingConfiguration ? null : (packingCache?.package?.vbnPackageCode ?? null)),
+            custom_package_id: d?.packingConfiguration?.package?.customPackageId ??
+                (d?.packingConfiguration ? null : (packingCache?.package?.customPackageId ?? null)),
+            load_carrier: d?.packingConfiguration?.loadCarrier ??
+                (d?.packingConfiguration ? null : (packingCache?.loadCarrier ?? null)),
+            source: d?.packingConfiguration ? "order" : packingCache ? "trade-item" : null,
         };
-        const existingOrder = existingByFoId.get(foId);
-        if (!orderNumber) {
-            skipped++;
-            errors.push(`${foId}: geen ordernummer in floriday_order_number_map`);
+        return {
+            foId,
+            d,
+            orgId,
+            custId: cust?.id ?? null,
+            customerName,
+            delivery,
+            deliveryIso,
+            orderDateIso,
+            orderDateMs: Date.parse(orderDateIso) || 0,
+            sequenceNumber: Number(d?.sequenceNumber ?? 0),
+            pickupLocation,
+            deliveryLocation,
+            numberOfPieces,
+            tradeItemId,
+            productId,
+            productName,
+            plants_per_crate,
+            crates_per_layer,
+            layers_per_cart,
+            unitPrice: Number(d?.pricePerPiece?.value ?? 0),
+            totalPrice,
+            status,
+            ff,
+            fullyFulfilled,
+            packing,
+        };
+    }
+    const allLines = rows.map(buildLine);
+    // Floriday levert per artikel een aparte verkooporder; er is geen groeps-id
+    // in de payload (salesOrderGroupId/customerOrderId zijn leeg). Regels van
+    // dezelfde bestelling herkennen we daarom aan: zelfde klant, zelfde
+    // aflevermoment, zelfde afleverlocatie, zelfde uitleverlocatie én vlak na
+    // elkaar geplaatst.
+    const GROUP_WINDOW_MS = 5 * 60 * 1000;
+    const byKey = new Map();
+    for (const line of allLines) {
+        const key = [
+            line.orgId,
+            line.deliveryIso,
+            line.deliveryLocation ?? "",
+            line.pickupLocation ?? "",
+            line.status,
+        ].join("|");
+        const arr = byKey.get(key);
+        if (arr)
+            arr.push(line);
+        else
+            byKey.set(key, [line]);
+    }
+    const groups = [];
+    for (const arr of byKey.values()) {
+        arr.sort((a, b) => a.orderDateMs - b.orderDateMs || a.sequenceNumber - b.sequenceNumber);
+        let current = [];
+        for (const line of arr) {
+            if (current.length === 0 ||
+                line.orderDateMs - current[current.length - 1].orderDateMs <= GROUP_WINDOW_MS) {
+                current.push(line);
+            }
+            else {
+                groups.push(current);
+                current = [line];
+            }
+        }
+        if (current.length > 0)
+            groups.push(current);
+    }
+    /** Een bestaande order mag niet opgeruimd worden als hij al onderweg is. */
+    const isFrozen = (o) => {
+        const st = String(o?.status ?? "").toLowerCase();
+        return Boolean(o?.plan_locked_at) || st === "verzonden" || st === "shipped";
+    };
+    // Regels waarvan de bestaande order bevroren is, blijven losse orders.
+    const finalGroups = [];
+    for (const group of groups) {
+        if (group.length === 1) {
+            finalGroups.push(group);
             continue;
         }
+        const frozen = [];
+        const free = [];
+        for (const line of group) {
+            const ex = existingByFoId.get(line.foId);
+            if (ex && isFrozen(ex))
+                frozen.push(line);
+            else
+                free.push(line);
+        }
+        for (const line of frozen)
+            finalGroups.push([line]);
+        if (free.length > 0)
+            finalGroups.push(free);
+    }
+    // Vaste bestelsleutel per groep. Hij is deterministisch: dezelfde klant,
+    // hetzelfde aflevermoment, dezelfde aflever-/uitleverlocatie en het vroegste
+    // besteltijdstip (op de minuut) leveren altijd dezelfde sleutel op. Daardoor
+    // vindt een volgende spiegelronde exact dezelfde lokale order terug en valt
+    // een samengevoegde bestelling nooit opnieuw uiteen.
+    const groupKeyFor = (group) => {
+        const first = group.reduce((a, b) => (a.orderDateMs <= b.orderDateMs ? a : b));
+        const minuteIso = new Date(Math.floor((first.orderDateMs || 0) / 60000) * 60000).toISOString();
+        return [
+            "fo",
+            first.orgId,
+            first.deliveryIso,
+            first.deliveryLocation ?? "",
+            first.pickupLocation ?? "",
+            minuteIso,
+        ].join("|");
+    };
+    const keyedGroups = finalGroups.map((group) => ({ group, key: groupKeyFor(group) }));
+    // Bestaande orders die al aan een van deze bestelsleutels hangen. Zo vinden
+    // we ook de order terug waarvan de primaire Floriday-regel is gewijzigd.
+    const existingByGroupKey = new Map();
+    const allKeys = Array.from(new Set(keyedGroups.map((g) => g.key)));
+    if (allKeys.length > 0) {
+        const { data: keyRows } = await supabaseAdmin
+            .from("orders")
+            .select("id, order_number, floriday_sales_order_id, floriday_order_group_key, updated_at, custom_fields, status, plan_locked_at, buffer_id")
+            .in("floriday_order_group_key", allKeys)
+            .is("deleted_at", null);
+        for (const o of keyRows ?? []) {
+            const k = String(o.floriday_order_group_key ?? "");
+            if (!k)
+                continue;
+            const prev = existingByGroupKey.get(k);
+            // Laagste ordernummer wint; die order blijft bestaan bij samenvoegen.
+            if (!prev ||
+                String(o.order_number ?? "") < String(prev.order_number ?? "")) {
+                existingByGroupKey.set(k, o);
+            }
+        }
+    }
+    for (const { group, key: groupKey } of keyedGroups) {
+        const primary = group[0];
+        const memberIds = group.map((l) => l.foId);
+        const anyFulfilled = group.some((l) => l.fullyFulfilled);
+        const ffPrimary = primary.ff;
+        const totalPrice = group.reduce((s, l) => s + (Number(l.totalPrice) || 0), 0);
+        const custom_fields = {
+            source: "floriday",
+            pickup_location: primary.pickupLocation,
+            delivery_location: primary.deliveryLocation,
+            delivery_location_gln: primary.delivery?.location?.gln ?? null,
+            region_gln: primary.delivery?.regionGln ?? null,
+            floriday_sales_order_id: primary.foId,
+            // Alle Floriday-verkooporders die samen deze ene order vormen.
+            floriday_sales_order_ids: memberIds,
+            floriday_line_count: group.length,
+            floriday_status: primary.d?.status ?? null,
+            floriday_trade_item_id: primary.tradeItemId || null,
+            floriday_fulfilled: anyFulfilled,
+            floriday_fulfilled_externally: anyFulfilled && !ffPrimary?.createdByErp,
+            floriday_fulfilled_by_erp: anyFulfilled && Boolean(ffPrimary?.createdByErp),
+            floriday_delivery_notes: ffPrimary?.deliveryNoteCodes ?? [],
+            floriday_received_at: ffPrimary?.receivedAt ?? null,
+            floriday_packing: primary.packing,
+            floriday_lines: group.map((l) => ({
+                sales_order_id: l.foId,
+                trade_item_id: l.tradeItemId || null,
+                pieces: l.numberOfPieces,
+                packing: l.packing,
+            })),
+        };
         try {
+            // Bestaande order kiezen. Volgorde: de order die al aan deze
+            // bestelsleutel hangt (dat is de bestelling zelf), dan die van de
+            // primaire regel, dan de eerste vrije order van een andere regel.
+            let target = existingByGroupKey.get(groupKey) ?? null;
+            if (target && isFrozen(target))
+                target = null;
+            if (!target) {
+                const byPrimary = existingByFoId.get(primary.foId) ?? null;
+                if (byPrimary && !isFrozen(byPrimary))
+                    target = byPrimary;
+            }
+            if (!target) {
+                for (const l of group) {
+                    const ex = existingByFoId.get(l.foId);
+                    if (ex && !isFrozen(ex)) {
+                        target = ex;
+                        break;
+                    }
+                }
+            }
+            // Ordernummer: een bestaande order houdt zijn nummer, anders het nummer
+            // uit floriday_order_number_map van de primaire regel.
+            const orderNumber = (target ? String(target.order_number ?? "").trim() : "") ||
+                orderNumberByFoId.get(primary.foId) ||
+                null;
+            if (!orderNumber) {
+                skipped += group.length;
+                errors.push(`${primary.foId}: geen ordernummer in floriday_order_number_map`);
+                continue;
+            }
+            // Dubbele orders van dezelfde bestelling opruimen: alles wat via een
+            // regel of via dezelfde bestelsleutel bestaat en niet het doel is.
+            const obsolete = [
+                ...group.map((l) => existingByFoId.get(l.foId)),
+                existingByGroupKey.get(groupKey),
+            ].filter((o) => o && (!target || o.id !== target.id) && !isFrozen(o));
+            const obsoleteIds = Array.from(new Set(obsolete.map((o) => String(o.id))));
+            if (obsoleteIds.length > 0) {
+                await supabaseAdmin.from("order_items").delete().in("order_id", obsoleteIds);
+                await supabaseAdmin.from("orders")
+                    .update({ deleted_at: new Date().toISOString(), buffer_id: null })
+                    .in("id", obsoleteIds);
+            }
             let orderId;
-            if (existingOrder) {
+            if (target) {
                 // Tweerichtingssynchronisatie: de Floriday-status overschrijft onze
                 // status alleen als hij aan de Floriday-kant echt is veranderd sinds de
-                // vorige spiegelronde. Anders zou een wijziging uit ons ERP (bv.
-                // "Verzonden") bij elke ronde teruggedraaid worden.
-                const prevFloridayStatus = (existingOrder?.custom_fields ?? {})?.floriday_status ?? null;
-                const floridayStatusChanged = String(d?.status ?? "") !== String(prevFloridayStatus ?? "");
-                const localStatus = String(existingOrder?.status ?? "");
-                const statusPatch = floridayStatusChanged && status !== localStatus
-                    ? { status, status_sync_token: globalThis.crypto.randomUUID() }
+                // vorige spiegelronde.
+                const prevFloridayStatus = (target?.custom_fields ?? {})?.floriday_status ?? null;
+                const floridayStatusChanged = String(primary.d?.status ?? "") !== String(prevFloridayStatus ?? "");
+                const localStatus = String(target?.status ?? "");
+                const statusPatch = floridayStatusChanged && primary.status !== localStatus
+                    ? { status: primary.status, status_sync_token: globalThis.crypto.randomUUID() }
                     : {};
-                // Update basiskolommen; laat bestaande karren staan tot replan-queue draait.
                 const { error: uErr } = await supabaseAdmin.from("orders")
                     .update({
                     order_number: orderNumber,
-                    customer_id: cust?.id ?? null,
-                    customer_name: customerName,
-                    delivery_date: deliveryIso ? deliveryIso.slice(0, 10) : null,
-                    order_date: orderDateIso,
+                    customer_id: primary.custId,
+                    customer_name: primary.customerName,
+                    delivery_date: primary.deliveryIso ? primary.deliveryIso.slice(0, 10) : null,
+                    order_date: primary.orderDateIso,
                     ...statusPatch,
                     total: String(totalPrice),
                     custom_fields,
                     order_source: "floriday",
+                    floriday_sales_order_id: primary.foId,
+                    floriday_order_group_key: groupKey,
+                    deleted_at: null,
                 })
-                    .eq("id", existingOrder.id);
+                    .eq("id", target.id);
                 if (uErr)
                     throw new Error(uErr.message);
-                orderId = existingOrder.id;
+                orderId = target.id;
                 updated++;
             }
             else {
                 const { data: ins, error: iErr } = await supabaseAdmin.from("orders")
                     .insert({
                     order_number: orderNumber,
-                    customer_name: customerName,
-                    customer_id: cust?.id ?? null,
-                    order_date: orderDateIso,
-                    delivery_date: deliveryIso ? deliveryIso.slice(0, 10) : null,
-                    status,
+                    customer_name: primary.customerName,
+                    customer_id: primary.custId,
+                    order_date: primary.orderDateIso,
+                    delivery_date: primary.deliveryIso ? primary.deliveryIso.slice(0, 10) : null,
+                    status: primary.status,
                     total: String(totalPrice),
                     custom_fields,
                     order_source: "floriday",
-                    floriday_sales_order_id: foId,
-                    // Nieuwe spiegelorder: de status komt uit Floriday.
+                    floriday_sales_order_id: primary.foId,
+                    floriday_order_group_key: groupKey,
                     status_sync_token: globalThis.crypto.randomUUID(),
                 })
                     .select("id")
@@ -325,30 +495,25 @@ async function mirrorInternal(limit) {
                 orderId = ins.id;
                 inserted++;
             }
-            // Upsert de enkele orderregel (FO's zijn 1-artikel).
+            // Eén orderregel per Floriday-verkooporder in deze groep.
             await supabaseAdmin.from("order_items").delete().eq("order_id", orderId);
-            const { error: liErr } = await supabaseAdmin.from("order_items").insert({
+            const { error: liErr } = await supabaseAdmin.from("order_items").insert(group.map((l) => ({
                 order_id: orderId,
-                product_id: productId,
-                product_name: productName,
-                quantity: Math.max(0, numberOfPieces),
+                product_id: l.productId,
+                product_name: l.productName,
+                quantity: Math.max(0, l.numberOfPieces),
                 unit: "stuks",
-                unit_price: Number(d?.pricePerPiece?.value ?? 0),
-            });
+                unit_price: l.unitPrice,
+                plants_per_crate: l.plants_per_crate,
+                crates_per_layer: l.crates_per_layer,
+                layers_per_cart: l.layers_per_cart,
+            })));
             if (liErr)
                 throw new Error(liErr.message);
-            // Zorg dat product-packing gebruikt wordt door de planner. Als er nog
-            // geen product-mapping is, valt de planner terug op 1×1×1 en dat wil
-            // je niet — sla dan tijdelijke packing op via een "shadow" product
-            // niet toe; in plaats daarvan berust de planner op de defaults.
-            // (Toekomstige verbetering: shadow product per trade item.)
-            void plants_per_crate;
-            void crates_per_layer;
-            void layers_per_cart;
             // Buffer resolven en in de replan-queue zetten. Alleen orders die buiten
             // ons ERP om in Floriday zijn afgehandeld hoeven niet meer gepland te
-            // worden; een fulfillment die wíj zelf pushten moet gewoon gepickt.
-            const externallyHandled = fullyFulfilled && !ff?.createdByErp;
+            // worden.
+            const externallyHandled = anyFulfilled && !ffPrimary?.createdByErp;
             if (!externallyHandled) {
                 await resolveBufferForOrderInternal(orderId);
                 affectedOrderIds.push(orderId);
@@ -357,7 +522,7 @@ async function mirrorInternal(limit) {
         catch (err) {
             failed++;
             const msg = err.message ?? "unknown";
-            errors.push(`${foId}: ${msg.slice(0, 200)}`);
+            errors.push(`${primary.foId}: ${msg.slice(0, 200)}`);
         }
     }
     // Batch enqueue voor karherplanning. processed_at resetten, anders blijft een