jav_madmin 2.6.7 → 3.3.2

data/config/locales/ko.yml

@@ -26,6 +26,9 @@ ko:
       errors:
         one: 제출한 내용에 오류가 1개 있습니다
         other: 제출한 내용에 오류가 %{count}개 있습니다
+    flash:
+      destroy_failed: "%{name}을(를) 삭제할 수 없습니다"
+      destroy_restricted: "다른 레코드가 참조하고 있어 %{name}을(를) 삭제할 수 없습니다"
     confirmations:
       delete: 정말 삭제하시겠습니까?
       remove_with_changes: 정말 제거하시겠습니까? 다른 변경 사항도 함께 사라집니다.
@@ -38,3 +41,48 @@ ko:
     missing_resource:
       message: "%{resource}이(가) 존재하지 않습니다."
       create_hint: "다음 명령어를 실행하여 생성하세요:"
+    pagination:
+      label: 페이지 탐색
+      previous: 이전
+      next: 다음
+      info: "%{count}개 중 %{from}-%{to} 표시"
+      empty: 레코드가 없습니다
+      per_page: 페이지당
+    filters:
+      button: "필터"
+      heading: "다음 조건의 레코드 표시"
+      add: "+ 필터 추가"
+      apply: "적용"
+      clear_all: "필터 지우기"
+      remove: "필터 제거"
+      column: "열"
+      operator: "조건"
+      value: "값"
+      operators:
+        string:
+          contains: "포함"
+          eq: "일치"
+          starts_with: "시작"
+          blank: "비어 있음"
+          present: "비어 있지 않음"
+        number:
+          eq: "="
+          gt: ">"
+          gte: "≥"
+          lt: "<"
+          lte: "≤"
+          blank: "비어 있음"
+        date:
+          eq: "당일"
+          gte: "이후(당일 포함)"
+          lte: "이전(당일 포함)"
+          blank: "비어 있음"
+        datetime:
+          gte: "이후"
+          lte: "이전"
+          blank: "비어 있음"
+        boolean:
+          "true": "참"
+          "false": "거짓"
+        array:
+          includes: "포함"

data/lib/generators/madmin/resource/templates/resource.rb.tt

@@ -26,6 +26,9 @@ class <%= class_name %>Resource < Madmin::Resource
   # Customize the display name of records in the admin area.
   # def self.display_name(record) = record.name
 
+  # Customize the confirmation shown before deleting a record. Return nil to skip it.
+  # def self.delete_confirmation(record) = "Delete #{record.name}? This can't be undone."
+
   # Customize the default sort column and direction.
   # def self.default_sort_column = "created_at"
   #

data/lib/madmin/field.rb

@@ -6,6 +6,10 @@ module Madmin
       to_s.split("::").last.underscore
     end
 
+    # The kind of index filter a field offers (:string, :number, :date,
+    # :datetime or :boolean), or nil for none
+    def self.filter_type = nil
+
     def initialize(attribute_name:, model:, resource:, options:)
       @attribute_name = attribute_name.to_sym
       @model = model
@@ -29,6 +33,16 @@ module Madmin
       attribute_name
     end
 
+    # Converts the submitted form value into the value assigned to the record
+    def cast(value)
+      value
+    end
+
+    # Whether the value returned by `cast` can be saved. The form is shown again with an error when it can't.
+    def accepts?(value)
+      true
+    end
+
     def label
       options[:label].presence || model.human_attribute_name(attribute_name)
     end
@@ -62,6 +76,18 @@ module Madmin
       false
     end
 
+    def filter_type
+      self.class.filter_type if filterable?
+    end
+
+    private
+
+    # Only database columns can be filtered, and not encrypted ones since their
+    # stored values can't be compared. `filter: false` turns it off
+    def filterable?
+      options.fetch(:filter, true) && resource.model_column_names.include?(attribute_name.to_s) && !model.try(:encrypted_attributes)&.include?(attribute_name)
+    end
+
     ActiveSupport.run_load_hooks(:madmin_field, self)
   end
 end

