upload_d_n_d 0.9.1

data/app/components/upload_d_n_d/upload_component.rb

@@ -0,0 +1,204 @@
+module UploadDND
+  class UploadComponent < ViewComponent::Base
+    attr_reader :record, :attribute_name, :multiple, :accepted_types, :max_size, :user, :namespace
+
+    def initialize(
+      attribute_name:,
+      record: nil,
+      user: nil,
+      multiple: nil,
+      accepted_types: nil,
+      max_size: nil,
+      namespace: nil
+    )
+      @record = record
+      @user = user
+      @attribute_name = attribute_name
+      @namespace = namespace
+
+      # Récupère la config depuis le modèle si disponible, sinon utilise les params ou la config globale
+      model_config = get_uploadable_config
+
+      # Détection automatique de multiple basée sur has_one vs has_many
+      # Peut être surchargé explicitement via le paramètre ou la config du modèle
+      @multiple = if multiple.nil?
+        model_config[:multiple].nil? ? detect_multiple_from_attachment : model_config[:multiple]
+      else
+        multiple
+      end
+
+      # Limites du champ, identiques à celles appliquées par le serveur.
+      # accepted_types: et max_size: ne changent que l'affichage : le serveur
+      # applique toujours les limites du modèle.
+      @constraints = field_constraints
+      @accepted_types = accepted_types || @constraints.accepted_extensions
+      @max_size = max_size || @constraints.max_size
+    end
+
+    # Types MIME acceptés, pour le contrôle du navigateur
+    def accepted_mime_types
+      return @constraints.content_types.join(",") if @accepted_types == @constraints.accepted_extensions
+
+      UploadDND::MimeTypes.from_accepted_types(@accepted_types).join(",")
+    end
+
+    # Référence signée du champ, renvoyée au dépôt : le serveur en déduit les
+    # limites du modèle. nil sans record (limites globales).
+    def field_ref
+      return unless record && record.class.respond_to?(:reflect_on_attachment)
+      return unless record.class.reflect_on_attachment(attribute_name)
+
+      UploadDND::FieldReference.generate(record.class, attribute_name)
+    end
+
+    def model_name
+      return attribute_name.to_s.singularize unless record
+
+      # Convertit "Admin::Article" en "admin_article" (pour les IDs DOM)
+      record.class.name.underscore.tr("/", "_")
+    end
+
+    # Génère le GlobalID pour le record (fonctionne avec tous les namespaces)
+    def record_gid
+      # Un record non persisté n'a pas d'ID => GlobalID impossible (MissingModelIdError).
+      return nil unless record&.persisted?
+
+      record.to_global_id.to_s
+    end
+
+    # Détermine l'URL d'attachement : soit vers le moteur de la gem, soit vers une route spécifique
+    def attach_path
+      action_path = record&.persisted? ? :attachments_path : :temporary_attachments_path
+
+      # Si pas de namespace, on utilise les routes internes de l'engine (plus robuste)
+      return UploadDND::Engine.routes.url_helpers.send(action_path) if namespace.blank?
+
+      # Avec namespace, on utilise polymorphic_path pour supporter les routes de l'app hôte
+      begin
+        action = record&.persisted? ? :attachments : :temporary_attachments
+        helpers.polymorphic_path([ namespace, :upload_d_n_d, action ])
+      rescue NoMethodError, ArgumentError, ViewComponent::HelpersCalledBeforeRenderError
+        # En cas d'erreur (ex: helpers non dispos avant render), fallback sur l'engine
+        UploadDND::Engine.routes.url_helpers.send(action_path)
+      end
+    end
+
+    def files
+      if record&.persisted?
+        get_attachments
+      else
+        # Fichiers temporaires de la session courante (formulaire sans record persisté)
+        UploadDND::TemporaryAttachment
+          .for_session(UploadDND::SessionId.for(helpers.session))
+          .for_attribute(attribute_name)
+          .with_blobs
+      end
+    end
+
+    # --- Thème / Couleurs ---
+    # Exposé pour permettre au composant d'injecter des variables CSS cohérentes
+    def main_color
+      UploadDND.configuration.main_color.presence || "#E97451"
+    end
+
+    # Renvoie "r g b" (ex: "233 116 81") pour usage avec `rgb(var(--udnd-accent-rgb) / 0.2)`
+    def main_color_rgb
+      hex = main_color.to_s.delete_prefix("#")
+      hex = hex.chars.map { |c| "#{c}#{c}" }.join if hex.length == 3
+
+      return "233 116 81" unless hex.match?(/\A[0-9a-fA-F]{6}\z/)
+
+      r = hex[0..1].to_i(16)
+      g = hex[2..3].to_i(16)
+      b = hex[4..5].to_i(16)
+      "#{r} #{g} #{b}"
+    end
+
+    private
+
+    def field_constraints
+      return UploadDND::FieldConstraints.global unless record
+
+      UploadDND::FieldConstraints.for(record.class, attribute_name)
+    end
+
+    def get_uploadable_config
+      return {} unless record&.class.respond_to?(:uploadable_attributes)
+
+      record.class.uploadable_attributes[attribute_name.to_sym] || {}
+    end
+
+    # Détecte automatiquement si l'attachment est has_one ou has_many
+    def detect_multiple_from_attachment
+      return false unless record&.respond_to?(attribute_name)
+
+      attachment = record.send(attribute_name)
+
+      # has_many_attached retourne une collection qui respond_to :attach
+      # has_one_attached retourne un objet qui ne respond_to pas :each
+      attachment.is_a?(ActiveStorage::Attached::Many)
+    end
+
+    def get_attachments
+      return [] unless record&.respond_to?(attribute_name)
+
+      attachment = record.public_send(attribute_name)
+      case attachment
+      when ActiveStorage::Attached::Many
+        attachment.blobs
+      when ActiveStorage::Attached::One
+        attachment.attached? ? [ attachment.blob ] : []
+      else
+        []
+      end
+    end
+
+    # Retourne les messages i18n pour JavaScript
+    def i18n_messages
+      {
+        alerts: {
+          singleFileOnly: {
+            title: I18n.t("upload_d_n_d.javascript.alerts.single_file_only.title"),
+            text: I18n.t("upload_d_n_d.javascript.alerts.single_file_only.text")
+          },
+          uploadError: {
+            title: I18n.t("upload_d_n_d.javascript.alerts.upload_error.title"),
+            text: I18n.t("upload_d_n_d.javascript.alerts.upload_error.text")
+          },
+          fileTooLarge: {
+            title: I18n.t("upload_d_n_d.javascript.alerts.file_too_large.title"),
+            text: I18n.t("upload_d_n_d.javascript.alerts.file_too_large.text")
+          },
+          emptyFile: {
+            title: I18n.t("upload_d_n_d.javascript.alerts.empty_file.title"),
+            text: I18n.t("upload_d_n_d.javascript.alerts.empty_file.text")
+          },
+          invalidFormat: {
+            title: I18n.t("upload_d_n_d.javascript.alerts.invalid_format.title"),
+            text: I18n.t("upload_d_n_d.javascript.alerts.invalid_format.text")
+          },
+          suspiciousType: {
+            title: I18n.t("upload_d_n_d.javascript.alerts.suspicious_type.title"),
+            text: I18n.t("upload_d_n_d.javascript.alerts.suspicious_type.text")
+          },
+          attachError: {
+            title: I18n.t("upload_d_n_d.javascript.alerts.attach_error.title"),
+            text: I18n.t("upload_d_n_d.javascript.alerts.attach_error.text")
+          },
+          deleteError: {
+            title: I18n.t("upload_d_n_d.javascript.alerts.delete_error.title"),
+            text: I18n.t("upload_d_n_d.javascript.alerts.delete_error.text")
+          }
+        },
+        confirms: {
+          deleteFile: {
+            title: I18n.t("upload_d_n_d.javascript.confirms.delete_file.title"),
+            text: I18n.t("upload_d_n_d.javascript.confirms.delete_file.text"),
+            confirmButton: I18n.t("upload_d_n_d.javascript.confirms.delete_file.confirm_button"),
+            cancelButton: I18n.t("upload_d_n_d.javascript.confirms.delete_file.cancel_button")
+          }
+        }
+      }
+    end
+  end
+end

