eluvia-base 3.37.1

data/lib/eluvia/active_model/object_attribute.rb

@@ -0,0 +1,143 @@
+module Eluvia
+  module ActiveModel
+    module ObjectAttribute
+      extend ::ActiveSupport::Concern
+      include Eluvia::ActiveModel::Attributes
+
+      class_methods do
+
+        # *********************************************************************
+        # Clean and transform value methods
+        # *********************************************************************
+
+        def clean_object_value(value, attr_name)
+          return nil if value.nil?
+          attr_spec = self.find_object_attr(attr_name)
+          raise Eluvia::Errors::StandardError.new("Cannot clean value of unknow attribute `#{attr_name}`.") unless attr_spec
+          raise Eluvia::Errors::StandardError.new("Invalid object value format: #{value.inspect}") unless value.is_a?(::Hash)
+
+          # Convert all keys to symbols for easier access
+          value = value.symbolize_keys
+
+          # Iterate fields and extract values
+          cleaned_value = {}
+          attr_spec[:fields].each do |field|
+            key = field.keys.first.to_sym
+            cleaned_value[key] = value.key?(key) ? value[key] : nil
+          end
+          cleaned_value
+        end
+
+        # *********************************************************************
+        # Attribute store methods
+        # *********************************************************************
+
+        def _object_attrs
+          @object_attrs ||= {}
+        end
+
+        def object_attrs
+          _object_attrs.values
+        end
+
+        def object_attr_names
+          object_attrs.map { |a| a[:attr_name] }
+        end
+
+        def has_object_attr?(attr_name)
+          _object_attrs.key?(attr_name.to_sym)
+        end
+
+        def find_object_attr(attr_name)
+          _object_attrs.fetch(attr_name.to_sym, nil)
+        end
+
+        # *********************************************************************
+        # Attribute definition methods for object
+        # *********************************************************************
+
+        # Add a new "object" attribute to this model
+        #
+        # @param attr_name [Symbol] Attribute name
+        # @param fields [Array<Symbol,String,Hash>] Underlying attribute names or mapping
+        # @param declare [Boolean] Whether to declare the underlying attribute
+        def object_attr(attr_name, fields, declare: false)
+          attr_name = attr_name.to_sym
+
+          # Declare underlying attribute
+          if declare
+            any_attr attr_name
+          end
+
+          # Check fields input
+          raise Eluvia::Errors::StandardError.new('Please specify object fields as an array.') unless fields.is_a?(::Array)
+          fields = fields.map do |field|
+            if field.is_a?(::Hash)
+              key = field.keys.first.to_sym
+              underlying_attr_name = field.values.first.to_sym
+            elsif field.is_a?(::Symbol) || field.is_a?(::String)
+              key = underlying_attr_name = field.to_sym
+            end
+            { key => underlying_attr_name }
+          end
+
+          # Register metadata
+          self._object_attrs[attr_name] = {
+            attr_name: attr_name,
+            fields: fields
+          }
+
+          # *******************************************************************
+          # Dynamically defined instance methods for object
+          # *******************************************************************
+
+          # Set method
+          define_method(:"#{attr_name}=") do |value|
+
+            # Convert string to object, we expect JSON string here
+            if value.is_a?(::String)
+              if !value.blank?
+                value = JSON.parse(value) rescue nil
+              else
+                value = nil
+              end
+            end
+
+            # Check input
+            raise Eluvia::Errors::BadRequest.new("Invalid value for object attribute `#{attr_name}`, expecting Hash or nil.") unless value.nil? || value.is_a?(::Hash)
+
+            # Handle blank value
+            if value.blank?
+              return
+            end
+
+            # Set values to underlying attributes if defined as fields
+            symbolized_value = value.symbolize_keys
+            fields.each do |field|
+              key = field.keys.first.to_sym
+              underlying_attr_name = field.values.first.to_sym
+              if symbolized_value.key?(key)
+                self.send(:"#{underlying_attr_name}=", symbolized_value[key])
+              end
+            end
+          end
+
+          # Get method
+          define_method(attr_name) do
+
+            # Set values of underlying attributes if defined as fields
+            cleaned_value = {}
+            fields.each do |field|
+              key = field.keys.first.to_sym
+              underlying_attr_name = field.values.first.to_sym
+              cleaned_value[key] = self.send(underlying_attr_name)
+            end
+
+            cleaned_value
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/eluvia/active_model/range_attribute.rb

