@flowselections/floriday-verkoop-module 1.0.125 → 1.0.127

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (39) hide show
  1. package/dist-lib/lib/cart-replan.functions.d.ts +3 -58
  2. package/dist-lib/lib/cart-replan.functions.d.ts.map +1 -1
  3. package/dist-lib/lib/cart-replan.functions.js +3 -364
  4. package/dist-lib/lib/cart-replan.server.d.ts +67 -0
  5. package/dist-lib/lib/cart-replan.server.d.ts.map +1 -0
  6. package/dist-lib/lib/cart-replan.server.js +367 -0
  7. package/dist-lib/lib/create-order.functions.d.ts.map +1 -1
  8. package/dist-lib/lib/create-order.functions.js +8 -2
  9. package/dist-lib/lib/cron/salesorders-sync.server.d.ts +20 -0
  10. package/dist-lib/lib/cron/salesorders-sync.server.d.ts.map +1 -0
  11. package/dist-lib/lib/cron/salesorders-sync.server.js +104 -0
  12. package/dist-lib/lib/cron/sync-salesorders.js +1 -1
  13. package/dist-lib/lib/engine-wake.server.d.ts +3 -1
  14. package/dist-lib/lib/engine-wake.server.d.ts.map +1 -1
  15. package/dist-lib/lib/engine-wake.server.js +16 -14
  16. package/dist-lib/lib/floriday-mirror.functions.d.ts +1 -19
  17. package/dist-lib/lib/floriday-mirror.functions.d.ts.map +1 -1
  18. package/dist-lib/lib/floriday-mirror.functions.js +6 -1475
  19. package/dist-lib/lib/floriday-mirror.server.d.ts +20 -0
  20. package/dist-lib/lib/floriday-mirror.server.d.ts.map +1 -0
  21. package/dist-lib/lib/floriday-mirror.server.js +1475 -0
  22. package/dist-lib/lib/module-version.d.ts +1 -1
  23. package/dist-lib/lib/module-version.js +1 -1
  24. package/dist-lib/lib/order-buffers.functions.d.ts +0 -2
  25. package/dist-lib/lib/order-buffers.functions.d.ts.map +1 -1
  26. package/dist-lib/lib/order-buffers.functions.js +0 -10
  27. package/dist-lib/lib/order-buffers.server.d.ts +3 -0
  28. package/dist-lib/lib/order-buffers.server.d.ts.map +1 -0
  29. package/dist-lib/lib/order-buffers.server.js +11 -0
  30. package/dist-lib/lib/order-cancel.server.d.ts +2 -0
  31. package/dist-lib/lib/order-cancel.server.d.ts.map +1 -1
  32. package/dist-lib/lib/order-cancel.server.js +1 -1
  33. package/dist-lib/lib/order-item-packing.functions.js +1 -1
  34. package/dist-lib/lib/salesorders-list.functions.d.ts.map +1 -1
  35. package/dist-lib/lib/salesorders-list.functions.js +7 -5
  36. package/dist-lib/lib/salesorders.functions.d.ts +0 -14
  37. package/dist-lib/lib/salesorders.functions.d.ts.map +1 -1
  38. package/dist-lib/lib/salesorders.functions.js +4 -102
  39. package/package.json +3 -2
@@ -1,1481 +1,12 @@
1
- import { diffBuyerChanges } from "./floriday-change-diff.js";
2
- import { MISSING_LINE_KEY_NOTICE, splitByLineKey } from "./floriday-line-key.js";
3
- import { keepOrSetCustomer, promoteCustomers } from "./floriday-promote-customer.js";
4
- import { fillOnlyEmpty, snapshotFromFloridayOrder } from "./packing-snapshot.js";
5
- // Spiegelt Floriday-verkooporders (FO's) uit `floriday_salesorders_cache`
6
- // naar de lokale `orders`-tabel, zodat ze via `resolveBufferForOrderInternal`
7
- // in dezelfde buffer terechtkomen als lokale orders en gedeelde karren
8
- // kunnen ontstaan.
9
- //
10
- // - Alleen recente/toekomstige FO's worden gespiegeld (delivery >= today - 14d)
11
- // om te voorkomen dat ~40k historische orders de tabel opblazen.
12
- // - De minuutronde (sync-salesorders) roept `mirrorFloridayOrdersFromCron`
13
- // aan; het spiegelen draait onder een eigen slot, zodat twee aanroepen
14
- // nooit tegelijk dezelfde orders verwerken.
1
+ // Scherm-aanroepbare spiegelactie. Alleen createServerFn-exports; het
2
+ // spiegelwerk zelf staat in floriday-mirror.server.ts (server-only).
15
3
  import { createServerFn } from "@tanstack/react-start";
16
4
  import { z } from "zod";
17
- import { deriveOrderLevel } from "./floriday-order-level.js";
18
- import { productNameForStorage } from "./product-name.js";
19
5
  import { requireSupabaseAuth } from "../integrations/supabase/auth-middleware.js";
