@flowselections/logistiek-engine 1.0.34 → 1.0.53

package/dist-lib/lib/flowRoute.js

@@ -0,0 +1,280 @@
+// ============================================================================
+// src/lib/flowRoute.ts — de route van één herberekening (versie) van een order
+// over de flowkaart
+// ============================================================================
+// Uit de logboekgegevens van één versie leiden we af tot welke stap de order
+// is gekomen en waar hij eventueel is vastgelopen. Die informatie leggen we als
+// laag over de flowkaart: de gelopen route wordt blauw, de rest licht, en het
+// vastgelopen vakje krijgt een rode markering.
+//
+// Belangrijk: de kaart zelf blijft de actuele werkwijze. Welke keuze binnen een
+// stap gold, komt uit de instellingen van nú; het logboek bewaart (nog) geen
+// momentopname van de werkwijze per herberekening. Dat melden we in de kaart.
+// ============================================================================
+import { WIZARD_STEPS } from "./ruleEngineWizard";
+import { FLOW_NODE, bronNodeVoor } from "./flowNodes";
+import { vakUitleg } from "./vakUitleg";
+const STEP_IDS = WIZARD_STEPS.map((s) => s.id);
+const STAP = {
+    combineren: STEP_IDS[0] ?? "orders_combineren",
+    indeling: STEP_IDS[1] ?? "beladingindeling",
+    picken: STEP_IDS[2] ?? "picken",
+    drukte: STEP_IDS[3] ?? "drukte_vertraging",
+    stations: STEP_IDS[4] ?? "pickstations",
+    controle: STEP_IDS[5] ?? "controle",
+};
+export const REASON_LABEL = {
+    afmetingen_onbekend: "Afmetingen van fust/product onbekend",
+    kargrens_overschreden: "Kargrens overschreden (te veel lagen/karren)",
+    bufferdekking_onvolledig: "Buffer nog niet compleet: niet alle orders binnen",
+    werktijden_ontbreken: "Werktijden van de klant ontbreken",
+    fust_onbekend: "Fusttype onbekend",
+    geen_regels: "Order heeft geen regels",
+};
+export function redenTekst(code, error) {
+    const label = code ? REASON_LABEL[code] ?? code.replace(/_/g, " ") : null;
+    if (label && error && !error.includes(code ?? ""))
+        return `${label} — ${error}`;
+    return label ?? error ?? "Onbekende reden";
+}
+const AFGEROND = new Set(["verzonden", "gereed voor facturatie", "afgehandeld", "gefactureerd", "afgemeld"]);
+/** Leidt uit één versie + de huidige stand van de order de gelopen route af. */
+export function bepaalRoute(versie, order, carts, isLaatste) {
+    const bron = order?.orderSource ? bronNodeVoor(order.orderSource) : null;
+    const source = bron === FLOW_NODE.bronFloriday
+        ? "floriday"
+        : bron === FLOW_NODE.bronMail
+            ? "mail"
+            : bron === FLOW_NODE.bronActiemail
+                ? "actiemail"
+                : bron === FLOW_NODE.bronHandmatig
+                    ? "handmatig"
+                    : null;
+    const reached = [];
+    let stuck = null;
+    let busy = null;
+    let finished = false;
+    if (!versie) {
+        return {
+            source,
+            reached,
+            stuck: null,
+            busy: { stepId: STAP.combineren, reason: "Order is binnen, maar nog nooit ingedeeld" },
+            finished: false,
+            summary: "Nog geen herberekening bekend voor deze order.",
+        };
+    }
+    // 1. Ontvangen en combineren: zodra er een wachtrijrij is, is de order binnen.
+    reached.push(STAP.combineren);
+    // 2. Karindeling: de uitkomst van de planwachtrij.
+    const status = (versie.status ?? "pending").toLowerCase();
+    if (status === "pending") {
+        busy = { stepId: STAP.indeling, reason: "Wacht op de planronde" };
+    }
+    else if (status === "running") {
+        reached.push(STAP.indeling);
+        busy = { stepId: STAP.indeling, reason: "Karindeling wordt nu berekend" };
+    }
+    else if (status === "failed" || status === "geblokkeerd") {
+        reached.push(STAP.indeling);
+        stuck = {
+            stepId: STAP.indeling,
+            reason: (status === "geblokkeerd" ? "Geblokkeerd: " : "Mislukt: ") +
+                redenTekst(versie.reasonCode, versie.error ?? versie.lastError),
+        };
+    }
+    else {
+        reached.push(STAP.indeling);
+    }
+    if (!stuck && !busy) {
+        // 3–5. Picken, vrijgave en pickstations: pakbonnen/printopdrachten.
+        if (versie.printJobs > 0) {
+            reached.push(STAP.picken, STAP.drukte, STAP.stations);
+            if (versie.printFailed > 0 && versie.printFailed >= versie.printJobs) {
+                stuck = { stepId: STAP.stations, reason: "Printopdracht mislukt of geannuleerd" };
+            }
+        }
+        else if (versie.lastErrorStep && versie.errors > 0 && (versie.lastPhase ?? "").includes("verzendbrief")) {
+            reached.push(STAP.picken, STAP.drukte, STAP.stations);
+            stuck = { stepId: STAP.stations, reason: `Verzendbrief: ${versie.lastError ?? "fout"}` };
+        }
+        else {
+            reached.push(STAP.picken);
+            busy = { stepId: STAP.drukte, reason: "Ingedeeld; wacht op vrijgave/aanmeldmoment" };
+        }
+        const ship = (versie.shippingStatus ?? "").toLowerCase();
+        if (!stuck && (ship === "mislukt" || ship === "geblokkeerd")) {
+            stuck = { stepId: STAP.stations, reason: `Verzendbrief ${ship}${versie.lastError ? `: ${versie.lastError}` : ""}` };
+        }
+        // 6. Controle en afronding: alleen aantoonbaar voor de laatste versie
+        //    (de karrenstand is een stand van nú).
+        if (!stuck && isLaatste && carts && carts.total > 0) {
+            if (carts.printed > 0) {
+                if (!reached.includes(STAP.stations))
+                    reached.push(STAP.drukte, STAP.stations);
+                busy = null;
+                if (carts.controlled >= carts.total) {
+                    reached.push(STAP.controle);
+                    finished = true;
+                }
+                else {
+                    reached.push(STAP.controle);
+                    busy = {
+                        stepId: STAP.controle,
+                        reason: `${carts.controlled} van ${carts.total} karren gecontroleerd`,
+                    };
+                }
+            }
+        }
+        if (isLaatste && order?.status && AFGEROND.has(order.status.toLowerCase())) {
+            if (!reached.includes(STAP.controle))
+                reached.push(STAP.drukte, STAP.stations, STAP.controle);
+            busy = null;
+            finished = true;
+        }
+    }
+    if (isLaatste && order?.cancelledAt) {
+        stuck = { stepId: stuck?.stepId ?? busy?.stepId ?? STAP.combineren, reason: "Order is geannuleerd" };
+        busy = null;
+        finished = false;
+    }
+    const uniek = [...new Set(reached)];
+    const summary = finished
+        ? "Route volledig doorlopen: order is gecontroleerd en afgemeld."
+        : stuck
+            ? `Vastgelopen bij "${stapLabel(stuck.stepId)}": ${stuck.reason}`
+            : busy
+                ? `Nu bij "${stapLabel(busy.stepId)}": ${busy.reason}`
+                : `Gekomen tot "${stapLabel(uniek[uniek.length - 1] ?? STAP.combineren)}".`;
+    return { source, reached: uniek, stuck, busy, finished, summary };
+}
+export function stapLabel(stepId) {
+    return WIZARD_STEPS.find((s) => s.id === stepId)?.label ?? stepId;
+}
+// ── Route over de kaart leggen ──────────────────────────────────────────────
+/** Stapvolgorde-index van een knoop; -1 = vóór de eerste stap; 99 = einde. */
+function stapIndex(node, byId) {
+    if (!node)
+        return -1;
+    if (node.id === "__eind")
+        return 99;
+    if (node.id.startsWith("__"))
+        return -1;
+    const m = /^(?:samen:)?stap:(.+)$/.exec(node.id);
+    if (m)
+        return STEP_IDS.indexOf(m[1]);
+    if (node.stepId)
+        return STEP_IDS.indexOf(node.stepId);
+    for (const a of [...node.ancestors].reverse()) {
+        const anc = byId.get(a);
+        if (anc?.stepId)
+            return STEP_IDS.indexOf(anc.stepId);
+    }
+    return -1;
+}
+/**
+ * Maakt een kopie van de kaart waarin alleen de gelopen route "active" is.
+ * Knopen/pijlen die de order (nog) niet heeft bereikt worden "possible".
+ *
+ * Zijn er echte gebeurtenissen per vakje (`groepen`), dan winnen die: de reis
+ * komt dan uit wat de Engine heeft vastgelegd. De heuristiek hieronder blijft
+ * de terugval voor oudere gebeurtenissen zonder vakje.
+ */
+export function applyRoute(tree, route, groepen) {
+    const markers = new Map();
+    const nodes = Array.isArray(tree?.nodes) ? tree.nodes : [];
+    const edges = Array.isArray(tree?.edges) ? tree.edges : [];
+    if (!route)
+        return { tree: { nodes, edges }, markers };
+    const echt = groepen && groepen.size > 0 ? groepen : null;
+    const byId = new Map(nodes.map((n) => [n.id, n]));
+    const maxIdx = route.reached.reduce((m, id) => Math.max(m, STEP_IDS.indexOf(id)), -1);
+    const bereikt = (idx) => (idx === 99 ? route.finished : idx <= maxIdx);
+    // Het bronvakje van deze order (Floriday, mail, actiemail of handmatig).
+    const bronNode = route.source === "floriday"
+        ? FLOW_NODE.bronFloriday
+        : route.source === "mail"
+            ? FLOW_NODE.bronMail
+            : route.source === "actiemail"
+                ? FLOW_NODE.bronActiemail
+                : route.source === "handmatig"
+                    ? FLOW_NODE.bronHandmatig
+                    : null;
+    const bronTak = (id) => id === FLOW_NODE.bronFloriday ||
+        id === FLOW_NODE.bronMail ||
+        id === FLOW_NODE.bronActiemail ||
+        id === FLOW_NODE.bronHandmatig;
+    /** Hoort dit bronvakje (of de samenvoegstap erna) bij deze order? */
+    const bronOk = (id) => {
+        if (bronTak(id))
+            return id === bronNode;
+        if (id === FLOW_NODE.samenvoegen)
+            return bronNode === FLOW_NODE.bronFloriday;
+        return true;
+    };
+    /** Ligt dit vakje op de reis? Echte gebeurtenissen gaan vóór de heuristiek. */
+    const opReis = (n) => {
+        if (bronTak(n.id) || n.id === FLOW_NODE.samenvoegen) {
+            return bronOk(n.id) && (echt ? true : bereikt(-1));
+        }
+        if (echt) {
+            if (echt.has(n.id))
+                return true;
+            if (n.ancestors.some((a) => echt.has(a)))
+                return true;
+            if (n.stepId && echt.has(`stap:${n.stepId}`))
+                return true;
+            if (n.id === "__start" || n.id === "__bron" || n.id === "__bron_merge")
+                return true;
+            return false;
+        }
+        return bereikt(stapIndex(n, byId));
+    };
+    const demote = (s) => (s === "active" ? "possible" : s);
+    const newNodes = nodes.map((n) => {
+        const ok = n.state === "active" && opReis(n);
+        return ok ? { ...n, route: true } : { ...n, state: demote(n.state), route: false };
+    });
+    const nodeState = new Map(newNodes.map((n) => [n.id, n.state]));
+    const newEdges = edges.map((e) => {
+        if (e.state !== "active")
+            return e;
+        const to = byId.get(e.to);
+        const from = byId.get(e.from);
+        const ok = nodeState.get(e.from) === "active" &&
+            nodeState.get(e.to) === "active" &&
+            (echt
+                ? !!(from && to && opReis(from) && opReis(to))
+                : bereikt(Math.max(stapIndex(from, byId), stapIndex(to, byId)))) &&
+            bronOk(e.from) &&
+            bronOk(e.to);
+        return ok ? { ...e, route: true } : { ...e, state: "possible", route: false };
+    });
+    if (echt) {
+        for (const g of echt.values()) {
+            const kind = g.status === "mislukt" ? "stuck" : g.status === "wachtend" || g.status === "waarschuwing" ? "busy" : "done";
+            const uitleg = vakUitleg(g);
+            markers.set(g.nodeId, {
+                kind,
+                text: uitleg.beslissing,
+                beslissing: uitleg.beslissing,
+                waarom: uitleg.waarom,
+                feiten: uitleg.feiten,
+                at: g.laatste,
+                durationMs: g.duurMs,
+                count: g.aantal,
+                attempts: g.pogingen,
+                errorClass: g.errorClass,
+                nextStep: g.volgendeStap,
+            });
+        }
+        return { tree: { nodes: newNodes, edges: newEdges }, markers };
+    }
+    if (route.stuck)
+        markers.set(`stap:${route.stuck.stepId}`, { kind: "stuck", text: route.stuck.reason });
+    else if (route.busy)
+        markers.set(`stap:${route.busy.stepId}`, { kind: "busy", text: route.busy.reason });
+    if (route.finished)
+        markers.set("__eind", { kind: "done", text: "Afgehandeld" });
+    return { tree: { nodes: newNodes, edges: newEdges }, markers };
+}

