@flowselections/mailbox-orders 1.0.3 → 1.0.4

package/dist-lib/lib/mailbox.functions.js

@@ -71,6 +71,7 @@ async function ingestSingleEvent(supabaseAdmin, connectionId, ev) {
         .insert({
         external_id: externalId,
         message_id: pickStr(p, "message_id", "messageId") ?? externalId,
+        connection_id: connectionId,
         from_email: fromEmail,
         from_name: fromName,
         subject,
@@ -88,8 +89,100 @@ async function ingestSingleEvent(supabaseAdmin, connectionId, ev) {
         }
         throw new Error(insErr.message);
     }
+    // Maak direct een leeg voorstel aan (AI staat uit) — match klant op afzender
+    await createStubProposal(supabaseAdmin, inserted.id, fromEmail);
     return { inserted: true, messageId: inserted.id };
 }
+async function createStubProposal(supabaseAdmin, messageId, fromEmail) {
+    const { data: existing } = await supabaseAdmin
+        .from("mailbox_order_proposals").select("id").eq("message_id", messageId).maybeSingle();
+    if (existing?.id)
+        return;
+    const matchResult = await matchCustomerByEmail(supabaseAdmin, fromEmail);
+    await supabaseAdmin.from("mailbox_order_proposals").insert({
+        message_id: messageId,
+        matched_customer_id: matchResult.customerId,
+        confidence: matchResult.customerId ? 1 : 0,
+        status: "pending",
+        parsed_payload: {
+            stub: true,
+            reason: "ai_disabled",
+            auto_matched_customer: matchResult.customerId !== null,
+            auto_match_source: matchResult.source,
+            auto_match_email: fromEmail,
+            auto_match_warning: matchResult.warning,
+            auto_match_candidates: matchResult.candidates,
+        },
+    });
+}
+// Exact (case-insensitive) match op afzender-e-mailadres.
+// Eerst customers.email, dan customer_contacts.email als fallback.
+// Bij meerdere treffers: geen automatische koppeling, wel waarschuwing.
+async function matchCustomerByEmail(supabaseAdmin, fromEmail) {
+    if (!fromEmail) {
+        return { customerId: null, source: null, warning: null, candidates: [] };
+    }
+    const email = fromEmail.trim();
+    if (!email) {
+        return { customerId: null, source: null, warning: null, candidates: [] };
+    }
+    // 1) customers.email (case-insensitive exact)
+    const { data: directHits } = await supabaseAdmin
+        .from("customers")
+        .select("id, company_name")
+        .ilike("email", email)
+        .limit(5);
+    const direct = Array.isArray(directHits) ? directHits : [];
+    if (direct.length === 1) {
+        return {
+            customerId: direct[0].id,
+            source: "customers",
+            warning: null,
+            candidates: direct.map((c) => ({ id: c.id, name: c.company_name })),
+        };
+    }
+    if (direct.length > 1) {
+        return {
+            customerId: null,
+            source: "customers",
+            warning: `Meerdere klanten met e-mailadres ${email} — kies handmatig.`,
+            candidates: direct.map((c) => ({ id: c.id, name: c.company_name })),
+        };
+    }
+    // 2) customer_contacts.email (case-insensitive exact)
+    const { data: contactHits } = await supabaseAdmin
+        .from("customer_contacts")
+        .select("customer_id")
+        .ilike("email", email)
+        .limit(5);
+    const contacts = Array.isArray(contactHits) ? contactHits : [];
+    const uniqueCustomerIds = Array.from(new Set(contacts.map((c) => c.customer_id).filter(Boolean)));
+    if (uniqueCustomerIds.length === 0) {
+        return { customerId: null, source: null, warning: null, candidates: [] };
+    }
+    const { data: custRows } = await supabaseAdmin
+        .from("customers")
+        .select("id, company_name")
+        .in("id", uniqueCustomerIds);
+    const cands = (Array.isArray(custRows) ? custRows : []).map((c) => ({
+        id: c.id,
+        name: c.company_name,
+    }));
+    if (uniqueCustomerIds.length === 1) {
+        return {
+            customerId: uniqueCustomerIds[0],
+            source: "customer_contacts",
+            warning: null,
+            candidates: cands,
+        };
+    }
+    return {
+        customerId: null,
+        source: "customer_contacts",
+        warning: `Meerdere klanten gevonden via contactpersoon met e-mailadres ${email} — kies handmatig.`,
+        candidates: cands,
+    };
+}
 // ─── Ingest één specifiek event (vanuit realtime subscription) ───────────────
 export const ingestEmailEvent = createServerFn({ method: "POST" })
     .middleware([requireSupabaseAuth])
@@ -160,10 +253,20 @@ export const backfillRecentEvents = createServerFn({ method: "POST" })
             .update({ consumed_at: new Date().toISOString() })
             .in("id", consumedIds);
     }
