Créer controller_issues_bulk_edit_after_save ?

Ce message a déjà été posté ici : https://www.redmine.org/boards/3/topics/67147
Ceci est pour Redmine !

Pour un plugin, je crée des géométries pour pouvoir géoréférencer des Issues.
Le but de mon problème est de pouvoir copier ces géométries lors de la création d'Issue par copie de masse (plusieurs à la fois). C'est fait via une callback controller_issues_new_after_save comme ceci (lorsqu'il n'y en a qu'une seule) :

module xPointeHook
  module Hooks
    class GeometryIssueHook < Redmine::Hook::Listener
      def controller_issues_new_after_save_geometries(context = { })
        issue = context[:issue]

        if !issue.id.nil? && !issue.project_id.nil?
          if context[:params].key?(:copy_from) && !context[:params][:copy_from].nil?
            project = Project.find(issue.project_id)

            if !project.nil?
              #Rails.logger.info("project = " + project.id.to_s + " / name = " +  project.name)
              #Rails.logger.info("issue source = " + context[:params][:copy_from].to_s)
              if is_project_allow_pointe?(project)
                # Uniquement si le projet destination autorise les pointés
                Pointes.where(issue_id: context[:params][:copy_from]).all.each do |blc_pointe|
                  pointe = Pointes.new( { :issue_id => issue.id,
                                          :pointe => blc_pointe.pointe.nil? ? nil : blc_pointe.pointe.as_text(),
                                          :point_attendu => blc_pointe.point_attendu.nil? ? nil : blc_pointe.point_attendu.as_text(),
                                          :line_attendu => blc_pointe.line_attendu.nil? ? nil : blc_pointe.line_attendu.as_text(),
                                          :polygon_attendu => blc_pointe.polygon_attendu.nil? ? nil :  blc_pointe.polygon_attendu.as_text(),
                                          :state => blc_pointe.state,
                                          :comment => blc_pointe.comment
                                        }
                                      )
                  pointe.save
                end
              end
            end
          end
        end

        return ''
      end

      alias_method :controller_issues_new_after_save, :controller_issues_new_after_save_geometries
    end
  end
end

Je hook d'abord controller_issues_new_after_save, puis, si l"Issue est une copie et que les géométries sont autorisées sur le projet cible (is_project_allow_pointe?), Je copie les lignes de Pointes correspondant à l'Issue source vers la nouvelle Issue. Ça marche parfaitement !
Le problème est ... pour la copie en masse. Il y a controller_issues_bulk_edit_before_save mais pas de controller_issues_bulk_edit_after_save comme demandé par certains développeurs : https://www.redmine.org/issues/8757

Je voudrais faire de même avec la version de copie de masse mais il n'y a pas de callback pour ce cas là

Je suis novice sur les rails.
Ma question est la suivante : est-il possible de hook controller_issues_bulk_edit_before_save, puis de hook chaque Issue avec "after_save" avec ActiveRecord ?
Le problème est que je ne peux pas créer Pointes.new si je n'ai pas l'identifiant de l'Issue et dans controller_issues_bulk_edit_before_save la ligne n'est pas déjà enregistrée et l'identifiant est nul, donc je dois attendre que l'Issue soit vraiment enregistré dans la base de données.

C'est peut-être un moyen de pouvoir ajouter des lignes Pointes après la copie en bloc du problème.
En fait j'ai ce code : (identique au précédent mais le hook spécifique controller_issues_bulk_edit_before_save.

Ce que j'obtiens

Rien puisque ça ne fonctionne pas

Le code existant (l'autre partie, par bulk copie)

module xPointeHook
  module Hooks
    class GeometryIssueHook < Redmine::Hook::Listener

      def controller_issues_bulk_edit_before_save_geometries(context = { })
        if context[:params][:copy].present?
          # Uniquement en cas de copie
          issue = context[:issue]
          Rails.logger.info("issue.id = " + (issue.id.nil? ? "nil" : issue.id.to_s))
          Rails.logger.info("issue.project_id = " + (issue.project_id.nil? ? "nil" : issue.project_id.to_s))

          context[:params].each do |key, value|
            Rails.logger.info("params[#{key}]  =  #{value}")
          end
        end
        Rails.logger.info(">>>>>>>> issue = #{context[:issue]}")
      end

      alias_method :controller_issues_bulk_edit_before_save, :controller_issues_bulk_edit_before_save_geometries
    end
  end
end

Il faudrait que je trouve un moyen de hook les Issues crées comme ça sinon il sera impossible de gérer la copie par groupe.