custom_table 0.1.0

data/app/helpers/custom_table/application_helper.rb

@@ -0,0 +1,483 @@
+module CustomTable
+  module ApplicationHelper
+
+    # MOVE TO GENERATED HELPER
+    # def boolean_icon(value, true_value = nil, false_value = nil)
+    #   capture do
+    #     concat content_tag(:i, "", class: (value ? "bi bi-check-lg text-success" : "bi bi-x-lg text-danger"), data: {raw: value})
+    #     concat content_tag(:span, value ? true_value : false_value, class: "ms-1") unless true_value.nil?
+    #   end
+    # end
+
+    def custom_table_form_for(record, options = {}, &block)
+      options[:url] = request.path if options[:url].nil?
+      options[:method] = :get
+  
+      options[:html] ||= {} 
+      options[:html][:class] = "row row-cols-md-auto g-3 align-items-center custom-table-filter"
+      options[:wrapper] = options[:wrapper] || :inline_form
+  
+      options[:wrapper_mappings] = {
+        boolean: :inline_boolean,
+        check_boxes: :vertical_collection,
+        radio_buttons: :vertical_collection,
+        date: :inline_element,
+        select: :inline_select
+      }
+
+      simple_form_for(record, options, &block)
+    end
+  
+    def fields_table_for(collection, options = {}, &block); end
+  
+    # Tries to fetch attribute value by all possible ways (by priority):
+    # Helper {singular_model_name}_{field}_field
+    # Helper {singular_model_name}_{field}
+    # Helper {singular_model_name}_{field}_raw
+    # Attribute of model
+    def field_value_for item, field, definitions: nil, variant: nil
+ 
+      defs = definitions
+
+      model_name = item.model_name.singular
+      global_model_name = item.class.model_name.singular # non-model
+
+      helpers = []
+      helpers += [defs[:helper]] if !defs.nil?
+
+      helpers += [
+        "#{model_name}_#{variant}_#{field}_field",
+        "#{model_name}_#{variant}_#{field}",
+      ] if !variant.nil?
+
+      helpers += [
+        "#{model_name}_#{field}_field",
+        "#{model_name}_#{field}",
+        "#{model_name}_#{field}_raw",
+        "#{global_model_name}_#{field}"
+      ]
+
+      if item.class.superclass.to_s != "ApplicationRecord"
+        super_model_name = item.class.superclass.model_name.singular
+        helpers += [
+          "#{super_model_name}_#{field}_field",
+          "#{super_model_name}_#{field}",
+          "#{super_model_name}_#{field}_raw",
+        ] 
+      end
+
+      helpers = helpers.flatten.compact
+
+      helpers.each do |helper|
+        if self.class.method_defined?(helper)
+          if self.method(helper).arity == 1 || self.method(helper).arity == -2
+            return self.send(helper, item) || not_set 
+          end
+          if self.method(helper).arity == 2
+            return self.send(helper, item, field) || not_set 
+          end
+        end
+      end
+  
+      if !defs.nil? && defs[:amount]
+        if !item.class.columns_hash[field.to_s].nil? && item.class.columns_hash[field.to_s].type == :integer
+          return amount_value(item.send(field), 0) rescue ""
+        else
+          return amount(item.send(field)) rescue ""
+        end
+      else
+        if item.class.reflect_on_association(field)
+          return not_set if (item.send(field) rescue nil).nil?
+          return render(item.send(field)) rescue item.send(field).to_s rescue ""
+        elsif item.class.columns_hash[field.to_s] && item.class.columns_hash[field.to_s].type == :boolean
+          return boolean_icon(item.send(field)) rescue ""
+        elsif item.class.defined_enums.has_key?(field.to_s)
+          return (item.send("human_#{field}") rescue (item.send(field).presence || not_set)).to_s rescue ""
+        elsif item.class.columns_hash[field.to_s] && [:date, :datetime].include?(item.class.columns_hash[field.to_s].type)
+          return (item.send(field).blank? ? not_set : l(item.send(field), format: :short)) rescue ""
+        elsif item.class.columns_hash[field.to_s] && [:integer, :float, :decimal].include?(item.class.columns_hash[field.to_s].type)
+          return not_set if (item.send(field) rescue nil).nil?
+          return amount(item.send(field)) rescue ""
+        else
+          return (item.send(field).presence || not_set).to_s rescue ""
+        end
+      end
+      
+    end
+
+    def custom_table_totals collection, fields, totals = {}, fields_totals = {}
+
+      out = {}
+      totals = {} if totals.nil?
+      fields_totals = {} if fields_totals.nil?
+
+      fields.keys.each do |field|
+
+        # We only work if field total is enabled explicitly with definition or totals
+        next if !fields[field][:total] && !totals.has_key?(field)
+
+        # Taking pre-defined value if available
+        if !totals[field].nil?
+          out[field] = totals[field]
+        else
+          model_class = collection.model
+          # Trying to find helper first
+          model_name = model_class.model_name.singular
+          helper = "#{model_name}_#{field}_total"
+
+          if self.class.method_defined?(helper)
+            # Better use helper!
+            out[field] = self.send(helper, collection.except(:limit, :offset, :order, :group))
+          else
+            if collection.respond_to?(:total_pages) && (!model_class.columns_hash[field.to_s].nil? || !fields[field][:total_scope].nil?) 
+              # We can try to sum value from database
+
+              if fields[field][:total_scope].nil?
+                out[field] = collection.except(:limit, :offset, :order, :group).sum(field)
+              else 
+                out[field] = collection.except(:limit, :offset, :order, :group).send(fields[field][:total_scope])
+              end
+            else
+              # Taking simple summed value because all data is shown
+              out[field] = fields_totals[field]
+            end
+
+          end
+
+        end
+      end
+
+      out
+
+    end
+  
+    # Same as above but for Export only
+    def raw_field_value_for item, field, definitions: nil, variant: nil
+ 
+      defs = definitions
+
+      model_name = item.model_name.singular
+      global_model_name = item.class.model_name.singular
+  
+      helpers = []
+
+      helpers += [
+        "#{model_name}_#{variant}_#{field}_field_raw",
+        "#{model_name}_#{variant}_#{field}_raw",
+      ] if !variant.nil?
+
+      helpers += [
+        "#{model_name}_#{field}_field_raw",
+        "#{model_name}_#{field}_raw",
+        "#{global_model_name}_#{field}_raw"
+      ]
+
+      if item.class.superclass.to_s != "ApplicationRecord"
+        super_model_name = item.class.superclass.model_name.singular
+        helpers += [
+          "#{super_model_name}_#{field}_field_raw",
+          "#{super_model_name}_#{field}_raw",
+        ] 
+      end
+
+      helpers = helpers.flatten.compact
+
+      helpers.each do |helper|
+        return self.send(helper, item) if self.class.method_defined?(helper)
+      end
+
+      if !defs.nil? && defs[:amount]
+        return item.send(field) rescue nil
+      else
+        if item.class.reflect_on_association(field)
+          return item.send(field).to_s rescue nil
+        elsif item.class.columns_hash[field.to_s] && item.class.columns_hash[field.to_s].type == :boolean
+          return item.send(field) rescue nil
+        elsif item.class.defined_enums.has_key?(field.to_s)
+          return (item.send(field).presence) rescue nil
+        elsif item.class.columns_hash[field.to_s] && [:date, :datetime].include?(item.class.columns_hash[field.to_s].type)
+          return (item.send(field).presence) rescue nil
+        elsif item.class.columns_hash[field.to_s] && [:float, :decimal].include?(item.class.columns_hash[field.to_s].type)
+          return item.send(field).round(2) rescue nil
+        elsif item.class.columns_hash[field.to_s] && [:integer].include?(item.class.columns_hash[field.to_s].type)
+          return item.send(field) rescue nil
+        else
+          return (item.send(field).presence) rescue nil
+        end
+      end
+      
+    end
+  
+
+    # Returns list of fields to show in table according user settings
+    def custom_table_fields_for(model, variant: nil, current_search: {}, predefined_fields: nil, use_all_fields: false)
+  
+      fields = []
+      current_search = {} if current_search.nil?
+  
+      model_fields = custom_table_fields_definition_for(model, variant)
+  
+      if (!predefined_fields.nil?)
+        out = {}
+        predefined_fields.each do |f|
+          out[f] = model_fields[f]
+        end
+        return out.compact
+        # return model_fields.select {|k,v| predefined_fields.include?(k) }
+      end
+  
+      fields_key = model.model_name.to_s
+      fields_key += "-#{variant}" unless variant.nil?
+  
+      s = custom_table_user_customized_fields_for(model, variant)
+ 
+      use_all_fields = true if params[:custom_table_use_all_fields]
+
+      if use_all_fields
+        selected_fields = model_fields.keys
+      else
+        if !s.nil?
+          # Use saved user settings for the model
+          always_selected_fields = model_fields.select { |x, y| [:always].include?(y[:appear]) || current_search.keys.include?(x.to_s) }.keys
+          always_selected_fields.each {|f| s = {"#{f.to_s}": true}.merge(s) if s[f].nil? }
+          selected_fields = s.select{|f,v| v }.keys
+        else
+          # Use default model settings
+          selected_fields = model_fields.select { |x, y| [:always, :default].include?(y[:appear]) || current_search.keys.include?(x.to_s) }.keys
+        end
+      end
+  
+      # Filter selection again with model settings for sure
+      return selected_fields.collect{|f| [f, model_fields[f]]}.to_h
+  
+    end
+  
+    # Returns list of fields for customization form
+    def custom_table_fields_settings_for(model, variant: nil)
+  
+      model_fields = custom_table_fields_definition_for(model, variant)
+      model_fields = model_fields.reject {|k,v| [:export, :never].include?(v[:appear]) }
+
+      fields_key = model.model_name.to_s
+      fields_key += "-#{variant}" unless variant.nil?
+  
+      user_customization = custom_table_user_customized_fields_for(model, variant)
+
+      if !user_customization.nil?
+        # Add new fields at the top to user customization if not present
+        model_fields.each do |f, v| 
+          next if !user_customization[f].nil? 
+          selected = [:always, :default].include?(v[:appear])
+          new_field = {"#{f.to_s}": selected}
+          if selected
+            user_customization = new_field.merge(user_customization)
+          else
+            user_customization = user_customization.merge(new_field)
+          end
+        end
+        return user_customization.reject{|f,v| model_fields[f].nil?}.collect{|f,v| [f, {selected: v}.merge(model_fields[f])]}.to_h
+      else
+        # Use default model settings
+        # abort model_fields.transform_values!{|f| f[:selected] = true}.inspect
+        return model_fields.each{|k,f| f[:selected] = [:always, :default].include?(f[:appear])}
+      end
+  
+    
+    end
+  
+    # Prepares object of user fields customization
+    def custom_table_user_customized_fields_for(model, variant = nil)
+      fields_key = custom_table_fields_key(model, variant)
+      defs = custom_table_fields_definition_for(model, variant)
+      return nil if current_user.nil? || current_user.custom_table.nil? || current_user.custom_table.dig(fields_key, :fields).nil?
+      return current_user.custom_table.dig(fields_key, :fields).symbolize_keys.reject{|k,v| defs[k.to_sym].nil?}
+  
+    end
+  
+    # Prepares object of user search customization
+    def custom_table_user_customization_for(model, variant = nil)
+      fields_key = custom_table_fields_key(model, variant)
+      return nil if current_user.nil? || current_user.custom_table.nil?
+      return current_user.custom_table[fields_key]&.symbolize_keys
+    end
+  
+    def custom_table_fields_key(model, variant = nil)
+      fields_key = model.model_name.to_s
+      fields_key += "-#{variant}" unless variant.nil?
+      return fields_key
+    end
+  
+    def custom_table_customizable_fields_for(model, variant = nil)
+      model_fields = custom_table_fields_definition_for(model, variant)
+      model_fields.reject {|k,v| [:always, :export, :never].include?(v[:appear]) }
+    end
+  
+    # Base definition for model
+    def custom_table_fields_definition_for(model, variant = nil)
+      helper_name = "#{model.model_name.singular}_custom_table_fields"
+      if (! self.class.method_defined?(helper_name))
+        raise "#{helper_name} helper is not defined so we do not know how to render custom_table for #{model}"
+      end
+
+      if variant.nil? || method(helper_name).parameters.empty?
+        defs = self.send("#{helper_name}")
+      else
+        defs = self.send("#{helper_name}", variant)
+      end
+
+      return defs.each{|x,y| y[:label] = model.human_attribute_name(x) if y[:label].nil? }
+    end
+  
+    # Base definition for model
+    def custom_table_fields_definition_for_field(model, field, variant = nil)
+      helper_name = "#{model.model_name.singular}_custom_table_fields"
+      if (! self.class.method_defined?(helper_name))
+        raise "#{helper_name} helper is not defined so we do not know how to render custom_table for #{model}"
+      end
+      if variant.nil? || method(helper_name).parameters.empty?
+        defs = self.send("#{helper_name}")
+      else
+        defs = self.send("#{helper_name}", variant)
+      end
+      return nil if defs[field].nil?
+      defs[:label] = model.human_attribute_name(field) if defs[:label].nil?
+      return defs
+    end
+  
+
+    # Returns true if model can be customized by current user at least by one field
+    def current_user_has_customizable_fields_for?(model, variant=nil)
+      return false if current_user.nil?
+      custom_table_customizable_fields_for(model, variant).count.positive?
+    end
+  
+    def custom_table_data collection, variant=nil, **params
+
+      params[:collection] = collection
+      params[:variant] = variant
+      params[:paginate] = true if params[:paginate]!=false
+      params[:last_page] = true if params[:last_page]!=false
+      params[:namespace] = (controller.class.module_parent == Object) ? nil : controller.class.module_parent.to_s.underscore.to_sym
+      params[:force_edit_button] = false if params[:force_edit_button].nil?
+      params[:modal_edit] = true if params[:modal_edit].nil?
+      
+      render "custom_table/table", params do
+        yield
+      end
+    end
+  
+    # Data for updating values via turbo according object id and field name
+    def custom_table_row_data item, variant = nil, **params
+  
+      params[:item] = item
+      params[:variant] = variant
+      params[:namespace] = (controller.class.module_parent == Object) ? nil : controller.class.module_parent.to_s.underscore.to_sym
+      
+      render "custom_table/table_row_data", params do
+        yield
+      end
+    end
+  
+    def custom_table_filter search_model, variant=nil, **params, &block
+
+      params[:search_model] = search_model
+      params[:variant] = variant
+      render "custom_table/filter", params do |f|
+        yield if !block.nil?
+      end
+    end
+
+    # Rounded
+    def amount_round(c)
+      content_tag(:span, amount_value(c, 0), "data-raw": (c.blank? ? nil : c.round))
+    end
+  
+    # Base
+    def amount(c)
+      content_tag(:span, amount_value(c), "data-raw": (c.blank? ? nil : c.round(2)))
+    end
+  
+    # Abstract
+    def amount_value(c, p = 2)
+      number_to_currency(c, precision: p, locale: :en, unit: "")
+    end
+  
+    # Colored
+    def amount_color(c)
+      content_tag(:span, amount(c), class: ["amount", (c.to_f >= 0 ? "positive" : "negative")])
+    end
+  
+    # Colored rounded
+    def amount_round_color(c)
+      content_tag(:span, amount_round(c), class: ["amount", (c.to_f >= 0 ? "positive" : "negative")])
+    end
+  
+    def custom_table_download_button collection, **p
+      p[:collection] = collection
+      p[:downloads] ||= {}
+      p[:downloads].unshift({title: t("custom_table.download_as_csv"), href: params.permit!.merge({:format => :csv})}) if p[:csv]
+      render "custom_table/download", p
+    end
+  
+    def custom_table_settings search_model, variant=nil, **params
+
+      params[:search_model] = search_model
+      params[:variant] = variant
+  
+      render "custom_table/settings", params
+  
+    end
+  
+    def custom_table_settings_button search_model, variant=nil, size: "sm"
+      link_to custom_table.edit_setting_path(search_model.model_name, variant: variant), :class => "btn btn-outline-primary btn-#{size}", data: {"turbo-frame": "remote-modal"} do
+        custom_table_settings_icon
+      end
+    end
+
+    def custom_table_variants_for model
+      helper_name = "#{model.model_name.singular}_custom_table_variants"
+      return self.send(helper_name) if self.class.method_defined?(helper_name)
+      return []
+    end
+
+    def tree_opener item_id, has_children=false, expanded=false
+      content_tag :span, class: "tree-opener #{expanded ? 'opened' : ''}", data: {action: (has_children ? "click->table#toggle" : ""), "table-css-param": ".child-of-#{item_id}"} do
+        concat content_tag(:span, (has_children ? "▶" : "▷"), class: "closed")
+        concat content_tag(:span, "▼", class: "opened")
+      end
+    end
+
+    def custom_table_fields_totals fields:, totals:, item:, fields_totals:, variant:
+      fields.each do |field, defs|
+        if !totals.nil? && totals.has_key?(field) && totals[field].nil? # Auto-counting
+          fields_totals[field] = 0 if fields_totals[field].nil?
+          fields_totals[field] += raw_field_value_for(item, field, definitions: defs, variant: variant).to_f rescue 0
+        end
+      end
+      return fields_totals
+    end
+
+    def custom_table_batch_selector_check_box item, **params
+
+      # abort params.inspect
+
+      params[:param] = "#{item.model_name.plural}[]" if params[:param].nil?
+      params[:data] = {"toggle-target": "checkbox", "batch-actions-target": "checkbox", "action": "toggle#recalculateToggler batch-actions#refresh"}
+
+      check_box_tag params[:param], item.id, (!params[item.model_name.plural.to_sym].blank?) && (params[item.model_name.plural.to_sym].include?(item.id.to_s)), params
+    end
+
+    # Gets array of fields and results in object of available fields and definitions from fields from list
+    def custom_table_fields_list_to_definitions model, fields
+      d = custom_table_fields_definition_for(model) 
+      out = {}
+      fields.each do |f|
+        found = d.find {|k, v| k == f }
+        out[f] = found[1] if !found.nil?
+      end
+      return out
+    end
+
+  end
+  
+end

