upload_d_n_d 0.9.1

data/app/controllers/upload_d_n_d/base_attachments_controller.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+module UploadDND
+  # Contrôleur de base contenant toute la logique commune aux attachments
+  # permanents et temporaires.
+  #
+  # Responsabilités:
+  # - Validation des paramètres (signed_blob_id, attribute_name)
+  # - Authentification et autorisation (Devise, UploadDND::Authorization)
+  # - Gestion des erreurs et logging
+  # - Helpers de rendu (Turbo Streams, JSON, HTML)
+  # - Sécurité (CSRF, validation de signature, sanitisation)
+  # - Rate limiting (contrôle du taux de requêtes)
+  class BaseAttachmentsController < ActionController::Base
+    # Inclure Pundit si disponible
+    include Pundit::Authorization if defined?(Pundit)
+
+    # Inclure le rate limiting
+    include UploadDND::RateLimiting
+
+    # Nom d'attribut autorisé (alphanumérique + underscore uniquement)
+    ATTRIBUTE_NAME_FORMAT = /\A[a-z_][a-z0-9_]*\z/
+
+    # Protection CSRF (désactivée uniquement en test)
+    skip_before_action :verify_authenticity_token, if: -> { Rails.env.test? }
+
+    # Authentification (si disponible dans l'app hôte)
+    before_action :authenticate_user_if_available!
+
+    # Gestion des erreurs
+    # IMPORTANT: rescue_from utilise le "dernier match" -> on déclare StandardError en premier
+    # pour laisser les handlers spécifiques (RecordNotFound, etc.) prendre le dessus.
+    rescue_from StandardError, with: :handle_error
+    rescue_from ActiveRecord::RecordNotFound, with: :record_not_found
+    rescue_from ActiveStorage::IntegrityError, with: :blob_integrity_error
+    rescue_from ActionController::BadRequest, with: :bad_request_error
+
+    before_action :validate_params, only: [ :create ]
+    before_action :validate_signed_blob_id_format, only: [ :create ]
+    before_action :find_blob, only: [ :create ]
+
+    # Déclaré après find_blob (@blob connu) et avant les before_action des
+    # sous-classes (autorisation, contraintes), qu'il englobe.
+    around_action :discard_blob_on_rejection, only: [ :create ]
+
+    protected
+
+    # === Purge des blobs refusés ===
+
+    # Avec DirectUpload, le blob est déjà dans le bucket : s'il est refusé
+    # (réponse en erreur ou exception, relancée), on le purge — sous les
+    # garde-fous de UploadDND::RejectedBlob.
+    def discard_blob_on_rejection
+      yield
+    rescue StandardError
+      discard_rejected_blob
+      raise
+    else
+      discard_rejected_blob if response.status >= 400
+    end
+
+    # Ne purge que si l'autorisation a été posée comme réussie
+    # (grant_upload_authorization!) : une requête refusée faute de droits, ou
+    # dont l'autorisation n'a pas abouti (exception, adaptateur inconnu), ne
+    # modifie rien. Un échec de la purge ne masque pas l'erreur d'origine : il
+    # est journalisé, le blob restera au nettoyage.
+    def discard_rejected_blob
+      return unless upload_authorized?
+
+      UploadDND::RejectedBlob.discard(@blob)
+    rescue StandardError => e
+      Rails.logger.error "UploadDND: rejected blob purge failed - #{e.class}: #{e.message}"
+    end
+
+    # À appeler par chaque contrôle d'autorisation, une fois réussi.
+    def grant_upload_authorization!
+      @upload_authorized = true
+    end
+
+    def revoke_upload_authorization!
+      @upload_authorized = false
+    end
+
+    def upload_authorized?
+      @upload_authorized == true
+    end
+
+    # === Callbacks de validation ===
+
+    # SÉCURITÉ : le signed_id vient du navigateur et figure dans chaque URL de
+    # fichier. Un blob déjà rattaché (record ou fichier temporaire) n'est pas
+    # rattaché une seconde fois : il serait partagé avec un autre record.
+    # À déclarer dans les sous-classes après l'autorisation, avant toute écriture.
+    def reject_attached_blob
+      return unless @blob&.attachments&.exists?
+
+      Rails.logger.warn "UploadDND: already attached blob #{@blob.id} refused"
+      render_error(I18n.t("upload_d_n_d.errors.blob_already_attached"), :unprocessable_entity)
+    end
+
+    def validate_params
+      unless params[:signed_blob_id].present? && params[:attribute_name].present?
+        render_error(I18n.t("upload_d_n_d.errors.missing_params"), :bad_request)
+        return
+      end
+
+      # Validation du nom d'attribut (alphanumeric + underscore uniquement)
+      unless params[:attribute_name].match?(ATTRIBUTE_NAME_FORMAT)
+        render_error(I18n.t("upload_d_n_d.errors.invalid_attribute_name"), :bad_request)
+        nil
+      end
+    end
+
+    def find_blob
+      @blob = ActiveStorage::Blob.find_signed(params[:signed_blob_id])
+    rescue ActiveSupport::MessageVerifier::InvalidSignature
+      render_error(I18n.t("upload_d_n_d.errors.invalid_blob_signature"), :unauthorized)
+      nil
+    end
+
+    # === Helpers de rendu ===
+
+    def render_error(message, status = :unprocessable_entity)
+      render json: { error: message }, status: status
+    end
+
+    def render_turbo_stream_replace(target, partial:, locals:)
+      html = render_to_string(partial: partial, formats: [ :html ], locals: locals)
+      turbo_stream_markup = %(<turbo-stream action="replace" target="#{ERB::Util.html_escape(target)}"><template>#{html}</template></turbo-stream>)
+
+      render body: turbo_stream_markup, content_type: "text/vnd.turbo-stream.html"
+    end
+
+    # === Gestion des erreurs ===
+
+    def record_not_found
+      render_error(I18n.t("upload_d_n_d.errors.record_not_found"), :not_found)
+    end
+
+    def blob_integrity_error
+      render_error(I18n.t("upload_d_n_d.errors.corrupted"), :unprocessable_entity)
+    end
+
+    def handle_error(exception)
+      Rails.logger.error "UploadDND Error: #{exception.class} - #{exception.message}"
+      Rails.logger.error exception.backtrace.join("\n")
+
+      render_error(I18n.t("upload_d_n_d.errors.upload_error"), :internal_server_error)
+    end
+
+    # Le détail de l'exception reste dans les logs, jamais dans la réponse.
+    def bad_request_error(exception)
+      Rails.logger.warn "UploadDND BadRequest: #{exception.message}"
+      render_error(I18n.t("upload_d_n_d.errors.bad_request"), :bad_request)
+    end
+
+    # === Logging ===
+
+    def log_upload_success
+      return unless UploadDND.configuration.respond_to?(:on_upload_success)
+
+      UploadDND.configuration.on_upload_success&.call(@blob, current_user)
+    end
+
+    # === Helpers d'authentification ===
+
+    def current_user
+      # Tente de récupérer current_user depuis l'application hôte
+      # En utilisant warden (Devise)
+      if defined?(Warden) && request.env["warden"]
+        request.env["warden"].user
+      elsif respond_to?(:super, true)
+        super
+      else
+        nil
+      end
+    end
+
+    def authenticate_user_if_available!
+      # Si l'app hôte a Devise, on l'utilise
+      if defined?(Devise) && respond_to?(:authenticate_user!, true)
+        authenticate_user!
+      # Sinon, on vérifie qu'un current_user existe si config l'exige
+      elsif UploadDND.configuration.require_authentication
+        unless current_user.present?
+          render_error(I18n.t("upload_d_n_d.errors.authentication_required"), :unauthorized)
+          nil
+        end
+      end
+    end
+
+    # === Helpers d'autorisation ===
+
+    # Délègue au port d'autorisation (UploadDND::Authorization) : lève
+    # Denied, RuleMissing ou ConfigurationError. Fail-closed sans adaptateur.
+    def authorize_with_adapter!(subject, action)
+      UploadDND::Authorization.authorize!(self, subject, action)
+    end
+
+    def render_forbidden
+      render_error(I18n.t("upload_d_n_d.errors.unauthorized"), :forbidden)
+    end
+
+    # === Helpers de session ===
+
+    def current_session_id
+      UploadDND::SessionId.for(session)
+    end
+
+    # === Validation de sécurité ===
+
+    def validate_signed_blob_id_format
+      signed_blob_id = params[:signed_blob_id]
+
+      return if signed_blob_id.blank?
+
+      # Vérifier le format du signed_blob_id
+      unless signed_blob_id.is_a?(String) &&
+             signed_blob_id.length > 20 &&
+             signed_blob_id.match?(/\A[A-Za-z0-9\-_+=]+\z/)
+        Rails.logger.warn "UploadDND: Invalid signed_blob_id format attempted"
+        render_error(I18n.t("upload_d_n_d.errors.invalid_file_token"), :unauthorized)
+        nil
+      end
+    end
+
+    def sanitize_filename(filename)
+      # Supprime les caractères dangereux du nom de fichier
+      filename = filename.to_s.strip
+
+      # Remplace les caractères dangereux
+      filename = filename.gsub(/[^\w\.\-]/, "_")
+
+      # Limite la longueur
+      filename = filename.truncate(255, omission: "")
+
+      # Assure qu'il reste une extension
+      filename = "file#{File.extname(filename)}" if filename.blank?
+
+      filename
+    end
+
+    # === Support Turbo Streams ===
+
+    def turbo_stream_request?
+      params[:format].to_s == "turbo_stream" ||
+        request.headers["Accept"].to_s.include?("text/vnd.turbo-stream.html")
+    end
+  end
+end

data/app/controllers/upload_d_n_d/temporary_attachments_controller.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module UploadDND
+  # Contrôleur dédié à la gestion des attachments temporaires.
+  #
+  # Responsabilités:
+  # - Créer des TemporaryAttachment pour les formulaires qui n'ont pas encore de record
+  # - Supprimer des fichiers temporaires (avant soumission du formulaire)
+  # - Renvoyer la liste des fichiers temporaires pour mise à jour UI
+  #
+  # Utilisé par:
+  # - GET /upload_d_n_d/temporary_attachments?attribute_name=x (liste de la session courante)
+  # - POST /upload_d_n_d/temporary_attachments (lors de l'upload)
+  # - DELETE /upload_d_n_d/temporary_attachments/:id (suppression avant soumission)
+  # - DELETE /upload_d_n_d/temporary_attachments?attribute_name=x (purge, ex: annulation du formulaire)
+  #
+  # Workflow:
+  # 1. User upload file in form (no record yet) → create TemporaryAttachment
+  # 2. User submit form → UsersController calls attach_upload_d_n_d_files helper
+  # 3. Helper transfers temp files to real record and destroys TemporaryAttachment
+  class TemporaryAttachmentsController < BaseAttachmentsController
+    # Autorisation (UploadDND::Authorization, fail-closed)
+    before_action :authorize_upload!, only: [ :create ]
+    before_action :authorize_delete!, only: [ :destroy, :purge ]
+
+    before_action :find_temp_attachment, only: [ :destroy ]
+    before_action :reject_attached_blob, only: [ :create ]
+    before_action :validate_blob_constraints, only: [ :create ]
+
+    # GET /upload_d_n_d/temporary_attachments?attribute_name=documents
+    #
+    # Renvoie le HTML du partial `temp_files_list` pour les fichiers temporaires
+    # de la session courante (ex: restaurer la zone après un rechargement de page
+    # sans repasser par le composant).
+    #
+    # Sécurité: pas d'autorisation Pundit — le scope par session_id est le filtre.
+    # Un utilisateur ne peut voir que ses propres fichiers temporaires.
+    def index
+      attribute_name = params[:attribute_name].to_s
+      return render_error(I18n.t("upload_d_n_d.errors.missing_params"), :bad_request) if attribute_name.blank?
+      return render_error(I18n.t("upload_d_n_d.errors.invalid_attribute_name"), :bad_request) unless attribute_name.match?(ATTRIBUTE_NAME_FORMAT)
+
+      files = TemporaryAttachment.for_session(current_session_id)
+                                  .for_attribute(attribute_name)
+                                  .with_blobs
+
+      render partial: "upload_d_n_d/shared/temp_files_list",
+             formats: [ :html ],
+             locals: { files: files, attribute_name: attribute_name },
+             layout: false
+    end
+
+    # POST /upload_d_n_d/temporary_attachments
+    #
+    # Params:
+    # - signed_blob_id: String (ActiveStorage signed blob ID)
+    # - attribute_name: String (ex: "avatar", "documents")
+    #
+    # Returns:
+    # - Turbo Stream pour remplacer la liste de fichiers
+    # - JSON {status: 'ok'} en mode API
+    def create
+      attribute_name = params[:attribute_name]
+
+      # Sanitize filename avant de créer l'attachment
+      @blob.update(filename: sanitize_filename(@blob.filename.to_s))
+
+      # SÉCURITÉ : Pour les attributs au singulier (has_one_attached probable),
+      # purger les fichiers temporaires existants avant d'en créer un nouveau
+      # Convention Rails : avatar, cover, logo = singulier = has_one
+      #                    documents, images, files = pluriel = has_many
+      if attribute_name.to_s == attribute_name.to_s.singularize
+        # Attribut au singulier → probablement has_one_attached
+        # Purger les fichiers temporaires existants pour cette session + attribut
+        TemporaryAttachment.for_session(current_session_id)
+                           .for_attribute(attribute_name)
+                           .destroy_all
+      end
+
+      temp_attachment = TemporaryAttachment.create!(
+        session_id: current_session_id,
+        attribute_name: attribute_name,
+        user_id: current_user&.id
+      )
+      temp_attachment.blob.attach(@blob)
+
+      render_temp_file_list(attribute_name)
+      log_upload_success
+    rescue ActiveRecord::RecordInvalid => e
+      render_error(I18n.t("upload_d_n_d.errors.save_failed", errors: e.message), :unprocessable_entity)
+    end
+
+    # DELETE /upload_d_n_d/temporary_attachments/:id
+    #
+    # Supprime un fichier temporaire avant soumission du formulaire.
+    #
+    # Sécurité: On ne peut supprimer que les fichiers de sa propre session/user_id.
+    def destroy
+      attribute_name = @temp_attachment.attribute_name
+      @temp_attachment.destroy
+
+      render_temp_file_list(attribute_name)
+      log_deletion
+    end
+
+    # DELETE /upload_d_n_d/temporary_attachments?attribute_name=documents
+    #
+    # Purge tous les fichiers temporaires de la session courante pour cet attribut.
+    # Typiquement appelé par le bouton « Annuler » d'un formulaire de création,
+    # pour que les fichiers déposés ne réapparaissent pas au prochain formulaire.
+    #
+    # Sécurité: scopé sur la session courante uniquement. Renvoie 204.
+    def purge
+      attribute_name = params[:attribute_name].to_s
+      return render_error(I18n.t("upload_d_n_d.errors.missing_params"), :bad_request) if attribute_name.blank?
+      return render_error(I18n.t("upload_d_n_d.errors.invalid_attribute_name"), :bad_request) unless attribute_name.match?(ATTRIBUTE_NAME_FORMAT)
+
+      purged = TemporaryAttachment.for_session(current_session_id)
+                                   .for_attribute(attribute_name)
+                                   .destroy_all
+
+      Rails.logger.info "UploadDND: #{purged.size} temporary file(s) purged - #{attribute_name} by #{current_user&.id || 'anonymous'}"
+      head :no_content
+    end
+
+    private
+
+    def find_temp_attachment
+      # Sécurité: on ne peut supprimer que les fichiers de sa propre session ou utilisateur
+      scope = TemporaryAttachment.where(session_id: current_session_id)
+      scope = scope.or(TemporaryAttachment.where(user_id: current_user&.id)) if current_user
+
+      @temp_attachment = scope.find(params[:id])
+    rescue ActiveRecord::RecordNotFound
+      render_error(I18n.t("upload_d_n_d.errors.file_not_found_or_denied"), :not_found)
+    end
+
+    def render_temp_file_list(attribute_name)
+      files = TemporaryAttachment.for_session(current_session_id)
+                                  .for_attribute(attribute_name)
+                                  .with_blobs
+
+      if turbo_stream_request?
+        render_turbo_stream_replace(
+          "udnd_files_list_#{attribute_name}",
+          partial: "upload_d_n_d/shared/temp_files_list",
+          locals: { files: files, attribute_name: attribute_name }
+        )
+      else
+        respond_to do |format|
+          format.json { render json: { status: "ok", message: I18n.t("upload_d_n_d.success.file_uploaded") }, status: :ok }
+          format.html { redirect_back fallback_location: root_path, notice: I18n.t("upload_d_n_d.success.file_added") }
+          format.any { render json: { status: "ok", message: I18n.t("upload_d_n_d.success.file_uploaded") }, status: :ok }
+        end
+      end
+    end
+
+    def log_deletion
+      Rails.logger.info "UploadDND: Temporary file deleted - #{@temp_attachment.attribute_name} by #{current_user&.id || 'anonymous'}"
+    end
+
+    # Limites du champ visé : celles du modèle si le composant a fourni sa
+    # référence signée (field_ref), sinon la configuration globale (ancien
+    # client, appel direct).
+    def validate_blob_constraints
+      return unless @blob
+
+      constraints = field_constraints
+      return if performed?
+
+      violation = constraints.violation(@blob)
+      render_error(constraints.error_message(violation), :unprocessable_entity) if violation
+    end
+
+    def field_constraints
+      return UploadDND::FieldConstraints.global if params[:field_ref].blank?
+
+      UploadDND::FieldReference.constraints(params[:field_ref], params[:attribute_name])
+    rescue UploadDND::FieldReference::Invalid
+      Rails.logger.warn "UploadDND: invalid field reference for #{params[:attribute_name]}"
+      render_error(I18n.t("upload_d_n_d.errors.invalid_field_reference"), :bad_request)
+      nil
+    end
+
+    # === Autorisation ===
+
+    def authorize_upload!
+      authorize_with_adapter!(:upload_d_n_d_temporary_attachment, :create)
+      grant_upload_authorization!
+    rescue UploadDND::Authorization::Denied
+      render_forbidden
+    end
+
+    def authorize_delete!
+      authorize_with_adapter!(:upload_d_n_d_temporary_attachment, :destroy)
+    rescue UploadDND::Authorization::Denied
+      render_forbidden
+    end
+  end
+end

data/app/helpers/upload_d_n_d/application_helper.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module UploadDND
+  module ApplicationHelper
+    # URL de suppression d'un fichier attaché.
+    #
+    # Mode :engine (défaut) : route DELETE du moteur de la gem, identifiée
+    # par record_gid — aucune route requise côté app, quel que soit le
+    # routing du record (imbriqué, singulier, namespacé).
+    #
+    # Mode :host (legacy, config.delete_route = :host) : route membre
+    # remove_file du record côté app (convention : resources + member
+    # remove_file). Nécessite une route polymorphique — voir README,
+    # section "Records imbriqués". Point d'extension : redéfinissez cette
+    # méthode dans le ApplicationHelper de votre app.
+    def udnd_remove_file_url(record, attachment, attribute_name)
+      if UploadDND.configuration.delete_route == :host
+        query = { file_id: attachment.id, attribute_name: attribute_name }.to_query
+        "#{udnd_record_path(record)}/remove_file?#{query}"
+      else
+        UploadDND::Engine.routes.url_helpers.attachment_path(
+          attachment.id,
+          record_gid: record.to_global_id.to_s,
+          attribute_name: attribute_name
+        )
+      end
+    end
+
+    def udnd_record_path(record)
+      main_app.polymorphic_path(record)
+    rescue NoMethodError, ActionController::UrlGenerationError
+      raise UploadDND::UnroutableRecordError, <<~MSG
+        #{record.class.name} n'a pas de route polymorphique : impossible de
+        construire l'URL de suppression de fichier.
+
+        Deux remèdes :
+
+        1. Déclarer la résolution polymorphique dans config/routes.rb (recommandé).
+           Exemple pour une resource singulière imbriquée
+           (resource :convention sous resources :projects) :
+
+             resolve("Convention") { |convention, options| route_for(:project_convention, convention.project, options) }
+
+        2. Ou surcharger udnd_remove_file_url(record, attachment, attribute_name)
+           dans le ApplicationHelper de votre app.
+
+        Voir la section "Records imbriqués" du README de upload_d_n_d.
+      MSG
+    end
+  end
+end

data/app/helpers/upload_d_n_d/controllers/helpers.rb

@@ -0,0 +1,21 @@
+# lib/upload_d_n_d/controllers/helpers.rb
+module UploadDND
+  module Controllers
+    module Helpers
+      extend ActiveSupport::Concern
+
+      def attach_upload_d_n_d_files(record, attribute_name)
+        # On cherche les fichiers temporaires liés à cette session
+        temps = UploadDND::TemporaryAttachment.where(
+          session_id: UploadDND::SessionId.for(session),
+          attribute_name: attribute_name
+        )
+
+        temps.each do |temp|
+          record.send(attribute_name).attach(temp.blob)
+          temp.destroy # On nettoie après attachement
+        end
+      end
+    end
+  end
+end