data/lib/madmin/fields/array.rb

@@ -0,0 +1,16 @@
+module Madmin
+  module Fields
+    # PostgreSQL array columns, shown and edited as comma separated values
+    class Array < Field
+      def self.filter_type = :array
+
+      def text(record)
+        value(record)&.join(", ")
+      end
+
+      def cast(value)
+        value.to_s.split(",").map(&:strip).compact_blank
+      end
+    end
+  end
+end

data/lib/madmin/fields/attachment.rb

@@ -1,6 +1,13 @@
 module Madmin
   module Fields
     class Attachment < Field
+      # Path for removing the attachment, or nil when the attachment resource
+      # or its destroy route has been removed from the app
+      def remove_path(attachment)
+        resource = Madmin.resource_for(attachment)
+        resource.show_path(attachment) if resource.route?(:destroy)
+      rescue MissingResource
+      end
     end
   end
 end

data/lib/madmin/fields/belongs_to.rb

@@ -3,7 +3,7 @@ module Madmin
     class BelongsTo < Field
       def options_for_select(record)
         current_value = record.send(attribute_name)
-        records = [current_value].compact + associated_resource.model.excluding(current_value).limit(25)
+        records = [current_value].compact + model.reflect_on_association(attribute_name).klass.excluding(current_value).limit(25)
         records.map { [Madmin.resource_for(_1).display_name(_1), _1.id] }
       end
 
@@ -13,6 +13,7 @@ module Madmin
 
       def index_path(format: :json)
         associated_resource&.index_path(format: format)
+      rescue MissingRoute
       end
 
       def associated_resource

data/lib/madmin/fields/boolean.rb

@@ -1,6 +1,7 @@
 module Madmin
   module Fields
     class Boolean < Field
+      def self.filter_type = :boolean
     end
   end
 end

data/lib/madmin/fields/currency.rb

@@ -1,12 +1,19 @@
 module Madmin
   module Fields
     class Currency < Field
+      def self.filter_type = :number
+
       def value(record)
         value = record.public_send(attribute_name)
         value /= 100.0 if value && options.minor_units
         value
       end
 
+      # Filter values are in major units, which minor_units columns don't store
+      def filter_type
+        super unless options.minor_units
+      end
+
       def searchable?
         options.fetch(:searchable, model.column_names.include?(attribute_name.to_s))
       end

data/lib/madmin/fields/date.rb

@@ -1,6 +1,7 @@
 module Madmin
   module Fields
     class Date < Field
+      def self.filter_type = :date
     end
   end
 end

data/lib/madmin/fields/date_time.rb

@@ -1,6 +1,7 @@
 module Madmin
   module Fields
     class DateTime < Field
+      def self.filter_type = :datetime
     end
   end
 end

data/lib/madmin/fields/decimal.rb

@@ -1,6 +1,7 @@
 module Madmin
   module Fields
     class Decimal < Field
+      def self.filter_type = :number
     end
   end
 end

data/lib/madmin/fields/float.rb

@@ -1,6 +1,7 @@
 module Madmin
   module Fields
     class Float < Field
+      def self.filter_type = :number
     end
   end
 end

data/lib/madmin/fields/has_many.rb

@@ -1,6 +1,8 @@
 module Madmin
   module Fields
     class HasMany < Field
+      include Madmin::Pagination
+
       def options_for_select(record)
         if (records = record.send(attribute_name))
           return [] unless records.first
@@ -17,6 +19,7 @@ module Madmin
 
       def index_path(format: :json)
         associated_resource&.index_path(format: format)
+      rescue MissingRoute
       end
 
       def associated_resource
@@ -33,29 +36,11 @@ module Madmin
         true
       end
 