data/app/helpers/custom_table/fieldset_helper.rb

@@ -0,0 +1,90 @@
+module CustomTable
+
+  module FieldsetHelper
+
+    class FieldsetBuilder
+
+      def initialize(object, template, **params)
+        @object = object
+        @template = template
+        @params = params
+      end
+
+      def has_editable?
+        @template.respond_to?(:editable)
+      end
+
+      def field column, **params, &block
+
+        defs = custom_table_fields_definition_for_field(@object.class, column) rescue nil
+
+        params = {} if params.nil?
+        params = params.deep_merge(@params)
+        params[:editable] = true if params[:editable].nil?
+        params[:adaptive] = false if params[:adaptive].nil?
+
+        if params[:label].nil?
+          if !defs.nil? && !defs[:label].blank?
+            params[:label] = defs[:label].nil?
+          else
+            params[:label] = @object.class.human_attribute_name(column) 
+          end
+        end
+
+        params[:template] = "field" if params[:template].nil?
+        params[:column] = column
+        params[:object] = @object
+
+        hint_key = "simple_form.hints.#{@object.model_name.singular}.#{column}"
+        if I18n.exists?(hint_key)
+          params[:hint] = I18n.t(hint_key)
+        end
+
+        @template.render "custom_table/#{params[:template]}", **params do
+          if params[:editable] && has_editable?
+            params[:editable_params] = {} if params[:editable_params].nil?
+            editable_field = params[:editable_params][:field] || column
+            @template.editable @object, editable_field, **params[:editable_params] do
+              if block_given?
+                yield
+              else
+                @template.field_value_for(@object, column)
+              end
+            end
+          else
+            if block_given?
+              yield
+            else
+              @template.field_value_for(@object, column)
+            end
+          end
+
+        end
+      end
+
+    end
+
+    def fieldset object=nil, **params, &block
+
+      builder = FieldsetBuilder.new(object, self, **params)
+      output = capture(builder, &block)
+
+      render "custom_table/fieldset" do
+        output
+      end
+
+    end
+
+    def field object, column, **params, &block
+
+      params[:template] = "field_plain"
+
+      builder = FieldsetBuilder.new(object, self, **params)
+
+      builder.field(column, **params, &block)
+
+    end
+
+  end
+
+end

