@flowselections/floriday-verkoop-module 1.0.17 → 1.0.19

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

@@ -16,28 +16,61 @@ export const listCustomersForCreateOrder = createServerFn({ method: "GET" })
         .range(0, 4999);
     return { items: data ?? [] };
 });
-// ─── Producten (uit voorraadmodule: alle actieve Floriday trade items) ─────
-// Bron = zelfde data als de Voorraad-pagina: floriday_trade_items_cache
-// gejoined met trade_item_stock. Items zonder voorraad worden ook getoond
-// (grijs in de UI, met melding "niet op voorraad"), zodat gebruikers ook
-// vooruit kunnen bestellen op verwachte voorraad.
+// ─── Producten (uit voorraadmodule) ────────────────────────────────────────
+// Bron = de volledige voorraad, ongeacht Floriday-publicatie:
+//  1) floriday_trade_items_cache — gepubliceerde Floriday trade items
+//  2) trade_item_drafts          — interne artikelen (o.a. BV-artikelcodes)
+//  3) product_groups             — productgroepen / samenstellingen
+//  4) products                   — losse voorraadartikelen (fallback)
+// Stock komt uit trade_item_stock (key-formaten: `<floriday_id>`,
+// `draft:<uuid>`, `product:<uuid>`, `group:<uuid>`).
 export const listProductsForCreateOrder = createServerFn({ method: "GET" })
     .middleware([requireSupabaseAuth])
     .handler(async ({ context }) => {
-    const [tradeItemsRes, stockRes] = await Promise.all([
+    const [tradeItemsRes, draftsRes, groupsRes, groupItemsRes, productsRes] = await Promise.all([
         context.supabase
             .from("floriday_trade_items_cache")
             .select("floriday_id, data")
             .eq("is_deleted", false)
             .range(0, 4999),
         context.supabase
-            .from("trade_item_stock")
-            .select("trade_item_key, physical_stock, reserved_stock, incoming_stock"),
+            .from("trade_item_drafts")
+            .select("id, data, floriday_id")
+            .range(0, 4999),
+        context.supabase
+            .from("product_groups")
+            .select("id, name, description, is_active, head_trade_item_floriday_id, head_product_id")
+            .eq("is_active", true)
+            .range(0, 4999),
+        context.supabase
+            .from("product_group_items")
+            .select("product_group_id, trade_item_id, sort_order")
+            .order("sort_order", { ascending: true })
+            .range(0, 9999),
+        context.supabase
+            .from("products")
+            .select("id, product, unit, sale_price, plants_per_crate, crates_per_layer, layers_per_cart, quantity, custom_fields")
+            .range(0, 4999),
     ]);
-    const tradeItems = tradeItemsRes.data;
-    const stockRows = stockRes.data;
+    // Supabase geeft standaard max. 1000 rijen terug. Voor productgroepen kan de
+    // relevante voorraad op een member-key verderop in trade_item_stock staan,
+    // dus voorraad pagineren we expliciet volledig uit.
+    const stockRows = [];
+    const stockPageSize = 1000;
+    for (let from = 0; from < 50000; from += stockPageSize) {
+        const { data: batch, error } = await context.supabase
+            .from("trade_item_stock")
+            .select("trade_item_key, physical_stock, reserved_stock, incoming_stock")
+            .range(from, from + stockPageSize - 1);
+        if (error)
+            throw error;
+        const rows = Array.isArray(batch) ? batch : [];
+        stockRows.push(...rows);
+        if (rows.length < stockPageSize)
+            break;
+    }
     const stockByKey = new Map();
-    for (const s of Array.isArray(stockRows) ? stockRows : []) {
+    for (const s of stockRows) {
         const k = s?.trade_item_key;
         if (typeof k !== "string")
             continue;
@@ -54,35 +87,278 @@ export const listProductsForCreateOrder = createServerFn({ method: "GET" })
             return n;
         return String(n.nl ?? n.en ?? n.de ?? Object.values(n)[0] ?? "");
     };
-    const items = (Array.isArray(tradeItems) ? tradeItems : [])
-        .map((r) => {
+    const byId = new Map();
+    // Dedup-index op logische identiteit (article_code of genormaliseerde naam),
+    // zodat hetzelfde product niet twee keer verschijnt als het zowel als
+    // Floriday-item, draft én products-rij bestaat.
+    const identityIndex = new Map(); // identityKey -> byId key
+    const norm = (s) => s.trim().toLowerCase().replace(/\s+/g, " ");
+    const identityKeysFor = (name, articleCode) => {
+        const keys = [];
+        if (articleCode && articleCode.trim())
+            keys.push(`ac:${norm(articleCode)}`);
+        if (name && name.trim())
+            keys.push(`nm:${norm(name)}`);
+        return keys;
+    };
+    const registerIdentity = (id, name, articleCode) => {
+        for (const k of identityKeysFor(name, articleCode)) {
+            if (!identityIndex.has(k))
+                identityIndex.set(k, id);
+        }
+    };
+    const findExistingId = (name, articleCode) => {
+        for (const k of identityKeysFor(name, articleCode)) {
+            const hit = identityIndex.get(k);
+            if (hit)
+                return hit;
+        }
+        return null;
+    };
+    const stockOf = (key) => {
+        const s = stockByKey.get(key);
+        const physical = s?.physical ?? 0;
+        const reserved = s?.reserved ?? 0;
+        return { physical, reserved, available: Math.max(0, physical - reserved) };
+    };
+    const stockOfAliases = (keys) => {
+        let fallback = null;
+        for (const k of keys) {
+            const s = stockByKey.get(k);
+            if (!s)
+                continue;
+            fallback ?? (fallback = s);
+            if (s.physical !== 0 || s.reserved !== 0 || s.incoming !== 0)
+                return s;
+        }
+        return fallback ?? { physical: 0, reserved: 0, incoming: 0 };
+    };
+    // Bouw index: draft_id/floriday_id → mirror products.id. De voorraad kan
+    // op de mirror-key (`product:<mirrorId>`) staan i.p.v. op `draft:<id>`
+    // of het bare Floriday-id.
+    const mirrorProductIdsByDraft = new Map();
+    const mirrorProductIdsByFloriday = new Map();
+    for (const p of Array.isArray(productsRes.data) ? productsRes.data : []) {
+        const cf = (p.custom_fields ?? {});
+        const pid = p.id;
+        const draftId = typeof cf.draft_id === "string" ? cf.draft_id : null;
+        const floridayId = typeof cf.floriday_id === "string" ? cf.floriday_id : null;
+        if (draftId) {
+            const arr = mirrorProductIdsByDraft.get(draftId) ?? [];
+            arr.push(pid);
+            mirrorProductIdsByDraft.set(draftId, arr);
+        }
+        if (floridayId) {
+            const arr = mirrorProductIdsByFloriday.get(floridayId) ?? [];
+            arr.push(pid);
+            mirrorProductIdsByFloriday.set(floridayId, arr);
+        }
+    }
+    // 1) Floriday trade items
+    for (const r of Array.isArray(tradeItemsRes.data) ? tradeItemsRes.data : []) {
         const d = r?.data ?? {};
         const name = pickName(d.tradeItemName) || d.tradeItemReference || "(naamloos)";
         const packs = Array.isArray(d.packingConfigurations) ? d.packingConfigurations : [];
-        const primary = packs.find((p) => p?.primary) ?? packs[0] ?? {};
-        const ppc = Math.max(1, Number(primary?.piecesPerPackage ?? 1));
-        const cpl = Math.max(1, Number(primary?.packagesPerLayer ?? 1));
-        const lpc = Math.max(1, Number(primary?.layersPerLoadCarrier ?? 1));
-        const stock = stockByKey.get(r.floriday_id);
-        const physical = stock?.physical ?? 0;
-        const reserved = stock?.reserved ?? 0;
+        const primary = packs.find((p) => p?.primary || p?.isPrimary) ?? packs[0] ?? {};
+        const id = r.floriday_id;
+        const articleCode = d.supplierArticleCode ?? null;
+        const mirrorKeys = (mirrorProductIdsByFloriday.get(id) ?? []).map((pid) => `product:${pid}`);
+        const sAgg = stockOfAliases([id, ...mirrorKeys]);
+        const physical = sAgg.physical;
+        const reserved = sAgg.reserved;
         const available = Math.max(0, physical - reserved);
-        return {
-            id: r.floriday_id,
+        byId.set(id, {
+            id,
             product: name,
-            article_code: d.supplierArticleCode ?? null,
+            article_code: articleCode,
             unit: "stuks",
             sale_price: null,
-            plants_per_crate: ppc,
-            crates_per_layer: cpl,
-            layers_per_cart: lpc,
+            plants_per_crate: Math.max(1, Number(primary?.piecesPerPackage ?? primary?.unitsPerPackage ?? 1)),
+            crates_per_layer: Math.max(1, Number(primary?.packagesPerLayer ?? 1)),
+            layers_per_cart: Math.max(1, Number(primary?.layersPerLoadCarrier ?? 1)),
             physical_stock: physical,
             reserved_stock: reserved,
             available_stock: available,
             in_stock: available > 0,
-        };
-    })
-        .sort((a, b) => {
+            source: "floriday",
+        });
+        registerIdentity(id, name, articleCode);
+    }
+    // 2) Interne concept-artikelen (BV-codes, Excel-import, etc.)
+    for (const r of Array.isArray(draftsRes.data) ? draftsRes.data : []) {
+        const d = r?.data ?? {};
+        // Sla drafts over die al als Floriday-item verschijnen
+        const linkedFloridayId = r.floriday_id;
+        if (linkedFloridayId && byId.has(linkedFloridayId))
+            continue;
+        const id = r.id;
+        const name = pickName(d.name) || pickName(d.tradeItemName) || d.articleCode || "(naamloos concept)";
+        const articleCode = d.articleCode ?? d.supplierArticleCode ?? null;
+        // Skip als er al een logisch identiek item bestaat (zelfde artikelcode of naam)
+        if (findExistingId(name, articleCode))
+            continue;
+        const packs = Array.isArray(d.packingConfigurations) ? d.packingConfigurations : [];
+        const primary = packs.find((p) => p?.primary || p?.isPrimary) ?? packs[0] ?? {};
+        const draftMirrorKeys = (mirrorProductIdsByDraft.get(id) ?? []).map((pid) => `product:${pid}`);
+        const sAggD = stockOfAliases([`draft:${id}`, ...draftMirrorKeys]);
+        const physical = sAggD.physical;
+        const reserved = sAggD.reserved;
+        const available = Math.max(0, physical - reserved);
+        byId.set(id, {
+            id,
+            product: name,
+            article_code: articleCode,
+            unit: "stuks",
+            sale_price: typeof d.salePricePerPiece === "number" ? d.salePricePerPiece : null,
+            // Drafts gebruiken Floriday-veldnamen: unitsPerPackage / packagesPerLayer / layersPerLoadCarrier
+            plants_per_crate: Math.max(1, Number(primary?.unitsPerPackage ?? primary?.piecesPerPackage ?? 1)),
+            crates_per_layer: Math.max(1, Number(primary?.packagesPerLayer ?? 1)),
+            layers_per_cart: Math.max(1, Number(primary?.layersPerLoadCarrier ?? 1)),
+            physical_stock: physical,
+            reserved_stock: reserved,
+            available_stock: available,
+            in_stock: available > 0,
+            source: "draft",
+        });
+        registerIdentity(id, name, articleCode);
+    }
+    // 3) Productgroepen (samenstellingen) — belading komt van het eerste
+    //    (hoogst gerangschikte) product uit de verkoopranglijst binnen de groep.
+    //    Bij een wijziging in sort_order past de belading zich automatisch aan
+    //    omdat we hier live opnieuw kijken naar de bovenste rij.
+    const groupItemsByGroup = new Map();
+    for (const gi of Array.isArray(groupItemsRes.data) ? groupItemsRes.data : []) {
+        const gid = gi.product_group_id;
+        const arr = groupItemsByGroup.get(gid) ?? [];
+        arr.push({
+            trade_item_id: gi.trade_item_id,
+            sort_order: Number(gi.sort_order ?? 0),
+        });
+        groupItemsByGroup.set(gid, arr);
+    }
+    // Products-rijen ook indexeren, zodat groep-members die naar een products.id
+    // wijzen (i.p.v. floriday_id of draft-id) alsnog gevonden worden.
+    const productsById = new Map();
+    for (const p of Array.isArray(productsRes.data) ? productsRes.data : []) {
+        productsById.set(p.id, p);
+    }
+    const packingFromProductRow = (p) => ({
+        plants_per_crate: Math.max(1, Number(p?.plants_per_crate ?? 1)),
+        crates_per_layer: Math.max(1, Number(p?.crates_per_layer ?? 1)),
+        layers_per_cart: Math.max(1, Number(p?.layers_per_cart ?? 1)),
+    });
+    for (const r of Array.isArray(groupsRes.data) ? groupsRes.data : []) {
+        const id = r.id;
+        if (byId.has(id))
+            continue;
+        const groupName = r.name ?? "(naamloos)";
+        // Groepen laten we niet dupliceren met een gelijknamig product/draft:
+        // de groep wint (want geeft samenstelling). Verwijder een eerder toegevoegd
+        // los product met dezelfde identiteit.
+        const displayName = `[Groep] ${groupName}`;
+        const dup = findExistingId(groupName, null);
+        if (dup && byId.has(dup))
+            byId.delete(dup);
+        // Voorraad: eigen key `group:<id>` óf gesommeerd over de members
+        // (voorraad kan op de member-id, `draft:<id>` of `product:<id>` staan).
+        let { physical, reserved, available } = stockOf(`group:${id}`);
+        const members = (groupItemsByGroup.get(id) ?? [])
+            .slice()
+            .sort((a, b) => a.sort_order - b.sort_order);
+        if (physical === 0 && reserved === 0) {
+            let phySum = 0;
+            let resSum = 0;
+            for (const m of members) {
+                const s = stockOfAliases([`draft:${m.trade_item_id}`, `product:${m.trade_item_id}`, m.trade_item_id]);
+                phySum += s.physical;
+                resSum += s.reserved;
+            }
+            physical = phySum;
+            reserved = resSum;
+            available = Math.max(0, physical - reserved);
+        }
+        // Probeer belading van de bovenste member; val terug op head_trade_item /
+        // head_product_id als de member niet in byId of products staat.
+        let packing = { plants_per_crate: 1, crates_per_layer: 1, layers_per_cart: 1 };
+        const candidates = [
+            members[0]?.trade_item_id ?? null,
+            r.head_trade_item_floriday_id ?? null,
+            r.head_product_id ?? null,
+        ];
+        for (const cand of candidates) {
+            if (!cand)
+                continue;
+            const fromBy = byId.get(cand);
+            if (fromBy) {
+                packing = {
+                    plants_per_crate: fromBy.plants_per_crate,
+                    crates_per_layer: fromBy.crates_per_layer,
+                    layers_per_cart: fromBy.layers_per_cart,
+                };
+                break;
+            }
+            const fromProd = productsById.get(cand);
+            if (fromProd) {
+                packing = packingFromProductRow(fromProd);
+                break;
+            }
+        }
+        byId.set(id, {
+            id,
+            product: displayName,
+            article_code: null,
+            unit: "stuks",
+            sale_price: null,
+            plants_per_crate: packing.plants_per_crate,
+            crates_per_layer: packing.crates_per_layer,
+            layers_per_cart: packing.layers_per_cart,
+            physical_stock: physical,
+            reserved_stock: reserved,
+            available_stock: available,
+            in_stock: available > 0,
+            source: "group",
+        });
+        registerIdentity(id, groupName, null);
+    }
+    // 4) Losse voorraadartikelen (products-tabel) — fallback
+    for (const r of Array.isArray(productsRes.data) ? productsRes.data : []) {
+        const id = r.id;
+        if (byId.has(id))
+            continue;
+        const cf = (r.custom_fields ?? {});
+        // Sla mirrors van Floriday/draft items over
+        if (typeof cf.floriday_id === "string" && byId.has(cf.floriday_id))
+            continue;
+        if (typeof cf.draft_id === "string" && byId.has(cf.draft_id))
+            continue;
+        const name = r.product ?? "(naamloos)";
+        const articleCode = cf.article_code ?? null;
+        // Skip als er al een logisch identiek item (draft/floriday/group) bestaat
+        if (findExistingId(name, articleCode))
+            continue;
+        const stockA = stockOf(`product:${id}`);
+        const stockB = stockOf(id);
+        const physical = stockA.physical || stockB.physical || Number(r.quantity ?? 0);
+        const reserved = stockA.reserved || stockB.reserved || 0;
+        const available = Math.max(0, physical - reserved);
+        byId.set(id, {
+            id,
+            product: name,
+            article_code: articleCode,
+            unit: r.unit ?? "stuks",
+            sale_price: r.sale_price ?? null,
+            plants_per_crate: Math.max(1, Number(r.plants_per_crate ?? 1)),
+            crates_per_layer: Math.max(1, Number(r.crates_per_layer ?? 1)),
+            layers_per_cart: Math.max(1, Number(r.layers_per_cart ?? 1)),
+            physical_stock: physical,
+            reserved_stock: reserved,
+            available_stock: available,
+            in_stock: available > 0,
+            source: "product",
+        });
+        registerIdentity(id, name, articleCode);
+    }
+    const items = Array.from(byId.values()).sort((a, b) => {
         if (a.in_stock !== b.in_stock)
             return a.in_stock ? -1 : 1;
         return a.product.localeCompare(b.product, "nl");
@@ -172,7 +448,8 @@ const CreateManualOrderInput = z.object({
     deliveryLocationId: z.string().uuid(),
     pickupLocationId: z.string().min(1),
     carrierId: z.string().uuid(),
-    deliveryDate: z.string().min(1).max(50),
+    deliveryDate: z.string().min(1).max(50).nullable().optional(),
+    isReservation: z.boolean().optional(),
     notes: z.string().max(2000).nullable().optional(),
     lines: z.array(LineInput).min(1),
 });
@@ -199,49 +476,118 @@ export const createManualOrder = createServerFn({ method: "POST" })
         .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).`);
+    if (!data.isReservation) {
+        if (!data.deliveryDate)
+            throw new Error("Leverdatum ontbreekt.");
+        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");
-    // Zorg dat elk product_id (= trade_item_key uit voorraad) een rij in
-    // `products` heeft — de order_items FK vereist dit én de karindeling
+    // Zorg dat elk product_id (= identiteit uit de voorraadmodule) een rij
+    // in `products` heeft — de order_items FK vereist dit én de karindeling
     // (planAndSaveAutoCarts) joined op products voor de packing-waarden.
+    //
+    // BELANGRIJK: de wizard geeft als product_id een identiteit terug die uit
+    // 1 van 4 bronnen komt: floriday_trade_items_cache.floriday_id,
+    // trade_item_drafts.id, product_groups.id, of products.id. Om te
+    // voorkomen dat de voorraadmodule onze "spiegelrijen" verwart met
+    // eigen data, zetten we per bron het juiste `trade_item_key`-formaat,
+    // een niet-misleidend `article_number` en een duidelijke `source` in
+    // `custom_fields` (zodat de voorraadmodule ze veilig kan negeren of
+    // opruimen).
     const productIds = Array.from(new Set(data.lines.map((l) => l.product_id)));
-    const { data: existingProducts } = await supabaseAdmin
-        .from("products").select("id").in("id", productIds);
-    const existingIds = new Set((existingProducts ?? []).map((p) => p.id));
-    const missingLines = data.lines.filter((l) => !existingIds.has(l.product_id));
+    const [existingProductsRes, draftsRes, floridayRes, groupsRes] = await Promise.all([
+        supabaseAdmin.from("products").select("id").in("id", productIds),
+        supabaseAdmin.from("trade_item_drafts").select("id, data").in("id", productIds),
+        supabaseAdmin.from("floriday_trade_items_cache").select("floriday_id, data").in("floriday_id", productIds),
+        supabaseAdmin.from("product_groups").select("id, name").in("id", productIds),
+    ]);
+    const existingIds = new Set((existingProductsRes.data ?? []).map((p) => p.id));
+    const draftById = new Map();
+    for (const r of draftsRes.data ?? [])
+        draftById.set(r.id, r.data ?? {});
+    const floridayById = new Map();
+    for (const r of floridayRes.data ?? [])
+        floridayById.set(r.floriday_id, r.data ?? {});
+    const groupById = new Map();
+    for (const r of groupsRes.data ?? [])
+        groupById.set(r.id, r);
+    // Groepen krijgen GEEN spiegelrij in `products`: de database heeft een
+    // trigger die id-botsingen tussen products en product_groups tegenhoudt.
+    // De order-regel wordt daarom met product_id = null én naamprefix
+    // "[Groep] <naam>" opgeslagen; expand-group-order-items resolvt de groep
+    // dan op naam en splitst hem in members.
+    const missingLines = data.lines.filter((l) => !existingIds.has(l.product_id) && !groupById.has(l.product_id));
     if (missingLines.length > 0) {
+        const shortRand = () => Array.from({ length: 6 }, () => Math.floor(Math.random() * 16).toString(16).toUpperCase()).join("");
         const seen = new Set();
         const toInsert = missingLines.filter((l) => {
             if (seen.has(l.product_id))
                 return false;
             seen.add(l.product_id);
             return true;
-        }).map((l) => ({
-            id: l.product_id,
-            product: l.product_name,
-            batch: "",
-            location: "",
-            unit: l.unit ?? "stuks",
-            plants_per_crate: Math.max(1, Number(l.plants_per_crate ?? 1)),
-            crates_per_layer: Math.max(1, Number(l.crates_per_layer ?? 1)),
-            layers_per_cart: Math.max(1, Number(l.layers_per_cart ?? 1)),
-            sale_price: l.unit_price ?? null,
-            trade_item_key: l.product_id,
-            custom_fields: { floriday_id: l.product_id, source: "auto-from-voorraad" },
-        }));
-        const { error: prodErr } = await supabaseAdmin.from("products").insert(toInsert);
-        if (prodErr)
-            throw new Error(`Product aanmaken faalde: ${prodErr.message}`);
+        }).map((l) => {
+            const id = l.product_id;
+            let source = "unknown";
+            let tradeItemKey = id;
+            let articleNumber = null;
+            const customFields = {};
+            if (draftById.has(id)) {
+                source = "draft";
+                const draft = draftById.get(id) ?? {};
+                tradeItemKey = `draft:${id}`;
+                articleNumber = (typeof draft.articleCode === "string" && draft.articleCode.trim())
+                    ? String(draft.articleCode).trim()
+                    : `DRAFT-${shortRand()}`;
+                customFields.draft_id = id;
+                customFields.source = "sales-module-draft-mirror";
+            }
+            else if (floridayById.has(id)) {
+                source = "floriday";
+                const fd = floridayById.get(id) ?? {};
+                tradeItemKey = id; // Floriday-format is de kale floriday_id
+                articleNumber = (typeof fd.supplierArticleCode === "string" && fd.supplierArticleCode.trim())
+                    ? String(fd.supplierArticleCode).trim()
+                    : `FLR-${shortRand()}`;
+                customFields.floriday_id = id;
+                customFields.source = "sales-module-floriday-mirror";
+            }
+            else {
+                source = "unknown";
+                tradeItemKey = `product:${id}`;
+                articleNumber = l.article_code?.trim() || `ART-${shortRand()}`;
+                customFields.source = "sales-module-unknown-mirror";
+            }
+            return {
+                id,
+                product: l.product_name,
+                batch: "",
+                location: "",
+                unit: l.unit ?? "stuks",
+                plants_per_crate: Math.max(1, Number(l.plants_per_crate ?? 1)),
+                crates_per_layer: Math.max(1, Number(l.crates_per_layer ?? 1)),
+                layers_per_cart: Math.max(1, Number(l.layers_per_cart ?? 1)),
+                sale_price: l.unit_price ?? null,
+                trade_item_key: tradeItemKey,
+                article_number: articleNumber,
+                custom_fields: { ...customFields, mirror_kind: source },
+            };
+        });
+        if (toInsert.length > 0) {
+            const { error: prodErr } = await supabaseAdmin.from("products").insert(toInsert);
+            if (prodErr)
+                throw new Error(`Product aanmaken faalde: ${prodErr.message}`);
+        }
     }
     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",
+        delivery_date: data.isReservation ? null : data.deliveryDate,
+        is_reservation: !!data.isReservation,
+        status: data.isReservation ? "gereserveerd" : "nieuw",
         total: String(total.toFixed(2)),
         notes: data.notes ?? null,
         custom_fields: {
@@ -249,18 +595,29 @@ export const createManualOrder = createServerFn({ method: "POST" })
             delivery_location: data.deliveryLocationId,
             pickup_location: data.pickupLocationId,
             carrier: data.carrierId,
+            is_reservation: !!data.isReservation,
         },
     }).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 items = data.lines.map((l) => {
+        const isGroup = groupById.has(l.product_id);
+        const groupRow = isGroup ? groupById.get(l.product_id) : null;
+        const groupName = groupRow?.name ?? l.product_name;
+        const displayName = isGroup
+            ? (/^\s*\[Groep\]/i.test(l.product_name) ? l.product_name : `[Groep] ${groupName}`)
+            : l.product_name;
+        return {
+            order_id: order.id,
+            // Groepen krijgen product_id = null; expand-group-order-items
+            // resolvt hen op naam ("[Groep] <naam>").
+            product_id: isGroup ? null : l.product_id,
+            product_name: displayName,
+            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);
@@ -275,6 +632,112 @@ export const createManualOrder = createServerFn({ method: "POST" })
     void context; // reserveren indien later audit-log nodig is
     return { ok: true, orderId: order.id };
 });
+// ─── Verwijderen van een lokale bestelling ────────────────────────────────
+// Draait alle voorraadmutaties van deze order terug (fysiek + gereserveerd)
+// en verwijdert de order (order_items, order_carts en cart_replan_queue via
+// cascade). FO-orders (Floriday) worden geweigerd — die kunnen alleen via
+// Floriday zelf worden geannuleerd.
+export const deleteLocalOrder = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((input) => z.object({ orderId: z.string().uuid() }).parse(input))
+    .handler(async ({ data, context }) => {
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    const { data: order, error: oErr } = await supabaseAdmin
+        .from("orders")
+        .select("id, custom_fields, order_source")
+        .eq("id", data.orderId)
+        .maybeSingle();
+    if (oErr)
+        throw new Error(oErr.message);
+    if (!order)
+        throw new Error("Bestelling niet gevonden");
+    const cf = order.custom_fields ?? {};
+    const src = String(cf?.source ?? order.order_source ?? "").toLowerCase();
+    if (src === "floriday" || src === "fo") {
+        throw new Error("FO-orders kunnen niet verwijderd worden. Annuleer deze in Floriday.");
+    }
+    // Voorraadmutaties terugdraaien.
+    const { data: mutations, error: mErr } = await supabaseAdmin
+        .from("stock_mutation_log")
+        .select("trade_item_key, qty_delta, physical_before, physical_after, reserved_before, reserved_after")
+        .eq("order_id", data.orderId);
+    if (mErr)
+        throw new Error(`Voorraadmutaties ophalen faalde: ${mErr.message}`);
+    const perKey = new Map();
+    for (const m of mutations ?? []) {
+        const key = m.trade_item_key;
+        if (!key)
+            continue;
+        const pd = Number(m.physical_after ?? 0) - Number(m.physical_before ?? 0);
+        const rd = Number(m.reserved_after ?? 0) - Number(m.reserved_before ?? 0);
+        const qd = Number(m.qty_delta ?? 0);
+        const cur = perKey.get(key) ?? { physicalDelta: 0, reservedDelta: 0, qtyDelta: 0 };
+        cur.physicalDelta += pd;
+        cur.reservedDelta += rd;
+        cur.qtyDelta += qd;
+        perKey.set(key, cur);
+    }
+    const reversalRows = [];
+    for (const [key, agg] of perKey.entries()) {
+        if (agg.physicalDelta === 0 && agg.reservedDelta === 0)
+            continue;
+        const { data: stockRows } = await supabaseAdmin
+            .from("trade_item_stock")
+            .select("id, connection_id, physical_stock, reserved_stock")
+            .eq("trade_item_key", key);
+        for (const s of stockRows ?? []) {
+            const physBefore = Number(s.physical_stock ?? 0);
+            const resvBefore = Number(s.reserved_stock ?? 0);
+            const physAfter = physBefore - agg.physicalDelta;
+            const resvAfter = Math.max(0, resvBefore - agg.reservedDelta);
+            const { error: uErr } = await supabaseAdmin.from("trade_item_stock")
+                .update({
+                physical_stock: physAfter,
+                reserved_stock: resvAfter,
+                updated_at: new Date().toISOString(),
+            })
+                .eq("id", s.id);
+            if (uErr)
+                throw new Error(`Voorraad terugdraaien faalde: ${uErr.message}`);
+            reversalRows.push({
+                trade_item_key: key,
+                connection_id: s.connection_id,
+                order_id: data.orderId,
+                order_source: src || "manual",
+                mutation_type: "reversal",
+                qty_delta: -agg.qtyDelta,
+                physical_before: physBefore,
+                physical_after: physAfter,
+                reserved_before: resvBefore,
+                reserved_after: resvAfter,
+                reason: "Bestelling verwijderd — mutaties teruggedraaid",
+                created_by: context.userId,
+            });
+        }
+    }
+    if (reversalRows.length > 0) {
+        const { error: lErr } = await supabaseAdmin.from("stock_mutation_log").insert(reversalRows);
+        if (lErr)
+            throw new Error(`Reversal-log schrijven faalde: ${lErr.message}`);
+    }
+    // Eerst order_items verwijderen — de AFTER DELETE trigger op order_items
+    // enqueue't naar cart_replan_queue met order_id, dus de orders-rij moet
+    // op dat moment nog bestaan (anders FK-violation).
+    await supabaseAdmin.from("order_items").delete().eq("order_id", data.orderId);
+    // Queue-entries opruimen die de trigger zojuist heeft aangemaakt.
+    await supabaseAdmin.from("cart_replan_queue").delete().eq("order_id", data.orderId);
+    const { error: dErr } = await supabaseAdmin
+        .from("orders")
+        .delete()
+        .eq("id", data.orderId);
+    if (dErr)
+        throw new Error(`Bestelling verwijderen faalde: ${dErr.message}`);
+    return {
+        ok: true,
+        reversedKeys: perKey.size,
+        reversalEntries: reversalRows.length,
+    };
+});
 export const planAndSaveAutoCarts = createServerFn({ method: "POST" })
     .middleware([requireSupabaseAuth])
     .inputValidator((input) => z.object({ orderId: z.string().uuid() }).parse(input))
@@ -424,3 +887,290 @@ export const saveManualCarts = createServerFn({ method: "POST" })
     }
     return { ok: true };
 });
+// ─── Lokale bestelling bewerken (aantal + leverdatum) ─────────────────────
+// Alleen voor lokale/handmatige bestellingen. FO-orders worden geweigerd.
+// Stock (reserved) en karindeling worden automatisch bijgewerkt door
+// DB-triggers op order_items / orders (trg_order_items_reserve,
+// trg_orders_recompute_reserved, orders_replan_trg, order_items_replan_trg).
+const UpdateLocalOrderInput = z.object({
+    orderId: z.string().uuid(),
+    deliveryDate: z.string().min(1).max(50).optional(),
+    items: z
+        .array(z.object({
+        itemId: z.string().uuid(),
+        quantity: z.number().int().positive(),
+    }))
+        .optional(),
+});
+export const getLocalOrderForEdit = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((input) => z.object({ orderId: z.string().uuid() }).parse(input))
+    .handler(async ({ data, context }) => {
+    const { data: order, error: oErr } = await context.supabase
+        .from("orders")
+        .select("id, delivery_date, custom_fields, order_source, order_number, is_reservation, status")
+        .eq("id", data.orderId)
+        .maybeSingle();
+    if (oErr)
+        throw new Error(oErr.message);
+    if (!order)
+        throw new Error("Bestelling niet gevonden");
+    const cf = order.custom_fields ?? {};
+    const src = String(cf?.source ?? order.order_source ?? "").toLowerCase();
+    if (src === "floriday" || src === "fo") {
+        throw new Error("FO-orders kunnen niet bewerkt worden.");
+    }
+    const { data: items, error: iErr } = await context.supabase
+        .from("order_items")
+        .select("id, product_id, product_name, quantity, unit, products(plants_per_crate)")
+        .eq("order_id", data.orderId)
+        .order("id");
+    if (iErr)
+        throw new Error(iErr.message);
+    // Voor group order-items (en items die naar drafts/trade_items verwijzen)
+    // levert de products-join niets op. Resolve belading via:
+    //  1) product_groups → product_group_items → belading van eerste member
+    //     (via products / trade_item_drafts / floriday_trade_items_cache)
+    //  2) direct via drafts/cache voor niet-group items
+    const rows = (items ?? []);
+    const GROUP_PREFIX = /^\s*\[Groep\]\s*/i;
+    // Verzamel group-ids (per id of per naam)
+    const groupCandidateIds = rows
+        .filter((it) => it.product_id && !it.products)
+        .map((it) => it.product_id);
+    const groupNameCandidates = Array.from(new Set(rows
+        .filter((it) => !it.product_id && GROUP_PREFIX.test(it.product_name ?? ""))
+        .map((it) => it.product_name.replace(GROUP_PREFIX, "").trim())
+        .filter(Boolean)));
+    const groupIdSet = new Set();
+    const groupIdByName = new Map();
+    if (groupCandidateIds.length || groupNameCandidates.length) {
+        const [byId, byName] = await Promise.all([
+            groupCandidateIds.length
+                ? context.supabase.from("product_groups").select("id, name").in("id", groupCandidateIds)
+                : Promise.resolve({ data: [] }),
+            groupNameCandidates.length
+                ? context.supabase.from("product_groups").select("id, name").in("name", groupNameCandidates)
+                : Promise.resolve({ data: [] }),
+        ]);
+        for (const g of byId.data ?? [])
+            groupIdSet.add(g.id);
+        for (const g of byName.data ?? []) {
+            groupIdSet.add(g.id);
+            groupIdByName.set(g.name.trim().toLowerCase(), g.id);
+        }
+    }
+    // Members per group
+    const memberMap = new Map();
+    const memberIds = new Set();
+    if (groupIdSet.size) {
+        const { data: gis } = await context.supabase
+            .from("product_group_items")
+            .select("product_group_id, trade_item_id, sort_order")
+            .in("product_group_id", Array.from(groupIdSet));
+        for (const gi of gis ?? []) {
+            const gid = gi.product_group_id;
+            const arr = memberMap.get(gid) ?? [];
+            arr.push({
+                trade_item_id: gi.trade_item_id,
+                sort_order: Number(gi.sort_order ?? 0),
+            });
+            memberMap.set(gid, arr);
+            memberIds.add(gi.trade_item_id);
+        }
+    }
+    // Ook non-group items zonder products-join proberen we via drafts/cache.
+    const directIds = rows
+        .filter((it) => it.product_id && !it.products && !groupIdSet.has(it.product_id))
+        .map((it) => it.product_id);
+    for (const id of directIds)
+        memberIds.add(id);
+    const ppcById = new Map();
+    if (memberIds.size) {
+        const ids = Array.from(memberIds);
+        const [prodRes, draftRes, tradeRes] = await Promise.all([
+            context.supabase
+                .from("products")
+                .select("id, plants_per_crate, custom_fields")
+                .or(`id.in.(${ids.join(",")}),custom_fields->>floriday_id.in.(${ids.join(",")})`),
+            context.supabase.from("trade_item_drafts").select("id, data").in("id", ids),
+            context.supabase.from("floriday_trade_items_cache").select("floriday_id, data").in("floriday_id", ids),
+        ]);
+        for (const p of prodRes.data ?? []) {
+            const ppc = Math.max(1, Number(p.plants_per_crate ?? 1));
+            ppcById.set(p.id, ppc);
+            const fid = p.custom_fields?.floriday_id;
+            if (fid && !ppcById.has(fid))
+                ppcById.set(fid, ppc);
+        }
+        for (const d of draftRes.data ?? []) {
+            if (ppcById.has(d.id))
+                continue;
+            const cfg = Array.isArray(d.data?.packingConfigurations)
+                ? (d.data.packingConfigurations.find((c) => c?.isPrimary) ??
+                    d.data.packingConfigurations[0])
+                : null;
+            const ppc = Math.max(1, Number(cfg?.unitsPerPackage ?? cfg?.piecesPerPackage ?? 1));
+            if (ppc > 1)
+                ppcById.set(d.id, ppc);
+        }
+        for (const t of tradeRes.data ?? []) {
+            if (ppcById.has(t.floriday_id))
+                continue;
+            const cfg = t.data?.packingConfiguration;
+            const ppc = Math.max(1, Number(cfg?.piecesPerPackage ?? cfg?.unitsPerPackage ?? 1));
+            if (ppc > 1)
+                ppcById.set(t.floriday_id, ppc);
+        }
+    }
+    const groupPpc = (groupId) => {
+        const members = (memberMap.get(groupId) ?? []).slice().sort((a, b) => a.sort_order - b.sort_order);
+        for (const m of members) {
+            const p = ppcById.get(m.trade_item_id);
+            if (p && p > 1)
+                return p;
+        }
+        return 1;
+    };
+    // Reeds geleverde/geplande aantallen per order-item — nodig zodat het
+    // bewerkscherm niet onder deze ondergrens kan gaan.
+    const itemIds = rows.map((r) => r.id);
+    const shippedByItem = new Map();
+    const plannedByItem = new Map();
+    if (itemIds.length > 0) {
+        const { data: sRows } = await context.supabase
+            .from("order_shipment_items")
+            .select("order_item_id, quantity, order_shipments!inner(status)")
+            .in("order_item_id", itemIds);
+        for (const r of sRows ?? []) {
+            const st = r.order_shipments?.status;
+            const oi = r.order_item_id;
+            const q = Number(r.quantity ?? 0);
+            if (st === "shipped")
+                shippedByItem.set(oi, (shippedByItem.get(oi) ?? 0) + q);
+            else if (st === "planned")
+                plannedByItem.set(oi, (plannedByItem.get(oi) ?? 0) + q);
+        }
+    }
+    return {
+        orderId: order.id,
+        orderNumber: order.order_number,
+        deliveryDate: order.delivery_date,
+        isReservation: !!order.is_reservation,
+        status: order.status,
+        items: rows.map((it) => {
+            let ppc = Math.max(1, Number(it.products?.plants_per_crate ?? 1));
+            if (ppc === 1 && it.product_id && groupIdSet.has(it.product_id)) {
+                ppc = groupPpc(it.product_id);
+            }
+            else if (ppc === 1 && !it.product_id && GROUP_PREFIX.test(it.product_name ?? "")) {
+                const key = it.product_name.replace(GROUP_PREFIX, "").trim().toLowerCase();
+                const gid = groupIdByName.get(key);
+                if (gid)
+                    ppc = groupPpc(gid);
+            }
+            else if (ppc === 1 && it.product_id && ppcById.has(it.product_id)) {
+                ppc = ppcById.get(it.product_id);
+            }
+            const shipped = shippedByItem.get(it.id) ?? 0;
+            const planned = plannedByItem.get(it.id) ?? 0;
+            return {
+                id: it.id,
+                productId: it.product_id,
+                productName: it.product_name,
+                quantity: Number(it.quantity ?? 0),
+                unit: it.unit,
+                plantsPerCrate: ppc,
+                shippedQuantity: shipped,
+                plannedQuantity: planned,
+                minQuantity: shipped + planned,
+            };
+        }),
+    };
+});
+export const updateLocalOrder = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((input) => UpdateLocalOrderInput.parse(input))
+    .handler(async ({ data }) => {
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    const { data: order, error: oErr } = await supabaseAdmin
+        .from("orders")
+        .select("id, custom_fields, order_source, is_reservation")
+        .eq("id", data.orderId)
+        .maybeSingle();
+    if (oErr)
+        throw new Error(oErr.message);
+    if (!order)
+        throw new Error("Bestelling niet gevonden");
+    const cf = order.custom_fields ?? {};
+    const src = String(cf?.source ?? order.order_source ?? "").toLowerCase();
+    if (src === "floriday" || src === "fo") {
+        throw new Error("FO-orders kunnen niet bewerkt worden.");
+    }
+    // Valideer per regel dat het nieuwe aantal niet onder de reeds geleverde
+    // of geplande hoeveelheid zakt — anders zouden bezorgmomenten negatief
+    // openstaand krijgen.
+    if (data.items && data.items.length > 0) {
+        const itemIds = data.items.map((i) => i.itemId);
+        const { data: existing } = await supabaseAdmin
+            .from("order_items")
+            .select("id, product_name")
+            .in("id", itemIds);
+        const nameById = new Map((existing ?? []).map((r) => [r.id, r.product_name]));
+        const { data: sRows } = await supabaseAdmin
+            .from("order_shipment_items")
+            .select("order_item_id, quantity, order_shipments!inner(status)")
+            .in("order_item_id", itemIds);
+        const minByItem = new Map();
+        for (const r of sRows ?? []) {
+            const st = r.order_shipments?.status;
+            if (st !== "shipped" && st !== "planned")
+                continue;
+            const oi = r.order_item_id;
+            minByItem.set(oi, (minByItem.get(oi) ?? 0) + Number(r.quantity ?? 0));
+        }
+        for (const it of data.items) {
+            const min = minByItem.get(it.itemId) ?? 0;
+            if (it.quantity < min) {
+                const name = nameById.get(it.itemId) ?? "Regel";
+                throw new Error(`"${name}" kan niet naar ${it.quantity} — er is al ${min} gepland/geleverd op bezorgmomenten. Verwijder of verlaag eerst een bezorgmoment.`);
+            }
+        }
+    }
+    // Leverdatum bijwerken (alleen als niet-reservering).
+    if (data.deliveryDate && !order.is_reservation) {
+        const { error: uErr } = await supabaseAdmin.from("orders")
+            .update({ delivery_date: data.deliveryDate, updated_at: new Date().toISOString() })
+            .eq("id", data.orderId);
+        if (uErr)
+            throw new Error(`Leverdatum bijwerken faalde: ${uErr.message}`);
+    }
+    if (data.items && data.items.length > 0) {
+        for (const it of data.items) {
+            const { error: iErr } = await supabaseAdmin.from("order_items")
+                .update({ quantity: it.quantity })
+                .eq("id", it.itemId)
+                .eq("order_id", data.orderId);
+            if (iErr)
+                throw new Error(`Aantal bijwerken faalde: ${iErr.message}`);
+        }
+        // Hertellen ordertotaal op basis van items × unit_price.
+        const { data: itemsAll } = await supabaseAdmin
+            .from("order_items")
+            .select("quantity, unit_price")
+            .eq("order_id", data.orderId);
+        const total = (itemsAll ?? []).reduce((s, r) => s + Number(r.unit_price ?? 0) * Number(r.quantity ?? 0), 0);
+        await supabaseAdmin.from("orders")
+            .update({ total: String(total.toFixed(2)), updated_at: new Date().toISOString() })
+            .eq("id", data.orderId);
+    }
+    // Karindeling opnieuw draaien zodat het scherm de nieuwe belading toont.
+    try {
+        const { replanOrderCartsFromCron } = await import("./cart-replan.functions");
+        await replanOrderCartsFromCron(data.orderId);
+    }
+    catch (err) {
+        console.error("[updateLocalOrder] karindeling faalde:", err);
+    }
+    return { ok: true };
+});