@flowselections/floriday-verkoop-module 1.0.40 → 1.0.41

package/dist-lib/lib/invoice-timing.functions.js

@@ -0,0 +1,88 @@
+// Server functions voor het instelbare factuurmoment.
+import { createServerFn } from "@tanstack/react-start";
+import { z } from "zod";
+import { requireSupabaseAuth } from "../integrations/supabase/auth-middleware";
+import { DEFAULT_INVOICE_TIMING, normalizeTimeOfDay, } from "./invoice-timing";
+const ANCHORS = [
+    "order_created",
+    "confirmed",
+    "picked",
+    "shipped",
+    "expected_delivery",
+    "pickup_date",
+    "delivery_date",
+];
+const settingsSchema = z.object({
+    enabled: z.boolean(),
+    anchor: z.enum(ANCHORS),
+    offsetDays: z.number().int().min(-60).max(60),
+    businessDaysOnly: z.boolean(),
+    timeOfDay: z.string().min(4),
+    pickupAnchor: z.enum(ANCHORS),
+    pickupOffsetDays: z.number().int().min(-60).max(60),
+    pickupBusinessDaysOnly: z.boolean(),
+    pickupTimeOfDay: z.string().min(4),
+});
+export const getInvoiceTimingSettings = createServerFn({ method: "GET" })
+    .middleware([requireSupabaseAuth])
+    .handler(async ({ context }) => {
+    const { loadInvoiceTimingSettings } = await import("./invoice-timing.server");
+    return loadInvoiceTimingSettings(context.supabase);
+});
+export const saveInvoiceTimingSettings = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((input) => settingsSchema.parse(input))
+    .handler(async ({ data, context }) => {
+    const supabase = context.supabase;
+    const payload = {
+        singleton: true,
+        enabled: data.enabled,
+        anchor: data.anchor,
+        offset_days: data.offsetDays,
+        business_days_only: data.businessDaysOnly,
+        time_of_day: normalizeTimeOfDay(data.timeOfDay),
+        pickup_anchor: data.pickupAnchor,
+        pickup_offset_days: data.pickupOffsetDays,
+        pickup_business_days_only: data.pickupBusinessDaysOnly,
+        pickup_time_of_day: normalizeTimeOfDay(data.pickupTimeOfDay),
+    };
+    const { error } = await supabase.from("invoice_timing_settings").upsert(payload, {
+        onConflict: "singleton",
+    });
+    if (error)
+        throw new Error(error.message);
+    // Direct doorrekenen zodat de orders het nieuwe moment tonen.
+    const { recomputeInvoiceDueDates } = await import("./invoice-timing.server");
+    const { updated } = await recomputeInvoiceDueDates(supabase, { limit: 500 });
+    return { ok: true, recomputed: updated };
+});
+export const recomputeInvoiceDueForOrder = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((input) => z.object({ orderId: z.string().uuid() }).parse(input))
+    .handler(async ({ data, context }) => {
+    const { recomputeInvoiceDueDates } = await import("./invoice-timing.server");
+    await recomputeInvoiceDueDates(context.supabase, { orderIds: [data.orderId] });
+    const { data: row } = await context.supabase
+        .from("orders")
+        .select("invoice_due_at")
+        .eq("id", data.orderId)
+        .maybeSingle();
+    return { invoiceDueAt: row?.invoice_due_at ?? null };
+});
+export const getOrderInvoiceMoment = createServerFn({ method: "GET" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((input) => z.object({ orderId: z.string().uuid() }).parse(input))
+    .handler(async ({ data, context }) => {
+    const { loadInvoiceTimingSettings } = await import("./invoice-timing.server");
+    const settings = await loadInvoiceTimingSettings(context.supabase).catch(() => DEFAULT_INVOICE_TIMING);
+    const { data: row } = await context.supabase
+        .from("orders")
+        .select("invoice_due_at, status")
+        .eq("id", data.orderId)
+        .maybeSingle();
+    return {
+        invoiceDueAt: row?.invoice_due_at ?? null,
+        status: row?.status ?? null,
+        settings,
+    };
+});

package/dist-lib/lib/invoice-timing.js

@@ -0,0 +1,139 @@
+// Pure rekenlogica voor het instelbare factuurmoment.
+// Formule: factuurmoment = ijkpunt + X dagen (op tijdstip T).
+// Zelfafhalers kunnen een eigen ijkpunt/offset hebben.
+export const INVOICE_ANCHORS = [
+    { id: "order_created", label: "Order binnengekomen", hint: "Moment waarop de order is aangemaakt" },
+    { id: "confirmed", label: "Order bevestigd", hint: "Zodra de order is bevestigd/ingepland" },
+    { id: "picked", label: "Order gepickt", hint: "Zodra de order volledig is gepickt" },
+    { id: "shipped", label: "Order verzonden", hint: "Meegegeven aan de vervoerder" },
+    { id: "expected_delivery", label: "Verwachte levering", hint: "Berekend op basis van de leverdatum van de order" },
+    { id: "pickup_date", label: "Afhaaldatum", hint: "Datum waarop de klant de order zelf ophaalt" },
+    { id: "delivery_date", label: "Leverdatum op de order", hint: "De leverdatum zoals op de order staat" },
+];
+export const DEFAULT_INVOICE_TIMING = {
+    enabled: true,
+    anchor: "expected_delivery",
+    offsetDays: 0,
+    businessDaysOnly: false,
+    timeOfDay: "18:00",
+    pickupAnchor: "pickup_date",
+    pickupOffsetDays: 0,
+    pickupBusinessDaysOnly: false,
+    pickupTimeOfDay: "18:00",
+};
+export function normalizeTimeOfDay(value) {
+    const s = String(value ?? "").trim();
+    const m = /^(\d{1,2}):(\d{2})/.exec(s);
+    if (!m)
+        return "18:00";
+    const h = Math.min(23, Math.max(0, Number(m[1])));
+    const mi = Math.min(59, Math.max(0, Number(m[2])));
+    return `${String(h).padStart(2, "0")}:${String(mi).padStart(2, "0")}`;
+}
+function toDateOnly(value) {
+    if (!value)
+        return null;
+    const iso = String(value).slice(0, 10);
+    const [y, m, d] = iso.split("-").map(Number);
+    if (!y || !m || !d)
+        return null;
+    const dt = new Date(Date.UTC(y, m - 1, d));
+    return Number.isNaN(dt.getTime()) ? null : dt;
+}
+function toTimestamp(value) {
+    if (!value)
+        return null;
+    const dt = new Date(String(value));
+    return Number.isNaN(dt.getTime()) ? null : dt;
+}
+function addDays(date, days, businessOnly) {
+    const out = new Date(date.getTime());
+    if (!businessOnly) {
+        out.setUTCDate(out.getUTCDate() + days);
+        return out;
+    }
+    const step = days >= 0 ? 1 : -1;
+    let left = Math.abs(days);
+    while (left > 0) {
+        out.setUTCDate(out.getUTCDate() + step);
+        const wd = out.getUTCDay();
+        if (wd !== 0 && wd !== 6)
+            left -= 1;
+    }
+    // Landt het resultaat in het weekend, schuif naar de eerstvolgende werkdag.
+    while (out.getUTCDay() === 0 || out.getUTCDay() === 6) {
+        out.setUTCDate(out.getUTCDate() + (step >= 0 ? 1 : -1));
+    }
+    return out;
+}
+function applyTime(date, timeOfDay) {
+    const [h, m] = normalizeTimeOfDay(timeOfDay).split(":").map(Number);
+    const out = new Date(date.getTime());
+    out.setUTCHours(h ?? 18, m ?? 0, 0, 0);
+    return out;
+}
+function anchorDate(anchor, input) {
+    switch (anchor) {
+        case "order_created": {
+            const d = toTimestamp(input.createdAt);
+            return d ? { date: d, dateOnly: false } : null;
+        }
+        case "confirmed": {
+            const d = toTimestamp(input.confirmedAt);
+            return d ? { date: d, dateOnly: false } : null;
+        }
+        case "picked": {
+            const d = toTimestamp(input.pickedAt);
+            return d ? { date: d, dateOnly: false } : null;
+        }
+        case "shipped": {
+            const d = toTimestamp(input.shippedAt);
+            return d ? { date: d, dateOnly: false } : null;
+        }
+        case "expected_delivery": {
+            const d = toDateOnly(input.expectedDeliveryDate ?? input.deliveryDate);
+            return d ? { date: d, dateOnly: true } : null;
+        }
+        case "pickup_date": {
+            const d = toDateOnly(input.pickupDate ?? input.deliveryDate);
+            return d ? { date: d, dateOnly: true } : null;
+        }
+        case "delivery_date": {
+            const d = toDateOnly(input.deliveryDate);
+            return d ? { date: d, dateOnly: true } : null;
+        }
+        default:
+            return null;
+    }
+}
+/**
+ * Berekent het moment waarop de order gefactureerd mag worden.
+ * Geeft `null` wanneer het ijkpunt (nog) onbekend is.
+ */
+export function computeInvoiceDueAt(input, settings) {
+    if (!settings.enabled)
+        return null;
+    const usePickup = !!input.selfPickup;
+    const anchor = usePickup ? settings.pickupAnchor : settings.anchor;
+    const offset = usePickup ? settings.pickupOffsetDays : settings.offsetDays;
+    const businessOnly = usePickup ? settings.pickupBusinessDaysOnly : settings.businessDaysOnly;
+    const timeOfDay = usePickup ? settings.pickupTimeOfDay : settings.timeOfDay;
+    const base = anchorDate(anchor, input);
+    if (!base)
+        return null;
+    const shifted = addDays(base.date, Math.trunc(offset || 0), businessOnly);
+    // Bij datum-ijkpunten bepaalt het ingestelde tijdstip het uur.
+    const final = base.dateOnly || offset !== 0 ? applyTime(shifted, timeOfDay) : shifted;
+    return final.toISOString();
+}
+export function describeInvoiceTiming(settings, forPickup = false) {
+    const anchor = forPickup ? settings.pickupAnchor : settings.anchor;
+    const offset = forPickup ? settings.pickupOffsetDays : settings.offsetDays;
+    const businessOnly = forPickup ? settings.pickupBusinessDaysOnly : settings.businessDaysOnly;
+    const time = forPickup ? settings.pickupTimeOfDay : settings.timeOfDay;
+    const label = INVOICE_ANCHORS.find((a) => a.id === anchor)?.label ?? anchor;
+    const days = offset === 0
+        ? "zelfde dag"
+        : `${offset > 0 ? "+" : "−"}${Math.abs(offset)} ${businessOnly ? "werkdag(en)" : "dag(en)"}`;
+    return `${label} ${offset === 0 ? "" : days} om ${normalizeTimeOfDay(time)}`.replace("  ", " ");
+}

package/dist-lib/lib/invoice-timing.server.d.ts

@@ -0,0 +1,22 @@
+import { type InvoiceTimingSettings } from "./invoice-timing";
+/** Status die de facturatiemodule oppakt zodra het factuurmoment is bereikt. */
+export declare const INVOICE_READY_STATUS = "Gereed voor facturatie";
+export declare function loadInvoiceTimingSettings(supabase: any): Promise<InvoiceTimingSettings>;
+/** Herberekent `invoice_due_at` voor de meegegeven orders (of alle open orders). */
+export declare function recomputeInvoiceDueDates(supabase: any, options?: {
+    orderIds?: string[];
+    limit?: number;
+}): Promise<{
+    updated: number;
+}>;
+/** Zet orders waarvan het factuurmoment is bereikt op de facturatiestatus. */
+export declare function releaseDueInvoices(supabase: any, limit?: number): Promise<{
+    released: number;
+    orderIds: string[];
+}>;
+/** Volledige cyclus: eerst herberekenen, daarna vrijgeven. */
+export declare function runInvoiceTimingCycle(): Promise<{
+    recomputed: number;
+    released: number;
+}>;
+//# sourceMappingURL=invoice-timing.server.d.ts.map

package/dist-lib/lib/invoice-timing.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invoice-timing.server.d.ts","sourceRoot":"","sources":["../../src/lib/invoice-timing.server.ts"],"names":[],"mappings":"AACA,OAAO,EAML,KAAK,qBAAqB,EAC3B,MAAM,kBAAkB,CAAC;AAE1B,gFAAgF;AAChF,eAAO,MAAM,oBAAoB,2BAA2B,CAAC;AAE7D,wBAAsB,yBAAyB,CAAC,QAAQ,EAAE,GAAG,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAkB7F;AAyED,oFAAoF;AACpF,wBAAsB,wBAAwB,CAC5C,QAAQ,EAAE,GAAG,EACb,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GACpD,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CA4B9B;AAED,8EAA8E;AAC9E,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,GAAG,EACb,KAAK,SAAM,GACV,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CA4BnD;AAED,8DAA8D;AAC9D,wBAAsB,qBAAqB,IAAI,OAAO,CAAC;IACrD,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC,CAKD"}

package/dist-lib/lib/invoice-timing.server.js

@@ -0,0 +1,154 @@
+// Server-side toepassing van het instelbare factuurmoment.
+import { DEFAULT_INVOICE_TIMING, computeInvoiceDueAt, normalizeTimeOfDay, } from "./invoice-timing";
+/** Status die de facturatiemodule oppakt zodra het factuurmoment is bereikt. */
+export const INVOICE_READY_STATUS = "Gereed voor facturatie";
+export async function loadInvoiceTimingSettings(supabase) {
+    const { data } = await supabase
+        .from("invoice_timing_settings")
+        .select("*")
+        .limit(1)
+        .maybeSingle();
+    if (!data)
+        return { ...DEFAULT_INVOICE_TIMING };
+    return {
+        enabled: !!data.enabled,
+        anchor: (data.anchor ?? "expected_delivery"),
+        offsetDays: Number(data.offset_days ?? 0),
+        businessDaysOnly: !!data.business_days_only,
+        timeOfDay: normalizeTimeOfDay(data.time_of_day),
+        pickupAnchor: (data.pickup_anchor ?? "pickup_date"),
+        pickupOffsetDays: Number(data.pickup_offset_days ?? 0),
+        pickupBusinessDaysOnly: !!data.pickup_business_days_only,
+        pickupTimeOfDay: normalizeTimeOfDay(data.pickup_time_of_day),
+    };
+}
+function isSelfPickup(customFields) {
+    const cf = customFields ?? {};
+    if (cf.self_pickup === true || cf.afhalen === true)
+        return true;
+    const label = String(cf.carrier_name ?? cf.vervoerder ?? "").toLowerCase();
+    return /afhaal|zelf ophalen|eigen vervoer/.test(label);
+}
+function pickupDateFromCustomFields(cf) {
+    const raw = cf?.pickup_date ?? cf?.afhaaldatum ?? null;
+    if (raw)
+        return String(raw).slice(0, 10);
+    const moment = cf?.pickup_moment ? String(cf.pickup_moment) : null;
+    if (moment) {
+        const first = moment.split("|")[0];
+        if (first && /^\d{4}-\d{2}-\d{2}$/.test(first))
+            return first;
+    }
+    return null;
+}
+async function buildAnchorInputs(supabase, rows) {
+    const ids = rows.map((r) => String(r.id));
+    const shipped = new Map();
+    if (ids.length) {
+        try {
+            const { data } = await supabase
+                .from("order_shipments")
+                .select("order_id, status, shipped_at, updated_at")
+                .in("order_id", ids.slice(0, 1000));
+            for (const s of (data ?? [])) {
+                const key = String(s.order_id);
+                const prev = shipped.get(key) ?? { shippedAt: null, pickedAt: null };
+                const st = String(s.status ?? "").toLowerCase();
+                if (s.shipped_at)
+                    prev.shippedAt = prev.shippedAt ?? String(s.shipped_at);
+                if (["gepickt", "picked", "gecontroleerd"].includes(st)) {
+                    prev.pickedAt = prev.pickedAt ?? String(s.updated_at ?? s.shipped_at ?? "");
+                }
+                shipped.set(key, prev);
+            }
+        }
+        catch {
+            /* verzendmomenten zijn optioneel */
+        }
+    }
+    const out = new Map();
+    for (const r of rows) {
+        const cf = r.custom_fields ?? {};
+        const ship = shipped.get(String(r.id));
+        out.set(String(r.id), {
+            createdAt: r.created_at,
+            confirmedAt: cf.confirmed_at ? String(cf.confirmed_at) : r.created_at,
+            pickedAt: ship?.pickedAt || null,
+            shippedAt: ship?.shippedAt || null,
+            expectedDeliveryDate: r.delivery_date,
+            deliveryDate: r.delivery_date,
+            pickupDate: pickupDateFromCustomFields(cf),
+            selfPickup: isSelfPickup(cf),
+        });
+    }
+    return out;
+}
+/** Herberekent `invoice_due_at` voor de meegegeven orders (of alle open orders). */
+export async function recomputeInvoiceDueDates(supabase, options = {}) {
+    const settings = await loadInvoiceTimingSettings(supabase);
+    let query = supabase
+        .from("orders")
+        .select("id, created_at, delivery_date, status, custom_fields")
+        .is("deleted_at", null)
+        .limit(options.limit ?? 500);
+    if (options.orderIds?.length)
+        query = query.in("id", options.orderIds.slice(0, 500));
+    else
+        query = query.order("created_at", { ascending: false });
+    const { data, error } = await query;
+    if (error)
+        throw new Error(error.message);
+    const rows = (data ?? []);
+    if (rows.length === 0)
+        return { updated: 0 };
+    const inputs = await buildAnchorInputs(supabase, rows);
+    let updated = 0;
+    for (const row of rows) {
+        const input = inputs.get(String(row.id));
+        if (!input)
+            continue;
+        const due = computeInvoiceDueAt(input, settings);
+        const { error: upErr } = await supabase
+            .from("orders")
+            .update({ invoice_due_at: due })
+            .eq("id", row.id);
+        if (!upErr)
+            updated += 1;
+    }
+    return { updated };
+}
+/** Zet orders waarvan het factuurmoment is bereikt op de facturatiestatus. */
+export async function releaseDueInvoices(supabase, limit = 200) {
+    const settings = await loadInvoiceTimingSettings(supabase);
+    if (!settings.enabled)
+        return { released: 0, orderIds: [] };
+    const { data, error } = await supabase
+        .from("orders")
+        .select("id, status, order_source, floriday_sales_order_id")
+        .is("deleted_at", null)
+        .not("invoice_due_at", "is", null)
+        .lte("invoice_due_at", new Date().toISOString())
+        .neq("status", INVOICE_READY_STATUS)
+        .limit(limit);
+    if (error)
+        throw new Error(error.message);
+    const rows = (data ?? []).filter((r) => !r.floriday_sales_order_id &&
+        String(r.order_source ?? "").toLowerCase() !== "floriday");
+    const orderIds = [];
+    for (const r of rows) {
+        const { error: upErr } = await supabase
+            .from("orders")
+            .update({ status: INVOICE_READY_STATUS })
+            .eq("id", r.id);
+        if (!upErr)
+            orderIds.push(String(r.id));
+    }
+    return { released: orderIds.length, orderIds };
+}
+/** Volledige cyclus: eerst herberekenen, daarna vrijgeven. */
+export async function runInvoiceTimingCycle() {
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    const recomputed = (await recomputeInvoiceDueDates(supabaseAdmin, { limit: 500 })).updated;
+    const released = (await releaseDueInvoices(supabaseAdmin, 200)).released;
+    return { recomputed, released };
+}