data/app/helpers/custom_table/icons_helper.rb

@@ -0,0 +1,42 @@
+module CustomTable
+
+  module IconsHelper
+
+    def custom_table_download_icon
+      return custom_table_icon("fa fa-download") if CustomTable.configuration.icons_framework == :fa
+      return custom_table_icon("bi bi-download") if CustomTable.configuration.icons_framework == :bi
+    end
+
+    def custom_table_settings_icon
+      return custom_table_icon("fa fa-cog") if CustomTable.configuration.icons_framework == :fa
+      return custom_table_icon("bi bi-gear") if CustomTable.configuration.icons_framework == :bi
+
+    end
+
+    def custom_table_move_icon_class
+      return "fa fa-sort" if CustomTable.configuration.icons_framework == :fa
+      return "bi bi-arrow-down-up" if CustomTable.configuration.icons_framework == :bi
+    end
+
+    def custom_table_tree_child_icon_class
+      return "fa fa-arrow-right" if CustomTable.configuration.icons_framework == :fa
+      return "bi bi-arrow-return-right" if CustomTable.configuration.icons_framework == :bi
+    end
+
+    def custom_table_cancel_icon
+      return custom_table_icon("fa fa-ban") if CustomTable.configuration.icons_framework == :fa
+      return custom_table_icon("bi bi-slash-circle") if CustomTable.configuration.icons_framework == :bi
+    end
+
+    def custom_table_search_icon
+      return custom_table_icon("fa fa-search") if CustomTable.configuration.icons_framework == :fa
+      return custom_table_icon("bi bi-search") if CustomTable.configuration.icons_framework == :bi
+    end
+
+    def custom_table_icon c
+      return content_tag(:i, "", class: c)
+    end
+
+  end
+
+end