20
- import { resolveBufferForOrderInternal } from "./order-buffers.functions.js";
21
- const LOOKBACK_DAYS = 14;
22
- const DEFAULT_BATCH = 200;
23
- /** Onbekend blijft onbekend: geen stilzwijgende 1. Zelfde helper als de planner. */
24
- function pos(value) {
25
- if (value === null || value === undefined)
26
- return null;
27
- const n = Number(value);
28
- return Number.isFinite(n) && n > 0 ? Math.round(n) : null;
29
- }
30
- /** Stabiele JSON-vergelijking (sleutelvolgorde mag verschillen). */
31
- function stableJson(value) {
32
- const walk = (v) => {
33
- if (v === null || typeof v !== "object")
34
- return v ?? null;
35
- if (Array.isArray(v))
36
- return v.map(walk);
37
- const out = {};
38
- for (const k of Object.keys(v).sort())
39
- out[k] = walk(v[k]);
40
- return out;
41
- };
42
- return JSON.stringify(walk(value ?? null));
43
- }
44
- function sameJson(a, b) {
45
- return stableJson(a) === stableJson(b);
46
- }
47
- /** Datums vergelijken zonder ruis van tijdzone- of notatieverschillen. */
48
- function sameDate(a, b) {
49
- const norm = (v) => {
50
- if (v === null || v === undefined || v === "")
51
- return "";
52
- const d = new Date(String(v));
53
- return Number.isNaN(d.getTime()) ? String(v) : d.toISOString();
54
- };
55
- return norm(a) === norm(b);
56
- }
57
- /** Een bron telt alleen als álle drie de velden gevuld zijn (> 0). */
58
- function completeSource(plants_per_crate, crates_per_layer, layers_per_cart) {
59
- const a = pos(plants_per_crate);
60
- const b = pos(crates_per_layer);
61
- const c = pos(layers_per_cart);
62
- return a && b && c ? { plants_per_crate: a, crates_per_layer: b, layers_per_cart: c } : null;
63
- }
64
- /** Koper-organisatienummer: kolom uit de cache, met de Floriday-data als terugval. */
65
- function buyerOrgIdOf(row) {
66
- return String(row?.buyer_organization_id ?? row?.data?.customerOrganizationId ?? "");
67
- }
68
- /**
69
- * Vangnet: Floriday-orders zonder customer_id krijgen de klant die
70
- * promote_floriday_customer teruggeeft. Organisatienummer: custom_fields.
71
- * floriday_customer_id, anders de koper uit de Floriday-gegevens. Alleen
72
- * customer_id wordt gezet, alleen als die nog leeg is.
73
- */
74
- async function linkCustomersForFloridayOrders() {
75
- const { supabaseAdmin } = await import("../integrations/supabase/client.server.js");
76
- const { data: loose, error: lErr } = await supabaseAdmin
77
- .from("orders")
78
- .select("id, floriday_sales_order_id, custom_fields")
79
- .is("customer_id", null)
80
- .not("floriday_sales_order_id", "is", null)
81
- .limit(1000);
82
- if (lErr)
83
- throw new Error(lErr.message);
84
- const todo = (loose ?? []);
85
- if (!todo.length)
86
- return 0;
87
- const needCache = [
88
- ...new Set(todo.filter((o) => !o?.custom_fields?.floriday_customer_id).map((o) => String(o.floriday_sales_order_id))),
89
- ];
90
- const orgBySo = new Map();
91
- for (let i = 0; i < needCache.length; i += 200) {
92
- const { data: cache, error: cErr } = await supabaseAdmin
93
- .from("floriday_salesorders_cache")
94
- .select("floriday_id, buyer_organization_id")
95
- .in("floriday_id", needCache.slice(i, i + 200));
96
- if (cErr)
97
- throw new Error(cErr.message);
98
- for (const r of cache ?? []) {
99
- const org = r.buyer_organization_id;
100
- if (org)
101
- orgBySo.set(String(r.floriday_id), String(org));
102
- }
103
- }
104
- const orgOf = (o) => (o?.custom_fields?.floriday_customer_id ? String(o.custom_fields.floriday_customer_id) : null) ??
105
- orgBySo.get(String(o.floriday_sales_order_id)) ??
106
- null;
107
- const promoted = await promoteCustomers(todo.map(orgOf).filter(Boolean), (org) => supabaseAdmin.rpc("promote_floriday_customer", { _org_id: org }));
108
- let linked = 0;
109
- for (const o of todo) {
110
- const org = orgOf(o);
111
- const custId = org ? promoted.get(org) : null;
112
- if (!custId)
113
- continue;
114
- const { data, error } = await supabaseAdmin
115
- .from("orders")
116
- .update({ customer_id: custId })
117
- .eq("id", o.id)
118
- .is("customer_id", null)
119
- .select("id");
120
- if (error)
121
- throw new Error(error.message);
122
- linked += data?.length ?? 0;
123
- }
124
- return linked;
125
- }
126
- function pickString(value) {
127
- if (value == null)
128
- return null;
129
- if (typeof value === "string" || typeof value === "number") {
130
- const s = String(value).trim();
131
- return s ? s : null;
132
- }
133
- if (Array.isArray(value)) {
134
- for (const item of value) {
135
- const s = pickString(item);
136
- if (s)
137
- return s;
138
- }
139
- return null;
140
- }
141
- if (typeof value === "object") {
142
- return (pickString(value.gln) ??
143
- pickString(value.locationGln) ??
144
- pickString(value.warehouseId) ??
145
- pickString(value.id) ??
146
- pickString(value.name) ??
147
- pickString(value.location) ??
148
- pickString(value.address?.addressLine) ??
149
- null);
150
- }
151
- return null;
152
- }
153
- // Eigen slot, los van het slot van de minuutronde (die houdt haar slot vast
154
- // terwijl ze dit spiegelen aanroept). Faalt gesloten: geen slot = geen ronde.
155
- const MIRROR_LOCK_KEY = "verkoop:floriday-mirror";
156
- const MIRROR_LOCK_SECONDS = 600;
157
- async function mirrorInternal(limit, since = null) {
158
- const { supabaseAdmin } = await import("../integrations/supabase/client.server.js");
159
- const empty = (reason, ok) => ({
160
- ok, processed: 0, inserted: 0, updated: 0, skipped: 0, failed: 0, errors: ok ? [] : [reason], skipped_reason: reason,
161
- });
162
- const { data: acquired, error: lockErr } = await supabaseAdmin.rpc("try_acquire_job_lock", { _key: MIRROR_LOCK_KEY, _seconds: MIRROR_LOCK_SECONDS, _owner: "floriday-mirror" });
163
- if (lockErr)
164
- return empty(`slot nemen mislukt: ${lockErr.message}`, false);
165
- if (acquired !== true)
166
- return empty("already-running", true);
167
- try {
168
- return await mirrorUnlocked(limit, since);
169
- }
170
- finally {
171
- try {
172
- await supabaseAdmin.rpc("release_job_lock", { _key: MIRROR_LOCK_KEY });
173
- }
174
- catch {
175
- /* slot verloopt vanzelf */
176
- }
177
- }
178
- }
179
- async function mirrorUnlocked(limit, since) {
180
- const { supabaseAdmin } = await import("../integrations/supabase/client.server.js");
181
- const { loadFloridayFulfillmentStates, expectedPackagesFromSalesOrder, isFullyFulfilled, } = await import("./floriday-fulfillment-status.server.js");
182
- const cutoffIso = new Date(Date.now() - LOOKBACK_DAYS * 24 * 60 * 60 * 1000).toISOString();
183
- // Recente/toekomstige FO's uit de cache.
184
- // Met watermerk (minuutronde): alleen salesorders die sinds `since` gewijzigd
185
- // zijn, plus salesorders waarvan de afhandeling (index) sindsdien wijzigde.
186
- let cacheQuery = supabaseAdmin
187
- .from("floriday_salesorders_cache")
188
- .select("floriday_id, data, updated_at, buyer_organization_id")
189
- .eq("is_deleted", false)
190
- .gte("data->delivery->>latestDeliveryDateTime", cutoffIso);
191
- if (since)
192
- cacheQuery = cacheQuery.gt("updated_at", since);
193
- const { data: baseRows, error: cacheErr } = await cacheQuery
194
- .order("updated_at", { ascending: false })
195
- .limit(limit);
196
- if (cacheErr)
197
- throw new Error(cacheErr.message);
198
- let cacheRows = (baseRows ?? []);
199
- if (since) {
200
- const { data: idxRows, error: idxErr } = await supabaseAdmin
201
- .from("verkoop_fulfillment_index")
202
- .select("sales_order_id")
203
- .gt("changed_at", since)
204
- .limit(limit);
205
- if (idxErr)
206
- throw new Error(`afhandelingsindex lezen: ${idxErr.message}`);
207
- const have = new Set(cacheRows.map((r) => String(r.floriday_id)));
208
- const extra = Array.from(new Set((idxRows ?? []).map((r) => String(r.sales_order_id)))).filter((id) => !have.has(id));
209
- for (let i = 0; i < extra.length; i += 200) {
210
- const { data: more, error: mErr } = await supabaseAdmin
211
- .from("floriday_salesorders_cache")
212
- .select("floriday_id, data, updated_at, buyer_organization_id")
213
- .eq("is_deleted", false)
214
- .in("floriday_id", extra.slice(i, i + 200));
215
- if (mErr)
216
- throw new Error(mErr.message);
217
- cacheRows = cacheRows.concat((more ?? []));
218
- }
219
- }
220
- const rows = (cacheRows ?? []);
221
- if (rows.length === 0) {
222
- // Ook zonder nieuwe Floriday-gegevens: orders koppelen aan klanten die
223
- // inmiddels (bijv. door de Klanten-module) zijn aangemaakt.
224
- const errors = [];
225
- try {
226
- await linkCustomersForFloridayOrders();
227
- }
228
- catch (e) {
229
- errors.push(`klantkoppeling: ${String(e?.message ?? e).slice(0, 150)}`);
230
- }
231
- return { ok: errors.length === 0, processed: 0, inserted: 0, updated: 0, skipped: 0, failed: 0, errors };
232
- }
233
- // Bestaande mirrors ophalen (voor insert/update-onderscheid).
234
- const foIds = rows.map((r) => String(r.floriday_id));
235
- // Ordernummers komen ALTIJD uit floriday_order_number_map. De DB-trigger
236
- // tg_orders_assign_number kent voor orders met floriday_sales_order_id niets
237
- // meer toe, dus dit is de enige bron. Ook in het update-pad, zodat een order
238
- // met een eerder verkeerd toegekend nummer zichzelf herstelt.
239
- const orderNumberByFoId = new Map();
240
- try {
241
- const { data: numRows, error: numErr } = await supabaseAdmin.rpc("assign_floriday_order_numbers", { p_ids: foIds });
242
- if (numErr)
243
- throw new Error(numErr.message);
244
- for (const n of (numRows ?? [])) {
245
- const num = String(n.order_number ?? "").trim();
246
- if (num)
247
- orderNumberByFoId.set(String(n.floriday_id), num);
248
- }
249
- }
250
- catch (err) {
251
- console.error(`[floriday-mirror] ordernummers ophalen mislukt: ${err.message}`);
252
- }
253
- const { data: existing } = await supabaseAdmin
254
- .from("orders")
255
- .select("id, order_number, floriday_sales_order_id, floriday_order_group_key, updated_at, custom_fields, status, plan_locked_at, buffer_id, customer_id, customer_name, delivery_date, order_date, total, order_source, deleted_at")
256
- .in("floriday_sales_order_id", foIds)
257
- .is("deleted_at", null);
258
- const existingByFoId = new Map();
259
- for (const o of existing ?? []) {
260
- existingByFoId.set(String(o.floriday_sales_order_id), o);
261
- }
262
- // Samenvoegingen door de Logistieke Engine (logistics_merge_floriday_lines).
263
- // De Engine zet de samengevoegde order op verwijderd en verplaatst de regels
264
- // naar de aangehouden order. Zonder deze kennis probeerde de spiegelronde
265
- // elke ronde opnieuw een order aan te maken en liep ze vast op de unieke
266
- // sleutels (ordernummer / Floriday-nummer) van de verwijderde rij.
267
- const ORDER_COLS = "id, order_number, floriday_sales_order_id, floriday_order_group_key, updated_at, custom_fields, status, plan_locked_at, buffer_id, customer_id, customer_name, delivery_date, order_date, total, order_source, deleted_at";
268
- const deletedByFoId = new Map();
269
- const mergedTargetByFoId = new Map();
270
- const lineOwnerByFoId = new Map();
271
- const mergedKeptIds = new Set();
272
- if (foIds.length > 0) {
273
- const { data: delRows, error: delErr } = await supabaseAdmin
274
- .from("orders")
275
- .select(ORDER_COLS)
276
- .in("floriday_sales_order_id", foIds)
277
- .not("deleted_at", "is", null);
278
- if (delErr)
279
- throw new Error(`verwijderde orders lezen: ${delErr.message}`);
280
- for (const o of delRows ?? []) {
281
- deletedByFoId.set(String(o.floriday_sales_order_id), o);
282
- }
283
- const { data: mergeRows, error: mErr } = await supabaseAdmin
284
- .from("logistics_order_merges")
285
- .select("merged_order_id, kept_order_id, sales_order_id")
286
- .in("sales_order_id", foIds);
287
- if (mErr)
288
- throw new Error(`samenvoegingen lezen: ${mErr.message}`);
289
- const { data: ownerItems, error: oiErr } = await supabaseAdmin.from("order_items")
290
- .select("order_id, source_line_key")
291
- .in("source_line_key", foIds);
292
- if (oiErr)
293
- throw new Error(`regeleigenaren lezen: ${oiErr.message}`);
294
- const wantIds = new Set();
295
- for (const m of (mergeRows ?? []))
296
- wantIds.add(String(m.kept_order_id));
297
- for (const it of (ownerItems ?? []))
298
- wantIds.add(String(it.order_id));
299
- const liveById = new Map();
300
- const idList = Array.from(wantIds);
301
- for (let i = 0; i < idList.length; i += 200) {
302
- const { data: live, error: lErr } = await supabaseAdmin
303
- .from("orders")
304
- .select(ORDER_COLS)
305
- .in("id", idList.slice(i, i + 200))
306
- .is("deleted_at", null);
307
- if (lErr)
308
- throw new Error(`aangehouden orders lezen: ${lErr.message}`);
309
- for (const o of live ?? [])
310
- liveById.set(String(o.id), o);
311
- }
312
- for (const m of (mergeRows ?? [])) {
313
- const kept = liveById.get(String(m.kept_order_id));
314
- if (kept) {
315
- mergedTargetByFoId.set(String(m.sales_order_id), kept);
316
- mergedKeptIds.add(String(kept.id));
317
- }
318
- }
319
- for (const it of (ownerItems ?? [])) {
320
- const owner = liveById.get(String(it.order_id));
321
- if (owner)
322
- lineOwnerByFoId.set(String(it.source_line_key), owner);
323
- }
324
- }
325
- // Groepeert de Engine buiten het tijdvenster? Dan zoeken we bestaande orders
326
- // ook op de Engine-sleutel (de groepssleutel zonder minuut).
327
- let engineMergeEnabled = false;
328
- {
329
- const { data: me, error: meErr } = await supabaseAdmin.rpc("logistics_merge_lines_enabled");
330
- if (!meErr)
331
- engineMergeEnabled = me === true;
332
- }
333
- const mergeKeyOf = (k) => {
334
- const parts = String(k ?? "").split("|");
335
- return parts.length > 1 ? parts.slice(0, -1).join("|") : null;
336
- };
337
- // Afhandeling die in Floriday zelf is gedaan (afleverbrieven). Zo'n order is
338
- // de deur uit, ook al staat de verkooporder in Floriday nog op COMMITTED.
339
- let fulfillmentStates = new Map();
340
- try {
341
- fulfillmentStates = await loadFloridayFulfillmentStates(supabaseAdmin, foIds);
342
- }
343
- catch {
344
- /* afhandelstatus is best-effort */
345
- }
346
- // Klant per koper: altijd via de Klanten-module (promote_floriday_customer),
347
- // één aanroep per organisatienummer per ronde. Fout → geen klant.
348
- const orgIds = Array.from(new Set(rows.map((r) => buyerOrgIdOf(r)).filter(Boolean)));
349
- const customerByOrgId = new Map();
350
- if (orgIds.length > 0) {
351
- const promotedIds = await promoteCustomers(orgIds, (org) => supabaseAdmin.rpc("promote_floriday_customer", { _org_id: org }));
352
- if (promotedIds.size > 0) {
353
- const { data: promRows } = await supabaseAdmin
354
- .from("customers")
355
- .select("id, company_name, commercial_name")
356
- .in("id", Array.from(new Set(promotedIds.values())));
357
- const byId = new Map((promRows ?? []).map((c) => [String(c.id), c]));
358
- for (const [org, id] of promotedIds) {
359
- const c = byId.get(id);
360
- customerByOrgId.set(org, {
361
- id,
362
- name: c?.commercial_name ?? c?.company_name ?? "Onbekende klant",
363
- });
364
- }
365
- }
366
- }
367
- const { data: floCustRows } = await supabaseAdmin
368
- .from("floriday_customers_cache")
369
- .select("organization_id, data")
370
- .in("organization_id", orgIds.length ? orgIds : ["-"]);
371
- const floCustByOrgId = new Map();
372
- for (const c of floCustRows ?? []) {
373
- floCustByOrgId.set(String(c.organization_id), c.data ?? {});
374
- }
375
- // Product-lookup: floriday_trade_item_id → product met packing.
376
- const tradeItemIds = Array.from(new Set(rows.map((r) => String(r.data?.tradeItemId ?? "")).filter(Boolean)));
377
- const productByTradeItemId = new Map();
378
- if (tradeItemIds.length > 0) {
379
- const { data: prodRows } = await supabaseAdmin
380
- .from("products")
381
- .select("id, product, article_number, plants_per_crate, crates_per_layer, layers_per_cart, floriday_trade_item_id")
382
- .in("floriday_trade_item_id", tradeItemIds);
383
- for (const p of prodRows ?? []) {
384
- productByTradeItemId.set(String(p.floriday_trade_item_id), p);
385
- }
386
- }
387
- // Trade-item cache voor naam/packing fallback.
388
- const { data: tiRows } = await supabaseAdmin
389
- .from("floriday_trade_items_cache")
390
- .select("floriday_id, data")
391
- .in("floriday_id", tradeItemIds.length ? tradeItemIds : ["-"]);
392
- const tiByFoId = new Map();
393
- for (const t of tiRows ?? []) {
394
- tiByFoId.set(String(t.floriday_id), t.data ?? {});
395
- }
396
- let inserted = 0, updated = 0, skipped = 0, unchanged = 0, failed = 0;
397
- const errors = [];
398
- const affectedOrderIds = [];
399
- const floridayCancelIds = [];
400
- // Orders die in deze ronde echt zijn aangemaakt of gewijzigd: alleen die
401
- // melden we expliciet aan bij de planwachtrij van de logistiek-engine.
402
- const changedOrderIds = [];
403
- // Statusmapping Floriday -> onze pickstatus. "gemeten" = feitelijk
404
- // aangetroffen in floriday_salesorders_cache; "uit code" = staat wel in de
405
- // Floriday-types/onze code, maar is nooit in de data gezien.
406
- const FLORIDAY_STATUS_MAP = {
407
- open: "Nog te picken", // uit code
408
- new: "Nog te picken", // uit code
409
- nieuw: "Nog te picken", // uit code
410
- committed: "Nog te picken", // GEMETEN
411
- confirmed: "Nog te picken", // uit code
412
- accepted: "Nog te picken", // uit code
413
- processing: "Nog te picken", // uit code
414
- shipped: "Nog te picken", // uit code — Floriday-shipped is voor ons geen
415
- delivered: "Nog te picken", // uit code — bewijs van vertrek; de karren-/
416
- // shipmentroute bepaalt onze "Verzonden".
417
- pending: "Nog te picken", // uit code
418
- cancelled: "geannuleerd", // uit code
419
- canceled: "geannuleerd", // uit code
420
- rejected: "geannuleerd", // uit code
421
- expired: "geannuleerd", // uit code
422
- unfulfillable: "geannuleerd", // uit code
423
- };
424
- /** Eén Floriday-verkooporder = één toekomstige orderregel. */
425
- function buildLine(row) {
426
- const foId = String(row.floriday_id);
427
- const d = row.data ?? {};
428
- const orgId = buyerOrgIdOf(row);
429
- const cust = customerByOrgId.get(orgId);
430
- const floCust = floCustByOrgId.get(orgId) ?? {};
431
- const customerName = cust?.name ?? floCust?.commercialName ?? floCust?.name ?? "Onbekende klant";
432
- const delivery = d?.delivery ?? {};
433
- const deliveryIso = delivery?.latestDeliveryDateTime ?? "";
434
- const orderDateIso = d?.orderDateTime ?? d?.creationDateTime ?? new Date().toISOString();
435
- const pickupLocation = pickString(d?.despatchWarehouseId ?? delivery?.pickupLocation);
436
- const deliveryLocation = pickString(delivery?.location?.gln ??
437
- delivery?.locationGln ??
438
- delivery?.deliveryLocation ??
439
- delivery?.location ??
440
- delivery?.regionGln);
441
- const numberOfPieces = Number(d?.numberOfPieces ?? 0);
442
- const tradeItemId = String(d?.tradeItemId ?? "");
443
- const tiCache = tiByFoId.get(tradeItemId) ?? {};
444
- // Verpakking-snapshot (1.0.105): alleen de packingConfiguration van déze
445
- // sales order. Geen terugval op de artikelkopie of het product: die kopie
446
- // kon door andere processen overschreven zijn (1/10/4). Bij klokorders
447
- // zijn fusten per laag en lagen 0 → leeg; de Logistieke Engine vult aan.
448
- // Ontbrekend blijft leeg, nooit 1.
449
- const snapshot = snapshotFromFloridayOrder(d?.packingConfiguration);
450
- const piecesPerPackage = snapshot.plants_per_crate;
451
- const packagesPerLayer = snapshot.crates_per_layer;
452
- const layersPerLoadCarrier = snapshot.layers_per_cart;
453
- const packingSource = snapshot.packing_source ? "order" : null;
454
- const productRow = productByTradeItemId.get(tradeItemId);
455
- const productName = productNameForStorage(productRow?.product, tiCache?.name, tiCache?.tradeItemName, d?.tradeItemName, productRow?.article_number, "Floriday-artikel");
456
- const productId = productRow?.id ?? null;
457
- const plants_per_crate = piecesPerPackage;
458
- const crates_per_layer = packagesPerLayer;
459
- const layers_per_cart = layersPerLoadCarrier;
460
- const totalPrice = Number(d?.calculatedFields?.orderAmount?.value ?? 0);
461
- const ff = fulfillmentStates.get(foId);
462
- const fullyFulfilled = ff
463
- ? Boolean(ff.received) || isFullyFulfilled(ff, expectedPackagesFromSalesOrder(d))
464
- : false;
465
- const rawStatus = String(d?.status ?? "").toLowerCase() || "open";
466
- const mapped = FLORIDAY_STATUS_MAP[rawStatus];
467
- if (!mapped) {
468
- console.warn(`[floriday-mirror] onbekende Floriday-status "${rawStatus}" voor order ${foId} — val terug op "Nog te picken"`);
469
- }
470
- const status = mapped ?? "Nog te picken";
471
- // Fustcode en ladingdrager horen bij dezelfde configuratie als de
472
- // belading. Is geen enkele bron compleet, dan geldt de gewone
473
- // bronvolgorde (order → trade item) voor alleen deze codes; er worden
474
- // nooit beladingsgetallen uit verschillende bronnen gemengd.
475
- const codeCfg = d?.packingConfiguration ?? null;
476
- const packing = {
477
- pieces_per_package: piecesPerPackage,
478
- packages_per_layer: packagesPerLayer,
479
- layers_per_load_carrier: layersPerLoadCarrier,
480
- vbn_package_code: codeCfg?.package?.vbnPackageCode ?? null,
481
- custom_package_id: codeCfg?.package?.customPackageId ?? null,
482
- load_carrier: codeCfg?.loadCarrier ?? null,
483
- source: packingSource,
484
- };
485
- return {
486
- foId,
487
- d,
488
- orgId,
489
- custId: cust?.id ?? null,
490
- customerName,
491
- delivery,
492
- deliveryIso,
493
- orderDateIso,
494
- orderDateMs: Date.parse(orderDateIso) || 0,
495
- sequenceNumber: Number(d?.sequenceNumber ?? 0),
496
- pickupLocation,
497
- deliveryLocation,
498
- numberOfPieces,
499
- tradeItemId,
500
- productId,
501
- productName,
502
- plants_per_crate,
503
- crates_per_layer,
504
- layers_per_cart,
505
- unitPrice: Number(d?.pricePerPiece?.value ?? 0),
506
- totalPrice,
507
- status,
508
- ff,
509
- fullyFulfilled,
510
- packing,
511
- snapshot,
512
- };
513
- }
514
- const allLines = rows.map(buildLine);
515
- // Floriday levert per artikel een aparte verkooporder; er is geen groeps-id
516
- // in de payload (salesOrderGroupId/customerOrderId zijn leeg). Regels van
517
- // dezelfde bestelling herkennen we daarom aan: zelfde klant, zelfde
518
- // aflevermoment, zelfde afleverlocatie, zelfde uitleverlocatie én vlak na
519
- // elkaar geplaatst.
520
- // GEEN tijdvenster meer: samenvoegen op klant/levermoment/minuut voegde
521
- // echt verschillende bestellingen samen en wiste hun regels. Alleen een
522
- // echt Floriday-groepsnummer mag regels bundelen; zonder dat nummer is elke
523
- // Floriday-verkooporder een eigen order.
524
- // Alleen salesOrderGroupId is een echt Floriday-groepsnummer.
525
- // customerOrderId is de vrije-tekst bestelreferentie van de koper (bijv. een
526
- // PO-nummer) en mag NOOIT bundelen: dezelfde tekst op ongerelateerde orders
527
- // zou ze anders onterecht samenvoegen.
528
- const realGroupIdOf = (line) => pickString(line.d?.salesOrderGroupId) || null;
529
- const byKey = new Map();
530
- for (const line of allLines) {
531
- const gid = realGroupIdOf(line);
532
- const key = gid ? `g|${line.orgId}|${gid}` : `s|${line.foId}`;
533
- const arr = byKey.get(key);
534
- if (arr)
535
- arr.push(line);
536
- else
537
- byKey.set(key, [line]);
538
- }
539
- const groups = [];
540
- for (const arr of byKey.values()) {
541
- arr.sort((a, b) => a.orderDateMs - b.orderDateMs || a.sequenceNumber - b.sequenceNumber);
542
- groups.push(arr);
543
- }
544
- /** Een bestaande order mag niet opgeruimd worden als hij al onderweg is. */
545
- const isFrozen = (o) => {
546
- const st = String(o?.status ?? "").toLowerCase();
547
- return Boolean(o?.plan_locked_at) || st === "verzonden" || st === "shipped";
548
- };
549
- // Regels waarvan de bestaande order bevroren is, blijven losse orders.
550
- const finalGroups = [];
551
- for (const group of groups) {
552
- if (group.length === 1) {
553
- finalGroups.push(group);
554
- continue;
555
- }
556
- const frozen = [];
557
- const free = [];
558
- for (const line of group) {
559
- const ex = existingByFoId.get(line.foId);
560
- if (ex && isFrozen(ex))
561
- frozen.push(line);
562
- else
563
- free.push(line);
564
- }
565
- for (const line of frozen)
566
- finalGroups.push([line]);
567
- if (free.length > 0)
568
- finalGroups.push(free);
569
- }
570
- // Vaste bestelsleutel per groep. Hij is deterministisch: dezelfde klant,
571
- // hetzelfde aflevermoment, dezelfde aflever-/uitleverlocatie en het vroegste
572
- // besteltijdstip (op de minuut) leveren altijd dezelfde sleutel op. Daardoor
573
- // vindt een volgende spiegelronde exact dezelfde lokale order terug en valt
574
- // een samengevoegde bestelling nooit opnieuw uiteen.
575
- const groupKeyFor = (group) => {
576
- const first = group[0];
577
- const gid = realGroupIdOf(first);
578
- return gid ? ["fo", "g", first.orgId, gid].join("|") : ["fo", first.foId].join("|");
579
- };
580
- const keyedGroups = finalGroups.map((group) => ({ group, key: groupKeyFor(group) }));
581
- // Bestaande orders die al aan een van deze bestelsleutels hangen. Zo vinden
582
- // we ook de order terug waarvan de primaire Floriday-regel is gewijzigd.
583
- const existingByGroupKey = new Map();
584
- const allKeys = Array.from(new Set(keyedGroups.map((g) => g.key)));
585
- if (allKeys.length > 0) {
586
- const { data: keyRows } = await supabaseAdmin
587
- .from("orders")
588
- .select("id, order_number, floriday_sales_order_id, floriday_order_group_key, updated_at, custom_fields, status, plan_locked_at, buffer_id, customer_id, customer_name, delivery_date, order_date, total, order_source, deleted_at")
589
- .in("floriday_order_group_key", allKeys)
590
- .is("deleted_at", null);
591
- for (const o of keyRows ?? []) {
592
- const k = String(o.floriday_order_group_key ?? "");
593
- if (!k)
594
- continue;
595
- const prev = existingByGroupKey.get(k);
596
- // Laagste ordernummer wint; die order blijft bestaan bij samenvoegen.
597
- if (!prev ||
598
- String(o.order_number ?? "") < String(prev.order_number ?? "")) {
599
- existingByGroupKey.set(k, o);
600
- }
601
- }
602
- }
603
- // Bestaande orders op de Engine-sleutel (zonder minuut), alleen als de
604
- // Engine samenvoegt. Laagste ordernummer wint, net als in de Engine.
605
- const existingByMergeKey = new Map();
606
- if (engineMergeEnabled && keyedGroups.length > 0) {
607
- const dates = Array.from(new Set(keyedGroups
608
- .map((g) => g.group[0]?.deliveryIso?.slice(0, 10))
609
- .filter((d) => Boolean(d))));
610
- if (dates.length > 0) {
611
- const { data: mkRows, error: mkErr } = await supabaseAdmin
612
- .from("orders")
613
- .select(ORDER_COLS)
614
- .eq("order_source", "floriday")
615
- .in("delivery_date", dates)
616
- .not("floriday_order_group_key", "is", null)
617
- .is("deleted_at", null);
618
- if (mkErr)
619
- throw new Error(`orders op Engine-sleutel lezen: ${mkErr.message}`);
620
- for (const o of mkRows ?? []) {
621
- const mk = mergeKeyOf(o.floriday_order_group_key);
622
- if (!mk)
623
- continue;
624
- const prev = existingByMergeKey.get(mk);
625
- if (!prev || String(o.order_number ?? "") < String(prev.order_number ?? "")) {
626
- existingByMergeKey.set(mk, o);
627
- }
628
- }
629
- }
630
- }
631
- // Regels in quarantaine zetten (nooit wissen) + logregel + order markeren.
632
- const quarantineLines = async (args) => {
633
- let q = supabaseAdmin.from("order_items")
634
- .select("id, product_id, product_name, quantity, source_line_key")
635
- .eq("order_id", args.orderId)
636
- .is("quarantined_at", null);
637
- if (args.keys)
638
- q = q.in("source_line_key", args.keys);
639
- const { data: rows, error: rErr } = await q;
640
- if (rErr)
641
- throw new Error(`regels voor quarantaine lezen: ${rErr.message}`);
642
- const ids = (rows ?? []).map((r) => r.id);
643
- const now = new Date().toISOString();
644
- if (ids.length > 0) {
645
- const { error: qErr } = await supabaseAdmin.from("order_items")
646
- .update({
647
- quarantined_at: now,
648
- quarantine_reason: args.reason,
649
- quarantined_into_order_id: args.intoOrderId,
650
- })
651
- .in("id", ids);
652
- if (qErr)
653
- throw new Error(`regels in quarantaine zetten: ${qErr.message}`);
654
- }
655
- const { error: lErr } = await supabaseAdmin.from("floriday_merge_log").insert({
656
- action: args.action,
657
- kept_order_id: args.intoOrderId,
658
- removed_order_id: args.orderId,
659
- floriday_sales_order_ids: args.foIds,
660
- lines: rows ?? [],
661
- reason: args.reason,
662
- });
663
- if (lErr)
664
- throw new Error(`samenvoeglog schrijven: ${lErr.message}`);
665
- if (ids.length > 0) {
666
- const { data: o } = await supabaseAdmin
667
- .from("orders")
668
- .select("custom_fields")
669
- .eq("id", args.orderId)
670
- .maybeSingle();
671
- const cf = (o?.custom_fields ?? {});
672
- await supabaseAdmin.from("orders")
673
- .update({
674
- custom_fields: {
675
- ...cf,
676
- needs_manual_review: true,
677
- manual_review_reason: `${ids.length} orderregel(s) in quarantaine: ${args.reason}`,
678
- },
679
- })
680
- .eq("id", args.orderId);
681
- }
682
- };
683
- // Terugkerend falen per Floriday-bestelling, om zichtbaar te markeren.
684
- const failuresByFoId = new Map();
685
- // Ordervelden-invoer per Floriday-bestelling (uit deze ronde of de cache).
686
- const lineInfoOf = (l) => ({
687
- foId: l.foId,
688
- orderDate: l.orderDateIso || null,
689
- deliveryDate: l.deliveryIso ? l.deliveryIso.slice(0, 10) : null,
690
- status: l.d?.status ?? null,
691
- orgId: l.orgId || "",
692
- deleted: Boolean(l.isDeleted),
693
- });
694
- const lineInfoFromCache = (c) => {
695
- const d = c?.data ?? {};
696
- const del = d?.delivery?.latestDeliveryDateTime ?? "";
697
- return {
698
- foId: String(c.floriday_id),
699
- orderDate: d?.orderDateTime ?? d?.creationDateTime ?? null,
700
- deliveryDate: del ? String(del).slice(0, 10) : null,
701
- status: d?.status ?? c?.status ?? null,
702
- orgId: buyerOrgIdOf(c),
703
- deleted: Boolean(c?.is_deleted),
704
- };
705
- };
706
- const lineInfoByFoId = new Map();
707
- for (const l of allLines)
708
- lineInfoByFoId.set(l.foId, lineInfoOf(l));
709
- // Orders die in deze ronde al door een andere bestelling zijn geschreven.
710
- const handledOrderIds = new Set();
711
- const legacyExternalIds = new Set();
712
- // Welke velden per order echt veranderden (voor melding en syncresultaat).
713
- const changedFieldsByOrder = new Map();
714
- const noteChange = (orderId, field) => {
715
- const s = changedFieldsByOrder.get(orderId) ?? new Set();
716
- s.add(field);
717
- changedFieldsByOrder.set(orderId, s);
718
- };
719
- for (const { group, key: groupKey } of keyedGroups) {
720
- const primary = group[0];
721
- const memberIds = group.map((l) => l.foId);
722
- const groupLvl = deriveOrderLevel(group.map(lineInfoOf));
723
- const anyFulfilled = group.some((l) => l.fullyFulfilled);
724
- const ffPrimary = primary.ff;
725
- const totalPrice = group.reduce((s, l) => s + (Number(l.totalPrice) || 0), 0);
726
- // Eén bron voor de belading: de regels. `floriday_packing` is niet langer
727
- // een tweede, apart berekende kopie maar exact de belading van de primaire
728
- // regel uit `floriday_lines`.
729
- const floridayLines = group.map((l) => ({
730
- sales_order_id: l.foId,
731
- trade_item_id: l.tradeItemId || null,
732
- pieces: l.numberOfPieces,
733
- packing: l.packing,
734
- }));
735
- const primaryLine = floridayLines.find((l) => l.sales_order_id === primary.foId) ?? floridayLines[0];
736
- const custom_fields = {
737
- source: "floriday",
738
- pickup_location: primary.pickupLocation,
739
- delivery_location: primary.deliveryLocation,
740
- delivery_location_gln: primary.delivery?.location?.gln ?? null,
741
- region_gln: primary.delivery?.regionGln ?? null,
742
- floriday_sales_order_id: primary.foId,
743
- // Koper-organisatie; gelezen door de Engine ("Zelfde Floriday klant").
744
- floriday_customer_id: primary.orgId || null,
745
- // Alle Floriday-verkooporders die samen deze ene order vormen.
746
- floriday_sales_order_ids: memberIds,
747
- floriday_line_count: group.length,
748
- floriday_status: primary.d?.status ?? null,
749
- floriday_trade_item_id: primary.tradeItemId || null,
750
- floriday_fulfilled: anyFulfilled,
751
- // Afgehandeld in Floriday = er is een afhandeling die niet door het ERP
752
- // is gemaakt; het aantal fust doet er niet toe (koppelprompt 1.0.96).
753
- floriday_fulfilled_externally: group.some((l) => Boolean(l.ff?.external)),
754
- floriday_fulfilled_by_erp: anyFulfilled && Boolean(ffPrimary?.createdByErp),
755
- floriday_delivery_notes: ffPrimary?.deliveryNoteCodes ?? [],
756
- floriday_received_at: ffPrimary?.receivedAt ?? null,
757
- floriday_packing: primaryLine.packing,
758
- floriday_lines: floridayLines,
759
- };
760
- try {
761
- // Bestaande order kiezen. Volgorde: de order die al aan deze
762
- // bestelsleutel hangt (dat is de bestelling zelf), dan die van de
763
- // primaire regel, dan de eerste vrije order van een andere regel.
764
- let target = existingByGroupKey.get(groupKey) ?? null;
765
- if (target && isFrozen(target))
766
- target = null;
767
- if (!target) {
768
- const byPrimary = existingByFoId.get(primary.foId) ?? null;
769
- if (byPrimary && !isFrozen(byPrimary))
770
- target = byPrimary;
771
- }
772
- if (!target) {
773
- for (const l of group) {
774
- const ex = existingByFoId.get(l.foId);
775
- if (ex && !isFrozen(ex)) {
776
- target = ex;
777
- break;
778
- }
779
- }
780
- }
781
- // Door de Engine samengevoegd: de aangehouden order is het doel. Ook een
782
- // order die de regels van deze bestelling al draagt, of die op de
783
- // Engine-sleutel (zonder minuut) hangt.
784
- const mergeCandidates = [];
785
- for (const l of group) {
786
- const m = mergedTargetByFoId.get(l.foId);
787
- if (m)
788
- mergeCandidates.push(m);
789
- }
790
- for (const l of group) {
791
- const ow = lineOwnerByFoId.get(l.foId);
792
- if (ow)
793
- mergeCandidates.push(ow);
794
- }
795
- const mk = engineMergeEnabled ? mergeKeyOf(groupKey) : null;
796
- void mk; // Engine-sleutel wordt niet meer gebruikt om een doel te kiezen.
797
- if (!target) {
798
- target = mergeCandidates.find((c) => c && !isFrozen(c)) ?? null;
799
- }
800
- // Hangt het doel aan een andere bestelsleutel, dan is het een order die
801
- // de Engine heeft samengesteld: we vullen hem aan, nooit overschrijven.
802
- // Ook als een andere bestelling deze order in dezelfde ronde al heeft
803
- // geschreven: dan alleen aanvullen, de identiteit niet overschrijven.
804
- const viaMerge = Boolean(target &&
805
- ((String(target.floriday_sales_order_id ?? "") !== primary.foId &&
806
- String(target.floriday_order_group_key ?? "") !== groupKey) ||
807
- (handledOrderIds.has(String(target.id)) &&
808
- String(target.floriday_order_group_key ?? "") !== groupKey)));
809
- // Vergrendelde/verzonden order: een nieuwe insert zou elke ronde opnieuw
810
- // stukslaan op orders_floriday_sales_order_id_uidx. Dat herkennen we
811
- // expliciet: de order wordt zichtbaar gemarkeerd voor handmatige
812
- // beoordeling en deze ronde wordt overgeslagen.
813
- if (!target) {
814
- const frozenCandidates = new Map();
815
- for (const l of group) {
816
- const ex = existingByFoId.get(l.foId);
817
- if (ex && isFrozen(ex))
818
- frozenCandidates.set(String(ex.id), ex);
819
- }
820
- const byKey = existingByGroupKey.get(groupKey);
821
- if (byKey && isFrozen(byKey))
822
- frozenCandidates.set(String(byKey.id), byKey);
823
- for (const c of mergeCandidates) {
824
- if (c && isFrozen(c))
825
- frozenCandidates.set(String(c.id), c);
826
- }
827
- if (frozenCandidates.size > 0) {
828
- // Alleen echte koperwijzigingen (artikel, aantal, leverdatum,
829
- // bestelling erbij/weg). Status, belading en Floriday-echo niet.
830
- const signature = JSON.stringify({
831
- lines: floridayLines.map((l) => ({
832
- id: l.sales_order_id,
833
- t: l.trade_item_id,
834
- p: l.pieces,
835
- })),
836
- d: groupLvl.deliveryDate ?? null,
837
- });
838
- for (const fo of frozenCandidates.values()) {
839
- const cf = (fo.custom_fields ?? {});
840
- const changes = diffBuyerChanges(cf.floriday_lines, floridayLines, fo.delivery_date, groupLvl.deliveryDate);
841
- if (changes.length === 0)
842
- continue; // niets door de koper gewijzigd
843
- if (cf.floriday_change_signature === signature)
844
- continue; // al gemeld
845
- const { error: revErr } = await supabaseAdmin.from("orders")
846
- .update({
847
- custom_fields: {
848
- ...cf,
849
- floriday_change_after_completion: true,
850
- floriday_change_detected_at: new Date().toISOString(),
851
- floriday_change_signature: signature,
852
- needs_manual_review: true,
853
- floriday_change_summary: changes,
854
- manual_review_reason: `Wijziging door de koper na afronding: ${changes.join("; ")} — handmatige beoordeling nodig`,
855
- },
856
- updated_at: new Date().toISOString(),
857
- })
858
- .eq("id", fo.id);
859
- if (revErr) {
860
- console.warn(`[floriday-mirror] beoordelingsmarkering zetten faalde voor ${fo.id}: ${revErr.message}`);
861
- }
862
- }
863
- skipped += group.length;
864
- // Afgeronde order: deze ronde overslaan; alleen melden bij echte wijziging.
865
- if (![...frozenCandidates.values()].some((fo) => diffBuyerChanges((fo.custom_fields ?? {}).floriday_lines, floridayLines, fo.delivery_date, groupLvl.deliveryDate).length > 0))
866
- continue;
867
- errors.push(`${primary.foId}: wijziging na afronding — order gemarkeerd voor handmatige beoordeling`);
868
- continue;
869
- }
870
- }
871
- // Ordernummer: een bestaande order houdt zijn nummer, anders het nummer
872
- // uit floriday_order_number_map van de primaire regel.
873
- const orderNumber = (target ? String(target.order_number ?? "").trim() : "") ||
874
- orderNumberByFoId.get(primary.foId) ||
875
- null;
876
- if (!orderNumber) {
877
- skipped += group.length;
878
- errors.push(`${primary.foId}: geen ordernummer in floriday_order_number_map`);
879
- continue;
880
- }
881
- // Dubbele orders van dezelfde bestelling opruimen: alles wat via een
882
- // regel of via dezelfde bestelsleutel bestaat en niet het doel is.
883
- const obsolete = [
884
- ...group.map((l) => existingByFoId.get(l.foId)),
885
- existingByGroupKey.get(groupKey),
886
- ].filter((o) => o && (!target || o.id !== target.id) && !isFrozen(o));
887
- const obsoleteIds = Array.from(new Set(obsolete.map((o) => String(o.id))));
888
- if (obsoleteIds.length > 0) {
889
- // Per order verwijderen en de fout expliciet controleren: een stil
890
- // mislukte verwijdering was de oorzaak van duizenden dubbele regels.
891
- // Nooit meer definitief wissen: regels gaan in quarantaine en elke
892
- // actie wordt vastgelegd, zodat een mens kan nakijken en herstellen.
893
- for (const oid of obsoleteIds) {
894
- await quarantineLines({
895
- orderId: oid,
896
- keys: null,
897
- intoOrderId: target ? String(target.id) : null,
898
- action: "merge",
899
- reason: `Order opgeruimd als dubbel van Floriday-bestelling ${primary.foId}`,
900
- foIds: memberIds,
901
- });
902
- }
903
- const { error: obsErr } = await supabaseAdmin.from("orders")
904
- .update({ deleted_at: new Date().toISOString(), buffer_id: null })
905
- .in("id", obsoleteIds);
906
- if (obsErr)
907
- throw new Error(obsErr.message);
908
- }
909
- let orderId;
910
- let staleCandidateKeys = [];
911
- if (target) {
912
- // Tweerichtingssynchronisatie: de status wordt verderop bepaald uit
913
- // alle bestellingen op de order samen (deriveOrderLevel).
914
- // Custom fields: lijsten van alle Floriday-bestellingen in deze order
915
- // samenvoegen, nooit overschrijven — de order kan door de Engine uit
916
- // meerdere bestellingen zijn samengesteld.
917
- const prevCf = { ...(target.custom_fields ?? {}) };
918
- // Bestaande orders die vóór 1.0.96 al als "buiten het ERP afgehandeld"
919
- // stonden, worden niet vanzelf omgezet (eerst akkoord gebruiker).
920
- if (prevCf.floriday_fulfilled_externally === true && !prevCf.floriday_external_fulfilled_sales_order_ids && !prevCf.floriday_external_fulfilled_at) {
921
- legacyExternalIds.add(String(target.id));
922
- }
923
- // Oudere orders kennen floriday_groups nog niet: hun eigen bestelling
924
- // als eerste groep overnemen, zodat die lijst niet verloren gaat.
925
- const prevGroups = (prevCf.floriday_groups ??
926
- (prevCf.floriday_sales_order_id && Array.isArray(prevCf.floriday_sales_order_ids)
927
- ? {
928
- [String(prevCf.floriday_sales_order_id)]: prevCf.floriday_sales_order_ids.map(String),
929
- }
930
- : {}));
931
- const groupsMap = { ...prevGroups, [primary.foId]: memberIds };
932
- const allIds = Array.from(new Set(Object.values(groupsMap).flat()));
933
- const otherLines = (prevCf.floriday_lines ?? []).filter((l) => allIds.includes(String(l?.sales_order_id)) &&
934
- !memberIds.includes(String(l?.sales_order_id)));
935
- const failures = { ...(prevCf.mirror_failures ?? {}) };
936
- delete failures[primary.foId];
937
- const mergedCf = viaMerge
938
- ? { ...prevCf }
939
- : { ...prevCf, ...custom_fields };
940
- mergedCf.floriday_groups = groupsMap;
941
- if (!mergedCf.floriday_customer_id && primary.orgId) {
942
- mergedCf.floriday_customer_id = primary.orgId;
943
- }
944
- // Vaste volgorde: anders verschilt de lijst per verwerkingsvolgorde van
945
- // de groepen en zou de order elke ronde als "gewijzigd" worden gezien
946
- // (en telkens opnieuw gepland).
947
- const groupSorted = {};
948
- for (const k of Object.keys(groupsMap).sort())
949
- groupSorted[k] = groupsMap[k];
950
- mergedCf.floriday_groups = groupSorted;
951
- mergedCf.floriday_sales_order_ids = [...allIds].sort();
952
- mergedCf.floriday_lines = [...otherLines, ...floridayLines].sort((a, b) => String(a?.sales_order_id).localeCompare(String(b?.sales_order_id)));
953
- mergedCf.floriday_line_count = mergedCf.floriday_lines.length;
954
- // Regels zonder geldige Floriday-salesOrderId worden niet overgenomen,
955
- // maar nooit stil: zichtbare melding op de order + foutregel.
956
- {
957
- const { invalid } = splitByLineKey(group);
958
- if (invalid.length > 0) {
959
- mergedCf.floriday_missing_line_key_notice = MISSING_LINE_KEY_NOTICE;
960
- mergedCf.floriday_missing_line_key_count = invalid.length;
961
- errors.push(`${primary.foId}: ${invalid.length} regel(s) zonder geldig Floriday-bestelnummer niet overgenomen`);
962
- }
963
- else {
964
- delete mergedCf.floriday_missing_line_key_notice;
965
- delete mergedCf.floriday_missing_line_key_count;
966
- }
967
- }
968
- if (Object.keys(failures).length > 0)
969
- mergedCf.mirror_failures = failures;
970
- else {
971
- delete mergedCf.mirror_failures;
972
- if (mergedCf.manual_review_source === "mirror_failure") {
973
- delete mergedCf.needs_manual_review;
974
- delete mergedCf.manual_review_reason;
975
- delete mergedCf.manual_review_source;
976
- }
977
- }
978
- // Vaste regels voor de ordervelden, over ALLE bestellingen op deze
979
- // order samen (zie floriday-order-level.ts). Zo krijgt elke bestelling
980
- // in de ronde dezelfde uitkomst en schrijven ze elkaar niet over.
981
- const lineInfos = [];
982
- const missing = [];
983
- for (const id of mergedCf.floriday_sales_order_ids) {
984
- const info = lineInfoByFoId.get(id);
985
- if (info)
986
- lineInfos.push(info);
987
- else
988
- missing.push(id);
989
- }
990
- if (missing.length > 0) {
991
- const { data: mRows, error: mErr } = await supabaseAdmin
992
- .from("floriday_salesorders_cache")
993
- .select("floriday_id, data, status, is_deleted, buyer_organization_id")
994
- .in("floriday_id", missing);
995
- if (mErr)
996
- throw new Error(`cache lezen voor ordervelden: ${mErr.message}`);
997
- for (const c of (mRows ?? [])) {
998
- const info = lineInfoFromCache(c);
999
- lineInfoByFoId.set(info.foId, info);
1000
- lineInfos.push(info);
1001
- }
1002
- }
1003
- const lvl = deriveOrderLevel(lineInfos.length ? lineInfos : [lineInfoByFoId.get(primary.foId)]);
1004
- mergedCf.floriday_status = lvl.floridayStatusSummary;
1005
- if (lvl.mixedDeliveryDates)
1006
- mergedCf.floriday_mixed_delivery_dates = true;
1007
- else
1008
- delete mergedCf.floriday_mixed_delivery_dates;
1009
- if (lvl.multiBuyer) {
1010
- mergedCf.needs_manual_review = true;
1011
- mergedCf.manual_review_source = "multi_buyer";
1012
- mergedCf.manual_review_reason = "Bestellingen van verschillende kopers op één order";
1013
- }
1014
- else if (mergedCf.manual_review_source === "multi_buyer") {
1015
- delete mergedCf.needs_manual_review;
1016
- delete mergedCf.manual_review_reason;
1017
- delete mergedCf.manual_review_source;
1018
- }
1019
- // Status alleen overnemen als de Floriday-kant echt veranderde.
1020
- const prevFloridayStatus = prevCf.floriday_status ?? null;
1021
- const floridayStatusChanged = String(lvl.floridayStatusSummary ?? "") !== String(prevFloridayStatus ?? "");
1022
- const localStatus = String(target?.status ?? "");
1023
- // Annulering uit Floriday: niet zelf de status zetten, maar na de ronde
1024
- // via handleFloridayCancellation (pickstand bij de Engine controleren).
1025
- const isFloridayCancel = lvl.status === "geannuleerd" && localStatus.toLowerCase() !== "geannuleerd";
1026
- if (floridayStatusChanged && isFloridayCancel)
1027
- floridayCancelIds.push(String(target.id));
1028
- const statusPatch = floridayStatusChanged && lvl.status !== localStatus && !isFloridayCancel
1029
- ? { status: lvl.status, status_sync_token: globalThis.crypto.randomUUID() }
1030
- : {};
1031
- // Alleen regels die eerder bij déze bestelling hoorden mogen als
1032
- // verouderd worden gewist; regels van andere (door de Engine
1033
- // samengevoegde) bestellingen blijven altijd staan.
1034
- const prevOwn = prevGroups[primary.foId];
1035
- if (Array.isArray(prevOwn)) {
1036
- staleCandidateKeys = prevOwn.map(String);
1037
- }
1038
- else if (!viaMerge && !mergedKeptIds.has(String(target.id))) {
1039
- staleCandidateKeys = (prevCf.floriday_sales_order_ids ?? []).map(String);
1040
- }
1041
- const patch = viaMerge
1042
- ? {
1043
- // Aangehouden order van de Engine: identiteit (nummer, sleutel,
1044
- // primair Floriday-nummer, besteldatum, status) blijft van hem.
1045
- custom_fields: mergedCf,
1046
- deleted_at: null,
1047
- }
1048
- : {
1049
- order_number: orderNumber,
1050
- // Verschillende kopers op één order: nooit gokken welke klant.
1051
- ...(lvl.multiBuyer
1052
- ? {}
1053
- : target?.customer_id
1054
- ? {} // bestaande klant nooit overschrijven
1055
- : {
1056
- customer_id: keepOrSetCustomer(null, primary.custId),
1057
- customer_name: primary.customerName,
1058
- }),
1059
- delivery_date: lvl.deliveryDate,
1060
- order_date: lvl.orderDate ?? primary.orderDateIso,
1061
- ...statusPatch,
1062
- // Bevat de order ook andere bestellingen, dan rekent de Engine
1063
- // het totaal; alleen dit deel meetellen zou het verkeerd maken.
1064
- ...(Object.keys(groupsMap).length > 1 ? {} : { total: String(totalPrice) }),
1065
- custom_fields: mergedCf,
1066
- order_source: "floriday",
1067
- // Houdt een (door de Engine samengevoegde, verwijderde) rij dit
1068
- // Floriday-nummer nog vast, dan behoudt het doel zijn eigen nummer;
1069
- // anders botst het op orders_floriday_sales_order_id_uidx.
1070
- floriday_sales_order_id: deletedByFoId.has(primary.foId)
1071
- ? (target.floriday_sales_order_id ?? null)
1072
- : primary.foId,
1073
- floriday_order_group_key: groupKey,
1074
- deleted_at: null,
1075
- };
1076
- // KRITIEK: een schrijfactie op `orders` laat de logistieke triggers de
1077
- // hele karindeling weggooien en opnieuw plannen. Elke spiegelronde
1078
- // dezelfde waarden terugschrijven betekende dus: elke ronde de karren
1079
- // van iedere Floriday-order wissen. Daarom schrijven we alleen als er
1080
- // echt iets is veranderd.
1081
- const changedKeys = Object.keys(patch).filter((k) => {
1082
- if (k === "status_sync_token")
1083
- return false;
1084
- const next = patch[k];
1085
- const prev = target[k];
1086
- if (k === "custom_fields")
1087
- return !sameJson(prev, next);
1088
- if (k === "deleted_at")
1089
- return prev != null;
1090
- if (k === "total")
1091
- return Number(prev ?? 0) !== Number(next ?? 0);
1092
- if (k === "order_date" || k === "delivery_date")
1093
- return !sameDate(prev, next);
1094
- return String(prev ?? "") !== String(next ?? "");
1095
- });
1096
- orderId = target.id;
1097
- handledOrderIds.add(orderId);
1098
- if (changedKeys.length > 0) {
1099
- // Alleen gewijzigde velden, en ook in de database "alleen als anders"
1100
- // (IS DISTINCT FROM): een gelijktijdige ronde schrijft dan niets.
1101
- const { distinctFilter } = await import("./order-patch.js");
1102
- const diff = {};
1103
- for (const k of changedKeys)
1104
- diff[k] = patch[k];
1105
- const { error: uErr } = await supabaseAdmin.from("orders")
1106
- .update(diff)
1107
- .eq("id", orderId)
1108
- .or(distinctFilter(diff));
1109
- if (uErr)
1110
- throw new Error(uErr.message);
1111
- updated++;
1112
- changedOrderIds.push(orderId);
1113
- for (const k of changedKeys)
1114
- noteChange(orderId, k);
1115
- // Volgende bestelling in dezelfde ronde ziet de net geschreven waarden.
1116
- Object.assign(target, patch);
1117
- }
1118
- else {
1119
- unchanged++;
1120
- }
1121
- }
1122
- else {
1123
- const { data: ins, error: iErr } = await supabaseAdmin.from("orders")
1124
- .insert({
1125
- order_number: orderNumber,
1126
- customer_name: primary.customerName,
1127
- customer_id: primary.custId,
1128
- order_date: groupLvl.orderDate ?? primary.orderDateIso,
1129
- delivery_date: groupLvl.deliveryDate,
1130
- status: groupLvl.status,
1131
- total: String(totalPrice),
1132
- custom_fields: {
1133
- ...custom_fields,
1134
- floriday_status: groupLvl.floridayStatusSummary,
1135
- ...(groupLvl.mixedDeliveryDates ? { floriday_mixed_delivery_dates: true } : {}),
1136
- floriday_groups: { [primary.foId]: memberIds },
1137
- },
1138
- order_source: "floriday",
1139
- floriday_sales_order_id: primary.foId,
1140
- floriday_order_group_key: groupKey,
1141
- status_sync_token: globalThis.crypto.randomUUID(),
1142
- })
1143
- .select("id")
1144
- .single();
1145
- if (iErr)
1146
- throw new Error(iErr.message);
1147
- orderId = ins.id;
1148
- inserted++;
1149
- changedOrderIds.push(orderId);
1150
- noteChange(orderId, "nieuw");
1151
- handledOrderIds.add(orderId);
1152
- }
1153
- // Handmatig vastgezette belading beschermen. Een orderregel met
1154
- // packing_locked_at is bewust door een medewerker gecorrigeerd en mag
1155
- // door deze automatische ronde nooit worden herberekend of overschreven.
1156
- // De correctie blijft strikt lokaal: ze wordt nooit teruggeschreven naar
1157
- // het Floriday-artikel — dat loopt uitsluitend via de voorraad-module.
1158
- const lockedByKey = new Map();
1159
- const existingLineByKey = new Map();
1160
- {
1161
- const { data: itemRows, error: lockErr } = await supabaseAdmin.from("order_items")
1162
- .select("source_line_key, product_id, product_name, quantity, unit, unit_price, plants_per_crate, crates_per_layer, layers_per_cart, vbn_package_code, load_carrier_type, packing_source, packing_locked_at")
1163
- .eq("order_id", orderId);
1164
- if (lockErr)
1165
- throw new Error(`bestaande orderregels lezen: ${lockErr.message}`);
1166
- for (const r of (itemRows ?? [])) {
1167
- const k = String(r.source_line_key ?? "");
1168
- if (!k)
1169
- continue;
1170
- existingLineByKey.set(k, r);
1171
- if (r.packing_locked_at)
1172
- lockedByKey.set(k, r);
1173
- }
1174
- }
1175
- // Eén orderregel per Floriday-verkooporder in deze groep. Bijwerken op
1176
- // een vaste herkomstsleutel (source_line_key = Floriday sales order id),
1177
- // nooit meer wissen-en-opnieuw-toevoegen: dat veroorzaakte duplicaten
1178
- // zodra de verwijdering op een timeout stuk liep.
1179
- // Alleen regels met een geldige Floriday-salesOrderId (uuid) als sleutel.
1180
- //
1181
- // Verpakking-snapshot: een nieuwe regel krijgt de verpakking van de
1182
- // sales order; een bestaande regel houdt zijn verpakking. Alleen een
1183
- // leeg veld wordt aangevuld met een echte waarde (bijv. klokorder
1184
- // waarvan de Engine/Floriday later lagen meldt). Nooit overschrijven.
1185
- const lineRows = splitByLineKey(group).valid.map((l) => {
1186
- const locked = lockedByKey.get(l.foId);
1187
- const prev = existingLineByKey.get(l.foId);
1188
- // Regels van vóór 1.0.105 (geen packing_source) blijven helemaal
1189
- // ongemoeid: bestaande regels worden niet achteraf aangevuld.
1190
- const snap = !prev
1191
- ? l.snapshot
1192
- : prev.packing_source === "floriday_order"
1193
- ? fillOnlyEmpty(prev, l.snapshot)
1194
- : {
1195
- plants_per_crate: pos(prev.plants_per_crate),
1196
- crates_per_layer: pos(prev.crates_per_layer),
1197
- layers_per_cart: pos(prev.layers_per_cart),
1198
- vbn_package_code: prev.vbn_package_code ?? null,
1199
- load_carrier_type: prev.load_carrier_type ?? null,
1200
- packing_source: prev.packing_source ?? null,
1201
- };
1202
- return {
1203
- order_id: orderId,
1204
- source_line_key: l.foId,
1205
- // Geen product via het trade-item-id gevonden? Dan een al ingevuld
1206
- // product op de regel laten staan, nooit overschrijven met "geen
1207
- // product" (anders schrijft elke ronde opnieuw en plant de Engine
1208
- // telkens opnieuw in).
1209
- product_id: l.productId ?? prev?.product_id ?? null,
1210
- product_name: l.productName,
1211
- quantity: Math.max(0, l.numberOfPieces),
1212
- unit: "stuks",
1213
- unit_price: l.unitPrice,
1214
- locked: Boolean(locked),
1215
- // Vastgezet? Dan telt de handmatige waarde.
1216
- plants_per_crate: locked ? pos(locked.plants_per_crate) : snap.plants_per_crate,
1217
- crates_per_layer: locked ? pos(locked.crates_per_layer) : snap.crates_per_layer,
1218
- layers_per_cart: locked ? pos(locked.layers_per_cart) : snap.layers_per_cart,
1219
- vbn_package_code: snap.vbn_package_code,
1220
- load_carrier_type: snap.load_carrier_type,
1221
- packing_source: snap.packing_source,
1222
- };
1223
- });
1224
- const LINE_CHUNK = 100;
1225
- // Ook hier geldt: een schrijfactie op een orderregel laat de logistieke
1226
- // triggers de karindeling weggooien. Regels die ongewijzigd zijn worden
1227
- // dus niet opnieuw geschreven.
1228
- const lineChanged = (r) => {
1229
- const prev = existingLineByKey.get(String(r.source_line_key));
1230
- if (!prev)
1231
- return true;
1232
- if (String(prev.product_id ?? "") !== String(r.product_id ?? ""))
1233
- return true;
1234
- if (String(prev.product_name ?? "") !== String(r.product_name ?? ""))
1235
- return true;
1236
- if (Number(prev.quantity ?? 0) !== Number(r.quantity ?? 0))
1237
- return true;
1238
- if (String(prev.unit ?? "") !== String(r.unit ?? ""))
1239
- return true;
1240
- if (Number(prev.unit_price ?? 0) !== Number(r.unit_price ?? 0))
1241
- return true;
1242
- if (String(prev.vbn_package_code ?? "") !== String(r.vbn_package_code ?? ""))
1243
- return true;
1244
- if (String(prev.load_carrier_type ?? "") !== String(r.load_carrier_type ?? ""))
1245
- return true;
1246
- if (String(prev.packing_source ?? "") !== String(r.packing_source ?? ""))
1247
- return true;
1248
- if (r.locked)
1249
- return false;
1250
- return (pos(prev.plants_per_crate) !== pos(r.plants_per_crate) ||
1251
- pos(prev.crates_per_layer) !== pos(r.crates_per_layer) ||
1252
- pos(prev.layers_per_cart) !== pos(r.layers_per_cart));
1253
- };
1254
- const writeRows = lineRows.filter(lineChanged);
1255
- if (writeRows.length > 0) {
1256
- changedOrderIds.push(orderId);
1257
- noteChange(orderId, writeRows.some((r) => !existingLineByKey.has(String(r.source_line_key)))
1258
- ? "orderregels (nieuw)"
1259
- : "orderregels");
1260
- }
1261
- // Twee vormen: vrije regels inclusief belading, vastgezette regels
1262
- // zónder de beladingskolommen (die worden dan niet meegeschreven).
1263
- const freeRows = writeRows
1264
- .filter((r) => !r.locked)
1265
- .map(({ locked: _l, ...rest }) => rest);
1266
- const lockedRowsOut = writeRows
1267
- .filter((r) => r.locked)
1268
- .map(({ locked: _l, plants_per_crate: _a, crates_per_layer: _b, layers_per_cart: _c, ...rest }) => rest);
1269
- for (const batchSource of [freeRows, lockedRowsOut]) {
1270
- for (let i = 0; i < batchSource.length; i += LINE_CHUNK) {
1271
- const { error: liErr } = await supabaseAdmin.from("order_items").upsert(batchSource.slice(i, i + LINE_CHUNK), { onConflict: "order_id,source_line_key" });
1272
- if (liErr)
1273
- throw new Error(`orderregels bijwerken: ${liErr.message}`);
1274
- }
1275
- }
1276
- // Regels die niet meer bij deze bestelling horen: alleen gericht wissen
1277
- // wat eerder bij déze bestelling hoorde. Regels van andere bestellingen
1278
- // (door de Engine samengevoegd) en handmatige regels blijven staan.
1279
- const keepKeys = new Set(lineRows.map((r) => r.source_line_key));
1280
- let staleKeys = staleCandidateKeys.filter((k) => k && !keepKeys.has(k));
1281
- if (staleKeys.length > 0) {
1282
- // Extra bescherming: regels van bestellingen die de Engine in deze
1283
- // order heeft samengevoegd, worden nooit als verouderd gewist.
1284
- const { data: mRows, error: mrErr } = await supabaseAdmin
1285
- .from("logistics_order_merges")
1286
- .select("merged_order_id")
1287
- .eq("kept_order_id", orderId);
1288
- if (mrErr)
1289
- throw new Error(`samenvoegingen lezen: ${mrErr.message}`);
1290
- const mergedIds = (mRows ?? []).map((r) => String(r.merged_order_id));
1291
- if (mergedIds.length > 0) {
1292
- const { data: mo, error: moErr } = await supabaseAdmin
1293
- .from("orders")
1294
- .select("floriday_sales_order_id, custom_fields")
1295
- .in("id", mergedIds);
1296
- if (moErr)
1297
- throw new Error(`samengevoegde orders lezen: ${moErr.message}`);
1298
- const protect = new Set();
1299
- for (const o of (mo ?? [])) {
1300
- if (o.floriday_sales_order_id)
1301
- protect.add(String(o.floriday_sales_order_id));
1302
- for (const id of (o.custom_fields?.floriday_sales_order_ids ?? [])) {
1303
- protect.add(String(id));
1304
- }
1305
- }
1306
- staleKeys = staleKeys.filter((k) => !protect.has(k));
1307
- }
1308
- }
1309
- if (staleKeys.length > 0) {
1310
- // Alleen markeren als de eigen Floriday-bestelling van de regel in de
1311
- // gedeelde cache echt verwijderd of geannuleerd is. Een regel die bij
1312
- // een andere, nog actieve bestelling hoort (bv. door het oude
1313
- // tijdvenster meegenomen), is niet verouderd en blijft actief.
1314
- const { data: cRows, error: cErr } = await supabaseAdmin
1315
- .from("floriday_salesorders_cache")
1316
- .select("floriday_id, status, is_deleted")
1317
- .in("floriday_id", staleKeys);
1318
- if (cErr)
1319
- throw new Error(`cache lezen voor opruimen: ${cErr.message}`);
1320
- const gone = new Set();
1321
- for (const c of (cRows ?? [])) {
1322
- const st = String(c.status ?? "").toUpperCase();
1323
- if (c.is_deleted || st === "CANCELLED" || st === "CANCELED" || st === "DELETED") {
1324
- gone.add(String(c.floriday_id));
1325
- }
1326
- }
1327
- staleKeys = staleKeys.filter((k) => gone.has(k));
1328
- }
1329
- if (staleKeys.length > 0) {
1330
- await quarantineLines({
1331
- orderId,
1332
- keys: staleKeys,
1333
- intoOrderId: null,
1334
- action: "quarantine",
1335
- reason: "Regel komt niet meer voor in de Floriday-bestelling",
1336
- foIds: memberIds,
1337
- });
1338
- }
1339
- // Geen eigen beladings-/ladingdragercontrole: alleen de Logistiek Engine
1340
- // beslist of een belading kan (koppelprompt 22).
1341
- // Buffer resolven en in de replan-queue zetten. Alleen orders die buiten
1342
- // ons ERP om in Floriday zijn afgehandeld hoeven niet meer gepland te
1343
- // worden.
1344
- const externallyHandled = anyFulfilled && !ffPrimary?.createdByErp;
1345
- if (!externallyHandled) {
1346
- await resolveBufferForOrderInternal(orderId);
1347
- affectedOrderIds.push(orderId);
1348
- }
1349
- }
1350
- catch (err) {
1351
- failed++;
1352
- const msg = err.message ?? "unknown";
1353
- errors.push(`${primary.foId}: ${msg.slice(0, 200)}`);
1354
- failuresByFoId.set(primary.foId, msg.slice(0, 300));
1355
- }
1356
- }
1357
- // Terugkerend falen zichtbaar maken. Na 3 rondes op rij krijgt de betrokken
1358
- // order "Handmatige beoordeling nodig". Daarna schrijven we niet elke ronde
1359
- // opnieuw (een schrijfactie laat de karindeling opnieuw plannen), alleen als
1360
- // de melding verandert.
1361
- const FAILURE_THRESHOLD = 3;
1362
- for (const [foId, msg] of failuresByFoId) {
1363
- const row = existingByFoId.get(foId) ??
1364
- mergedTargetByFoId.get(foId) ??
1365
- lineOwnerByFoId.get(foId) ??
1366
- deletedByFoId.get(foId) ??
1367
- null;
1368
- if (!row)
1369
- continue;
1370
- const cf = { ...(row.custom_fields ?? {}) };
1371
- const failures = { ...(cf.mirror_failures ?? {}) };
1372
- const prev = failures[foId];
1373
- const prevCount = Number(prev?.count ?? 0);
1374
- if (prevCount >= FAILURE_THRESHOLD && prev?.last_error === msg)
1375
- continue;
1376
- const count = prev?.last_error === msg ? prevCount + 1 : Math.max(1, prevCount + 1);
1377
- failures[foId] = { count, last_error: msg, at: new Date().toISOString() };
1378
- cf.mirror_failures = failures;
1379
- if (count >= FAILURE_THRESHOLD) {
1380
- cf.needs_manual_review = true;
1381
- cf.manual_review_source = "mirror_failure";
1382
- cf.manual_review_reason = `Floriday-wijziging kan niet worden verwerkt: ${msg.slice(0, 160)}`;
1383
- }
1384
- const { error: fErr } = await supabaseAdmin.from("orders")
1385
- .update({ custom_fields: cf })
1386
- .eq("id", row.id);
1387
- if (fErr)
1388
- console.warn(`[floriday-mirror] foutteller bijwerken faalde voor ${row.id}: ${fErr.message}`);
1389
- }
1390
- // Batch enqueue voor karherplanning. processed_at resetten, anders blijft een
1391
- // eerder verwerkte order voor altijd overgeslagen door de cron.
1392
- // Annuleringen uit Floriday afhandelen (koppelprompt 1.0.77).
1393
- // Afgehandeld in Floriday (buiten het ERP om) — na de ronde, per order.
1394
- for (const oid of Array.from(handledOrderIds)) {
1395
- if (legacyExternalIds.has(oid))
1396
- continue;
1397
- try {
1398
- const { handleFloridayExternalFulfillment } = await import("./floriday-external-fulfillment.server.js");
1399
- await handleFloridayExternalFulfillment(oid, fulfillmentStates);
1400
- }
1401
- catch (err) {
1402
- errors.push(`${oid}: afhandeling in Floriday verwerken faalde: ${err.message}`.slice(0, 200));
1403
- }
1404
- }
1405
- for (const cid of Array.from(new Set(floridayCancelIds))) {
1406
- try {
1407
- const { handleFloridayCancellation } = await import("./order-cancel.server.js");
1408
- const res = await handleFloridayCancellation(cid);
1409
- if (res !== "cancelled")
1410
- errors.push(`${cid}: ${res}`);
1411
- }
1412
- catch (err) {
1413
- errors.push(`${cid}: annulering uit Floriday faalde: ${err.message}`.slice(0, 200));
1414
- }
1415
- }
1416
- if (affectedOrderIds.length > 0) {
1417
- const queueRows = affectedOrderIds.map((oid) => ({
1418
- order_id: oid,
1419
- requested_at: new Date().toISOString(),
1420
- processed_at: null,
1421
- attempts: 0,
1422
- last_error: null,
1423
- }));
1424
- await supabaseAdmin.from("cart_replan_queue").upsert(queueRows, {
1425
- onConflict: "order_id",
1426
- });
1427
- }
1428
- // Stap 2: orders die in deze ronde echt zijn aangemaakt of gewijzigd
1429
- // expliciet aanmelden bij de planwachtrij van de logistiek-engine. Mislukt
1430
- // dat, dan verschijnt het als duidelijke fout in het syncresultaat.
1431
- let enqueued = 0;
1432
- const toEnqueue = Array.from(new Set(changedOrderIds)).filter((id) => affectedOrderIds.includes(id));
1433
- for (const oid of toEnqueue) {
1434
- const fields = Array.from(changedFieldsByOrder.get(oid) ?? []).sort();
1435
- const { error: enqErr } = await supabaseAdmin.rpc("logistics_plan_enqueue", {
1436
- p_order_id: oid,
1437
- p_reason: fields.length
1438
- ? `nieuwe of gewijzigde Floriday-order: ${fields.join(", ")}`.slice(0, 300)
1439
- : "nieuwe of gewijzigde Floriday-order",
1440
- });
1441
- if (enqErr) {
1442
- errors.push(`${oid}: aanmelden voor karindeling faalde: ${enqErr.message.slice(0, 150)}`);
1443
- failed++;
1444
- }
1445
- else {
1446
- enqueued++;
1447
- }
1448
- }
1449
- // Orders zonder karindeling en zonder aanmelding worden door de
1450
- // Logistieke Engine zelf opgespoord (logistics_reconcile_missing_plan_queue
1451
- // in elke tick), voor alle ordertypes. Geen vangnet meer in deze module.
1452
- // Klantkoppeling achteraf: zodra precies één klant het organisatienummer
1453
- // heeft, krijgen alle Floriday-orders zonder customer_id die klant.
1454
- try {
1455
- await linkCustomersForFloridayOrders();
1456
- }
1457
- catch (e) {
1458
- errors.push(`klantkoppeling: ${String(e?.message ?? e).slice(0, 150)}`);
1459
- }
1460
- return {
1461
- ok: failed === 0,
1462
- processed: rows.length,
1463
- inserted,
1464
- updated,
1465
- unchanged,
1466
- skipped,
1467
- failed,
1468
- enqueued,
1469
- changes: Array.from(changedFieldsByOrder.entries())
1470
- .slice(0, 50)
1471
- .map(([order_id, f]) => ({ order_id, fields: Array.from(f).sort() })),
1472
- errors: errors.slice(0, 20),
1473
- };
1474
- }
1475
- export async function mirrorFloridayOrdersFromCron(limit = DEFAULT_BATCH, since = null) {
1476
- return mirrorInternal(limit, since);
1477
- }
1478
6
  export const mirrorFloridayOrders = createServerFn({ method: "POST" })
1479
7
  .middleware([requireSupabaseAuth])
1480
8
  .inputValidator((input) => z.object({ limit: z.number().int().positive().max(1000).optional() }).parse(input ?? {}))
1481
- .handler(async ({ data }) => mirrorInternal(data.limit ?? DEFAULT_BATCH));
9
+ .handler(async ({ data }) => {
10
+ const { mirrorFloridayOrdersFromCron, DEFAULT_MIRROR_BATCH } = await import("./floriday-mirror.server.js");
11
+ return mirrorFloridayOrdersFromCron(data.limit ?? DEFAULT_MIRROR_BATCH);
12
+ });