cm-admin 0.3.0 → 0.4.0

data/lib/cm_admin/models/controller_method.rb

@@ -0,0 +1,75 @@
+module CmAdmin
+  module Models
+    module ControllerMethod
+      extend ActiveSupport::Concern
+
+      def show(params)
+        @current_action = CmAdmin::Models::Action.find_by(self, name: 'show')
+        @ar_object = @ar_model.find(params[:id])
+      end
+  
+      def index(params)
+        @current_action = CmAdmin::Models::Action.find_by(self, name: 'index')
+        # Based on the params the filter and pagination object to be set
+        @ar_object = filter_by(params, nil, filter_params(params))
+      end
+  
+      def new(params)
+        @current_action = CmAdmin::Models::Action.find_by(self, name: 'new')
+        @ar_object = @ar_model.new
+      end
+  
+      def edit(params)
+        @current_action = CmAdmin::Models::Action.find_by(self, name: 'edit')
+        @ar_object = @ar_model.find(params[:id])
+      end
+  
+      def update(params)
+        @ar_object = @ar_model.find(params[:id])
+        @ar_object.assign_attributes(resource_params(params))
+        @ar_object
+      end
+  
+      def create(params)
+        @ar_object = @ar_model.new(resource_params(params))
+      end
+
+      def filter_by(params, records, filter_params={}, sort_params={})
+        filtered_result = OpenStruct.new
+        sort_column = "created_at"
+        sort_direction = %w[asc desc].include?(sort_params[:sort_direction]) ? sort_params[:sort_direction] : "asc"
+        sort_params = {sort_column: sort_column, sort_direction: sort_direction}
+        records = self.name.constantize.where(nil) if records.nil?
+        final_data = CmAdmin::Models::Filter.filtered_data(filter_params, records, @filters)
+        pagy, records = pagy(final_data)
+        filtered_result.data = records
+        filtered_result.pagy = pagy
+        # filtered_result.facets = paginate(page, raw_data.size)
+        # filtered_result.sort = sort_params
+        # filtered_result.facets.sort = sort_params
+        return filtered_result
+      end
+  
+      def resource_params(params)
+        permittable_fields = @permitted_fields || @ar_model.columns.map(&:name).reject { |i| CmAdmin::REJECTABLE_FIELDS.include?(i) }.map(&:to_sym)
+        permittable_fields += @ar_model.reflect_on_all_attachments.map {|x|
+          if x.class.name.include?('HasOne')
+            x.name
+          elsif x.class.name.include?('HasMany')
+            Hash[x.name.to_s, []]
+          end
+        }.compact
+        nested_tables = self.available_fields[:new].except(:fields).keys
+        nested_tables += self.available_fields[:edit].except(:fields).keys
+        nested_fields = nested_tables.map {|table|
+          Hash[
+            table.to_s + '_attributes',
+            table.to_s.singularize.titleize.constantize.columns.map(&:name).reject { |i| CmAdmin::REJECTABLE_FIELDS.include?(i) }.map(&:to_sym) + [:id, :_destroy]
+          ]
+        }
+        permittable_fields += nested_fields
+        params.require(self.name.underscore.to_sym).permit(*permittable_fields)
+      end
+    end
+  end
+end

data/lib/cm_admin/models/dsl_method.rb

