@flowselections/logistiek-engine 1.0.219 → 1.0.224

package/db/schema/logistiek-engine.sql

@@ -37647,4 +37647,1328 @@ RETURNS TABLE(punt text, ok boolean, uitleg text) LANGUAGE sql STABLE SECURITY D
      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;
+GRANT EXECUTE ON FUNCTION public.logistics_install_check_218() TO authenticated, service_role;
+-- ===== 1.0.220 =====
+-- ===== 1.0.220 reden per verouderde kar, één buffertelling, eigen vervoer in Dagdetails =====
+
+-- Kar gemaakt voor een eerdere gecombineerde order (de order zit nu in een andere buffer). Alleen melding.
+CREATE OR REPLACE FUNCTION public.logistics_cart_eerdere_buffer(p_cart_id uuid)
+ RETURNS jsonb LANGUAGE sql STABLE SET search_path TO 'public'
+AS $function$
+  WITH k AS (SELECT c.id, c.order_id, c.buffer_id FROM public.order_carts c WHERE c.id = p_cart_id),
+  o AS (
+    SELECT x.order_number, x.buffer_id FROM k
+      JOIN public.order_cart_items ci ON ci.cart_id = k.id
+      JOIN public.order_items oi ON oi.id = ci.order_item_id
+      JOIN public.orders x ON x.id = oi.order_id
+     WHERE x.deleted_at IS NULL
+    UNION
+    SELECT x.order_number, x.buffer_id FROM k JOIN public.orders x ON x.id = k.order_id WHERE x.deleted_at IS NULL
+  ),
+  a AS (SELECT DISTINCT o.order_number FROM o, k
+         WHERE o.buffer_id IS DISTINCT FROM k.buffer_id AND (o.buffer_id IS NOT NULL OR k.order_id IS NULL))
+  SELECT CASE WHEN count(*) > 0 THEN jsonb_build_object('orders', jsonb_agg(order_number ORDER BY order_number),
+    'tekst', 'Deze kar is ingedeeld voor een eerdere gecombineerde order; '
+             || string_agg(order_number, ', ' ORDER BY order_number)
+             || CASE WHEN count(*) > 1 THEN ' zitten' ELSE ' zit' END || ' nu in een andere gecombineerde order.') END
+    FROM a
+$function$;
+
+-- Alle redenen waarom een kar verouderd is, in gewone taal, in vaste volgorde (eerste = hoofdreden).
+CREATE OR REPLACE FUNCTION public.logistics_cart_verouderd_redenen(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; v_out jsonb := '[]'::jsonb;
+BEGIN
+  IF p_cart_id IS NULL THEN RETURN v_out; END IF;
+  SELECT coalesce(cart_number::text, '?') INTO v_nr FROM public.order_carts WHERE id = p_cart_id;
+  IF NOT FOUND THEN RETURN v_out; END IF;
+  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
+      v_out := v_out || jsonb_build_array(jsonb_build_object('code', 'quarantaine',
+        'tekst', format('%s regel(s) op kar %s staan in quarantaine bij Verkoop.', v_n, v_nr),
+        'extra', jsonb_build_object('regelsInQuarantaine', 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.', 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 v_out || jsonb_build_array(jsonb_build_object('code', 'leeg',
+      'tekst', format('Kar %s heeft geen regels meer.', v_nr),
+      'blokkade', jsonb_build_object('code', 'kar_leeg',
+        'tekst', format('Kar %s heeft geen regels meer. Deel de niet-geprinte karren opnieuw in.', v_nr))));
+  END IF;
+  v_afw := public.logistics_cart_aantal_afwijking_core(p_cart_id);
+  IF coalesce(cardinality(v_afw), 0) > 0 THEN
+    v_out := v_out || jsonb_build_array(jsonb_build_object('code', 'aantal',
+      'tekst', format('De aantallen op de kar wijken af van de order (%s).', array_to_string(v_afw, ', ')),
+      'extra', jsonb_build_object('producten', to_jsonb(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.', v_nr, array_to_string(v_afw, ', ')))));
+  END IF;
+  v_r := public.logistics_cart_vervoer_gemengd(p_cart_id);
+  IF v_r IS NOT NULL THEN
+    v_out := v_out || jsonb_build_array(jsonb_build_object('code', 'vervoer_gemengd', 'tekst', v_r->>'tekst', 'blokkade', NULL));
+  END IF;
+  v_r := public.logistics_cart_eerdere_buffer(p_cart_id);
+  IF v_r IS NOT NULL THEN
+    v_out := v_out || jsonb_build_array(jsonb_build_object('code', 'eerdere_buffer', 'tekst', v_r->>'tekst', 'blokkade', NULL));
+  END IF;
+  v_r := public.logistics_cart_regels_verouderd_core(p_cart_id);
+  IF v_r IS NOT NULL THEN
+    v_out := v_out || jsonb_build_array(jsonb_build_object('code', v_r->>'reden', 'tekst', v_r->>'tekst', 'blokkade', NULL));
+  END IF;
+  RETURN v_out;
+END $function$;
+
+-- Hoofdreden blijft gelijk aan vóór 1.0.220 (zelfde volgorde: quarantaine, leeg, aantal,
+-- logistics_cart_vervoer_gemengd, regels); nieuw: eerdere buffer en de volledige lijst 'redenen'.
+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_lijst jsonb; v_r jsonb;
+BEGIN
+  IF p_cart_id IS NULL THEN RETURN NULL; END IF;
+  v_lijst := public.logistics_cart_verouderd_redenen(p_cart_id);
+  IF coalesce(jsonb_array_length(v_lijst), 0) = 0 THEN RETURN NULL; END IF;
+  v_r := v_lijst->0;
+  RETURN jsonb_build_object('verouderd', true, 'reden', v_r->>'code', 'tekst', v_r->>'tekst',
+           'blokkade', v_r->'blokkade',
+           'redenen', (SELECT jsonb_agg(e - 'extra' - 'blokkade') FROM jsonb_array_elements(v_lijst) e))
+         || coalesce(v_r->'extra', '{}'::jsonb);
+END $function$;
+
+-- Kaartgegevens krijgen naast verouderdReden ook de volledige lijst verouderdRedenen.
+DO $fs$
+DECLARE v_def text;
+BEGIN
+  v_def := pg_get_functiondef('public.logistics_cart_platen_verrijk'::regproc);
+  IF position('verouderdRedenen' IN v_def) = 0 THEN
+    IF position('''verouderdReden'', public.logistics_cart_verouderd_core(v_id)->>''tekst'')' IN v_def) = 0 THEN
+      RAISE EXCEPTION 'logistics_cart_platen_verrijk: verwachte tekst niet gevonden; niet aangepast';
+    END IF;
+    v_def := replace(v_def, '''verouderdReden'', public.logistics_cart_verouderd_core(v_id)->>''tekst'')',
+      '''verouderdReden'', public.logistics_cart_verouderd_core(v_id)->>''tekst'', ''verouderdRedenen'', public.logistics_cart_verouderd_core(v_id)->''redenen'')');
+    EXECUTE v_def;
+  END IF;
+END $fs$;
+
+-- Eén bron voor de karren van een gecombineerde order: kop, karindeling en pickdocumenten.
+CREATE OR REPLACE FUNCTION public.logistics_buffer_carts(p_buffer_id uuid)
+ RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE v_ids uuid[]; v_refs text[]; v_carts jsonb; v_types jsonb; v_dubbel jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_buffer_carts');
+  IF p_buffer_id IS NULL THEN RETURN NULL; END IF;
+  SELECT array_agg(o.id ORDER BY o.order_number), array_agg(o.order_number ORDER BY o.order_number) INTO v_ids, v_refs
+    FROM public.orders o
+   WHERE o.buffer_id = p_buffer_id AND o.deleted_at IS NULL AND o.cancelled_at IS NULL
+     AND coalesce(o.status, '') <> 'geannuleerd';
+  IF v_ids IS NULL THEN
+    RETURN jsonb_build_object('bufferId', p_buffer_id, 'orders', '[]'::jsonb, 'karren', 0, 'ladingdragers', '[]'::jsonb,
+                              'carts', '[]'::jsonb, 'dubbeleDocumenten', '[]'::jsonb);
+  END IF;
+  WITH u AS (SELECT * FROM public.logistics_order_unit_carts_core(v_ids)),
+  d AS (
+    SELECT DISTINCT ON (q.reference) q.reference, q.id, q.document_number, q.printed_at
+      FROM public.pick_queue q
+     WHERE q.cancelled_at IS NULL AND q.reference IN (SELECT u.cart_id::text FROM u)
+     ORDER BY q.reference, q.created_at DESC
+  )
+  SELECT coalesce(jsonb_agg(jsonb_build_object(
+           'cartId', u.cart_id, 'seq', u.display_seq, 'total', u.display_total,
+           'storedCartNumber', u.cart_number, 'cartBufferId', u.buffer_id, 'orderId', u.order_id,
+           'carrierType', c.carrier_type,
+           'ladingdrager', coalesce((SELECT coalesce(t.name, t.code) FROM public.load_carrier_types t WHERE t.code = c.carrier_type LIMIT 1), c.carrier_type),
+           'verouderd', v.v IS NOT NULL, 'verouderdReden', v.v->>'tekst', 'verouderdRedenen', coalesce(v.v->'redenen', '[]'::jsonb),
+           'pickDocument', CASE WHEN d.id IS NULL THEN NULL ELSE jsonb_build_object('id', d.id, 'documentNumber', d.document_number, 'printedAt', d.printed_at) END)
+           ORDER BY u.display_seq), '[]'::jsonb)
+    INTO v_carts
+    FROM u JOIN public.order_carts c ON c.id = u.cart_id
+    LEFT JOIN LATERAL (SELECT public.logistics_cart_verouderd_core(u.cart_id) AS v) v ON true
+    LEFT JOIN d ON d.reference = u.cart_id::text;
+
+  SELECT coalesce(jsonb_agg(jsonb_build_object('ladingdrager', x->>'ladingdrager', 'aantal', n) ORDER BY n DESC, x->>'ladingdrager'), '[]'::jsonb)
+    INTO v_types
+    FROM (SELECT jsonb_build_object('ladingdrager', e->>'ladingdrager') x, count(*) n FROM jsonb_array_elements(v_carts) e GROUP BY 1) s;
+
+  -- Open pickdocumenten van deze orders met hetzelfde nummer (alleen melden, niets wijzigen).
+  SELECT coalesce(jsonb_agg(jsonb_build_object('documentNumber', g.document_number, 'documenten', g.docs)), '[]'::jsonb)
+    INTO v_dubbel
+    FROM (SELECT q.document_number,
+                 jsonb_agg(jsonb_build_object('id', q.id, 'cartId', q.reference, 'aangemaakt', q.created_at,
+                   'hoortBijIndeling', EXISTS (SELECT 1 FROM jsonb_array_elements(v_carts) e WHERE e->>'cartId' = q.reference)) ORDER BY q.created_at) AS docs
+            FROM public.pick_queue q
+           WHERE q.cancelled_at IS NULL AND q.order_number = ANY(v_refs) AND q.document_number IS NOT NULL
+           GROUP BY q.document_number HAVING count(DISTINCT q.reference) > 1) g;
+
+  RETURN jsonb_build_object('bufferId', p_buffer_id, 'orders', to_jsonb(v_refs),
+    'karren', jsonb_array_length(v_carts), 'ladingdragers', v_types, 'carts', v_carts, 'dubbeleDocumenten', v_dubbel);
+END $function$;
+REVOKE ALL ON FUNCTION public.logistics_buffer_carts(uuid) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_buffer_carts(uuid) TO authenticated, service_role;
+
+-- buffer_cart_count telt exact dezelfde karren als logistics_buffer_carts (logistics_order_unit_carts_core).
+CREATE OR REPLACE FUNCTION public.logistics_order_plan_coverage_list(p_order_ids uuid[])
+ RETURNS TABLE(order_id uuid, order_number text, buffer_id uuid, state text, label text, progress_pct integer, reason text, cart_count integer, pick_row_count integer, pick_status text, picked_at timestamp with time zone, buffer_order_count integer, buffer_cart_count integer)
+ LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+  SELECT public.logistics_acc_guard('ingelogd', 'logistics_order_plan_coverage_list');
+  WITH b AS (SELECT * FROM public.logistics_order_plan_coverage_list_v152(p_order_ids)),
+  mem AS (
+    SELECT DISTINCT b.buffer_id AS buf, o.id AS oid FROM b
+      JOIN public.orders o ON o.buffer_id = b.buffer_id
+     WHERE b.buffer_id IS NOT NULL AND o.deleted_at IS NULL AND o.cancelled_at IS NULL AND coalesce(o.status,'') <> 'geannuleerd'
+  ),
+  bc AS (
+    SELECT m.buf, (SELECT count(*) FROM public.logistics_order_unit_carts_core(array_agg(m.oid)))::int AS n
+      FROM mem m GROUP BY m.buf
+  )
+  SELECT b.order_id, b.order_number, b.buffer_id,
+         CASE WHEN x.full_fulfilled THEN 'afgehandeld_extern' ELSE b.state END,
+         CASE WHEN x.full_fulfilled THEN 'Afgehandeld in Floriday' ELSE b.label END,
+         b.progress_pct,
+         CASE WHEN x.full_fulfilled THEN 'De order is in Floriday afgehandeld; de Engine plant en print er niets meer voor.' ELSE b.reason END,
+         b.cart_count, b.pick_row_count, b.pick_status, b.picked_at,
+         CASE WHEN b.buffer_id IS NULL THEN 1 ELSE greatest((SELECT count(*) FROM mem WHERE mem.buf = b.buffer_id)::int, 1) END,
+         CASE WHEN b.buffer_id IS NULL THEN b.cart_count ELSE coalesce((SELECT bc.n FROM bc WHERE bc.buf = b.buffer_id), 0) END
+    FROM b LEFT JOIN public.logistics_external_fulfillment x ON x.order_id = b.order_id
+$function$;
+
+-- Dagdag van een order: de pickdag, maar nooit later dan de leverdag. Een order waarvan de leverdag
+-- in het verleden is gezet (bijv. HO-2601467 op 28-10, gewijzigd op 29-10) blijft zo op zijn leverdag staan.
+CREATE OR REPLACE FUNCTION public.logistics_order_dag(p_planned_start timestamptz, p_delivery_date text)
+ RETURNS date LANGUAGE sql STABLE SET search_path TO 'public'
+AS $function$
+  SELECT CASE
+    WHEN p_delivery_date ~ '^\d{4}-\d{2}-\d{2}' AND p_planned_start IS NOT NULL
+      THEN least((p_planned_start AT TIME ZONE public.logistics_tz())::date, left(p_delivery_date, 10)::date)
+    WHEN p_planned_start IS NOT NULL THEN (p_planned_start AT TIME ZONE public.logistics_tz())::date
+    WHEN p_delivery_date ~ '^\d{4}-\d{2}-\d{2}' THEN left(p_delivery_date, 10)::date
+  END
+$function$;
+
+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 $function$
+  WITH t0 AS (
+    SELECT DISTINCT ON (t.order_ref) t.order_ref, t.planned_start
+      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 >= p_from
+     ORDER BY t.order_ref, t.planned_start
+  ),
+  t AS (
+    SELECT t0.order_ref, public.logistics_order_dag(t0.planned_start, o.delivery_date) AS d, o.id
+      FROM t0 JOIN public.orders o ON o.order_number = t0.order_ref AND o.deleted_at IS NULL
+  ),
+  o AS (SELECT t.d, t.order_ref, t.id FROM t WHERE t.d BETWEEN p_from AND p_to),
+  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 o.d, count(*)::int AS n FROM o
+     WHERE NOT EXISTS (SELECT 1 FROM public.logistics_order_unit_carts_core(ARRAY[o.id]) u)
+     GROUP BY o.d
+  ),
+  dd AS (SELECT DISTINCT o.d FROM o)
+  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;
+$function$;
+
+-- Alle open orders van één dag (ook eigen vervoer, klant haalt op en orders zonder kar), met reden.
+CREATE OR REPLACE FUNCTION public.logistics_capacity_day_orders(p_date date)
+ RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE v jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_capacity_day_orders');
+  IF p_date IS NULL THEN RETURN '[]'::jsonb; END IF;
+  WITH t AS (
+    SELECT DISTINCT ON (t.order_ref) t.order_ref, t.planned_start
+      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
+     ORDER BY t.order_ref, t.planned_start
+  ),
+  o AS (
+    SELECT x.*, t.planned_start, public.logistics_order_dag(t.planned_start, x.delivery_date) AS dag
+      FROM public.orders x LEFT JOIN t ON t.order_ref = x.order_number
+     WHERE x.deleted_at IS NULL AND x.cancelled_at IS NULL
+       AND lower(coalesce(x.status,'')) NOT IN ('cancelled','geannuleerd','deleted','verwijderd','afgehandeld','completed','delivered','geleverd')
+       AND (t.order_ref IS NOT NULL OR x.delivery_date ~ '^\d{4}-\d{2}-\d{2}')
+  ),
+  r AS (
+    SELECT o.*, (SELECT count(*) FROM public.logistics_order_unit_carts_core(ARRAY[o.id]))::int AS karren,
+           public.logistics_order_transport_group(to_jsonb(o)) AS grp
+      FROM o WHERE o.dag = p_date
+  )
+  SELECT coalesce(jsonb_agg(jsonb_build_object(
+           'orderId', r.id, 'orderNumber', r.order_number, 'bufferId', r.buffer_id,
+           'deliveryDate', left(r.delivery_date, 10), 'pickStart', r.planned_start,
+           'transportGroup', r.grp,
+           'vervoer', CASE r.grp WHEN 'eigen_vervoer' THEN 'Eigen vervoer (wij leveren)' WHEN 'klant_haalt_op' THEN 'Klant haalt op' ELSE 'Vervoerder' END,
+           'karren', r.karren, 'zonderKar', r.karren = 0,
+           'reden', CASE WHEN r.karren > 0 THEN NULL
+                         WHEN r.planned_start IS NULL THEN 'Nog niet ingepland: er staat geen picktaak voor deze order.'
+                         ELSE 'Ingepland, maar zonder kar: de karindeling ontbreekt. De bewaking deelt hem opnieuw in.' END)
+           ORDER BY r.buffer_id NULLS LAST, r.order_number), '[]'::jsonb)
+    INTO v FROM r;
+  RETURN v;
+END $function$;
+REVOKE ALL ON FUNCTION public.logistics_capacity_day_orders(date) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_capacity_day_orders(date) TO authenticated, service_role;
+
+-- Bewaking zonder kar: ook een open order waarvan de leverdag net in het verleden is gezet
+-- (max. 7 dagen terug en in de laatste 24 uur gewijzigd), zoals HO-2601467.
+CREATE OR REPLACE FUNCTION public.logistics_open_orders_zonder_kar()
+ RETURNS TABLE(order_id uuid, order_number text, delivery_date text, laatste_reden text)
+ LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+  SELECT public.logistics_acc_guard('ingelogd', 'logistics_open_orders_zonder_kar');
+  WITH lq AS (
+    SELECT DISTINCT ON (q.order_id) q.order_id, q.status, q.reason_code, q.error
+      FROM public.logistics_plan_queue q ORDER BY q.order_id, q.updated_at DESC
+  )
+  SELECT o.id, o.order_number, o.delivery_date, lq.error
+    FROM public.orders o
+    LEFT JOIN lq ON lq.order_id = o.id
+   WHERE o.deleted_at IS NULL AND o.cancelled_at IS NULL
+     AND lower(coalesce(o.status,'')) NOT IN ('cancelled','geannuleerd','deleted','verwijderd','afgehandeld','completed','delivered','geleverd')
+     AND o.delivery_date ~ '^\d{4}-\d{2}-\d{2}'
+     AND (left(o.delivery_date,10)::date >= public.logistics_local_today()
+          OR (left(o.delivery_date,10)::date >= public.logistics_local_today() - 7 AND o.updated_at > now() - interval '24 hours'))
+     AND EXISTS (SELECT 1 FROM public.order_items oi WHERE oi.order_id = o.id)
+     AND NOT coalesce(public.logistics_order_buffer_excluded(o.id), false)
+     AND NOT (coalesce(lq.status,'') IN ('geblokkeerd','pending','running'))
+     AND NOT (coalesce(lq.status,'') = 'gearchiveerd'
+              AND coalesce(lq.reason_code,'') IN ('belading_onwaarschijnlijk','belading_onvolledig','belading_onbekend','artikel_kiezen','ladingdrager_onbekend'))
+     AND NOT EXISTS (SELECT 1 FROM logistics_active.order_carts c WHERE c.order_id = o.id)
+     AND NOT EXISTS (SELECT 1 FROM public.order_items oi
+                       JOIN logistics_active.order_cart_items ci ON ci.order_item_id = oi.id
+                       JOIN logistics_active.order_carts c ON c.id = ci.cart_id
+                      WHERE oi.order_id = o.id);
+$function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_install_check_220()
+RETURNS TABLE(punt text, ok boolean, uitleg text) LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+  SELECT 'redenen per kar', position('logistics_cart_verouderd_redenen' IN pg_get_functiondef('public.logistics_cart_verouderd_core(uuid)'::regprocedure)) > 0,
+         'Verouderde kar geeft alle redenen in gewone taal'
+  UNION ALL SELECT 'kaart toont redenen', position('verouderdRedenen' IN pg_get_functiondef('public.logistics_cart_platen_verrijk'::regproc)) > 0,
+         'Kaartgegevens bevatten verouderdRedenen'
+  UNION ALL SELECT 'één buffertelling', position('logistics_order_unit_carts_core' IN pg_get_functiondef('public.logistics_order_plan_coverage_list(uuid[])'::regprocedure)) > 0
+     AND to_regprocedure('public.logistics_buffer_carts(uuid)') IS NOT NULL,
+         'Kop, karindeling en pickdocumenten uit dezelfde karren'
+  UNION ALL SELECT 'dagdag niet na leverdag', position('logistics_order_dag' IN pg_get_functiondef('public.logistics_capacity_day_load(date,date,uuid,jsonb)'::regprocedure)) > 0,
+         'Order staat op zijn pickdag, nooit later dan de leverdag'
+  UNION ALL SELECT 'dagorders', to_regprocedure('public.logistics_capacity_day_orders(date)') IS NOT NULL,
+         'Alle open orders van een dag, ook eigen vervoer en zonder kar'
+  UNION ALL SELECT 'bewaking recente datumwijziging', position('interval ''24 hours''' IN pg_get_functiondef('public.logistics_open_orders_zonder_kar()'::regprocedure)) > 0,
+         'Order met net in het verleden gezette leverdag wordt opnieuw ingedeeld'
+$$;
+GRANT EXECUTE ON FUNCTION public.logistics_install_check_220() TO authenticated, service_role;
+
+-- ===== 1.0.221 bevroren verdelingen, karren uit eerdere buffer, status geannuleerd =====
+
+-- ---------- 1+2. Bevroren verdeling ongeldig? (inactieve groep / niet-canonieke sleutel) ----------
+CREATE OR REPLACE FUNCTION public.logistics_allocation_stale_reden(p_order_item_id uuid)
+ RETURNS text LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE v_pid uuid; v_qty numeric; v_items text[]; v_groups uuid[]; v_err boolean; r record;
+BEGIN
+  IF p_order_item_id IS NULL THEN RETURN NULL; END IF;
+  SELECT oi.product_id, COALESCE(oi.quantity, 0)::numeric INTO v_pid, v_qty
+    FROM public.order_items oi WHERE oi.id = p_order_item_id;
+  IF v_pid IS NULL OR v_qty <= 0 THEN RETURN NULL; END IF;
+  IF NOT EXISTS (SELECT 1 FROM public.logistics_reservation_allocations a
+                  WHERE a.order_item_id = p_order_item_id AND a.source IN ('item', 'group')) THEN
+    RETURN NULL;
+  END IF;
+  SELECT array_agg(public.logistics_reserved_key(e.ref)) FILTER (WHERE e.kind = 'item'),
+         array_agg(e.ref::uuid) FILTER (WHERE e.kind = 'group'),
+         bool_or(e.kind = 'error')
+    INTO v_items, v_groups, v_err
+    FROM public.logistics_expand_line(v_pid, v_qty) e;
+  IF COALESCE(v_err, false) THEN RETURN NULL; END IF;
+  FOR r IN SELECT a.source, a.group_id, a.trade_item_key FROM public.logistics_reservation_allocations a
+            WHERE a.order_item_id = p_order_item_id AND a.source IN ('item', 'group') LOOP
+    IF r.source = 'group' THEN
+      IF r.group_id IS NULL OR NOT EXISTS (SELECT 1 FROM public.product_groups g WHERE g.id = r.group_id AND g.is_active) THEN
+        RETURN 'Verdeeld via een groep die niet meer actief is';
+      END IF;
+      IF NOT (r.group_id = ANY (COALESCE(v_groups, '{}'::uuid[]))) THEN
+        RETURN 'Verdeeld via een groep die niet meer bij dit artikel hoort';
+      END IF;
+      IF NOT EXISTS (SELECT 1 FROM public.product_group_items pgi
+                      WHERE pgi.product_group_id = r.group_id
+                        AND public.logistics_reserved_key(public.resolve_group_member_stock_key(pgi.trade_item_id)) = r.trade_item_key) THEN
+        RETURN 'Groepsregel wijst naar een voorraadregel die geen lid (meer) is';
+      END IF;
+    ELSE
+      IF NOT (r.trade_item_key = ANY (COALESCE(v_items, '{}'::text[]))) THEN
+        RETURN 'Sleutel is niet de canonieke voorraadregel van het artikel';
+      END IF;
+    END IF;
+  END LOOP;
+  RETURN NULL;
+END $function$;
+
+CREATE OR REPLACE FUNCTION public.logistics_allocation_stale(p_order_item_id uuid)
+ RETURNS boolean LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$ SELECT public.logistics_allocation_stale_reden(p_order_item_id) IS NOT NULL $function$;
+
+REVOKE ALL ON FUNCTION public.logistics_allocation_stale_reden(uuid) FROM PUBLIC, anon, authenticated;
+REVOKE ALL ON FUNCTION public.logistics_allocation_stale(uuid) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_allocation_stale_reden(uuid) TO service_role;
+GRANT EXECUTE ON FUNCTION public.logistics_allocation_stale(uuid) TO service_role;
+
+-- Bestaande (bevroren) verdeling alleen teruggeven als hij nog geldig is.
+CREATE OR REPLACE FUNCTION public.logistics_order_line_allocation(p_order_item_id uuid)
+ RETURNS TABLE(trade_item_key text, qty numeric, source text, group_id uuid, note text)
+ LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE
+  v_oi record; part record; member_rec record;
+  v_key text; v_last text; v_rem numeric; v_av numeric; v_take numeric; v_err text;
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_order_line_allocation');
+  IF p_order_item_id IS NULL THEN RETURN; END IF;
+
+  IF EXISTS (SELECT 1 FROM public.logistics_double_group_lines(
+               (SELECT oi.order_id FROM public.order_items oi WHERE oi.id = p_order_item_id)) d
+              WHERE d.order_item_id = p_order_item_id) THEN
+    RETURN;
+  END IF;
+
+  IF EXISTS (SELECT 1 FROM public.logistics_reservation_allocations a WHERE a.order_item_id = p_order_item_id)
+     AND NOT public.logistics_allocation_stale(p_order_item_id) THEN
+    RETURN QUERY
+      SELECT a.trade_item_key, a.qty, a.source, a.group_id, NULL::text
+        FROM public.logistics_reservation_allocations a
+       WHERE a.order_item_id = p_order_item_id
+       ORDER BY a.source, a.trade_item_key;
+    RETURN;
+  END IF;
+
+  SELECT oi.id, oi.product_id, COALESCE(oi.quantity, 0)::numeric AS quantity
+    INTO v_oi FROM public.order_items oi WHERE oi.id = p_order_item_id;
+  IF v_oi.id IS NULL OR v_oi.product_id IS NULL OR v_oi.quantity <= 0 THEN RETURN; END IF;
+
+  SELECT string_agg(e.note, '; ') INTO v_err
+    FROM public.logistics_expand_line(v_oi.product_id, v_oi.quantity) e WHERE e.kind = 'error';
+  IF v_err IS NOT NULL THEN
+    RETURN QUERY SELECT NULL::text, 0::numeric, 'error'::text, NULL::uuid, v_err;
+    RETURN;
+  END IF;
+
+  FOR part IN SELECT e.kind, e.ref, e.qty FROM public.logistics_expand_line(v_oi.product_id, v_oi.quantity) e LOOP
+    IF part.kind = 'item' THEN
+      v_key := public.logistics_reserved_key(part.ref);
+      IF v_key IS NULL THEN
+        RETURN QUERY SELECT part.ref, part.qty, 'error'::text, NULL::uuid, 'geen voorraadrij'::text;
+      ELSE
+        RETURN QUERY SELECT v_key, part.qty, 'item'::text, NULL::uuid, NULL::text;
+      END IF;
+    ELSE
+      v_rem := part.qty;
+      v_last := NULL;
+      FOR member_rec IN
+        SELECT public.resolve_group_member_stock_key(pgi.trade_item_id) AS raw_key
+          FROM public.product_group_items pgi
+         WHERE pgi.product_group_id = part.ref::uuid
+           AND public.resolve_group_member_stock_key(pgi.trade_item_id) IS NOT NULL
+           AND public.resolve_group_member_stock_key(pgi.trade_item_id) NOT LIKE 'group:%'
+         ORDER BY pgi.sort_order ASC NULLS LAST, pgi.created_at ASC, pgi.id ASC
+      LOOP
+        v_key := public.logistics_reserved_key(member_rec.raw_key);
+        IF v_key IS NULL THEN CONTINUE; END IF;
+        v_last := v_key;
+        IF v_rem <= 0 THEN CONTINUE; END IF;
+        SELECT GREATEST(COALESCE(MAX(s.physical_stock), 0)
+                        - COALESCE((SELECT SUM(a.qty) FROM public.logistics_reservation_allocations a
+                                     WHERE a.trade_item_key = v_key
+                                       AND a.order_item_id <> p_order_item_id), 0), 0)
+          INTO v_av
+          FROM public.trade_item_stock s WHERE s.trade_item_key = v_key;
+        IF COALESCE(v_av, 0) <= 0 THEN CONTINUE; END IF;
+        v_take := LEAST(v_av, v_rem);
+        RETURN QUERY SELECT v_key, v_take, 'group'::text, part.ref::uuid, NULL::text;
+        v_rem := v_rem - v_take;
+      END LOOP;
+      IF v_rem > 0 THEN
+        IF v_last IS NULL THEN
+          RETURN QUERY SELECT ('group:' || part.ref)::text, v_rem, 'error'::text, part.ref::uuid, 'groep zonder lid met voorraadrij'::text;
+        ELSE
+          RETURN QUERY SELECT v_last, v_rem, 'group'::text, part.ref::uuid, NULL::text;
+        END IF;
+      END IF;
+    END IF;
+  END LOOP;
+END
+$function$;
+
+-- Gerichte herberekening: een ongeldige bevroren verdeling telt niet als bevroren.
+DO $do$
+DECLARE d text; n text;
+BEGIN
+  d := pg_get_functiondef('public.logistics_recompute_reserved_targeted(uuid)'::regprocedure);
+  IF position('logistics_allocation_stale(o.order_item_id)' IN d) > 0 THEN RETURN; END IF;
+  n := replace(d, 'AND public.logistics_allocation_frozen(o.order_id)',
+                  'AND public.logistics_allocation_frozen(o.order_id) AND NOT public.logistics_allocation_stale(o.order_item_id)');
+  IF n = d THEN RAISE EXCEPTION '1.0.221: bevroren-stap in logistics_recompute_reserved_targeted niet gevonden'; END IF;
+  EXECUTE n;
+END $do$;
+
+-- Herstel: ongeldige bevroren verdelingen van open orders opnieuw maken (droog of uitvoeren).
+CREATE OR REPLACE FUNCTION public.logistics_reservation_repair_stale_core(p_uitvoeren boolean, p_order_item_ids uuid[])
+ RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE r record; v_old jsonb; v_new jsonb; v_regels jsonb := '[]'::jsonb; v_keys text[] := '{}'; v_n int := 0;
+BEGIN
+  FOR r IN
+    SELECT x.order_item_id, o.order_number, oi.quantity, oi.product_name AS artikel,
+           public.logistics_allocation_stale_reden(x.order_item_id) AS reden
+      FROM (SELECT DISTINCT a.order_item_id FROM public.logistics_reservation_allocations a
+             WHERE a.source IN ('item', 'group')
+               AND (p_order_item_ids IS NULL OR a.order_item_id = ANY (p_order_item_ids))) x
+      JOIN public.order_items oi ON oi.id = x.order_item_id
+      JOIN public.orders o ON o.id = oi.order_id
+     WHERE o.deleted_at IS NULL AND o.cancelled_at IS NULL
+       AND NOT public.logistics_order_is_shipped_status(o.status)
+       AND NOT EXISTS (SELECT 1 FROM public.stock_mutation_log sml
+                        WHERE sml.order_item_id = x.order_item_id AND sml.mutation_type = 'consumption')
+     ORDER BY o.order_number
+  LOOP
+    CONTINUE WHEN r.reden IS NULL;
+    v_n := v_n + 1;
+    SELECT jsonb_agg(jsonb_build_object('sleutel', a.trade_item_key, 'bron', a.source, 'groep', a.group_id, 'aantal', a.qty)
+                     ORDER BY a.source, a.trade_item_key)
+      INTO v_old FROM public.logistics_reservation_allocations a WHERE a.order_item_id = r.order_item_id;
+    SELECT jsonb_agg(jsonb_build_object('sleutel', n.trade_item_key, 'bron', n.source, 'groep', n.group_id, 'aantal', n.qty, 'melding', n.note))
+      INTO v_new FROM public.logistics_order_line_allocation(r.order_item_id) n;
+    v_regels := v_regels || jsonb_build_object('order', r.order_number, 'artikel', r.artikel, 'orderRegel', r.order_item_id,
+                  'besteld', r.quantity, 'reden', r.reden, 'nu', COALESCE(v_old, '[]'::jsonb), 'nieuw', COALESCE(v_new, '[]'::jsonb));
+    v_keys := v_keys
+      || ARRAY(SELECT e->>'sleutel' FROM jsonb_array_elements(COALESCE(v_old, '[]'::jsonb)) e WHERE e->>'sleutel' IS NOT NULL)
+      || ARRAY(SELECT e->>'sleutel' FROM jsonb_array_elements(COALESCE(v_new, '[]'::jsonb)) e WHERE e->>'sleutel' IS NOT NULL);
+    IF p_uitvoeren THEN
+      DELETE FROM public.logistics_reservation_allocations WHERE order_item_id = r.order_item_id;
+      INSERT INTO public.logistics_reservation_allocations (order_item_id, trade_item_key, qty, source, group_id, line_qty)
+      SELECT r.order_item_id, e->>'sleutel', (e->>'aantal')::numeric, e->>'bron', NULLIF(e->>'groep', '')::uuid, r.quantity
+        FROM jsonb_array_elements(COALESCE(v_new, '[]'::jsonb)) e
+       WHERE e->>'sleutel' IS NOT NULL;
+    END IF;
+  END LOOP;
+  RETURN jsonb_build_object('uitgevoerd', p_uitvoeren, 'aantalRegels', v_n,
+    'sleutels', (SELECT COALESCE(jsonb_agg(DISTINCT k ORDER BY k), '[]'::jsonb) FROM unnest(v_keys) k),
+    'regels', v_regels);
+END $function$;
+REVOKE ALL ON FUNCTION public.logistics_reservation_repair_stale_core(boolean, uuid[]) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_reservation_repair_stale_core(boolean, uuid[]) TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_reservation_repair_stale(p_uitvoeren boolean DEFAULT false)
+ RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+BEGIN
+  IF NOT (public.logistics_acc_is_server() OR public.logistics_is_beheer()) THEN
+    RAISE EXCEPTION 'Geen toegang: alleen beheer of de server mag verdelingen herstellen.' USING ERRCODE = '42501';
+  END IF;
+  RETURN public.logistics_reservation_repair_stale_core(COALESCE(p_uitvoeren, false), NULL);
+END $function$;
+REVOKE ALL ON FUNCTION public.logistics_reservation_repair_stale(boolean) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_reservation_repair_stale(boolean) TO authenticated, service_role;
+
+-- Groep op inactief: regels die via die groep verdeeld zijn direct opnieuw maken (nooit blokkeren).
+CREATE OR REPLACE FUNCTION public.logistics_group_inactive_repair_trg()
+ RETURNS trigger LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE v_ids uuid[];
+BEGIN
+  IF COALESCE(OLD.is_active, false) AND NOT COALESCE(NEW.is_active, false) THEN
+    SELECT array_agg(DISTINCT a.order_item_id) INTO v_ids
+      FROM public.logistics_reservation_allocations a WHERE a.group_id = NEW.id;
+    IF v_ids IS NOT NULL THEN
+      BEGIN
+        PERFORM public.logistics_reservation_repair_stale_core(true, v_ids);
+      EXCEPTION WHEN OTHERS THEN
+        RAISE WARNING 'Verdelingen van groep % niet direct hersteld: %', NEW.id, SQLERRM;
+      END;
+    END IF;
+  END IF;
+  RETURN NULL;
+END $function$;
+DROP TRIGGER IF EXISTS trg_logistics_group_inactive_repair ON public.product_groups;
+CREATE TRIGGER trg_logistics_group_inactive_repair AFTER UPDATE OF is_active ON public.product_groups
+  FOR EACH ROW EXECUTE FUNCTION public.logistics_group_inactive_repair_trg();
+
+-- ---------- 6. cancelled_at gevuld => status geannuleerd ----------
+INSERT INTO public.pick_document_statuses (code, name, color, sort_order, is_open, is_terminal, active)
+VALUES ('cancelled', 'Geannuleerd', '#ef4444', 90, false, true, true)
+ON CONFLICT (code) DO NOTHING;
+
+CREATE OR REPLACE FUNCTION public.logistics_pick_queue_cancel_status_trg()
+ RETURNS trigger LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE v_id uuid;
+BEGIN
+  IF NEW.cancelled_at IS NULL THEN RETURN NEW; END IF;
+  SELECT s.id INTO v_id FROM public.pick_document_statuses s WHERE s.code = 'cancelled';
+  IF v_id IS NULL THEN
+    RAISE EXCEPTION 'Pickdocumentstatus "cancelled" (Geannuleerd) ontbreekt; annuleren kan de status niet zetten.';
+  END IF;
+  IF NEW.status_id IS DISTINCT FROM v_id THEN NEW.status_id := v_id; END IF;
+  RETURN NEW;
+END $function$;
+DROP TRIGGER IF EXISTS trg_logistics_pick_queue_cancel_status ON public.pick_queue;
+CREATE TRIGGER trg_logistics_pick_queue_cancel_status BEFORE INSERT OR UPDATE OF cancelled_at, status_id ON public.pick_queue
+  FOR EACH ROW EXECUTE FUNCTION public.logistics_pick_queue_cancel_status_trg();
+
+CREATE OR REPLACE FUNCTION public.logistics_pick_queue_fix_cancelled_status(p_uitvoeren boolean DEFAULT false)
+ RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE v_id uuid; v_list jsonb; v_n int := 0;
+BEGIN
+  IF NOT (public.logistics_acc_is_server() OR public.logistics_is_beheer()) THEN
+    RAISE EXCEPTION 'Geen toegang: alleen beheer of de server mag pickdocumenten rechtzetten.' USING ERRCODE = '42501';
+  END IF;
+  SELECT s.id INTO v_id FROM public.pick_document_statuses s WHERE s.code = 'cancelled';
+  IF v_id IS NULL THEN RAISE EXCEPTION 'Pickdocumentstatus "cancelled" ontbreekt.'; END IF;
+  SELECT jsonb_agg(jsonb_build_object('id', q.id, 'document', q.document_number, 'order', q.order_number,
+           'statusNu', s.name, 'geannuleerdOp', q.cancelled_at) ORDER BY q.document_number, q.created_at)
+    INTO v_list
+    FROM public.pick_queue q LEFT JOIN public.pick_document_statuses s ON s.id = q.status_id
+   WHERE q.cancelled_at IS NOT NULL AND q.status_id IS DISTINCT FROM v_id;
+  IF p_uitvoeren THEN
+    UPDATE public.pick_queue SET status_id = v_id WHERE cancelled_at IS NOT NULL AND status_id IS DISTINCT FROM v_id;
+    GET DIAGNOSTICS v_n = ROW_COUNT;
+  END IF;
+  RETURN jsonb_build_object('uitgevoerd', COALESCE(p_uitvoeren, false), 'aantal', COALESCE(jsonb_array_length(v_list), 0),
+                            'rechtgezet', v_n, 'documenten', COALESCE(v_list, '[]'::jsonb));
+END $function$;
+REVOKE ALL ON FUNCTION public.logistics_pick_queue_fix_cancelled_status(boolean) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_pick_queue_fix_cancelled_status(boolean) TO authenticated, service_role;
+
+-- ---------- 5. Karren uit een eerdere buffer ----------
+CREATE OR REPLACE FUNCTION public.logistics_stale_buffer_carts(p_buffer uuid DEFAULT NULL)
+ RETURNS TABLE(cart_id uuid, karnummer integer, oude_buffer uuid, orders text, nieuwe_buffer text,
+               actieve_order boolean, geprint boolean, gescand boolean, afgerond boolean, besluit text)
+ LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+  WITH k AS (
+    SELECT c.id, c.cart_number, c.buffer_id, c.order_id FROM public.order_carts c
+     WHERE c.archived_at IS NULL AND c.buffer_id IS NOT NULL
+       AND (p_buffer IS NULL OR c.buffer_id = p_buffer)
+       AND NOT EXISTS (SELECT 1 FROM public.orders o WHERE o.buffer_id = c.buffer_id AND o.deleted_at IS NULL)
+  ), ko AS (
+    SELECT k.id AS cart_id, o.order_number, o.buffer_id, o.deleted_at, o.cancelled_at, o.status FROM k
+      JOIN public.order_cart_items ci ON ci.cart_id = k.id
+      JOIN public.order_items oi ON oi.id = ci.order_item_id
+      JOIN public.orders o ON o.id = oi.order_id
+    UNION
+    SELECT k.id, o.order_number, o.buffer_id, o.deleted_at, o.cancelled_at, o.status FROM k JOIN public.orders o ON o.id = k.order_id
+  ), f AS (
+    SELECT k.*,
+      (SELECT string_agg(DISTINCT ko.order_number, ', ') FROM ko WHERE ko.cart_id = k.id) AS orders,
+      (SELECT string_agg(DISTINCT COALESCE(ko.buffer_id::text, 'geen'), ', ') FROM ko WHERE ko.cart_id = k.id) AS nieuwe_buffer,
+      EXISTS (SELECT 1 FROM ko WHERE ko.cart_id = k.id AND ko.deleted_at IS NULL AND ko.cancelled_at IS NULL
+                AND NOT public.logistics_order_is_shipped_status(ko.status)) AS actief,
+      EXISTS (SELECT 1 FROM public.pick_queue q WHERE (q.reference = k.id::text OR q.payload->>'cartId' = k.id::text)
+                AND (q.printed_at IS NOT NULL OR COALESCE(q.print_count, 0) > 0)) AS geprint,
+      EXISTS (SELECT 1 FROM public.logistics_control_scan s WHERE s.cart_id = k.id
+                AND s.approved_at IS NOT NULL AND s.status <> 'geannuleerd') AS gescand,
+      EXISTS (SELECT 1 FROM public.pick_queue q WHERE (q.reference = k.id::text OR q.payload->>'cartId' = k.id::text)
+                AND q.completed_at IS NOT NULL) AS afgerond
+    FROM k
+  )
+  SELECT f.id, f.cart_number, f.buffer_id, f.orders, f.nieuwe_buffer, f.actief, f.geprint, f.gescand, f.afgerond,
+         CASE WHEN f.actief THEN 'actieve order, niet gearchiveerd'
+              WHEN f.gescand OR f.afgerond THEN 'gescand of afgerond, niet gearchiveerd'
+              WHEN f.geprint THEN 'geprint, niet gearchiveerd'
+              ELSE 'archiveren' END
+    FROM f ORDER BY f.buffer_id, f.cart_number;
+$function$;
+REVOKE ALL ON FUNCTION public.logistics_stale_buffer_carts(uuid) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_stale_buffer_carts(uuid) TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_archive_stale_buffer_carts_core(p_uitvoeren boolean, p_buffer uuid)
+ RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE v_list jsonb; v_ids uuid[]; v_n int := 0;
+  v_reden constant text := 'Kar hoorde bij een eerdere gecombineerde order; de order is opnieuw ingedeeld in een andere buffer.';
+BEGIN
+  SELECT jsonb_agg(to_jsonb(s)), array_agg(s.cart_id) FILTER (WHERE s.besluit = 'archiveren')
+    INTO v_list, v_ids FROM public.logistics_stale_buffer_carts(p_buffer) s;
+  IF p_uitvoeren AND v_ids IS NOT NULL THEN
+    UPDATE public.pick_queue q
+       SET cancelled_at = now(),
+           payload = COALESCE(q.payload, '{}'::jsonb) || jsonb_build_object('cancelReason', v_reden, 'cancelledBy', 'karplan')
+     WHERE q.cancelled_at IS NULL AND q.completed_at IS NULL
+       AND (q.reference = ANY (SELECT x::text FROM unnest(v_ids) x) OR q.payload->>'cartId' = ANY (SELECT x::text FROM unnest(v_ids) x));
+    INSERT INTO public.logistics_cart_archive_log (cart_id, action, reason, actor, snapshot)
+    SELECT c.id, 'archive', v_reden, NULL, to_jsonb(c) FROM public.order_carts c WHERE c.id = ANY (v_ids) AND c.archived_at IS NULL;
+    UPDATE public.order_carts SET archived_at = now(), archived_reason = v_reden
+     WHERE id = ANY (v_ids) AND archived_at IS NULL;
+    GET DIAGNOSTICS v_n = ROW_COUNT;
+  END IF;
+  RETURN jsonb_build_object('uitgevoerd', COALESCE(p_uitvoeren, false), 'gearchiveerd', v_n, 'karren', COALESCE(v_list, '[]'::jsonb));
+END $function$;
+REVOKE ALL ON FUNCTION public.logistics_archive_stale_buffer_carts_core(boolean, uuid) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_archive_stale_buffer_carts_core(boolean, uuid) TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_archive_stale_buffer_carts(p_uitvoeren boolean DEFAULT false)
+ RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+BEGIN
+  IF NOT (public.logistics_acc_is_server() OR public.logistics_is_beheer()) THEN
+    RAISE EXCEPTION 'Geen toegang: alleen beheer of de server mag karren archiveren.' USING ERRCODE = '42501';
+  END IF;
+  RETURN public.logistics_archive_stale_buffer_carts_core(COALESCE(p_uitvoeren, false), NULL);
+END $function$;
+REVOKE ALL ON FUNCTION public.logistics_archive_stale_buffer_carts(boolean) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_archive_stale_buffer_carts(boolean) TO authenticated, service_role;
+
+-- Herindelen: na wijziging van buffer of na leeghalen van karren de oude buffer opruimen.
+CREATE OR REPLACE FUNCTION public.logistics_orders_old_buffer_trg()
+ RETURNS trigger LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+BEGIN
+  IF OLD.buffer_id IS NOT NULL AND NEW.buffer_id IS DISTINCT FROM OLD.buffer_id THEN
+    PERFORM public.logistics_archive_stale_buffer_carts_core(true, OLD.buffer_id);
+  END IF;
+  RETURN NULL;
+END $function$;
+DROP TRIGGER IF EXISTS trg_logistics_orders_old_buffer ON public.orders;
+CREATE TRIGGER trg_logistics_orders_old_buffer AFTER UPDATE OF buffer_id ON public.orders
+  FOR EACH ROW EXECUTE FUNCTION public.logistics_orders_old_buffer_trg();
+
+CREATE OR REPLACE FUNCTION public.logistics_cart_items_old_buffer_trg()
+ RETURNS trigger LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+DECLARE b uuid;
+BEGIN
+  FOR b IN SELECT DISTINCT c.buffer_id FROM old_rows r JOIN public.order_carts c ON c.id = r.cart_id
+            WHERE c.buffer_id IS NOT NULL AND c.archived_at IS NULL
+              AND NOT EXISTS (SELECT 1 FROM public.orders o WHERE o.buffer_id = c.buffer_id AND o.deleted_at IS NULL) LOOP
+    PERFORM public.logistics_archive_stale_buffer_carts_core(true, b);
+  END LOOP;
+  RETURN NULL;
+END $function$;
+DROP TRIGGER IF EXISTS trg_logistics_cart_items_old_buffer ON public.order_cart_items;
+CREATE TRIGGER trg_logistics_cart_items_old_buffer AFTER DELETE ON public.order_cart_items
+  REFERENCING OLD TABLE AS old_rows FOR EACH STATEMENT EXECUTE FUNCTION public.logistics_cart_items_old_buffer_trg();
+
+-- ---------- Install-check ----------
+CREATE OR REPLACE FUNCTION public.logistics_install_check_221()
+RETURNS TABLE(punt text, ok boolean, uitleg text) LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+  SELECT 'status geannuleerd bestaat', EXISTS (SELECT 1 FROM public.pick_document_statuses WHERE code = 'cancelled'),
+         'Pickdocumentstatus cancelled (Geannuleerd) is aanwezig'
+  UNION ALL SELECT 'geannuleerd => status', EXISTS (SELECT 1 FROM pg_trigger WHERE tgname = 'trg_logistics_pick_queue_cancel_status' AND NOT tgisinternal),
+         'cancelled_at gevuld zet altijd status Geannuleerd'
+  UNION ALL SELECT 'bevroren verdeling gecontroleerd', position('logistics_allocation_stale' IN pg_get_functiondef('public.logistics_order_line_allocation(uuid)'::regprocedure)) > 0
+     AND position('logistics_allocation_stale' IN pg_get_functiondef('public.logistics_recompute_reserved_targeted(uuid)'::regprocedure)) > 0,
+         'Ongeldige bevroren verdeling (inactieve groep, niet-canonieke sleutel) wordt opnieuw gemaakt'
+  UNION ALL SELECT 'groep inactief herstelt verdeling', EXISTS (SELECT 1 FROM pg_trigger WHERE tgname = 'trg_logistics_group_inactive_repair'),
+         'Groep op inactief maakt verdelingen via die groep opnieuw'
+  UNION ALL SELECT 'karren eerdere buffer', EXISTS (SELECT 1 FROM pg_trigger WHERE tgname = 'trg_logistics_orders_old_buffer')
+     AND EXISTS (SELECT 1 FROM pg_trigger WHERE tgname = 'trg_logistics_cart_items_old_buffer'),
+         'Ongeprinte karren zonder actieve order uit een eerdere buffer worden gearchiveerd'
+$$;
+GRANT EXECUTE ON FUNCTION public.logistics_install_check_221() TO authenticated, service_role;
+
+REVOKE ALL ON FUNCTION public.logistics_group_inactive_repair_trg() FROM PUBLIC, anon, authenticated;
+REVOKE ALL ON FUNCTION public.logistics_pick_queue_cancel_status_trg() FROM PUBLIC, anon, authenticated;
+REVOKE ALL ON FUNCTION public.logistics_orders_old_buffer_trg() FROM PUBLIC, anon, authenticated;
+REVOKE ALL ON FUNCTION public.logistics_cart_items_old_buffer_trg() FROM PUBLIC, anon, authenticated;
+REVOKE ALL ON FUNCTION public.logistics_install_check_221() FROM PUBLIC, anon;
+
+
+-- ===== 1.0.222 = Pickvoortgang per order (alleen lezen) =====
+-- 1.0.222 Pickvoortgang per order (alleen lezen).
+CREATE OR REPLACE FUNCTION public.logistics_order_pick_progress(p_order_ids uuid[])
+RETURNS TABLE(order_uuid uuid, carts_total integer, carts_printed integer, carts_scanned integer,
+              first_printed_at timestamptz, last_scanned_at timestamptz, pick_date date,
+              blocked boolean, blocked_reason_plain text, carts_archived boolean)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_order_pick_progress');
+  IF cardinality(p_order_ids) > 500 THEN
+    RAISE EXCEPTION 'Maximaal 500 orders per aanroep (ontvangen: %).', cardinality(p_order_ids) USING ERRCODE = '22023';
+  END IF;
+  IF p_order_ids IS NULL OR cardinality(p_order_ids) = 0 THEN RETURN; END IF;
+
+  RETURN QUERY
+  WITH ids AS (
+    SELECT DISTINCT o.id, o.order_number FROM public.orders o
+     WHERE o.id = ANY (p_order_ids) AND o.deleted_at IS NULL
+  ),
+  -- Actieve karren: eigen kar of kar met een regel van de order (gedeelde kar telt bij elke order).
+  act AS (
+    SELECT i.id AS oid, c.id AS cid FROM ids i JOIN logistics_active.order_carts c ON c.order_id = i.id
+    UNION
+    SELECT i.id, ci.cart_id FROM ids i
+      JOIN logistics_active.order_items oi ON oi.order_id = i.id
+      JOIN logistics_active.order_cart_items ci ON ci.order_item_id = oi.id
+      JOIN logistics_active.order_carts c2 ON c2.id = ci.cart_id
+  ),
+  -- Geprinte, niet-geannuleerde pickdocumenten van de order, per kar.
+  doc AS (
+    SELECT i.id AS oid, x.cid, q.printed_at
+      FROM ids i
+      JOIN public.pick_queue q
+        ON q.cancelled_at IS NULL AND q.printed_at IS NOT NULL
+       AND (q.payload->>'orderId' = i.id::text
+            OR (jsonb_typeof(q.payload->'orderIds') = 'array' AND q.payload->'orderIds' ? i.id::text))
+      CROSS JOIN LATERAL (
+        SELECT public.logistics_try_uuid(q.payload->>'cartId') AS cid
+        UNION SELECT public.logistics_try_uuid(u) FROM jsonb_array_elements_text(CASE WHEN jsonb_typeof(q.printed_cart_ids) = 'array' THEN q.printed_cart_ids ELSE '[]'::jsonb END) u
+      ) x
+     WHERE x.cid IS NOT NULL
+  ),
+  -- Goedgekeurde, niet-geannuleerde scans (zelfde regel als logistics_cart_scanned).
+  scan AS (
+    SELECT i.id AS oid, s.cart_id AS cid, s.approved_at
+      FROM ids i JOIN public.logistics_control_scan s
+        ON s.approved_at IS NOT NULL AND s.status <> 'geannuleerd' AND s.cart_id IS NOT NULL
+       AND (s.order_id = i.id OR s.cart_id IN (SELECT a.cid FROM act a WHERE a.oid = i.id)
+            OR s.cart_id IN (SELECT d.cid FROM doc d WHERE d.oid = i.id))
+  ),
+  mode AS (
+    SELECT i.id AS oid, EXISTS (SELECT 1 FROM act a WHERE a.oid = i.id) AS heeft_actief FROM ids i
+  ),
+  karren AS (
+    SELECT a.oid, a.cid FROM act a
+    UNION
+    SELECT m.oid, d.cid FROM mode m JOIN doc d ON d.oid = m.oid WHERE NOT m.heeft_actief
+    UNION
+    SELECT m.oid, s.cid FROM mode m JOIN scan s ON s.oid = m.oid WHERE NOT m.heeft_actief
+  ),
+  telling AS (
+    SELECT k.oid,
+           count(DISTINCT k.cid)::int AS tot,
+           count(DISTINCT k.cid) FILTER (WHERE EXISTS (SELECT 1 FROM doc d WHERE d.oid = k.oid AND d.cid = k.cid))::int AS pr,
+           count(DISTINCT k.cid) FILTER (WHERE EXISTS (SELECT 1 FROM scan s WHERE s.oid = k.oid AND s.cid = k.cid))::int AS sc,
+           min(d1.printed_at) AS first_pr,
+           max(s1.approved_at) AS last_sc
+      FROM karren k
+      LEFT JOIN doc d1 ON d1.oid = k.oid AND d1.cid = k.cid
+      LEFT JOIN scan s1 ON s1.oid = k.oid AND s1.cid = k.cid
+     GROUP BY k.oid
+  ),
+  blok AS (
+    SELECT DISTINCT ON (q.order_id) q.order_id AS oid, q.reason
+      FROM public.logistics_plan_queue q JOIN ids i ON i.id = q.order_id
+     WHERE q.status = 'geblokkeerd'
+     ORDER BY q.order_id, q.updated_at DESC
+  ),
+  kand AS MATERIALIZED (
+    SELECT a.oid, a.cid FROM act a
+     WHERE NOT EXISTS (SELECT 1 FROM scan s WHERE s.cid = a.cid)   -- gescande kar is afgerond
+       AND NOT EXISTS (SELECT 1 FROM blok b WHERE b.oid = a.oid)   -- blokkade gaat al voor
+  ),
+  oud AS (
+    SELECT DISTINCT ON (k.oid) k.oid, v.j->>'tekst' AS tekst
+      FROM kand k CROSS JOIN LATERAL (SELECT public.logistics_cart_verouderd_core(k.cid) AS j) v
+     WHERE coalesce((v.j->>'verouderd')::boolean, false)
+     ORDER BY k.oid, k.cid
+  ),
+  taak AS (
+    SELECT DISTINCT ON (i.id) i.id AS oid,
+           ((coalesce(t.planned_start, t.created_at) AT TIME ZONE public.logistics_tz())::date) AS dag
+      FROM ids i JOIN public.logistics_tasks t
+        ON t.task_type = 'pick.execute' AND t.shadow IS NOT TRUE AND t.status NOT IN ('cancelled','superseded')
+       AND (t.payload->>'orderId' = i.id::text OR (nullif(t.payload->>'orderId','') IS NULL AND t.order_ref = i.order_number))
+     ORDER BY i.id, t.created_at DESC
+  )
+  SELECT i.id,
+         coalesce(t.tot, 0), coalesce(t.pr, 0), coalesce(t.sc, 0),
+         t.first_pr, t.last_sc,
+         coalesce(pd.pick_date, tk.dag),
+         (b.oid IS NOT NULL OR o.oid IS NOT NULL),
+         CASE
+           WHEN b.oid IS NOT NULL AND coalesce(t.tot, 0) = 0 THEN 'Geen kar: ' || coalesce(nullif(b.reason, ''), 'order is geblokkeerd')
+           WHEN b.oid IS NOT NULL THEN 'Geblokkeerd: ' || coalesce(nullif(b.reason, ''), 'order is geblokkeerd')
+           WHEN o.oid IS NOT NULL THEN 'Kar verouderd: opnieuw indelen' || coalesce(' — ' || nullif(o.tekst, ''), '')
+         END,
+         (NOT m.heeft_actief AND coalesce(t.tot, 0) > 0)
+    FROM ids i
+    JOIN mode m ON m.oid = i.id
+    LEFT JOIN telling t ON t.oid = i.id
+    LEFT JOIN blok b ON b.oid = i.id
+    LEFT JOIN oud o ON o.oid = i.id
+    LEFT JOIN taak tk ON tk.oid = i.id
+    LEFT JOIN public.logistics_order_pick_day pd ON pd.order_id = i.id;
+END $function$;
+
+REVOKE ALL ON FUNCTION public.logistics_order_pick_progress(uuid[]) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_order_pick_progress(uuid[]) TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_install_check_222()
+RETURNS TABLE(punt text, ok boolean, uitleg text) LANGUAGE sql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+  SELECT 'pickvoortgang per order',
+         to_regprocedure('public.logistics_order_pick_progress(uuid[])') IS NOT NULL,
+         'Leesfunctie logistics_order_pick_progress (max 500 orders) is aanwezig'
+$$;
+REVOKE ALL ON FUNCTION public.logistics_install_check_222() FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_install_check_222() TO service_role;
+
+-- ===== 1.0.223 = Snelle pickvoortgang: set-gebaseerde verouderd-controle (alleen lezen) =====
+-- bron: migratie 1.0.223
+CREATE OR REPLACE FUNCTION public.logistics_carts_verouderd_set(p_cart_ids uuid[])
+RETURNS TABLE(cart_id uuid, redenen jsonb)
+LANGUAGE sql STABLE SET search_path TO 'public'
+AS $function$
+  WITH c AS (
+    SELECT oc.id, coalesce(oc.cart_number::text, '?') nr, oc.order_id, oc.buffer_id, oc.carrier_type, oc.total_layers_used
+      FROM public.order_carts oc WHERE oc.id = ANY (p_cart_ids)
+  ),
+  ln AS MATERIALIZED (
+    SELECT ci.id ci_id, ci.cart_id cid, ci.order_item_id, ci.crates, ci.crates_per_layer, ci.product_id,
+           oi.id oi_id, oi.quarantined_at, oi.load_carrier_type, oi.product_id oi_pid
+      FROM public.order_cart_items ci JOIN c ON c.id = ci.cart_id
+      LEFT JOIN public.order_items oi ON oi.id = ci.order_item_id
+  ),
+  agg AS (
+    SELECT ln.cid,
+           count(*) FILTER (WHERE ln.oi_id IS NOT NULL AND ln.quarantined_at IS NOT NULL) qn,
+           count(*) FILTER (WHERE coalesce(ln.crates, 0) > 0 AND ln.quarantined_at IS NULL) live,
+           sum(ln.crates::numeric / nullif(ln.crates_per_layer, 0)) lagen_som
+      FROM ln GROUP BY ln.cid
+  ),
+  basis AS (
+    SELECT c.*, coalesce(g.qn, 0) qn, coalesce(g.live, 0) live, g.lagen_som
+      FROM c LEFT JOIN agg g ON g.cid = c.id
+  ),
+  items AS (SELECT DISTINCT ln.order_item_id FROM ln WHERE ln.order_item_id IS NOT NULL),
+  s AS (
+    SELECT oi.id, coalesce(oi.product_name, 'regel') naam, oi.quantity q, sum(ci.crates) fust,
+           max(ci.plants_per_crate) ppc, count(DISTINCT ci.product_id) nprod,
+           bool_or(ci.components IS NOT NULL AND ci.components::text NOT IN ('null','[]','{}')) comp
+      FROM items r JOIN public.order_items oi ON oi.id = r.order_item_id
+      JOIN public.order_cart_items ci ON ci.order_item_id = oi.id
+      JOIN public.order_carts oc ON oc.id = ci.cart_id AND oc.archived_at IS NULL
+     WHERE oi.quarantined_at IS NULL
+     GROUP BY oi.id, oi.product_name, oi.quantity
+  ),
+  afw AS (
+    SELECT x.cid, array_agg(s.naam ORDER BY s.naam) namen
+      FROM (SELECT DISTINCT ln.cid, ln.order_item_id FROM ln WHERE ln.order_item_id IS NOT NULL) x
+      JOIN s ON s.id = x.order_item_id
+     WHERE NOT s.comp AND s.nprod <= 1 AND s.q IS NOT NULL AND s.q > 0
+       AND s.fust <> s.q AND s.fust <> ceil(s.q::numeric / greatest(coalesce(s.ppc, 1), 1))
+     GROUP BY x.cid
+  ),
+  vo AS (
+    SELECT DISTINCT c.id cid, x.id, x.order_number, public.logistics_order_transport_group(to_jsonb(x)) g
+      FROM c JOIN public.orders x
+        ON x.deleted_at IS NULL AND (x.id = c.order_id OR (c.buffer_id IS NOT NULL AND x.buffer_id = c.buffer_id))
+  ),
+  verv AS (
+    SELECT vo.cid, 'Op deze kar staan verschillende soorten vertrek (' ||
+           string_agg(vo.order_number || ': ' || CASE vo.g WHEN 'eigen_vervoer' THEN 'eigen vervoer' WHEN 'klant_haalt_op' THEN 'klant haalt op' ELSE 'vervoerder' END, ', ' ORDER BY vo.order_number)
+           || '); die worden niet samen gebufferd.' tekst
+      FROM vo GROUP BY vo.cid HAVING count(DISTINCT vo.g) > 1
+  ),
+  eo AS (
+    SELECT ln.cid, x.order_number, x.buffer_id FROM ln
+      JOIN public.order_items oi ON oi.id = ln.order_item_id
+      JOIN public.orders x ON x.id = oi.order_id
+     WHERE x.deleted_at IS NULL
+    UNION
+    SELECT c.id, x.order_number, x.buffer_id FROM c JOIN public.orders x ON x.id = c.order_id WHERE x.deleted_at IS NULL
+  ),
+  ea AS (
+    SELECT DISTINCT eo.cid, eo.order_number FROM eo JOIN c ON c.id = eo.cid
+     WHERE eo.buffer_id IS DISTINCT FROM c.buffer_id AND (eo.buffer_id IS NOT NULL OR c.order_id IS NULL)
+  ),
+  eerd AS (
+    SELECT ea.cid, 'Deze kar is ingedeeld voor een eerdere gecombineerde order; '
+           || string_agg(ea.order_number, ', ' ORDER BY ea.order_number)
+           || CASE WHEN count(*) > 1 THEN ' zitten' ELSE ' zit' END || ' nu in een andere gecombineerde order.' tekst
+      FROM ea GROUP BY ea.cid
+  ),
+  -- Ladingdrager: de keuze hangt alleen af van (regelcode, product); elke combinatie één keer laten kiezen.
+  reg AS (
+    SELECT ln.cid, ln.load_carrier_type rc, coalesce(ln.product_id, ln.oi_pid) pid
+      FROM ln JOIN c ON c.id = ln.cid
+     WHERE coalesce(ln.crates, 0) > 0
+       AND NOT (nullif(c.carrier_type, '') IS NULL OR c.carrier_type IN ('loose', 'none', 'NONE'))
+  ),
+  regu AS (
+    SELECT u.rc, u.pid, row_number() OVER (ORDER BY u.rc NULLS FIRST, u.pid NULLS FIRST)::text sleutel
+      FROM (SELECT DISTINCT reg.rc, reg.pid FROM reg) u
+  ),
+  kies AS MATERIALIZED (
+    SELECT kv.key, kv.value
+      FROM (SELECT public.logistics_ladingdrager_kies(jsonb_agg(jsonb_build_object('key', regu.sleutel, 'regel_code', regu.rc, 'product_id', regu.pid))) k
+              FROM regu GROUP BY (regu.sleutel::bigint - 1) / 2000) b
+      CROSS JOIN LATERAL jsonb_each(b.k) kv
+  ),
+  codes AS (
+    SELECT reg.cid, min(kies.value->>'code') eerste,
+           array_agg(DISTINCT kies.value->>'code') lijst
+      FROM reg
+      JOIN regu ON regu.rc IS NOT DISTINCT FROM reg.rc AND regu.pid IS NOT DISTINCT FROM reg.pid
+      JOIN kies ON kies.key = regu.sleutel
+     WHERE kies.value->>'code' IS NOT NULL AND kies.value->>'bron' <> 'werkwijze'
+     GROUP BY reg.cid
+  ),
+  -- Hoogte: zelfde afleiding als logistics_product_maten (fusthoogte + planthoogte), artikelgegevens één keer per product.
+  pids AS (SELECT DISTINCT ln.product_id FROM ln WHERE ln.product_id IS NOT NULL),
+  fm AS MATERIALIZED (SELECT * FROM public.logistics_fust_maten() WHERE EXISTS (SELECT 1 FROM pids)),
+  pr AS MATERIALIZED (
+    SELECT p.id, p.fust_type_id AS hand_fid, p.plant_height_cm AS hand_h, public.logistics_artikel_vbn(p.id) AS a
+      FROM public.products p JOIN pids ON pids.product_id = p.id
+  ),
+  k2 AS (
+    SELECT pr.id, pr.hand_h, pr.a,
+      coalesce(pr.hand_fid,
+        (SELECT m.fust_type_id FROM fm m
+          WHERE (pr.a->>'vbn_package_code') ~ '^[0-9]+$'
+            AND (m.vbn_code = (pr.a->>'vbn_package_code')::int OR m.fust_key = 'vbn:' || (pr.a->>'vbn_package_code'))
+          ORDER BY ((m.length_mm IS NOT NULL)::int + (m.width_mm IS NOT NULL)::int + (m.height_mm IS NOT NULL)::int) DESC, m.fust_type_id
+          LIMIT 1),
+        (SELECT f.id FROM public.fust_types f
+          WHERE nullif(pr.a->>'custom_package_id', '') IS NOT NULL AND f.custom_package_id = pr.a->>'custom_package_id'
+          ORDER BY f.created_at, f.id LIMIT 1)) AS fid
+      FROM pr
+  ),
+  maten AS MATERIALIZED (
+    SELECT x.product_id, greatest(coalesce(x.fh / 10.0, 0), coalesce(x.ph, 0)) lh FROM (
+      SELECT k.id product_id,
+             coalesce(m.height_mm, (SELECT m2.height_mm FROM fm m2 WHERE m.fust_key IS NOT NULL AND m2.fust_key = m.fust_key AND m2.height_mm IS NOT NULL ORDER BY m2.fust_type_id LIMIT 1)) fh,
+             coalesce(public.logistics_pos_num(k.hand_h::text), public.logistics_pos_num(k.a->>'s15_cm'), public.logistics_pos_num(k.a->>'s02_cm')) ph
+        FROM k2 k LEFT JOIN fm m ON m.fust_type_id = k.fid) x
+     WHERE x.fh IS NOT NULL AND x.ph IS NOT NULL
+  ),
+  lhc AS (
+    SELECT x.cid, max(m.lh) lh FROM (SELECT DISTINCT ln.cid, ln.product_id FROM ln WHERE ln.product_id IS NOT NULL) x
+      JOIN maten m ON m.product_id = x.product_id GROUP BY x.cid
+  ),
+  hoog AS (
+    SELECT b.id cid,
+           (SELECT t.max_height_cm FROM public.load_carrier_types t WHERE t.code = b.carrier_type ORDER BY t.is_active DESC LIMIT 1) vmax,
+           l.lh, coalesce(b.total_layers_used, b.lagen_som) lagen
+      FROM basis b LEFT JOIN lhc l ON l.cid = b.id
+  ),
+  regels AS (
+    SELECT c.id cid,
+      CASE
+        WHEN nullif(c.carrier_type, '') IS NULL OR c.carrier_type IN ('loose', 'none', 'NONE') THEN
+          jsonb_build_object('code', 'geen_ladingdrager', 'tekst', 'Kar staat zonder ladingdrager; een product zonder ladingdrager kan niet op een kar.')
+        WHEN cd.cid IS NOT NULL AND NOT (c.carrier_type = ANY (cd.lijst)) THEN
+          jsonb_build_object('code', 'andere_ladingdrager', 'tekst',
+            format('Volgens het artikel hoort deze kar op %s, niet op %s.',
+              coalesce((SELECT coalesce(t.name, t.code) FROM public.load_carrier_types t WHERE t.code = cd.eerste LIMIT 1), cd.eerste),
+              coalesce((SELECT coalesce(t.name, t.code) FROM public.load_carrier_types t WHERE t.code = c.carrier_type LIMIT 1), c.carrier_type)))
+        WHEN h.vmax IS NOT NULL AND h.vmax > 0 AND h.lh IS NOT NULL AND h.lh > 0 AND h.lagen IS NOT NULL
+             AND ceil(h.lagen - 0.001) > floor(h.vmax * (1 + public.logistics_laag_tolerantie()) / h.lh) THEN
+          jsonb_build_object('code', 'te_veel_lagen', 'tekst',
+            format('%s lagen van %s cm passen niet in %s cm; maximaal %s lagen.', trim_scale(round(h.lagen, 1)), trim_scale(round(h.lh, 1)), h.vmax,
+                   floor(h.vmax * (1 + public.logistics_laag_tolerantie()) / h.lh)))
+      END r
+      FROM c LEFT JOIN codes cd ON cd.cid = c.id JOIN hoog h ON h.cid = c.id
+  ),
+  alles AS (
+    SELECT b.id,
+      CASE WHEN b.qn > 0 THEN jsonb_build_array(jsonb_build_object('code', 'quarantaine',
+             'tekst', format('%s regel(s) op kar %s staan in quarantaine bij Verkoop.', b.qn, b.nr))) ELSE '[]'::jsonb END
+      || CASE WHEN b.live = 0 THEN jsonb_build_array(jsonb_build_object('code', 'leeg', 'tekst', format('Kar %s heeft geen regels meer.', b.nr)))
+         ELSE
+              CASE WHEN coalesce(cardinality(a.namen), 0) > 0 THEN jsonb_build_array(jsonb_build_object('code', 'aantal',
+                     'tekst', format('De aantallen op de kar wijken af van de order (%s).', array_to_string(a.namen, ', ')))) ELSE '[]'::jsonb END
+           || CASE WHEN v.cid IS NOT NULL THEN jsonb_build_array(jsonb_build_object('code', 'vervoer_gemengd', 'tekst', v.tekst)) ELSE '[]'::jsonb END
+           || CASE WHEN e.cid IS NOT NULL THEN jsonb_build_array(jsonb_build_object('code', 'eerdere_buffer', 'tekst', e.tekst)) ELSE '[]'::jsonb END
+           || CASE WHEN r.r IS NOT NULL THEN jsonb_build_array(r.r) ELSE '[]'::jsonb END
+         END AS lijst
+      FROM basis b
+      LEFT JOIN afw a ON a.cid = b.id
+      LEFT JOIN verv v ON v.cid = b.id
+      LEFT JOIN eerd e ON e.cid = b.id
+      LEFT JOIN regels r ON r.cid = b.id
+  )
+  SELECT alles.id, alles.lijst FROM alles WHERE jsonb_array_length(alles.lijst) > 0
+$function$;
+REVOKE ALL ON FUNCTION public.logistics_carts_verouderd_set(uuid[]) FROM PUBLIC, anon, authenticated;
+GRANT EXECUTE ON FUNCTION public.logistics_carts_verouderd_set(uuid[]) TO service_role;
+
+-- 1.0.223 Pickvoortgang: set-gebaseerde verouderd-beoordeling.
+CREATE OR REPLACE FUNCTION public.logistics_order_pick_progress(p_order_ids uuid[])
+RETURNS TABLE(order_uuid uuid, carts_total integer, carts_printed integer, carts_scanned integer,
+              first_printed_at timestamptz, last_scanned_at timestamptz, pick_date date,
+              blocked boolean, blocked_reason_plain text, carts_archived boolean)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_order_pick_progress');
+  IF cardinality(p_order_ids) > 500 THEN
+    RAISE EXCEPTION 'Maximaal 500 orders per aanroep (ontvangen: %).', cardinality(p_order_ids) USING ERRCODE = '22023';
+  END IF;
+  IF p_order_ids IS NULL OR cardinality(p_order_ids) = 0 THEN RETURN; END IF;
+
+  RETURN QUERY
+  WITH ids AS (
+    SELECT DISTINCT o.id, o.order_number FROM public.orders o
+     WHERE o.id = ANY (p_order_ids) AND o.deleted_at IS NULL
+  ),
+  act AS (
+    SELECT i.id AS oid, c.id AS cid FROM ids i JOIN logistics_active.order_carts c ON c.order_id = i.id
+    UNION
+    SELECT i.id, ci.cart_id FROM ids i
+      JOIN logistics_active.order_items oi ON oi.order_id = i.id
+      JOIN logistics_active.order_cart_items ci ON ci.order_item_id = oi.id
+      JOIN logistics_active.order_carts c2 ON c2.id = ci.cart_id
+  ),
+  doc AS (
+    SELECT i.id AS oid, x.cid, q.printed_at
+      FROM ids i
+      JOIN public.pick_queue q
+        ON q.cancelled_at IS NULL AND q.printed_at IS NOT NULL
+       AND (q.payload->>'orderId' = i.id::text
+            OR (jsonb_typeof(q.payload->'orderIds') = 'array' AND q.payload->'orderIds' ? i.id::text))
+      CROSS JOIN LATERAL (
+        SELECT public.logistics_try_uuid(q.payload->>'cartId') AS cid
+        UNION SELECT public.logistics_try_uuid(u) FROM jsonb_array_elements_text(CASE WHEN jsonb_typeof(q.printed_cart_ids) = 'array' THEN q.printed_cart_ids ELSE '[]'::jsonb END) u
+      ) x
+     WHERE x.cid IS NOT NULL
+  ),
+  scan AS (
+    SELECT i.id AS oid, s.cart_id AS cid, s.approved_at
+      FROM ids i JOIN public.logistics_control_scan s
+        ON s.approved_at IS NOT NULL AND s.status <> 'geannuleerd' AND s.cart_id IS NOT NULL
+       AND (s.order_id = i.id OR s.cart_id IN (SELECT a.cid FROM act a WHERE a.oid = i.id)
+            OR s.cart_id IN (SELECT d.cid FROM doc d WHERE d.oid = i.id))
+  ),
+  mode AS (
+    SELECT i.id AS oid, EXISTS (SELECT 1 FROM act a WHERE a.oid = i.id) AS heeft_actief FROM ids i
+  ),
+  karren AS (
+    SELECT a.oid, a.cid FROM act a
+    UNION
+    SELECT m.oid, d.cid FROM mode m JOIN doc d ON d.oid = m.oid WHERE NOT m.heeft_actief
+    UNION
+    SELECT m.oid, s.cid FROM mode m JOIN scan s ON s.oid = m.oid WHERE NOT m.heeft_actief
+  ),
+  telling AS (
+    SELECT k.oid,
+           count(DISTINCT k.cid)::int AS tot,
+           count(DISTINCT k.cid) FILTER (WHERE EXISTS (SELECT 1 FROM doc d WHERE d.oid = k.oid AND d.cid = k.cid))::int AS pr,
+           count(DISTINCT k.cid) FILTER (WHERE EXISTS (SELECT 1 FROM scan s WHERE s.oid = k.oid AND s.cid = k.cid))::int AS sc,
+           min(d1.printed_at) AS first_pr,
+           max(s1.approved_at) AS last_sc
+      FROM karren k
+      LEFT JOIN doc d1 ON d1.oid = k.oid AND d1.cid = k.cid
+      LEFT JOIN scan s1 ON s1.oid = k.oid AND s1.cid = k.cid
+     GROUP BY k.oid
+  ),
+  blok AS (
+    SELECT DISTINCT ON (q.order_id) q.order_id AS oid, q.reason
+      FROM public.logistics_plan_queue q JOIN ids i ON i.id = q.order_id
+     WHERE q.status = 'geblokkeerd'
+     ORDER BY q.order_id, q.updated_at DESC
+  ),
+  kand AS MATERIALIZED (
+    SELECT a.oid, a.cid FROM act a
+     WHERE NOT EXISTS (SELECT 1 FROM scan s WHERE s.cid = a.cid)
+       AND NOT EXISTS (SELECT 1 FROM blok b WHERE b.oid = a.oid)
+  ),
+  oud AS (
+    SELECT DISTINCT ON (k.oid) k.oid, v.redenen->0->>'tekst' AS tekst
+      FROM kand k
+      JOIN public.logistics_carts_verouderd_set((SELECT array_agg(DISTINCT k2.cid) FROM kand k2)) v ON v.cart_id = k.cid
+     ORDER BY k.oid, k.cid
+  ),
+  taak AS (
+    SELECT DISTINCT ON (i.id) i.id AS oid,
+           ((coalesce(t.planned_start, t.created_at) AT TIME ZONE public.logistics_tz())::date) AS dag
+      FROM ids i JOIN public.logistics_tasks t
+        ON t.task_type = 'pick.execute' AND t.shadow IS NOT TRUE AND t.status NOT IN ('cancelled','superseded')
+       AND (t.payload->>'orderId' = i.id::text OR (nullif(t.payload->>'orderId','') IS NULL AND t.order_ref = i.order_number))
+     ORDER BY i.id, t.created_at DESC
+  )
+  SELECT i.id,
+         coalesce(t.tot, 0), coalesce(t.pr, 0), coalesce(t.sc, 0),
+         t.first_pr, t.last_sc,
+         coalesce(pd.pick_date, tk.dag),
+         (b.oid IS NOT NULL OR o.oid IS NOT NULL),
+         CASE
+           WHEN b.oid IS NOT NULL AND coalesce(t.tot, 0) = 0 THEN 'Geen kar: ' || coalesce(nullif(b.reason, ''), 'order is geblokkeerd')
+           WHEN b.oid IS NOT NULL THEN 'Geblokkeerd: ' || coalesce(nullif(b.reason, ''), 'order is geblokkeerd')
+           WHEN o.oid IS NOT NULL THEN 'Kar verouderd: opnieuw indelen' || coalesce(' — ' || nullif(o.tekst, ''), '')
+         END,
+         (NOT m.heeft_actief AND coalesce(t.tot, 0) > 0)
+    FROM ids i
+    JOIN mode m ON m.oid = i.id
+    LEFT JOIN telling t ON t.oid = i.id
+    LEFT JOIN blok b ON b.oid = i.id
+    LEFT JOIN oud o ON o.oid = i.id
+    LEFT JOIN taak tk ON tk.oid = i.id
+    LEFT JOIN public.logistics_order_pick_day pd ON pd.order_id = i.id;
+END $function$;
+-- bron: migratie 1.0.223
+CREATE INDEX IF NOT EXISTS logistics_control_scan_order_idx ON public.logistics_control_scan (order_id) WHERE order_id IS NOT NULL;
+CREATE INDEX IF NOT EXISTS pick_queue_printed_order_idx ON public.pick_queue ((payload->>'orderId')) WHERE cancelled_at IS NULL AND printed_at IS NOT NULL;
+CREATE INDEX IF NOT EXISTS pick_queue_printed_orderids_gin ON public.pick_queue USING gin ((payload->'orderIds')) WHERE cancelled_at IS NULL AND printed_at IS NOT NULL;
+CREATE INDEX IF NOT EXISTS logistics_tasks_pick_order_idx ON public.logistics_tasks ((payload->>'orderId')) WHERE task_type = 'pick.execute';
+CREATE INDEX IF NOT EXISTS logistics_tasks_pick_ref_idx ON public.logistics_tasks (order_ref) WHERE task_type = 'pick.execute';
+
+CREATE OR REPLACE FUNCTION public.logistics_order_pick_progress(p_order_ids uuid[])
+RETURNS TABLE(order_uuid uuid, carts_total integer, carts_printed integer, carts_scanned integer,
+              first_printed_at timestamptz, last_scanned_at timestamptz, pick_date date,
+              blocked boolean, blocked_reason_plain text, carts_archived boolean)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public'
+AS $function$
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_order_pick_progress');
+  IF cardinality(p_order_ids) > 500 THEN
+    RAISE EXCEPTION 'Maximaal 500 orders per aanroep (ontvangen: %).', cardinality(p_order_ids) USING ERRCODE = '22023';
+  END IF;
+  IF p_order_ids IS NULL OR cardinality(p_order_ids) = 0 THEN RETURN; END IF;
+
+  -- 1.0.223: zelfde regels als 1.0.222, set-gebaseerd en via indexen.
+  RETURN QUERY
+  WITH ids AS MATERIALIZED (
+    SELECT DISTINCT o.id, o.order_number FROM public.orders o
+     WHERE o.id = ANY (p_order_ids) AND o.deleted_at IS NULL
+  ),
+  -- Actieve karren; regels volgens logistics_active.order_items (geen quarantaine, niet extern afgehandeld), hier set-gebaseerd.
+  act AS MATERIALIZED (
+    SELECT i.id AS oid, c.id AS cid FROM ids i JOIN public.order_carts c ON c.order_id = i.id AND c.archived_at IS NULL
+    UNION
+    SELECT i.id, ci.cart_id FROM ids i
+      JOIN public.order_items oi ON oi.order_id = i.id AND oi.quarantined_at IS NULL
+      JOIN public.order_cart_items ci ON ci.order_item_id = oi.id
+      JOIN public.order_carts c2 ON c2.id = ci.cart_id AND c2.archived_at IS NULL
+     WHERE NOT EXISTS (SELECT 1 FROM public.logistics_external_fulfillment x
+                        WHERE x.order_id = oi.order_id
+                          AND (x.full_fulfilled OR lower(btrim(coalesce(oi.source_line_key, ''))) = ANY (x.sales_order_ids)))
+  ),
+  dq AS (
+    SELECT i.id AS oid, q.id AS qid FROM ids i JOIN public.pick_queue q
+      ON q.cancelled_at IS NULL AND q.printed_at IS NOT NULL AND q.payload->>'orderId' = i.id::text
+    UNION
+    SELECT i.id, q.id FROM ids i JOIN public.pick_queue q
+      ON q.cancelled_at IS NULL AND q.printed_at IS NOT NULL
+     AND jsonb_typeof(q.payload->'orderIds') = 'array' AND q.payload->'orderIds' ? i.id::text
+  ),
+  doc AS MATERIALIZED (
+    SELECT dq.oid, x.cid, q.printed_at
+      FROM dq JOIN public.pick_queue q ON q.id = dq.qid
+      CROSS JOIN LATERAL (
+        SELECT public.logistics_try_uuid(q.payload->>'cartId') AS cid
+        UNION SELECT public.logistics_try_uuid(u) FROM jsonb_array_elements_text(CASE WHEN jsonb_typeof(q.printed_cart_ids) = 'array' THEN q.printed_cart_ids ELSE '[]'::jsonb END) u
+      ) x
+     WHERE x.cid IS NOT NULL
+  ),
+  docs AS (SELECT doc.oid, doc.cid, min(doc.printed_at) AS pa FROM doc GROUP BY doc.oid, doc.cid),
+  scan AS MATERIALIZED (
+    SELECT i.id AS oid, s.id AS sid, s.cart_id AS cid, s.approved_at FROM ids i JOIN public.logistics_control_scan s
+      ON s.order_id = i.id AND s.approved_at IS NOT NULL AND s.status <> 'geannuleerd' AND s.cart_id IS NOT NULL
+    UNION
+    SELECT a.oid, s.id, s.cart_id, s.approved_at FROM act a JOIN public.logistics_control_scan s
+      ON s.cart_id = a.cid AND s.approved_at IS NOT NULL AND s.status <> 'geannuleerd'
+    UNION
+    SELECT d.oid, s.id, s.cart_id, s.approved_at FROM (SELECT DISTINCT doc.oid, doc.cid FROM doc) d JOIN public.logistics_control_scan s
+      ON s.cart_id = d.cid AND s.approved_at IS NOT NULL AND s.status <> 'geannuleerd'
+  ),
+  scans AS (SELECT scan.oid, scan.cid, max(scan.approved_at) AS sa FROM scan GROUP BY scan.oid, scan.cid),
+  mode AS (
+    SELECT i.id AS oid, (a.oid IS NOT NULL) AS heeft_actief
+      FROM ids i LEFT JOIN (SELECT DISTINCT act.oid FROM act) a ON a.oid = i.id
+  ),
+  karren AS (
+    SELECT a.oid, a.cid FROM act a
+    UNION
+    SELECT m.oid, d.cid FROM mode m JOIN docs d ON d.oid = m.oid WHERE NOT m.heeft_actief
+    UNION
+    SELECT m.oid, s.cid FROM mode m JOIN scans s ON s.oid = m.oid WHERE NOT m.heeft_actief
+  ),
+  telling AS (
+    SELECT k.oid, count(*)::int AS tot, count(d.cid)::int AS pr, count(s.cid)::int AS sc,
+           min(d.pa) AS first_pr, max(s.sa) AS last_sc
+      FROM karren k
+      LEFT JOIN docs d ON d.oid = k.oid AND d.cid = k.cid
+      LEFT JOIN scans s ON s.oid = k.oid AND s.cid = k.cid
+     GROUP BY k.oid
+  ),
+  blok AS (
+    SELECT DISTINCT ON (q.order_id) q.order_id AS oid, q.reason
+      FROM public.logistics_plan_queue q JOIN ids i ON i.id = q.order_id
+     WHERE q.status = 'geblokkeerd'
+     ORDER BY q.order_id, q.updated_at DESC
+  ),
+  kand AS MATERIALIZED (
+    SELECT a.oid, a.cid FROM act a
+     WHERE NOT EXISTS (SELECT 1 FROM scan s WHERE s.cid = a.cid)
+       AND NOT EXISTS (SELECT 1 FROM blok b WHERE b.oid = a.oid)
+  ),
+  oud AS (
+    SELECT DISTINCT ON (k.oid) k.oid, v.redenen->0->>'tekst' AS tekst
+      FROM kand k
+      JOIN public.logistics_carts_verouderd_set((SELECT array_agg(DISTINCT k2.cid) FROM kand k2)) v ON v.cart_id = k.cid
+     ORDER BY k.oid, k.cid
+  ),
+  tk0 AS (
+    SELECT i.id AS oid, t.created_at, t.planned_start FROM ids i JOIN public.logistics_tasks t
+      ON t.task_type = 'pick.execute' AND t.payload->>'orderId' = i.id::text
+     AND t.shadow IS NOT TRUE AND t.status NOT IN ('cancelled','superseded')
+    UNION ALL
+    SELECT i.id, t.created_at, t.planned_start FROM ids i JOIN public.logistics_tasks t
+      ON t.task_type = 'pick.execute' AND t.order_ref = i.order_number AND nullif(t.payload->>'orderId','') IS NULL
+     AND t.shadow IS NOT TRUE AND t.status NOT IN ('cancelled','superseded')
+  ),
+  taak AS (
+    SELECT DISTINCT ON (tk0.oid) tk0.oid,
+           ((coalesce(tk0.planned_start, tk0.created_at) AT TIME ZONE public.logistics_tz())::date) AS dag
+      FROM tk0 ORDER BY tk0.oid, tk0.created_at DESC
+  )
+  SELECT i.id,
+         coalesce(t.tot, 0), coalesce(t.pr, 0), coalesce(t.sc, 0),
+         t.first_pr, t.last_sc,
+         coalesce(pd.pick_date, tk.dag),
+         (b.oid IS NOT NULL OR o.oid IS NOT NULL),
+         CASE
+           WHEN b.oid IS NOT NULL AND coalesce(t.tot, 0) = 0 THEN 'Geen kar: ' || coalesce(nullif(b.reason, ''), 'order is geblokkeerd')
+           WHEN b.oid IS NOT NULL THEN 'Geblokkeerd: ' || coalesce(nullif(b.reason, ''), 'order is geblokkeerd')
+           WHEN o.oid IS NOT NULL THEN 'Kar verouderd: opnieuw indelen' || coalesce(' — ' || nullif(o.tekst, ''), '')
+         END,
+         (NOT m.heeft_actief AND coalesce(t.tot, 0) > 0)
+    FROM ids i
+    JOIN mode m ON m.oid = i.id
+    LEFT JOIN telling t ON t.oid = i.id
+    LEFT JOIN blok b ON b.oid = i.id
+    LEFT JOIN oud o ON o.oid = i.id
+    LEFT JOIN taak tk ON tk.oid = i.id
+    LEFT JOIN public.logistics_order_pick_day pd ON pd.order_id = i.id;
+END $function$;
+-- bron: migratie 1.0.223
+CREATE OR REPLACE FUNCTION public.logistics_install_check_223()
+RETURNS TABLE(punt text, ok boolean, uitleg text) LANGUAGE sql STABLE SET search_path TO 'public' AS $$
+  SELECT 'set-gebaseerde verouderd-controle',
+         to_regprocedure('public.logistics_carts_verouderd_set(uuid[])') IS NOT NULL,
+         'logistics_carts_verouderd_set is aanwezig (gebruikt door logistics_order_pick_progress)'
+  UNION ALL
+  SELECT 'indexen pickvoortgang',
+         (SELECT count(*) FROM pg_indexes WHERE schemaname = 'public' AND indexname IN
+           ('logistics_control_scan_order_idx','pick_queue_printed_order_idx','pick_queue_printed_orderids_gin',
+            'logistics_tasks_pick_order_idx','logistics_tasks_pick_ref_idx')) = 5,
+         'Vijf indexen voor documenten, scans en picktaken per order zijn aanwezig'
+$$;
+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;