-    // AI-verwerking uitgeschakeld — wacht op externe model-koppeling
-    const autoProcessed = 0;
-    const autoApproved = 0;
-    return { ok: true, inserted, autoProcessed, autoApproved };
+    // Maak ook stubs voor eerder ontvangen berichten zonder voorstel
+    const { data: orphanMsgs } = await supabaseAdmin
+        .from("mailbox_messages")
+        .select("id, from_email, mailbox_order_proposals(id)")
+        .order("received_at", { ascending: false })
+        .limit(200);
+    let stubbed = 0;
+    for (const m of (orphanMsgs ?? [])) {
+        if (Array.isArray(m.mailbox_order_proposals) && m.mailbox_order_proposals.length > 0)
+            continue;
+        await createStubProposal(supabaseAdmin, m.id, m.from_email ?? null);
+        stubbed++;
+    }
+    return { ok: true, inserted: inserted + stubbed, autoProcessed: 0, autoApproved: 0 };
 });
 // ─── Messages & Proposals ────────────────────────────────────────────────────
 export const listMessages = createServerFn({ method: "GET" })
@@ -187,27 +290,42 @@ export const parseMessage = createServerFn({ method: "POST" })
         .from("mailbox_messages").select("*").eq("id", data.messageId).single();
     if (msgErr || !msg)
         throw new Error("Bericht niet gevonden");
-    // AI-parsing is uitgeschakeld tot de externe model-koppeling klaar is.
-    // Het bericht blijft bewaard; status gaat naar "failed" met een duidelijke melding.
-    const msg2 = msg;
+    // AI staat uit: maak een leeg voorstel zodat het bericht in "Voorstellen" verschijnt.
+    await createStubProposal(supabaseAdmin, msg.id, msg.from_email ?? null);
     await supabaseAdmin.from("mailbox_messages")
