ETQ usager, une condition sur une section masque aussi les champs de la section

tchak · claude · tchak · commit 730f81ce2067 · 2026-07-17T23:02:46.000+02:00
Add a section_conditions_hide_champs flag on procedures (false by default,
set to true for newly created procedures). When enabled, a champ is hidden
whenever any of its ancestors (header section or repetition) is hidden,
using the champ tree API. Legacy procedures keep the previous behaviour
where a section condition only hides the section header itself.

- visible? now checks the nearest ancestor and recurses up the chain
- turbo updates toggle non-conditional champs nested under conditional
  sections (conditional_visibility?)
- PDF export skips champs hidden through the cascade
- champs loaded through champs_on_stream now share their dossier instance
  (same technique as champ_for_update), so visibility memoization stays
  within one instance graph
- a re-entrancy guard in visible? protects against section conditions
  targeting a champ inside the section itself (invalid draft config,
  reachable until publication blocks it)

Co-Authored-By: Claude Fable 5 &lt;noreply@anthropic.com&gt;
diff --git a/app/controllers/administrateurs/procedures_controller.rb b/app/controllers/administrateurs/procedures_controller.rb
@@ -103,7 +103,7 @@ def zones
     end
 
     def create
-      new_procedure_params = { max_duree_conservation_dossiers_dans_ds: Expired::DEFAULT_DOSSIER_RENTENTION_IN_MONTH, no_gender: true }
+      new_procedure_params = { max_duree_conservation_dossiers_dans_ds: Expired::DEFAULT_DOSSIER_RENTENTION_IN_MONTH, no_gender: true, section_conditions_hide_champs: true }
         .merge(procedure_params)
         .merge(administrateurs: [current_administrateur])
 
diff --git a/app/controllers/concerns/turbo_champs_concern.rb b/app/controllers/concerns/turbo_champs_concern.rb
@@ -22,7 +22,7 @@ def champ_to_turbo_update(champ, champs)
   end
 
   def champs_to_toggle(champs, to_update)
-    champs.filter { it.conditional? || it.in_repetition? }
+    champs.filter(&:conditional_visibility?)
       .partition(&:visible?)
       .map { champs_to_one_selector(it - to_update) }
   end
diff --git a/app/models/champ.rb b/app/models/champ.rb
@@ -12,6 +12,10 @@ class Champ < ApplicationRecord
 
   attr_readonly :stable_id
 
+  # inverse_of stays disabled: the projection system builds transient champs
+  # with `dossier: self`, and an inverse would register them (and autosave
+  # them) into the loaded champ_data association. Reads share the dossier
+  # instance via DossierChampsConcern#champs_on_stream instead.
   belongs_to :dossier, inverse_of: false, touch: true, optional: false
   has_many_attached :piece_justificative_file
 
diff --git a/app/models/concerns/champ_conditional_concern.rb b/app/models/concerns/champ_conditional_concern.rb
@@ -11,16 +11,37 @@ def dependent_conditions?
     dossier.revision.dependent_conditions(type_de_champ).any?
   end
 
+  def section_conditions_hide_champs?
+    dossier.procedure.section_conditions_hide_champs?
+  end
+
+  # visibility can vary with form data (own condition, repetition membership,
+  # or a conditional ancestor section)
+  def conditional_visibility?
+    conditional? || in_repetition? || (section_conditions_hide_champs? && ancestors.any?(&:conditional?))
+  end
+
   def visible?
     # Huge gain perf for cascade conditions
     return @visible if instance_variable_defined? :@visible
 
-    return false if parent_hidden?
+    # a section condition targeting a champ inside the section itself creates
+    # a cycle (invalid draft config, reachable until publication); treat the
+    # in-progress champ as hidden, so the broken condition computes to nil and
+    # the section stays hidden
+    return false if @visible_computing
 
-    @visible = if conditional?
-      type_de_champ.condition.compute(champs_for_condition)
-    else
-      true
+    @visible_computing = true
+    begin
+      return false if parent_hidden?
+
+      @visible = if conditional?
+        type_de_champ.condition.compute(champs_for_condition)
+      else
+        true
+      end
+    ensure
+      @visible_computing = false
     end
   end
 