@@ -0,0 +1,122 @@
+module CmAdmin
+  module Models
+    module DslMethod
+      extend ActiveSupport::Concern
+
+      def cm_index(page_title: nil ,page_description: nil, &block)
+        @current_action = CmAdmin::Models::Action.find_by(self, name: 'index')
+        @current_action.page_title = page_title
+        @current_action.page_description = page_description
+        yield
+        # action.instance_eval(&block)
+      end
+
+      def cm_show(page_title: nil,page_description: nil,&block)
+        @current_action = CmAdmin::Models::Action.find_by(self, name: 'show')
+        @current_action.page_title = page_title
+        @current_action.page_description = page_description
+        yield
+      end
+  
+      def cm_edit(page_title: nil,page_description: nil, &block)
+        @current_action = CmAdmin::Models::Action.find_by(self, name: 'edit')
+        @current_action.page_title = page_title
+        @current_action.page_description = page_description
+        yield
+      end
+  
+      def cm_new(page_title: nil,page_description: nil,&block)
+        @current_action = CmAdmin::Models::Action.find_by(self, name: 'new')
+        @current_action.page_title = page_title
+        @current_action.page_description = page_description
+        yield
+      end
+
+      def page_title(title)
+        if @current_action
+          @current_action.page_title = title
+        end
+      end
+  
+      def page_description(description)
+        if @current_action
+          @current_action.page_description = description
+        end
+      end
+  
+      def tab(tab_name, custom_action, associated_model: nil, layout_type: nil, layout: nil, partial: nil, &block)
+        if custom_action.to_s == ''
+          @current_action = CmAdmin::Models::Action.find_by(self, name: 'show')
+          @available_tabs << CmAdmin::Models::Tab.new(tab_name, '', &block)
+        else
+          action = CmAdmin::Models::Action.new(name: custom_action.to_s, verb: :get, path: ':id/'+custom_action, layout_type: layout_type, layout: layout, partial: partial, child_records: associated_model)
+          @available_actions << action
+          @current_action = action
+          @available_tabs << CmAdmin::Models::Tab.new(tab_name, custom_action, &block)
+        end
+        yield if block
+      end
+  
+      def cm_show_section(section_name, &block)
+        @available_fields[@current_action.name.to_sym] ||= []
+        @available_fields[@current_action.name.to_sym] << CmAdmin::Models::CmShowSection.new(section_name, &block)
+      end
+  
+      def form_field(field_name, options={}, arg=nil)
+        unless @current_action.is_nested_field
+          @available_fields[@current_action.name.to_sym][:fields] << CmAdmin::Models::FormField.new(field_name, options[:input_type], options)
+        else
+          @available_fields[@current_action.name.to_sym][@current_action.nested_table_name] ||= []
+          @available_fields[@current_action.name.to_sym][@current_action.nested_table_name] << CmAdmin::Models::FormField.new(field_name, options[:input_type], options)
+        end
+      end
+  
+      def nested_form_field(field_name, &block)
+        @current_action.is_nested_field = true
+        @current_action.nested_table_name = field_name
+        yield
+      end
+  
+      def column(field_name, options={})
+        @available_fields[@current_action.name.to_sym] ||= []
+        if @available_fields[@current_action.name.to_sym].select{|x| x.lockable}.size > 0 && options[:lockable]
+          raise "Only one column can be locked in a table."
+        end
+        unless @available_fields[@current_action.name.to_sym].map{|x| x.field_name.to_sym}.include?(field_name)
+          @available_fields[@current_action.name.to_sym] << CmAdmin::Models::Column.new(field_name, options)
+        end
+      end
+  
+      def all_db_columns(options={})
+        field_names = self.instance_variable_get(:@ar_model)&.columns&.map{|x| x.name.to_sym}
+        if options.include?(:exclude) && field_names
+          excluded_fields = (Array.new << options[:exclude]).flatten.map(&:to_sym)
+          field_names -= excluded_fields
+        end
+        field_names.each do |field_name|
+          column field_name
+        end
+      end
+
+      # Custom actions
+      # eg
+      # class User < ApplicationRecord
+      #   cm_admin do
+      #     custom_action name: 'submit', verb: 'post', path: ':id/submit' do
+      #       def user_submit
+      #         Code for action here...
+      #       end
+      #     end
+      #   end
+      # end
+      def custom_action(name: nil, verb: nil, layout: nil, partial: nil, path: nil, &block)
+        @available_actions << CmAdmin::Models::Action.new(name: name, verb: verb, layout: layout, partial: partial, path: path)
+        self.class.class_eval(&block)
+      end
+
+      def filter(db_column_name, filter_type, options={})
+        @filters << CmAdmin::Models::Filter.new(db_column_name: db_column_name, filter_type: filter_type, options: options)
+      end
+    end
+  end
+end

data/lib/cm_admin/models/export.rb

@@ -2,19 +2,30 @@ module CmAdmin
   module Models
     class Export
       class << self
-        def generate_excel(klass_name, columns = [])
+        def generate_excel(klass_name, columns = [], helpers)
           klass = klass_name.constantize
-          records = get_records(klass, columns)
+          model = CmAdmin::Model.find_by({name: klass_name})
+          records = get_records(klass, model, columns, helpers)
           file_path = "#{Rails.root}/tmp/#{klass}_data_#{DateTime.now.strftime("%Y-%m-%d_%H-%M-%S")}.xlsx"
           create_workbook(records, columns, file_path)
           return file_path
         end
 
-        def get_records(klass, columns)
+        def get_records(klass, model, columns, helpers)
           records = klass
+          custom_fields = model.available_fields[:index].map{|field| field if field.field_type == :custom}.compact
+          normal_fields = model.available_fields[:index].map{|field| field unless field.field_type == :custom}.compact
           deserialized_columns = CmAdmin::Utils.deserialize_csv_columns(columns, :as_json_params)
           # This includes isn't recursve, a full solution should be recursive
