Merge pull request #13406 from demarche-numerique/push-usuuxqzlxsno

Tech: renommer la relation dossier.champs en champ_data

Author: tchak

app/components/instructeurs/cell_component.rb

@@ -33,7 +33,7 @@ def simple_layout
 
   def raw_value_for_column(dossier, column)
     data = if @column.champ_column?
-      @dossier.champs.find { _1.stable_id == column.stable_id }
+      @dossier.champ_data.find { _1.stable_id == column.stable_id }
     else
       @dossier
     end

app/controllers/champs/champ_controller.rb

@@ -8,7 +8,7 @@ class Champs::ChampController < ApplicationController
   private
 
   def find_champ
-    dossier = Dossier.with_revision.includes(:champs).find(params[:dossier_id])
+    dossier = Dossier.with_revision.includes(:champ_data).find(params[:dossier_id])
     authorize dossier, :read?
 
     type_de_champ = dossier.find_type_de_champ_by_stable_id(params[:stable_id])

app/jobs/bulk_route_job.rb

@@ -6,7 +6,7 @@ class BulkRouteJob < ApplicationJob
   def perform(procedure)
     dossiers = procedure.dossiers
       .with_revision
-      .includes(:procedure, :groupe_instructeur, :champs)
+      .includes(:procedure, :groupe_instructeur, :champ_data)
       .state_not_termine
 
     dossiers.each do |dossier|

app/jobs/migrations/backfill_dossier_repetition_job.rb

@@ -3,16 +3,16 @@
 class Migrations::BackfillDossierRepetitionJob < ApplicationJob
   def perform(dossier_ids)
     Dossier.where(id: dossier_ids)
-      .includes(:champs, revision: :types_de_champ)
+      .includes(:champ_data, revision: :types_de_champ)
       .find_each do |dossier|
         dossier
           .revision
           .types_de_champ
           .filter do |type_de_champ|
-            type_de_champ.type_champ == 'repetition' && dossier.champs.none? { _1.stable_id == type_de_champ.stable_id }
+            type_de_champ.type_champ == 'repetition' && dossier.champ_data.none? { _1.stable_id == type_de_champ.stable_id }
           end
           .each do |type_de_champ|
-            dossier.champs << type_de_champ.build_champ
+            dossier.champ_data << type_de_champ.build_champ
           end
       end
   end

app/lib/recovery/importer.rb

@@ -97,7 +97,7 @@ def load
           import(dossier.justificatif_motivation)
         end
 
-        dossier.champs.each do |champ|
+        dossier.champ_data.each do |champ|
           champ.piece_justificative_file.each { |pj| import(pj) }
 
           if champ.etablissement.present?

app/models/concerns/dossier_champs_concern.rb

@@ -199,19 +199,19 @@ def merge_instructeur_buffer_stream!
   end
 
   def reset_user_buffer_stream!
-    champs.where(stream: Champ::USER_BUFFER_STREAM).destroy_all
+    champ_data.where(stream: Champ::USER_BUFFER_STREAM).destroy_all
 
     # update loaded champ instances
-    association(:champs).target = champs.filter { _1.stream != Champ::USER_BUFFER_STREAM }
+    association(:champ_data).target = champ_data.filter { _1.stream != Champ::USER_BUFFER_STREAM }
 
     reset_champs_cache
   end
 
   def reset_instructeur_buffer_stream!
-    champs.where(stream: Champ::INSTRUCTEUR_BUFFER_STREAM).destroy_all
+    champ_data.where(stream: Champ::INSTRUCTEUR_BUFFER_STREAM).destroy_all
 
     # update loaded champ instances
-    association(:champs).target = champs.filter { _1.stream != Champ::INSTRUCTEUR_BUFFER_STREAM }
+    association(:champ_data).target = champ_data.filter { _1.stream != Champ::INSTRUCTEUR_BUFFER_STREAM }
 
     reset_champs_cache
   end