-      if Gem::Version.new(Pagy::VERSION) >= Gem::Version.new("43.0.0.rc")
-        include Pagy::Method
-
-        def paginated_value(record, params)
-          page_key = "#{attribute_name}_page"
-          request = {
-            params: {
-              "#{attribute_name}_page" => [params[page_key].to_i, 1].max
-            }
-          }
-          pagy value(record), page_key: page_key, request: request
-        rescue Pagy::OptionError
-        end
-      else
-        include Pagy::Backend
-
-        def paginated_value(record, params)
-          page_key = "#{attribute_name}_page"
-          page = [params[page_key].to_i, 1].max
-          pagy value(record), page: page, page_param: page_key
-        rescue Pagy::OverflowError, Pagy::VariableError
-          pagy value, page: 1, page_param: page_key
-        end
+      def paginated_value(record, params)
+        page_key = "#{attribute_name}_page"
+        per_page = Madmin::Page.per_page_for(params["#{attribute_name}_per_page"])
+
+        paginate value(record), page: params[page_key], per_page: per_page, param: page_key
       end
     end
   end

data/lib/madmin/fields/integer.rb

@@ -1,6 +1,7 @@
 module Madmin
   module Fields
     class Integer < Field
+      def self.filter_type = :number
     end
   end
 end

data/lib/madmin/fields/json.rb

@@ -1,6 +1,27 @@
 module Madmin
   module Fields
     class Json < Field
+      # Text that isn't JSON is shown as it is, so it can be corrected in the form
+      def json(record)
+        value = value(record)
+
+        if value.nil? || value.is_a?(::String)
+          value
+        else
+          JSON.pretty_generate(value)
+        end
+      end
+
+      def cast(value)
+        JSON.parse(value) if value.present?
+      rescue JSON::ParserError
+        value
+      end
+
+      # Still being text after the cast means it could not be parsed
+      def accepts?(value)
+        !value.is_a?(::String)
+      end
     end
   end
 end

data/lib/madmin/fields/nested_has_many.rb

@@ -7,7 +7,7 @@ module Madmin
       end
 
       def resource
-        "#{to_model.name}Resource".constantize
+        Madmin.resource_by_name(to_model)
       end
 
       def to_param
@@ -23,7 +23,7 @@ module Madmin
       end
 
       def to_model
-        attribute_name.to_s.singularize.classify.constantize
+        model.reflect_on_association(attribute_name).klass
       end
 
       def paginateable?

data/lib/madmin/fields/nested_has_one.rb

@@ -0,0 +1,48 @@
+module Madmin
+  module Fields
+    class NestedHasOne < HasOne
+      DEFAULT_ATTRIBUTES = %w[_destroy id].freeze
+
+      def nested_attributes
+        resource.attributes.except(*skipped_fields)
+      end
+
+      def resource
+        Madmin.resource_by_name(to_model)
+      end
+
+      def to_param
+        {"#{attribute_name}_attributes": permitted_fields}
+      end
+
+      # Index and show link to the record like a has_one, and the form shares
+      # its fields with nested_has_many
+      def to_partial_path(name)
+        case name.to_s
+        when "index", "show"
+          "/madmin/fields/has_one/#{name}"
+        when "form"
+          "/madmin/fields/nested_has_one/form"
+        when "fields"
+          "/madmin/fields/nested_has_many/fields"
+        else
+          raise ArgumentError, "`partial` must be 'index', 'show', 'form' or 'fields'"
+        end
+      end
+
+      def to_model
+        model.reflect_on_association(attribute_name).klass
+      end
+
+      private
+
+      def permitted_fields
+        (resource.permitted_params - skipped_fields + DEFAULT_ATTRIBUTES).uniq
+      end
+
+      def skipped_fields
+        options[:skip] || []
+      end
+    end
+  end
+end

data/lib/madmin/fields/polymorphic.rb

@@ -9,10 +9,15 @@ module Madmin
         end
       end
 
+      # `type` is no longer used, but customized form partials may still submit it
       def to_param
         {attribute_name => %i[type value]}
       end
 