-          records.includes(deserialized_columns[:include].keys).find_each.as_json(deserialized_columns)
+          records_arr = []
+          records.includes(deserialized_columns[:include].keys).find_each do |record|
+            record_hash = record.as_json({only: normal_fields.map(&:field_name)})
+            custom_fields.each do |field|
+              record_hash[field.field_name.to_sym] = helpers.send(field.helper_method, record, field.field_name)
+            end
+            records_arr << record_hash
+          end
+          records_arr
         end
 
         def create_workbook(records, class_name, file_path)
@@ -34,7 +45,7 @@ module CmAdmin
         end
 
         def exportable_columns(klass)
-          klass.available_fields[:index].map{|x| x.exportable ? x.db_column_name : ""}.reject { |c| c.empty? }
+          klass.available_fields[:index].map{|x| x.exportable ? x.field_name : ""}.reject { |c| c.empty? }
         end
 
       end

data/lib/cm_admin/models/field.rb

@@ -1,7 +1,8 @@
 module CmAdmin
   module Models
     class Field
-      attr_accessor :field_name, :label, :header
+
+      attr_accessor :field_name, :label, :header, :field_type, :format, :precision, :helper_method, :preview, :custom_link, :precision
 
       def initialize(field_name, attributes = {})
         @field_name = field_name

data/lib/cm_admin/models/filter.rb

@@ -1,9 +1,9 @@
 module CmAdmin
   module Models
     class Filter
-      attr_accessor :db_column_name, :filter_type, :placeholder, :collection, :multiselect, :checked
+      attr_accessor :db_column_name, :filter_type, :placeholder, :collection
 
-      VALID_FILTER_TYPES = Set[:checkbox, :date, :dropdown, :range, :search].freeze
+      VALID_FILTER_TYPES = Set[:date, :multi_select, :range, :search, :single_select].freeze
 
       def initialize(db_column_name:, filter_type:, options: {})
         raise TypeError, "Can't have array of multiple columns for #{filter_type} filter" if db_column_name.is_a?(Array) && db_column_name.size > 1 && !filter_type.to_sym.eql?(:search)
@@ -25,6 +25,71 @@ module CmAdmin
         end
         [db_column_name, filter_type]
       end
+
+      # Methods to filter the records based on the filter type.
+      class << self
+        def filtered_data(filter_params, records, filters)
+          if filter_params
+            filter_params.each do |scope_type, scope_value|
+              scope_name = if scope_type.eql?('date') || scope_type.eql?('range')
+                'date_and_range'
+              elsif scope_type.eql?('single_select') || scope_type.eql?('multi_select')
+                'dropdown'
+              else
+                scope_type
+              end
+              records = self.send("cm_#{scope_name}_filter", scope_value, records, filters) if scope_value.present?
+            end
+          end
+          records
+        end
+
+        def cm_search_filter(scope_value, records, filters)
+          return nil if scope_value.blank?
+          table_name = records.table_name
+
+          filters.select{|x| x if x.filter_type.eql?(:search)}.each do |filter|
+            terms = scope_value.downcase.split(/\s+/)
+            terms = terms.map { |e|
+              (e.gsub('*', '%').prepend('%') + '%').gsub(/%+/, '%')
+            }
+            sql = ""
+            filter.db_column_name.each.with_index do |column, i|
+              sql.concat("#{table_name}.#{column} ILIKE ?")
+              sql.concat(' OR ') unless filter.db_column_name.size.eql?(i+1)
+            end
+
+            records = records.where(
+              terms.map { |term|
+                sql
+              }.join(' AND '),
+              *terms.map { |e| [e] * filter.db_column_name.size }.flatten
+            )
+          end
+          records
+        end
+
+        def cm_date_and_range_filter(scope_value, records, filters)
+          return nil if scope_value.nil?
+          scope_value.each do |key, value|
+            if value.present?
+              value = value.split(' to ')
+              from = value[0].presence
+              to = value[1].presence
+              records = records.where(key => from..to)
+            end
+          end
+          records
+        end
+
+        def cm_dropdown_filter(scope_value, records, filters)
+          return nil if scope_value.nil?
+          scope_value.each do |key, value|
+            records = records.where(key => value) if value.present?
+          end
+          records
+        end
+      end
     end
   end
 end

data/lib/cm_admin/models/form_field.rb

