@flowselections/logistiek-engine 1.0.195 → 1.0.200

package/db/schema/logistiek-engine.sql

@@ -13,6 +13,25 @@
 -- Gegenereerd uit de database; niet met de hand bewerken.
 -- ============================================================================
 
+-- 1.0.196: vroege definitie van de toegangscontrole, zodat SQL-functies verderop
+-- bij een eerste installatie (lege database) al kunnen verwijzen. Identiek aan de
+-- definitie verderop; die blijft leidend.
+CREATE OR REPLACE FUNCTION public.logistics_acc_guard(p_level text, p_fn text)
+ RETURNS void LANGUAGE plpgsql STABLE SET search_path TO 'public'
+AS $function$
+BEGIN
+  IF public.logistics_acc_is_server() THEN RETURN; END IF;
+  IF pg_trigger_depth() > 0 THEN RETURN; END IF;
+  IF NOT public.logistics_acc_direct(p_fn) THEN RETURN; END IF;
+  IF p_level = 'ingelogd' AND auth.uid() IS NOT NULL THEN RETURN; END IF;
+  IF p_level = 'beheer' AND auth.uid() IS NOT NULL AND public.logistics_is_beheer() THEN RETURN; END IF;
+  RAISE EXCEPTION '%', CASE p_level
+      WHEN 'server' THEN 'Geen toegang: ' || p_fn || ' is alleen voor de server.'
+      WHEN 'beheer' THEN 'Geen toegang: ' || p_fn || ' is alleen voor beheer.'
+      ELSE 'Geen toegang: log in om ' || p_fn || ' te gebruiken.' END
+    USING ERRCODE = '42501';
+END $function$;
+
 SET check_function_bodies = off;
 
 DO $fs$ BEGIN
@@ -26902,7 +26921,7 @@ BEGIN
        AND coalesce(o.order_source, '') <> 'floriday'
        AND o.deleted_at IS NULL AND o.cancelled_at IS NULL
        AND coalesce(o.status, '') <> 'geannuleerd'
-       AND o.delivery_date >= current_date - 1
+       AND public.logistics_order_date(o.delivery_date) >= current_date - 1
      GROUP BY o.id, o.order_number, o.customer_id, oi.product_id
      LIMIT greatest(1, p_limit)
   LOOP
@@ -26989,14 +27008,12 @@ $function$;
 -- 6. Pakbon van het pickstation: alleen de centrale beslisregel (geen layout uit payload of werkwijze).
 REVOKE EXECUTE ON FUNCTION public.logistics_own_sticker_sync(integer) FROM PUBLIC, anon, authenticated;
 GRANT EXECUTE ON FUNCTION public.logistics_own_sticker_sync(integer) TO service_role;
-REVOKE EXECUTE ON FUNCTION public.logistics_document_for_order(uuid, text) FROM PUBLIC, anon;
-GRANT EXECUTE ON FUNCTION public.logistics_document_for_order(uuid, text) TO authenticated, service_role;
+-- 1.0.197: rechten van logistics_document_for_order staan direct na de definitie (verderop).
 REVOKE EXECUTE ON FUNCTION public.logistics_document_selection_status() FROM PUBLIC, anon;
 GRANT EXECUTE ON FUNCTION public.logistics_document_selection_status() TO authenticated, service_role;
 
 -- Veiligheid: draaien met de rechten van de aanroeper.
 ALTER FUNCTION public.logistics_document_selection_status() SECURITY INVOKER;
-ALTER FUNCTION public.logistics_document_for_order(uuid, text) SECURITY INVOKER;
 
 -- ===== 1.0.176 reserveringen FO + pakbon centrale keuze =====
 -- 1.0.176: reserveringen (Voorraad 1.0.93) en pakbon via centrale documentkeuze (Pickschermen 1.0.56).
@@ -27813,13 +27830,19 @@ BEGIN
     'documenttype', v_type, 'breedte_mm', v_l.breedte_mm, 'hoogte_mm', v_l.hoogte_mm, 'reden', NULL) || v_extra;
 END;
 $function$;
+-- 1.0.197: rechten na de definitie (een nieuwe Shell kent de functie hiervoor nog niet).
+REVOKE EXECUTE ON FUNCTION public.logistics_document_for_order(uuid, text) FROM PUBLIC, anon;
+GRANT EXECUTE ON FUNCTION public.logistics_document_for_order(uuid, text) TO authenticated, service_role;
+ALTER FUNCTION public.logistics_document_for_order(uuid, text) SECURITY INVOKER;
 
 
 -- ===== 1.0.178: fusten en land per kar, eigen traystickers =====
 -- 1.0.178 A: fusten en land per kar in control_get_todays_carts (achteraan toegevoegd)
 DO $m$ BEGIN
-  IF pg_get_function_result('public.control_get_todays_carts()'::regprocedure) NOT LIKE '%crates_on_cart%' THEN
-    DROP FUNCTION public.control_get_todays_carts();
+  IF to_regprocedure('public.control_get_todays_carts()') IS NOT NULL THEN
+    IF pg_get_function_result('public.control_get_todays_carts()'::regprocedure) NOT LIKE '%crates_on_cart%' THEN
+      DROP FUNCTION public.control_get_todays_carts();
+    END IF;
   END IF;
 END $m$;
 
@@ -28396,7 +28419,7 @@ BEGIN
          AND o.deleted_at IS NULL AND o.cancelled_at IS NULL
          AND coalesce(o.status, '') <> 'geannuleerd'
          AND oi.quarantined_at IS NULL
-         AND o.delivery_date >= current_date - 1
+         AND public.logistics_order_date(o.delivery_date) >= current_date - 1
     )
     SELECT g.*,
            (SELECT min(x.regelnaam) FROM regels x WHERE x.order_id = g.order_id AND coalesce(x.crates, 0) <= 0) AS onbekende_regel
@@ -28445,7 +28468,7 @@ BEGIN
      SET status = 'niet_printen', reden = 'Fust hoort niet meer bij deze kar of order vervallen.', updated_at = now()
    WHERE p.soort = 'eigen_traysticker' AND p.status IN ('wacht_op_moment', 'geblokkeerd', 'klaar')
      AND NOT (p.bron_id = ANY (v_keep))
-     AND p.order_id IN (SELECT o.id FROM public.orders o WHERE o.delivery_date >= current_date - 1);
+     AND p.order_id IN (SELECT o.id FROM public.orders o WHERE public.logistics_order_date(o.delivery_date) >= current_date - 1);
   GET DIAGNOSTICS n_uit = ROW_COUNT;
 
   UPDATE public.logistics_sticker_prints p
@@ -28679,7 +28702,7 @@ BEGIN
       FROM public.orders o
       JOIN public.floriday_salesorders_cache s ON s.floriday_id = o.floriday_sales_order_id AND NOT coalesce(s.is_deleted,false)
       CROSS JOIN LATERAL jsonb_array_elements(CASE WHEN jsonb_typeof(s.data->'additionalServices') = 'array' THEN s.data->'additionalServices' ELSE '[]'::jsonb END) e
-     WHERE o.deleted_at IS NULL AND o.delivery_date >= current_date - 2
+     WHERE o.deleted_at IS NULL AND public.logistics_order_date(o.delivery_date) >= current_date - 2
        AND upper(coalesce(e->>'unit','')) = 'LABEL' AND (e->>'numberOfUnits') ~ '^\d+$'
        AND nullif(btrim(coalesce(e->>'stickerId','')),'') IS NOT NULL
        AND NOT EXISTS (SELECT 1 FROM public.floriday_customer_stickers_cache c WHERE c.floriday_id = e->>'stickerId')
@@ -28713,7 +28736,7 @@ BEGIN
       SELECT o.id, o.order_number, nullif(btrim(o.floriday_sales_order_id),'') AS sales
         FROM public.orders o
        WHERE o.deleted_at IS NULL AND nullif(btrim(o.floriday_sales_order_id),'') IS NOT NULL
-         AND o.delivery_date >= current_date - 2
+         AND public.logistics_order_date(o.delivery_date) >= current_date - 2
          AND EXISTS (SELECT 1 FROM logistics_active.order_carts oc WHERE oc.order_id = o.id)
        ORDER BY o.delivery_date LIMIT greatest(p_limit,1)
     LOOP
@@ -29987,6 +30010,8 @@ DO $fs$ DECLARE f text; BEGIN
       'logistics_set_order_carrier(uuid,uuid)','logistics_carrier_status()','logistics_carrier_set_backfill(boolean)',
       'logistics_carrier_preview_existing(integer)','logistics_carrier_promote_oud(uuid[],integer)',
       'logistics_order_carrier_label(uuid)','logistics_install_check()','logistics_order_departure(uuid)','logistics_resolve_carrier_for_location_many(jsonb)'] LOOP
+    -- 1.0.197: in een nieuwe Shell kan een functie hier nog ontbreken (verderop gedefinieerd, eigen rechten daar).
+    CONTINUE WHEN to_regprocedure('public.' || f) IS NULL;
     EXECUTE format('REVOKE ALL ON FUNCTION public.%s FROM PUBLIC, anon', f);
     EXECUTE format('GRANT EXECUTE ON FUNCTION public.%s TO authenticated, service_role', f);
   END LOOP;
@@ -30005,9 +30030,10 @@ END $fs$;
 -- 1.0.184: karrenlijst toont de vervoerder uit orders.carrier_id (achteraan toegevoegd).
 -- "Eigen vervoer" en "Afhalen" op carrier_kind / self_pickup, nooit op naam.
 DO $m$ BEGIN
-  IF to_regprocedure('public.control_get_todays_carts()') IS NOT NULL
-     AND pg_get_function_result('public.control_get_todays_carts()'::regprocedure) NOT LIKE '%carrier_name%' THEN
-    DROP FUNCTION public.control_get_todays_carts();
+  IF to_regprocedure('public.control_get_todays_carts()') IS NOT NULL THEN
+    IF pg_get_function_result('public.control_get_todays_carts()'::regprocedure) NOT LIKE '%carrier_name%' THEN
+      DROP FUNCTION public.control_get_todays_carts();
+    END IF;
   END IF;
 END $m$;
 
@@ -33232,6 +33258,7 @@ BEGIN
        AND (q.printed_at IS NOT NULL OR q.completed_at IS NOT NULL)) THEN RETURN true; END IF;
   IF EXISTS (SELECT 1 FROM public.cart_control_items ci WHERE ci.order_number = v_number) THEN RETURN true; END IF;
   IF public.logistics_order_print_actief(v_number) THEN RETURN true; END IF;
+  IF public.logistics_order_print_actief(v_number) THEN RETURN true; END IF;
   RETURN false;
 END;
 $function$
@@ -33295,6 +33322,7 @@ begin
        and not exists (select 1 from public.pick_queue q
                         where q.reference = c.id::text and q.printed_at is not null)
        and not public.logistics_order_print_actief(o.order_number)
+       and not public.logistics_order_print_actief(o.order_number)
        and public.logistics_cart_checkin_at(c.id) is not null
      limit greatest(coalesce(p_limit, 50), 1)
   loop
@@ -33329,6 +33357,7 @@ AS $function$
      WHERE oc.order_id = p_order_id AND public.logistics_cart_is_frozen(oc.id)
   )
   OR public.logistics_order_print_actief((SELECT o.order_number FROM public.orders o WHERE o.id = p_order_id))