@@ -0,0 +1,74 @@
+module Eluvia
+  module ActiveModel
+    module RangeAttribute
+      extend ::ActiveSupport::Concern
+      include Eluvia::ActiveModel::ObjectAttribute
+
+      class_methods do
+
+        # *********************************************************************
+        # Clean and transform value methods
+        # *********************************************************************
+
+        def clean_range_value(value, attr_name)
+          clean_object_value(value, attr_name)
+        end
+
+        # *********************************************************************
+        # Attribute store methods
+        # *********************************************************************
+
+        def _range_attrs
+          @range_attrs ||= {}
+        end
+
+        def range_attrs
+          _range_attrs.values
+        end
+
+        def range_attr_names
+          range_attrs.map { |a| a[:attr_name] }
+        end
+
+        def has_range_attr?(attr_name)
+          _range_attrs.key?(attr_name.to_sym)
+        end
+
+        def find_range_attr(attr_name)
+          _range_attrs.fetch(attr_name.to_sym, nil)
+        end
+
+        # *********************************************************************
+        # Attribute definition methods for range
+        # *********************************************************************
+
+        # Add a new "range" attribute to this model
+        #
+        # @param attr_name [Symbol] Attribute name
+        # @param lower_attr_name [Symbol] Lower bound attribute name
+        # @param upper_attr_name [Symbol] Upper bound attribute name
+        # @param declare [Boolean] Whether to declare the underlying attribute as any
+        def range_attr(attr_name, lower_attr_name, upper_attr_name, declare: false)
+          attr_name = attr_name.to_sym
+          lower_attr_name = lower_attr_name.to_sym
+          upper_attr_name = upper_attr_name.to_sym
+
+          # Range is an object with lower and upper attributes
+          object_attr(attr_name,
+                      [
+                        { lower: lower_attr_name },
+                        { upper: upper_attr_name }
+                      ], declare: declare)
+
+          # Register metadata
+          self._range_attrs[attr_name] = {
+            attr_name: attr_name,
+            lower_attr_name: lower_attr_name,
+            upper_attr_name: upper_attr_name
+          }
+        end
+
+      end
+    end
+  end
+end

data/lib/eluvia/active_record/file_array_attribute.rb

