upload_d_n_d 0.9.1

data/lib/generators/upload_d_n_d/templates/concerns/upload_authorization.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module UploadDND
+  module UploadAuthorization
+    extend ActiveSupport::Concern
+
+    included do
+      before_action :authorize_upload!, only: [ :create ]
+      before_action :authorize_destroy!, only: [ :destroy ]
+    end
+
+    private
+
+    # Vérifie si l'utilisateur peut uploader sur cet attribut
+    # Peut être surchargée dans votre controller
+    def authorize_upload!
+      # Si vous utilisez Pundit
+      if defined?(Pundit)
+        authorize_with_pundit
+      # Si vous utilisez CanCanCan
+      elsif defined?(CanCan)
+        authorize_with_cancan
+      else
+        # Autorisation par défaut : l'utilisateur doit être connecté
+        authorize_basic_upload!
+      end
+    end
+
+    # Vérifie si l'utilisateur peut supprimer ce fichier
+    def authorize_destroy!
+      if defined?(Pundit)
+        authorize @temp_attachment || @attachment
+      elsif defined?(CanCan)
+        authorize! :destroy, @temp_attachment || @attachment
+      else
+        authorize_basic_destroy!
+      end
+    end
+
+    # Autorisation basique : utilisateur connecté
+    def authorize_basic_upload!
+      return if current_user.present?
+
+      render json: { error: "Vous devez être connecté pour uploader des fichiers" },
+             status: :unauthorized
+    end
+
+    def authorize_basic_destroy!
+      # Vérifie que le fichier appartient à la session ou à l'utilisateur
+      return if owner_matches_current_user?
+
+      render json: { error: "Vous ne pouvez pas supprimer ce fichier" },
+             status: :forbidden
+    end
+
+    def authorize_with_pundit
+      record = find_or_build_record
+      authorize record, :update?
+    end
+
+    def authorize_with_cancan
+      record = find_or_build_record
+      authorize! :update, record
+    end
+
+    def owner_matches_current_user?
+      if @temp_attachment
+        @temp_attachment.session_id == UploadDND::SessionId.for(session) ||
+          @temp_attachment.user_id == current_user&.id
+      elsif @attachment
+        @attachment.record.user_id == current_user&.id if @attachment.record.respond_to?(:user_id)
+      end
+    end
+
+    def find_or_build_record
+      if params[:record_gid].present?
+        GlobalID::Locator.locate(params[:record_gid])
+      else
+        # Pour les uploads temporaires, on ne peut pas vraiment autoriser
+        # car le record n'existe pas encore
+        nil
+      end
+    end
+
+    def current_user
+      # À adapter selon votre système d'authentification
+      # Par défaut, on suppose que vous utilisez Devise ou similaire
+      respond_to?(:current_user, true) ? super : nil
+    end
+  end
+end