@@ -268,7 +268,7 @@ def stream
   end
 
   def history
-    champs.filter(&:history_stream?)
+    champ_data.filter(&:history_stream?)
   end
 
   def set_default_value_for_france_connect_champs(user_email)
@@ -302,13 +302,13 @@ def instructeur_changed_columns
   private
 
   def changed_champ_ids_for_merge(stream)
-    stream_h = champs.where(stream:, stable_id: revision_stable_ids)
+    stream_h = champ_data.where(stream:, stable_id: revision_stable_ids)
       .pluck(:stable_id, :row_id, :id)
       .to_h { |(stable_id, row_id, id)| [TypeDeChamp.public_id(stable_id, row_id), id] }
 
     return [[], []] if stream_h.empty?
 
-    main_h = champs.where(stream: Champ::MAIN_STREAM, stable_id: revision_stable_ids)
+    main_h = champ_data.where(stream: Champ::MAIN_STREAM, stable_id: revision_stable_ids)
       .pluck(:stable_id, :row_id, :id)
       .to_h { |(stable_id, row_id, id)| [TypeDeChamp.public_id(stable_id, row_id), id] }
 
@@ -318,14 +318,14 @@ def changed_champ_ids_for_merge(stream)
     changed_ids = main_public_ids.intersection(stream_public_ids).map { main_h[it] }
     stream_ids = stream_h.values
 
-    # mark champs in discarded rows as changed
-    discarded_row_ids = champs.where(stream:, stable_id: revision_stable_ids)
+    # mark champ_data in discarded rows as changed
+    discarded_row_ids = champ_data.where(stream:, stable_id: revision_stable_ids)
       .where.not(row_id: nil)
       .where.not(discarded_at: nil)
       .pluck(:row_id)
 
     if discarded_row_ids.present?
-      changed_ids += champs.where(stream: Champ::MAIN_STREAM, row_id: discarded_row_ids).pluck(:id)
+      changed_ids += champ_data.where(stream: Champ::MAIN_STREAM, row_id: discarded_row_ids).pluck(:id)
     end
 
     [stream_ids, changed_ids]
@@ -334,25 +334,25 @@ def changed_champ_ids_for_merge(stream)
   def merge_buffer_champs(buffer_ids, changed_ids, stream)
     now = Time.zone.now
     history_stream = "#{Champ::HISTORY_STREAM}#{now}"
-    buffer_champs = champs.filter { buffer_ids.member?(it.id) }
+    buffer_champs = champ_data.filter { buffer_ids.member?(it.id) }
 
     transaction do
       # if merging user buffer, discard any instructeur made changes
       if stream == Champ::USER_BUFFER_STREAM
-        champs.where(id: buffer_ids, stream:).pluck(:stable_id, :row_id).each do |(stable_id, row_id)|
-          champs.where(stream: Champ::INSTRUCTEUR_BUFFER_STREAM, stable_id:, row_id:).destroy_all
+        champ_data.where(id: buffer_ids, stream:).pluck(:stable_id, :row_id).each do |(stable_id, row_id)|
+          champ_data.where(stream: Champ::INSTRUCTEUR_BUFFER_STREAM, stable_id:, row_id:).destroy_all
         end
       end
 
-      # move champs with changes from "main" to "history" stream
-      champs.where(id: changed_ids, stream: Champ::MAIN_STREAM).update_all(stream: history_stream)
-      # move champs from "buffer" to "main"
-      champs.where(id: buffer_ids, stream:).update_all(stream: Champ::MAIN_STREAM, updated_at: now, checkpoint: history_stream)
+      # move champ_data with changes from "main" to "history" stream
+      champ_data.where(id: changed_ids, stream: Champ::MAIN_STREAM).update_all(stream: history_stream)
+      # move champ_data from "buffer" to "main"
+      champ_data.where(id: buffer_ids, stream:).update_all(stream: Champ::MAIN_STREAM, updated_at: now, checkpoint: history_stream)
       update_champs_timestamps(buffer_champs, stream)
     end
 
     # update loaded champ instances
