headmin 0.4.1 → 0.5.1

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/blocks_view.rb

@@ -9,7 +9,7 @@ module Headmin
     end
 
     def prefixes
-      paths + ["website/blocks", "blocks", ""]
+      paths + ["website/blocks", "blocks"]
     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