@flowselections/floriday-verkoop-module 1.0.21 → 1.0.25

package/dist-lib/lib/cart-replan.functions.js

@@ -7,19 +7,21 @@ import { createServerFn } from "@tanstack/react-start";
 import { z } from "zod";
 import { requireSupabaseAuth } from "../integrations/supabase/auth-middleware";
 import { CART_PLANNER_VERSION, planCarts, } from "./cart-planner";
-async function replanOrderInternal(orderId) {
+import { resolveBufferForOrderInternal } from "./order-buffers.functions";
+export async function replanBufferInternal(bufferId) {
     const { supabaseAdmin } = await import("../integrations/supabase/client.server");
-    // Order-metadata ophalen (voor FO-detectie / packingConfiguration fallback).
-    const { data: orderRow } = await supabaseAdmin
+    const { data: orders } = await supabaseAdmin
         .from("orders")
         .select("id, custom_fields, plan_locked_at")
-        .eq("id", orderId)
-        .maybeSingle();
-    // Als de order al vergrendeld is (eerste pakbon geprint), niets doen.
-    if (orderRow?.plan_locked_at) {
+        .eq("buffer_id", bufferId)
+        .is("deleted_at", null);
+    const orderRows = (orders ?? []);
+    const orderIds = orderRows.map((o) => o.id);
+    if (orderRows.some((o) => o.plan_locked_at)) {
         return {
             ok: true,
-            orderId,
+            bufferId,
+            orderIds,
             cartsCreated: 0,
             replacedManualCount: 0,
             usedFloridayPacking: false,
@@ -27,13 +29,11 @@ async function replanOrderInternal(orderId) {
             skipped: "locked",
         };
     }
-    const custom = orderRow?.custom_fields ?? {};
-    const floridayPacking = custom?.floriday_packing ?? null;
-    // Items + belading uit products-tabel.
+    // Items van alle orders in de buffer.
     const { data: items, error: itErr } = await supabaseAdmin
         .from("order_items")
-        .select("id, product_id, product_name, quantity, products(plants_per_crate, crates_per_layer, layers_per_cart)")
-        .eq("order_id", orderId);
+        .select("id, order_id, product_id, product_name, quantity, products(plants_per_crate, crates_per_layer, layers_per_cart)")
+        .in("order_id", orderIds.length > 0 ? orderIds : ["00000000-0000-0000-0000-000000000000"]);
     if (itErr)
         throw new Error(itErr.message);
     const inputs = (items ?? []).map((it) => {
@@ -48,26 +48,33 @@ async function replanOrderInternal(orderId) {
             layers_per_cart: Math.max(1, Number(prod.layers_per_cart ?? 1)),
         };
     });
-    // Bestaande karren tellen voordat we alles wissen (voor waarschuwing).
+    // Item → order-map voor het toewijzen van cart.order_id bij homogene karren.
+    const itemToOrder = new Map();
+    for (const it of items ?? []) {
+        itemToOrder.set(it.id, it.order_id);
+    }
+    // Bestaande karren in de buffer tellen (voor waarschuwing) en wissen.
     const { data: existingCarts } = await supabaseAdmin
         .from("order_carts")
         .select("id, source")
-        .eq("order_id", orderId);
+        .eq("buffer_id", bufferId);
     const replacedManualCount = (existingCarts ?? []).filter((c) => c.source === "manual").length;
-    // Alles wegvegen — cascade wist order_cart_items.
     const { error: delErr } = await supabaseAdmin
         .from("order_carts")
         .delete()
-        .eq("order_id", orderId);
+        .eq("buffer_id", bufferId);
     if (delErr)
         throw new Error(delErr.message);
-    // FO-fallback: gebruik Floriday packingConfiguration wanneer volledig aanwezig.
+    // Floriday-packingConfiguration-fallback: alleen als de buffer precies één
+    // order bevat én die order een volledig Floriday-packingConfiguration heeft.
     let usedFloridayPacking = false;
     let plannedCarts = [];
     const warnings = [];
-    const isFo = custom?.source === "floriday" || floridayPacking?.pieces_per_package;
+    const solo = orderRows.length === 1 ? orderRows[0] : null;
+    const soloCustom = solo?.custom_fields ?? {};
+    const floridayPacking = soloCustom?.floriday_packing ?? null;
+    const isFo = solo && (soloCustom?.source === "floriday" || floridayPacking?.pieces_per_package);
     if (isFo && floridayPacking && Array.isArray(floridayPacking.carts)) {
-        // Verwacht formaat: { carts: [{ items: [{ order_item_id, crates, plants_per_crate, crates_per_layer, layers_per_cart }] }] }
         usedFloridayPacking = true;
         plannedCarts = floridayPacking.carts.map((c, idx) => {
             const cItems = (c.items ?? []).map((i) => ({
@@ -93,17 +100,36 @@ async function replanOrderInternal(orderId) {
         });
     }
     else {
-        const result = planCarts(inputs);
+        const [{ data: settings }, { data: overrides }] = await Promise.all([
+            supabaseAdmin.from("cart_planning_settings").select("*").eq("id", 1).maybeSingle(),
+            supabaseAdmin.from("cart_planning_product_overrides").select("product_id, never_mix"),
+        ]);
+        const neverMix = new Set((overrides ?? [])
+            .filter((o) => o.never_mix && o.product_id)
+            .map((o) => o.product_id));
+        const result = planCarts(inputs, {
+            maxPartySharePerLayerPct: settings?.max_party_share_per_layer_pct ?? 50,
+            maxBeladingenPerLayer: settings?.max_beladingen_per_layer ?? 2,
+            neverMixProductIds: neverMix,
+        });
         plannedCarts = result.carts;
         warnings.push(...result.warnings);
     }
-    // Wegschrijven.
     let cartsCreated = 0;
     for (const cart of plannedCarts) {
+        // Bepaal cart.order_id: null bij mix van orders, anders die ene order.
+        const orderIdsOnCart = new Set();
+        for (const i of cart.items) {
+            const oid = itemToOrder.get(i.order_item_id);
+            if (oid)
+                orderIdsOnCart.add(oid);
+        }
+        const singleOrderId = orderIdsOnCart.size === 1 ? [...orderIdsOnCart][0] : null;
         const { data: inserted, error: cErr } = await supabaseAdmin
             .from("order_carts")
             .insert({
-            order_id: orderId,
+            order_id: singleOrderId,
+            buffer_id: bufferId,
             cart_number: cart.cart_number,
             is_auto: true,
             is_complete: cart.is_complete,
@@ -139,13 +165,28 @@ async function replanOrderInternal(orderId) {
     }
     return {
         ok: true,
-        orderId,
+        bufferId,
+        orderIds,
         cartsCreated,
         replacedManualCount,
         usedFloridayPacking,
         warnings,
     };
 }
+async function replanOrderInternal(orderId) {
+    // Resolve (of maak) de buffer voor de order en plan de hele buffer opnieuw.
+    const bufferId = await resolveBufferForOrderInternal(orderId);
+    const res = await replanBufferInternal(bufferId);
+    return {
+        ok: res.ok,
+        orderId,
+        cartsCreated: res.cartsCreated,
+        replacedManualCount: res.replacedManualCount,
+        usedFloridayPacking: res.usedFloridayPacking,
+        warnings: res.warnings,
+        skipped: res.skipped,
+    };
+}
 export async function replanOrderCartsFromCron(orderId) {
     return replanOrderInternal(orderId);
 }
@@ -190,14 +231,31 @@ export async function drainCartReplanQueue(limit = 50) {
     return { ok: failed === 0, processed, failed, results };
 }
 // ─── Lezen — voor de UI ─────────────────────────────────────────────────────
+// Retourneert alle karren van de buffer waarin de order valt, zodat karren
+// die items van meerdere orders bevatten volledig zichtbaar zijn.
 export const listOrderCarts = createServerFn({ method: "GET" })
     .middleware([requireSupabaseAuth])
     .inputValidator((input) => z.object({ orderId: z.string().uuid() }).parse(input))
     .handler(async ({ data, context }) => {
+    const { data: order } = await context.supabase
+        .from("orders")
+        .select("buffer_id")
+        .eq("id", data.orderId)
+        .maybeSingle();
+    const bufferId = order?.buffer_id;
+    if (!bufferId)
+        return { carts: [], bufferId: null };
     const { data: carts } = await context.supabase
         .from("order_carts")
-        .select("id, cart_number, source, is_complete, occupancy_pct, total_layers_used, algorithm_version, notes, order_cart_items(id, order_item_id, product_id, product_name, crates, plants_per_crate, crates_per_layer, layers_per_cart, layer_fraction, layer_share_pct)")
-        .eq("order_id", data.orderId)
+        .select("id, order_id, buffer_id, cart_number, source, is_complete, occupancy_pct, total_layers_used, algorithm_version, notes, order_cart_items(id, order_item_id, product_id, product_name, crates, plants_per_crate, crates_per_layer, layers_per_cart, layer_fraction, layer_share_pct)")
+        .eq("buffer_id", bufferId)
         .order("cart_number");
-    return { carts: carts ?? [] };
+    return { carts: carts ?? [], bufferId };
+});
+export const replanBufferForOrder = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((input) => z.object({ orderId: z.string().uuid() }).parse(input))
+    .handler(async ({ data }) => {
+    const bufferId = await resolveBufferForOrderInternal(data.orderId);
+    return replanBufferInternal(bufferId);
 });