data/app/inputs/date_picker_input.rb

@@ -0,0 +1,52 @@
+class DatePickerInput < SimpleForm::Inputs::StringInput
+  def input(wrapper_options)
+    set_html_options
+    set_value_html_option
+
+    classes = ["input-group"]
+
+    input_html_options[:data] ||= {}
+    input_html_options[:data]["controller"] = "flatpickr"
+
+    picker_options = (options[:picker] || {}).merge!(flatpickr_options)
+
+    picker_options.each do |k, v|
+      input_html_options[:data]["flatpickr-#{k}-value"] = v
+    end
+
+    input_html_options[:data]["flatpickr-locale-value"] = I18n.locale
+
+    classes.push("input-group-sm") if input_html_options[:class].include? "input-sm"
+
+    # template.content_tag :div, class: classes do
+    input = super(wrapper_options) # leave StringInput do the real rendering
+    # end
+  end
+
+  def input_html_classes
+    super.push '' # 'form-control'
+  end
+
+  private
+
+  def set_html_options
+    input_html_options[:type] = 'text'
+    input_html_options[:data] ||= {}
+  end
+
+  def set_value_html_option
+    # return unless value.present?
+    # input_html_options[:value] ||= I18n.localize(value, format: display_pattern)
+  end
+
+  def value
+    v = object.send(attribute_name) if object.respond_to?(attribute_name) || object.is_a?(Ransack::Search)
+    v = v.to_date if v.is_a?(String)
+    v
+  end
+
+  def flatpickr_options
+    {}
+  end
+
+end