@flowselections/floriday-verkoop-module 1.0.11 → 1.0.13

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

@@ -0,0 +1,343 @@
+// Server functions voor de handmatige "Nieuwe bestelling" flow.
+// Deelt DB-queries met de Mailbox-module zodat beide manieren van
+// orderinvoer identieke lijsten, validaties en berekeningen gebruiken.
+import { createServerFn } from "@tanstack/react-start";
+import { z } from "zod";
+import { requireSupabaseAuth } from "../integrations/supabase/auth-middleware";
+// ─── Klanten ────────────────────────────────────────────────────────────────
+export const listCustomersForCreateOrder = createServerFn({ method: "GET" })
+    .middleware([requireSupabaseAuth])
+    .handler(async ({ context }) => {
+    const { data } = await context.supabase
+        .from("customers")
+        .select("id, company_name, email")
+        .eq("is_active", true)
+        .order("company_name")
+        .range(0, 4999);
+    return { items: data ?? [] };
+});
+// ─── Producten (alleen met voorraad — zelfde filter als Mailbox) ────────────
+export const listProductsForCreateOrder = createServerFn({ method: "GET" })
+    .middleware([requireSupabaseAuth])
+    .handler(async ({ context }) => {
+    const { data: stockRows } = await context.supabase
+        .from("trade_item_stock")
+        .select("trade_item_key, physical_stock, reserved_stock");
+    const availableKeys = new Set();
+    for (const s of Array.isArray(stockRows) ? stockRows : []) {
+        const avail = Number(s.physical_stock ?? 0) - Number(s.reserved_stock ?? 0);
+        if (avail > 0 && typeof s.trade_item_key === "string") {
+            availableKeys.add(s.trade_item_key);
+        }
+    }
+    if (availableKeys.size === 0)
+        return { items: [] };
+    const { data } = await context.supabase
+        .from("products")
+        .select("id, product, unit, sale_price, plants_per_crate, crates_per_layer, layers_per_cart, custom_fields")
+        .order("product")
+        .range(0, 4999);
+    const items = (Array.isArray(data) ? data : []).filter((p) => {
+        const fid = p?.custom_fields?.floriday_id;
+        return typeof fid === "string" && availableKeys.has(fid);
+    });
+    return { items };
+});
+// ─── Afleverlocaties van geselecteerde klant ────────────────────────────────
+export const listDeliveryLocationsForCustomerCO = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((d) => z.object({ customerId: z.string().uuid() }).parse(d))
+    .handler(async ({ data, context }) => {
+    if (!data.customerId)
+        return { items: [] };
+    const { data: rows } = await context.supabase
+        .from("customer_delivery_locations")
+        .select("id, name, address_line, street, house_number, postal_code, city, province, country, is_primary, carrier_id, carriers(id, name)")
+        .eq("customer_id", data.customerId)
+        .order("is_primary", { ascending: false })
+        .order("name");
+    return { items: Array.isArray(rows) ? rows : [] };
+});
+// ─── Afhaallocaties (eigen tuinen) — Floriday warehouses ────────────────────
+export const listPickupLocationsCO = createServerFn({ method: "GET" })
+    .middleware([requireSupabaseAuth])
+    .handler(async ({ context }) => {
+    const { data } = await context.supabase
+        .from("floriday_warehouses_cache")
+        .select("floriday_id, name, data")
+        .eq("is_deleted", false);
+    const rows = Array.isArray(data) ? data : [];
+    const items = rows
+        .filter((r) => {
+        const d = r?.data ?? {};
+        return d?.hasAccess === true && d?.isExternal === false;
+    })
+        .map((r) => {
+        const addr = r?.data?.location?.address?.addressLine;
+        const city = r?.data?.location?.address?.city;
+        const nameRaw = typeof r.name === "string" ? r.name.trim() : "";
+        const label = nameRaw.length > 0
+            ? nameRaw
+            : [addr, city].filter(Boolean).join(", ") || "(naamloos)";
+        return { id: r.floriday_id, name: label };
+    })
+        .sort((a, b) => a.name.localeCompare(b.name, "nl"));
+    return { items };
+});
+// ─── Vervoerders ────────────────────────────────────────────────────────────
+export const listCarriersForCreateOrder = createServerFn({ method: "GET" })
+    .middleware([requireSupabaseAuth])
+    .handler(async ({ context }) => {
+    const { data } = await context.supabase
+        .from("carriers")
+        .select("id, name, is_default, sort_order, delivery_days")
+        .order("sort_order", { ascending: true, nullsFirst: false })
+        .order("name");
+    return { items: data ?? [] };
+});
+// ─── Orderpicktijd (dagen) ──────────────────────────────────────────────────
+export const getOrderPickDaysCO = createServerFn({ method: "GET" })
+    .middleware([requireSupabaseAuth])
+    .handler(async ({ context }) => {
+    const { data } = await context.supabase
+        .from("afhandeling_settings")
+        .select("pick_days_before_transport")
+        .order("updated_at", { ascending: false })
+        .limit(1)
+        .maybeSingle();
+    return { pickDays: Math.max(0, Number(data?.pick_days_before_transport ?? 0)) };
+});
+// ─── Handmatige bestelling aanmaken ────────────────────────────────────────
+const LineInput = z.object({
+    product_id: z.string().uuid(),
+    product_name: z.string().min(1).max(255),
+    quantity: z.number().int().positive(), // aantal PLANTEN (== fusten * plants_per_crate)
+    unit: z.string().max(50).nullable().optional(),
+    unit_price: z.number().nonnegative().optional(),
+});
+const CreateManualOrderInput = z.object({
+    customerId: z.string().uuid(),
+    customerName: z.string().min(1).max(255),
+    deliveryLocationId: z.string().uuid(),
+    pickupLocationId: z.string().min(1),
+    carrierId: z.string().uuid(),
+    deliveryDate: z.string().min(1).max(50),
+    notes: z.string().max(2000).nullable().optional(),
+    lines: z.array(LineInput).min(1),
+});
+function addCalendarDays(base, n) {
+    const x = new Date(base);
+    x.setDate(x.getDate() + n);
+    return x;
+}
+function toISODate(d) {
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+export const createManualOrder = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((input) => CreateManualOrderInput.parse(input))
+    .handler(async ({ data, context }) => {
+    // Validatie eerst mogelijke leverdatum — identiek aan approveProposal
+    const { data: c } = await context.supabase
+        .from("carriers").select("delivery_days").eq("id", data.carrierId).maybeSingle();
+    const carrierDeliveryDays = Math.max(0, Number(c?.delivery_days ?? 0));
+    const { data: settings } = await context.supabase
+        .from("afhandeling_settings")
+        .select("pick_days_before_transport")
+        .order("updated_at", { ascending: false })
+        .limit(1).maybeSingle();
+    const pickDays = Math.max(0, Number(settings?.pick_days_before_transport ?? 0));
+    const earliestISO = toISODate(addCalendarDays(new Date(), pickDays + carrierDeliveryDays));
+    if (data.deliveryDate < earliestISO) {
+        throw new Error(`Leverdatum (${data.deliveryDate}) ligt voor de eerst mogelijke datum (${earliestISO}) o.b.v. orderpicktijd (${pickDays}d) + levertijd vervoerder (${carrierDeliveryDays}d).`);
+    }
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    const total = data.lines.reduce((s, l) => s + (Number(l.unit_price ?? 0) * Number(l.quantity)), 0);
+    const { data: order, error: orderErr } = await supabaseAdmin.from("orders").insert({
+        customer_name: data.customerName,
+        customer_id: data.customerId,
+        order_date: new Date().toISOString().slice(0, 10),
+        delivery_date: data.deliveryDate,
+        status: "nieuw",
+        total: String(total.toFixed(2)),
+        notes: data.notes ?? null,
+        custom_fields: {
+            source: "manual",
+            delivery_location: data.deliveryLocationId,
+            pickup_location: data.pickupLocationId,
+            carrier: data.carrierId,
+        },
+    }).select("id, order_number").single();
+    if (orderErr)
+        throw new Error(orderErr.message);
+    const items = data.lines.map((l) => ({
+        order_id: order.id,
+        product_id: l.product_id,
+        product_name: l.product_name,
+        quantity: Math.max(1, Math.round(l.quantity)),
+        unit: l.unit ?? "stuks",
+        unit_price: l.unit_price ?? undefined,
+    }));
+    const { error: itemsErr } = await supabaseAdmin.from("order_items").insert(items);
+    if (itemsErr)
+        throw new Error(itemsErr.message);
+    // Direct karindeling berekenen, zodat het scherm ze meteen kan tonen.
+    try {
+        const { replanOrderCartsFromCron } = await import("./cart-replan.functions");
+        await replanOrderCartsFromCron(order.id);
+    }
+    catch (err) {
+        console.error("[createManualOrder] karindeling faalde:", err);
+    }
+    void context; // reserveren indien later audit-log nodig is
+    return { ok: true, orderId: order.id };
+});
+export const planAndSaveAutoCarts = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((input) => z.object({ orderId: z.string().uuid() }).parse(input))
+    .handler(async ({ data, context }) => {
+    const { data: items, error: itErr } = await context.supabase
+        .from("order_items")
+        .select("id, product_id, product_name, quantity, products(plants_per_crate, crates_per_layer, layers_per_cart)")
+        .eq("order_id", data.orderId);
+    if (itErr)
+        throw new Error(itErr.message);
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    await supabaseAdmin.from("order_carts").delete().eq("order_id", data.orderId).eq("is_auto", true);
+    let cartNumber = 1;
+    const { data: existingMax } = await supabaseAdmin
+        .from("order_carts").select("cart_number").eq("order_id", data.orderId)
+        .order("cart_number", { ascending: false }).limit(1);
+    if (existingMax && existingMax[0])
+        cartNumber = existingMax[0].cart_number + 1;
+    const autoCarts = [];
+    const remainders = [];
+    for (const it of items ?? []) {
+        const prod = it.products ?? {};
+        const ppc = Math.max(1, Number(prod.plants_per_crate ?? 1));
+        const cpl = Math.max(1, Number(prod.crates_per_layer ?? 1));
+        const lpc = Math.max(1, Number(prod.layers_per_cart ?? 1));
+        const cratesPerCart = cpl * lpc;
+        const totalPlants = Math.max(0, Number(it.quantity ?? 0));
+        const totalCrates = Math.ceil(totalPlants / ppc);
+        const fullCarts = Math.floor(totalCrates / cratesPerCart);
+        const remainder = totalCrates - fullCarts * cratesPerCart;
+        for (let i = 0; i < fullCarts; i++) {
+            const { data: cart, error: cErr } = await supabaseAdmin
+                .from("order_carts").insert({
+                order_id: data.orderId,
+                cart_number: cartNumber,
+                is_auto: true,
+                is_complete: true,
+            }).select("id").single();
+            if (cErr)
+                throw new Error(cErr.message);
+            await supabaseAdmin.from("order_cart_items").insert({
+                cart_id: cart.id,
+                order_item_id: it.id,
+                product_id: it.product_id,
+                product_name: it.product_name,
+                crates: cratesPerCart,
+                plants_per_crate: ppc,
+                crates_per_layer: cpl,
+            });
+            autoCarts.push({
+                cart_number: cartNumber,
+                product_name: it.product_name,
+                crates: cratesPerCart,
+                plants: cratesPerCart * ppc,
+                capacity: cratesPerCart,
+            });
+            cartNumber++;
+        }
+        if (remainder > 0) {
+            remainders.push({
+                order_item_id: it.id,
+                product_id: it.product_id,
+                product_name: it.product_name,
+                crates_remaining: remainder,
+                plants_per_crate: ppc,
+                crates_per_layer: cpl,
+                layers_per_cart: lpc,
+            });
+        }
+    }
+    const { data: manualCartsRaw } = await supabaseAdmin
+        .from("order_carts")
+        .select("id, cart_number, notes, order_cart_items(order_item_id, product_id, product_name, crates, plants_per_crate, crates_per_layer)")
+        .eq("order_id", data.orderId).eq("is_auto", false)
+        .order("cart_number");
+    const existingManualCarts = (manualCartsRaw ?? []).map((c) => ({
+        cart_number: c.cart_number,
+        notes: c.notes,
+        items: (c.order_cart_items ?? []).map((i) => ({
+            order_item_id: i.order_item_id,
+            product_id: i.product_id,
+            product_name: i.product_name,
+            crates: Number(i.crates ?? 0),
+            plants_per_crate: Number(i.plants_per_crate ?? 1),
+            crates_per_layer: Number(i.crates_per_layer ?? 1),
+        })),
+    }));
+    const assignedByItem = {};
+    existingManualCarts.forEach((c) => c.items.forEach((i) => {
+        if (!i.order_item_id)
+            return;
+        assignedByItem[i.order_item_id] = (assignedByItem[i.order_item_id] ?? 0) + Number(i.crates ?? 0);
+    }));
+    const adjustedRemainders = remainders
+        .map((r) => ({ ...r, crates_remaining: Math.max(0, r.crates_remaining - (assignedByItem[r.order_item_id] ?? 0)) }))
+        .filter((r) => r.crates_remaining > 0);
+    return { ok: true, autoCarts, remainders: adjustedRemainders, existingManualCarts, nextCartNumber: cartNumber };
+});
+const ManualCartItemSchema = z.object({
+    order_item_id: z.string().uuid().nullable(),
+    product_id: z.string().uuid().nullable(),
+    product_name: z.string().min(1).max(255),
+    crates: z.number().int().min(1),
+    plants_per_crate: z.number().int().min(1),
+    crates_per_layer: z.number().int().min(1),
+});
+const ManualCartSchema = z.object({
+    is_complete: z.boolean().optional(),
+    notes: z.string().max(500).nullable().optional(),
+    items: z.array(ManualCartItemSchema).min(1),
+});
+export const saveManualCarts = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((input) => z.object({ orderId: z.string().uuid(), carts: z.array(ManualCartSchema) }).parse(input))
+    .handler(async ({ data }) => {
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    await supabaseAdmin.from("order_carts").delete()
+        .eq("order_id", data.orderId).eq("is_auto", false);
+    const { data: existingMax } = await supabaseAdmin
+        .from("order_carts").select("cart_number").eq("order_id", data.orderId)
+        .order("cart_number", { ascending: false }).limit(1);
+    let cartNumber = existingMax && existingMax[0] ? existingMax[0].cart_number + 1 : 1;
+    for (const cart of data.carts) {
+        const { data: inserted, error: cErr } = await supabaseAdmin
+            .from("order_carts").insert({
+            order_id: data.orderId,
+            cart_number: cartNumber,
+            is_auto: false,
+            is_complete: !!cart.is_complete,
+            notes: cart.notes ?? null,
+        }).select("id").single();
+        if (cErr)
+            throw new Error(cErr.message);
+        const rows = cart.items.map((i) => ({
+            cart_id: inserted.id,
+            order_item_id: i.order_item_id,
+            product_id: i.product_id,
+            product_name: i.product_name,
+            crates: i.crates,
+            plants_per_crate: i.plants_per_crate,
+            crates_per_layer: i.crates_per_layer,
+        }));
+        const { error: iErr } = await supabaseAdmin.from("order_cart_items").insert(rows);
+        if (iErr)
+            throw new Error(iErr.message);
+        cartNumber++;
+    }
+    return { ok: true };
+});