data/app/controllers/concerns/upload_d_n_d/rate_limiting.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module UploadDND
+  module RateLimiting
+    extend ActiveSupport::Concern
+
+    included do
+      before_action :check_rate_limit, if: :rate_limiting_enabled?
+    end
+
+    private
+
+    def rate_limiting_enabled?
+      UploadDND.configuration.rate_limit_enabled
+    end
+
+    def check_rate_limit
+      # Clé basée sur l'IP et l'utilisateur si disponible
+      key = rate_limit_key
+
+      # Récupère le compteur actuel pour cette clé
+      count = increment_rate_limit_counter(key)
+
+      max_requests = UploadDND.configuration.rate_limit_max_requests
+      period = UploadDND.configuration.rate_limit_period
+
+      if count > max_requests
+        Rails.logger.warn "UploadDND RateLimit: #{key} exceeded limit (#{count}/#{max_requests})"
+
+        # Calcule le temps restant avant reset
+        retry_after = rate_limit_reset_time(key)
+
+        response.headers["Retry-After"] = retry_after.to_s
+        response.headers["X-RateLimit-Limit"] = max_requests.to_s
+        response.headers["X-RateLimit-Remaining"] = "0"
+        response.headers["X-RateLimit-Reset"] = (Time.current + retry_after.seconds).to_i.to_s
+
+        render_error(
+          I18n.t("upload_d_n_d.errors.rate_limited", seconds: retry_after),
+          :too_many_requests
+        )
+
+        false # Stop processing
+      else
+        # Ajoute les headers informatifs
+        response.headers["X-RateLimit-Limit"] = max_requests.to_s
+        response.headers["X-RateLimit-Remaining"] = (max_requests - count).to_s
+        response.headers["X-RateLimit-Reset"] = (Time.current + period.seconds).to_i.to_s
+
+        true # Continue processing
+      end
+    end
+
+    def rate_limit_key
+      # Combine IP et user_id si disponible pour éviter le partage de limite
+      ip = request.remote_ip
+      user_identifier = current_user&.id || "anonymous"
+
+      "upload_dnd:rate_limit:#{user_identifier}:#{ip}"
+    end
+
+    def increment_rate_limit_counter(key)
+      period = UploadDND.configuration.rate_limit_period
+
+      # increment est atomique, contrairement à read + write qui laisse
+      # passer des requêtes concurrentes sous la barre du compteur.
+      # Certains stores (NullStore, Memcached sans clé existante) renvoient
+      # nil : on initialise alors le compteur en format raw.
+      Rails.cache.increment(key, 1, expires_in: period.seconds) || begin
+        Rails.cache.write(key, 1, raw: true, expires_in: period.seconds)
+        1
+      end
+    end
+
+    def rate_limit_reset_time(key)
+      # Récupère le TTL du cache pour cette clé
+      # Si le cache ne supporte pas ttl, retourne la période par défaut
+      period = UploadDND.configuration.rate_limit_period
+
+      begin
+        # Certains cache stores supportent `ttl` (Redis, Memcached)
+        ttl = Rails.cache.instance_variable_get(:@data)&.ttl(key)
+        ttl && ttl > 0 ? ttl : period
+      rescue
+        period
+      end
+    end
+  end
+end

