@flowselections/floriday-verkoop-module 1.0.12 → 1.0.13

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

@@ -153,9 +153,7 @@ export const createManualOrder = createServerFn({ method: "POST" })
     }
     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 orderNumber = `LOC-${Date.now()}`;
     const { data: order, error: orderErr } = await supabaseAdmin.from("orders").insert({
-        order_number: orderNumber,
         customer_name: data.customerName,
         customer_id: data.customerId,
         order_date: new Date().toISOString().slice(0, 10),
@@ -169,7 +167,7 @@ export const createManualOrder = createServerFn({ method: "POST" })
             pickup_location: data.pickupLocationId,
             carrier: data.carrierId,
         },
-    }).select("id").single();
+    }).select("id, order_number").single();
     if (orderErr)
         throw new Error(orderErr.message);
     const items = data.lines.map((l) => ({
@@ -183,6 +181,163 @@ export const createManualOrder = createServerFn({ method: "POST" })
     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 };
+});