headmin 0.4.2 → 0.5.0

data/app/assets/stylesheets/headmin/layout/body.scss

@@ -2,5 +2,10 @@
   background: $card-cap-bg;
   height: 100vh;
   overflow-y: scroll;
+  display: flex;
+  flex-direction: column;
 }
 
+.content {
+  flex-grow: 1
+}

data/app/assets/stylesheets/headmin/popup.scss

@@ -2,7 +2,6 @@
   padding: 10px;
   background: $white;
   z-index: $zindex-popover;
-  width: $popover-max-width;
   @include reset-text();
   @include font-size($popover-font-size);
   word-wrap: break-word;

data/app/assets/stylesheets/headmin.css

@@ -13103,7 +13103,6 @@ input[type=search] {
 }
 html {
   height: 100%;
-  background: red;
 }
 .list-group-item.active .text-muted {
   color: #fff !important;
@@ -13117,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;
@@ -13310,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;
@@ -13318,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/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

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

@@ -0,0 +1,61 @@
+module Headmin
+  module Filter
+    class BooleanView < ViewModel
+      def base_options
+        keys = %i[name label form]
+        options = to_h.slice(*keys)
+        default_base_options.merge(options)
+      end
+
+      def input_options
+        keys = %i[form]
+        options = to_h.slice(*keys)
+        default_input_options.merge(options)
+      end
+
+      private
+
+      def value
+        # If the value is nil we want to display the first option (which is true)
+        @value.nil? ? @value = true : ""
+      end
+
+      def id
+        "#{name}_value"
+      end
+
+      def name
+        @name || attribute
+      end
+
+      def label
+        @label || I18n.t("attributes.#{attribute}", default: name.to_s)
+      end
+
+      def default_base_options
+        {
+          label: label,
+          name: attribute,
+          filter: Headmin::Filter::Boolean.new(name, @params),
+          display_values: [[I18n.t("headmin.filters.values.true"), true], [I18n.t("headmin.filters.values.false"), false]],
+          allowed_operators: Headmin::Filter::Boolean::OPERATORS
+        }
+      end
+
+      def default_input_options
+        {
+          label: false,
+          wrapper: false,
+          id: id,
+          collection: [[I18n.t("headmin.filters.values.true"), 1], [I18n.t("headmin.filters.values.false"), 0]],
+          selected: value ? 1 : 0,
+          data: {
+            action: "change->filter#updateHiddenValue",
+            filter_target: "value",
+            filter_row_target: "original"
+          }
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Headmin
+  module Filter
+    class ButtonView < ViewModel
+      def id
+        @id || SecureRandom.hex
+      end
+
+      def name
+        @name.to_sym
+      end
+
+      def label
+        @label || name.to_s.humanize
+      end
+
+      def display_values
+        @display_values || []
+      end
+
+      def filter
+        @filter || nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Headmin
+  module Filter
+    class ConditionalView < ViewModel
+      def selected
+        @selected ? "+#{@selected.to_s.upcase}+" : nil
+      end
+
+      def values
+        {
+          "+AND+": I18n.t("headmin.filters.filter.conditional.and"),
+          "+OR+": I18n.t("headmin.filters.filter.conditional.or")
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Headmin
+  module Filter
+    class Date < Headmin::Filter::Base
+      OPERATORS = %w[eq not_eq gt gteq lt lteq between not_between in not_in is_null is_not_null]
+
+      def cast_value(value)
+        value.present? ? value.to_date : ::Date.current
+      rescue
+        raise TypeError, "The value that was passed to this filter is not a date"
+      end
+
+      def display_value(value)
+        # This uses the default date format of headmin.
+        # Can be overwritten by setting default date format of the application.
+        I18n.l(value)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Headmin
+  module Filter
+    class DateView < ViewModel
+      def base_options
+        keys = %i[name label form]
+        options = to_h.slice(*keys)
+        default_base_options.merge(options)
+      end
+
+      def input_options
+        keys = %i[form]
+        options = to_h.slice(*keys)
+        default_input_options.merge(options)
+      end
+
+      private
+
+      def id
+        "#{name}_value"
+      end
+
+      def name
+        @name || attribute
+      end
+
+      def label
+        @label || I18n.t("attributes.#{attribute}", default: name.to_s)
+      end
+
+      def default_base_options
+        {
+          label: label,
+          name: attribute,
+          filter: Headmin::Filter::Date.new(name, @params),
+          allowed_operators: Headmin::Filter::Date::OPERATORS - %w[in not_in between not_between]
+        }
+      end
+
+      def default_input_options
+        {
+          label: false,
+          wrapper: false,
+          id: id,
+          data: {action: "change->filter#updateHiddenValue",
+                 filter_target: "value",
+                 filter_row_target: "original"},
+          class: "form-control"
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Headmin
+  module Filter
+    class FlatpickrView < ViewModel
+      def base_options
+        keys = %i[name label form]
+        options = to_h.slice(*keys)
+        default_base_options.merge(options)
+      end
+
+      def input_options
+        keys = %i[form]
+        options = to_h.slice(*keys)
+        default_input_options.merge(options)
+      end
+
+      private
+
+      def id
+        "#{name}_value"
+      end
+
+      def name
+        @name || attribute
+      end
+
+      def label
+        @label || I18n.t("attributes.#{attribute}", default: name.to_s)
+      end
+
+      def default_base_options
+        {
+          label: label,
+          name: attribute,
+          filter: Headmin::Filter::Date.new(name, @params),
+          allowed_operators: Headmin::Filter::Date::OPERATORS - %w[in not_in between not_between]
+        }
+      end
+
+      def default_input_options
+        {
+          label: false,
+          wrapper: false,
+          id: id,
+          data: {
+            action: "change->filter#updateHiddenValue",
+            filter_target: "value",
+            filter_row_target: "original"
+          },
+          class: "form-control"
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module Headmin
+  module Filter
+    class MenuItemView < ViewModel
+    end
+  end
+end