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