data/lib/generators/upload_d_n_d/templates/concerns/uploadable.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module UploadDND
+  module Uploadable
+    extend ActiveSupport::Concern
+
+    included do
+      # Callbacks pour attacher les fichiers temporaires après création
+      after_create :attach_temporary_uploads
+    end
+
+    # Stocke temporairement le session_id pour l'upload
+    # Utilise une variable d'instance privée plutôt qu'attr_accessor
+    def temp_upload_session_id=(value)
+      @_temp_upload_session_id = value
+    end
+
+    def temp_upload_session_id
+      @_temp_upload_session_id
+    end
+
+    class_methods do
+      # Déclare un champ uploadable avec validation
+      #
+      # @param attribute_name [Symbol] le nom de l'attribut (ex: :avatar, :documents)
+      # @param options [Hash] les options de validation
+      # @option options [Array<Symbol>] :accept extensions acceptées (ex: [:jpg, :png, :pdf])
+      # @option options [Array<String>] :content_type types MIME autorisés (alternative à :accept)
+      # @option options [Integer] :max_size la taille max en bytes
+      # @option options [Integer] :max_files le nombre max de fichiers (pour has_many)
+      # @option options [Boolean] :multiple autoriser plusieurs fichiers (déclare has_many_attached)
+      # @option options [String] :message message d'erreur personnalisé
+      # @option options [Boolean] :strict_mime_check active la détection MIME côté serveur (anti-spoofing)
+      # @option options [String] :spoofing_message message d'erreur personnalisé pour les erreurs de spoofing
+      #
+      # @example Image unique (has_one_attached déclaré automatiquement)
+      #   class User < ApplicationRecord
+      #     include UploadDND::Uploadable
+      #
+      #     uploadable :avatar,
+      #                accept: [:jpg, :png],
+      #                max_size: 5.megabytes,
+      #                strict_mime_check: true
+      #   end
+      #
+      # @example Documents multiples (has_many_attached déclaré automatiquement)
+      #   class Project < ApplicationRecord
+      #     include UploadDND::Uploadable
+      #
+      #     uploadable :documents,
+      #                accept: [:pdf, :doc, :docx],
+      #                max_size: 10.megabytes,
+      #                multiple: true,
+      #                max_files: 5,
+      #                strict_mime_check: true
+      #   end
+      def uploadable(attribute_name, **options)
+        validates attribute_name,
+                  file: options.slice(:content_type, :max_size, :max_files, :message, :strict_mime_check, :spoofing_message)
+
+        # Stocke les options pour usage ultérieur
+        (@uploadable_attributes ||= {})[attribute_name] = options
+      end
+
+      def uploadable_attributes
+        @uploadable_attributes || {}
+      end
+    end
+
+    private
+
+    def attach_temporary_uploads
+      return unless temp_upload_session_id.present?
+      return unless UploadDND::TemporaryAttachment.exists?(session_id: temp_upload_session_id)
+
+      UploadDND::TemporaryAttachment.where(session_id: temp_upload_session_id).find_each do |temp_attachment|
+        attribute_name = temp_attachment.attribute_name
+        next unless respond_to?(attribute_name)
+
+        # SÉCURITÉ : Détection serveur du type d'attachment (has_one vs has_many)
+        attachment = send(attribute_name)
+
+        if attachment.is_a?(ActiveStorage::Attached::Many)
+          # has_many_attached: ajouter à la collection
+          attachment.attach(temp_attachment.blob.blob)
+        elsif attachment.is_a?(ActiveStorage::Attached::One)
+          # has_one_attached: utiliser = (remplace automatiquement)
+          # Ne transférer que le PREMIER fichier temporaire si plusieurs existent
+          unless attachment.attached?
+            send("#{attribute_name}=", temp_attachment.blob.blob)
+          end
+        end
+
+        temp_attachment.destroy
+      end
+
+      # Nettoie le session_id après utilisation
+      @_temp_upload_session_id = nil
+    end
+  end
+end

data/lib/generators/upload_d_n_d/templates/controller.rb.tt

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+<% module_namespacing do -%>
+class <%= plural_name.camelize %>Controller < ApplicationController
+  include UploadDND::Controllers::Uploadable
+
+  before_action :set_<%= singular_name %>, only: [:show, :edit, :update, :destroy, :attach_file, :remove_file]
+
+  def index
+    @<%= plural_name %> = <%= class_name %>.all
+  end
+
+  def show
+  end
+
+  def new
+    @<%= singular_name %> = <%= class_name %>.new
+  end
+
+  def edit
+  end
+
+  def create
+    @<%= singular_name %> = <%= class_name %>.new(<%= singular_name %>_params)
+
+    # Lie les uploads temporaires (session) au record
+    wire_temporary_uploads(@<%= singular_name %>)
+
+    if @<%= singular_name %>.save
+      redirect_to @<%= singular_name %>, notice: '<%= class_name %> créé avec succès'
+    else
+      render :new, status: :unprocessable_entity
+    end
+  end
+
+  def update
+    if @<%= singular_name %>.update(<%= singular_name %>_params)
+      redirect_to @<%= singular_name %>, notice: '<%= class_name %> mis à jour avec succès'
+    else
+      render :edit, status: :unprocessable_entity
+    end
+  end
+
+  def destroy
+    @<%= singular_name %>.destroy
+    redirect_to <%= plural_name %>_url, notice: '<%= class_name %> supprimé avec succès'
+  end
+
+  private
+
+  def set_<%= singular_name %>
+    @<%= singular_name %> = <%= class_name %>.find(params[:id])
+  end
+
+  def <%= singular_name %>_params
+    params.require(:<%= singular_name %>).permit(:name) # Ajoutez vos attributs ici
+    # Note: les fichiers uploadés ne sont PAS dans strong params (gérés par UploadDND)
+  end
+end
+<% end -%>