-    champs.each do |champ|
+    champ_data.each do |champ|
       if champ.id.in?(changed_ids)
         champ.stream = history_stream
       elsif champ.id.in?(buffer_ids)
@@ -401,7 +401,7 @@ def champs_on_stream
     when Champ::INSTRUCTEUR_BUFFER_STREAM
       (champs_on_instructeur_buffer_stream + champs_on_main_stream).uniq(&:public_id)
     when Champ::USER_HISTORY_STREAM
-      champs
+      champ_data
         # only "main" and "history"
         .reject(&:buffer_stream?)
         # only updates made before last submission
@@ -420,11 +420,11 @@ def revision_stable_ids
   end
 
   def champs_in_revision
-    champs.filter { stable_id_in_revision?(_1.stable_id) }
+    champ_data.filter { stable_id_in_revision?(_1.stable_id) }
   end
 
   def discarded_champs_on_main_stream
-    champs.filter(&:main_stream?).reject { stable_id_in_revision?(_1.stable_id) }
+    champ_data.filter(&:main_stream?).reject { stable_id_in_revision?(_1.stable_id) }
   end
 
   def champs_on_main_stream
@@ -466,11 +466,11 @@ def champ_upsert_by!(type_de_champ, row_id)
     Champ.where(dossier_id: id, row_id: Champ::NULL_ROW_ID).update_all(row_id: nil)
 
     # FIXME: Try to find the champ in memory before querying the database
-    champ = champs.find { _1.stream == stream && _1.public_id == type_de_champ.public_id(row_id) }
+    champ = champ_data.find { _1.stream == stream && _1.public_id == type_de_champ.public_id(row_id) }
 
     if champ.nil?
       champ = Dossier.no_touching do
-        champs
+        champ_data
           .create_with(**type_de_champ.params_for_champ, source_stream: stream)
           .create_or_find_by!(stable_id: type_de_champ.stable_id, row_id:, stream:)
       end
@@ -481,14 +481,14 @@ def champ_upsert_by!(type_de_champ, row_id)
       champ = champ.becomes!(type_de_champ.champ_class)
       champ.assign_attributes(value: nil, value_json: nil, external_id: nil, data: nil)
     elsif stream != Champ::MAIN_STREAM && champ.previously_new_record?
-      main_stream_champ = champs.find_by(stable_id: type_de_champ.stable_id, row_id:, stream: Champ::MAIN_STREAM)
+      main_stream_champ = champ_data.find_by(stable_id: type_de_champ.stable_id, row_id:, stream: Champ::MAIN_STREAM)
       champ.clone_value_from(main_stream_champ) if main_stream_champ.present?
     end
 
-    # If the champ returned from `create_or_find_by` is not the same as the one already loaded in `dossier.champs`, we need to update the association cache
-    loaded_champ = champs.find { [_1.stream, _1.public_id] == [champ.stream, champ.public_id] }
+    # If the champ returned from `create_or_find_by` is not the same as the one already loaded in `dossier.champ_data`, we need to update the association cache
+    loaded_champ = champ_data.find { [_1.stream, _1.public_id] == [champ.stream, champ.public_id] }
     if loaded_champ.present? && loaded_champ.object_id != champ.object_id
-      association(:champs).target = champs - [loaded_champ] + [champ]
+      association(:champ_data).target = champ_data - [loaded_champ] + [champ]
     end
 
     # If the dossier instance on champ has changed we need to update the association cache

app/models/concerns/dossier_clone_concern.rb

@@ -27,7 +27,7 @@ def clone(user: nil)
         kopy.parent_dossier = original
         kopy.user = user || original.user
         kopy.state = Dossier.states.fetch(:brouillon)
-        kopy.champs = cloned_champs.map do |champ|
+        kopy.champ_data = cloned_champs.map do |champ|
           champ.dossier = kopy
           champ
         end