+  OR public.logistics_order_print_actief((SELECT o.order_number FROM public.orders o WHERE o.id = p_order_id))
   OR EXISTS (
     SELECT 1 FROM logistics_active.order_carts oc
       JOIN logistics_active.order_cart_items oci ON oci.cart_id = oc.id
@@ -33354,6 +33383,7 @@ AS $function$
         OR public.logistics_cart_handled(COALESCE(po.order_number, p.peer_order_id::text), p.cart_number)
         OR public.logistics_order_afgemeld(p.peer_order_id)
         OR public.logistics_order_print_actief(po.order_number)
+        OR public.logistics_order_print_actief(po.order_number)
         OR public.logistics_cart_is_frozen(p.cart_id)
         OR EXISTS (SELECT 1 FROM public.pick_queue q WHERE q.cancelled_at IS NULL
              AND q.payload->>'cartId' = p.cart_id::text
@@ -33444,6 +33474,34 @@ BEGIN
   END;
   v_result := v_result || jsonb_build_object('instellingen_ms', (extract(epoch from clock_timestamp()-v_t)*1000)::int);
 
+  -- 1.0.194: lichte ronde — pickwachtrij en laadtoestand in SQL, niet meer via HTTP.
+  v_t := clock_timestamp();
+  BEGIN
+    PERFORM set_config('statement_timeout', '15000', true);
+    v_result := v_result || jsonb_build_object('pickwachtrij', public.logistics_sync_pick_queue());
+  EXCEPTION WHEN OTHERS THEN
+    v_err := true; v_result := v_result || jsonb_build_object('pickwachtrij', left(SQLERRM, 200));
+  END;
+  v_result := v_result || jsonb_build_object('pickwachtrij_ms', (extract(epoch from clock_timestamp()-v_t)*1000)::int);
+
+  v_t := clock_timestamp();
+  BEGIN
+    PERFORM set_config('statement_timeout', '10000', true);
+    v_result := v_result || jsonb_build_object('laadtoestand', public.logistics_refresh_plan_state_als_nodig());
+  EXCEPTION WHEN OTHERS THEN
+    v_err := true; v_result := v_result || jsonb_build_object('laadtoestand', left(SQLERRM, 200));
+  END;
+  v_result := v_result || jsonb_build_object('laadtoestand_ms', (extract(epoch from clock_timestamp()-v_t)*1000)::int);
+
+  v_t := clock_timestamp();
+  BEGIN
+    PERFORM set_config('statement_timeout', '10000', true);
+    v_result := v_result || jsonb_build_object('instellingen', public.logistics_ensure_periodiek());
+  EXCEPTION WHEN OTHERS THEN
+    v_err := true; v_result := v_result || jsonb_build_object('instellingen', left(SQLERRM, 200));
+  END;
+  v_result := v_result || jsonb_build_object('instellingen_ms', (extract(epoch from clock_timestamp()-v_t)*1000)::int);
+
   BEGIN
     INSERT INTO public.logistics_tick_runs(started_at, finished_at, duration_ms, has_error, steps)
     VALUES (v_start, clock_timestamp(), (extract(epoch from clock_timestamp()-v_start)*1000)::int, v_err, v_result);
@@ -33553,6 +33611,7 @@ BEGIN
      ORDER BY e.created_at DESC LIMIT 1), '') END;
   RETURN NEXT;
   RETURN QUERY SELECT * FROM public.logistics_install_check_194();
+  RETURN QUERY SELECT * FROM public.logistics_install_check_196();
   RETURN QUERY SELECT * FROM public.logistics_access_check();
   RETURN QUERY SELECT * FROM public.logistics_overload_check();
   RETURN QUERY SELECT * FROM public.logistics_check_190();
@@ -33572,3 +33631,973 @@ GRANT EXECUTE ON FUNCTION public.logistics_order_date(date) TO authenticated, se
 GRANT EXECUTE ON FUNCTION public.logistics_print_status(uuid[]) TO authenticated, service_role;
 GRANT EXECUTE ON FUNCTION public.logistics_kick_metingen(integer) TO authenticated, service_role;
 GRANT EXECUTE ON FUNCTION public.logistics_install_check_194() TO authenticated, service_role;