data/app/controllers/upload_d_n_d/attachments_controller.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+module UploadDND
+  # Contrôleur dédié à la gestion des attachments permanents (sur records existants).
+  #
+  # Responsabilités:
+  # - Attacher des fichiers à des records ActiveRecord déjà persistés
+  # - Valider que le record existe via GlobalID
+  # - Gérer has_one vs has_many attachments
+  # - Renvoyer la liste des fichiers pour mise à jour UI
+  #
+  # Utilisé par:
+  # - POST /upload_d_n_d/attachments (lors de l'upload sur record existant)
+  #
+  # Workflow:
+  # 1. User uploads file on edit form → record_gid present in params
+  # 2. Controller locates record via GlobalID
+  # 3. Attaches blob directly to record.attribute_name
+  # 4. Saves record with validations
+  # 5. Returns updated file list
+  #
+  # Note: Pour les formulaires SANS record (ex: new User), utilisez TemporaryAttachmentsController.
+  class AttachmentsController < BaseAttachmentsController
+    # Autorisation (UploadDND::Authorization, fail-closed)
+    before_action :authorize_upload!, only: [ :create ]
+    before_action :reject_attached_blob, only: [ :create ]
+
+    before_action :validate_record_gid_presence, only: [ :create ]
+    before_action :validate_destroy_params, only: [ :destroy ]
+
+    # POST /upload_d_n_d/attachments
+    #
+    # Params:
+    # - signed_blob_id: String (ActiveStorage signed blob ID)
+    # - attribute_name: String (ex: "avatar", "documents")
+    # - record_gid: String (GlobalID du record, ex: "gid://app/User/123")
+    # - multiple: String ("true" ou "false", optionnel)
+    #
+    # Returns:
+    # - Turbo Stream pour remplacer la liste de fichiers
+    # - JSON {status: 'ok'} en mode API
+    def create
+      attribute_name = params[:attribute_name]
+
+      begin
+        record = GlobalID::Locator.locate(params[:record_gid])
+      rescue ActiveRecord::RecordNotFound
+        render_error(I18n.t("upload_d_n_d.errors.blob_not_found"), :not_found)
+        return
+      end
+
+      unless record
+        render_error(I18n.t("upload_d_n_d.errors.blob_not_found"), :not_found)
+        return
+      end
+
+      authorize_record_upload!(record)
+      return if performed?
+
+      # SÉCURITÉ : l'attribut doit être un attachment déclaré sur le modèle.
+      # Détection SERVEUR du type d'attachment (has_one vs has_many) :
+      # NE JAMAIS faire confiance au paramètre client params[:multiple]
+      attachment = UploadDND::AttachmentLookup.find(record, attribute_name)
+      unless attachment
+        render_error(I18n.t("upload_d_n_d.errors.invalid_attribute", attribute: attribute_name), :unprocessable_entity)
+        return
+      end
+
+      # Limites du champ, lues sur le modèle du record (vérifiées avant toute
+      # écriture ; le blob refusé est purgé).
+      constraints = UploadDND::FieldConstraints.for(record.class, attribute_name)
+      if (violation = constraints.violation(@blob))
+        render_error(constraints.error_message(violation), :unprocessable_entity)
+        return
+      end
+
+      # Sanitize filename avant l'attachement
+      @blob.update(filename: sanitize_filename(@blob.filename.to_s))
+
+      if attachment.is_a?(ActiveStorage::Attached::Many)
+        # has_many_attached: ajouter à la collection
+        attachment.attach(@blob)
+      elsif attachment.is_a?(ActiveStorage::Attached::One)
+        # has_one_attached: remplacer (purge l'ancien automatiquement)
+        record.send("#{attribute_name}=", @blob)
+      else
+        render_error(I18n.t("upload_d_n_d.errors.not_active_storage_attachment", attribute: attribute_name), :unprocessable_entity)
+        return
+      end
+
+      # Sauvegarde avec validation
+      if record.save
+        render_file_list(record, attribute_name)
+        log_upload_success
+      else
+        render_error(I18n.t("upload_d_n_d.errors.save_failed", errors: record.errors.full_messages.join(", ")), :unprocessable_entity)
+      end
+    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/attachments/:id
+    #
+    # Détache un fichier d'un record existant, sans dépendre des routes de
+    # l'app hôte (contrairement au flux legacy remove_file du concern
+    # Controllers::Uploadable). Symétrique du POST #create.
+    #
+    # Params:
+    # - id: Integer (ActiveStorage::Attachment id)
+    # - record_gid: String (GlobalID du record)
+    # - attribute_name: String (ex: "avatar", "documents")
+    def destroy
+      record = GlobalID::Locator.locate(params[:record_gid])
+
+      unless record
+        render_error(I18n.t("upload_d_n_d.errors.record_not_found"), :not_found)
+        return
+      end
+
+      authorize_destroy!(record)
+      return if performed?
+
+      attachment = ActiveStorage::Attachment.find_by(id: params[:id])
+      attribute_name = params[:attribute_name]
+
+      # Sécurité : le fichier doit appartenir au record ET à l'attribut annoncés
+      if attachment && attachment.record == record && attachment.name == attribute_name.to_s
+        attachment.purge_later
+        record.reload
+
+        UploadDND.configuration.on_file_removed&.call(record, attribute_name, current_user)
+
+        render_file_list(record, attribute_name)
+      else
+        render_error(I18n.t("upload_d_n_d.errors.file_not_found_or_denied"), :not_found)
+      end
+    end
+
+    private
+
+    def validate_destroy_params
+      unless params[:record_gid].present? && params[:attribute_name].present?
+        render_error(I18n.t("upload_d_n_d.errors.missing_params"), :bad_request)
+        return
+      end
+
+      unless params[:attribute_name].match?(/\A[a-z_][a-z0-9_]*\z/)
+        render_error(I18n.t("upload_d_n_d.errors.invalid_attribute_name"), :bad_request)
+        nil
+      end
+    end
+
+    # Autorisation de la suppression : règle du record (update), avec repli
+    # sur la règle générique de la gem si le modèle n'en a pas (Pundit : pas
+    # de policy). Fail-closed : sans règle du tout, RuleMissing remonte en 500
+    # plutôt que de laisser passer.
+    def authorize_destroy!(record)
+      begin
+        authorize_with_adapter!(record, :update)
+      rescue UploadDND::Authorization::RuleMissing
+        authorize_with_adapter!(:upload_d_n_d_attachment, :destroy)
+      end
+    rescue UploadDND::Authorization::Denied
+      render_forbidden
+    end
+
+    # Autorisation de l'upload sur le record lui-même (policy update?), en plus
+    # de la policy générique vérifiée en before_action : le record_gid vient du
+    # client, sans ce contrôle tout utilisateur autorisé à uploader pouvait
+    # attacher un fichier à n'importe quel record. Si le modèle n'a pas de
+    # règle, la règle générique (create) déjà vérifiée fait foi.
+    def authorize_record_upload!(record)
+      revoke_upload_authorization!
+      begin
+        authorize_with_adapter!(record, :update)
+      rescue UploadDND::Authorization::RuleMissing
+        nil # règle générique déjà vérifiée
+      end
+      grant_upload_authorization!
+    rescue UploadDND::Authorization::Denied
+      render_forbidden
+    end
+
+    def validate_record_gid_presence
+      unless params[:record_gid].present?
+        render_error(I18n.t("upload_d_n_d.errors.record_gid_required"), :bad_request)
+        nil
+      end
+    end
+
+    def render_file_list(record, attribute_name)
+      if turbo_stream_request?
+        render_turbo_stream_replace(
+          "udnd_files_list_#{attribute_name}",
+          partial: "upload_d_n_d/shared/files_list",
+          locals: { record: record, attribute_name: attribute_name }
+        )
+      else
+        respond_to do |format|
+          format.json { render json: { status: "ok", message: I18n.t("upload_d_n_d.success.file_added") }, 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_added") }, status: :ok }
+        end
+      end
+    end
+
+    # === Autorisation ===
+
+    # Policy générique ; la policy du record est vérifiée ensuite
+    # (authorize_record_upload!), une fois le record localisé.
+    def authorize_upload!
+      authorize_with_adapter!(:upload_d_n_d_attachment, :create)
+      grant_upload_authorization!
+    rescue UploadDND::Authorization::Denied
+      render_forbidden
+    end
+  end
+end