data/lib/generators/upload_d_n_d/templates/helpers/upload_helper.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module UploadDND
+  module UploadHelper
+    # Rendu du composant d'upload
+    #
+    # @param attribute_name [Symbol] le nom de l'attribut (ex: :avatar, :documents)
+    # @param record [ApplicationRecord, nil] le record à attacher (nil pour upload temporaire)
+    # @param options [Hash] options supplémentaires
+    # @option options [Boolean] :multiple (false) autoriser plusieurs fichiers
+    # @option options [String] :accepted_types types de fichiers acceptés (ex: '.jpg,.png')
+    # @option options [Integer] :max_size taille max en bytes
+    # @option options [String] :label label personnalisé
+    # @option options [Hash] :validation_options options passées au FileValidator
+    #
+    # @example Upload simple
+    #   <%= upload_field :avatar, record: @user %>
+    #
+    # @example Upload multiple avec validation
+    #   <%= upload_field :documents,
+    #                    record: @project,
+    #                    multiple: true,
+    #                    accepted_types: '.pdf,.docx',
+    #                    max_size: 10.megabytes %>
+    #
+    # @example Upload temporaire (record pas encore créé)
+    #   <%= upload_field :logo, accepted_types: '.png,.jpg' %>
+    #
+    def upload_field(attribute_name, record: nil, **options)
+      render UploadDND::UploadComponent.new(
+        attribute_name: attribute_name,
+        record: record,
+        user: current_user_for_upload,
+        **options
+      )
+    end
+
+    # Génère un champ caché avec le session_id pour les uploads temporaires.
+    # À placer dans les formulaires qui créent un nouveau record avec upload.
+    def upload_session_field
+      tag.input(type: "hidden", name: "temp_upload_session_id", value: UploadDND::SessionId.for(session))
+    end
+
+    # Affiche la liste des fichiers uploadés
+    #
+    # @param attribute_name [Symbol] le nom de l'attribut
+    # @param record [ApplicationRecord] le record
+    #
+    def uploaded_files_list(attribute_name, record:)
+      return unless record&.respond_to?(attribute_name)
+
+      attachments = record.send(attribute_name)
+      return unless attachments.attached?
+
+      files = attachments.respond_to?(:each) ? attachments : [ attachments ]
+
+      render partial: "upload_d_n_d/shared/files_list",
+             locals: { files: files, attribute_name: attribute_name }
+    end
+
+    # Récupère l'utilisateur courant pour l'upload
+    # Peut être surchargé dans votre application
+    def current_user_for_upload
+      respond_to?(:current_user, true) ? current_user : nil
+    end
+
+    # Icône selon le type de fichier
+    def file_icon_class(filename)
+      extension = File.extname(filename).downcase
+
+      case extension
+      when ".pdf"
+        "fa-file-pdf"
+      when ".doc", ".docx"
+        "fa-file-word"
+      when ".xls", ".xlsx"
+        "fa-file-excel"
+      when ".jpg", ".jpeg", ".png", ".gif", ".svg"
+        "fa-file-image"
+      when ".zip", ".rar", ".7z"
+        "fa-file-archive"
+      when ".mp4", ".avi", ".mov"
+        "fa-file-video"
+      else
+        "fa-file"
+      end
+    end
+
+    # Badge de couleur selon le type
+    def file_type_badge_class(content_type)
+      case content_type
+      when /^image\//
+        "badge-success"
+      when /^application\/pdf/
+        "badge-danger"
+      when /^application\/.*word/
+        "badge-primary"
+      when /^application\/.*excel/, /^application\/.*spreadsheet/
+        "badge-success"
+      else
+        "badge-secondary"
+      end
+    end
+  end
+end