+
+-- ============================================================================
+-- logistiek-engine 1.0.196 — direct wekken, achterstand in één aanroep, gegevens
+-- voor karindeling, sticker opnieuw proberen, rebuffer-slot (additief, idempotent)
+-- ============================================================================
+-- 1.0.196 — direct wekken, achterstand in één aanroep, gegevens voor karindeling, sticker opnieuw, rebuffer-slot
+
+CREATE OR REPLACE FUNCTION public.logistics_plan_now_gate(p_order_ids uuid[])
+RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE
+  v_running boolean; v_last timestamptz;
+  v_debounce int := public.logistics_plan_setting('kick_debounce_seconds', 5)::int;
+  v_n int := coalesce(cardinality(p_order_ids), 0);
+BEGIN
+  PERFORM public.logistics_acc_guard('server', 'logistics_plan_now_gate');
+  IF v_n > 1000 THEN
+    RAISE EXCEPTION 'Maximaal 1000 orders per aanroep (ontvangen: %).', v_n USING ERRCODE = '22023';
+  END IF;
+  SELECT EXISTS (SELECT 1 FROM public.logistics_plan_locks WHERE lock_key = 'tick:ronde' AND locked_until > now())
+    INTO v_running;
+  IF v_running THEN
+    INSERT INTO public.logistics_plan_settings(key, value, updated_at)
+    VALUES ('kick_pending', clock_timestamp()::text, now())
+    ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = now();
+    BEGIN INSERT INTO public.logistics_kick_log(skipped_reason) VALUES ('plan_now_vlag_gezet'); EXCEPTION WHEN OTHERS THEN NULL; END;
+    RETURN jsonb_build_object('actie', 'vlag_gezet', 'orders', v_n);
+  END IF;
+  SELECT NULLIF(value,'')::timestamptz INTO v_last FROM public.logistics_plan_settings WHERE key = 'last_kick_at';
+  IF v_last IS NOT NULL AND v_last > now() - make_interval(secs => v_debounce) THEN
+    -- Binnen de wachttijd: niet laten vallen, de eerstvolgende ronde pakt de vlag op.
+    INSERT INTO public.logistics_plan_settings(key, value, updated_at)
+    VALUES ('kick_pending', clock_timestamp()::text, now())
+    ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = now();
+    BEGIN INSERT INTO public.logistics_kick_log(skipped_reason) VALUES ('plan_now_debounce'); EXCEPTION WHEN OTHERS THEN NULL; END;
+    RETURN jsonb_build_object('actie', 'debounce', 'orders', v_n);
+  END IF;
+  INSERT INTO public.logistics_plan_settings(key, value, updated_at)
+  VALUES ('last_kick_at', now()::text, now())
+  ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = now();
+  BEGIN INSERT INTO public.logistics_kick_log(skipped_reason) VALUES ('plan_now_start'); EXCEPTION WHEN OTHERS THEN NULL; END;
+  RETURN jsonb_build_object('actie', 'start', 'orders', v_n);
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_plan_now_gate(uuid[]) TO service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_order_backlog_info_many(p_order_ids uuid[])
+RETURNS TABLE(order_id uuid, info jsonb, achterstand boolean, leverdatum date, dagen integer)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_order_backlog_info_many');
+  IF coalesce(cardinality(p_order_ids), 0) > 1000 THEN
+    RAISE EXCEPTION 'Maximaal 1000 orders per aanroep (ontvangen: %).', cardinality(p_order_ids) USING ERRCODE = '22023';
+  END IF;
+  RETURN QUERY
+  WITH ids AS (SELECT DISTINCT u AS id FROM unnest(coalesce(p_order_ids, '{}'::uuid[])) u WHERE u IS NOT NULL),
+  today AS (SELECT (now() AT TIME ZONE public.logistics_tz())::date AS d),
+  hit AS (
+    SELECT o.id, (o.delivery_date::text)::date AS ld
+      FROM public.orders o JOIN ids ON ids.id = o.id, today
+     WHERE o.deleted_at IS NULL AND o.cancelled_at IS NULL
+       AND COALESCE(o.is_reservation, false) = false
+       AND lower(coalesce(o.status, '')) = 'nog te picken'
+       AND NULLIF(o.delivery_date::text, '') IS NOT NULL
+       AND (o.delivery_date::text)::date < today.d
+       AND NOT public.logistics_order_handled(o.id)
+       AND NOT EXISTS (SELECT 1 FROM public.floriday_salesorders_cache fc
+          WHERE o.floriday_sales_order_id IS NOT NULL AND fc.floriday_id = o.floriday_sales_order_id AND fc.controlled_at IS NOT NULL)
+  )
+  SELECT ids.id,
+         CASE WHEN h.id IS NULL THEN NULL
+              ELSE jsonb_build_object('achterstand', true, 'leverdatum', h.ld, 'dagen', t.d - h.ld) END,
+         h.id IS NOT NULL, h.ld, CASE WHEN h.id IS NULL THEN NULL ELSE t.d - h.ld END
+    FROM ids CROSS JOIN today t LEFT JOIN hit h ON h.id = ids.id;
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_order_backlog_info_many(uuid[]) TO authenticated, service_role;
+
+-- E4/E5: gegevens voor karindeling
+CREATE OR REPLACE FUNCTION public.logistics_data_gereedheid(p_product_ids uuid[] DEFAULT NULL)
+RETURNS TABLE(product_id uuid, product text, ladingdrager text, methode text, in_open_order boolean,
+              ontbrekend text[], velden jsonb, voorstel jsonb, uitleg text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_methode text; v_carrier text; c record;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_data_gereedheid');
+  SELECT CASE WHEN coalesce(s.settings->'karrenindeling'->'fields'->>'cart_layout_method', s.settings->'karrenindeling'->>'cart_layout_method') = 'afmetingen'
+              THEN 'afmetingen' ELSE 'belading' END,
+         nullif(btrim(coalesce(s.settings->'karrenindeling'->'fields'->>'default_carrier_type', s.settings->'karrenindeling'->>'default_carrier_type')), '')
+    INTO v_methode, v_carrier
+    FROM public.logistics_rule_configs s WHERE s.is_active ORDER BY s.updated_at DESC LIMIT 1;
+  v_methode := coalesce(v_methode, 'belading');
+  SELECT t.code, t.name, t.layer_length_cm, t.layer_width_cm, t.max_height_cm INTO c
+    FROM public.load_carrier_types t
+   WHERE t.is_active AND (t.code = v_carrier OR (v_carrier IS NULL AND t.is_default))
+   ORDER BY (t.code = v_carrier) DESC NULLS LAST LIMIT 1;
+
+  RETURN QUERY
+  WITH open_p AS (
+    SELECT DISTINCT oi.product_id FROM public.orders o JOIN public.order_items oi ON oi.order_id = o.id
+     WHERE o.deleted_at IS NULL AND o.cancelled_at IS NULL AND coalesce(o.is_reservation,false) = false
+       AND lower(coalesce(o.status,'')) = 'nog te picken' AND oi.product_id IS NOT NULL
+  ),
+  p AS (
+    SELECT pr.id, pr.product, pr.plants_per_crate, pr.crates_per_layer, pr.layers_per_cart,
+           NULLIF(regexp_replace(coalesce(pr.weight::text,''), '[^0-9.,]', '', 'g'), '') AS weight_txt,
+           pr.plant_height_cm, pr.fust_type_id, pr.floriday_packing_source,
+           ft.length_mm, ft.width_mm, ft.height_mm,
+           (op.product_id IS NOT NULL) AS in_open
+      FROM public.products pr
+      LEFT JOIN public.fust_types ft ON ft.id = pr.fust_type_id
+      LEFT JOIN open_p op ON op.product_id = pr.id
+     WHERE (p_product_ids IS NULL AND op.product_id IS NOT NULL) OR pr.id = ANY(p_product_ids)
+  ),
+  m AS (
+    SELECT p.*,
+      array_remove(ARRAY[
+        CASE WHEN coalesce(p.plants_per_crate,0) <= 0 THEN 'plants_per_crate' END,
+        CASE WHEN v_methode = 'belading' AND coalesce(p.crates_per_layer,0) <= 0 THEN 'crates_per_layer' END,
+        CASE WHEN v_methode = 'belading' AND coalesce(p.layers_per_cart,0) <= 0 THEN 'layers_per_cart' END,
+        CASE WHEN v_methode = 'afmetingen' AND p.fust_type_id IS NULL THEN 'fust_type_id' END,
+        CASE WHEN v_methode = 'afmetingen' AND coalesce(p.plant_height_cm,0) <= 0 THEN 'plant_height_cm' END,
+        CASE WHEN p.weight_txt IS NULL THEN 'weight' END
+      ], NULL) AS mist,
+      -- Fusten per laag uit fustmaat × laagmaat (beide oriëntaties, raster).
+      CASE WHEN p.length_mm > 0 AND p.width_mm > 0 AND c.layer_length_cm > 0 AND c.layer_width_cm > 0 THEN
+        greatest(floor(c.layer_length_cm*10 / p.length_mm) * floor(c.layer_width_cm*10 / p.width_mm),
+                 floor(c.layer_length_cm*10 / p.width_mm) * floor(c.layer_width_cm*10 / p.length_mm))::int END AS calc_cpl,
+      -- Lagen per kar uit planthoogte + fusthoogte tegen hoogte ladingdrager.
+      CASE WHEN coalesce(p.plant_height_cm,0) > 0 AND c.max_height_cm > 0 THEN
+        floor(c.max_height_cm / (p.plant_height_cm + coalesce(p.height_mm,0)/10.0))::int END AS calc_lpc
+    FROM p
+  )
+  SELECT m.id, m.product, c.code, v_methode, m.in_open, m.mist,
+    jsonb_build_object(
+      'plants_per_crate', jsonb_build_object('waarde', m.plants_per_crate, 'bron', CASE WHEN m.plants_per_crate > 0 THEN coalesce(m.floriday_packing_source, 'product') END),
+      'crates_per_layer', jsonb_build_object('waarde', m.crates_per_layer, 'bron', CASE WHEN m.crates_per_layer > 0 THEN coalesce(m.floriday_packing_source, 'product') END),
+      'layers_per_cart', jsonb_build_object('waarde', m.layers_per_cart, 'bron', CASE WHEN m.layers_per_cart > 0 THEN coalesce(m.floriday_packing_source, 'product') END),
+      'weight', jsonb_build_object('waarde', m.weight_txt, 'bron', CASE WHEN m.weight_txt IS NOT NULL THEN 'product' END),
+      'plant_height_cm', jsonb_build_object('waarde', m.plant_height_cm, 'bron', CASE WHEN m.plant_height_cm > 0 THEN 'product' END),
+      'fust_type_id', jsonb_build_object('waarde', m.fust_type_id, 'bron', CASE WHEN m.fust_type_id IS NOT NULL THEN 'product' END)),
+    jsonb_strip_nulls(jsonb_build_object(
+      'crates_per_layer', CASE WHEN m.calc_cpl > 0 THEN jsonb_build_object('waarde', m.calc_cpl, 'bron', 'berekend',
+          'berekening', format('fust %s×%s mm op laag %s×%s cm (%s)', m.length_mm, m.width_mm, c.layer_length_cm, c.layer_width_cm, c.name))
+        ELSE (SELECT jsonb_build_object('waarde', x.v, 'bron', 'vergelijkbaar', 'berekening', format('meest gebruikt bij %s product(en) met dezelfde fust', x.n))
+                FROM (SELECT p2.crates_per_layer v, count(*) n FROM public.products p2
+                       WHERE m.fust_type_id IS NOT NULL AND p2.fust_type_id = m.fust_type_id AND p2.crates_per_layer > 0 AND p2.id <> m.id
+                       GROUP BY 1 ORDER BY 2 DESC LIMIT 1) x) END,
+      'layers_per_cart', CASE WHEN m.calc_lpc > 0 THEN jsonb_build_object('waarde', m.calc_lpc, 'bron', 'berekend',
+          'berekening', format('hoogte %s cm / (plant %s cm + fust %s cm)', c.max_height_cm, m.plant_height_cm, round(coalesce(m.height_mm,0)/10.0,1)))
+        ELSE (SELECT jsonb_build_object('waarde', x.v, 'bron', 'vergelijkbaar', 'berekening', format('meest gebruikt bij %s product(en) met dezelfde fust', x.n))
+                FROM (SELECT p2.layers_per_cart v, count(*) n FROM public.products p2
+                       WHERE m.fust_type_id IS NOT NULL AND p2.fust_type_id = m.fust_type_id AND p2.layers_per_cart > 0 AND p2.id <> m.id
+                       GROUP BY 1 ORDER BY 2 DESC LIMIT 1) x) END)),
+    CASE WHEN cardinality(m.mist) = 0 THEN 'Compleet.'
+         ELSE format('Bij "%s" ontbreekt: %s. Vul dit in bij het product (Voorraad) of hier met "Invullen".', m.product,
+           array_to_string(ARRAY(SELECT CASE f WHEN 'plants_per_crate' THEN 'planten per fust' WHEN 'crates_per_layer' THEN 'fusten per laag'
+             WHEN 'layers_per_cart' THEN 'lagen per kar' WHEN 'fust_type_id' THEN 'fustsoort' WHEN 'plant_height_cm' THEN 'planthoogte'
+             WHEN 'weight' THEN 'gewicht per fust' ELSE f END FROM unnest(m.mist) f), ', ')) END
+  FROM m
+  ORDER BY cardinality(m.mist) DESC, m.in_open DESC, m.product
+  LIMIT 2000;
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_data_gereedheid(uuid[]) TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_data_vul_in(p_product_id uuid, p_veld text, p_waarde numeric)
+RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+BEGIN
+  PERFORM public.logistics_acc_guard('beheer', 'logistics_data_vul_in');
+  IF p_waarde IS NULL OR p_waarde <= 0 THEN
+    RAISE EXCEPTION 'Vul een getal groter dan 0 in.' USING ERRCODE = '22023';
+  END IF;
+  IF p_veld = 'plants_per_crate' THEN UPDATE public.products SET plants_per_crate = p_waarde, updated_at = now() WHERE id = p_product_id;
+  ELSIF p_veld = 'crates_per_layer' THEN UPDATE public.products SET crates_per_layer = p_waarde, updated_at = now() WHERE id = p_product_id;
+  ELSIF p_veld = 'layers_per_cart' THEN UPDATE public.products SET layers_per_cart = p_waarde, updated_at = now() WHERE id = p_product_id;
+  ELSIF p_veld = 'plant_height_cm' THEN UPDATE public.products SET plant_height_cm = p_waarde, updated_at = now() WHERE id = p_product_id;
+  ELSIF p_veld = 'weight' THEN UPDATE public.products SET weight = p_waarde, updated_at = now() WHERE id = p_product_id;
+  ELSE RAISE EXCEPTION 'Dit veld kan hier niet worden ingevuld: %', p_veld USING ERRCODE = '22023';
+  END IF;
+  IF NOT FOUND THEN RAISE EXCEPTION 'Product niet gevonden.' USING ERRCODE = 'P0002'; END IF;
+  RETURN jsonb_build_object('ok', true, 'productId', p_product_id, 'veld', p_veld, 'waarde', p_waarde);
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_data_vul_in(uuid, text, numeric) TO authenticated, service_role;
+
+-- 4: geweigerde sticker opnieuw proberen (status blijft binnen bestaande CHECK)
+CREATE OR REPLACE FUNCTION public.logistics_sticker_retry(p_id uuid)
+RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+BEGIN
+  PERFORM public.logistics_acc_guard('beheer', 'logistics_sticker_retry');
+  UPDATE public.logistics_sticker_prints
+     SET status = 'klaar', reden = NULL, print_job_id = NULL, attempts = 0, next_attempt_at = NULL, updated_at = now()
+   WHERE id = p_id AND status IN ('geblokkeerd', 'mislukt');
+  IF NOT FOUND THEN
+    RAISE EXCEPTION 'Deze sticker is niet geblokkeerd of mislukt; opnieuw proberen is niet nodig.' USING ERRCODE = '22023';
+  END IF;
+  RETURN jsonb_build_object('ok', true, 'id', p_id);
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_sticker_retry(uuid) TO authenticated, service_role;
+
+-- 6: rebuffer-instelling onder advisory lock (geen deadlock meer bij gelijktijdige aanroepen)
+CREATE OR REPLACE FUNCTION public.logistics_ensure_rebuffer_setting()
+RETURNS integer LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_n integer := 0;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_ensure_rebuffer_setting');
+  -- 1.0.196: één tegelijk; bezet = overslaan zonder fout. Daarna rijen in vaste volgorde vergrendelen.
+  IF NOT pg_try_advisory_xact_lock(hashtext('logistics_ensure_rebuffer_setting')) THEN
+    RETURN 0;
+  END IF;
+  PERFORM 1 FROM public.logistics_rule_configs c
+   WHERE NOT coalesce(c.settings->'order_verwerking'->'fields' ? 'rebuffer_on_change', false)
+     AND NOT coalesce(c.settings->'order_verwerking' ? 'rebuffer_on_change', false)
+   ORDER BY c.id FOR UPDATE SKIP LOCKED;
+  UPDATE public.logistics_rule_configs c
+     SET settings = jsonb_set(coalesce(c.settings, '{}'::jsonb), '{order_verwerking}',
+           coalesce(c.settings->'order_verwerking', '{}'::jsonb)
+             || jsonb_build_object('fields', coalesce(c.settings->'order_verwerking'->'fields', '{}'::jsonb)
+                                            || jsonb_build_object('rebuffer_on_change', true)), true)
+   WHERE c.id IS NOT NULL
+     AND NOT coalesce(c.settings->'order_verwerking'->'fields' ? 'rebuffer_on_change', false)
+     AND NOT coalesce(c.settings->'order_verwerking' ? 'rebuffer_on_change', false);
+  GET DIAGNOSTICS v_n = ROW_COUNT;
+  RETURN v_n;
+END $$;
+
+CREATE OR REPLACE FUNCTION public.logistics_install_check_196()
+RETURNS TABLE(controle text, ok boolean, toelichting text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_install_check_196');
+  RETURN QUERY SELECT 'Engine: direct wekken (plan-now) – sleutel ingesteld'::text,
+    EXISTS (SELECT 1 FROM public.module_runtime_config WHERE key = 'logistics_tick_apikey' AND nullif(btrim(value),'') IS NOT NULL),
+    'module_runtime_config logistics_tick_apikey; zonder sleutel antwoordt de route 500.'::text;
+  RETURN QUERY SELECT 'Engine: poort direct wekken aanwezig', to_regprocedure('public.logistics_plan_now_gate(uuid[])') IS NOT NULL, 'logistics_plan_now_gate';
+  RETURN QUERY SELECT 'Engine: achterstand in één aanroep', to_regprocedure('public.logistics_order_backlog_info_many(uuid[])') IS NOT NULL, 'logistics_order_backlog_info_many';
+  RETURN QUERY SELECT 'Engine: gegevens voor karindeling', to_regprocedure('public.logistics_data_gereedheid(uuid[])') IS NOT NULL, 'logistics_data_gereedheid';
+  RETURN QUERY SELECT 'Engine: sticker opnieuw proberen', to_regprocedure('public.logistics_sticker_retry(uuid)') IS NOT NULL, 'logistics_sticker_retry';
+  RETURN QUERY SELECT 'Engine: rebuffer-instelling onder slot',
+    coalesce(pg_get_functiondef('public.logistics_ensure_rebuffer_setting()'::regprocedure) LIKE '%pg_try_advisory_xact_lock%', false),
+    'voorkomt deadlock bij gelijktijdige aanroep';
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_install_check_196() TO authenticated, service_role;
+DO $do$ DECLARE d text;
+BEGIN
+  d := pg_get_functiondef('public.logistics_install_check()'::regprocedure);
+  IF position('logistics_install_check_196' in d) = 0 THEN
+    d := replace(d, $r$  RETURN QUERY SELECT * FROM public.logistics_access_check();$r$,
+                    $r$  RETURN QUERY SELECT * FROM public.logistics_install_check_196();
+  RETURN QUERY SELECT * FROM public.logistics_access_check();$r$);
+    EXECUTE d;
+  END IF;
+EXCEPTION WHEN undefined_function THEN NULL;
+END $do$;
+
+-- ===== 1.0.197 =====
+-- ============================================================================
+-- logistiek-engine 1.0.197 — unieke karnummering per buffer (incl. bevroren
+-- karren uit eerdere buffers), "van N" over alle karren, orderscherm telt via de
+-- buffer, fysieke beladingscontrole in de installatiecontrole (additief, idempotent)
+-- ============================================================================
+
+-- Kern zonder guard en zonder SECURITY DEFINER: RLS van de aanroeper blijft gelden.
+CREATE OR REPLACE FUNCTION public.logistics_order_unit_carts_core(p_order_ids uuid[])
+RETURNS TABLE(cart_id uuid, cart_number integer, buffer_id uuid, order_id uuid, display_seq integer, display_total integer)
+LANGUAGE sql STABLE SET search_path TO 'public' AS $$
+  WITH ords AS (
+    SELECT o.id, o.buffer_id FROM public.orders o WHERE o.id = ANY(coalesce(p_order_ids, '{}'::uuid[]))
+  ),
+  bufs AS (SELECT DISTINCT b.buffer_id FROM ords b WHERE b.buffer_id IS NOT NULL),
+  ords2 AS (
+    SELECT o.id FROM ords o
+    UNION
+    SELECT o.id FROM public.orders o
+     WHERE o.buffer_id IN (SELECT bb.buffer_id FROM bufs bb) AND o.deleted_at IS NULL AND o.cancelled_at IS NULL
+  ),
+  k AS (
+    SELECT c.id FROM logistics_active.order_carts c WHERE c.order_id IN (SELECT x.id FROM ords2 x)
+    UNION
+    SELECT ci.cart_id FROM logistics_active.order_cart_items ci
+      JOIN public.order_items oi ON oi.id = ci.order_item_id
+     WHERE oi.order_id IN (SELECT x.id FROM ords2 x)
+    UNION
+    SELECT c.id FROM logistics_active.order_carts c
+     WHERE c.order_id IS NULL AND c.buffer_id IN (SELECT bb.buffer_id FROM bufs bb)
+  ),
+  base AS (
+    SELECT c.id, c.cart_number, c.buffer_id, c.order_id, c.created_at,
+           min(c.created_at) OVER (PARTITION BY coalesce(c.buffer_id, c.id)) AS grp_at
+      FROM logistics_active.order_carts c WHERE c.id IN (SELECT k.id FROM k)
+  ),
+  f AS (
+    SELECT count(*)::int AS n, count(DISTINCT b.cart_number)::int AS nd,
+           coalesce(max(b.cart_number), 0)::int AS mx,
+           count(*) FILTER (WHERE b.cart_number IS NULL)::int AS leeg
+      FROM base b
+  )
+  SELECT b.id, b.cart_number, b.buffer_id, b.order_id,
+         CASE WHEN f.nd = f.n AND f.leeg = 0 THEN b.cart_number
+              ELSE row_number() OVER (ORDER BY b.grp_at, coalesce(b.buffer_id, b.id), b.cart_number NULLS LAST, b.id)::int END,
+         CASE WHEN f.nd = f.n AND f.leeg = 0 THEN greatest(f.n, f.mx) ELSE f.n END
+    FROM base b CROSS JOIN f
+$$;
+
+CREATE OR REPLACE FUNCTION public.logistics_order_unit_carts(p_order_ids uuid[])
+RETURNS TABLE(cart_id uuid, cart_number integer, buffer_id uuid, order_id uuid, display_seq integer, display_total integer)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_order_unit_carts');
+  IF coalesce(cardinality(p_order_ids), 0) > 1000 THEN
+    RAISE EXCEPTION 'Maximaal 1000 orders per aanroep (ontvangen: %).', cardinality(p_order_ids) USING ERRCODE = '22023';
+  END IF;
+  RETURN QUERY SELECT * FROM public.logistics_order_unit_carts_core(p_order_ids);
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_order_unit_carts(uuid[]) TO authenticated, service_role;
+
+-- Bestaande handtekening blijft; weergave nu uniek binnen de hele eenheid.
+CREATE OR REPLACE FUNCTION public.logistics_cart_fixed_numbering(p_cart_id uuid)
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE c record; v_ids uuid[]; u record; v_total int;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_cart_fixed_numbering');
+  SELECT * INTO c FROM public.order_carts WHERE id = p_cart_id;
+  IF NOT FOUND THEN RETURN NULL; END IF;
+  IF c.archived_at IS NULL THEN
+    SELECT array_agg(DISTINCT s.x) INTO v_ids FROM (
+      SELECT c.order_id AS x
+      UNION SELECT oi.order_id 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
+      UNION SELECT o.id FROM public.orders o WHERE c.buffer_id IS NOT NULL AND o.buffer_id = c.buffer_id AND o.deleted_at IS NULL
+    ) s WHERE s.x IS NOT NULL;
+    IF v_ids IS NOT NULL THEN
+      SELECT * INTO u FROM public.logistics_order_unit_carts_core(v_ids) z WHERE z.cart_id = p_cart_id;
+      IF FOUND AND u.display_seq IS NOT NULL THEN
+        RETURN jsonb_build_object('cartSeq', u.display_seq, 'cartIndex', u.display_seq, 'cartTotal', u.display_total,
+          'cartLabel', 'Kar ' || u.display_seq || ' van ' || u.display_total, 'storedCartNumber', c.cart_number);
+      END IF;
+    END IF;
+  END IF;
+  -- Terugval (gearchiveerde kar of geen orders): oude berekening.
+  SELECT greatest(coalesce(max(c2.total_carts), 0), count(*)::int, coalesce(c.cart_number, 0)) INTO v_total
+    FROM public.order_carts c2
+   WHERE (c.order_id IS NULL AND c.buffer_id IS NOT NULL AND c2.order_id IS NULL AND c2.buffer_id = c.buffer_id)
+      OR (c.order_id IS NOT NULL AND c2.order_id = c.order_id)
+      OR (c.order_id IS NULL AND c.buffer_id IS NULL AND c2.id = c.id);
+  RETURN jsonb_build_object('cartSeq', c.cart_number, 'cartIndex', c.cart_number, 'cartTotal', v_total,
+    'cartLabel', 'Kar ' || c.cart_number || ' van ' || v_total);
+END $$;
+
+-- Orderscherm: tel alle karren van de eenheid (buffer + karren met goederen van de order).
+CREATE OR REPLACE FUNCTION public.logistics_live_cart_count(p_order_ref text)
+RETURNS integer LANGUAGE sql STABLE SET search_path TO 'public' AS $$
+  SELECT COALESCE(
+    NULLIF((SELECT count(*)::int FROM public.logistics_order_unit_carts_core(
+              ARRAY(SELECT o.id FROM public.orders o WHERE o.order_number = p_order_ref AND o.deleted_at IS NULL))), 0),
+    public.logistics_order_cart_count(p_order_ref),
+    0);
+$$;
+
+-- Controle: actieve pakbonnen met dezelfde naam (alleen melden, niets wijzigen).
+CREATE OR REPLACE FUNCTION public.logistics_dubbele_pakbonnamen()
+RETURNS TABLE(document_number text, aantal integer, karren text[])
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_dubbele_pakbonnamen');
+  RETURN QUERY
+  SELECT q.document_number, count(*)::int, array_agg(q.reference ORDER BY q.reference)
+    FROM public.pick_queue q
+   WHERE q.cancelled_at IS NULL AND q.document_number LIKE 'PB-%-K%'
+   GROUP BY q.document_number HAVING count(*) > 1;
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_dubbele_pakbonnamen() TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_install_check_197()
+RETURNS TABLE(controle text, ok boolean, toelichting text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_dub int;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_install_check_197');
+  RETURN QUERY SELECT 'Engine: karnummering per eenheid'::text,
+    to_regprocedure('public.logistics_order_unit_carts(uuid[])') IS NOT NULL
+      AND coalesce(pg_get_functiondef('public.logistics_cart_fixed_numbering(uuid)'::regprocedure) LIKE '%logistics_order_unit_carts_core%', false),
+    'logistics_order_unit_carts + logistics_cart_fixed_numbering'::text;
+  RETURN QUERY SELECT 'Engine: orderscherm telt karren via de buffer',
+    coalesce(pg_get_functiondef('public.logistics_live_cart_count(text)'::regprocedure) LIKE '%logistics_order_unit_carts_core%', false),
+    'logistics_live_cart_count';
+  BEGIN
+    SELECT count(*) INTO v_dub FROM public.logistics_dubbele_pakbonnamen();
+    RETURN QUERY SELECT 'Engine: geen dubbele pakbonnamen', v_dub = 0,
+      CASE WHEN v_dub = 0 THEN 'geen' ELSE v_dub || ' naam/namen dubbel; de eerstvolgende pakbonronde zet het unieke nummer' END;
+  EXCEPTION WHEN undefined_table THEN
+    RETURN QUERY SELECT 'Engine: geen dubbele pakbonnamen', true, 'pick_queue ontbreekt in deze Shell';
+  END;
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_install_check_197() TO authenticated, service_role;
+
+DO $do$ DECLARE d text;
+BEGIN
+  d := pg_get_functiondef('public.logistics_install_check()'::regprocedure);
+  IF position('logistics_install_check_197' in d) = 0 THEN
+    d := replace(d, $r$  RETURN QUERY SELECT * FROM public.logistics_access_check();$r$,
+                    $r$  RETURN QUERY SELECT * FROM public.logistics_install_check_197();
+  RETURN QUERY SELECT * FROM public.logistics_access_check();$r$);
+    EXECUTE d;
+  END IF;
+EXCEPTION WHEN undefined_function THEN NULL;
+END $do$;
+
+-- ============================================================================
+-- 1.0.198: maten hergebruiken uit Floricode/Floriday/Voorraad; niets stil invullen
+-- ============================================================================
+
+-- Bronregistratie van overgenomen of bevestigde waarden (Engine-eigendom).
+CREATE TABLE IF NOT EXISTS public.logistics_gegevens_bron (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  onderwerp text NOT NULL,
+  sleutel text NOT NULL,
+  veld text NOT NULL,
+  waarde text,
+  bron text NOT NULL,
+  toelichting text,
+  vastgelegd_door uuid,
+  vastgelegd_op timestamptz NOT NULL DEFAULT now(),
+  UNIQUE (onderwerp, sleutel, veld)
+);
+GRANT SELECT ON public.logistics_gegevens_bron TO authenticated;
+GRANT ALL ON public.logistics_gegevens_bron TO service_role;
+ALTER TABLE public.logistics_gegevens_bron ENABLE ROW LEVEL SECURITY;
+DO $do$ BEGIN
+  IF NOT EXISTS (SELECT 1 FROM pg_policies WHERE schemaname = 'public' AND tablename = 'logistics_gegevens_bron' AND policyname = 'logistics_gegevens_bron_lezen') THEN
+    CREATE POLICY logistics_gegevens_bron_lezen ON public.logistics_gegevens_bron FOR SELECT TO authenticated USING (true);
+  END IF;
+END $do$;
+
+-- Positief getal uit tekst, anders NULL. Nooit een standaardwaarde.
+CREATE OR REPLACE FUNCTION public.logistics_pos_num(p text)
+RETURNS numeric LANGUAGE sql IMMUTABLE SET search_path TO 'public' AS $$
+  SELECT CASE WHEN replace(btrim(coalesce(p, '')), ',', '.') ~ '^[0-9]+(\.[0-9]+)?$'
+              THEN NULLIF(replace(btrim(p), ',', '.')::numeric, 0) END
+$$;
+GRANT EXECUTE ON FUNCTION public.logistics_pos_num(text) TO authenticated, service_role;
+
+-- VBN-kenmerkwaarde in cm. Met Floricode: alleen een omschrijving "N cm" telt;
+-- een bereik of andere tekst = onbekend. Zonder Floricode-tabel: de code zelf (cm).
+CREATE OR REPLACE FUNCTION public.logistics_vbn_cm(p_feature text, p_code text)
+RETURNS numeric LANGUAGE plpgsql STABLE SET search_path TO 'public' AS $$
+DECLARE v_desc text; v_found boolean := false;
+BEGIN
+  IF p_code IS NULL OR btrim(p_code) = '' THEN RETURN NULL; END IF;
+  IF to_regclass('public.floricode_records') IS NOT NULL THEN
+    EXECUTE $q$SELECT r.data->>'description' FROM public.floricode_records r
+                WHERE r.resource = 'FeatureValue' AND r.data->>'feature_type_id' = $1 AND r.data->>'code' = $2
+                ORDER BY (r.data->>'expiry_date') IS NULL DESC LIMIT 1$q$
+      INTO v_desc USING p_feature, p_code;
+    v_found := v_desc IS NOT NULL;
+  END IF;
+  IF v_found THEN
+    IF v_desc ~* '^\s*[0-9]+([.,][0-9]+)?\s*cm\s*$' THEN
+      RETURN public.logistics_pos_num(regexp_replace(v_desc, '[^0-9.,]', '', 'g'));
+    END IF;
+    RETURN NULL;
+  END IF;
+  RETURN public.logistics_pos_num(p_code);
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_vbn_cm(text, text) TO authenticated, service_role;
+
+-- 1: eigen terugval voor fustmaten. Per veld: Floricode -> Floriday custom package -> handmatig -> onbekend.
+CREATE OR REPLACE FUNCTION public.logistics_fust_maten_terugval()
+RETURNS TABLE(fust_type_id uuid, fust_key text, vbn_code integer, name text,
+              length_mm numeric, width_mm numeric, height_mm numeric,
+              lengte_bron text, breedte_bron text, hoogte_bron text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+#variable_conflict use_column
+DECLARE v_fc text; v_fd text;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_fust_maten_terugval');
+  IF to_regprocedure('public.floricode_packaging_types()') IS NOT NULL THEN
+    v_fc := $q$SELECT DISTINCT ON (c.code::text)
+                 CASE WHEN c.code::text ~ '^[0-9]+$' THEN c.code::text::int END AS code,
+                 public.logistics_pos_num(c.length_mm::text) AS l, public.logistics_pos_num(c.width_mm::text) AS w,
+                 public.logistics_pos_num(c.height_mm::text) AS h
+               FROM public.floricode_packaging_types() c ORDER BY c.code::text, c.expiry_date DESC NULLS FIRST$q$;
+  ELSIF to_regclass('public.floricode_records') IS NOT NULL THEN
+    v_fc := $q$SELECT DISTINCT ON (r.data->>'code')
+                 CASE WHEN (r.data->>'code') ~ '^[0-9]+$' THEN (r.data->>'code')::int END AS code,
+                 public.logistics_pos_num(r.data->>'length') AS l, public.logistics_pos_num(r.data->>'width') AS w,
+                 public.logistics_pos_num(r.data->>'height') AS h
+               FROM public.floricode_records r WHERE r.resource = 'LoadCarrier'
+               ORDER BY r.data->>'code', (r.data->>'expiry_date') DESC NULLS FIRST$q$;
+  ELSE
+    v_fc := $q$SELECT NULL::int AS code, NULL::numeric AS l, NULL::numeric AS w, NULL::numeric AS h WHERE false$q$;
+  END IF;
+  IF to_regclass('public.floriday_packings_cache') IS NOT NULL THEN
+    v_fd := $q$SELECT DISTINCT ON (p.floriday_id) p.floriday_id AS id, p.data->>'customPackageId' AS id2,
+                 public.logistics_pos_num(coalesce(p.data->'dimension'->>'length', p.data->'dimensions'->>'length', p.data->>'lengthInMm', p.data->>'length')) AS l,
+                 public.logistics_pos_num(coalesce(p.data->'dimension'->>'width', p.data->'dimensions'->>'width', p.data->>'widthInMm', p.data->>'width')) AS w,
+                 public.logistics_pos_num(coalesce(p.data->'dimension'->>'height', p.data->'dimensions'->>'height', p.data->>'heightInMm', p.data->>'height')) AS h
+               FROM public.floriday_packings_cache p WHERE coalesce(p.is_deleted, false) = false
+               ORDER BY p.floriday_id, p.updated_at DESC NULLS LAST$q$;
+  ELSE
+    v_fd := $q$SELECT NULL::text AS id, NULL::text AS id2, NULL::numeric AS l, NULL::numeric AS w, NULL::numeric AS h WHERE false$q$;
+  END IF;
+  RETURN QUERY EXECUTE format($q$
+    WITH fc AS (%s), fd AS (%s)
+    SELECT f.id, f.fust_key, f.vbn_code, f.name,
+      coalesce(fc.l, fdx.l, public.logistics_pos_num(f.length_mm::text)),
+      coalesce(fc.w, fdx.w, public.logistics_pos_num(f.width_mm::text)),
+      coalesce(fc.h, fdx.h, public.logistics_pos_num(f.height_mm::text)),
+      CASE WHEN fc.l IS NOT NULL THEN 'floricode' WHEN fdx.l IS NOT NULL THEN 'floriday' WHEN public.logistics_pos_num(f.length_mm::text) IS NOT NULL THEN 'handmatig' ELSE 'onbekend' END,
+      CASE WHEN fc.w IS NOT NULL THEN 'floricode' WHEN fdx.w IS NOT NULL THEN 'floriday' WHEN public.logistics_pos_num(f.width_mm::text) IS NOT NULL THEN 'handmatig' ELSE 'onbekend' END,
+      CASE WHEN fc.h IS NOT NULL THEN 'floricode' WHEN fdx.h IS NOT NULL THEN 'floriday' WHEN public.logistics_pos_num(f.height_mm::text) IS NOT NULL THEN 'handmatig' ELSE 'onbekend' END
+    FROM public.fust_types f
+    LEFT JOIN fc ON fc.code = coalesce(f.vbn_code, CASE WHEN f.fust_key ~ '^vbn:[0-9]+$' THEN substr(f.fust_key, 5)::int END)
+    LEFT JOIN LATERAL (SELECT fd.l, fd.w, fd.h FROM fd
+                        WHERE nullif(f.custom_package_id, '') IS NOT NULL AND (fd.id = f.custom_package_id OR fd.id2 = f.custom_package_id)
+                        LIMIT 1) fdx ON true
+  $q$, v_fc, v_fd);
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_fust_maten_terugval() TO authenticated, service_role;
+
+-- 1: fustmaten. Voorraad (voorraad_fust_dimensions) als die bestaat, anders de eigen terugval.
+CREATE OR REPLACE FUNCTION public.logistics_fust_maten()
+RETURNS TABLE(fust_type_id uuid, fust_key text, vbn_code integer, name text,
+              length_mm numeric, width_mm numeric, height_mm numeric,
+              lengte_bron text, breedte_bron text, hoogte_bron text, pad text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+#variable_conflict use_column
+DECLARE j jsonb; v_src text;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_fust_maten');
+  IF to_regprocedure('public.voorraad_fust_dimensions()') IS NOT NULL THEN
+    FOR j IN EXECUTE 'SELECT to_jsonb(x) FROM public.voorraad_fust_dimensions() x' LOOP
+      fust_type_id := (j->>'fust_type_id')::uuid;
+      fust_key := j->>'fust_key';
+      vbn_code := CASE WHEN (j->>'vbn_code') ~ '^[0-9]+$' THEN (j->>'vbn_code')::int END;
+      name := j->>'name';
+      length_mm := public.logistics_pos_num(j->>'length_mm');
+      width_mm := public.logistics_pos_num(j->>'width_mm');
+      height_mm := public.logistics_pos_num(j->>'height_mm');
+      v_src := nullif(j->>'dimension_source', 'onbekend');
+      lengte_bron := CASE WHEN length_mm IS NULL THEN 'onbekend' ELSE coalesce(j->>'length_source', j->>'lengte_bron', v_src, 'voorraad') END;
+      breedte_bron := CASE WHEN width_mm IS NULL THEN 'onbekend' ELSE coalesce(j->>'width_source', j->>'breedte_bron', v_src, 'voorraad') END;
+      hoogte_bron := CASE WHEN height_mm IS NULL THEN 'onbekend' ELSE coalesce(j->>'height_source', j->>'hoogte_bron', v_src, 'voorraad') END;
+      pad := 'voorraad';
+      RETURN NEXT;
+    END LOOP;
+    RETURN;
+  END IF;
+  RETURN QUERY SELECT t.fust_type_id, t.fust_key, t.vbn_code, t.name, t.length_mm, t.width_mm, t.height_mm,
+                      t.lengte_bron, t.breedte_bron, t.hoogte_bron, 'terugval'::text
+                 FROM public.logistics_fust_maten_terugval() t;
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_fust_maten() TO authenticated, service_role;
+
+-- 2: eigen terugval voor artikelkenmerken (S15, S02, fust) uit het Floriday-handelsitem.
+-- Leest nooit products.custom_fields.
+CREATE OR REPLACE FUNCTION public.logistics_artikel_vbn_terugval(p_product_id uuid)
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_ti text; v jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_artikel_vbn_terugval');
+  SELECT coalesce(nullif(p.floriday_trade_item_id, ''), nullif(p.trade_item_key, '')) INTO v_ti FROM public.products p WHERE p.id = p_product_id;
+  IF v_ti IS NULL OR to_regclass('public.floriday_trade_items_cache') IS NULL THEN
+    RETURN jsonb_build_object('bron', 'geen', 's02_cm', NULL, 's15_cm', NULL, 'vbn_package_code', NULL, 'custom_package_id', NULL);
+  END IF;
+  EXECUTE $q$
+    SELECT jsonb_build_object(
+      'bron', 'floriday_handelsitem',
+      's15_cm', public.logistics_vbn_cm('S15', (SELECT x->>'vbnValueCode' FROM jsonb_array_elements(coalesce(c.data->'characteristics', '[]'::jsonb)) x WHERE x->>'vbnCode' = 'S15' LIMIT 1)),
+      's02_cm', public.logistics_vbn_cm('S02', (SELECT x->>'vbnValueCode' FROM jsonb_array_elements(coalesce(c.data->'characteristics', '[]'::jsonb)) x WHERE x->>'vbnCode' = 'S02' LIMIT 1)),
+      'vbn_package_code', (SELECT CASE WHEN (pc->'package'->>'vbnPackageCode') ~ '^[0-9]+$' THEN (pc->'package'->>'vbnPackageCode')::int END
+                             FROM jsonb_array_elements(coalesce(c.data->'packingConfigurations', '[]'::jsonb)) pc
+                            ORDER BY (pc->>'primary')::boolean DESC NULLS LAST LIMIT 1),
+      'custom_package_id', (SELECT nullif(pc->'package'->>'customPackageId', '')
+                             FROM jsonb_array_elements(coalesce(c.data->'packingConfigurations', '[]'::jsonb)) pc
+                            ORDER BY (pc->>'primary')::boolean DESC NULLS LAST LIMIT 1))
+      FROM public.floriday_trade_items_cache c
+     WHERE (c.floriday_id = $1 OR c.data->>'tradeItemId' = $1) AND coalesce(c.is_deleted, false) = false
+     LIMIT 1$q$ INTO v USING v_ti;
+  RETURN coalesce(v, jsonb_build_object('bron', 'geen', 's02_cm', NULL, 's15_cm', NULL, 'vbn_package_code', NULL, 'custom_package_id', NULL));
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_artikel_vbn_terugval(uuid) TO authenticated, service_role;
+
+-- 2: artikelkenmerken. Voorraad (voorraad_article_vbn) als die bestaat, anders de eigen terugval.
+CREATE OR REPLACE FUNCTION public.logistics_artikel_vbn(p_product_id uuid)
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE j jsonb;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_artikel_vbn');
+  IF to_regprocedure('public.voorraad_article_vbn(uuid)') IS NOT NULL THEN
+    EXECUTE 'SELECT to_jsonb(x) FROM public.voorraad_article_vbn($1) x LIMIT 1' INTO j USING p_product_id;
+    IF j ? 'voorraad_article_vbn' AND jsonb_typeof(j->'voorraad_article_vbn') = 'object' THEN j := j->'voorraad_article_vbn'; END IF;
+    j := coalesce(j, '{}'::jsonb);
+    RETURN jsonb_build_object(
+      'pad', 'voorraad',
+      'bron', coalesce(j->>'bron', j->>'source', 'voorraad'),
+      's15_cm', coalesce(public.logistics_pos_num(j->>'s15_cm'), public.logistics_vbn_cm('S15', j->'features'->>'S15')),
+      's02_cm', coalesce(public.logistics_pos_num(j->>'s02_cm'),
+                         CASE WHEN j->>'s02_source' = 'handmatig' THEN public.logistics_pos_num(j->>'s02')
+                              ELSE public.logistics_vbn_cm('S02', coalesce(j->>'s02', j->'features'->>'S02')) END),
+      'vbn_package_code', CASE WHEN coalesce(j->>'vbn_package_code', j->'fust'->>'vbn_code') ~ '^[0-9]+$' THEN coalesce(j->>'vbn_package_code', j->'fust'->>'vbn_code')::int END,
+      'custom_package_id', nullif(coalesce(j->>'custom_package_id', j->'fust'->>'custom_package_id'), ''));
+  END IF;
+  RETURN public.logistics_artikel_vbn_terugval(p_product_id) || jsonb_build_object('pad', 'terugval');
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_artikel_vbn(uuid) TO authenticated, service_role;
+
+-- 1+2: maten per product in één bron. Fustkeuze: handmatig -> VBN-code (rij met de meeste maten) -> custom package.
+-- Maten per veld; ontbreekt een veld bij de gekozen rij, dan uit een andere rij met dezelfde fust_key.
+-- Planthoogte geldt altijd INCLUSIEF pot: handmatig -> S15 (transporthoogte) -> S02 (min. planthoogte incl. pot).
+CREATE OR REPLACE FUNCTION public.logistics_product_maten(p_product_ids uuid[])
+RETURNS TABLE(product_id uuid, product_name text, plants_per_crate integer, fust_type_id uuid, fust_name text, fust_bron text,
+              fust_length_mm numeric, fust_width_mm numeric, fust_height_mm numeric,
+              lengte_bron text, breedte_bron text, hoogte_bron text,
+              plant_height_cm numeric, height_source text, weight_kg numeric,
+              pad_fust text, pad_artikel text, missing_reason text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+#variable_conflict use_column
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_product_maten');
+  IF p_product_ids IS NOT NULL AND cardinality(p_product_ids) > 2000 THEN
+    RAISE EXCEPTION 'Maximaal 2000 producten per aanvraag.' USING ERRCODE = '22023';
+  END IF;
+  RETURN QUERY
+  WITH fm AS (SELECT * FROM public.logistics_fust_maten()),
+  pr AS (
+    SELECT p.id, p.product, p.plants_per_crate, p.fust_type_id AS hand_fid, p.plant_height_cm AS hand_h, p.weight,
+           public.logistics_artikel_vbn(p.id) AS a
+      FROM public.products p
+     WHERE p_product_ids IS NULL OR p.id = ANY(p_product_ids)
+  ),
+  keuze AS (
+    SELECT pr.*,
+      (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) AS vbn_fid,
+      (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 cp_fid
+      FROM pr
+  ),
+  k2 AS (
+    SELECT k.*, coalesce(k.hand_fid, k.vbn_fid, k.cp_fid) AS fid,
+      CASE WHEN k.hand_fid IS NOT NULL THEN 'handmatig' WHEN k.vbn_fid IS NOT NULL THEN 'vbn' WHEN k.cp_fid IS NOT NULL THEN 'floriday' END AS fbron
+      FROM keuze k
+  ),
+  maat AS (
+    SELECT k.*, m.name AS mname, m.pad AS mpad,
+      coalesce(m.length_mm, lx.length_mm) AS l, CASE WHEN m.length_mm IS NOT NULL THEN m.lengte_bron ELSE coalesce(lx.lengte_bron, 'onbekend') END AS lb,
+      coalesce(m.width_mm, wx.width_mm) AS w, CASE WHEN m.width_mm IS NOT NULL THEN m.breedte_bron ELSE coalesce(wx.breedte_bron, 'onbekend') END AS wb,
+      coalesce(m.height_mm, hx.height_mm) AS h, CASE WHEN m.height_mm IS NOT NULL THEN m.hoogte_bron ELSE coalesce(hx.hoogte_bron, 'onbekend') END AS hb
+      FROM k2 k
+      LEFT JOIN fm m ON m.fust_type_id = k.fid
+      LEFT JOIN LATERAL (SELECT m2.length_mm, m2.lengte_bron FROM fm m2 WHERE m.fust_key IS NOT NULL AND m2.fust_key = m.fust_key AND m2.length_mm IS NOT NULL ORDER BY m2.fust_type_id LIMIT 1) lx ON true
+      LEFT JOIN LATERAL (SELECT m2.width_mm, m2.breedte_bron FROM fm m2 WHERE m.fust_key IS NOT NULL AND m2.fust_key = m.fust_key AND m2.width_mm IS NOT NULL ORDER BY m2.fust_type_id LIMIT 1) wx ON true
+      LEFT JOIN LATERAL (SELECT m2.height_mm, m2.hoogte_bron 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) hx ON true
+  ),
+  hoogte AS (
+    SELECT x.*,
+      public.logistics_pos_num(x.hand_h::text) AS hh,
+      public.logistics_pos_num(x.a->>'s15_cm') AS s15,
+      public.logistics_pos_num(x.a->>'s02_cm') AS s02,
+      (SELECT b.bron FROM public.logistics_gegevens_bron b
+        WHERE b.onderwerp = 'product' AND b.sleutel = x.id::text AND b.veld = 'plant_height_cm'
+          AND public.logistics_pos_num(b.waarde) = public.logistics_pos_num(x.hand_h::text) LIMIT 1) AS hand_bron
+      FROM maat x
+  )
+  SELECT h.id, h.product, h.plants_per_crate::int, h.fid, h.mname, h.fbron,
+    h.l, h.w, h.h, h.lb, h.wb, h.hb,
+    coalesce(h.hh, h.s15, h.s02),
+    CASE WHEN h.hh IS NOT NULL THEN coalesce(h.hand_bron, 'handmatig')
+         WHEN h.s15 IS NOT NULL THEN 'floricode_s15'
+         WHEN h.s02 IS NOT NULL THEN 'floricode_s02' END,
+    public.logistics_pos_num(regexp_replace(coalesce(h.weight::text, ''), '[^0-9.,]', '', 'g')),
+    coalesce(h.mpad, (SELECT fm.pad FROM fm LIMIT 1)), h.a->>'pad',
+    CASE
+      WHEN h.fid IS NULL AND h.a->>'vbn_package_code' IS NULL AND h.a->>'custom_package_id' IS NULL
+        THEN format('Bij "%s" is geen fustsoort bekend: kies de fustsoort bij het product in Voorraad.', h.product)
+      WHEN h.fid IS NULL
+        THEN format('Bij "%s" bestaat de fustsoort (VBN %s) niet in Voorraad → Fusten.', h.product, coalesce(h.a->>'vbn_package_code', h.a->>'custom_package_id'))
+      WHEN h.l IS NULL OR h.w IS NULL OR h.h IS NULL
+        THEN format('Fust %s heeft geen volledige maten in Floricode, Floriday of Voorraad → Fusten (ontbreekt: %s).', coalesce(h.mname, 'onbekend'),
+               array_to_string(array_remove(ARRAY[CASE WHEN h.l IS NULL THEN 'lengte' END, CASE WHEN h.w IS NULL THEN 'breedte' END, CASE WHEN h.h IS NULL THEN 'hoogte' END], NULL), ', '))
+      WHEN coalesce(h.hh, h.s15, h.s02) IS NULL
+        THEN format('Bij "%s" is de planthoogte inclusief pot onbekend (geen S15/S02 in Floricode of Floriday, niet handmatig ingevuld).', h.product)
+    END
+  FROM hoogte h;
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_product_maten(uuid[]) TO authenticated, service_role;
+
+-- Bestaande view blijft met dezelfde kolommen werken; de bron is nu logistics_product_maten.
+DO $fs$ BEGIN
+  EXECUTE $v$CREATE OR REPLACE VIEW public.logistics_product_dimensions AS
+    SELECT m.product_id, m.product_name, m.plants_per_crate, m.fust_type_id,
+           CASE m.fust_bron WHEN 'vbn' THEN 'floriday' ELSE m.fust_bron END AS fust_source,
+           m.fust_name, m.fust_length_mm, m.fust_width_mm, m.fust_height_mm,
+           m.plant_height_cm, m.height_source,
+           CASE WHEN m.missing_reason IS NULL THEN coalesce(nullif(m.fust_bron, 'vbn'), 'floriday') ELSE 'onbekend' END AS dimension_source,
+           m.missing_reason
+      FROM public.logistics_product_maten(NULL) m$v$;
+EXCEPTION WHEN undefined_table OR undefined_column OR undefined_function OR invalid_table_definition THEN
+  RAISE NOTICE 'logistiek-engine: view logistics_product_dimensions niet vervangen: %', SQLERRM;
+END $fs$;
+
+-- 3+E4: gegevens voor karindeling, nu met bronnen uit logistics_product_maten.
+-- Gewicht per fust alleen gevraagd als de gebruikte ladingdrager een kg-grens heeft.
+-- Lagen per kar: laaghoogte = max(fusthoogte, planthoogte inclusief pot).
+CREATE OR REPLACE FUNCTION public.logistics_data_gereedheid(p_product_ids uuid[] DEFAULT NULL)
+RETURNS TABLE(product_id uuid, product text, ladingdrager text, methode text, in_open_order boolean,
+              ontbrekend text[], velden jsonb, voorstel jsonb, uitleg text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+#variable_conflict use_column
+DECLARE v_methode text; v_carrier text; c record; v_ids uuid[];
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_data_gereedheid');
+  SELECT CASE WHEN coalesce(s.settings->'karrenindeling'->'fields'->>'cart_layout_method', s.settings->'karrenindeling'->>'cart_layout_method') = 'afmetingen'
+              THEN 'afmetingen' ELSE 'belading' END,
+         nullif(btrim(coalesce(s.settings->'karrenindeling'->'fields'->>'default_carrier_type', s.settings->'karrenindeling'->>'default_carrier_type')), '')
+    INTO v_methode, v_carrier
+    FROM public.logistics_rule_configs s WHERE s.is_active ORDER BY s.updated_at DESC LIMIT 1;
+  v_methode := coalesce(v_methode, 'belading');
+  SELECT t.code, t.name, t.layer_length_cm, t.layer_width_cm, t.max_height_cm, t.max_weight_kg INTO c
+    FROM public.load_carrier_types t
+   WHERE t.is_active AND (t.code = v_carrier OR (v_carrier IS NULL AND t.is_default))
+   ORDER BY (t.code = v_carrier) DESC NULLS LAST LIMIT 1;
+
+  SELECT array_agg(DISTINCT x) INTO v_ids FROM (
+    SELECT oi.product_id AS x FROM public.orders o JOIN public.order_items oi ON oi.order_id = o.id
+     WHERE p_product_ids IS NULL AND o.deleted_at IS NULL AND o.cancelled_at IS NULL AND coalesce(o.is_reservation, false) = false
+       AND lower(coalesce(o.status, '')) = 'nog te picken' AND oi.product_id IS NOT NULL
+    UNION SELECT unnest(p_product_ids)) q WHERE x IS NOT NULL;
+  IF v_ids IS NULL THEN RETURN; END IF;
+
+  RETURN QUERY
+  WITH open_p AS (
+    SELECT DISTINCT oi.product_id FROM public.orders o JOIN public.order_items oi ON oi.order_id = o.id
+     WHERE o.deleted_at IS NULL AND o.cancelled_at IS NULL AND coalesce(o.is_reservation, false) = false
+       AND lower(coalesce(o.status, '')) = 'nog te picken' AND oi.product_id = ANY(v_ids)
+  ),
+  p AS (
+    SELECT pr.id, pr.product, pr.plants_per_crate, pr.crates_per_layer, pr.layers_per_cart, pr.floriday_packing_source,
+           mt.fust_type_id, mt.fust_name, mt.fust_bron, mt.fust_length_mm AS length_mm, mt.fust_width_mm AS width_mm, mt.fust_height_mm AS height_mm,
+           mt.lengte_bron, mt.breedte_bron, mt.hoogte_bron, mt.plant_height_cm, mt.height_source, mt.weight_kg,
+           (op.product_id IS NOT NULL) AS in_open
+      FROM public.products pr
+      JOIN public.logistics_product_maten(v_ids) mt ON mt.product_id = pr.id
+      LEFT JOIN open_p op ON op.product_id = pr.id
+  ),
+  m AS (
+    SELECT p.*,
+      array_remove(ARRAY[
+        CASE WHEN coalesce(p.plants_per_crate, 0) <= 0 THEN 'plants_per_crate' END,
+        CASE WHEN v_methode = 'belading' AND coalesce(p.crates_per_layer, 0) <= 0 THEN 'crates_per_layer' END,
+        CASE WHEN v_methode = 'belading' AND coalesce(p.layers_per_cart, 0) <= 0 THEN 'layers_per_cart' END,
+        CASE WHEN v_methode = 'afmetingen' AND p.fust_type_id IS NULL THEN 'fust_type_id' END,
+        CASE WHEN v_methode = 'afmetingen' AND p.fust_type_id IS NOT NULL AND (p.length_mm IS NULL OR p.width_mm IS NULL OR p.height_mm IS NULL) THEN 'fust_maten' END,
+        CASE WHEN v_methode = 'afmetingen' AND p.plant_height_cm IS NULL THEN 'plant_height_cm' END,
+        CASE WHEN coalesce(c.max_weight_kg, 0) > 0 AND p.weight_kg IS NULL THEN 'weight' END
+      ], NULL) AS mist,
+      CASE WHEN p.length_mm > 0 AND p.width_mm > 0 AND c.layer_length_cm > 0 AND c.layer_width_cm > 0 THEN
+        greatest(floor(c.layer_length_cm * 10 / p.length_mm) * floor(c.layer_width_cm * 10 / p.width_mm),
+                 floor(c.layer_length_cm * 10 / p.width_mm) * floor(c.layer_width_cm * 10 / p.length_mm))::int END AS calc_cpl,
+      CASE WHEN p.plant_height_cm > 0 AND c.max_height_cm > 0 THEN
+        floor(c.max_height_cm / greatest(p.plant_height_cm, coalesce(p.height_mm, 0) / 10.0))::int END AS calc_lpc
+    FROM p
+  )
+  SELECT m.id, m.product, c.code, v_methode, m.in_open, m.mist,
+    jsonb_build_object(
+      'plants_per_crate', jsonb_build_object('waarde', m.plants_per_crate, 'bron', CASE WHEN m.plants_per_crate > 0 THEN coalesce(m.floriday_packing_source, 'product') END),
+      'crates_per_layer', jsonb_build_object('waarde', m.crates_per_layer, 'bron', CASE WHEN m.crates_per_layer > 0 THEN coalesce(m.floriday_packing_source, 'product') END),
+      'layers_per_cart', jsonb_build_object('waarde', m.layers_per_cart, 'bron', CASE WHEN m.layers_per_cart > 0 THEN coalesce(m.floriday_packing_source, 'product') END),
+      'weight', jsonb_build_object('waarde', m.weight_kg, 'bron', CASE WHEN m.weight_kg IS NOT NULL THEN 'product' END,
+                                   'nodig', coalesce(c.max_weight_kg, 0) > 0, 'grens_kg', c.max_weight_kg),
+      'plant_height_cm', jsonb_build_object('waarde', m.plant_height_cm, 'bron', m.height_source, 'inclusief_pot', true),
+      'fust_type_id', jsonb_build_object('waarde', m.fust_type_id, 'bron', m.fust_bron, 'naam', m.fust_name),
+      'fust_length_mm', jsonb_build_object('waarde', m.length_mm, 'bron', m.lengte_bron),
+      'fust_width_mm', jsonb_build_object('waarde', m.width_mm, 'bron', m.breedte_bron),
+      'fust_height_mm', jsonb_build_object('waarde', m.height_mm, 'bron', m.hoogte_bron)),
+    jsonb_strip_nulls(jsonb_build_object(
+      'crates_per_layer', CASE WHEN m.calc_cpl > 0 THEN jsonb_build_object('waarde', m.calc_cpl, 'bron', 'berekend',
+          'berekening', format('fust %s×%s mm op laag %s×%s cm (%s)', m.length_mm, m.width_mm, c.layer_length_cm, c.layer_width_cm, c.name)) END,
+      'layers_per_cart', CASE WHEN m.calc_lpc > 0 THEN jsonb_build_object('waarde', m.calc_lpc, 'bron', 'berekend',
+          'berekening', format('hoogte %s cm / grootste van (plant incl. pot %s cm, fust %s cm)', c.max_height_cm, m.plant_height_cm, round(coalesce(m.height_mm, 0) / 10.0, 1))) END)),
+    CASE WHEN cardinality(m.mist) = 0 THEN 'Compleet.'
+         ELSE format('Bij "%s" ontbreekt: %s. Vul dit in bij het product (Voorraad) of hier met "Invullen".', m.product,
+           array_to_string(ARRAY(SELECT CASE f WHEN 'plants_per_crate' THEN 'planten per fust' WHEN 'crates_per_layer' THEN 'fusten per laag'
+             WHEN 'layers_per_cart' THEN 'lagen per kar' WHEN 'fust_type_id' THEN 'fustsoort' WHEN 'fust_maten' THEN 'fustmaten'
+             WHEN 'plant_height_cm' THEN 'planthoogte inclusief pot'
+             WHEN 'weight' THEN format('gewicht per fust (%s heeft een grens van %s kg)', c.name, c.max_weight_kg) ELSE f END FROM unnest(m.mist) f), ', ')) END
+  FROM m
+  ORDER BY cardinality(m.mist) DESC, m.in_open DESC, m.product
+  LIMIT 2000;
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_data_gereedheid(uuid[]) TO authenticated, service_role;
+
+-- 5: "Alles overnemen uit Floricode/Floriday": alleen lege velden, bron vastgelegd.
+-- p_uitvoeren = false geeft alleen de voorvertoning.
+CREATE OR REPLACE FUNCTION public.logistics_data_overnemen(p_uitvoeren boolean)
+RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+#variable_conflict use_column
+DECLARE v_lijst jsonb := '[]'::jsonb; r record; v_n int := 0; v_ids uuid[];
+BEGIN
+  PERFORM public.logistics_acc_guard(CASE WHEN p_uitvoeren THEN 'beheer' ELSE 'ingelogd' END, 'logistics_data_overnemen');
+  SELECT array_agg(DISTINCT oi.product_id) INTO v_ids FROM public.orders o JOIN public.order_items oi ON oi.order_id = o.id
+   WHERE o.deleted_at IS NULL AND o.cancelled_at IS NULL AND coalesce(o.is_reservation, false) = false
+     AND lower(coalesce(o.status, '')) = 'nog te picken' AND oi.product_id IS NOT NULL;
+  IF v_ids IS NULL THEN RETURN jsonb_build_object('uitgevoerd', false, 'velden', v_lijst, 'aantal', 0); END IF;
+  FOR r IN
+    SELECT m.*, p.fust_type_id AS hand_fid, p.plant_height_cm AS hand_h, f.length_mm AS f_l, f.width_mm AS f_w, f.height_mm AS f_h
+      FROM public.logistics_product_maten(v_ids) m
+      JOIN public.products p ON p.id = m.product_id
+      LEFT JOIN public.fust_types f ON f.id = m.fust_type_id
+  LOOP
+    IF r.hand_h IS NULL AND r.height_source IN ('floricode_s15', 'floricode_s02') THEN
+      v_lijst := v_lijst || jsonb_build_object('onderwerp', 'product', 'sleutel', r.product_id, 'naam', r.product_name, 'veld', 'plant_height_cm', 'waarde', r.plant_height_cm, 'bron', r.height_source);
+      IF p_uitvoeren THEN
+        UPDATE public.products SET plant_height_cm = r.plant_height_cm, updated_at = now() WHERE id = r.product_id AND plant_height_cm IS NULL;
+      END IF;
+    END IF;
+    IF r.hand_fid IS NULL AND r.fust_type_id IS NOT NULL THEN
+      v_lijst := v_lijst || jsonb_build_object('onderwerp', 'product', 'sleutel', r.product_id, 'naam', r.product_name, 'veld', 'fust_type_id', 'waarde', r.fust_type_id,
+                                               'bron', CASE r.fust_bron WHEN 'vbn' THEN 'floriday_vbn' ELSE r.fust_bron END);
+      IF p_uitvoeren THEN
+        UPDATE public.products SET fust_type_id = r.fust_type_id, updated_at = now() WHERE id = r.product_id AND fust_type_id IS NULL;
+      END IF;
+    END IF;
+    IF r.fust_type_id IS NOT NULL AND r.f_l IS NULL AND r.fust_length_mm IS NOT NULL AND r.lengte_bron IN ('floricode', 'floriday') THEN
+      v_lijst := v_lijst || jsonb_build_object('onderwerp', 'fust', 'sleutel', r.fust_type_id, 'naam', r.fust_name, 'veld', 'length_mm', 'waarde', r.fust_length_mm, 'bron', r.lengte_bron);
+      IF p_uitvoeren THEN UPDATE public.fust_types SET length_mm = round(r.fust_length_mm)::int, updated_at = now() WHERE id = r.fust_type_id AND length_mm IS NULL; END IF;
+    END IF;
+    IF r.fust_type_id IS NOT NULL AND r.f_w IS NULL AND r.fust_width_mm IS NOT NULL AND r.breedte_bron IN ('floricode', 'floriday') THEN
+      v_lijst := v_lijst || jsonb_build_object('onderwerp', 'fust', 'sleutel', r.fust_type_id, 'naam', r.fust_name, 'veld', 'width_mm', 'waarde', r.fust_width_mm, 'bron', r.breedte_bron);
+      IF p_uitvoeren THEN UPDATE public.fust_types SET width_mm = round(r.fust_width_mm)::int, updated_at = now() WHERE id = r.fust_type_id AND width_mm IS NULL; END IF;
+    END IF;
+    IF r.fust_type_id IS NOT NULL AND r.f_h IS NULL AND r.fust_height_mm IS NOT NULL AND r.hoogte_bron IN ('floricode', 'floriday') THEN
+      v_lijst := v_lijst || jsonb_build_object('onderwerp', 'fust', 'sleutel', r.fust_type_id, 'naam', r.fust_name, 'veld', 'height_mm', 'waarde', r.fust_height_mm, 'bron', r.hoogte_bron);
+      IF p_uitvoeren THEN UPDATE public.fust_types SET height_mm = round(r.fust_height_mm)::int, updated_at = now() WHERE id = r.fust_type_id AND height_mm IS NULL; END IF;
+    END IF;
+  END LOOP;
+  -- Ontdubbelen (meerdere producten met hetzelfde fust).
+  SELECT coalesce(jsonb_agg(DISTINCT e), '[]'::jsonb) INTO v_lijst FROM jsonb_array_elements(v_lijst) e;
+  IF p_uitvoeren THEN
+    INSERT INTO public.logistics_gegevens_bron(onderwerp, sleutel, veld, waarde, bron, toelichting, vastgelegd_door)
+    SELECT e->>'onderwerp', e->>'sleutel', e->>'veld', e->>'waarde', e->>'bron', 'Overgenomen via de startlijst', auth.uid()
+      FROM jsonb_array_elements(v_lijst) e
+    ON CONFLICT (onderwerp, sleutel, veld) DO UPDATE SET waarde = EXCLUDED.waarde, bron = EXCLUDED.bron, toelichting = EXCLUDED.toelichting,
+      vastgelegd_door = EXCLUDED.vastgelegd_door, vastgelegd_op = now();
+  END IF;
+  v_n := jsonb_array_length(v_lijst);
+  RETURN jsonb_build_object('uitgevoerd', p_uitvoeren, 'aantal', v_n, 'velden', v_lijst,
+    'per_bron', (SELECT coalesce(jsonb_object_agg(b, n), '{}'::jsonb) FROM (SELECT e->>'bron' b, count(*) n FROM jsonb_array_elements(v_lijst) e GROUP BY 1) q));
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_data_overnemen(boolean) TO authenticated, service_role;
+
+-- 4: algemene standaard-laagmaten per Floriday-ladingdragertype (vaste, klant-onafhankelijke referentie).
+-- Alleen lengte en breedte; hoogte en gewichtsgrens hebben geen algemene standaard en vult de beheerder zelf in.
+CREATE OR REPLACE FUNCTION public.logistics_ladingdrager_referentie()
+RETURNS TABLE(floriday_code text, lengte_cm integer, breedte_cm integer, bron text)
+LANGUAGE sql IMMUTABLE SET search_path TO 'public' AS $$
+  VALUES ('DANISH_TROLLEY', 135, 56, 'Standaard Deense container (CC), 1350×565 mm'),
+         ('DANISH_TROLLEY_NON_CC_RFID', 135, 56, 'Standaard Deense container, 1350×565 mm'),
+         ('DANISH_TROLLEY_WATER_TRAY', 135, 56, 'Standaard Deense container met waterbak, 1350×565 mm'),
+         ('AUCTION_TROLLEY', 135, 56, 'Standaard veilingstapelwagen, 1350×565 mm'),
+         ('EURO_PALLET', 120, 80, 'Europallet (EPAL), 1200×800 mm'),
+         ('HT_EURO_PALLET', 120, 80, 'Europallet (EPAL, HT), 1200×800 mm'),
+         ('BLOCK_PALLET', 120, 100, 'Blokpallet, 1200×1000 mm')
+$$;
+GRANT EXECUTE ON FUNCTION public.logistics_ladingdrager_referentie() TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_ladingdrager_voorstellen()
+RETURNS TABLE(code text, naam text, floriday_code text, veld text, huidig numeric, voorstel numeric, bron text, actie text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+#variable_conflict use_column
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_ladingdrager_voorstellen');
+  RETURN QUERY
+  WITH k AS (
+    SELECT DISTINCT ON (t.code) t.code, t.name, m.floriday_code, t.layer_length_cm, t.layer_width_cm, r.lengte_cm, r.breedte_cm, r.bron
+      FROM public.load_carrier_types t
+      JOIN public.logistics_floriday_carrier_map m ON m.carrier_code = t.code
+      JOIN public.logistics_ladingdrager_referentie() r ON r.floriday_code = m.floriday_code
+     WHERE t.is_active
+     ORDER BY t.code, m.floriday_code
+  )
+  SELECT k.code, k.name, k.floriday_code, v.veld, v.huidig, v.voorstel, k.bron,
+         CASE WHEN coalesce(v.huidig, 0) <= 0 THEN 'invullen' WHEN v.huidig = v.voorstel THEN 'gelijk' ELSE 'afwijkend' END
+    FROM k CROSS JOIN LATERAL (VALUES ('layer_length_cm', k.layer_length_cm::numeric, k.lengte_cm::numeric),
+                                      ('layer_width_cm', k.layer_width_cm::numeric, k.breedte_cm::numeric)) v(veld, huidig, voorstel)
+   ORDER BY k.code, v.veld;
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_ladingdrager_voorstellen() TO authenticated, service_role;
+
+-- Bevestigen per ladingdrager: schrijft alleen lege velden en legt de bron vast. Overschrijft nooit.
+CREATE OR REPLACE FUNCTION public.logistics_ladingdrager_voorstel_bevestigen(p_code text)
+RETURNS jsonb LANGUAGE plpgsql SECURITY DEFINER SET search_path TO 'public' AS $$
+#variable_conflict use_column
+DECLARE r record; v_n int := 0;
+BEGIN
+  PERFORM public.logistics_acc_guard('beheer', 'logistics_ladingdrager_voorstel_bevestigen');
+  FOR r IN SELECT * FROM public.logistics_ladingdrager_voorstellen() v WHERE v.code = p_code AND v.actie = 'invullen' LOOP
+    IF r.veld = 'layer_length_cm' THEN
+      UPDATE public.load_carrier_types SET layer_length_cm = r.voorstel::int, updated_at = now() WHERE code = p_code AND coalesce(layer_length_cm, 0) <= 0;
+    ELSIF r.veld = 'layer_width_cm' THEN
+      UPDATE public.load_carrier_types SET layer_width_cm = r.voorstel::int, updated_at = now() WHERE code = p_code AND coalesce(layer_width_cm, 0) <= 0;
+    END IF;
+    IF FOUND THEN
+      v_n := v_n + 1;
+      INSERT INTO public.logistics_gegevens_bron(onderwerp, sleutel, veld, waarde, bron, toelichting, vastgelegd_door)
+      VALUES ('ladingdrager', p_code, r.veld, r.voorstel::text, 'standaard:' || r.floriday_code, r.bron, auth.uid())
+      ON CONFLICT (onderwerp, sleutel, veld) DO UPDATE SET waarde = EXCLUDED.waarde, bron = EXCLUDED.bron, toelichting = EXCLUDED.toelichting,
+        vastgelegd_door = EXCLUDED.vastgelegd_door, vastgelegd_op = now();
+    END IF;
+  END LOOP;
+  RETURN jsonb_build_object('ok', true, 'code', p_code, 'ingevuld', v_n);
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_ladingdrager_voorstel_bevestigen(text) TO authenticated, service_role;
+
+-- 5: startlijst voor een nieuwe shell.
+CREATE OR REPLACE FUNCTION public.logistics_startlijst()
+RETURNS jsonb LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+DECLARE v_drag int; v_drag_mist int; v_werk boolean; v_prod int; v_prod_mist int;
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_startlijst');
+  SELECT count(*), count(*) FILTER (WHERE coalesce(t.layer_length_cm, 0) <= 0 OR coalesce(t.layer_width_cm, 0) <= 0 OR coalesce(t.max_height_cm, 0) <= 0)
+    INTO v_drag, v_drag_mist
+    FROM public.load_carrier_types t
+   WHERE t.is_active AND NOT EXISTS (SELECT 1 FROM public.logistics_floriday_carrier_map m WHERE m.carrier_code = t.code AND m.floriday_code = 'NONE');
+  SELECT EXISTS (SELECT 1 FROM public.logistics_rule_configs s WHERE s.is_active AND s.settings ? 'karrenindeling') INTO v_werk;
+  SELECT count(*), count(*) FILTER (WHERE cardinality(g.ontbrekend) > 0) INTO v_prod, v_prod_mist FROM public.logistics_data_gereedheid(NULL) g;
+  RETURN jsonb_build_object(
+    'ladingdragers', jsonb_build_object('klaar', v_drag > 0 AND v_drag_mist = 0, 'aantal', v_drag, 'onvolledig', v_drag_mist),
+    'werkwijze', jsonb_build_object('klaar', v_werk),
+    'gereedheid', jsonb_build_object('klaar', v_prod_mist = 0, 'producten', v_prod, 'onvolledig', v_prod_mist));
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_startlijst() TO authenticated, service_role;
+
+CREATE OR REPLACE FUNCTION public.logistics_install_check_198()
+RETURNS TABLE(controle text, ok boolean, toelichting text)
+LANGUAGE plpgsql STABLE SECURITY DEFINER SET search_path TO 'public' AS $$
+BEGIN
+  PERFORM public.logistics_acc_guard('ingelogd', 'logistics_install_check_198');
+  RETURN QUERY SELECT 'Engine: fustmaten uit één bron'::text,
+    to_regprocedure('public.logistics_fust_maten()') IS NOT NULL,
+    CASE WHEN to_regprocedure('public.voorraad_fust_dimensions()') IS NOT NULL THEN 'via Voorraad (voorraad_fust_dimensions)'
+         ELSE 'eigen terugval: Floricode → Floriday → handmatig' END;
+  RETURN QUERY SELECT 'Engine: artikelkenmerken (S15/S02, fust)',
+    to_regprocedure('public.logistics_artikel_vbn(uuid)') IS NOT NULL,
+    CASE WHEN to_regprocedure('public.voorraad_article_vbn(uuid)') IS NOT NULL THEN 'via Voorraad (voorraad_article_vbn)'
+         ELSE 'eigen terugval: Floriday-handelsitem' END;
+  RETURN QUERY SELECT 'Engine: view logistics_product_dimensions gebruikt logistics_product_maten',
+    coalesce(pg_get_viewdef('public.logistics_product_dimensions'::regclass) LIKE '%logistics_product_maten%', false), 'view';
+  RETURN QUERY SELECT 'Engine: gereedheid vraagt gewicht alleen bij kg-grens',
+    coalesce(pg_get_functiondef('public.logistics_data_gereedheid(uuid[])'::regprocedure) LIKE '%max_weight_kg%', false), 'logistics_data_gereedheid';
+  RETURN QUERY SELECT 'Engine: startlijst en standaardmaten ladingdragers',
+    to_regprocedure('public.logistics_startlijst()') IS NOT NULL AND to_regprocedure('public.logistics_ladingdrager_voorstel_bevestigen(text)') IS NOT NULL,
+    'logistics_startlijst + logistics_ladingdrager_voorstel_bevestigen';
+  RETURN QUERY SELECT 'Engine: bronregistratie', to_regclass('public.logistics_gegevens_bron') IS NOT NULL, 'logistics_gegevens_bron';
+EXCEPTION WHEN undefined_table OR undefined_function THEN
+  RETURN QUERY SELECT 'Engine: maten 1.0.198'::text, false, SQLERRM;
+END $$;
+GRANT EXECUTE ON FUNCTION public.logistics_install_check_198() TO authenticated, service_role;
+
+DO $do$ DECLARE d text;
+BEGIN
+  d := pg_get_functiondef('public.logistics_install_check()'::regprocedure);
+  IF position('logistics_install_check_198' in d) = 0 THEN
+    d := replace(d, $r$  RETURN QUERY SELECT * FROM public.logistics_access_check();$r$,
+                    $r$  RETURN QUERY SELECT * FROM public.logistics_install_check_198();
+  RETURN QUERY SELECT * FROM public.logistics_access_check();$r$);
+    EXECUTE d;
+  END IF;
+EXCEPTION WHEN undefined_function THEN NULL;
+END $do$;