@@ -0,0 +1,21 @@
+module CmAdmin
+  module Models
+    class FormField
+      attr_accessor :field_name, :label, :header, :input_type, :collection, :custom_value, :disabled
+      VALID_INPUT_TYPES = [:integer, :decimal, :string, :single_select, :multi_select, :date, :date_time, :text, :single_file_upload, :multi_file_upload, :hidden].freeze
+
+      def initialize(field_name, input_type, attributes = {})
+        raise ArgumentError, "Kindly select a valid filter type like #{VALID_INPUT_TYPES.sort.to_sentence(last_word_connector: ', or ')} instead of #{input_type} for column #{field_name}" unless VALID_INPUT_TYPES.include?(input_type.to_sym)
+        @field_name = field_name
+        set_default_values
+        attributes.each do |key, value|
+          self.send("#{key.to_s}=", value)
+        end
+      end
+
+      def set_default_values
+        self.disabled = false
+      end
+    end
+  end
+end

data/lib/cm_admin/models/tab.rb

@@ -0,0 +1,13 @@
+module CmAdmin
+  module Models
+    class Tab
+
+      attr_accessor :nav_item_name, :custom_action
+
+      def initialize(nav_item_name, custom_action)
+        @nav_item_name = nav_item_name
+        @custom_action = custom_action
+      end
+    end
+  end
+end

data/lib/cm_admin/version.rb

@@ -1,3 +1,3 @@
 module CmAdmin
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/cm_admin/view_helpers/column_field_helper.rb

@@ -0,0 +1,29 @@
+module CmAdmin
+  module ViewHelpers
+    module ColumnFieldHelper
+
+      #adds prefix and suffix to a value
+      def add_prefix_and_suffix_helper(value, prefix, suffix)
+        "#{prefix} #{value} #{suffix}"
+      end
+
+      #formats the column value a field
+      def column_for_field_helper(ar_object, column)
+        value = ar_object.send(column.db_column_name)
+        formatted_value = CmAdmin::Models::Column.format_data_type(column, value)
+        formatted_value = add_prefix_and_suffix_helper(formatted_value, column.prefix, column.suffix)
+        formatted_value = link_url_value_helper(column, value, formatted_value)
+        return formatted_value
+      end
+
+      #column's value is either linked with 'url' attribute's value or its own value
+      def link_url_value_helper(column, value, formatted_value)
+        return formatted_value unless column.column_type.to_s == 'link'
+        link_url_value = column.url.present? ? column.url : value
+        final_value = "<a href=#{link_url_value}>#{formatted_value}</a>".html_safe
+        return final_value
+      end
+
+    end
+  end
+end

data/lib/cm_admin/view_helpers/field_display_helper.rb

@@ -0,0 +1,65 @@
+module CmAdmin
+  module ViewHelpers
+    module FieldDisplayHelper
+
+      def show_field(ar_object, field)
+        content_tag(:div, class: "info-split") do
+          concat show_field_label(ar_object, field)
+          concat show_field_value(ar_object, field)
+        end
+      end
+
+      def show_field_label(ar_object, field)
+        content_tag(:div, class: "info-split__lhs") do
+          p = field.label.present? ? field.label.to_s : field.field_name.to_s.titleize
+        end
+      end
+      
+      def show_field_value(ar_object, field)
+        content_tag(:div, class: "info-split__rhs") do
+          case field.field_type || :string
+          when :integer
+            ar_object.send(field.field_name).to_s
+          when :decimal
+            ar_object.send(field.field_name).to_f.round(field.precision).to_s if ar_object.send(field.field_name)
+          when :string
+            ar_object.send(field.field_name).to_s
+          when :datetime
+            ar_object.send(field.field_name).strftime(field.format || "%d/%m/%Y").to_s if ar_object.send(field.field_name)
+          when :text
+            ar_object.send(field.field_name)
+          when :custom
+            send(field.helper_method, ar_object, field.field_name)
+          when :link
+            if field.custom_link
+              link = field.custom_link
+            else
+              link = ar_object.send(field.field_name)
+            end
+            content_tag :a, href: link do
+              ar_object.send(field.field_name).to_s
+            end 
+          when :attachment
+            concat show_attachment_value(ar_object, field)
+          end
+        end
+      end
+
+      def show_attachment_value(ar_object, field)
+        if ar_object.send(field.field_name).attached?
+          if ar_object.send(field.field_name).class.name.include?('One')
+            content_tag :a, href: rails_blob_path(ar_object.send(field.field_name), disposition: "attachment") do
+              ar_object.send(field.field_name).filename.to_s 
+            end
+          elsif ar_object.send(field.field_name).class.name.include?('Many')
+            ar_object.send(field.field_name).map do |asset|
+              content_tag :a, href: rails_blob_path(asset, disposition: "attachment") do
+                asset.filename.to_s 
+              end
+            end.join("\n").html_safe
+          end
+        end
+      end
+    end
+  end
+end