@flowselections/logistiek-engine 1.0.226 → 1.0.230

package/db/schema/logistiek-engine.sql

@@ -38972,3 +38972,760 @@ RETURNS TABLE(punt text, ok boolean, uitleg text) LANGUAGE sql STABLE SET search
 $$;
 REVOKE ALL ON FUNCTION public.logistics_install_check_223() FROM PUBLIC, anon, authenticated;
 GRANT EXECUTE ON FUNCTION public.logistics_install_check_223() TO service_role;
+
+-- ===== 1.0.227 = Standaardgegevens aanvullen (zelfherstel) =====
+-- bron: migratie 1.0.227
+-- 1.0.227: standaardgegevens Engine aanvullen (zelfherstel in nieuwe shells)
+CREATE OR REPLACE FUNCTION public.logistics_ensure_defaults()
+RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path = public AS $$
+DECLARE
+  v_ladingdragers text[] := '{}';
+  v_ladingdrager_velden text[] := '{}';
+  v_vertalingen text[] := '{}';
+  v_instellingen text[] := '{}';
+  v_tijd text := NULL;
+  v_strategie boolean := false;
+  v_meldingen text[] := '{}';
+  v_gewijzigd boolean;
+  v_res jsonb;
+  v_heeft_orders boolean;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_ensure_defaults');
+  PERFORM pg_advisory_xact_lock(hashtext('logistics_ensure_defaults'));
+
+  -- 1. Ladingdragers (systeemgegevens, vaste codes; Voorraad koppelt via engine_code).
+  WITH std(code, name, capacity_model, layers, len, wid, max_crates, max_boxes, max_kg, max_cm, mix, sort_order) AS (VALUES
+    ('trolley','Stapelwagen','layered',5,135,56,NULL::int,NULL::int,500::numeric,190,true,10),
+    ('danish_container','Deense container','layered',5,135,56,NULL,NULL,500,190,true,20),
+    ('euro_rolcontainer','Euro-rolcontainer','layered',6,120,80,NULL,NULL,600,200,true,30),
+    ('pallet','Pallet','stacked',4,120,80,NULL,40,800,180,true,40),
+    ('euro_pallet','Euro-pallet','single',1,60,40,1,1,20,40,false,50),
+    ('loose','Geen ladingdrager','none',1,0,0,NULL,NULL,NULL,NULL,false,60)
+  ), ins AS (
+    INSERT INTO public.load_carrier_types (code, name, capacity_model, layers_per_carrier, layer_length_cm, layer_width_cm,
+      max_crates_per_layer, max_boxes, max_weight_kg, max_height_cm, allow_mixing, is_active, is_default, sort_order)
+    SELECT s.code, s.name, s.capacity_model, s.layers, s.len, s.wid, s.max_crates, s.max_boxes, s.max_kg, s.max_cm, s.mix, true,
+           (s.code = 'trolley' AND NOT EXISTS (SELECT 1 FROM public.load_carrier_types d WHERE d.is_default)), s.sort_order
+      FROM std s
+     WHERE NOT EXISTS (SELECT 1 FROM public.load_carrier_types l WHERE l.code = s.code)
+    ON CONFLICT (code) DO NOTHING
+    RETURNING code
+  )
+  SELECT coalesce(array_agg(code ORDER BY code), '{}') INTO v_ladingdragers FROM ins;
+
+  -- Bestaande codes: alleen lege velden aanvullen (ingevulde waarden zijn klantwaarden).
+  WITH std(code, name, capacity_model, layers, len, wid, max_crates, max_boxes, max_kg, max_cm) AS (VALUES
+    ('trolley','Stapelwagen','layered',5,135,56,NULL::int,NULL::int,500::numeric,190),
+    ('danish_container','Deense container','layered',5,135,56,NULL,NULL,500,190),
+    ('euro_rolcontainer','Euro-rolcontainer','layered',6,120,80,NULL,NULL,600,200),
+    ('pallet','Pallet','stacked',4,120,80,NULL,40,800,180),
+    ('euro_pallet','Euro-pallet','single',1,60,40,1,1,20,40),
+    ('loose','Geen ladingdrager','none',1,0,0,NULL,NULL,NULL,NULL)
+  ), upd AS (
+    UPDATE public.load_carrier_types l SET
+      name = coalesce(nullif(btrim(l.name),''), s.name),
+      capacity_model = coalesce(l.capacity_model, s.capacity_model),
+      layers_per_carrier = coalesce(l.layers_per_carrier, s.layers),
+      layer_length_cm = coalesce(l.layer_length_cm, s.len),
+      layer_width_cm = coalesce(l.layer_width_cm, s.wid),
+      max_crates_per_layer = coalesce(l.max_crates_per_layer, s.max_crates),
+      max_boxes = coalesce(l.max_boxes, s.max_boxes),
+      max_weight_kg = coalesce(l.max_weight_kg, s.max_kg),
+      max_height_cm = coalesce(l.max_height_cm, s.max_cm),
+      updated_at = now()
+      FROM std s
+     WHERE l.code = s.code AND NOT (l.code = ANY(v_ladingdragers))
+       AND ( nullif(btrim(l.name),'') IS NULL
+          OR l.capacity_model IS NULL OR l.layers_per_carrier IS NULL OR l.layer_length_cm IS NULL OR l.layer_width_cm IS NULL
+          OR (l.max_crates_per_layer IS NULL AND s.max_crates IS NOT NULL)
+          OR (l.max_boxes IS NULL AND s.max_boxes IS NOT NULL)
+          OR (l.max_weight_kg IS NULL AND s.max_kg IS NOT NULL)
+          OR (l.max_height_cm IS NULL AND s.max_cm IS NOT NULL))
+    RETURNING l.code
+  )
+  SELECT coalesce(array_agg(code ORDER BY code), '{}') INTO v_ladingdrager_velden FROM upd;
+  -- Vervallen systeemcodes: lijst is leeg. Komt er ooit een code bij die vervalt:
+  -- UPDATE ... SET is_active = false WHERE code = ANY('{...}'); nooit verwijderen.
+
+  -- 2. Vertaling Floriday -> Engine (systeemgegevens): alleen ontbrekende floriday_code toevoegen.
+  IF to_regclass('public.logistics_floriday_carrier_map') IS NOT NULL THEN
+    WITH v(f, c) AS (VALUES
+      ('DANISH_TROLLEY','danish_container'), ('DANISH_TROLLEY_NON_CC_RFID','danish_container'),
+      ('DANISH_TROLLEY_WATER_TRAY','danish_container'), ('ONE_THIRD_DANISH_TROLLEY','danish_container'),
+      ('AUCTION_TROLLEY','trolley'),
+      ('EURO_TROLLEY','euro_rolcontainer'), ('WATERING_CONTAINER','euro_rolcontainer'),
+      ('EURO_PALLET','euro_pallet'), ('HT_EURO_PALLET','euro_pallet'),
+      ('PALLET','pallet'), ('BLOCK_PALLET','pallet'), ('IFCO_PALLET','pallet'),
+      ('CHEP_PALLET_BLUE','pallet'), ('CHEP_PALLET_RED','pallet'),
+      ('NONE','loose')
+    ), ins AS (
+      INSERT INTO public.logistics_floriday_carrier_map (floriday_code, carrier_code)
+      SELECT v.f, v.c FROM v
+       WHERE NOT EXISTS (SELECT 1 FROM public.logistics_floriday_carrier_map m WHERE upper(m.floriday_code) = v.f)
+      ON CONFLICT DO NOTHING
+      RETURNING floriday_code
+    )
+    SELECT coalesce(array_agg(floriday_code ORDER BY floriday_code), '{}') INTO v_vertalingen FROM ins;
+  END IF;
+
+  -- 3. Plan-instellingen: alleen sleutels met één eenduidige terugval in de code, met precies die waarde.
+  WITH v(k, w) AS (VALUES ('batch_size','10'), ('retention_days','7'), ('kick_debounce_seconds','5')),
+  ins AS (
+    INSERT INTO public.logistics_plan_settings (key, value)
+    SELECT v.k, v.w FROM v WHERE NOT EXISTS (SELECT 1 FROM public.logistics_plan_settings p WHERE p.key = v.k)
+    ON CONFLICT (key) DO NOTHING
+    RETURNING key
+  )
+  SELECT coalesce(array_agg(key ORDER BY key), '{}') INTO v_instellingen FROM ins;
+
+  -- 4. Tijdinstellingen (klant): alleen als de rij ontbreekt.
+  IF NOT EXISTS (SELECT 1 FROM public.logistics_time_settings) THEN
+    v_heeft_orders := EXISTS (SELECT 1 FROM public.orders);
+    IF v_heeft_orders THEN
+      -- Zelfde gedrag als zonder rij: vertrekregel uit, regel 160 valt terug op "nu".
+      INSERT INTO public.logistics_time_settings (id, timezone, departure_rule_since, rule_160_since)
+      VALUES (true, 'Europe/Amsterdam', NULL, NULL) ON CONFLICT DO NOTHING;
+      v_tijd := 'aangemaakt zonder ingangsdata (er zijn al orders)';
+    ELSE
+      INSERT INTO public.logistics_time_settings (id, timezone, departure_rule_since, rule_160_since)
+      VALUES (true, 'Europe/Amsterdam', now(), now()) ON CONFLICT DO NOTHING;
+      v_tijd := 'aangemaakt met ingangsdata nu (lege shell)';
+    END IF;
+  END IF;
+
+  -- 5. Strategie (klant): alleen als er nog geen enkele bestaat.
+  -- 5. Strategie (klant): alleen als er nog geen enkele bestaat. Een strategie hoort bij
+  -- een gebruiker (user_id verplicht); zonder ingelogde gebruiker (serverronde) wachten.
+  IF NOT EXISTS (SELECT 1 FROM public.logistics_strategies) THEN
+    IF auth.uid() IS NULL THEN
+      v_meldingen := array_append(v_meldingen, 'Basisstrategie wordt aangemaakt bij het openen van de Engine door een gebruiker'::text);
+    ELSE
+      WITH s AS (
+        INSERT INTO public.logistics_strategies (name, is_active, user_id)
+        VALUES ('Basisstrategie', true, auth.uid()) RETURNING id
+      )
+      INSERT INTO public.logistics_rule_configs (name, status, is_active, settings, strategy_id, user_id)
+      SELECT 'Werkwijze Basisstrategie', 'actief',
+             NOT EXISTS (SELECT 1 FROM public.logistics_rule_configs r WHERE r.is_active),
+             '{}'::jsonb, s.id, auth.uid() FROM s;
+      v_strategie := true;
+    END IF;
+  END IF;
+  IF NOT EXISTS (SELECT 1 FROM public.logistics_strategies WHERE is_active) THEN
+    v_meldingen := array_append(v_meldingen, 'Geen actieve strategie'::text);
+  END IF;
+
+  -- 6. Tabellen van andere modules: alleen melden.
+  IF to_regclass('public.pick_station_types') IS NOT NULL AND NOT EXISTS (SELECT 1 FROM public.pick_station_types) THEN
+    v_meldingen := array_append(v_meldingen, 'Pickstation-soorten leeg (Pickmodule)'::text);
+  END IF;
+  IF to_regclass('public.pick_screen_document_types') IS NOT NULL AND NOT EXISTS (SELECT 1 FROM public.pick_screen_document_types) THEN
+    v_meldingen := array_append(v_meldingen, 'Pickscherm-documentsoorten leeg (Pickmodule)'::text);
+  END IF;
+  IF to_regclass('public.cart_planning_settings') IS NOT NULL AND NOT EXISTS (SELECT 1 FROM public.cart_planning_settings) THEN
+    v_meldingen := array_append(v_meldingen, 'Karplanning-instellingen leeg (Verkoop)'::text);
+  END IF;
+
+  v_gewijzigd := cardinality(v_ladingdragers) + cardinality(v_ladingdrager_velden) + cardinality(v_vertalingen)
+                 + cardinality(v_instellingen) > 0 OR v_tijd IS NOT NULL OR v_strategie;
+  v_res := jsonb_build_object(
+    'gewijzigd', v_gewijzigd, 'op', now(),
+    'ladingdragers', to_jsonb(v_ladingdragers),
+    'ladingdrager_velden', to_jsonb(v_ladingdrager_velden),
+    'floriday_vertalingen', to_jsonb(v_vertalingen),
+    'plan_instellingen', to_jsonb(v_instellingen),
+    'tijdinstellingen', v_tijd,
+    'basisstrategie', v_strategie,
+    'meldingen', to_jsonb(v_meldingen));
+
+  -- Alleen wegschrijven als er iets is aangevuld (geen schrijfactie per ronde).
+  IF v_gewijzigd THEN
+    INSERT INTO public.logistics_plan_settings (key, value) VALUES ('defaults_last_result', v_res::text)
+    ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = now();
+  END IF;
+  RETURN v_res;
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_ensure_defaults() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_ensure_defaults() TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_defaults_status()
+RETURNS jsonb LANGUAGE sql STABLE SECURITY DEFINER SET search_path = public AS $$
+  SELECT public.logistics_acc_guard('ingelogd', 'logistics_defaults_status');
+  SELECT coalesce((SELECT value::jsonb FROM public.logistics_plan_settings WHERE key = 'defaults_last_result'), 'null'::jsonb);
+$$;
+REVOKE ALL ON FUNCTION public.logistics_defaults_status() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_defaults_status() TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_install_check_227()
+RETURNS TABLE(punt text, ok boolean, uitleg text) LANGUAGE sql STABLE SET search_path TO 'public' AS $$
+  SELECT 'standaardgegevens-functie', to_regprocedure('public.logistics_ensure_defaults()') IS NOT NULL,
+         'logistics_ensure_defaults is aanwezig'
+  UNION ALL
+  SELECT 'rechten standaardgegevens',
+         NOT has_function_privilege('anon', 'public.logistics_ensure_defaults()', 'EXECUTE')
+         AND has_function_privilege('authenticated', 'public.logistics_ensure_defaults()', 'EXECUTE'),
+         'Alleen ingelogde gebruikers en server mogen aanvullen'
+  UNION ALL
+  SELECT 'ladingdragers', (SELECT count(*) FROM public.load_carrier_types WHERE code IN
+           ('trolley','danish_container','euro_rolcontainer','pallet','euro_pallet','loose')) = 6,
+         'De zes vaste ladingdragercodes zijn aanwezig'
+  UNION ALL
+  SELECT 'Floriday-vertaling', (SELECT count(*) FROM public.logistics_floriday_carrier_map) >= 15,
+         'Vertaling Floriday naar Engine-ladingdrager is gevuld'
+  UNION ALL
+  SELECT 'tijdinstelling', EXISTS (SELECT 1 FROM public.logistics_time_settings), 'Tijdinstelling aanwezig'
+$$;
+REVOKE ALL ON FUNCTION public.logistics_install_check_227() FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_install_check_227() TO service_role;
+
+
+-- ===== 1.0.228: NONE → loose, lus planwachtrij, opruimen, bewaartermijnen, onderhoudsstatus =====
+-- 1.0.228: NONE eenduidig naar loose; lus in de planwachtrij stoppen.
+
+-- A1. Vertaling: alleen leeg = ontbreekt; NONE gaat via de vertaaltabel (bron floriday).
+CREATE OR REPLACE FUNCTION public.logistics_ladingdrager_resolve(p_code text)
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v text := nullif(btrim(p_code), ''); n int; m text;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_ladingdrager_resolve');
+  IF v IS NULL THEN
+    RETURN jsonb_build_object('code', NULL, 'invoer', v, 'bron', NULL, 'fout', 'ladingdrager ontbreekt');
+  END IF;
+  IF EXISTS (SELECT 1 FROM public.load_carrier_types t WHERE t.is_active AND t.code = v) THEN
+    RETURN jsonb_build_object('code', v, 'invoer', v, 'bron', 'beheer', 'fout', NULL);
+  END IF;
+  IF to_regclass('public.logistics_floriday_carrier_map') IS NULL THEN
+    RETURN jsonb_build_object('code', NULL, 'invoer', v, 'bron', NULL, 'fout', format('ladingdrager %s onbekend in Beheer', v));
+  END IF;
+  SELECT count(DISTINCT c.carrier_code), min(c.carrier_code) INTO n, m
+    FROM public.logistics_floriday_carrier_map c WHERE upper(c.floriday_code) = upper(v);
+  IF coalesce(n, 0) = 0 THEN
+    RETURN jsonb_build_object('code', NULL, 'invoer', v, 'bron', NULL, 'fout', format('ladingdrager %s onbekend in Beheer', v));
+  ELSIF n > 1 THEN
+    RETURN jsonb_build_object('code', NULL, 'invoer', v, 'bron', 'floriday', 'fout', format('ladingdrager niet eenduidig (%s)', v));
+  ELSIF NOT EXISTS (SELECT 1 FROM public.load_carrier_types t WHERE t.is_active AND t.code = m) THEN
+    RETURN jsonb_build_object('code', NULL, 'invoer', v, 'bron', 'floriday', 'fout', format('ladingdrager %s onbekend in Beheer', v));
+  END IF;
+  RETURN jsonb_build_object('code', m, 'invoer', v, 'bron', 'floriday', 'fout', NULL);
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_ladingdrager_resolve(text) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_ladingdrager_resolve(text) TO authenticated, service_role;
+
+-- A2. Planner-variant met het oude gedrag (regel 1.0.213: geen ladingdrager = niet op een kar).
+CREATE OR REPLACE FUNCTION public.logistics_ladingdrager_resolve_plan(p_code text)
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE rc jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_ladingdrager_resolve_plan');
+  IF upper(nullif(btrim(p_code), '')) = 'NONE' THEN
+    RETURN jsonb_build_object('code', NULL, 'invoer', nullif(btrim(p_code), ''), 'bron', NULL, 'fout', 'ladingdrager ontbreekt');
+  END IF;
+  rc := public.logistics_ladingdrager_resolve(p_code);
+  IF rc->>'code' = 'loose' AND rc->>'bron' = 'floriday' THEN
+    RETURN jsonb_build_object('code', NULL, 'invoer', rc->>'invoer', 'bron', 'floriday', 'fout', 'ladingdrager ontbreekt');
+  END IF;
+  RETURN rc;
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_ladingdrager_resolve_plan(text) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_ladingdrager_resolve_plan(text) TO authenticated, service_role;
+
+-- B1. Vingerafdruk van wat de planning van een order gebruikt (zonder eigen Engine-velden).
+CREATE OR REPLACE FUNCTION public.logistics_plan_inhoud_fp(p_order_id uuid)
+RETURNS text LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+  SELECT md5(concat_ws('|',
+    o.status, o.delivery_date, o.customer_id, o.deleted_at, o.is_reservation, to_jsonb(o)->>'carrier_id',
+    o.custom_fields->>'delivery_location', o.custom_fields->>'delivery_location_id', o.custom_fields->>'delivery_location_gln',
+    o.custom_fields->>'pickup_moment', o.custom_fields->>'pickup_datetime', o.custom_fields->>'manual_pick_day',
+    o.custom_fields->>'own_transport', o.custom_fields->>'carrier',
+    (SELECT string_agg(concat_ws(':', oi.id, oi.product_id, oi.quantity, oi.crates_per_layer, oi.layers_per_cart,
+                                 oi.plants_per_crate, oi.quarantined_at), ',' ORDER BY oi.id)
+       FROM logistics_active.order_items oi WHERE oi.order_id = o.id),
+    (SELECT max(p.updated_at) FROM logistics_active.order_items oi JOIN public.products p ON p.id = oi.product_id
+      WHERE oi.order_id = o.id)))
+    FROM public.orders o WHERE o.id = p_order_id
+$$;
+REVOKE ALL ON FUNCTION public.logistics_plan_inhoud_fp(uuid) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_plan_inhoud_fp(uuid) TO service_role;
+
+ALTER TABLE public.logistics_plan_queue ADD COLUMN IF NOT EXISTS order_fp text;
+CREATE INDEX IF NOT EXISTS logistics_plan_queue_order_upd_idx ON public.logistics_plan_queue (order_id, updated_at DESC);
+
+-- B2. Reconcile: gearchiveerd = afgehandeld zolang de inhoud van de order niet is gewijzigd.
+CREATE OR REPLACE FUNCTION public.logistics_reconcile_missing_plan_queue()
+ RETURNS integer LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $function$
+DECLARE r record; n integer := 0;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_reconcile_missing_plan_queue');
+  FOR r IN
+    SELECT o.id FROM public.orders o
+     WHERE o.deleted_at IS NULL
+       AND COALESCE(o.is_reservation,false) = false
+       AND o.plan_locked_at IS NULL
+       AND o.order_number IS NOT NULL
+       AND (o.created_at >= now() - interval '14 days' OR o.updated_at >= now() - interval '14 days')
+       AND NOT EXISTS (SELECT 1 FROM public.logistics_tasks t WHERE t.order_ref = o.order_number)
+       AND NOT EXISTS (SELECT 1 FROM public.logistics_plan_queue q
+                        WHERE q.order_id = o.id AND q.status IN ('pending','running'))
+       AND NOT EXISTS (
+         SELECT 1 FROM public.logistics_plan_queue q
+          WHERE q.order_id = o.id AND q.status IN ('geblokkeerd', 'done', 'opgelost')
+            AND q.updated_at >= COALESCE(o.updated_at, o.created_at)
+            AND NOT EXISTS (SELECT 1 FROM logistics_active.order_items oi WHERE oi.order_id = o.id AND oi.created_at > q.updated_at)
+            AND NOT EXISTS (SELECT 1 FROM logistics_active.order_items oi JOIN public.products p ON p.id = oi.product_id
+                             WHERE oi.order_id = o.id AND p.updated_at > q.updated_at))
+       -- 1.0.228: gearchiveerd telt als afgehandeld; alleen een inhoudelijke wijziging biedt opnieuw aan.
+       -- Oude rijen zonder vingerafdruk tellen ook als afgehandeld ("Opnieuw aanbieden" blijft mogelijk).
+       AND NOT EXISTS (
+         SELECT 1 FROM public.logistics_plan_queue q
+          WHERE q.order_id = o.id AND q.status = 'gearchiveerd'
+            AND (q.order_fp IS NULL OR q.order_fp = public.logistics_plan_inhoud_fp(o.id)))
+     ORDER BY o.created_at ASC
+     LIMIT 100
+  LOOP
+    PERFORM public.logistics_plan_enqueue(r.id, 'reconcile');
+    n := n + 1;
+  END LOOP;
+  RETURN n;
+END;
+$function$;
+
+-- B3. Housekeeping: vingerafdruk bewaren; per order hooguit één archiveringsmelding.
+CREATE OR REPLACE FUNCTION public.logistics_plan_housekeeping()
+ RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $function$
+DECLARE v_resolved int := 0; v_archived int := 0; v_nieuw int := 0; v_alerts int := 0; v_gone int := 0; v_refs text;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_plan_housekeeping');
+  UPDATE public.logistics_plan_queue q SET status='opgelost', error='opgelost: order is al verzonden',
+         claimed_at=NULL, updated_at=now()
+    FROM public.orders o
+   WHERE o.id = q.order_id AND q.status IN ('geblokkeerd','failed')
+     AND o.status IN ('Verzonden','Gereed voor facturatie');
+  GET DIAGNOSTICS v_resolved = ROW_COUNT;
+  UPDATE public.logistics_plan_queue q SET status='opgelost', error='order bestaat niet meer', claimed_at=NULL, updated_at=now()
+   WHERE q.status IN ('geblokkeerd','failed')
+     AND NOT EXISTS (SELECT 1 FROM public.orders o WHERE o.id = q.order_id AND o.deleted_at IS NULL);
+
+  WITH kand AS (
+    SELECT q.id, q.order_id, o.order_number, public.logistics_plan_inhoud_fp(o.id) AS fp
+      FROM public.logistics_plan_queue q JOIN public.orders o ON o.id = q.order_id
+     WHERE q.status IN ('geblokkeerd','failed')
+       AND o.deleted_at IS NULL
+       AND COALESCE(o.status,'') NOT IN ('Verzonden','Gereed voor facturatie','geannuleerd')
+       AND o.delivery_date IS NOT NULL AND o.delivery_date::date < current_date - 2
+  ), a AS (
+    UPDATE public.logistics_plan_queue q SET status='gearchiveerd', error=COALESCE(q.error, q.reason),
+           order_fp = k.fp, claimed_at=NULL, updated_at=now()
+      FROM kand k WHERE q.id = k.id
+    RETURNING q.id, k.order_id, k.order_number, k.fp
+  ), nieuw AS (
+    SELECT DISTINCT a.order_number FROM a
+     WHERE NOT EXISTS (SELECT 1 FROM public.logistics_plan_queue e
+                        WHERE e.order_id = a.order_id AND e.status = 'gearchiveerd' AND e.id <> a.id
+                          AND (e.order_fp IS NULL OR e.order_fp = a.fp))
+  )
+  SELECT (SELECT count(*) FROM a), (SELECT count(*) FROM nieuw), (SELECT string_agg(order_number, ', ' ORDER BY order_number) FROM nieuw)
+    INTO v_archived, v_nieuw, v_refs;
+
+  IF v_nieuw > 0 THEN
+    INSERT INTO public.notifications(user_id, title, message, read)
+    SELECT DISTINCT ur.user_id, 'Niet geleverd en gearchiveerd',
+           v_nieuw || ' geblokkeerde order(s) gearchiveerd (leverdatum voorbij): ' || v_refs ||
+           '. Zie Engine › Wachtrij; "Opnieuw aanbieden" zet ze terug.', false
+      FROM public.user_roles ur WHERE ur.role IN ('planner','admin');
+  END IF;
+
+  UPDATE public.logistics_stock_alerts a SET status='resolved', resolved_at=now(),
+         resolution_reason='automatisch opgelost: order verzonden/afgerond', updated_at=now()
+    FROM public.orders o
+   WHERE o.id = a.order_id AND a.status='open'
+     AND o.status IN ('Verzonden','Gereed voor facturatie','geannuleerd');
+  GET DIAGNOSTICS v_alerts = ROW_COUNT;
+
+  UPDATE public.logistics_stock_alerts a SET status='resolved', resolved_at=now(),
+         resolution_reason='order bestaat niet meer', updated_at=now()
+   WHERE a.status='open' AND a.order_id IS NOT NULL
+     AND NOT EXISTS (SELECT 1 FROM public.orders o WHERE o.id = a.order_id AND o.deleted_at IS NULL);
+  GET DIAGNOSTICS v_gone = ROW_COUNT;
+
+  RETURN jsonb_build_object('blokkadesOpgelost', v_resolved, 'gearchiveerd', v_archived, 'gemeld', v_nieuw,
+                            'meldingenOpgelost', v_alerts, 'meldingenZonderOrder', v_gone);
+END $function$;
+
+-- B4. Prune: ook gearchiveerd/opgelost; nieuwste rij per order blijft; porties met tijdslimiet.
+CREATE OR REPLACE FUNCTION public.logistics_plan_prune()
+ RETURNS integer LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $function$
+DECLARE v_n int := 0; r int; v_days int := LEAST(GREATEST(public.logistics_plan_setting('retention_days', 7)::int, 1), 365);
+        v_eind timestamptz := clock_timestamp() + interval '5 seconds'; v_rondes int := 0;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_plan_prune');
+  LOOP
+    WITH rang AS (
+      SELECT q.id, q.status, q.updated_at,
+             row_number() OVER (PARTITION BY q.order_id ORDER BY q.updated_at DESC, q.id DESC) AS rn
+        FROM public.logistics_plan_queue q
+    ), weg AS (
+      SELECT id FROM rang
+       WHERE rn > 1 AND status IN ('done','failed','gearchiveerd','opgelost')
+         AND updated_at < now() - make_interval(days => v_days)
+       LIMIT 5000)
+    DELETE FROM public.logistics_plan_queue d USING weg WHERE d.id = weg.id;
+    GET DIAGNOSTICS r = ROW_COUNT;
+    v_n := v_n + r; v_rondes := v_rondes + 1;
+    EXIT WHEN r < 5000 OR clock_timestamp() >= v_eind;
+  END LOOP;
+  PERFORM public.logistics_planner_diff_prune();
+  IF v_n > 0 THEN
+    INSERT INTO public.logistics_plan_settings (key, value)
+    VALUES ('prune_last_result', jsonb_build_object('op', now(), 'verwijderd', v_n, 'porties', v_rondes)::text)
+    ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = now();
+  END IF;
+  RETURN v_n;
+END;
+$function$;
+
+-- B5. Bewaartermijnen: werkwijze die de planner gebruikt, anders veilige standaard; maximaal 365 dagen.
+CREATE OR REPLACE FUNCTION public.logistics_retention_days(p_key text)
+ RETURNS integer LANGUAGE sql STABLE SET search_path TO 'public' AS $function$
+  SELECT LEAST(365, GREATEST(1, COALESCE(
+    (SELECT NULLIF(COALESCE(rc.settings->'opruimen'->'fields'->>p_key, rc.settings->'opruimen'->>p_key), '')::integer
+       FROM public.logistics_rule_configs rc
+       LEFT JOIN public.logistics_strategies s ON s.id = rc.strategy_id
+      WHERE NULLIF(COALESCE(rc.settings->'opruimen'->'fields'->>p_key, rc.settings->'opruimen'->>p_key), '') IS NOT NULL
+      ORDER BY (rc.is_active AND coalesce(s.is_active, false)) DESC, rc.is_active DESC, rc.updated_at DESC NULLS LAST
+      LIMIT 1),
+    CASE p_key WHEN 'task_retention_days' THEN 90 ELSE 30 END)))
+$function$;
+
+-- B6. Status onderhoud voor de Engine-pagina.
+CREATE OR REPLACE FUNCTION public.logistics_onderhoud_status()
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path = public AS $$
+DECLARE v_status jsonb; v_trace timestamptz; v_prune jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_onderhoud_status');
+  SELECT coalesce(jsonb_object_agg(status, n), '{}'::jsonb) INTO v_status
+    FROM (SELECT status, count(*) n FROM public.logistics_plan_queue GROUP BY status) x;
+  IF to_regclass('public.logistics_trace_events') IS NOT NULL THEN
+    EXECUTE 'SELECT min(created_at) FROM public.logistics_trace_events' INTO v_trace;
+  END IF;
+  SELECT value::jsonb INTO v_prune FROM public.logistics_plan_settings WHERE key = 'prune_last_result';
+  RETURN jsonb_build_object('wachtrij', v_status, 'oudsteTrace', v_trace, 'laatsteOpruimronde', v_prune,
+    'bewaartermijnen', jsonb_build_object('trace', public.logistics_retention_days('trace_retention_days'),
+      'pickhistorie', public.logistics_retention_days('pick_history_retention_days'),
+      'barcodes', public.logistics_retention_days('barcode_retention_days'),
+      'taken', public.logistics_retention_days('task_retention_days')));
+END $$;
+REVOKE ALL ON FUNCTION public.logistics_onderhoud_status() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_onderhoud_status() TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_install_check_228()
+RETURNS TABLE(punt text, ok boolean, uitleg text) LANGUAGE sql STABLE SET search_path TO 'public' AS $$
+  SELECT 'NONE wordt loose', position('''NONE''' IN pg_get_functiondef('public.logistics_ladingdrager_resolve(text)'::regprocedure)) = 0,
+         'resolve vertaalt NONE via de vertaaltabel'
+  UNION ALL SELECT 'planner-variant', to_regprocedure('public.logistics_ladingdrager_resolve_plan(text)') IS NOT NULL, 'Planner houdt regel 1.0.213'
+  UNION ALL SELECT 'reconcile gearchiveerd', position('gearchiveerd' IN pg_get_functiondef('public.logistics_reconcile_missing_plan_queue()'::regprocedure)) > 0,
+         'Gearchiveerde orders worden niet steeds opnieuw aangeboden'
+  UNION ALL SELECT 'index wachtrij', EXISTS (SELECT 1 FROM pg_indexes WHERE indexname = 'logistics_plan_queue_order_upd_idx'), 'Opruimen per order via index'
+$$;
+REVOKE ALL ON FUNCTION public.logistics_install_check_228() FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_install_check_228() TO service_role;
+
+-- 1.0.228: aanroepers van de ladingdragervertaling
+CREATE OR REPLACE FUNCTION public.logistics_ladingdrager_kies(p_regels jsonb)
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ STABLE SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE e jsonb; uit jsonb := '{}'; rc jsonb; hv jsonb; v_pid uuid; v_key text; v_def text; v_ti text; v_lc text;
+        v_cache boolean := to_regclass('public.floriday_trade_items_cache') IS NOT NULL;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_ladingdrager_kies');
+  IF p_regels IS NULL OR jsonb_typeof(p_regels) <> 'array' THEN RETURN '{}'; END IF;
+  IF jsonb_array_length(p_regels) > 2000 THEN
+    RAISE EXCEPTION 'Maximaal 2000 regels per aanroep.' USING ERRCODE = '22023';
+  END IF;
+  SELECT nullif(btrim(coalesce(s.settings->'karrenindeling'->'fields'->>'default_carrier_type', s.settings->'karrenindeling'->>'default_carrier_type')), '')
+    INTO v_def FROM public.logistics_rule_configs s WHERE s.is_active ORDER BY s.updated_at DESC LIMIT 1;
+  IF v_def IS NULL OR NOT EXISTS (SELECT 1 FROM public.load_carrier_types t WHERE t.is_active AND t.code = v_def) THEN
+    SELECT t.code INTO v_def FROM public.load_carrier_types t WHERE t.is_active AND t.is_default ORDER BY t.sort_order LIMIT 1;
+  END IF;
+  FOR e IN SELECT x FROM jsonb_array_elements(p_regels) x LOOP
+    v_key := e->>'key';
+    CONTINUE WHEN v_key IS NULL;
+    v_pid := CASE WHEN nullif(btrim(e->>'product_id'), '') ~* '^[0-9a-f-]{36}$' THEN (e->>'product_id')::uuid END;
+    -- 1. orderregel
+    rc := public.logistics_ladingdrager_resolve_plan(e->>'regel_code');
+    IF rc->>'code' IS NOT NULL THEN
+      uit := uit || jsonb_build_object(v_key, jsonb_build_object('code', rc->>'code', 'bron', 'orderregel', 'invoer', rc->>'invoer'));
+      CONTINUE;
+    END IF;
+    -- 2/3. product, dan voorraadartikel
+    IF v_pid IS NOT NULL THEN
+      hv := public.logistics_product_hoofdverpakking(v_pid);
+      IF nullif(hv->>'ladingdrager', '') IS NOT NULL THEN
+        rc := public.logistics_ladingdrager_resolve_plan(hv->>'ladingdrager');
+        IF rc->>'code' IS NOT NULL THEN
+          uit := uit || jsonb_build_object(v_key, jsonb_build_object('code', rc->>'code', 'bron', hv->>'bron', 'invoer', rc->>'invoer',
+                   'voorraadartikelId', hv->'voorraadartikelId'));
+          CONTINUE;
+        ELSIF upper(hv->>'ladingdrager') = 'NONE' OR rc->>'fout' = 'ladingdrager ontbreekt' THEN
+          uit := uit || jsonb_build_object(v_key, jsonb_build_object('code', NULL, 'bron', hv->>'bron', 'fout', 'ladingdrager ontbreekt (geen ladingdrager)'));
+          CONTINUE;
+        END IF;
+      ELSIF hv->>'fout' IS NOT NULL THEN
+        uit := uit || jsonb_build_object(v_key, jsonb_build_object('code', NULL, 'bron', hv->>'bron', 'fout', hv->>'fout'));
+        CONTINUE;
+      END IF;
+      -- 3b. Floriday-verpakking van het artikel (bestaand gedrag sinds 1.0.190).
+      IF v_cache THEN
+        v_lc := NULL;
+        SELECT p.floriday_trade_item_id INTO v_ti FROM public.products p WHERE p.id = v_pid;
+        IF v_ti IS NOT NULL THEN
+          EXECUTE $q$SELECT c->>'loadCarrier' FROM public.floriday_trade_items_cache t,
+                     jsonb_array_elements(coalesce(t.data->'packingConfigurations', '[]')) c
+                    WHERE t.floriday_id = $1 AND NOT coalesce(t.is_deleted, false) AND nullif(c->>'loadCarrier', '') IS NOT NULL
+                    ORDER BY coalesce((c->>'primary')::boolean, false) DESC LIMIT 1$q$ INTO v_lc USING v_ti;
+          rc := public.logistics_ladingdrager_resolve_plan(v_lc);
+          IF rc->>'code' IS NOT NULL THEN
+            uit := uit || jsonb_build_object(v_key, jsonb_build_object('code', rc->>'code', 'bron', 'floriday_verpakking', 'invoer', rc->>'invoer'));
+            CONTINUE;
+          END IF;
+        END IF;
+      END IF;
+    END IF;
+    -- 4. werkwijze, zichtbaar
+    uit := uit || jsonb_build_object(v_key, jsonb_build_object('code', v_def, 'bron', CASE WHEN v_def IS NOT NULL THEN 'werkwijze' END,
+             'waarschuwing', CASE WHEN v_def IS NOT NULL THEN 'ladingdrager uit de werkwijze, niet uit het artikel' END,
+             'fout', CASE WHEN v_def IS NULL THEN 'ladingdrager ontbreekt' END));
+  END LOOP;
+  RETURN uit;
+END $function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_product_oordeel_many(p_product_ids uuid[])
+ RETURNS TABLE(product_id uuid, oordeel text, tekst text, "actieUrl" text)
+ LANGUAGE plpgsql
+ STABLE SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+#variable_conflict use_column
+DECLARE r record; c record; cd record; v_carrier text; hv jsonb; rs jsonb; v_code text; v_lfout text; ls int; fh numeric; ph numeric; cpl numeric; lpc numeric; laag numeric;
+  blok text[]; waar text[]; mist text[]; hmist text[]; naam text; bron text;
+  c_url constant text := '/logistiek-engine/beheer#gegevens-voor-karindeling';
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_product_oordeel_many');
+  IF coalesce(cardinality(p_product_ids), 0) = 0 THEN RETURN; END IF;
+  IF cardinality(p_product_ids) > 1000 THEN
+    RAISE EXCEPTION 'Maximaal 1000 producten per aanroep (ontvangen: %).', cardinality(p_product_ids) USING ERRCODE = '22023';
+  END IF;
+  SELECT nullif(btrim(coalesce(s.settings->'karrenindeling'->'fields'->>'default_carrier_type', s.settings->'karrenindeling'->>'default_carrier_type')), '')
+    INTO v_carrier FROM public.logistics_rule_configs s WHERE s.is_active ORDER BY s.updated_at DESC LIMIT 1;
+  SELECT t.code, t.name, t.layer_length_cm, t.layer_width_cm, t.max_height_cm, t.max_crates_per_layer, t.layers_per_carrier INTO cd
+    FROM public.load_carrier_types t
+   WHERE t.is_active AND (t.code = v_carrier OR (v_carrier IS NULL AND t.is_default))
+   ORDER BY (t.code = v_carrier) DESC NULLS LAST LIMIT 1;
+
+  FOR r IN SELECT * FROM public.logistics_data_gereedheid(p_product_ids) LOOP
+    blok := '{}'; waar := '{}'; hmist := '{}';
+    mist := array_remove(coalesce(r.ontbrekend, '{}'), 'weight');
+    hv := public.logistics_product_hoofdverpakking(r.product_id);
+    v_code := NULL; v_lfout := NULL;
+    IF hv IS NOT NULL AND NOT coalesce((hv->>'aanwezig')::boolean, false) THEN
+      mist := mist || 'belading niet ingesteld'::text;
+    END IF;
+    IF hv IS NOT NULL AND coalesce((hv->>'aanwezig')::boolean, false) AND nullif(hv->>'ladingdrager', '') IS NOT NULL THEN
+      rs := public.logistics_ladingdrager_resolve(hv->>'ladingdrager');
+      v_code := rs->>'code'; v_lfout := rs->>'fout';
+      -- 1.0.228: geen ladingdrager (loose) = uitleg, geen blokkade; geen capaciteit, geen menging.
+      IF v_code = 'loose' THEN
+        product_id := r.product_id; "actieUrl" := c_url; oordeel := 'waarschuwing';
+        tekst := format('%s: geen ladingdrager, niet op een kar.', r.product);
+        RETURN NEXT;
+        CONTINUE;
+      END IF;
+    END IF;
+    SELECT NULL::text AS code, NULL::text AS name, NULL::int AS layer_length_cm, NULL::int AS layer_width_cm, NULL::int AS max_height_cm, NULL::int AS max_crates_per_layer, NULL::int AS layers_per_carrier INTO c;
+    IF v_code IS NOT NULL THEN
+      SELECT t.code, t.name, t.layer_length_cm, t.layer_width_cm, t.max_height_cm, t.max_crates_per_layer, t.layers_per_carrier INTO c
+        FROM public.load_carrier_types t WHERE t.is_active AND t.code = v_code LIMIT 1;
+    ELSIF v_lfout IS NULL THEN
+      SELECT cd.code, cd.name, cd.layer_length_cm, cd.layer_width_cm, cd.max_height_cm, cd.max_crates_per_layer, cd.layers_per_carrier INTO c;
+    ELSE
+      mist := mist || v_lfout;
+    END IF;
+    naam := coalesce(c.name, c.code, 'de ladingdrager');
+    bron := coalesce(r.velden->'crates_per_layer'->>'bron', 'product');
+    cpl := coalesce(nullif(r.velden->'crates_per_layer'->>'waarde', '')::numeric, 0);
+    lpc := coalesce(nullif(r.velden->'layers_per_cart'->>'waarde', '')::numeric, 0);
+    fh := nullif(r.velden->'fust_height_mm'->>'waarde', '')::numeric / 10.0;
+    ph := nullif(r.velden->'plant_height_cm'->>'waarde', '')::numeric;
+    ls := public.logistics_max_fusten_per_laag(c.layer_length_cm, c.layer_width_cm,
+            nullif(r.velden->'fust_length_mm'->>'waarde', '')::numeric / 10.0, nullif(r.velden->'fust_width_mm'->>'waarde', '')::numeric / 10.0);
+    IF coalesce(fh,0) > 0 AND coalesce(ph,0) > 0 AND coalesce(c.max_height_cm,0) > 0 THEN
+      laag := greatest(fh, ph);
+      IF lpc * laag > c.max_height_cm + 1e-9 AND ph >= fh AND coalesce(r.velden->'plant_height_cm'->>'bron', '') ILIKE 'floricode%' THEN
+        waar := waar || format('planthoogte volgens Floricode; controleer: %s lagen × %s cm = %s cm, hoger dan %s (%s cm)',
+          lpc, trim_scale(round(laag,1)), trim_scale(round(lpc*laag,1)), naam, trim_scale(round(c.max_height_cm::numeric,1)));
+      ELSIF lpc * laag > c.max_height_cm + 1e-9 THEN
+        blok := blok || format('%s lagen × %s cm = %s cm, terwijl %s %s cm hoog is; er passen maximaal %s lagen',
+          lpc, trim_scale(round(laag,1)), trim_scale(round(lpc*laag,1)), naam, trim_scale(round(c.max_height_cm::numeric,1)), floor(c.max_height_cm / laag));
+      END IF;
+    ELSE
+      IF coalesce(fh,0) <= 0 THEN hmist := hmist || 'fusthoogte'::text; END IF;
+      IF coalesce(ph,0) <= 0 THEN hmist := hmist || 'planthoogte'::text; END IF;
+      IF coalesce(c.max_height_cm,0) <= 0 THEN hmist := hmist || ('hoogte van ' || naam); END IF;
+    END IF;
+    IF public.logistics_laag_tolerantie_tekst(c.layer_length_cm, c.layer_width_cm,
+         nullif(r.velden->'fust_length_mm'->>'waarde', '')::numeric / 10.0, nullif(r.velden->'fust_width_mm'->>'waarde', '')::numeric / 10.0, cpl) IS NOT NULL THEN
+      waar := waar || public.logistics_laag_tolerantie_tekst(c.layer_length_cm, c.layer_width_cm,
+         nullif(r.velden->'fust_length_mm'->>'waarde', '')::numeric / 10.0, nullif(r.velden->'fust_width_mm'->>'waarde', '')::numeric / 10.0, cpl);
+    END IF;
+    IF ls IS NOT NULL AND cpl > ls THEN
+      blok := blok || format('%s fust per laag (bron: %s), maar op een laag van %s passen er maximaal %s', cpl, bron, naam, ls);
+    END IF;
+    IF coalesce(c.max_crates_per_layer,0) > 0 AND cpl > c.max_crates_per_layer THEN
+      blok := blok || format('%s fust per laag (bron: %s), maar %s staat maximaal %s fust per laag toe', cpl, bron, naam, c.max_crates_per_layer);
+    END IF;
+    IF cardinality(blok) = 0 AND cardinality(hmist) > 0 AND coalesce(c.layers_per_carrier,0) > 0 AND lpc > c.layers_per_carrier THEN
+      waar := waar || format('%s lagen opgegeven, standaard %s; niet te controleren omdat de %s ontbreekt', lpc, c.layers_per_carrier, array_to_string(hmist, ', '));
+    END IF;
+    IF 'weight' = ANY(coalesce(r.ontbrekend, '{}')) THEN waar := waar || 'gewicht per fust ontbreekt'::text; END IF;
+
+    product_id := r.product_id; "actieUrl" := c_url;
+    IF cardinality(blok) > 0 THEN
+      oordeel := 'onmogelijk'; tekst := format('%s past niet op %s: %s.', r.product, naam, array_to_string(blok, '; '));
+    ELSIF cardinality(mist) > 0 THEN
+      oordeel := 'mist_gegevens';
+      tekst := CASE WHEN 'belading niet ingesteld' = ANY(mist) THEN format('%s: belading niet ingesteld.', r.product)
+                    WHEN v_lfout IS NOT NULL AND v_lfout = ANY(mist) THEN format('%s: %s.', r.product, v_lfout)
+                    ELSE r.uitleg END;
+    ELSIF cardinality(waar) > 0 THEN
+      oordeel := 'waarschuwing'; tekst := format('%s: %s.', r.product, array_to_string(waar, '; '));
+    ELSE
+      oordeel := 'compleet'; tekst := format('%s: gegevens voor karindeling compleet.', r.product);
+    END IF;
+    RETURN NEXT;
+  END LOOP;
+END $function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_product_oordeel_belading(p_regels jsonb)
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ STABLE SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE e jsonb; gj jsonb; gmap jsonb := '{}'::jsonb; c record; rc jsonb; hv jsonb; v_code text; v_eigen text; ids uuid[]; uit jsonb := '[]'::jsonb;
+  ls int; fh numeric; ph numeric; cpl numeric; lpc numeric; ppc numeric; laag numeric; naam text; v_prod text; fl numeric; fb numeric;
+  blok text[]; waar text[]; mist text[]; hmist text[]; v_pid uuid; v_oordeel text; v_tekst text; v_heeft_kol boolean; v_cfout text;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_product_oordeel_belading');
+  IF p_regels IS NULL OR jsonb_typeof(p_regels) <> 'array' THEN RAISE EXCEPTION 'p_regels moet een lijst zijn.' USING ERRCODE = '22023'; END IF;
+  IF jsonb_array_length(p_regels) > 1000 THEN
+    RAISE EXCEPTION 'Maximaal 1000 regels per aanroep (ontvangen: %).', jsonb_array_length(p_regels) USING ERRCODE = '22023';
+  END IF;
+  SELECT array_agg(DISTINCT (x->>'product_id')::uuid) INTO ids FROM jsonb_array_elements(p_regels) x
+   WHERE nullif(btrim(x->>'product_id'), '') ~* '^[0-9a-f-]{36}$';
+  IF ids IS NOT NULL THEN
+    SELECT coalesce(jsonb_object_agg(g.product_id::text, to_jsonb(g)), '{}'::jsonb) INTO gmap
+      FROM public.logistics_data_gereedheid(ids) g;
+  END IF;
+  SELECT EXISTS (SELECT 1 FROM pg_attribute WHERE attrelid = to_regclass('public.products') AND attname = 'load_carrier_type' AND NOT attisdropped) INTO v_heeft_kol;
+
+  FOR e IN SELECT x FROM jsonb_array_elements(p_regels) x LOOP
+    blok := '{}'; waar := '{}'; mist := '{}'; hmist := '{}'; v_eigen := NULL; v_cfout := NULL;
+    SELECT NULL::text AS code, NULL::text AS name, NULL::numeric AS layer_length_cm, NULL::numeric AS layer_width_cm,
+           NULL::numeric AS max_height_cm, NULL::integer AS max_crates_per_layer, NULL::integer AS layers_per_carrier INTO c;
+    v_pid := CASE WHEN nullif(btrim(e->>'product_id'), '') ~* '^[0-9a-f-]{36}$' THEN (e->>'product_id')::uuid END;
+    gj := CASE WHEN v_pid IS NULL THEN NULL ELSE gmap->(v_pid::text) END;
+    IF gj IS NULL THEN
+      uit := uit || jsonb_build_array(jsonb_build_object('product_id', v_pid, 'oordeel', 'mist_gegevens', 'tekst', 'product onbekend',
+        'regels', jsonb_build_array('Product onbekend.')));
+      CONTINUE;
+    END IF;
+    v_prod := coalesce(gj->>'product', 'Product');
+    hv := public.logistics_product_hoofdverpakking(v_pid);
+    v_code := nullif(btrim(e->>'carrier_code'), '');
+    IF v_code IS NULL THEN v_code := nullif(hv->>'ladingdrager', ''); END IF;
+    IF v_code IS NULL AND v_heeft_kol THEN
+      EXECUTE 'SELECT nullif(btrim(load_carrier_type::text), '''') FROM public.products WHERE id = $1' INTO v_eigen USING v_pid;
+      v_code := v_eigen;
+    END IF;
+    rc := public.logistics_ladingdrager_resolve(v_code);
+    v_cfout := rc->>'fout';
+    -- 1.0.228: geen ladingdrager (loose) = uitleg, geen blokkade; geen capaciteit, geen menging.
+    IF rc->>'code' = 'loose' THEN
+      uit := uit || jsonb_build_array(jsonb_build_object('product_id', v_pid, 'oordeel', 'waarschuwing',
+        'tekst', format('%s: geen ladingdrager, niet op een kar.', v_prod),
+        'ladingdrager', 'loose', 'ladingdragerInvoer', rc->>'invoer', 'ladingdragerBron', rc->>'bron',
+        'regels', jsonb_build_array('Geen ladingdrager: niet op een kar.')));
+      CONTINUE;
+    END IF;
+    IF rc->>'code' IS NOT NULL THEN
+      SELECT t.code, t.name, t.layer_length_cm, t.layer_width_cm, t.max_height_cm, t.max_crates_per_layer, t.layers_per_carrier INTO c
+        FROM public.load_carrier_types t WHERE t.is_active AND t.code = rc->>'code' LIMIT 1;
+    END IF;
+    naam := coalesce(c.name, c.code, 'de ladingdrager');
+    ppc := nullif(e->>'plants_per_crate', '')::numeric;
+    cpl := nullif(e->>'crates_per_layer', '')::numeric;
+    lpc := nullif(e->>'layers_per_cart', '')::numeric;
+    fh := nullif(gj->'velden'->'fust_height_mm'->>'waarde', '')::numeric / 10.0;
+    ph := nullif(gj->'velden'->'plant_height_cm'->>'waarde', '')::numeric;
+    fl := nullif(gj->'velden'->'fust_length_mm'->>'waarde', '')::numeric / 10.0;
+    fb := nullif(gj->'velden'->'fust_width_mm'->>'waarde', '')::numeric / 10.0;
+    IF hv IS NOT NULL AND NOT coalesce((hv->>'aanwezig')::boolean, false) THEN mist := mist || 'belading niet ingesteld'::text; END IF;
+    IF coalesce(ppc, 0) <= 0 THEN mist := mist || 'planten per fust'::text; END IF;
+    IF coalesce(cpl, 0) <= 0 THEN mist := mist || 'fusten per laag'::text; END IF;
+    IF coalesce(lpc, 0) <= 0 THEN mist := mist || 'lagen per kar'::text; END IF;
+
+    IF c.code IS NULL THEN
+      mist := mist || coalesce(v_cfout, 'ladingdrager ontbreekt');
+      ls := public.logistics_max_fusten_per_laag_alle(fl, fb);
+      IF ls IS NOT NULL AND coalesce(cpl,0) > ls THEN
+        blok := blok || format('%s fust per laag, maar op geen enkele ladingdrager in Beheer passen er meer dan %s', cpl, ls);
+      END IF;
+    ELSE
+      ls := public.logistics_max_fusten_per_laag(c.layer_length_cm, c.layer_width_cm, fl, fb);
+      IF public.logistics_laag_tolerantie_tekst(c.layer_length_cm, c.layer_width_cm, fl, fb, cpl) IS NOT NULL THEN
+        waar := waar || public.logistics_laag_tolerantie_tekst(c.layer_length_cm, c.layer_width_cm, fl, fb, cpl);
+      END IF;
+      IF coalesce(lpc,0) > 0 AND coalesce(fh,0) > 0 AND coalesce(ph,0) > 0 AND coalesce(c.max_height_cm,0) > 0 THEN
+        laag := greatest(fh, ph);
+        IF lpc * laag > c.max_height_cm + 1e-9 AND ph >= fh AND coalesce(gj->'velden'->'plant_height_cm'->>'bron', '') ILIKE 'floricode%' THEN
+          waar := waar || format('planthoogte volgens Floricode; controleer: %s lagen × %s cm = %s cm, hoger dan %s (%s cm)',
+            lpc, trim_scale(round(laag,1)), trim_scale(round(lpc*laag,1)), naam, trim_scale(round(c.max_height_cm::numeric,1)));
+        ELSIF lpc * laag > c.max_height_cm + 1e-9 THEN
+          blok := blok || format('%s lagen × %s cm = %s cm, terwijl %s %s cm hoog is; er passen maximaal %s lagen',
+            lpc, trim_scale(round(laag,1)), trim_scale(round(lpc*laag,1)), naam, trim_scale(round(c.max_height_cm::numeric,1)), floor(c.max_height_cm / laag));
+        END IF;
+      ELSE
+        IF coalesce(fh,0) <= 0 THEN hmist := hmist || 'fusthoogte'::text; END IF;
+        IF coalesce(ph,0) <= 0 THEN hmist := hmist || 'planthoogte'::text; END IF;
+        IF coalesce(c.max_height_cm,0) <= 0 THEN hmist := hmist || ('hoogte van ' || naam); END IF;
+      END IF;
+      IF ls IS NOT NULL AND coalesce(cpl,0) > ls THEN
+        blok := blok || format('%s fust per laag, maar op een laag van %s passen er maximaal %s', cpl, naam, ls);
+      END IF;
+      IF coalesce(c.max_crates_per_layer,0) > 0 AND coalesce(cpl,0) > c.max_crates_per_layer THEN
+        blok := blok || format('%s fust per laag, maar %s staat maximaal %s fust per laag toe', cpl, naam, c.max_crates_per_layer);
+      END IF;
+      IF cardinality(blok) = 0 AND cardinality(hmist) > 0 AND coalesce(c.layers_per_carrier,0) > 0 AND coalesce(lpc,0) > c.layers_per_carrier THEN
+        waar := waar || format('%s lagen opgegeven, standaard %s; niet te controleren omdat de %s ontbreekt', lpc, c.layers_per_carrier, array_to_string(hmist, ', '));
+      END IF;
+    END IF;
+    IF coalesce(gj->'ontbrekend', '[]'::jsonb) ? 'weight' THEN waar := waar || 'gewicht per fust ontbreekt'::text; END IF;
+    IF cardinality(blok) > 0 THEN
+      v_oordeel := 'onmogelijk'; v_tekst := format('%s past niet op %s.', v_prod, CASE WHEN c.code IS NULL THEN 'een ladingdrager' ELSE naam END);
+    ELSIF cardinality(mist) > 0 THEN
+      v_oordeel := 'mist_gegevens'; v_tekst := format('%s: %s.', v_prod, array_to_string(mist, ', '));
+    ELSIF cardinality(waar) > 0 THEN
+      v_oordeel := 'waarschuwing'; v_tekst := format('%s: belading mogelijk, met waarschuwing.', v_prod);
+    ELSE
+      v_oordeel := 'compleet'; v_tekst := format('%s: belading past.', v_prod);
+    END IF;
+    uit := uit || jsonb_build_array(jsonb_build_object('product_id', v_pid, 'oordeel', v_oordeel, 'tekst', v_tekst,
+      'ladingdrager', rc->>'code', 'ladingdragerInvoer', rc->>'invoer', 'ladingdragerBron', rc->>'bron',
+      'regels', to_jsonb(ARRAY(SELECT upper(left(z,1)) || substr(z,2) || '.' FROM unnest(blok || mist || waar) z))));
+  END LOOP;
+  RETURN uit;
+END $function$;
+REVOKE ALL ON FUNCTION public.logistics_ladingdrager_resolve_plan(text) FROM authenticated;
+