@@ -0,0 +1,116 @@
+module Eluvia
+  module ActiveRecord
+    module FileArrayAttribute
+      extend ::ActiveSupport::Concern
+      include Eluvia::ActiveModel::ArrayAttribute
+
+      class_methods do
+
+        # *********************************************************************
+        # Attribute definition methods for file array
+        # *********************************************************************
+
+        # Add a new "file array" attribute to this model
+        #
+        # @param attr_name [Symbol] Attribute name
+        # @param underlying_attachments [Symbol, nil] Name of the attribute holding underlying Active Storage attachments
+        # @param underlying_filter [Proc, nil] Optional filter to be applied to scope underlying attachments
+        # @param nature [Symbol] Nature of file attribute (:file, :image, etc.)
+        # @param declare [Boolean] Whether to declare the underlying attribute
+        def file_array_attr(attr_name, underlying_attachments: nil, underlying_filter: nil, nature: :file, declare: false)
+          attr_name = attr_name.to_sym
+          nature = nature.to_sym
+
+          # Define it using "has many" attribute
+          if declare
+            has_many_attr(attr_name, nature == :image ? 'Eluvia::ImageWrapper' : 'Eluvia::FileWrapper')
+          end
+
+          # *******************************************************************
+          # Dynamically defined instance methods for file array
+          # *******************************************************************
+
+          if underlying_attachments
+
+            # Set method
+            define_method(:"#{attr_name}=") do |new_values|
+
+              # Check input
+              raise Eluvia::Errors::BadRequest.new("Invalid value for attribute `#{attr_name}`, expecting Array.") unless new_values.is_a?(::Array)
+
+              # Current values
+              current_values = self.send(attr_name)
+              current_ids = current_values.map(&:id)
+              new_ids = []
+
+              # Create missing attachments
+              new_values.each do |value|
+                # Normalize and check value
+                if value.is_a?(::Hash)
+                  if nature == :image
+                    value = Eluvia::ImageWrapper.map(value)
+                  else
+                    value = Eluvia::FileWrapper.map(value)
+                  end
+                end
+                raise Eluvia::Errors::BadRequest.new("Invalid value for attribute `#{attr_name}[]`, expecting Eluvia::FileWrapper or Eluvia::ImageWrapper.") unless value.is_a?(Eluvia::FileWrapper) || value.is_a?(Eluvia::ImageWrapper)
+                raise Eluvia::Errors::BadRequest.new("Invalid value for attribute `#{attr_name}[].file`, can't be blank.") if value.file.blank?
+
+                # Keep track of new ids
+                new_ids << value.id if value.id
+
+                # Retrieve filename and content
+                filename = value.file&.filename
+                content = value.file&.content
+
+                # Sanitize filename
+                filename = ActiveStorage::Filename.new(filename).sanitized
+
+                # Create or update attachment only if both filename and content are passed (this means that user uploaded a new file)
+                if !filename.blank? && !content.blank?
+
+                  # Delete the existing attachment
+                  if value.id && current_ids.include?(value.id)
+                    attachment_record = self.send("#{underlying_attachments}_attachments").find(value.id)
+                    attachment_record.purge_later
+                  end
+
+                  # Create a new attachment
+                  self.send(underlying_attachments).attach(io: StringIO.new(Base64.decode64(content)), filename: filename)
+                end
+
+              end
+
+              # Delete no longer wanted attachments
+              current_values.each do |value|
+                unless new_ids.include?(value.id)
+                  attachment_record = self.send("#{underlying_attachments}_attachments").find(value.id)
+                  attachment_record.purge_later
+                end
+              end
+            end
+
+            # Get method
+            define_method(attr_name) do
+              # must be sorted in memory and not in SQL in order to support prefetch via "includes"
+              attachments_records = self.send("#{underlying_attachments}_attachments").to_a.sort_by(&:created_at)
+              if underlying_filter && underlying_filter.respond_to?(:call)
+                attachments_records = attachments_records.select { |attachment_record| underlying_filter.call(attachment_record) }
+              end
+              attachments_records.map do |attachment|
+                if nature == :image
+                  Eluvia::ImageWrapper.new(id: attachment.id, file: Eluvia::File.from_active_storage_attachment(attachment, skip_check: true))
+                else
+                  Eluvia::FileWrapper.new(id: attachment.id, file: Eluvia::File.from_active_storage_attachment(attachment, skip_check: true))
+                end
+              end
+            end
+
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/eluvia/active_record/file_attribute.rb