data/lib/generators/upload_d_n_d/templates/initializers/upload_d_n_d.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+# Configuration de UploadDND
+UploadDND.configure do |config|
+  # Taille maximale par défaut des fichiers (en bytes)
+  # Peut être surchargé au niveau du composant
+  config.max_size = 10.megabytes
+
+  # Types de fichiers acceptés par défaut
+  # Peut être surchargé au niveau du composant
+  config.accepted_types = ".pdf,.doc,.docx,.jpg,.jpeg,.png,.gif"
+
+  # Vérification stricte du type MIME (anti-spoofing)
+  # Analyse le contenu réel du fichier via Marcel (plus coûteux)
+  # config.strict_mime_check = false
+
+  # Couleur principale du thème (utilisée pour les boutons, progress bar, etc.)
+  config.main_color = "#E97451"
+
+  # Autoriser les uploads sans authentification (déconseillé en production)
+  # config.allow_anonymous_uploads = false
+
+  # Durée de conservation des fichiers temporaires (en jours)
+  # Les fichiers temporaires non attachés seront supprimés après ce délai
+  # config.temporary_files_retention = 7
+
+  # Un fichier refusé par le serveur (taille, type, validation...) est purgé
+  # s'il a été envoyé dans cette fenêtre et n'est rattaché à rien.
+  # nil désactive la purge des fichiers refusés.
+  # config.rejected_blob_purge_window = 1.hour
+
+  # Nettoyage des blobs orphelins (opt-in : UploadDND::PurgeOrphanBlobsJob ou
+  # la tâche rake upload_d_n_d:purge_orphans). PostgreSQL requis.
+  # config.orphan_blob_min_age = 2.days
+  # Limite le scan des citations aux colonnes de texte riche (borne la mémoire).
+  # Sans liste, toutes les colonnes texte/JSON sont scannées.
+  # config.orphan_scan_columns = ["projects.description", "pages.body_translations"]
+  # Motifs d'adresse supplémentaires (hôte/bucket du service de stockage).
+  # config.orphan_scan_patterns = ["%votre-bucket.example.com%"]
+  # config.orphan_scan_excluded_tables = []
+
+  # Autorisation : :pundit ou :cancancan (détection automatique), ou :none
+  # pour s'en passer. Sans adaptateur utilisable, tout est refusé (403).
+  # config.authorization_adapter = :pundit # ou :cancancan, ou :none
+
+  # Validateur personnalisé
+  # Par défaut, utilise FileValidator si disponible
+  # config.validator_class = 'FileValidator'
+
+  # Configuration du stockage ActiveStorage (optionnel)
+  # Exemple: forcer l'utilisation d'un service spécifique
+  # config.active_storage_service = :amazon
+
+  # Callbacks personnalisés
+  # config.on_upload_success = ->(blob, user) {
+  #   # Logger ou notifier
+  #   Rails.logger.info "File uploaded: #{blob.filename} by #{user&.email}"
+  # }
+  #
+  # config.on_upload_error = ->(error, user) {
+  #   # Logger ou notifier
+  #   Rails.logger.error "Upload failed: #{error.message} for #{user&.email}"
+  # }
+
+  # Rate limiting (compteur basé sur Rails.cache ; aucune gem requise)
+  # config.rate_limit_enabled = true
+  # config.rate_limit_max_requests = 10
+  # config.rate_limit_period = 1.minute
+end

