@flowselections/floriday-verkoop-module 1.0.20 → 1.0.24

package/dist-lib/lib/order-buffers.functions.js

@@ -0,0 +1,244 @@
+// Bepaalt en beheert "orderbuffers": groepen orders die volgens de
+// Karindeling-instelling samen op karren ingedeeld moeten worden.
+import { createServerFn } from "@tanstack/react-start";
+import { z } from "zod";
+import { requireSupabaseAuth } from "../integrations/supabase/auth-middleware";
+function normalizeBufferPart(value) {
+    if (value == null)
+        return null;
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const normalized = normalizeBufferPart(item);
+            if (normalized)
+                return normalized;
+        }
+        return null;
+    }
+    if (typeof value === "object") {
+        const obj = value;
+        return pickFirstString(obj.gln, obj.locationGln, obj.warehouseId, obj.id, obj.name, obj.location, obj.address?.addressLine);
+    }
+    const raw = String(value).trim();
+    if (!raw)
+        return null;
+    return raw.toLowerCase().replace(/\s+/g, " ");
+}
+function pickFirstString(...values) {
+    for (const value of values) {
+        const normalized = normalizeBufferPart(value);
+        if (normalized)
+            return normalized;
+    }
+    return null;
+}
+function isUuid(value) {
+    return !!value && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+}
+/** Bouwt de deterministische buffer-sleutel voor een order op basis van de modus. */
+export function buildBufferKey(order, mode) {
+    const cf = order.custom_fields ?? {};
+    const pickup_date = pickFirstString(cf.pickup_moment, cf.pickup_date, cf.pickup_datetime, order.delivery_date);
+    // De bufferlocatie is de afleverlocatie/bestemming. Voorheen werd hier de
+    // afhaallocatie gebruikt, waardoor orders voor dezelfde rit maar met dezelfde
+    // tuin niet betrouwbaar op bestemming werden samengevoegd.
+    const delivery_location = pickFirstString(cf.delivery_location_gln, cf.destination_gln, cf.region_gln, cf.location_gln, cf.delivery_location_id, cf.delivery_location);
+    const customer_id = normalizeBufferPart(order.customer_id);
+    switch (mode) {
+        case "same_pickup_and_location":
+            return {
+                key: `pl|${pickup_date ?? "-"}|${delivery_location ?? "-"}`,
+                pickup_date,
+                pickup_location: delivery_location,
+            };
+        case "same_pickup":
+            return {
+                key: `p|${pickup_date ?? "-"}`,
+                pickup_date,
+                pickup_location: delivery_location,
+            };
+        case "same_location":
+            return {
+                key: `l|${delivery_location ?? "-"}`,
+                pickup_date,
+                pickup_location: delivery_location,
+            };
+        case "same_customer":
+            return {
+                key: `c|${customer_id ?? "-"}|${pickup_date ?? "-"}`,
+                pickup_date,
+                pickup_location: delivery_location,
+            };
+        case "never":
+        default:
+            return {
+                key: `order-${order.id}`,
+                pickup_date,
+                pickup_location: delivery_location,
+            };
+    }
+}
+/** Zorgt dat een order aan de juiste buffer hangt. Retourneert de buffer-id. */
+export async function resolveBufferForOrderInternal(orderId) {
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    const [{ data: order }, { data: settings }] = await Promise.all([
+        supabaseAdmin
+            .from("orders")
+            .select("id, customer_id, delivery_date, custom_fields, buffer_id")
+            .eq("id", orderId)
+            .maybeSingle(),
+        supabaseAdmin
+            .from("cart_planning_settings")
+            .select("buffer_grouping_mode")
+            .eq("id", 1)
+            .maybeSingle(),
+    ]);
+    if (!order)
+        throw new Error(`Order ${orderId} niet gevonden`);
+    const mode = (settings?.buffer_grouping_mode ??
+        "same_pickup_and_location");
+    const orderForKey = { ...order, custom_fields: { ...(order.custom_fields ?? {}) } };
+    const cf = orderForKey.custom_fields ?? {};
+    const deliveryLocationId = pickFirstString(cf.delivery_location_id, cf.delivery_location);
+    if (!cf.delivery_location_gln && isUuid(deliveryLocationId)) {
+        const { data: loc } = await supabaseAdmin
+            .from("customer_delivery_locations")
+            .select("gln, name, address_line, street, house_number, postal_code, city")
+            .eq("id", deliveryLocationId)
+            .maybeSingle();
+        if (loc) {
+            const locAny = loc;
+            cf.delivery_location_gln = locAny.gln ?? null;
+            cf.delivery_location_name = locAny.name ?? [locAny.address_line, locAny.street, locAny.house_number, locAny.postal_code, locAny.city]
+                .filter(Boolean)
+                .join(" ");
+        }
+    }
+    const { key, pickup_date, pickup_location } = buildBufferKey(orderForKey, mode);
+    // Upsert de buffer.
+    const { data: existing } = await supabaseAdmin
+        .from("order_buffers")
+        .select("id")
+        .eq("buffer_key", key)
+        .maybeSingle();
+    let bufferId = existing?.id;
+    if (!bufferId) {
+        const { data: created, error } = await supabaseAdmin
+            .from("order_buffers")
+            .insert({
+            buffer_key: key,
+            grouping_mode: mode,
+            pickup_date,
+            pickup_location,
+            customer_id: order.customer_id,
+        })
+            .select("id")
+            .single();
+        if (error) {
+            // Race: someone else inserted first — refetch.
+            const { data: retry } = await supabaseAdmin
+                .from("order_buffers")
+                .select("id")
+                .eq("buffer_key", key)
+                .maybeSingle();
+            bufferId = retry?.id;
+            if (!bufferId)
+                throw new Error(error.message);
+        }
+        else {
+            bufferId = created.id;
+        }
+    }
+    else {
+        await supabaseAdmin.from("order_buffers")
+            .update({
+            grouping_mode: mode,
+            pickup_date,
+            pickup_location,
+            customer_id: order.customer_id,
+        })
+            .eq("id", bufferId);
+    }
+    // Koppel de order aan de buffer als dit nog niet klopt.
+    if (order.buffer_id !== bufferId) {
+        await supabaseAdmin.from("orders")
+            .update({ buffer_id: bufferId })
+            .eq("id", orderId);
+    }
+    return bufferId;
+}
+/** Rebuffer alle orders (bv. na wijziging van buffer_grouping_mode). */
+export async function rebufferAllOrdersInternal() {
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    const { data: orders } = await supabaseAdmin
+        .from("orders")
+        .select("id")
+        .is("deleted_at", null);
+    const affectedBuffers = new Set();
+    let processed = 0;
+    for (const row of orders ?? []) {
+        try {
+            const bufferId = await resolveBufferForOrderInternal(row.id);
+            affectedBuffers.add(bufferId);
+            processed++;
+        }
+        catch {
+            // skip
+        }
+    }
+    // Verwijder buffers die geen orders meer bevatten (na regroeping).
+    const { data: allBuffers } = await supabaseAdmin
+        .from("order_buffers")
+        .select("id, orders(id)")
+        .limit(10000);
+    const emptyIds = (allBuffers ?? [])
+        .filter((b) => !b.orders || b.orders.length === 0)
+        .map((b) => b.id);
+    if (emptyIds.length > 0) {
+        await supabaseAdmin.from("order_carts").delete().in("buffer_id", emptyIds);
+        await supabaseAdmin.from("order_buffers").delete().in("id", emptyIds);
+    }
+    // Herplan elke aangeraakte buffer direct, zodat karren de nieuwe groepering volgen.
+    const { replanBufferInternal } = await import("./cart-replan.functions");
+    let buffersReplanned = 0;
+    for (const bufferId of affectedBuffers) {
+        try {
+            await replanBufferInternal(bufferId);
+            buffersReplanned++;
+        }
+        catch {
+            // skip; wordt anders door de queue opgepakt
+        }
+    }
+    return { processed, buffersReplanned };
+}
+export const rebufferAllOrders = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .handler(async () => rebufferAllOrdersInternal());
+export const resolveBufferForOrder = 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 { bufferId };
+});
+/** Haalt alle orders van dezelfde buffer als de gegeven order. */
+export const listOrdersInBufferOfOrder = 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 { bufferId: null, orders: [] };
+    const { data: siblings } = await context.supabase
+        .from("orders")
+        .select("id, order_number, customer_name, delivery_date, custom_fields")
+        .eq("buffer_id", bufferId)
+        .is("deleted_at", null)
+        .order("created_at");
+    return { bufferId, orders: siblings ?? [] };
+});