@@ -51,11 +72,18 @@ def filled_champs_by_row_id
   end
 
   def parent_hidden?
-    # if there is no row_id, it always has been a root champ
-    return false if !in_repetition?
+    if section_conditions_hide_champs?
+      # hidden as soon as the nearest ancestor (section or repetition) is
+      # hidden; the parent's own visible? recurses up the ancestor chain
+      parent.present? && !parent.visible?
+    else
+      # legacy: only the repetition ancestor can hide a champ
+      # if there is no row_id, it always has been a root champ
+      return false if !in_repetition?
 
-    # otherwise maybe the champ has been moved outside a repetition
-    parent = repetition
-    parent.present? && !parent.visible?
+      # otherwise maybe the champ has been moved outside a repetition
+      parent = repetition
+      parent.present? && !parent.visible?
+    end
   end
 end
diff --git a/app/models/concerns/dossier_champs_concern.rb b/app/models/concerns/dossier_champs_concern.rb
@@ -356,7 +356,15 @@ def discarded_champs_by_public_id
   end
 
   def champs_on_stream
-    @champs_on_stream ||= if user_buffer_stream?
+    @champs_on_stream ||= champs_for_current_stream
+      # champ.dossier is loaded without inverse_of; share this dossier
+      # instance so tree navigation (parent, ancestors) and visibility
+      # memoization stay within one instance graph
+      .each { it.association(:dossier).target = self }
+  end
+
+  def champs_for_current_stream
+    if user_buffer_stream?
       (champs_on_user_buffer_stream + champs_on_main_stream).uniq(&:public_id)
     elsif instructeur_buffer_stream?
       (champs_on_instructeur_buffer_stream + champs_on_main_stream).uniq(&:public_id)
diff --git a/app/models/concerns/procedure_clone_concern.rb b/app/models/concerns/procedure_clone_concern.rb
@@ -80,6 +80,7 @@ module ProcedureCloneConcern
     'routing_alert',
     'api_particulier_token',
     'no_gender',
+    'section_conditions_hide_champs',
     'pro_connect_restriction',
     'pro_connect_for_moral_procedure',
     'robots_indexable',
diff --git a/app/views/dossiers/show.pdf.prawn b/app/views/dossiers/show.pdf.prawn
@@ -227,7 +227,7 @@ end
 
 def add_single_champ(pdf, champ)
   tdc = champ.type_de_champ
-  return if champ.conditional? && !champ.visible?
+  return if !champ.visible? && (champ.conditional? || champ.section_conditions_hide_champs?)
 
   case champ.type
   when 'Champs::PieceJustificativeChamp'
@@ -307,7 +307,7 @@ def add_champs(pdf, champs)
 
   champs.each do |champ|
     if champ.type == 'Champs::HeaderSectionChamp'
-      next if champ.conditional? && !champ.visible?
+      next if !champ.visible? && (champ.conditional? || champ.section_conditions_hide_champs?)
       current_indent = champ.level * section_indent_step
       add_single_champ(pdf, champ)
     elsif champ.repetition?
diff --git a/db/migrate/20260717000000_add_section_conditions_hide_champs_to_procedures.rb b/db/migrate/20260717000000_add_section_conditions_hide_champs_to_procedures.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddSectionConditionsHideChampsToProcedures < ActiveRecord::Migration[8.0]
+  def change
+    add_column :procedures, :section_conditions_hide_champs, :boolean, default: false, null: false
+  end
+end
diff --git a/db/schema.rb b/db/schema.rb
@@ -11,7 +11,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema[8.0].define(version: 2026_07_13_000000) do
+ActiveRecord::Schema[8.0].define(version: 2026_07_17_000000) do
   # These are extensions that must be enabled in order to support this database
   enable_extension "pg_buffercache"
   enable_extension "pg_stat_statements"
@@ -1156,6 +1156,7 @@
     t.boolean "robots_indexable", default: true, null: false
     t.boolean "routing_alert", default: false, null: false
     t.boolean "routing_enabled"