data/lib/generators/upload_d_n_d/templates/migrations/create_upload_d_n_d_temporary_attachments.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class CreateUploadDNDTemporaryAttachments < ActiveRecord::Migration[7.2]
+  def change
+    create_table :upload_d_n_d_temporary_attachments do |t|
+      t.string :session_id, null: false
+      t.string :attribute_name, null: false
+      t.integer :user_id
+
+      t.timestamps
+    end
+
+    add_index :upload_d_n_d_temporary_attachments, :session_id
+    add_index :upload_d_n_d_temporary_attachments, :user_id
+    add_index :upload_d_n_d_temporary_attachments, [ :session_id, :attribute_name ],
+              name: "index_temp_attachments_on_session_and_attribute"
+  end
+end

data/lib/generators/upload_d_n_d/templates/policies/upload_d_n_d_attachment_policy.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Policy Pundit pour l'upload de fichiers permanents avec UploadDND
+#
+# Cette policy contrôle qui peut attacher et supprimer des fichiers
+# sur des records existants (via le moteur UploadDND).
+#
+# Le controller du moteur autorise via `authorize :upload_d_n_d_attachment`
+# (record symbolique), ce qui amène Pundit à chercher cette classe.
+#
+class UploadDNDAttachmentPolicy < ApplicationPolicy
+  # Détermine qui peut attacher un fichier à un record existant
+  #
+  # Par défaut : tous les utilisateurs authentifiés
+  # Exemples de personnalisation :
+  #   - Seulement les admins : user&.admin?
+  #   - Seulement certains rôles : user&.admin? || user&.editor?
+  #
+  def create?
+    # PERSONNALISEZ CETTE MÉTHODE selon vos besoins
+    user.present?
+  end
+
+  # Détermine qui peut modifier les fichiers d'un record
+  #
+  def update?
+    # PERSONNALISEZ CETTE MÉTHODE selon vos besoins
+    user.present?
+  end
+
+  # Détermine qui peut supprimer un fichier d'un record
+  #
+  def destroy?
+    # PERSONNALISEZ CETTE MÉTHODE selon vos besoins
+    user.present?
+  end
+end

data/lib/generators/upload_d_n_d/templates/policies/upload_d_n_d_temporary_attachment_policy.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# Policy Pundit pour l'upload de fichiers temporaires avec UploadDND
+#
+# Cette policy contrôle qui peut uploader et supprimer des fichiers temporaires.
+# Personnalisez les méthodes ci-dessous selon vos besoins d'autorisation.
+#
+class UploadDNDTemporaryAttachmentPolicy < ApplicationPolicy
+  # Détermine qui peut créer (uploader) un fichier temporaire
+  #
+  # Par défaut : tous les utilisateurs authentifiés
+  # Exemples de personnalisation :
+  #   - Seulement les admins : user&.admin?
+  #   - Seulement certains rôles : user&.admin? || user&.editor?
+  #   - Selon un attribut : user&.can_upload?
+  #
+  def create?
+    # PERSONNALISEZ CETTE MÉTHODE selon vos besoins
+    user.present?
+  end
+
+  # Détermine qui peut supprimer un fichier temporaire
+  #
+  # Par défaut : tous les utilisateurs authentifiés
+  # La vérification de propriété (session) est déjà faite dans le controller
+  #
+  def destroy?
+    # PERSONNALISEZ CETTE MÉTHODE selon vos besoins
+    user.present?
+  end
+
+  # Détermine qui peut nettoyer les fichiers temporaires expirés
+  # (utilisé par les tâches cron/jobs)
+  #
+  def cleanup?
+    # PERSONNALISEZ CETTE MÉTHODE selon vos besoins
+    user&.admin?
+  end
+
+  # Exemple d'autorisation plus stricte (commenté par défaut)
+  # Décommentez et adaptez selon vos besoins
+  #
+  # def create?
+  #   return false unless user.present?
+  #
+  #   # Seulement les admins et éditeurs
+  #   user.admin? || user.editor?
+  # end
+  #
+  # def destroy?
+  #   return false unless user.present?
+  #
+  #   # Seulement les admins, éditeurs, ou l'équipe régionale
+  #   user.admin? || user.editor? || user.team&.regional_team?
+  # end
+end