-        .update({
-        status: "failed",
-        error_message: "AI-parsing is tijdelijk uitgeschakeld — wacht op externe model-koppeling.",
-    })
-        .eq("id", msg2.id);
-    return {
-        ok: false,
-        error: "AI-parsing is tijdelijk uitgeschakeld — wacht op externe model-koppeling.",
-    };
+        .update({ status: "parsed", error_message: null }).eq("id", msg.id);
+    return { ok: true };
 });
 export const listProposals = createServerFn({ method: "GET" })
     .middleware([requireSupabaseAuth])
     .inputValidator((input) => z.object({ status: z.enum(["pending", "approved", "rejected"]).optional() }).parse(input ?? {}))
     .handler(async ({ data, context }) => {
+    // Beperk tot berichten die binnenkwamen via de actieve orders/receive mailbox
+    const { data: active } = await context.supabase.rpc("email_auth_for_purpose", {
+        _purpose: "orders",
+        _direction: "receive",
+    });
+    const activeRow = Array.isArray(active) ? active[0] : null;
+    const activeConnectionId = activeRow?.id ?? null;
+    if (!activeConnectionId)
+        return { items: [] };
+    // Stap 1: message-ids van de actieve mailbox
+    const { data: msgs, error: msgErr } = await context.supabase
+        .from("mailbox_messages")
+        .select("id")
+        .eq("connection_id", activeConnectionId)
+        .order("received_at", { ascending: false })
+        .limit(500);
+    if (msgErr)
+        throw new Error(msgErr.message);
+    const messageIds = (msgs ?? []).map((m) => m.id);
+    if (messageIds.length === 0)
+        return { items: [] };
+    // Stap 2: voorstellen op die berichten
     let q = context.supabase
         .from("mailbox_order_proposals")
-        .select("*, mailbox_messages(subject, from_email, from_name, body_text, received_at), mailbox_proposal_lines(*), mailbox_proposal_field_values(*)")
+        .select("*, mailbox_messages(subject, from_email, from_name, body_text, received_at, connection_id), mailbox_proposal_lines(*), mailbox_proposal_field_values(*)")
+        .in("message_id", messageIds)
         .order("created_at", { ascending: false })
         .limit(100);
     if (data.status)
@@ -245,6 +363,25 @@ export const approveProposal = createServerFn({ method: "POST" })
     (data.fieldValues ?? []).forEach((fv) => {
         customFields[fv.field_key] = fv.value;
     });
+    // ─── Validatie eerst mogelijke leverdatum ────────────────────────────────
+    const carrierId = typeof customFields["carrier"] === "string" ? customFields["carrier"] : null;
+    let carrierDeliveryDays = 0;
+    if (carrierId) {
+        const { data: c } = await context.supabase
+            .from("carriers").select("delivery_days").eq("id", carrierId).maybeSingle();
+        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 earliest = addCalendarDays(new Date(), pickDays + carrierDeliveryDays);
+    const earliestISO = toISODate(earliest);
+    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 orderNumber = `MB-${Date.now()}`;
     const { data: order, error: orderErr } = await supabaseAdmin
         .from("orders").insert({
@@ -307,6 +444,19 @@ export const rejectProposal = createServerFn({ method: "POST" })
     }).eq("id", data.proposalId);
     return { ok: true };
 });
+// Een afgewezen (of goedgekeurd) voorstel terugzetten naar "te controleren".
+export const reopenProposal = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((input) => z.object({ proposalId: z.string().uuid() }).parse(input))
+    .handler(async ({ data }) => {
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    await supabaseAdmin.from("mailbox_order_proposals").update({
+        status: "pending",
+        reviewed_by: null,
+        reviewed_at: null,
+    }).eq("id", data.proposalId);
+    return { ok: true };
+});
 export const listCustomersForPicker = createServerFn({ method: "GET" })
     .middleware([requireSupabaseAuth])
     .handler(async ({ context }) => {
@@ -318,6 +468,230 @@ export const listProductsForPicker = createServerFn({ method: "GET" })
     .middleware([requireSupabaseAuth])
     .handler(async ({ context }) => {
     const { data } = await context.supabase
-        .from("products").select("id, product, unit").order("product").range(0, 4999);
+        .from("products")
+        .select("id, product, unit, plants_per_crate, crates_per_layer, layers_per_cart")
+        .order("product").range(0, 4999);
+    return { items: data ?? [] };
+});
+export const planAndSaveAutoCarts = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((input) => z.object({ orderId: z.string().uuid() }).parse(input))
+    .handler(async ({ data, context }) => {
+    // Items met productbelading ophalen
+    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");
+    // Reset eventuele eerdere auto-karren (idempotent)
+    await supabaseAdmin.from("order_carts").delete().eq("order_id", data.orderId).eq("is_auto", true);
+    let cartNumber = 1;
+    // Eerst hoogste bestaande nr ophalen (voor manueel toegevoegde karren)
+    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;
+        // quantity is in PLANTEN (zie approveProposal)
+        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,
+            });
+        }
+    }
+    // Bestaande handmatige karren ophalen + crates per order_item aftrekken van remainders,
+    // zodat heropenen van de wizard niet dezelfde fusten opnieuw vraagt.
+    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 ManualCartItem = 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 ManualCart = z.object({
+    is_complete: z.boolean().optional(),
+    notes: z.string().max(500).nullable().optional(),
+    items: z.array(ManualCartItem).min(1),
+});
+export const saveManualCarts = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((input) => z.object({ orderId: z.string().uuid(), carts: z.array(ManualCart) }).parse(input))
+    .handler(async ({ data }) => {
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    // Verwijder eerdere handmatige karren (replace strategy)
+    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 };
+});
+export const listOrderCarts = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((d) => d)
+    .handler(async ({ data, context }) => {
+    const { data: carts } = await context.supabase
+        .from("order_carts")
+        .select("id, cart_number, is_auto, is_complete, notes, order_cart_items(*)")
+        .eq("order_id", data.orderId)
+        .order("cart_number");
+    return { items: carts ?? [] };
+});
+export const listDeliveryLocationsForCustomer = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((d) => 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 : [] };
+});
+// Onze eigen bedrijfslocaties (tuinen / afhaallocaties). Staan los van klantlocaties.
+export const listPickupLocations = createServerFn({ method: "GET" })
+    .middleware([requireSupabaseAuth])
+    .handler(async ({ context }) => {
+    const { data } = await context.supabase
+        .from("locations")
+        .select("id, name, sort_order")
+        .order("sort_order", { ascending: true })
+        .order("name");
+    return { items: Array.isArray(data) ? data : [] };
+});
+export const listCarriersForPicker = 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 — gebruikt voor het berekenen van de eerst mogelijke leverdatum
+export const getOrderPickDays = 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)) };
+});
+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")}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowselections/mailbox-orders",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "private": false,
   "sideEffects": false,
   "type": "module",
@@ -46,7 +46,7 @@
     "@cloudflare/vite-plugin": "^1.25.5",
     "@eslint/js": "^9.32.0",
     "@flowselections/core": "^1.0.11",
-    "@lovable.dev/vite-tanstack-config": "2.5.3",
+    "@lovable.dev/vite-tanstack-config": "2.6.4",
     "@rsbuild/core": "^1.0.0",
     "@tailwindcss/vite": "^4.2.1",
     "@tanstack/react-query": "^5.83.0",
@@ -77,11 +77,6 @@
   "flowselections": {
     "moduleId": "Mailbox",
     "pages": [
-      {
-        "export": "MailboxInboxPage",
-        "route": "mailbox-orders",
-        "title": "Inbox"
-      },
       {
         "export": "MailboxProposalsPage",
         "route": "mailbox-orders/voorstellen",