+      def cast(value)
+        GlobalID::Locator.locate(value[:value])
+      end
+
       def associated_resource_for(object)
         Madmin.resource_for(object)
       rescue MissingResource

data/lib/madmin/fields/string.rb

@@ -1,6 +1,8 @@
 module Madmin
   module Fields
     class String < Field
+      def self.filter_type = :string
+
       def searchable?
         options.fetch(:searchable, resource.model_column_names.include?(attribute_name.to_s))
       end

data/lib/madmin/fields/text.rb

@@ -1,6 +1,8 @@
 module Madmin
   module Fields
     class Text < Field
+      def self.filter_type = :string
+
       def searchable?
         options.fetch(:searchable, resource.model_column_names.include?(attribute_name.to_s))
       end

data/lib/madmin/filter.rb

@@ -0,0 +1,113 @@
+module Madmin
+  # One condition from the index filters, like `created_at gte 2026-08-15T09:00`
+  class Filter
+    OPERATORS = {
+      string: %w[contains eq starts_with blank present],
+      number: %w[eq gt gte lt lte blank],
+      date: %w[eq gte lte blank],
+      datetime: %w[gte lte blank],
+      boolean: %w[true false],
+      array: %w[includes]
+    }.freeze
+
+    WITHOUT_VALUE = %w[blank present true false].freeze
+
+    # Operators that match the value as text instead of casting it to the column's type
+    MATCHING_OPERATORS = %w[contains starts_with].freeze
+
+    attr_reader :field, :operator, :value
+
+    # Skips conditions for unknown columns or operators, and values that don't
+    # cast to the column's type
+    def self.from_params(resource, params)
+      params.map { |param| new(resource.get_attribute(param[:column].to_s.to_sym)&.field, param[:operator].to_s, param[:value].to_s) }.select(&:valid?)
+    end
+
+    # A new row in the filters form, for the first filterable column
+    def self.blank(resource)
+      field = resource.filterable_attributes.first.field
+      new(field, OPERATORS.fetch(field.filter_type).first, "")
+    end
+
+    def initialize(field, operator, value)
+      @field = field
+      @operator = operator
+      @value = value
+    end
+
+    def column
+      field.attribute_name.to_s
+    end
+
+    def type
+      field.filter_type
+    end
+
+    def value?
+      WITHOUT_VALUE.exclude?(operator)
+    end
+
+    def valid?
+      field&.filter_type.present? && OPERATORS[type].include?(operator) &&
+        (!value? || (matching_operator? ? value.present? : typed_value.present?))
+    end
+
+    def apply(scope)
+      attribute = scope.arel_table[column]
+
+      case operator
+      when "contains" then scope.where(as_text(attribute).matches("%#{escaped_value}%"))
+      when "starts_with" then scope.where(as_text(attribute).matches("#{escaped_value}%"))
+      when "eq" then scope.where(column => typed_value)
+      when "gt" then scope.where(attribute.gt(typed_value))
+      when "gte" then scope.where(attribute.gteq(typed_value))
+      when "lt" then scope.where(attribute.lt(typed_value))
+      when "lte" then scope.where(attribute.lteq(typed_value))
+      when "blank" then scope.where(column => blank_values)
+      when "present" then scope.where.not(column => blank_values)
+      when "true" then scope.where(column => true)
+      when "false" then scope.where(column => false)
+      when "includes" then scope.where(Arel::Nodes.build_quoted(typed_value).eq(Arel::Nodes::NamedFunction.new("ANY", [attribute])))
+      end
+    end
+
+    # The params for this filter, used to keep it in links
+    def to_h
+      {column: column, operator: operator, value: value}
+    end
+
+    # The value in the column's type, or its element type for arrays. Datetimes are parsed in Time.zone, like form input
+    def typed_value
+      @typed_value ||= value.presence && value_type.cast(value)
+    end
+
+    private
+
+    # Arrays filter by their elements
+    def value_type
+      attribute_type = field.model.type_for_attribute(column)
+      (type == :array) ? attribute_type.subtype : attribute_type
+    end
+
+    def matching_operator?
+      MATCHING_OPERATORS.include?(operator)
+    end
+
+    def uuid?
+      value_type.type == :uuid
+    end
+
+    def as_text(attribute)
+      uuid? ? Arel::Nodes::NamedFunction.new("CAST", [attribute.as("CHAR(36)")]) : attribute
+    end
+
+    def escaped_value
+      field.model.sanitize_sql_like(value)
+    end
+
+    def blank_values
+      # UUIDs cast "" to NULL, which would match nothing
+      (type == :string && !uuid?) ? [nil, ""] : nil
+    end
+  end
+end