+    t.boolean "section_conditions_hide_champs", default: false, null: false
     t.bigint "service_id"
     t.jsonb "sva_svr", default: {}, null: false
     t.text "tags", default: [], array: true
diff --git a/spec/controllers/users/dossiers_controller_spec.rb b/spec/controllers/users/dossiers_controller_spec.rb
@@ -1004,6 +1004,39 @@
       end
     end
 
+    context 'when a section is conditioned by the updated champ' do
+      include Logic
+
+      let(:types_de_champ_public) do
+        [
+          { type: :yes_no, stable_id: 1 },
+          { type: :header_section, level: 1, stable_id: 10, condition: ds_eq(champ_value(1), constant(true)) },
+          { type: :text, stable_id: 11 },
+        ]
+      end
+      let(:value) { 'false' }
+
+      def selector_for(stable_id)
+        "##{assigns(:dossier).flat_champs_public.find { it.stable_id == stable_id }.input_group_id}"
+      end
+
+      it 'hides the section and the champs under it' do
+        subject
+        expect(assigns(:to_hide)).to include(selector_for(10))
+        expect(assigns(:to_hide)).to include(selector_for(11))
+      end
+
+      context 'when the procedure uses the legacy behaviour' do
+        before { procedure.update!(section_conditions_hide_champs: false) }
+
+        it 'hides only the section' do
+          subject
+          expect(assigns(:to_hide)).to include(selector_for(10))
+          expect(assigns(:to_hide)).not_to include(selector_for(11))
+        end
+      end
+    end
+
     context 'when the champ is a drop_down_list with referentiel' do
       let(:procedure) { create(:procedure, :published, types_de_champ_public: [{ type: :drop_down_list }]) }
 
diff --git a/spec/factories/procedure.rb b/spec/factories/procedure.rb
@@ -18,6 +18,7 @@
     declarative_with_state { nil }
     sva_svr { {} }
     no_gender { true }
+    section_conditions_hide_champs { true }
     api_entreprise_token { JWT.encode({ exp: 2.months.from_now.to_i }, nil, 'none') }
 
     groupe_instructeurs { [association(:groupe_instructeur, :default, procedure: instance, strategy: :build)] }
diff --git a/spec/models/concerns/champ_conditional_concern_spec.rb b/spec/models/concerns/champ_conditional_concern_spec.rb
@@ -44,6 +44,95 @@
       }
     end
 
