@flowselections/logistiek-engine 1.0.214 → 1.0.219

package/db/schema/logistiek-engine.sql

@@ -36952,3 +36952,699 @@ RETURNS TABLE(punt text, ok boolean, uitleg text) LANGUAGE sql STABLE SECURITY D
   UNION ALL SELECT 'guard', to_regprocedure('public.logistics_acc_guard(text,text)') IS NOT NULL, 'Toegangscontrole aanwezig'
 $$;
 GRANT EXECUTE ON FUNCTION public.logistics_install_check_213() TO authenticated, service_role;
+
+-- ===== 1.0.215 =====
+
+CREATE OR REPLACE FUNCTION public.logistics_product_hoofdverpakking(p_product_id uuid)
+ RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE v_lc text; v_found boolean := false; v_heeft_lc boolean; v_n int; v_sid uuid; v_lijst text;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_product_hoofdverpakking');
+  IF to_regclass('public.product_packings') IS NULL THEN RETURN NULL; END IF;
+  SELECT EXISTS (SELECT 1 FROM pg_attribute WHERE attrelid = 'public.product_packings'::regclass AND attname = 'load_carrier' AND NOT attisdropped) INTO v_heeft_lc;
+  IF NOT v_heeft_lc THEN
+    EXECUTE 'SELECT true FROM public.product_packings WHERE product_id = $1 AND is_primary LIMIT 1' INTO v_found USING p_product_id;
+    RETURN jsonb_build_object('aanwezig', coalesce(v_found, false), 'ladingdrager', NULL, 'bron', CASE WHEN v_found THEN 'product' END);
+  END IF;
+  -- Stap 2: primaire verpakking van het product zelf.
+  EXECUTE 'SELECT true, nullif(btrim(load_carrier::text), '''') FROM public.product_packings WHERE product_id = $1 AND is_primary
+            ORDER BY sort_order NULLS LAST, created_at LIMIT 1' INTO v_found, v_lc USING p_product_id;
+  IF coalesce(v_found, false) AND v_lc IS NOT NULL THEN
+    RETURN jsonb_build_object('aanwezig', true, 'ladingdrager', v_lc, 'bron', 'product');
+  END IF;
+  -- Stap 3 (1.0.215): eigen artikel → voorraadartikel met products.floriday_trade_item_id = dit product-id.
+  IF EXISTS (SELECT 1 FROM pg_attribute WHERE attrelid = 'public.products'::regclass AND attname = 'floriday_trade_item_id' AND NOT attisdropped) THEN
+    EXECUTE $q$
+      SELECT count(DISTINCT x.lc), min(x.lc), (array_agg(x.pid ORDER BY x.pid))[1], string_agg(DISTINCT x.lc, ', ')
+        FROM (SELECT DISTINCT ON (s.id) s.id pid, nullif(btrim(pp.load_carrier::text), '') lc
+                FROM public.products s JOIN public.product_packings pp ON pp.product_id = s.id AND pp.is_primary
+               WHERE s.floriday_trade_item_id = $1::text AND s.id <> $1
+               ORDER BY s.id, pp.sort_order NULLS LAST, pp.created_at) x
+       WHERE x.lc IS NOT NULL$q$
+      INTO v_n, v_lc, v_sid, v_lijst USING p_product_id;
+    IF coalesce(v_n, 0) = 1 THEN
+      RETURN jsonb_build_object('aanwezig', true, 'ladingdrager', v_lc, 'bron', 'voorraadartikel', 'voorraadartikelId', v_sid);
+    ELSIF coalesce(v_n, 0) > 1 THEN
+      RETURN jsonb_build_object('aanwezig', false, 'ladingdrager', NULL, 'bron', 'voorraadartikel',
+        'fout', format('gekoppelde voorraadartikelen hebben verschillende ladingdragers (%s)', v_lijst));
+    END IF;
+  END IF;
+  RETURN jsonb_build_object('aanwezig', coalesce(v_found, false), 'ladingdrager', NULL, 'bron', CASE WHEN v_found THEN 'product' END);
+END $function$;
+GRANT EXECUTE ON FUNCTION public.logistics_product_hoofdverpakking(uuid) TO authenticated, service_role;
+
+-- Gedeelde keuze per planregel: regel → product → voorraadartikel → Floriday-verpakking → werkwijze (waarschuwing).
+-- p_regels: [{ "key": text, "regel_code": text|null, "product_id": uuid|null }], max 2000.
+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(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(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(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$;
+GRANT EXECUTE ON FUNCTION public.logistics_ladingdrager_kies(jsonb) TO authenticated, service_role;
+
+-- Kar die volgens de huidige regels anders zou worden ingedeeld (geen blokkade).
+CREATE OR REPLACE FUNCTION public.logistics_cart_regels_verouderd_core(p_cart_id uuid)
+ RETURNS jsonb LANGUAGE plpgsql STABLE SET search_path TO 'public'
+AS $function$
+DECLARE v_cart record; v_reg jsonb; k jsonb; v_codes text[]; v_naam text; v_max int; v_lagen numeric; v_lh numeric;
+BEGIN
+  IF p_cart_id IS NULL THEN RETURN NULL; END IF;
+  SELECT c.id, c.cart_number, c.carrier_type, c.total_layers_used INTO v_cart FROM public.order_carts c WHERE c.id = p_cart_id;
+  IF v_cart.id IS NULL THEN RETURN NULL; END IF;
+  IF nullif(v_cart.carrier_type, '') IS NULL OR v_cart.carrier_type IN ('loose', 'none', 'NONE') THEN
+    RETURN jsonb_build_object('reden', 'geen_ladingdrager', 'tekst', 'Kar staat zonder ladingdrager; een product zonder ladingdrager kan niet op een kar.');
+  END IF;
+  SELECT coalesce(jsonb_agg(jsonb_build_object('key', ci.id::text, 'regel_code', oi.load_carrier_type, 'product_id', coalesce(ci.product_id, oi.product_id))), '[]')
+    INTO v_reg
+    FROM public.order_cart_items ci LEFT JOIN public.order_items oi ON oi.id = ci.order_item_id
+   WHERE ci.cart_id = p_cart_id AND coalesce(ci.crates, 0) > 0;
+  IF jsonb_array_length(v_reg) > 0 THEN
+    k := public.logistics_ladingdrager_kies(v_reg);
+    SELECT array_agg(DISTINCT x.value->>'code') FILTER (WHERE x.value->>'code' IS NOT NULL AND x.value->>'bron' <> 'werkwijze')
+      INTO v_codes FROM jsonb_each(k) x;
+    IF coalesce(cardinality(v_codes), 0) > 0 AND NOT (v_cart.carrier_type = ANY(v_codes)) THEN
+      SELECT coalesce(t.name, t.code) INTO v_naam FROM public.load_carrier_types t WHERE t.code = v_codes[1] LIMIT 1;
+      RETURN jsonb_build_object('reden', 'andere_ladingdrager', 'ladingdrager', v_codes[1],
+        'tekst', format('Volgens het artikel hoort deze kar op %s, niet op %s.', coalesce(v_naam, v_codes[1]),
+          coalesce((SELECT coalesce(t.name, t.code) FROM public.load_carrier_types t WHERE t.code = v_cart.carrier_type LIMIT 1), v_cart.carrier_type)));
+    END IF;
+  END IF;
+  -- Fysieke hoogte: lagen × laaghoogte (max(fusthoogte, planthoogte)) boven de hoogte van de ladingdrager.
+  SELECT t.max_height_cm INTO v_max FROM public.load_carrier_types t WHERE t.code = v_cart.carrier_type ORDER BY t.is_active DESC LIMIT 1;
+  IF v_max IS NOT NULL AND v_max > 0 THEN
+    SELECT max(greatest(coalesce(m.fust_height_mm / 10.0, 0), coalesce(m.plant_height_cm, 0))) INTO v_lh
+      FROM public.logistics_product_maten((SELECT array_agg(DISTINCT ci.product_id) FROM public.order_cart_items ci
+                                            WHERE ci.cart_id = p_cart_id AND ci.product_id IS NOT NULL)) m
+     WHERE m.fust_height_mm IS NOT NULL AND m.plant_height_cm IS NOT NULL;
+    v_lagen := coalesce(v_cart.total_layers_used,
+      (SELECT sum(ci.crates::numeric / nullif(ci.crates_per_layer, 0)) FROM public.order_cart_items ci WHERE ci.cart_id = p_cart_id));
+    IF v_lh IS NOT NULL AND v_lh > 0 AND v_lagen IS NOT NULL
+       AND ceil(v_lagen - 0.001) > floor(v_max * (1 + public.logistics_laag_tolerantie()) / v_lh) THEN
+      RETURN jsonb_build_object('reden', 'te_veel_lagen', 'tekst',
+        format('%s lagen van %s cm passen niet in %s cm; maximaal %s lagen.', trim_scale(round(v_lagen, 1)), trim_scale(round(v_lh, 1)), v_max,
+               floor(v_max * (1 + public.logistics_laag_tolerantie()) / v_lh)));
+    END IF;
+  END IF;
+  RETURN NULL;
+END $function$;
+GRANT EXECUTE ON FUNCTION public.logistics_cart_regels_verouderd_core(uuid) TO service_role;
+
+-- ===== 1.0.215 =====
+
+CREATE OR REPLACE FUNCTION public.logistics_cart_verouderd_core(p_cart_id uuid)
+ RETURNS jsonb LANGUAGE plpgsql STABLE SET search_path TO 'public'
+AS $function$
+DECLARE v_nr text; v_n int; v_live int; v_afw text[]; v_r jsonb;
+BEGIN
+  IF p_cart_id IS NULL THEN RETURN NULL; END IF;
+  SELECT cart_number::text INTO v_nr FROM public.order_carts WHERE id = p_cart_id;
+  IF EXISTS (SELECT 1 FROM information_schema.columns WHERE table_schema = 'public' AND table_name = 'order_items' AND column_name = 'quarantined_at') THEN
+    SELECT count(*) INTO v_n FROM public.order_cart_items ci JOIN public.order_items oi ON oi.id = ci.order_item_id
+     WHERE ci.cart_id = p_cart_id AND oi.quarantined_at IS NOT NULL;
+    IF coalesce(v_n, 0) > 0 THEN
+      RETURN jsonb_build_object('verouderd', true, 'reden', 'quarantaine', 'regelsInQuarantaine', v_n,
+        'tekst', format('Kar %s heeft %s regel(s) in quarantaine.', coalesce(v_nr, '?'), v_n),
+        'blokkade', jsonb_build_object('code', 'kar_verouderd',
+          'tekst', format('Kar %s heeft %s regel(s) die Verkoop in quarantaine heeft gezet. Deel de niet-geprinte karren opnieuw in.', coalesce(v_nr, '?'), v_n)));
+    END IF;
+    SELECT count(*) INTO v_live FROM public.order_cart_items ci LEFT JOIN public.order_items oi ON oi.id = ci.order_item_id
+     WHERE ci.cart_id = p_cart_id AND coalesce(ci.crates, 0) > 0 AND oi.quarantined_at IS NULL;
+  ELSE
+    SELECT count(*) INTO v_live FROM public.order_cart_items ci WHERE ci.cart_id = p_cart_id AND coalesce(ci.crates, 0) > 0;
+  END IF;
+  IF coalesce(v_live, 0) = 0 THEN
+    RETURN jsonb_build_object('verouderd', true, 'reden', 'leeg', 'tekst', format('Kar %s heeft geen regels meer.', coalesce(v_nr, '?')),
+      'blokkade', jsonb_build_object('code', 'kar_leeg',
+        'tekst', format('Kar %s heeft geen regels meer. Deel de niet-geprinte karren opnieuw in.', coalesce(v_nr, '?'))));
+  END IF;
+  v_afw := public.logistics_cart_aantal_afwijking_core(p_cart_id);
+  IF coalesce(cardinality(v_afw), 0) > 0 THEN
+    RETURN jsonb_build_object('verouderd', true, 'reden', 'aantal', 'producten', to_jsonb(v_afw),
+      'tekst', format('De aantallen wijken af van de order (%s).', array_to_string(v_afw, ', ')),
+      'blokkade', jsonb_build_object('code', 'kar_verouderd',
+        'tekst', format('Kar %s: de aantallen wijken af van de order (%s). Deel de niet-geprinte karren opnieuw in.', coalesce(v_nr, '?'), array_to_string(v_afw, ', '))));
+  END IF;
+  -- 1.0.215: huidige regels zouden de kar anders indelen → alleen melden, geen blokkade.
+  v_r := public.logistics_cart_regels_verouderd_core(p_cart_id);
+  IF v_r IS NOT NULL THEN
+    RETURN jsonb_build_object('verouderd', true, 'reden', v_r->>'reden', 'tekst', v_r->>'tekst', 'blokkade', NULL);
+  END IF;
+  RETURN NULL;
+END $function$;
+GRANT EXECUTE ON FUNCTION public.logistics_cart_verouderd_core(uuid) TO service_role;
+
+DO $do$
+DECLARE d text; n text;
+BEGIN
+  d := pg_get_functiondef('public.logistics_cart_platen_verrijk(jsonb)'::regprocedure);
+  IF position('verouderdReden' IN d) = 0 THEN
+    n := replace(d,
+      $a$THEN jsonb_build_object('teHoog', false, 'indelingVerouderd', true, 'blokkade', public.logistics_cart_verouderd_core(v_id)->'blokkade')$a$,
+      $a$THEN jsonb_build_object('teHoog', false, 'indelingVerouderd', true, 'blokkade', public.logistics_cart_verouderd_core(v_id)->'blokkade',
+                 'verouderdReden', public.logistics_cart_verouderd_core(v_id)->>'tekst')$a$);
+    IF n = d THEN RAISE EXCEPTION 'patroon platen_verrijk niet gevonden'; END IF;
+    EXECUTE n;
+  END IF;
+END $do$;
+
+CREATE OR REPLACE FUNCTION public.logistics_install_check_215()
+RETURNS TABLE(punt text, ok boolean, uitleg text) LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+  SELECT 'hoofdverpakking via voorraadartikel', position('floriday_trade_item_id' IN pg_get_functiondef('public.logistics_product_hoofdverpakking(uuid)'::regprocedure)) > 0,
+         'Eigen artikel: belading van het voorraadartikel (products.floriday_trade_item_id)'
+  UNION ALL SELECT 'gedeelde ladingdragerkeuze', to_regprocedure('public.logistics_ladingdrager_kies(jsonb)') IS NOT NULL,
+         'Orderregel → artikel → voorraadartikel → Floriday-verpakking → werkwijze met waarschuwing'
+  UNION ALL SELECT 'kar verouderd volgens regels', position('logistics_cart_regels_verouderd_core' IN pg_get_functiondef('public.logistics_cart_verouderd_core(uuid)'::regprocedure)) > 0,
+         'Geen/andere ladingdrager of te veel lagen → verouderd: opnieuw indelen (geen blokkade)'
+  UNION ALL SELECT 'reden op kar', position('verouderdReden' IN pg_get_functiondef('public.logistics_cart_platen_verrijk(jsonb)'::regprocedure)) > 0, 'Reden zichtbaar per kar'
+  UNION ALL SELECT 'guard', position('logistics_acc_guard' IN pg_get_functiondef('public.logistics_ladingdrager_kies(jsonb)'::regprocedure)) > 0, 'Keuze controleert de aanroeper'
+$$;
+GRANT EXECUTE ON FUNCTION public.logistics_install_check_215() TO authenticated, service_role;
+
+-- ===================== 1.0.217 =====================
+
+-- Hulp: één ref → canoniek artikel (Voorraad), fouten als reden (geen stille keuze).
+CREATE OR REPLACE FUNCTION public.logistics_canon_ref(p_ref text)
+RETURNS TABLE(pid uuid, tkey text, reden text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $function$
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_canon_ref');
+  pid := NULL; tkey := NULL; reden := NULL;
+  IF p_ref IS NULL OR btrim(p_ref) = '' THEN reden := 'artikel onbekend'; RETURN NEXT; RETURN; END IF;
+  BEGIN
+    SELECT c.product_id, c.trade_item_key INTO pid, tkey FROM public.voorraad_canoniek_artikel(p_ref::text) c LIMIT 1;
+  EXCEPTION WHEN SQLSTATE 'VR010' THEN reden := SQLERRM;
+            WHEN others THEN reden := 'artikel niet te herleiden: ' || SQLERRM;
+  END;
+  IF reden IS NULL AND tkey IS NULL THEN reden := 'artikel onbekend'; END IF;
+  RETURN NEXT;
+END $function$;
+GRANT EXECUTE ON FUNCTION public.logistics_canon_ref(text) TO authenticated, service_role;
+
+-- 1. Voorraadcontrole nieuwe order: canoniek artikel (Voorraad) + trade_item_stock (fysiek − gereserveerd).
+CREATE OR REPLACE FUNCTION public.logistics_check_order_allowed(p_lines jsonb, p_strategy_id uuid DEFAULT NULL::uuid)
+ RETURNS jsonb
+ LANGUAGE plpgsql
+ STABLE SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_allow boolean := public.logistics_backorder_allowed(p_strategy_id);
+  v_canon boolean := to_regprocedure('public.voorraad_canoniek_artikel(text)') IS NOT NULL;
+  v_shortages jsonb := '[]'::jsonb;
+  r record;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_check_order_allowed');
+  IF p_lines IS NULL OR jsonb_typeof(p_lines) <> 'array' THEN
+    RETURN jsonb_build_object('allowed', true, 'allowBackorder', v_allow, 'shortages', '[]'::jsonb);
+  END IF;
+
+  IF NOT v_canon THEN
+    -- Terugval zonder Voorraad-module: oude regel, bron zichtbaar.
+    SELECT COALESCE(jsonb_agg(s ORDER BY s->>'product'), '[]'::jsonb) INTO v_shortages
+    FROM (
+      SELECT jsonb_build_object('productId', p.id, 'product', COALESCE(p.product, l2.ref),
+               'wanted', l2.wanted, 'available', COALESCE(p.quantity, 0),
+               'missing', l2.wanted - COALESCE(p.quantity, 0), 'bron', 'products.quantity') AS s
+      FROM (SELECT COALESCE(e->>'productId', e->>'product_id', e->>'productRef', e->>'ref') AS ref,
+                   SUM(COALESCE((e->>'quantity')::numeric, 0)) AS wanted
+              FROM jsonb_array_elements(p_lines) e GROUP BY 1) l2
+      LEFT JOIN LATERAL (SELECT * FROM public.products p
+                          WHERE p.id = public.logistics_try_uuid(l2.ref) OR p.article_number = l2.ref
+                             OR p.barcode = l2.ref OR p.floriday_trade_item_id = l2.ref OR p.trade_item_key = l2.ref
+                          ORDER BY (p.id = public.logistics_try_uuid(l2.ref)) DESC NULLS LAST LIMIT 1) p ON true
+      WHERE l2.wanted > COALESCE(p.quantity, 0)) q;
+  ELSE
+    FOR r IN
+      SELECT min(a.ref) AS ref, (array_agg(a.pid))[1] AS pid, a.tkey, min(a.reden) AS reden, SUM(a.wanted) AS wanted,
+             (SELECT GREATEST(COALESCE(SUM(s.physical_stock), 0) - COALESCE(SUM(s.reserved_stock), 0), 0)
+                FROM public.trade_item_stock s WHERE s.trade_item_key = a.tkey AND s.archived_at IS NULL) AS available
+        FROM (SELECT l2.ref, c.pid, c.tkey, c.reden, l2.wanted
+                FROM (SELECT COALESCE(e->>'productId', e->>'product_id', e->>'productRef', e->>'ref') AS ref,
+                             SUM(COALESCE((e->>'quantity')::numeric, 0)) AS wanted
+                        FROM jsonb_array_elements(p_lines) e GROUP BY 1) l2,
+                     LATERAL public.logistics_canon_ref(l2.ref) c) a GROUP BY a.tkey, CASE WHEN a.tkey IS NULL THEN a.ref END
+    LOOP
+      IF r.reden IS NOT NULL OR r.wanted > COALESCE(r.available, 0) THEN
+        v_shortages := v_shortages || jsonb_build_object(
+          'productId', r.pid,
+          'product', COALESCE((SELECT p.product FROM public.products p WHERE p.id = r.pid), r.ref),
+          'wanted', r.wanted,
+          'available', CASE WHEN r.reden IS NULL THEN COALESCE(r.available, 0) ELSE 0 END,
+          'missing', r.wanted - CASE WHEN r.reden IS NULL THEN COALESCE(r.available, 0) ELSE 0 END,
+          'tradeItemKey', r.tkey,
+          'bron', 'trade_item_stock (physical_stock − reserved_stock), canoniek artikel',
+          'reden', r.reden);
+      END IF;
+    END LOOP;
+  END IF;
+
+  RETURN jsonb_build_object(
+    'allowed', v_allow OR jsonb_array_length(v_shortages) = 0,
+    'allowBackorder', v_allow,
+    'shortages', v_shortages,
+    'bron', CASE WHEN v_canon THEN 'voorraad_canoniek_artikel' ELSE 'products.quantity (Voorraad-module ontbreekt)' END,
+    'reason', CASE WHEN NOT v_allow AND jsonb_array_length(v_shortages) > 0 THEN 'insufficient_stock' ELSE NULL END);
+END;
+$function$;
+
+-- 2. Reserveringssleutel: zelfde regel als Voorraad — voorraad_canoniek_artikel(ref::text).trade_item_key.
+CREATE OR REPLACE FUNCTION public.logistics_reserved_key(p_key text)
+ RETURNS text
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_raw text;
+  v_key text;
+  v_pid uuid;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_reserved_key');
+  IF p_key IS NULL OR btrim(p_key) = '' THEN RETURN NULL; END IF;
+  v_raw := btrim(p_key);
+
+  IF to_regprocedure('public.voorraad_canoniek_artikel(text)') IS NOT NULL THEN
+    BEGIN
+      SELECT c.trade_item_key INTO v_key FROM public.voorraad_canoniek_artikel(v_raw::text) c LIMIT 1;
+    EXCEPTION
+      WHEN SQLSTATE 'VR010' THEN RETURN NULL;   -- meerdere artikelen: niets kiezen (fail-closed)
+      WHEN others THEN v_key := NULL;
+    END;
+    IF v_key IS NOT NULL AND EXISTS (SELECT 1 FROM public.trade_item_stock s
+                                      WHERE s.trade_item_key = v_key AND s.archived_at IS NULL) THEN
+      RETURN v_key;
+    END IF;
+    v_key := NULL;
+  END IF;
+
+  -- Terugval: regel van vóór 1.0.217.
+  v_key := public.ensure_trade_item_stock_row_key(v_raw);
+  IF v_key IS NOT NULL THEN RETURN v_key; END IF;
+
+  BEGIN
+    v_pid := CASE WHEN v_raw LIKE 'product:%' THEN substring(v_raw from 9)::uuid ELSE v_raw::uuid END;
+  EXCEPTION WHEN others THEN
+    v_pid := NULL;
+  END;
+
+  IF v_pid IS NOT NULL THEN
+    SELECT COALESCE(NULLIF(btrim(COALESCE(p.floriday_trade_item_id, '')), ''),
+                    NULLIF(btrim(COALESCE(p.trade_item_key, '')), ''), p.id::text)
+      INTO v_key FROM public.products p WHERE p.id = v_pid LIMIT 1;
+  ELSE
+    SELECT COALESCE(NULLIF(btrim(COALESCE(p.floriday_trade_item_id, '')), ''),
+                    NULLIF(btrim(COALESCE(p.trade_item_key, '')), ''), p.id::text)
+      INTO v_key FROM public.products p
+     WHERE p.floriday_trade_item_id = v_raw OR p.trade_item_key = v_raw LIMIT 1;
+  END IF;
+  v_key := COALESCE(v_key, v_raw);
+
+  IF EXISTS (SELECT 1 FROM public.trade_item_stock s WHERE s.trade_item_key = v_key) THEN
+    RETURN v_key;
+  END IF;
+  RETURN NULL;
+END
+$function$;
+
+-- 3. Dagtelling: unieke fysieke karren per dag; orders zonder kar apart.
+CREATE OR REPLACE FUNCTION public.logistics_capacity_day_load(p_from date, p_to date, p_user uuid, p_settings jsonb)
+RETURNS TABLE(d date, carts integer, required numeric, zonder_kar integer)
+LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+  WITH t AS (
+    SELECT DISTINCT ON (t.order_ref) t.order_ref, (t.planned_start AT TIME ZONE public.logistics_tz())::date AS d
+      FROM public.logistics_tasks t
+     WHERE t.task_type = 'pick.execute' AND t.status NOT IN ('done','cancelled') AND NOT t.shadow
+       AND t.planned_start IS NOT NULL AND (p_user IS NULL OR t.user_id = p_user)
+       AND (t.planned_start AT TIME ZONE public.logistics_tz())::date BETWEEN p_from AND p_to
+     ORDER BY t.order_ref, t.planned_start
+  ),
+  o AS (SELECT t.d, t.order_ref, o.id FROM t JOIN public.orders o ON o.order_number = t.order_ref AND o.deleted_at IS NULL),
+  k AS (
+    SELECT DISTINCT ON (u.cart_id) u.cart_id, o.d
+      FROM o, LATERAL public.logistics_order_unit_carts_core(ARRAY[o.id]) u
+     ORDER BY u.cart_id, o.d
+  ),
+  kc AS (
+    SELECT k.d, count(*)::int AS carts,
+           SUM(public.logistics_carrier_minutes(COALESCE(c.carrier_type, 'trolley'), p_settings)) AS mins
+      FROM k JOIN public.order_carts c ON c.id = k.cart_id GROUP BY k.d
+  ),
+  zk AS (
+    SELECT t.d, count(*)::int AS n FROM t
+     WHERE NOT EXISTS (SELECT 1 FROM o JOIN LATERAL public.logistics_order_unit_carts_core(ARRAY[o.id]) u ON true
+                        WHERE o.order_ref = t.order_ref)
+     GROUP BY t.d
+  ),
+  dd AS (SELECT DISTINCT t.d FROM t)
+  SELECT dd.d, COALESCE(kc.carts, 0), COALESCE(NULLIF(kc.mins, 0), COALESCE(kc.carts, 0) * 15)::numeric, COALESCE(zk.n, 0)
+    FROM dd LEFT JOIN kc ON kc.d = dd.d LEFT JOIN zk ON zk.d = dd.d
+   ORDER BY dd.d;
+$$;
+GRANT EXECUTE ON FUNCTION public.logistics_capacity_day_load(date, date, uuid, jsonb) TO authenticated, service_role;
+
+DO $do$
+DECLARE d text; n text;
+BEGIN
+  d := pg_get_functiondef('public.logistics_capacity_day_check(date,date)'::regprocedure);
+  IF position('logistics_capacity_day_load' IN d) = 0 THEN
+    n := regexp_replace(d, 'FOR v_day IN\s+SELECT d,.*?ORDER BY d\s+LOOP',
+           'FOR v_day IN SELECT * FROM public.logistics_capacity_day_load(p_from, v_to, v_user, v_settings) LOOP', 's');
+    IF n = d THEN RAISE EXCEPTION 'patroon capacity_day_check (lus) niet gevonden'; END IF;
+    d := n;
+    n := replace(d, $a$'carts', v_day.carts,$a$, $a$'carts', v_day.carts,
+      'ordersZonderKar', v_day.zonder_kar,$a$);
+    IF n = d THEN RAISE EXCEPTION 'patroon capacity_day_check (carts) niet gevonden'; END IF;
+    EXECUTE n;
+  END IF;
+END $do$;
+
+CREATE OR REPLACE FUNCTION public.logistics_install_check_217()
+RETURNS TABLE(punt text, ok boolean, uitleg text) LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+  SELECT 'Voorraad canoniek artikel aanwezig', to_regprocedure('public.voorraad_canoniek_artikel(text)') IS NOT NULL,
+         'Zonder deze functie valt de Engine terug op de oude regel (bron zichtbaar in het antwoord)'
+  UNION ALL SELECT 'voorraadcontrole canoniek', position('voorraad_canoniek_artikel' IN pg_get_functiondef('public.logistics_check_order_allowed(jsonb,uuid)'::regprocedure)) > 0,
+         'Beschikbaar = physical_stock − reserved_stock (archived_at IS NULL) van de canonieke sleutel'
+  UNION ALL SELECT 'reserveringssleutel canoniek', position('voorraad_canoniek_artikel' IN pg_get_functiondef('public.logistics_reserved_key(text)'::regprocedure)) > 0,
+         'voorraad_canoniek_artikel(ref::text).trade_item_key, anders oude regel'
+  UNION ALL SELECT 'dagtelling unieke karren', position('logistics_capacity_day_load' IN pg_get_functiondef('public.logistics_capacity_day_check(date,date)'::regprocedure)) > 0,
+         'Gedeelde kar telt één keer; orders zonder kar apart (ordersZonderKar)'
+  UNION ALL SELECT 'guards', position('logistics_acc_guard' IN pg_get_functiondef('public.logistics_check_order_allowed(jsonb,uuid)'::regprocedure)) > 0
+                         AND position('logistics_acc_guard' IN pg_get_functiondef('public.logistics_reserved_key(text)'::regprocedure)) > 0,
+         'Aanroeper wordt intern gecontroleerd'
+$$;
+GRANT EXECUTE ON FUNCTION public.logistics_install_check_217() TO authenticated, service_role;
+
+
+-- ===== 1.0.218 =====
+-- ===== 1.0.218 eigen vervoer / klant haalt op =====
+DO $fs$ BEGIN
+  IF EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'orders_carrier_source_check')
+     AND position('eigen_vervoer' IN (SELECT pg_get_constraintdef(oid) FROM pg_constraint WHERE conname = 'orders_carrier_source_check' LIMIT 1)) = 0 THEN
+    ALTER TABLE public.orders DROP CONSTRAINT orders_carrier_source_check;
+  END IF;
+  IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'orders_carrier_source_check') THEN
+    ALTER TABLE public.orders ADD CONSTRAINT orders_carrier_source_check CHECK (carrier_source IS NULL OR carrier_source IN
+      ('handmatig','afleverlocatie','afleverlocatie_gln','klant','werkgebied','favoriet','geen','oud','eigen_vervoer')) NOT VALID;
+  END IF;
+END $fs$;
+
+CREATE OR REPLACE FUNCTION public.logistics_order_own_transport(p_custom_fields jsonb)
+ RETURNS boolean LANGUAGE sql IMMUTABLE SET search_path TO 'public'
+AS $function$
+  SELECT CASE jsonb_typeof(p_custom_fields->'own_transport')
+    WHEN 'object' THEN p_custom_fields->'own_transport' <> '{}'::jsonb
+    WHEN 'boolean' THEN (p_custom_fields->>'own_transport')::boolean
+    WHEN 'string' THEN coalesce(nullif(btrim(lower(p_custom_fields->>'own_transport')), ''), 'false') NOT IN ('false','0','nee','no')
+    WHEN 'number' THEN (p_custom_fields->>'own_transport')::numeric <> 0
+    WHEN 'array' THEN jsonb_array_length(p_custom_fields->'own_transport') > 0
+    ELSE false END
+$function$;
+GRANT EXECUTE ON FUNCTION public.logistics_order_own_transport(jsonb) TO authenticated, service_role;
+
+-- Soort vertrek van een order (orders-rij als jsonb): extern | eigen_vervoer | klant_haalt_op.
+CREATE OR REPLACE FUNCTION public.logistics_order_transport_group(p_order jsonb)
+ RETURNS text LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE cf jsonb := CASE WHEN jsonb_typeof(p_order->'custom_fields') = 'object' THEN p_order->'custom_fields' ELSE '{}'::jsonb END;
+  v_id uuid; v_kind text;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_order_transport_group');
+  IF public.logistics_order_own_transport(cf) THEN RETURN 'eigen_vervoer'; END IF;
+  v_id := public.logistics_try_uuid(p_order->>'carrier_id');
+  IF v_id IS NOT NULL THEN
+    SELECT to_jsonb(c)->>'carrier_kind' INTO v_kind FROM public.carriers c WHERE c.id = v_id;
+    IF v_kind IN ('eigen_vervoer', 'klant_haalt_op') THEN RETURN v_kind; END IF;
+    RETURN 'extern';
+  END IF;
+  -- Zonder vervoerder maar met een bron (afleverlocatie self_pickup) = klant haalt op.
+  IF coalesce(p_order->>'carrier_source', 'geen') NOT IN ('geen', 'eigen_vervoer') THEN RETURN 'klant_haalt_op'; END IF;
+  RETURN 'extern';
+END $function$;
+GRANT EXECUTE ON FUNCTION public.logistics_order_transport_group(jsonb) TO authenticated, service_role;
+
+-- Resolverstap eigen vervoer: NULL = niet van toepassing.
+CREATE OR REPLACE FUNCTION public.logistics_own_transport_carrier(p_order jsonb, p_skip_manual boolean)
+ RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE cf jsonb := CASE WHEN jsonb_typeof(p_order->'custom_fields') = 'object' THEN p_order->'custom_fields' ELSE '{}'::jsonb END;
+  v_id uuid; v_kind text; v_skips text[] := '{}'::text[]; v_ids uuid[]; v_reden text;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_own_transport_carrier');
+  IF NOT public.logistics_order_own_transport(cf) THEN RETURN NULL; END IF;
+  v_id := public.logistics_try_uuid(p_order->>'carrier_id');
+  IF v_id IS NOT NULL AND NOT p_skip_manual AND p_order->>'carrier_source' = 'handmatig' THEN
+    SELECT to_jsonb(c)->>'carrier_kind' INTO v_kind FROM public.carriers c WHERE c.id = v_id;
+    IF v_kind = 'eigen_vervoer' AND public.logistics_carrier_skip_reason(v_id) IS NULL THEN
+      RETURN public.logistics_carrier_result(v_id, 'handmatig', 'Handmatig gekozen: eigen vervoer.', v_skips);
+    END IF;
+    v_skips := v_skips || 'handmatige vervoerder is geen eigen vervoer'::text;
+  END IF;
+  SELECT array_agg(c.id ORDER BY c.id) INTO v_ids FROM public.carriers c
+   WHERE to_jsonb(c)->>'carrier_kind' = 'eigen_vervoer' AND nullif(to_jsonb(c)->>'archived_at', '') IS NULL;
+  IF coalesce(cardinality(v_ids), 0) = 1 THEN
+    RETURN public.logistics_carrier_result(v_ids[1], 'eigen_vervoer', 'Eigen vervoer op de order; vervoerder met soort eigen vervoer.', v_skips);
+  END IF;
+  v_reden := CASE WHEN coalesce(cardinality(v_ids), 0) = 0
+    THEN 'Eigen vervoer op de order, maar er is geen vervoerder met soort eigen vervoer. Er is geen andere vervoerder gekozen.'
+    ELSE 'Eigen vervoer op de order, maar er zijn ' || cardinality(v_ids) || ' vervoerders met soort eigen vervoer. Er is geen vervoerder gekozen.' END;
+  RETURN jsonb_build_object('carrier_id', NULL, 'carrier_name', 'Eigen vervoer', 'carrier_kind', 'eigen_vervoer',
+    'bron', 'geen', 'reden', v_reden, 'waarschuwing', v_reden, 'overgeslagen', to_jsonb(v_skips));
+END $function$;
+REVOKE ALL ON FUNCTION public.logistics_own_transport_carrier(jsonb, boolean) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_own_transport_carrier(jsonb, boolean) TO authenticated, service_role;
+
+-- Bestaande functies gericht aanvullen (luid falen als het patroon ontbreekt).
+DO $do$
+DECLARE d text; n text; f record; v_hit int := 0;
+BEGIN
+  -- resolver
+  d := pg_get_functiondef('public.logistics_resolve_carrier_core(jsonb,boolean)'::regprocedure);
+  IF position('logistics_own_transport_carrier' IN d) = 0 THEN
+    n := replace(d, $p$PERFORM public.logistics_acc_guard('server', 'logistics_resolve_carrier_core');$p$,
+      $p$PERFORM public.logistics_acc_guard('server', 'logistics_resolve_carrier_core');
+  IF public.logistics_own_transport_carrier(p_order, p_skip_manual) IS NOT NULL THEN
+    RETURN public.logistics_own_transport_carrier(p_order, p_skip_manual);
+  END IF;$p$);
+    IF n = d THEN RAISE EXCEPTION '1.0.218: patroon resolver niet gevonden'; END IF;
+    EXECUTE n;
+  END IF;
+  -- set_order_carrier: externe vervoerder bij eigen vervoer weigeren
+  d := pg_get_functiondef('public.logistics_set_order_carrier(uuid,uuid,uuid)'::regprocedure);
+  IF position('logistics_order_own_transport' IN d) = 0 THEN
+    n := replace(d, $p$    IF v_skip IS NOT NULL THEN RAISE EXCEPTION 'Deze vervoerder kan niet gekozen worden: %.', v_skip; END IF;$p$,
+      $p$    IF v_skip IS NOT NULL THEN RAISE EXCEPTION 'Deze vervoerder kan niet gekozen worden: %.', v_skip; END IF;
+    IF public.logistics_order_own_transport(o->'custom_fields')
+       AND coalesce((SELECT to_jsonb(ca)->>'carrier_kind' FROM public.carriers ca WHERE ca.id = p_carrier_id), '') <> 'eigen_vervoer' THEN
+      RAISE EXCEPTION 'Deze order heeft eigen vervoer; kies een vervoerder met soort eigen vervoer.' USING ERRCODE = '22023';
+    END IF;$p$);
+    IF n = d THEN RAISE EXCEPTION '1.0.218: patroon set_order_carrier niet gevonden'; END IF;
+    EXECUTE n;
+  END IF;
+  -- trigger: own_transport-wijziging herberekent, ook na handmatige externe keuze
+  d := pg_get_functiondef('public.logistics_orders_carrier_fill()'::regprocedure);
+  IF position('own_transport' IN d) = 0 THEN
+    n := replace(d, $p$    IF OLD.carrier_source = 'handmatig' THEN RETURN NEW; END IF;$p$,
+      $p$    IF OLD.carrier_source = 'handmatig'
+       AND (NEW.custom_fields->'own_transport') IS NOT DISTINCT FROM (OLD.custom_fields->'own_transport') THEN RETURN NEW; END IF;$p$);
+    n := replace(n, $p$       AND (NEW.custom_fields->>'carrier') IS NOT DISTINCT FROM (OLD.custom_fields->>'carrier') THEN$p$,
+      $p$       AND (NEW.custom_fields->>'carrier') IS NOT DISTINCT FROM (OLD.custom_fields->>'carrier')
+       AND (NEW.custom_fields->'own_transport') IS NOT DISTINCT FROM (OLD.custom_fields->'own_transport') THEN$p$);
+    IF position('own_transport' IN n) = 0 THEN RAISE EXCEPTION '1.0.218: patroon carrier_fill niet gevonden'; END IF;
+    EXECUTE n;
+  END IF;
+  -- bufferpayload: soort vertrek meegeven
+  d := pg_get_functiondef('public.logistics_buffer_payload(uuid)'::regprocedure);
+  IF position('transportGroup' IN d) = 0 THEN
+    n := replace(d, $p$'isReservation', COALESCE(o.is_reservation, false)$p$,
+      $p$'isReservation', COALESCE(o.is_reservation, false),
+      'transportGroup', public.logistics_order_transport_group(to_jsonb(o))$p$);
+    IF n = d THEN RAISE EXCEPTION '1.0.218: patroon buffer_payload niet gevonden'; END IF;
+    EXECUTE n;
+  END IF;
+  -- buffersleutel: niet-extern altijd apart (extern ongewijzigd = bestaande sleutels blijven gelijk)
+  FOR f IN SELECT p.oid FROM pg_proc p JOIN pg_namespace s ON s.oid = p.pronamespace
+            WHERE s.nspname = 'public' AND p.proname LIKE 'logistics_buffer_decision%' LOOP
+    d := pg_get_functiondef(f.oid);
+    IF position('v_parts := ARRAY(SELECT DISTINCT ON (p) p FROM unnest(v_parts)' IN d) > 0 THEN
+      v_hit := v_hit + 1;
+      IF position('transport_group' IN d) = 0 THEN
+        n := replace(d, $p$  v_parts := ARRAY(SELECT DISTINCT ON (p) p FROM unnest(v_parts)$p$,
+          $p$  IF coalesce(p_order ->> 'transportGroup', 'extern') IN ('eigen_vervoer', 'klant_haalt_op') THEN
+    v_parts := v_parts || ('vervoer=' || (p_order ->> 'transportGroup'));
+    v_trace := v_trace || jsonb_build_array(jsonb_build_object('rule', 'transport_group', 'value', p_order ->> 'transportGroup', 'result', true,
+      'message', CASE p_order ->> 'transportGroup' WHEN 'eigen_vervoer' THEN 'Eigen vervoer wordt alleen samen gebufferd met andere orders met eigen vervoer.'
+                 ELSE 'Klant haalt op wordt alleen samen gebufferd met andere orders die de klant ophaalt.' END));
+  END IF;
+  v_parts := ARRAY(SELECT DISTINCT ON (p) p FROM unnest(v_parts)$p$);
+        EXECUTE n;
+      END IF;
+    END IF;
+  END LOOP;
+  IF v_hit = 0 THEN RAISE EXCEPTION '1.0.218: buffersleutel niet gevonden'; END IF;
+  -- verouderd: gemengde soorten op één kar (alleen melding)
+  d := pg_get_functiondef('public.logistics_cart_verouderd_core(uuid)'::regprocedure);
+  IF position('logistics_cart_vervoer_gemengd' IN d) = 0 THEN
+    n := replace(d, $p$  v_r := public.logistics_cart_regels_verouderd_core(p_cart_id);$p$,
+      $p$  v_r := public.logistics_cart_vervoer_gemengd(p_cart_id);
+  IF v_r IS NOT NULL THEN
+    RETURN jsonb_build_object('verouderd', true, 'reden', 'vervoer_gemengd', 'tekst', v_r->>'tekst', 'blokkade', NULL);
+  END IF;
+  v_r := public.logistics_cart_regels_verouderd_core(p_cart_id);$p$);
+    IF n = d THEN RAISE EXCEPTION '1.0.218: patroon cart_verouderd_core niet gevonden'; END IF;
+    -- hulpfunctie eerst
+    EXECUTE $h$CREATE OR REPLACE FUNCTION public.logistics_cart_vervoer_gemengd(p_cart_id uuid)
+ RETURNS jsonb LANGUAGE sql STABLE SET search_path TO 'public'
+AS $f$
+  WITH k AS (SELECT oc.order_id, oc.buffer_id FROM public.order_carts oc WHERE oc.id = p_cart_id),
+  o AS (SELECT DISTINCT x.id, x.order_number, public.logistics_order_transport_group(to_jsonb(x)) g
+          FROM public.orders x, k
+         WHERE x.deleted_at IS NULL AND (x.id = k.order_id OR (k.buffer_id IS NOT NULL AND x.buffer_id = k.buffer_id)))
+  SELECT CASE WHEN count(DISTINCT g) > 1 THEN jsonb_build_object('soorten', jsonb_agg(DISTINCT g),
+    'tekst', 'Op deze kar staan verschillende soorten vertrek (' ||
+      string_agg(order_number || ': ' || CASE g WHEN 'eigen_vervoer' THEN 'eigen vervoer' WHEN 'klant_haalt_op' THEN 'klant haalt op' ELSE 'vervoerder' END, ', ' ORDER BY order_number)
+      || '); die worden niet samen gebufferd.') END
+  FROM o
+$f$$h$;
+    EXECUTE n;
+  END IF;
+END $do$;
+GRANT EXECUTE ON FUNCTION public.logistics_cart_vervoer_gemengd(uuid) TO service_role;
+
+-- Voorbeeldberekening: reden bij soort vertrek.
+CREATE OR REPLACE FUNCTION public.logistics_rebuffer_simulate_open()
+ RETURNS TABLE(id uuid, order_number text, delivery_date text, buffer_id uuid, cur_label text, new_label text, changed boolean, reason text)
+ LANGUAGE plpgsql
+ STABLE SECURITY DEFINER
+ SET search_path TO 'public'
+AS $function$
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_rebuffer_simulate_open');
+  RETURN QUERY
+  WITH c AS MATERIALIZED (
+    SELECT o.id, o.order_number, o.delivery_date, o.buffer_id, public.logistics_buffer_target(o.id) AS t,
+           public.logistics_order_afgemeld(o.id) AS afgemeld,
+           (o.buffer_id IS NOT NULL AND coalesce(public.logistics_buffer_frozen(o.buffer_id), false)) AS buf_vast,
+           public.logistics_order_transport_group(to_jsonb(o)) AS grp
+      FROM public.orders o JOIN public.logistics_rebuffer_candidates() k ON k.order_id = o.id
+  ), m AS (
+    SELECT c.*,
+      (c.afgemeld OR c.buf_vast) AS beschermd,
+      (SELECT array_agg(x.id ORDER BY x.id) FROM public.orders x WHERE c.buffer_id IS NOT NULL AND x.buffer_id = c.buffer_id AND x.deleted_at IS NULL AND x.id <> c.id) AS cur_mates,
+      (SELECT array_agg(x.id ORDER BY x.id) FROM public.orders x WHERE c.t->>'soort' = 'buffer' AND x.buffer_id = (c.t->>'bufferId')::uuid AND x.deleted_at IS NULL AND x.id <> c.id) AS new_mates,
+      EXISTS (SELECT 1 FROM public.orders x WHERE c.buffer_id IS NOT NULL AND x.buffer_id = c.buffer_id AND x.deleted_at IS NULL AND x.id <> c.id
+                AND public.logistics_order_transport_group(to_jsonb(x)) <> c.grp) AS gemengd
+      FROM c
+  ), l AS (
+    SELECT m.*,
+      CASE WHEN m.buffer_id IS NULL THEN 'Geen buffer (eigen kar)'
+           WHEN m.cur_mates IS NULL THEN 'Eigen buffer'
+           ELSE 'Buffer met ' || (SELECT string_agg(x.order_number, ', ' ORDER BY x.order_number) FROM public.orders x WHERE x.id = ANY(m.cur_mates)) END AS cur_l,
+      CASE m.grp WHEN 'eigen_vervoer' THEN 'eigen vervoer' WHEN 'klant_haalt_op' THEN 'klant haalt op' ELSE 'vervoerder' END AS grp_t
+      FROM m
+  )
+  SELECT l.id, l.order_number, l.delivery_date, l.buffer_id, l.cur_l,
+    CASE WHEN l.beschermd THEN l.cur_l
+         WHEN l.t->>'soort' IN ('solo','uitgesloten') THEN 'Geen buffer (eigen kar)'
+         WHEN l.new_mates IS NULL THEN 'Eigen buffer'
+         ELSE 'Buffer met ' || (SELECT string_agg(x.order_number, ', ' ORDER BY x.order_number) FROM public.orders x WHERE x.id = ANY(l.new_mates)) END,
+    CASE WHEN l.beschermd THEN false
+         ELSE coalesce(l.cur_mates, '{}') IS DISTINCT FROM coalesce(l.new_mates, '{}')
+           OR ((l.t->>'soort') IN ('solo','uitgesloten') AND l.buffer_id IS NOT NULL AND l.cur_mates IS NOT NULL) END,
+    CASE WHEN l.afgemeld THEN 'Ongewijzigd: de order is al verzonden of afgemeld; een bestaande buffer wordt niet gesplitst.'
+         WHEN l.buf_vast THEN 'Ongewijzigd: de buffer ligt al vast (geprint, gescand of verstuurd) en wordt niet gesplitst.'
+                              || CASE WHEN l.gemengd THEN ' Let op: in deze buffer staan verschillende soorten vertrek (deze order: ' || l.grp_t || ').' ELSE '' END
+         WHEN jsonb_array_length(coalesce(l.t->'overgeslagen','[]'::jsonb)) > 0
+           THEN 'Niet samengevoegd: buffer van ' || (SELECT string_agg(v, '; ') FROM jsonb_array_elements_text(l.t->'overgeslagen') v)
+                || ' ligt vast (geprint, gescand of verstuurd).'
+         WHEN l.t->>'soort' = 'uitgesloten' THEN 'Deze order is uitgesloten van combineren (handmatig uitgesloten van indeling).'
+         WHEN l.gemengd THEN 'Aparte kar: ' || l.grp_t || ' wordt niet samen gebufferd met orders met een ander soort vertrek (extern, eigen vervoer, klant haalt op).'
+         WHEN l.t->>'soort' = 'solo' THEN 'Volgens de huidige combineerregels krijgt deze order een eigen kar (' || coalesce(l.t->>'reason','onbekend') || ').'
+         WHEN l.grp <> 'extern' THEN 'Volgens de huidige combineerregels, alleen met orders met ' || l.grp_t || ' (' || coalesce(l.t->>'reason','onbekend') || ').'
+         ELSE 'Volgens de huidige combineerregels (' || coalesce(l.t->>'reason','onbekend') || ').' END
+  FROM l;
+END $function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_install_check_218()
+RETURNS TABLE(punt text, ok boolean, uitleg text) LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+  SELECT 'resolver eigen vervoer', position('logistics_own_transport_carrier' IN pg_get_functiondef('public.logistics_resolve_carrier_core(jsonb,boolean)'::regprocedure)) > 0,
+         'own_transport: vervoerder met soort eigen vervoer of geen; nooit favoriet/standaard'
+  UNION ALL SELECT 'bron eigen_vervoer toegestaan', position('eigen_vervoer' IN coalesce((SELECT pg_get_constraintdef(oid) FROM pg_constraint WHERE conname = 'orders_carrier_source_check' LIMIT 1), 'eigen_vervoer')) > 0,
+         'carrier_source mag eigen_vervoer zijn'
+  UNION ALL SELECT 'externe keuze geweigerd', position('logistics_order_own_transport' IN pg_get_functiondef('public.logistics_set_order_carrier(uuid,uuid,uuid)'::regprocedure)) > 0,
+         'logistics_set_order_carrier weigert externe vervoerder bij eigen vervoer'
+  UNION ALL SELECT 'trigger own_transport', position('own_transport' IN pg_get_functiondef('public.logistics_orders_carrier_fill()'::regprocedure)) > 0,
+         'Wijziging van own_transport herberekent de vervoerder'
+  UNION ALL SELECT 'buffersleutel soort vertrek', position('transportGroup' IN pg_get_functiondef('public.logistics_buffer_payload(uuid)'::regprocedure)) > 0
+     AND EXISTS (SELECT 1 FROM pg_proc p JOIN pg_namespace s ON s.oid = p.pronamespace WHERE s.nspname = 'public'
+                  AND p.proname LIKE 'logistics_buffer_decision%' AND position('transport_group' IN pg_get_functiondef(p.oid)) > 0),
+         'Extern, eigen vervoer en klant haalt op nooit samen gebufferd'
+  UNION ALL SELECT 'verouderd bij gemengd vervoer', position('logistics_cart_vervoer_gemengd' IN pg_get_functiondef('public.logistics_cart_verouderd_core(uuid)'::regprocedure)) > 0,
+         'Kar met verschillende soorten vertrek: verouderd: opnieuw indelen'
+  UNION ALL SELECT 'guards', position('logistics_acc_guard' IN pg_get_functiondef('public.logistics_own_transport_carrier(jsonb,boolean)'::regprocedure)) > 0
+     AND position('logistics_acc_guard' IN pg_get_functiondef('public.logistics_order_transport_group(jsonb)'::regprocedure)) > 0,
+         'Aanroeper wordt intern gecontroleerd'
+$$;
+GRANT EXECUTE ON FUNCTION public.logistics_install_check_218() TO authenticated, service_role;