app/models/concerns/dossier_rebase_concern.rb

@@ -40,15 +40,15 @@ def rebase
     # update dossier revision
     update_column(:revision_id, target_revision.id)
 
-    # mark updated champs as rebased
-    champs.where(stable_id: updated_stable_ids).update_all(rebased_at: Time.zone.now)
+    # mark updated champ_data as rebased
+    champ_data.where(stable_id: updated_stable_ids).update_all(rebased_at: Time.zone.now)
 
     # add rows for new repetitions
     target_revision
       .types_de_champ
       .filter { _1.repetition? && _1.stable_id.in?(added_stable_ids) && (_1.mandatory? || _1.private?) }
       .each do |type_de_champ|
-        self.champs << type_de_champ.build_champ(row_id: ULID.generate, rebased_at: Time.zone.now)
+        self.champ_data << type_de_champ.build_champ(row_id: ULID.generate, rebased_at: Time.zone.now)
       end
   end
 end

app/models/concerns/dossier_state_concern.rb

@@ -391,14 +391,14 @@ def clean_champs_after_instruction!
   private
 
   def remove_not_in_revision_champs!
-    champs.where.not(stable_id: revision_stable_ids).where(stream: Champ::MAIN_STREAM).destroy_all
+    champ_data.where.not(stable_id: revision_stable_ids).where(stream: Champ::MAIN_STREAM).destroy_all
   end
 
   def remove_discarded_rows!
-    row_to_remove_ids = champs.filter { _1.row? && _1.discarded? }.map(&:row_id)
+    row_to_remove_ids = champ_data.filter { _1.row? && _1.discarded? }.map(&:row_id)
 
     return if row_to_remove_ids.empty?
-    champs.where(row_id: row_to_remove_ids, stream: Champ::MAIN_STREAM).destroy_all
+    champ_data.where(row_id: row_to_remove_ids, stream: Champ::MAIN_STREAM).destroy_all
   end
 
   def remove_not_visible_or_empty_repetitions!
@@ -407,27 +407,27 @@ def remove_not_visible_or_empty_repetitions!
       .flat_map(&:row_ids)
 
     return if row_to_remove_ids.empty?
-    champs.where(row_id: row_to_remove_ids, stream: Champ::MAIN_STREAM).destroy_all
+    champ_data.where(row_id: row_to_remove_ids, stream: Champ::MAIN_STREAM).destroy_all
   end
 
   def clear_not_visible_or_empty_champs!
     champs_to_clear = project_champs_public_all
       .reject(&:repetition?)
       .filter { _1.blank? || !_1.visible? }
 
-    champs.where(id: champs_to_clear, stream: Champ::MAIN_STREAM).find_each(&:clear)
+    champ_data.where(id: champs_to_clear, stream: Champ::MAIN_STREAM).find_each(&:clear)
   end
 
   def clear_france_connect_champs_piece_justificatives!
     champs_to_clear = project_champs_public.filter(&:france_connect?)
 
     return if champs_to_clear.empty?
-    champs.where(id: champs_to_clear).find_each(&:clear_piece_justificative)
+    champ_data.where(id: champs_to_clear).find_each(&:clear_piece_justificative)
   end
 
   def clear_titres_identite!
-    champ_to_clear_stable_ids = champs.filter do |champ|
-      # Use STI type to avoid querying type_de_champ for orphaned champs
+    champ_to_clear_stable_ids = champ_data.filter do |champ|
+      # Use STI type to avoid querying type_de_champ for orphaned champ_data
       next false unless champ.is_a?(Champs::PieceJustificativeChamp)
 
       begin
@@ -438,7 +438,7 @@ def clear_titres_identite!
       end
     end.to_set(&:stable_id)
 
-    champs.where(stable_id: champ_to_clear_stable_ids).find_each(&:clear)
+    champ_data.where(stable_id: champ_to_clear_stable_ids).find_each(&:clear)
   end
 
   def clear_auto_purged_piece_justificatives!