@@ -0,0 +1,158 @@
+module Eluvia
+  module ActiveRecord
+    module FileAttribute
+      extend ::ActiveSupport::Concern
+      include Eluvia::ActiveModel::Attributes
+
+      class_methods do
+
+        # *********************************************************************
+        # Attribute store methods
+        # *********************************************************************
+
+        def _file_attrs
+          @file_attrs ||= {}
+        end
+
+        def file_attrs
+          _file_attrs.values
+        end
+
+        def file_attr_names
+          file_attrs.map { |a| a[:attr_name] }
+        end
+
+        def has_file_attr?(attr_name)
+          _file_attrs.key?(attr_name.to_sym)
+        end
+
+        def find_file_attr(attr_name)
+          _file_attrs.fetch(attr_name.to_sym, nil)
+        end
+
+        # *********************************************************************
+        # Attribute definition methods for file
+        # *********************************************************************
+
+        # Add a new "file" attribute to this model
+        #
+        # @param attr_name [Symbol] Attribute name
+        # @param underlying_attachment [Symbol, nil] Name of the attribute holding underlying Active Storage attachment
+        # @param nature [Symbol] Nature of file attribute (:file, :image, etc.)
+        # @param declare [Boolean] Whether to declare the underlying attribute
+        def file_attr(attr_name, underlying_attachment: nil, nature: :file, declare: false)
+          attr_name = attr_name.to_sym
+          nature = nature.to_sym
+
+          # Declare underlying "has one" attribute
+          if declare
+            has_one_attr(attr_name, 'Eluvia::File')
+          end
+
+          # Register metadata
+          self._file_attrs[attr_name] = {
+            attr_name: attr_name,
+            underlying_attachment: underlying_attachment,
+            nature: nature
+          }
+
+          # *******************************************************************
+          # Dynamically defined instance methods for file
+          # *******************************************************************
+
+          if underlying_attachment
+
+            # Set method
+            define_method(:"#{attr_name}=") do |value|
+              # Delete the existing attachment if requested
+              if value.nil?
+                attachment_record = self.send(underlying_attachment)
+                attachment_record.purge_later if attachment_record.attached?
+                return
+              end
+
+              # Normalize and check value
+              value = Eluvia::File.map(value) if value.is_a?(::Hash)
+              raise Eluvia::Errors::BadRequest.new("Invalid value for file attribute `#{attr_name}`, expecting Eluvia::File.") unless value.is_a?(Eluvia::File)
+
+              # Retrieve and check filename - for a chunked/direct upload the frontend only sends
+              # `upload_key` (see habarico's `uploadFileChunked`), not a separate filename; the key
+              # itself already encodes the original filename as its last path segment (providers
+              # build it as `<tmp_prefix><uuid>/<filename>`), so fall back to that instead of
+              # requiring it to be sent twice.
+              filename = value.filename
+              filename = ::File.basename(value.upload_key) if filename.blank? && value.upload_key.present?
+              raise Eluvia::Errors::BadRequest.new("Expected `filename` in the attribute `#{attr_name}`.") if filename.blank?
+
+              # Sanitize filename
+              filename = ActiveStorage::Filename.new(filename).sanitized
+
+              # Retrieve the underlying attribute
+              attachment_record = self.send(underlying_attachment)
+
+              if value.upload_key.present?
+                # Finalize a previously uploaded (chunked/direct) temp object via the registered finalizer
+                finalizer = Eluvia::Uploads.finalizer
+                raise Eluvia::Errors::StandardError.new("No `Eluvia::Uploads.finalizer` registered, cannot finalize upload for attribute `#{attr_name}`.") unless finalizer.respond_to?(:call)
+                finalizer.call(attachment_record, value.upload_key, filename)
+              else
+                # Attach base64 encoded content directly
+                content = value.content
+                raise Eluvia::Errors::BadRequest.new("Expected `filename` and `content` in the attribute `#{attr_name}`.") if content.blank?
+                attachment_record.attach(
+                  io: StringIO.new(Base64.decode64(content)),
+                  filename: filename,
+                )
+              end
+            end
+
+            # Get method
+            define_method(attr_name) do
+              # Read value from underlying attribute
+              attachment = self.send(underlying_attachment)
+
+              # Handle blank value or not attached
+              return nil unless attachment&.attached?
+
+              # Convert to standard format
+              Eluvia::File.from_active_storage_attachment(attachment, skip_check: true)
+            end
+
+          else
+
+            # Set method
+            define_method(:"#{attr_name}=") do |value|
+              # Normalize value
+              value = Eluvia::File.map(value) if value.is_a?(::Hash)
+
+              # Check input
+              raise Eluvia::Errors::BadRequest.new("Invalid value for file attribute `#{attr_name}`, expecting Eluvia::File.") unless value.is_a?(Eluvia::File)
+
+              # Store to the underlying attribute
+              write_attribute(attr_name, value)
+            end
+
+            # Get method
+            define_method(attr_name) do
+              # Read value from underlying attribute
+              value = read_attribute(attr_name)
+
+              # Handle blank value
+              return nil if value.blank?
+
+              # Normalize value
+              value = Eluvia::File.map(value) if value.is_a?(::Hash)
+
+              # Check output
+              raise Eluvia::Errors::StandardError.new("Invalid value for object attribute `#{attr_name}`, expecting Eluvia::File.") unless value.is_a?(Eluvia::File)
+
+              value
+            end
+
+          end
+        end
+
+      end
+    end
+  end
+end