@flowselections/floriday-verkoop-module 1.0.12 → 1.0.14

package/dist-lib/lib/floriday-auto-fulfillment.server.js

@@ -0,0 +1,352 @@
+import { florydayWrite } from "./floriday-gateway.server";
+async function loadConnectionMeta(supabase, connectionId) {
+    const { data } = await supabase
+        .from("floriday_connections")
+        .select("id, environment, access_token, api_key, is_active, gln_code, preferred_warehouse_id")
+        .eq("id", connectionId)
+        .maybeSingle();
+    return data ?? null;
+}
+async function loadProductPacking(supabase, tradeItemId) {
+    if (!tradeItemId)
+        return null;
+    const { data } = await supabase
+        .from("products")
+        .select("plants_per_crate, crates_per_layer, layers_per_cart")
+        .eq("trade_item_key", tradeItemId)
+        .limit(1)
+        .maybeSingle();
+    if (!data)
+        return null;
+    return {
+        plants_per_crate: Number(data.plants_per_crate) || 0,
+        crates_per_layer: Number(data.crates_per_layer) || 0,
+        layers_per_cart: Number(data.layers_per_cart) || 0,
+    };
+}
+function upsertLog(supabase, connectionId, salesOrderId, patch) {
+    return supabase.from("floriday_auto_fulfillment_log").upsert({
+        connection_id: connectionId,
+        sales_order_id: salesOrderId,
+        last_attempt_at: new Date().toISOString(),
+        ...patch,
+    }, { onConflict: "connection_id,sales_order_id" });
+}
+async function existingFulfillmentForOrder(supabase, connectionId, salesOrderId) {
+    // Scan the most recent fulfillment orders for this connection and look for
+    // a nested loadCarrierItems entry referencing this sales order.
+    const { data } = await supabase
+        .from("floriday_fulfillment_orders_cache")
+        .select("data")
+        .eq("connection_id", connectionId)
+        .order("fetched_at", { ascending: false })
+        .limit(500);
+    const rows = data ?? [];
+    for (const row of rows) {
+        const carriers = row?.data?.loadCarriers;
+        if (!Array.isArray(carriers))
+            continue;
+        for (const c of carriers) {
+            const items = c?.loadCarrierItems;
+            if (!Array.isArray(items))
+                continue;
+            for (const it of items) {
+                if (String(it?.salesOrderId ?? "") === salesOrderId)
+                    return true;
+            }
+        }
+    }
+    return false;
+}
+async function alreadyProcessed(supabase, connectionId, salesOrderId) {
+    const { data } = await supabase
+        .from("floriday_auto_fulfillment_log")
+        .select("status")
+        .eq("connection_id", connectionId)
+        .eq("sales_order_id", salesOrderId)
+        .maybeSingle();
+    return data?.status === "created";
+}
+async function loadDeliveryContext(supabase, connectionId, salesOrderId) {
+    const { data } = await supabase
+        .from("floriday_delivery_orders_cache")
+        .select("data")
+        .eq("connection_id", connectionId)
+        .eq("is_deleted", false)
+        .order("fetched_at", { ascending: false })
+        .limit(500);
+    const rows = data ?? [];
+    for (const row of rows) {
+        const d = row?.data;
+        const reqs = Array.isArray(d?.fulfillmentRequests) ? d.fulfillmentRequests : [];
+        const matching = [];
+        for (const r of reqs) {
+            if (String(r?.salesOrderId ?? "") !== salesOrderId)
+                continue;
+            matching.push({
+                fulfillmentRequestId: String(r?.fulfillmentRequestId ?? ""),
+                salesOrderId: String(r?.salesOrderId ?? ""),
+                loadCarrier: r?.loadCarrier ?? null,
+                numberOfPackages: Number(r?.numberOfPackages ?? 0) || 0,
+                deliveryRemarks: r?.deliveryRemarks ?? null,
+                tradeItemId: r?.tradeItemId ?? null,
+            });
+        }
+        if (matching.length > 0) {
+            return {
+                deliveryOrderId: String(d?.deliveryOrderId ?? ""),
+                despatchWarehouseId: d?.despatchWarehouseId ?? null,
+                destination: d?.destination ?? null,
+                latestDeliveryDateTime: d?.deliveryDateTime ?? null,
+                requests: matching,
+            };
+        }
+    }
+    return null;
+}
+function buildFulfillmentPayload(order, warehouseId, ctx) {
+    const warnings = [];
+    const supplierOrganizationId = String(order?.supplierOrganizationId ?? "");
+    const customerOrganizationId = String(order?.customerOrganizationId ?? "");
+    // Group requests by load-carrier type to build one loadCarrier per group.
+    const byCarrier = new Map();
+    for (const r of ctx.requests) {
+        const key = r.loadCarrier ?? "DANISH_TROLLEY";
+        if (!byCarrier.has(key))
+            byCarrier.set(key, []);
+        byCarrier.get(key).push(r);
+    }
+    const loadCarriers = [];
+    let sortIndex = 1;
+    for (const [carrier, requests] of byCarrier) {
+        loadCarriers.push({
+            sortIndex: sortIndex++,
+            loadCarrierType: carrier === "NONE" ? "DANISH_TROLLEY" : carrier,
+            numberOfAdditionalLayers: 0,
+            loadCarrierItems: requests.map((r, idx) => {
+                const item = {
+                    sortIndex: idx + 1,
+                    fulfillmentRequestId: r.fulfillmentRequestId,
+                    tradeItemId: r.tradeItemId ?? String(order?.tradeItemId ?? ""),
+                    salesOrderId: r.salesOrderId,
+                    numberOfPackages: r.numberOfPackages,
+                };
+                const remarks = (r.deliveryRemarks ?? "").toString().trim();
+                if (remarks)
+                    item.deliveryRemarks = remarks;
+                return item;
+            }),
+        });
+    }
+    const payload = {
+        fulfillmentOrderId: crypto.randomUUID(),
+        type: order?.tradeInstrument ?? "DIRECT_SALES",
+        despatchWarehouseId: warehouseId,
+        latestDeliveryDateTime: ctx.latestDeliveryDateTime ?? order?.delivery?.latestDeliveryDateTime ?? null,
+        supplierOrganizationId,
+        fulfillingOrganizationId: supplierOrganizationId,
+        destination: ctx.destination ?? {
+            organizationId: customerOrganizationId,
+            location: order?.delivery?.location ?? null,
+            warehouseId: null,
+        },
+        loadCarriers,
+        oneLabelOnly: false,
+    };
+    return { payload, warnings };
+}
+const SKIPPABLE_STATUSES = new Set(["REJECTED", "CANCELLED", "CANCELED", "EXPIRED"]);
+export async function processOrderForAutoFulfillment(supabase, order) {
+    const salesOrderId = order.floriday_id;
+    const connectionId = order.connection_id;
+    if (order.is_deleted) {
+        await upsertLog(supabase, connectionId, salesOrderId, {
+            status: "skipped",
+            reason: "sales-order-deleted",
+        });
+        return { status: "skipped", reason: "sales-order-deleted" };
+    }
+    if (order.status && SKIPPABLE_STATUSES.has(String(order.status).toUpperCase())) {
+        await upsertLog(supabase, connectionId, salesOrderId, {
+            status: "skipped",
+            reason: `status-${order.status}`,
+        });
+        return { status: "skipped", reason: `status-${order.status}` };
+    }
+    if (await alreadyProcessed(supabase, connectionId, salesOrderId)) {
+        return { status: "skipped", reason: "already-created" };
+    }
+    if (await existingFulfillmentForOrder(supabase, connectionId, salesOrderId)) {
+        await upsertLog(supabase, connectionId, salesOrderId, {
+            status: "skipped",
+            reason: "existing-fulfillment",
+        });
+        return { status: "skipped", reason: "existing-fulfillment" };
+    }
+    const conn = await loadConnectionMeta(supabase, connectionId);
+    if (!conn) {
+        await upsertLog(supabase, connectionId, salesOrderId, {
+            status: "failed",
+            error: "connection-not-found",
+        });
+        return { status: "failed", reason: "connection-not-found" };
+    }
+    // Warehouse fallback chain:
+    //   1) connection.preferred_warehouse_id
+    //   2) salesorder.data.despatchWarehouseId
+    //   3) first non-deleted warehouse from floriday_warehouses_cache
+    let warehouseId = conn.preferred_warehouse_id ?? null;
+    let warehouseFallback = null;
+    if (!warehouseId) {
+        const orderWarehouse = String(order.data?.despatchWarehouseId ?? "").trim();
+        if (orderWarehouse) {
+            warehouseId = orderWarehouse;
+            warehouseFallback = "warehouse-fallback:order";
+        }
+    }
+    if (!warehouseId) {
+        const { data: wh } = await supabase
+            .from("floriday_warehouses_cache")
+            .select("floriday_id, is_default")
+            .eq("connection_id", connectionId)
+            .eq("is_deleted", false)
+            .order("is_default", { ascending: false })
+            .limit(1)
+            .maybeSingle();
+        const cached = String(wh?.floriday_id ?? "").trim();
+        if (cached) {
+            warehouseId = cached;
+            warehouseFallback = "warehouse-fallback:cache";
+        }
+    }
+    if (!warehouseId) {
+        await upsertLog(supabase, connectionId, salesOrderId, {
+            status: "skipped",
+            reason: "no-warehouse",
+        });
+        return { status: "skipped", reason: "no-warehouse" };
+    }
+    // Load Floriday-issued fulfillment requests from the matching delivery order.
+    const deliveryCtx = await loadDeliveryContext(supabase, connectionId, salesOrderId);
+    if (!deliveryCtx || deliveryCtx.requests.length === 0) {
+        await upsertLog(supabase, connectionId, salesOrderId, {
+            status: "skipped",
+            reason: "no-delivery-order",
+        });
+        return { status: "skipped", reason: "no-delivery-order" };
+    }
+    // Prefer the delivery order's despatchWarehouseId when Floriday supplies it.
+    const effectiveWarehouseId = deliveryCtx.despatchWarehouseId || warehouseId;
+    const { payload, warnings } = buildFulfillmentPayload(order.data, effectiveWarehouseId, deliveryCtx);
+    if (warehouseFallback && !deliveryCtx.despatchWarehouseId)
+        warnings.push(warehouseFallback);
+    // Increment attempts.
+    const { data: existing } = await supabase
+        .from("floriday_auto_fulfillment_log")
+        .select("attempts")
+        .eq("connection_id", connectionId)
+        .eq("sales_order_id", salesOrderId)
+        .maybeSingle();
+    const attempts = Number(existing?.attempts ?? 0) + 1;
+    const env = (conn.environment === "production" || conn.environment === "live" ? "live" : "staging");
+    const result = await florydayWrite(supabase, env, {
+        module: "warehouse",
+        action: "add-fulfillment-order",
+        method: "POST",
+        path: "/fulfillment-orders",
+        referenceId: salesOrderId,
+        body: payload,
+    }, null);
+    if (!result.ok) {
+        await upsertLog(supabase, connectionId, salesOrderId, {
+            status: "failed",
+            attempts,
+            error: (result.error ?? `HTTP ${result.status}`).slice(0, 500),
+            reason: warnings.join(",") || null,
+        });
+        return { status: "failed", reason: result.error };
+    }
+    const fulfillmentOrderId = String(result.data?.fulfillmentOrderId ?? result.data?.id ?? payload.fulfillmentOrderId ?? "");
+    await upsertLog(supabase, connectionId, salesOrderId, {
+        status: "created",
+        attempts,
+        fulfillment_order_id: fulfillmentOrderId || null,
+        error: null,
+        reason: warnings.join(",") || null,
+    });
+    return { status: "created", fulfillmentOrderId };
+}
+export async function processRecentSalesOrders(supabase, connectionId, sinceIso) {
+    // 1) Recently synced / updated sales orders in this cycle.
+    const { data: recent } = await supabase
+        .from("floriday_salesorders_cache")
+        .select("connection_id, floriday_id, status, is_deleted, data, updated_at")
+        .eq("connection_id", connectionId)
+        .gte("updated_at", sinceIso)
+        .limit(200);
+    const rowMap = new Map();
+    for (const r of (recent ?? [])) {
+        rowMap.set(r.floriday_id, r);
+    }
+    // 2) Backlog: sales orders that never got a log row, or were previously
+    //    skipped/failed because the preferred warehouse wasn't set yet.
+    const { data: allOrders } = await supabase
+        .from("floriday_salesorders_cache")
+        .select("connection_id, floriday_id, status, is_deleted, data")
+        .eq("connection_id", connectionId)
+        .eq("is_deleted", false)
+        .limit(500);
+    const orderList = allOrders ?? [];
+    if (orderList.length > 0) {
+        const ids = orderList.map((o) => o.floriday_id);
+        const { data: logs } = await supabase
+            .from("floriday_auto_fulfillment_log")
+            .select("sales_order_id, status, reason")
+            .eq("connection_id", connectionId)
+            .in("sales_order_id", ids);
+        const logMap = new Map();
+        for (const l of (logs ?? [])) {
+            logMap.set(l.sales_order_id, { status: l.status, reason: l.reason });
+        }
+        for (const o of orderList) {
+            const existing = logMap.get(o.floriday_id);
+            if (!existing) {
+                rowMap.set(o.floriday_id, o);
+                continue;
+            }
+            if (existing.status === "failed") {
+                rowMap.set(o.floriday_id, o);
+                continue;
+            }
+            if (existing.status === "skipped" &&
+                (existing.reason === "no-preferred-warehouse" ||
+                    existing.reason === "no-warehouse" ||
+                    existing.reason === "no-delivery-order")) {
+                rowMap.set(o.floriday_id, o);
+            }
+        }
+    }
+    const rows = Array.from(rowMap.values());
+    let created = 0;
+    let failed = 0;
+    let skipped = 0;
+    for (const row of rows) {
+        try {
+            const r = await processOrderForAutoFulfillment(supabase, row);
+            if (r.status === "created")
+                created++;
+            else if (r.status === "failed")
+                failed++;
+            else
+                skipped++;
+        }
+        catch (err) {
+            failed++;
+            await upsertLog(supabase, row.connection_id, row.floriday_id, {
+                status: "failed",
+                error: err.message?.slice(0, 500) ?? "unknown error",
+            });
+        }
+    }
+    return { processed: rows.length, created, failed, skipped };
+}