@@ -450,7 +450,7 @@ def clear_auto_purged_piece_justificatives!
       .filter(&:pj_auto_purge?)
       .map(&:stable_id)
 
-    champs.where(stable_id: champ_to_clear_stable_ids).find_each(&:clear)
+    champ_data.where(stable_id: champ_to_clear_stable_ids).find_each(&:clear)
   end
 
   def remove_attente_avis_notification
@@ -462,7 +462,7 @@ def remove_auto_purged_piece_justificatives!
 
     return if champ_to_remove_ids.empty?
 
-    champs.where(id: champ_to_remove_ids, stream: Champ::MAIN_STREAM).destroy_all
+    champ_data.where(id: champ_to_remove_ids, stream: Champ::MAIN_STREAM).destroy_all
   end
 
   def enqueue_ami_notification(trigger: :dossier_state_change, state: nil)

app/models/dossier.rb

@@ -60,7 +60,7 @@ def self.instruction_action?(action)
 
   # autosave is required to import champ validation errors on the dossier
   # when validating with the :champs_public_value/:champs_private_value contexts
-  has_many :champs, dependent: :destroy, autosave: true
+  has_many :champ_data, dependent: :destroy, class_name: 'Champ', autosave: true
   has_many :commentaires, inverse_of: :dossier, dependent: :destroy
   has_many :commentaires_chronological, -> { chronological }, class_name: 'Commentaire', inverse_of: :dossier
   has_many :preloaded_commentaires, -> { includes(:dossier_correction, :dossier_pending_response, :instructeur, :expert, piece_jointe_attachments: :blob).order(created_at: :desc) }, class_name: 'Commentaire', inverse_of: :dossier
@@ -280,7 +280,7 @@ def classer_sans_suite(motivation: nil, instructeur: nil, processed_at: Time.zon
   scope :hidden_by_administration_since, -> (since) { where('dossiers.hidden_by_administration_at IS NOT NULL AND dossiers.hidden_by_administration_at >= ?', since) }
   scope :hidden_since,                   -> (since) { hidden_by_user_since(since).or(hidden_by_administration_since(since)) }
 
-  scope :with_type_de_champ, -> (stable_id) { joins(:champs).where(champs: { stream: 'main', stable_id: }) }
+  scope :with_type_de_champ, -> (stable_id) { joins(:champ_data).where(champs: { stream: 'main', stable_id: }) }
   scope :without_type_de_champ, -> (stable_id) { where.not(id: with_type_de_champ(stable_id).select(:id)) }
 
   scope :with_unread_messages_for_user, -> {
@@ -1139,7 +1139,7 @@ def prefill_and_enqueue_fetch_external_data_jobs(champs, types_de_champ)
   def purge_freeing_champs_cascade
     transaction do
       yield if block_given?
-      champs.in_batches(of: 50).each(&:destroy_all)
+      champ_data.in_batches(of: 50).each(&:destroy_all)
       destroy
     rescue => e
       Sentry.capture_exception(e, extra: { dossier: id })
@@ -1150,12 +1150,12 @@ def purge_freeing_champs_cascade
   end
 
   def build_default_champs
-    build_default_champs_for(revision.types_de_champ_public) if !champs.any?(&:public?)
-    build_default_champs_for(revision.types_de_champ_private) if !champs.any?(&:private?)
+    build_default_champs_for(revision.types_de_champ_public) if !champ_data.any?(&:public?)
+    build_default_champs_for(revision.types_de_champ_private) if !champ_data.any?(&:private?)
   end
 
   def build_default_champs_for(types_de_champ)
-    self.champs << types_de_champ.filter(&:fillable?).filter_map do |type_de_champ|
+    self.champ_data << types_de_champ.filter(&:fillable?).filter_map do |type_de_champ|
       if type_de_champ.repetition?
         if type_de_champ.private? || type_de_champ.mandatory?
           type_de_champ.build_champ(dossier: self, row_id: ULID.generate)