@flowselections/floriday-verkoop-module 1.0.125 → 1.0.129

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