remaniement(dossier.clone): simplifications, pas de callback/after, pas d'heritage, mm interface pour cloner les champs public/prive, clonage des PJs avec le nouveau service de clone, ajoute une cle etrangere sur la colonne parent_dossier_id

app/jobs/clone_piece_justificative_job.rb

@@ -1,5 +0,0 @@
-class ClonePieceJustificativeJob < ApplicationJob
-  def perform(from_champ, kopy_champ)
-    from_champ.clone_piece_justificative(kopy_champ)
-  end
-end

app/models/champ.rb

@@ -30,7 +30,6 @@ class Champ < ApplicationRecord
   has_many :geo_areas, -> { order(:created_at) }, dependent: :destroy, inverse_of: :champ
   belongs_to :etablissement, optional: true, dependent: :destroy
   has_many :champs, -> { ordered }, foreign_key: :parent_id, inverse_of: :parent, dependent: :destroy
-  after_create_commit :after_clone, if: :cloned?
 
   delegate :libelle,
     :type_champ,
@@ -217,26 +216,20 @@ class Champ < ApplicationRecord
   end
 
   def clone(dossier:, parent: nil)
-    kopy = deep_clone(only: [:data, :private, :row, :type, :value, :value_json, :external_id, :type_de_champ_id])
+    kopy = deep_clone(only: (private? ? [] : [:value, :value_json]) + [:data, :private, :row, :type, :external_id, :type_de_champ_id],
+                      include: private? ? [] : [:etablissement, :geo_areas])
 
     kopy.dossier = dossier
     kopy.parent = parent if parent
-    kopy
-  end
-
-  def mark_for_delayed_clone_piece_justificative(from)
-    if from.piece_justificative_file.attached?
-      @cloned_from = from
-      @cloned_kopy = self
+    case self
+    when Champs::RepetitionChamp
+      kopy.champs = (private? ? champs.where(row: 0) : champs).map do |champ_de_repetition|
+        champ_de_repetition.clone(dossier: dossier, parent: kopy)
+      end
+    when Champs::PieceJustificativeChamp, Champs::TitreIdentiteChamp
+      PiecesJustificativesService.clone_attachments(self, kopy) if !private? && piece_justificative_file.attached?
     end
-  end
-
-  def after_clone
-    ClonePieceJustificativeJob.perform_later(@cloned_from, @cloned_kopy)
-  end
-
-  def cloned?
-    @cloned_from && @cloned_kopy
+    kopy
   end
 
   def clone_piece_justificative(kopy)

app/models/champs/carte_champ.rb

@@ -115,13 +115,6 @@ class Champs::CarteChamp < Champ
     geo_areas.blank?
   end
 
-  def clone(dossier:, parent: nil)
-    kopy = super(dossier: dossier, parent: parent)
-
-    kopy.geo_areas = geo_areas.map(&:dup)
-    kopy
-  end
-
   private
 
   def selection_utilisateur_legacy_geometry

app/models/champs/piece_justificative_champ.rb

@@ -51,11 +51,4 @@ class Champs::PieceJustificativeChamp < Champ
       piece_justificative_file.service_url
     end
   end
-
-  def clone(dossier:, parent: nil)
-    kopy = super(dossier: dossier, parent: parent)
-
-    kopy.mark_for_delayed_clone_piece_justificative(self)
-    kopy
-  end
 end

app/models/champs/repetition_champ.rb

@@ -77,13 +77,4 @@ class Champs::RepetitionChamp < Champ
       ] + Dossier.champs_for_export(champs, types_de_champ)
     end
   end
-
-  def clone(dossier:, parent: nil)
-    kopy = super(dossier: dossier, parent: parent)
-
-    kopy.champs = champs.map do |champ_de_repetition|
-      champ_de_repetition.clone(dossier: dossier, parent: kopy)
-    end
-    kopy
-  end
 end

app/models/champs/siret_champ.rb

@@ -27,11 +27,4 @@ class Champs::SiretChamp < Champ
   def mandatory_blank?
     mandatory? && Siret.new(siret: value).invalid?
   end
-
-  def clone(dossier:, parent: nil)
-    kopy = super(dossier: dossier, parent: parent)
-
-    kopy.etablissement = etablissement.dup
-    kopy
-  end
 end

app/models/champs/titre_identite_champ.rb

@@ -43,11 +43,4 @@ class Champs::TitreIdentiteChamp < Champ
   def for_api
     nil
   end
-
-  def clone(dossier:, parent: nil)
-    kopy = super(dossier: dossier, parent: parent)
-
-    mark_for_delayed_clone_piece_justificative(kopy)
-    kopy
-  end
 end

app/models/dossier.rb

@@ -131,6 +131,8 @@ class Dossier < ApplicationRecord
   belongs_to :groupe_instructeur, optional: true
   belongs_to :revision, class_name: 'ProcedureRevision', optional: false
   belongs_to :user, optional: true
+  belongs_to :parent_dossier, class_name: 'Dossier', optional: true
+
   has_one :france_connect_information, through: :user
 
   has_one :attestation_template, through: :revision
@@ -140,6 +142,7 @@ class Dossier < ApplicationRecord
 
   belongs_to :transfer, class_name: 'DossierTransfer', foreign_key: 'dossier_transfer_id', optional: true, inverse_of: :dossiers
   has_many :transfer_logs, class_name: 'DossierTransferLog', dependent: :destroy
+  has_many :parent_dossiers, class_name: 'Dossier', foreign_key: 'parent_dossier_id', dependent: :nullify, inverse_of: :parent_dossier
 
   accepts_nested_attributes_for :champs_public
   accepts_nested_attributes_for :champs_private
@@ -475,7 +478,7 @@ class Dossier < ApplicationRecord
   end
 
   def build_default_champs_for_new_dossier
-    revision.build_champs.each do |champ|
+    revision.build_champs_public.each do |champ|
       champs_public << champ
     end
     revision.build_champs_private.each do |champ|
@@ -1179,14 +1182,20 @@ class Dossier < ApplicationRecord
     @sections[champ.parent || (champ.public? ? :public : :private)]
   end
 
+  # while cloning we do not have champ.id. it comes after transaction
+  # so we collect a list of jobs to process. then enqueue this list
   def clone
     cloned_dossier = deep_clone(only: [:autorisation_donnees, :user_id, :revision_id, :groupe_instructeur_id],
                                 include: [:individual, :etablissement]) do |original, kopy|
       if original.is_a?(Dossier)
         kopy.parent_dossier_id = original.id
         kopy.state = Dossier.states.fetch(:brouillon)
-        kopy.champs = original.champs.map { |champ| champ.clone(dossier: kopy) }
-        kopy.champs_private = kopy.revision.types_de_champ_private.map { |tdc| tdc.build_champ(revision: kopy.revision, dossier: kopy) }
+        kopy.champs_public = original.champs_public.map do |champ|
+          champ.clone(dossier: kopy)
+        end
+        kopy.champs_private = original.champs_private.map do |champ|
+          champ.clone(dossier: kopy)
+        end
       end
     end
 

app/services/pieces_justificatives_service.rb

@@ -57,6 +57,8 @@ class PiecesJustificativesService
 
   def self.clone_attachments(original, kopy)
     case original
+    when Champs::PieceJustificativeChamp, Champs::TitreIdentiteChamp
+      clone_attachment(original.piece_justificative_file, kopy.piece_justificative_file)
     when TypeDeChamp
       clone_attachment(original.piece_justificative_template, kopy.piece_justificative_template)
     when Procedure