@flowselections/floriday-verkoop-module 1.0.53 → 1.0.55

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

@@ -6,6 +6,7 @@
 import { createServerFn } from "@tanstack/react-start";
 import { z } from "zod";
 import { requireSupabaseAuth } from "../integrations/supabase/auth-middleware";
+import { resolveOrderRow } from "./order-row.server";
 import { CART_PLANNER_VERSION, planCarts, } from "./cart-planner";
 import { resolveBufferForOrderInternal } from "./order-buffers.functions";
 export async function replanBufferInternal(bufferId) {
@@ -360,8 +361,12 @@ export async function replanOrderCartsFromCron(orderId) {
 }
 export const replanOrderCarts = createServerFn({ method: "POST" })
     .middleware([requireSupabaseAuth])
-    .inputValidator((input) => z.object({ orderId: z.string().uuid() }).parse(input))
-    .handler(async ({ data }) => replanOrderInternal(data.orderId));
+    .inputValidator((input) => z.object({ orderId: z.string().min(1) }).parse(input))
+    .handler(async ({ data, context }) => {
+    // DTO-id kan een Floriday salesOrderId zijn.
+    const order = await resolveOrderRow(context.supabase, data.orderId);
+    return replanOrderInternal(order.id);
+});
 // ─── Queue drain (aangeroepen door pg_cron elke minuut) ─────────────────────
 export async function drainCartReplanQueue(limit = 50) {
     const { supabaseAdmin } = await import("../integrations/supabase/client.server");
@@ -401,27 +406,118 @@ export async function drainCartReplanQueue(limit = 50) {
 // ─── 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.
+// Levert ook de order-context (nummers per orderregel) en, als er geen karren
+// zijn, de laatste blokkadereden uit de engine (logistics_decisions /
+// logistics_plan_queue). De UI berekent NIETS zelf: hij toont wat er staat.
 export const listOrderCarts = createServerFn({ method: "GET" })
     .middleware([requireSupabaseAuth])
-    .inputValidator((input) => z.object({ orderId: z.string().uuid() }).parse(input))
+    .inputValidator((input) => z.object({ orderId: z.string().min(1) }).parse(input))
     .handler(async ({ data, context }) => {
-    const { data: order } = await context.supabase
+    // Elke query faalt HARD. "Geen karren" en "kon niet laden" zijn twee
+    // verschillende dingen; stilzwijgend een lege array teruggeven verbergt
+    // fouten (RLS, kolomnaam, embed) als "nog geen karindeling".
+    const fail = (what, error) => {
+        throw new Error(`Karindeling laden mislukt (${what}): ${error?.message ?? "onbekende fout"}`);
+    };
+    // De DTO-id is voor Floriday-orders het salesOrderId, niet orders.id.
+    // resolveOrderRow doet de twee-staps-lookup + botsingswaarschuwing.
+    const orderRow = await resolveOrderRow(context.supabase, data.orderId);
+    const dbOrderId = orderRow.id;
+    const bufferId = orderRow.buffer_id;
+    const lockRes = await context.supabase
         .from("orders")
-        .select("buffer_id")
-        .eq("id", data.orderId)
+        .select("plan_locked_at")
+        .eq("id", dbOrderId)
         .maybeSingle();
-    const bufferId = order?.buffer_id;
-    const 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)";
+    if (lockRes.error)
+        fail("plan-lock lezen", lockRes.error);
+    const planLockedAt = lockRes.data?.plan_locked_at ?? null;
+    const select = "id, order_id, buffer_id, cart_number, source, is_complete, occupancy_pct, total_layers_used, algorithm_version, carrier_type, max_layers, 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)";
     const base = context.supabase.from("order_carts").select(select);
-    const { data: carts } = await (bufferId
+    const cartsRes = await (bufferId
         ? base.eq("buffer_id", bufferId)
-        : base.eq("order_id", data.orderId)).order("cart_number");
-    return { carts: carts ?? [], bufferId };
+        : base.eq("order_id", dbOrderId)).order("cart_number");
+    if (cartsRes.error)
+        fail("karren lezen", cartsRes.error);
+    const carts = (cartsRes.data ?? []);
+    // Orders in de scope + ordernummer per orderregel (voor de badges).
+    let orders = [];
+    if (bufferId) {
+        const sibs = await context.supabase
+            .from("orders")
+            .select("id, order_number")
+            .eq("buffer_id", bufferId)
+            .is("deleted_at", null);
+        if (sibs.error)
+            fail("orders in buffer lezen", sibs.error);
+        orders = (sibs.data ?? []).map((o) => ({
+            id: o.id,
+            order_number: o.order_number ?? null,
+        }));
+    }
+    if (orders.length === 0) {
+        orders = [{ id: dbOrderId, order_number: orderRow.order_number ?? null }];
+    }
+    const orderIds = orders.map((o) => o.id);
+    let itemOrders = [];
+    if (orderIds.length > 0) {
+        const its = await context.supabase
+            .from("order_items")
+            .select("id, order_id")
+            .in("order_id", orderIds);
+        if (its.error)
+            fail("orderregels lezen", its.error);
+        itemOrders = (its.data ?? []).map((i) => ({
+            id: i.id,
+            order_id: i.order_id,
+        }));
+    }
+    // Blokkadereden alleen ophalen als er niets gepland staat.
+    let blocked = null;
+    if (carts.length === 0 && orderIds.length > 0) {
+        const dec = await context.supabase
+            .from("logistics_decisions")
+            .select("subject_id, slot, explanation, result, created_at")
+            .in("subject_id", orderIds)
+            .order("created_at", { ascending: false })
+            .limit(1);
+        if (dec.error)
+            fail("blokkadereden lezen", dec.error);
+        const d = (dec.data ?? [])[0];
+        if (d) {
+            blocked = {
+                reason: d.result?.reason ?? d.slot ?? null,
+                explanation: d.explanation ?? null,
+                at: d.created_at ?? null,
+            };
+        }
+        if (!blocked) {
+            const q = await context.supabase
+                .from("logistics_plan_queue")
+                .select("order_id, status, reason, error, updated_at")
+                .in("order_id", orderIds)
+                .order("updated_at", { ascending: false })
+                .limit(1);
+            if (q.error)
+                fail("planqueue lezen", q.error);
+            const r = (q.data ?? [])[0];
+            if (r && (r.error || r.reason)) {
+                blocked = {
+                    reason: r.reason ?? null,
+                    explanation: r.error ?? null,
+                    at: r.updated_at ?? null,
+                };
+            }
+        }
+    }
+    return { carts, bufferId, orderId: dbOrderId, planLockedAt, orders, itemOrders, blocked };
 });
 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 replanScopeInternal({ bufferId, orderId: data.orderId });
+    .inputValidator((input) => z.object({ orderId: z.string().min(1) }).parse(input))
+    .handler(async ({ data, context }) => {
+    // DTO-id kan een Floriday salesOrderId zijn.
+    const order = await resolveOrderRow(context.supabase, data.orderId);
+    const bufferId = await resolveBufferForOrderInternal(order.id);
+    return replanScopeInternal({ bufferId, orderId: order.id });
 });