headmin 0.4.0 → 0.5.0

data/app/assets/stylesheets/headmin.css

@@ -13104,6 +13104,9 @@ input[type=search] {
 html {
   height: 100%;
 }
+.list-group-item.active .text-muted {
+  color: #fff !important;
+}
 mark,
 .mark {
   padding: 0;
@@ -13113,6 +13116,11 @@ mark,
   background: rgba(0, 0, 0, 0.03);
   height: 100vh;
   overflow-y: scroll;
+  display: flex;
+  flex-direction: column;
+}
+.content {
+  flex-grow: 1;
 }
 .sidebar {
   font-size: 0.99rem;
@@ -13306,6 +13314,54 @@ body.empty {
 .h-filter-popup.closed {
   display: none;
 }
+.h-filter-row {
+  padding: 0.5rem 0 0.5rem 0;
+  position: relative;
+  flex-wrap: unset;
+  display: flex;
+  gap: 10px;
+}
+.h-filter-row:first-child {
+  padding-top: 0;
+}
+.h-filter-row:hover .h-filter-add-input,
+.h-filter-row:hover .h-filter-remove-input {
+  display: block;
+}
+.h-filter-row input,
+.h-filter-row select:not(.h-filter-operator) {
+  min-width: 200px;
+}
+.h-filter-operator {
+  width: 62px;
+}
+.h-filter-conditional {
+  position: relative;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+}
+.h-filter-conditional select {
+  width: 50px;
+}
+.h-filter-conditional::before {
+  content: "";
+  position: absolute;
+  top: calc(50% - 1px);
+  left: 0;
+  width: calc(50% - 35px);
+  height: 1px;
+  background: rgba(0, 0, 0, 0.2);
+}
+.h-filter-conditional::after {
+  content: "";
+  position: absolute;
+  top: calc(50% - 1px);
+  left: calc(50% + 35px);
+  width: calc(50% - 35px);
+  height: 1px;
+  background: rgba(0, 0, 0, 0.2);
+}
 .h-filter-remove {
   border-left: 1px solid #d1d5db;
   padding-left: 8px;
@@ -13314,11 +13370,24 @@ body.empty {
 .h-filter-remove i::before {
   font-size: 0.8em;
 }
+.h-filter-add-input {
+  position: absolute !important;
+  top: calc(100% - 12px);
+  left: calc(50% - 17px);
+  z-index: 9;
+  display: none;
+}
+.h-filter-remove-input {
+  position: absolute !important;
+  top: calc(50% - 15px);
+  left: calc(100% - 4px);
+  z-index: 9;
+  display: none;
+}
 .h-popup {
   padding: 10px;
   background: #ffffff;
   z-index: 1070;
-  width: 276px;
   font-family: var(--bs-font-sans-serif);
   font-style: normal;
   font-weight: 400;

data/app/controllers/concerns/headmin/filterable.rb

@@ -0,0 +1,27 @@
+module Headmin
+  module Filterable
+    # Will create a Headmin::Filters object with a default configuration for "id" and "search"
+    #
+    # Example:
+    #
+    # orders = Order
+    # orders = filter(orders, {
+    #  status: :text,
+    #  price: :number,
+    #  in_stock: :boolean
+    #  })
+    # @orders = orders.all
+
+    def filter(collection, filter_types = {})
+      type_hash = default_filter_types.merge(filter_types)
+      Headmin::Filters.new(params, type_hash).query(collection)
+    end
+
+    def default_filter_types
+      {
+        id: :number,
+        search: :search
+      }
+    end
+  end
+end

data/app/models/concerns/headmin/field.rb

@@ -11,8 +11,10 @@ module Headmin
       belongs_to :field, optional: true, touch: true
       has_many :fields, foreign_key: "parent_id"
       accepts_nested_attributes_for :fields, allow_destroy: true
-      has_one_attached :file
-      accepts_nested_attributes_for :file_attachment
+
+      # field_type: :files, :file
+      has_many_attached :files
+      accepts_nested_attributes_for :files_attachments, allow_destroy: true
     end
   end
 end

data/app/models/concerns/headmin/fieldable.rb

@@ -6,68 +6,162 @@ module Headmin
       has_many :fields, as: :fieldable, dependent: :destroy
       accepts_nested_attributes_for :fields, allow_destroy: true
 
+      # Callbacks
+      before_validation :build_fields
+
       def fields_hash
-        fields.order(position: :asc).map do |field|
-          parse_hash_tree(field.hash_tree)
-        end.reduce({}, :merge)
+        @fields_hash ||= parse_fields
       end
 
       def fields_hash=(hash)
-        parse_fields_hash(hash)
+        @fields_hash = hash
       end
 
       private
 
-      def parse_fields_hash(hash)
+      def parse_fields
+        fields.where(parent: nil).order(position: :asc).map { |field| parse_hash_tree(field.hash_tree) }.reduce({}, :merge)
+      end
+
+      def build_fields
+        return unless @fields_hash
+        self.fields = fields_for(@fields_hash)
+      end
+
+      def fields_for(hash)
         hash.map do |key, value|
           case value
           when Hash
-            fields.build(
-              name: key,
-              field_type: "group",
-              fields: parse_fields_hash(value)
-            )
+            field_for_hash(key, value)
           when Array
-            fields.build(
-              name: key,
-              field_type: "list",
-              fields: value.map do |item|
-                fields.new(name: "item", field_type: "group", fields: parse_fields_hash(item))
-              end
-            )
-          when String
-            fields.build(
-              name: key,
-              field_type: "text",
-              value: value
-            )
+            field_for_array(key, value)
+          when File
+            field_for_file(key, value)
           else
-            fields.build(
-              name: key,
-              field_type: "file",
-              file: value
-            )
+            field_for_string(key, value)
           end
         end
       end
 
+      def field_for_hash(name, hash)
+        ::Field.new(
+          fieldable: self,
+          name: name,
+          field_type: "group",
+          fields: fields_for(hash)
+        )
+      end
+
+      def field_for_array(name, array)
+        if array.all? { |item| item.is_a?(File) }
+          field_for_files(name, array)
+        elsif array.all? { |item| item.is_a?(Hash) }
+          field_for_group_list(name, array)
+        else
+          field_for_simple_list(name, array)
+        end
+      end
+
+      def field_for_simple_list(name, array)
+        ::Field.new(
+          fieldable: self,
+          name: name,
+          field_type: "list",
+          fields: array.map { |item| fields_for({item: item}) }.flatten
+        )
+      end
+
+      def field_for_group_list(name, array)
+        ::Field.new(
+          fieldable: self,
+          name: name,
+          field_type: "list",
+          fields: array.map { |item| ::Field.new(fieldable: self, name: "item", field_type: "group", fields: fields_for(item)) }
+        )
+      end
+
+      def field_for_string(name, string)
+        ::Field.new(
+          fieldable: self,
+          name: name,
+          field_type: "text",
+          value: string
+        )
+      end
+
+      def field_for_file(name, file)
+        ::Field.new(
+          fieldable: self,
+          name: name,
+          field_type: "file",
+          value: nil,
+          files: [ActiveStorage::Blob.create_and_upload!(
+            io: file,
+            filename: File.basename(file.path)
+          )]
+        )
+      end
+
+      def field_for_files(name, files)
+        ::Field.new(
+          fieldable: self,
+          name: name,
+          field_type: "files",
+          value: nil,
+          files: files.map { |file|
+            ActiveStorage::Blob.create_and_upload!(
+              io: file,
+              filename: File.basename(file.path)
+            )
+          }
+        )
+      end
+
+      # From hash tree to hash
       def parse_hash_tree(hash_tree)
-        hash_tree.map do |field, children|
-          case field.field_type.to_sym
-          when :group
-            children = children.any? ? children : field.hash_tree
-            [field.name, parse_hash_tree(children)]
-          when :list
-            children = children.any? ? children : field.hash_tree
-            [field.name, children.map { |child, grand_children| parse_hash_tree(grand_children) }]
-          when :image
-            [field.name, field.file]
-          when :file
-            [field.name, field.file]
-          else
-            [field.name, field.value]
-          end
-        end.to_h
+        new_hash = {}
+        hash_tree.each do |field, children|
+          new_hash[field.name.to_sym] = parse_field(field, children)
+        end
+        new_hash
+      end
+
+      # Parse value for given field
+      def parse_field(field, children)
+        case field.field_type.to_sym
+        when :group
+          parse_group_field(field, children)
+        when :list
+          parse_list_field(field, children)
+        when :files
+          parse_files_field(field)
+        when :file
+          parse_file_field(field)
+        else
+          parse_text_field(field)
+        end
+      end
+
+      def parse_group_field(field, children)
+        parse_hash_tree(children)
+      end
+
+      def parse_list_field(field, children)
+        children.map do |child, grand_children|
+          parse_field(child, grand_children)
+        end
+      end
+
+      def parse_files_field(field)
+        field.files.all
+      end
+
+      def parse_file_field(field)
+        field.files.last
+      end
+
+      def parse_text_field(field)
+        field.value
       end
     end
   end

data/app/models/headmin/filter/base.rb

@@ -0,0 +1,238 @@
+module Headmin
+  module Filter
+    class Base
+      # Constants
+      OPERATORS = %w[eq not_eq gt gteq lt lteq between not_between in not_in matches does_not_match is_null is_not_null starts_with ends_with]
+
+      OPERATORS_CONVERT_TO = {
+        convert_to_range: %w[between not_between],
+        convert_to_array: %w[in not_in],
+        convert_to_value: %w[eq not_eq gt gteq lt lteq matches does_not_match is_null is_not_null starts_with ends_with]
+      }
+
+      QUERY_VALUE_CONVERT_TO = {
+        convert_value_to_match: %w[matches does_not_match],
+        convert_to_starts: %w[starts_with],
+        convert_to_ends: %w[ends_with]
+      }
+
+      QUERY_OPERATOR_CONVERT_TO = {
+        matches: %w[starts_with ends_with]
+      }
+
+      # Methods
+      def initialize(attribute, params)
+        @raw_value = params[attribute]
+        @attribute = attribute
+        @instructions = []
+
+        if params.key?(attribute)
+          parse(@raw_value)
+        end
+      end
+
+      attr_reader :raw_value
+      attr_reader :attribute
+
+      def values
+        @instructions.map { |instruction| instruction[:value] }.compact
+      end
+
+      def operators
+        @instructions.map { |instruction| instruction[:operator] }.compact
+      end
+
+      def conditionals
+        @instructions.map { |instruction| instruction[:conditional] }.compact
+      end
+
+      def string(display_values = [])
+        build_instructions_string(display_values)
+      end
+
+      attr_reader :instructions
+
+      def query(collection)
+        return collection unless @instructions.any?
+
+        query = nil
+
+        @instructions.each do |instruction|
+          query = build_query(query, collection, instruction)
+        end
+
+        collection.where(query)
+      end
+
+      def cast_value(value)
+        # This method has to be implemented by the child.
+
+        raise NotImplementedMethodError, "Method cast_value has to be implemented by its child."
+      end
+
+      def display_value(value)
+        value
+      end
+
+      private
+
+      def parse(string)
+        instructions = split_instructions(string)
+        parse_instructions(instructions)
+      end
+
+      def split_instructions(string)
+        # Regex: It divides the string into separate parts:
+        # - Parts starting with +AND+ OR +OR+ until the next occurrence of +
+        # - First part of the string till the first occurrence of +
+        string.scan(/\+AND\+[^+]* | \+OR\+[^+]* | ^[^+]*/x)
+      end
+
+      def parse_instructions(instructions)
+        instructions.map { |instruction| parse_instruction(instruction) }
+      end
+
+      def parse_instruction(string)
+        conditional_raw, operator_raw, value_raw = split_instruction(string)
+
+        conditional = parse_conditional(conditional_raw)
+        operator = parse_operator(operator_raw, value_raw)
+        value = parse_value(value_raw, operator)
+
+        @instructions << {conditional: conditional, operator: operator, value: value}
+      end
+
+      def split_instruction(string)
+        # Regex: takes out the +AND+ / +OR+, if not found returns nil
+        conditional_raw = string.scan(/\+AND\+|\+OR\+/)[0]
+
+        string = string.remove("+AND+").remove("+OR+")
+
+        # Regex: takes out the value before the : character
+        operator_raw = string.match(/^[^:]*/)[0] == string ? nil : string.match(/^[^:]*/)[0]
+        value_raw = string.remove("#{operator_raw}:")
+
+        [conditional_raw, operator_raw, value_raw]
+      end
+
+      def parse_conditional(string)
+        string.present? ? string.delete("+").downcase : nil
+      end
+
+      def parse_operator(string, value)
+        if self.class::OPERATORS.include?(string)
+          # Operator is recognized, return the operator
+          string
+        elsif string.nil?
+          # There was no operator present, default operator is eq
+          "eq"
+        else
+          # There was an operator passed but it was not recognized, raise exception
+          raise OperatorNotSupportedError, "This operator is not supported by this filter."
+        end
+      end
+
+      def parse_value(string, operator)
+        if operator == "is_null" || operator == "is_not_null"
+          return string.to_i
+        end
+        process_value(string, operator)
+      end
+
+      def build_query(query, collection, instruction)
+        query_operator = convert_to_query_operator(instruction[:operator])
+        query_value = convert_to_query_value(instruction[:value], instruction[:operator])
+
+        query_operator, query_value = process_null_operators(query_operator, query_value)
+
+        model = collection.is_a?(Class) ? collection : collection.model
+        new_query = model.arel_table[attribute].send(query_operator, query_value)
+
+        query ? query.send(instruction[:conditional], new_query) : new_query
+      end
+
+      def process_null_operators(operator, value)
+        # In case of null operators (is_null and is_not_null), we have to intercept the operator and value values
+        # and transform them to the correct operator (eq or not_eq) and value (nil)
+        if operator == "is_null" && value == 1
+          ["eq", nil]
+        elsif operator == "is_null" && value == 0
+          ["not_eq", nil]
+        elsif operator == "is_not_null" && value == 1
+          ["not_eq", nil]
+        elsif operator == "is_not_null" && value == 0
+          ["eq", nil]
+        else
+          [operator, value]
+        end
+      end
+
+      def convert_to_range(value)
+        array = value.split(",")
+        cast_value(array[0])..cast_value(array[1])
+      end
+
+      def convert_to_array(value)
+        array = value.split(",")
+        array.map { |e| cast_value(e) }
+      end
+
+      def convert_to_value(value)
+        cast_value(value)
+      end
+
+      def convert_to_query_value(value, operator)
+        value_converter = self.class::QUERY_VALUE_CONVERT_TO.find { |key, values| values.include?(operator) }&.first
+
+        if value_converter.present?
+          send(value_converter, value)
+        else
+          value
+        end
+      end
+
+      def convert_value_to_match(value)
+        "%#{value}%"
+      end
+
+      def convert_to_query_operator(operator)
+        self.class::QUERY_OPERATOR_CONVERT_TO.find { |key, values| values.include?(operator) }&.first || operator
+      end
+
+      def match_operator_with_convert(operator)
+        self.class::OPERATORS_CONVERT_TO.find { |key, values| values.include?(operator) }&.first
+      end
+
+      def process_value(value, operator)
+        send(match_operator_with_convert(operator), value)
+      end
+
+      def build_instructions_string(display_values)
+        strings = @instructions.map { |instruction| build_instruction_string(instruction, display_values) }
+        strings.join(" ")
+      end
+
+      def build_instruction_string(instruction, display_values)
+        conditional = instruction[:conditional].present? ? "#{I18n.t("headmin.filters.conditionals.#{instruction[:conditional]}")} " : nil
+        operator = I18n.t("headmin.filters.operators.#{instruction[:operator]}")
+        value = display_values[:display_values].find { |item| item.second == instruction[:value] }
+        value = value.present? ? value.first : instruction[:value]
+
+        value = if instruction[:operator] == "is_null" || instruction[:operator] == "is_not_null"
+          # In case of special operators (is_null & is_not_null), we intercept the value
+          value == 1 ? I18n.t("headmin.filters.values.yes") : I18n.t("headmin.filters.values.no")
+        else
+          display_value(value)
+        end
+
+        "#{conditional}#{operator} &ldquo;#{value}&rdquo;"
+      end
+    end
+
+    class OperatorNotSupportedError < StandardError
+    end
+
+    class NotImplementedMethodError < StandardError
+    end
+  end
+end

data/app/models/headmin/filter/base_view.rb

@@ -0,0 +1,64 @@
+module Headmin
+  module Filter
+    class BaseView < ViewModel
+      def menu_item_options
+        keys = %i[name label]
+        options = to_h.slice(*keys)
+        default_menu_item_options.merge(options)
+      end
+
+      def filter_template_options
+        keys = %i[name label]
+        options = to_h.slice(*keys)
+        default_filter_template_options.merge(options)
+      end
+
+      def filter_operator_options
+        keys = %i[allowed_operators]
+        options = to_h.slice(*keys)
+        default_filter_operator_options.merge(options)
+      end
+
+      def filter_button_options
+        keys = %i[name label display_values filter]
+        options = to_h.slice(*keys)
+        default_filter_button_options.merge(options)
+      end
+
+      def label
+        @label || name.to_s.humanize
+      end
+
+      private
+
+      def default_menu_item_options
+        {
+          name: nil,
+          label: label
+        }
+      end
+
+      def default_filter_template_options
+        {
+          name: nil,
+          label: label
+        }
+      end
+
+      def default_filter_operator_options
+        {
+          allowed_operators: []
+        }
+      end
+
+      def default_filter_button_options
+        {
+          name: nil,
+          label: label,
+          display_values: [],
+          filter: nil
+        }
+      end
+    end
+  end
+end

data/app/models/headmin/filter/boolean.rb

@@ -0,0 +1,15 @@
+module Headmin
+  module Filter
+    class Boolean < Headmin::Filter::Base
+      OPERATORS = %w[eq not_eq is_null is_not_null]
+
+      def cast_value(value)
+        ActiveModel::Type::Boolean.new.cast(value)
+      end
+
+      def to_s
+        string
+      end
+    end
+  end
+end