package/dist-lib/lib/flowTree.d.ts

@@ -0,0 +1,64 @@
+import { type RuleEngineSettings, type RuleField } from "./ruleEngineSchema";
+export type FlowState = "active" | "possible" | "disabled";
+export type TreeNodeKind = "start" | "end" | "source" | "step" | "decision" | "setting" | "option" | "merge";
+export interface TreeOption {
+    value: string;
+    label: string;
+}
+export interface TreeNode {
+    id: string;
+    kind: TreeNodeKind;
+    label: string;
+    sublabel?: string;
+    state: FlowState;
+    /** Wizardstap waar deze knoop bij hoort (voor het zijpaneel). */
+    stepId?: string;
+    storeId?: string;
+    fieldKey?: string;
+    /** Alleen bij beslissingen: alle keuzes. */
+    options?: TreeOption[];
+    currentValue?: string;
+    isBoolean?: boolean;
+    /** Alleen bij beslissingen: de samenkomst-knoop van deze beslissing. */
+    mergeId?: string;
+    /** Beslissingen waar deze knoop onder hangt (voor inklappen). */
+    ancestors: string[];
+    help: string[];
+    /** Alleen bij instellingenblokken: één regel per instelling. */
+    lines?: string[];
+    /** Veldsleutels die in dit vakje bewerkt kunnen worden (dubbelklik). */
+    fieldKeys?: string[];
+    /** Ligt op de gelopen route van een gekozen order (blauwe lijn). */
+    route?: boolean;
+    w: number;
+    h: number;
+}
+export interface TreeEdge {
+    id: string;
+    from: string;
+    to: string;
+    label?: string;
+    state: FlowState;
+    /** flow = de route; ref = verwijzing naar een keuze uit een andere stap. */
+    kind: "flow" | "ref";
+    ancestors: string[];
+    /** Ligt op de gelopen route van een gekozen order (blauwe lijn). */
+    route?: boolean;
+}
+export interface FlowTree {
+    nodes: TreeNode[];
+    edges: TreeEdge[];
+}
+export declare const NODE_SIZE: Record<TreeNodeKind, {
+    w: number;
+    h: number;
+}>;
+/**
+ * Zoekt de schemavelden op die bij een vakje horen. Gebruikt dezelfde
+ * WIZARD_STEPS als het instelscherm, zodat er geen tweede definitie ontstaat.
+ */
+export declare function fieldsFor(storeId?: string, keys?: string[]): RuleField[];
+export declare function valueText(field: RuleField, value: unknown): string;
+/** Bouwt de complete beslisboom van binnenkomst tot afgehandelde order. */
+export declare function buildFlowTree(settings: RuleEngineSettings): FlowTree;
+//# sourceMappingURL=flowTree.d.ts.map