data/lib/madmin/menu.rb

@@ -36,8 +36,9 @@ module Madmin
           @children[parent] ||= Item.new(label: parent)
           @children[parent].add options
         else
+          key = options.delete(:key)
           item = Item.new(**options)
-          @children[item.label] = item
+          @children[key || item.label] = item
         end
       end
 

data/lib/madmin/page.rb

@@ -0,0 +1,89 @@
+module Madmin
+  # Holds the numbers for a single page of results. Knows nothing about the database.
+  #
+  # Non-ActiveRecord adapters overriding `paginate_collection` can return one of
+  # these (or any object responding to the same methods) alongside their records.
+  class Page
+    SERIES_SLOTS = 7
+    PER_PAGE_OPTIONS = [20, 50, 100, 200].freeze
+
+    attr_reader :count, :page, :per_page, :param
+
+    # The page size for a request param. Invalid sizes fall back to the default
+    # and large ones are capped. Sizes passed to Page.new directly aren't capped
+    def self.per_page_for(param)
+      size = param.to_s.to_i
+      size.positive? ? [size, max_per_page].min : Madmin.per_page
+    end
+
+    def self.max_per_page
+      [PER_PAGE_OPTIONS.max, Madmin.per_page].max
+    end
+    private_class_method :max_per_page
+
+    def initialize(count:, page: 1, per_page: Madmin.per_page, param: :page)
+      @count = count.to_i
+      @per_page = [per_page.to_i, 1].max
+      @page = [page.to_i, 1].max
+      @param = param.to_s
+    end
+
+    # The param carrying the page size: "per_page", or "posts_per_page" for a "posts_page" param
+    def per_page_param
+      "#{param.delete_suffix("page")}per_page"
+    end
+
+    # Page sizes to offer, always including the default and the current one
+    def per_page_options
+      (PER_PAGE_OPTIONS | [Madmin.per_page, per_page]).sort
+    end
+
+    # Whether a different page size would change what's shown
+    def resizable?
+      count > per_page_options.min
+    end
+
+    def last
+      [(count.to_f / per_page).ceil, 1].max
+    end
+
+    # Pages past the end are served empty rather than raising or clamping
+    def overflow?
+      page > last
+    end
+
+    def offset
+      (page - 1) * per_page
+    end
+
+    def from
+      (count.zero? || overflow?) ? 0 : offset + 1
+    end
+
+    def to
+      overflow? ? 0 : [offset + per_page, count].min
+    end
+
+    def prev
+      [page - 1, last].min if page > 1
+    end
+
+    def next
+      page + 1 if page < last
+    end
+
+    # Page numbers to link to, with :gap where pages are skipped
+    #   [1, :gap, 9, 10, 11, :gap, 20]
+    def series(slots: SERIES_SLOTS)
+      return (1..last).to_a if last <= slots
+
+      start = (page - (slots - 1) / 2).clamp(1, last - slots + 1)
+      pages = (start...(start + slots)).to_a
+      pages[0] = 1
+      pages[1] = :gap unless pages[1] == 2
+      pages[-1] = last
+      pages[-2] = :gap unless pages[-2] == last - 1
+      pages
+    end
+  end
+end