+    context 'inside a conditional section' do
+      let(:section_condition) { ds_eq(champ_value(1), constant(true)) }
+      let(:procedure) do
+        create(:procedure, types_de_champ_public: [
+          { type: :yes_no, stable_id: 1 },
+          { type: :header_section, level: 1, stable_id: 10, condition: section_condition },
+          { type: :text, stable_id: 11 },
+          { type: :header_section, level: 2, stable_id: 12 },
+          { type: :checkbox, stable_id: 13 },
+          { type: :repetition, stable_id: 14, children: [{ type: :text, stable_id: 15 }] },
+          { type: :header_section, level: 1, stable_id: 20 },
+          { type: :text, stable_id: 21, condition: ds_eq(champ_value(13), constant(true)) },
+        ])
+      end
+      let(:dossier) { create(:dossier, :with_populated_champs, procedure:) }
+
+      def champ(stable_id)
+        dossier.champ_data.find { it.stable_id == stable_id } || dossier.project_champ(dossier.find_type_de_champ_by_stable_id(stable_id))
+      end
+
+      before { champ(1).update_column(:value, yes_no_value) }
+
+      context 'when the section is visible' do
+        let(:yes_no_value) { 'true' }
+
+        it 'every champ under the section is visible' do
+          expect(champ(10).visible?).to be true
+          expect(champ(11).visible?).to be true
+          expect(champ(12).visible?).to be true
+          expect(champ(13).visible?).to be true
+          expect(champ(14).visible?).to be true
+          expect(champ(15).visible?).to be true
+          expect(champ(21).visible?).to be true
+        end
+      end
+
+      context 'when the section is hidden' do
+        let(:yes_no_value) { 'false' }
+
+        it 'every champ under the section is hidden, including nested sections, repetitions and their rows' do
+          expect(champ(10).visible?).to be false
+          expect(champ(11).visible?).to be false
+          expect(champ(12).visible?).to be false
+          expect(champ(13).visible?).to be false
+          expect(champ(14).visible?).to be false
+          expect(champ(15).visible?).to be false
+        end
+
+        it 'a condition targeting a champ inside the hidden section computes as hidden' do
+          expect(champ(21).visible?).to be false
+        end
+
+        it 'the champ outside the section stays visible' do
+          expect(champ(20).visible?).to be true
+        end
+      end
+
+      context 'when the section condition targets a champ inside the section itself' do
+        let(:procedure) do
+          create(:procedure, types_de_champ_public: [
+            { type: :header_section, level: 1, stable_id: 10, condition: section_condition },
+            { type: :yes_no, stable_id: 1 },
+          ])
+        end
+        let(:yes_no_value) { 'false' }
+
+        it 'does not loop' do
+          expect(champ(10).visible?).to be false
+          expect(champ(1).visible?).to be false
+        end
+      end
+
+      context 'when the procedure uses the legacy behaviour' do
+        let(:procedure) do
+          create(:procedure, section_conditions_hide_champs: false, types_de_champ_public: [
+            { type: :yes_no, stable_id: 1 },
+            { type: :header_section, level: 1, stable_id: 10, condition: section_condition },
+            { type: :text, stable_id: 11 },
+          ])
+        end
+        let(:yes_no_value) { 'false' }
+
+        it 'only the section itself is hidden' do
+          expect(champ(10).visible?).to be false
+          expect(champ(11).visible?).to be true
+        end
+      end
+    end
+
     context 'inside a repetition' do
       let(:procedure) do
         create(:procedure, :published, types_de_champ_public: [
@@ -79,6 +168,30 @@
     end
   end
 
+  describe '#conditional_visibility?' do
+    let(:procedure) do
+      create(:procedure, section_conditions_hide_champs:, types_de_champ_public: [
+        { type: :yes_no, stable_id: 1 },
+        { type: :header_section, level: 1, stable_id: 10, condition: ds_eq(champ_value(1), constant(true)) },
+        { type: :text, stable_id: 11 },
+      ])
+    end
+    let(:dossier) { create(:dossier, :with_populated_champs, procedure:) }
+    let(:text_champ) { dossier.champ_data.find { it.stable_id == 11 } }
+
+    context 'when section conditions hide champs' do
+      let(:section_conditions_hide_champs) { true }
+
+      it { expect(text_champ.conditional_visibility?).to be true }
+    end
+
+    context 'with the legacy behaviour' do
+      let(:section_conditions_hide_champs) { false }
+
+      it { expect(text_champ.conditional_visibility?).to be false }
+    end
+  end
+
   describe '#submitted_filled?' do
     context 'when dossier on submitted revision' do
       it { expect(champ.submitted_filled?).to be_falsey }
diff --git a/spec/models/dossier_spec.rb b/spec/models/dossier_spec.rb
@@ -2078,6 +2078,29 @@
           expect(errors).to be_empty
         end
       end
+
+      context "inside a hidden section" do
+        let(:types_de_champ) do
+          [
+            { type: :yes_no, stable_id: 99, mandatory: false },
+            { type: :header_section, level: 1, condition: ds_eq(champ_value(99), constant(true)) },
+            type_de_champ,
+          ]
+        end
+        let(:champ_with_error) { dossier.champ_data.find(&:mandatory?) }
+
+        it 'should not have errors' do
+          expect(errors).to be_empty
+        end
+
+        context "with the legacy behaviour" do
+          let(:procedure) { create(:procedure, section_conditions_hide_champs: false, types_de_champ_public: types_de_champ) }
+
+          it 'should have errors' do
+            expect(errors).not_to be_empty
+          end
+        end
+      end
     end
 
     context "with mandatory SIRET champ" do
diff --git a/spec/system/users/brouillon_spec.rb b/spec/system/users/brouillon_spec.rb
diff --git a/spec/views/dossiers/show.pdf.prawn_spec.rb b/spec/views/dossiers/show.pdf.prawn_spec.rb