package/dist-lib/lib/flowTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flowTree.d.ts","sourceRoot":"","sources":["../../src/lib/flowTree.ts"],"names":[],"mappings":"AAWA,OAAO,EAIL,KAAK,kBAAkB,EACvB,KAAK,SAAS,EAEf,MAAM,oBAAoB,CAAC;AAG5B,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,UAAU,GAAG,UAAU,CAAC;AAE3D,MAAM,MAAM,YAAY,GACpB,OAAO,GACP,KAAK,GACL,QAAQ,GACR,MAAM,GACN,UAAU,GACV,SAAS,GACT,QAAQ,GACR,OAAO,CAAC;AAEZ,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,YAAY,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,SAAS,CAAC;IACjB,iEAAiE;IACjE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4CAA4C;IAC5C,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,wEAAwE;IACxE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iEAAiE;IACjE,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,gEAAgE;IAChE,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,wEAAwE;IACxE,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,oEAAoE;IACpE,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,SAAS,CAAC;IACjB,4EAA4E;IAC5E,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC;IACrB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,oEAAoE;IACpE,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,KAAK,EAAE,QAAQ,EAAE,CAAC;CACnB;AAED,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,YAAY,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CASpE,CAAC;AAwCF;;;GAGG;AACH,wBAAgB,SAAS,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,EAAE,CAcxE;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,CA0BlE;AA6BD,2EAA2E;AAC3E,wBAAgB,aAAa,CAAC,QAAQ,EAAE,kBAAkB,GAAG,QAAQ,CA+NpE"}