cm-admin 0.3.0 → 0.4.0

data/app/views/layouts/static.html.slim

@@ -0,0 +1,18 @@
+doctype html
+html
+  head
+    title
+      | Admin
+    meta[name="viewport" content="width=device-width,initial-scale=1"]
+    = csrf_meta_tags
+    = csp_meta_tag
+    = stylesheet_link_tag 'cm_admin/cm_admin', media: 'all', 'data-turbolinks-track': 'reload'
+    = stylesheet_pack_tag 'cm_admin/application', 'data-turbolinks-track': 'reload'
+    = javascript_pack_tag 'cm_admin/application', 'data-turbolinks-track': 'reload'
+  body
+    - flash.each do |type, msg|
+      .alert class="alert-#{type}"
+        = msg
+    .cm-admin-static
+      .d-flex.flex-column.h-100
+        = yield

data/bin/console

@@ -1,7 +1,6 @@
 #!/usr/bin/env ruby
 
 require "bundler/setup"
-require "cm_admin"
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.

data/cm_admin.gemspec

@@ -30,4 +30,5 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'slim', '~> 4.1.0'
   spec.add_runtime_dependency 'webpacker', '~> 5.2.1'
   spec.add_runtime_dependency 'axlsx_rails', '~> 0.6.1'
+  spec.add_runtime_dependency 'cocoon', '~> 1.2.15'
 end

data/config/routes.rb

@@ -1,6 +1,7 @@
 CmAdmin::Engine.routes.draw do
-  controller 'main' do
+  controller 'static' do
     get '/', action: 'dashboard'
+    get '/access-denied', action: 'error_403'
   end
 
   controller 'exports' do

data/config/webpack/environment.js

@@ -3,8 +3,9 @@ const { environment } = require('@rails/webpacker')
 const webpack = require('webpack')
 environment.plugins.prepend('Provide',
   new webpack.ProvidePlugin({
-    $: 'jquery/src/jquery',
-    jQuery: 'jquery/src/jquery',
+    $: 'jquery',
+    jQuery: 'jquery',
+    moment: 'moment',
     Popper: ['popper.js', 'default']
   })
 )

data/lib/cm_admin/model.rb

@@ -1,19 +1,26 @@
 require_relative 'constants'
 require_relative 'models/action'
 require_relative 'models/field'
+require_relative 'models/form_field'
 require_relative 'models/blocks'
 require_relative 'models/column'
 require_relative 'models/filter'
 require_relative 'models/export'
+require_relative 'models/cm_show_section'
+require_relative 'models/tab'
+require_relative 'models/dsl_method'
+require_relative 'models/controller_method'
 require 'pagy'
 require 'axlsx'
-
+require 'cocoon'
 
 module CmAdmin
   class Model
     include Pagy::Backend
     include Models::Blocks
-    attr_accessor :available_actions, :actions_set, :available_fields, :permitted_fields, :current_action, :params, :filters
+    include Models::DslMethod
+    include Models::ControllerMethod
+    attr_accessor :available_actions, :actions_set, :available_fields, :permitted_fields, :current_action, :params, :filters, :available_tabs
     attr_reader :name, :ar_model
 
     # Class variable for storing all actions
@@ -25,7 +32,8 @@ module CmAdmin
       @ar_model = entity
       @available_actions ||= []
       @current_action = nil
-      @available_fields ||= {index: [], show: [], edit: [], new: []}
+      @available_tabs ||= []
+      @available_fields ||= {index: [], show: [], edit: {fields: []}, new: {fields: []}}
       @params = nil
       @filters ||= []
       instance_eval(&block) if block_given?
@@ -39,6 +47,29 @@ module CmAdmin
       def all_actions
         @all_actions || []
       end
+
+      def find_by(search_hash)
+        CmAdmin.cm_admin_models.find { |x| x.name == search_hash[:name] }
+      end
+    end
+
+    def custom_controller_action(action_name, params)
+      current_action = CmAdmin::Models::Action.find_by(self, name: action_name.to_s)
+      if current_action
+        @current_action = current_action
+        @ar_object = @ar_model.find(params[:id])
+        if @current_action.child_records
+          child_records = @ar_object.send(@current_action.child_records)
+          @associated_model = CmAdmin::Model.find_by(name: @ar_model.reflect_on_association(@current_action.child_records).klass.name)
+          if child_records.is_a? ActiveRecord::Relation
+            @associated_ar_object = filter_by(params, child_records)
+          else
+            @associated_ar_object = child_records
+          end
+          return @ar_object, @associated_model, @associated_ar_object
+        end
+        return @ar_object
+      end
     end
 
     # Insert into actions according to config block
@@ -53,166 +84,7 @@ module CmAdmin
       @actions_set = true
     end
 
-    def cm_show(&block)
-      @current_action = CmAdmin::Models::Action.find_by(self, name: 'show')
-      puts "Top of the line"
-      yield
-      # action.instance_eval(&block)
-      puts "End of the line"
-    end
-
-    def cm_index(&block)
-      @current_action = CmAdmin::Models::Action.find_by(self, name: 'index')
-      yield
-      # action.instance_eval(&block)
-    end
-
-    def cm_edit(&block)
-      action = CmAdmin::Models::Action.find_by(self, name: 'edit')
-      action.instance_eval(&block)
-    end
-
-    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, filter_params=filter_params(params))
-    end
-
-    def filter_by(params, filter_params={}, sort_params={})
-      filtered_result = OpenStruct.new
-      sort_column = "users.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}
-      final_data = filtered_data(filter_params)
-      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 filtered_data(filter_params)
-      records = self.name.constantize.where(nil)
-      if filter_params
-        filter_params.each do |scope, scope_value|
-          records = self.send("cm_#{scope}", scope_value, records)
-        end
-      end
-      records
-    end
-
-    def cm_search(scope_value, records)
-      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 new(params)
-      @ar_object = @ar_model.new
-    end
-
-    def edit(params)
-      @ar_object = @ar_model.find(params[:id])
-    end
-
-    def update(params)
-      @ar_object = @ar_model.find(params[:id])
-      @ar_object.update(resource_params(params))
-    end
-
-    def create(params)
-      @ar_object = @ar_model.new(resource_params(params))
-    end
-
-    def resource_params(params)
-      permittable_fields = @permitted_fields || @ar_model.columns.map(&:name).reject { |i| CmAdmin::REJECTABLE_FIELDS.include?(i) }.map(&:to_sym)
-      params.require(self.name.underscore.to_sym).permit(*permittable_fields)
-    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 field(field_name, options={})
-      puts "For printing field #{field_name}"
-      @available_fields[:show] << CmAdmin::Models::Field.new(field_name, options)
-    end
 
-    def column(field_name, options={})
-      unless @available_fields[:index].map{|x| x.db_column_name.to_sym}.include?(field_name)
-        puts "For printing column #{field_name}"
-        @available_fields[:index] << 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
-
-    def self.find_by(search_hash)
-      CmAdmin.cm_admin_models.find { |x| x.name == search_hash[:name] }
-    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
     private
 
     # Controller defined for each model
@@ -227,7 +99,19 @@ module CmAdmin
             @model = CmAdmin::Model.find_by(name: controller_name.classify)
             @model.params = params
             @action = CmAdmin::Models::Action.find_by(@model, name: action_name)
-            @ar_object = @model.send(action_name, params)
+            @ar_object = @model.try(action_name, params)
+            @ar_object, @associated_model, @associated_ar_object = @model.custom_controller_action(action_name, params.permit!) if !@ar_object.present? && params[:id].present?
+            nested_tables = @model.available_fields[:new].except(:fields).keys
+            nested_tables += @model.available_fields[:edit].except(:fields).keys
+            @reflections = @model.ar_model.reflect_on_all_associations
+            nested_tables.each do |table_name|
+              reflection = @reflections.select {|x| x if x.name == table_name}.first
+              if reflection.macro == :has_many
+                @ar_object.send(table_name).build if action_name == "new" || action_name == "edit"
+              else
+                @ar_object.send(('build_' + table_name.to_s).to_sym) if action_name == "new"
+              end
+            end
             respond_to do |format|
               if %w(show index new edit).include?(action_name)
                 if request.xhr? && action_name.eql?('index')
@@ -242,10 +126,10 @@ module CmAdmin
                   format.html { render '/cm_admin/main/new' }
                 end
               elsif action.layout.present?
-                if action.partial.present?
-                  render partial: action.partial, layout: action.layout
+                if request.xhr? && action.partial.present?
+                  format.html { render partial: action.partial }
                 else
-                  render layout: action.layout
+                  format.html { render action.layout }
                 end
               end
             end
@@ -256,7 +140,13 @@ module CmAdmin
     end
 
     def filter_params(params)
-      params.require(:filters).permit(:search) if params[:filters]
+      # OPTIMIZE: Need to check if we can permit the filter_params in a better way
+      date_columns = @filters.select{|x| x.filter_type.eql?(:date)}.map(&:db_column_name)
+      range_columns = @filters.select{|x| x.filter_type.eql?(:range)}.map(&:db_column_name)
+      single_select_columns = @filters.select{|x| x.filter_type.eql?(:single_select)}.map(&:db_column_name)
+      multi_select_columns = @filters.select{|x| x.filter_type.eql?(:multi_select)}.map{|x| Hash["#{x.db_column_name}", []]}
+
+      params.require(:filters).permit(:search, date: date_columns, range: range_columns, single_select: single_select_columns, multi_select: multi_select_columns) if params[:filters]
     end
   end
 end

data/lib/cm_admin/models/action.rb

@@ -4,14 +4,28 @@ module CmAdmin
   module Models
     class Action
       include Actions::Blocks
-      attr_accessor :name, :verb, :layout, :partial, :path, :page_title, :page_description
+      attr_accessor :name, :verb, :layout_type, :layout, :partial, :path, :page_title, :page_description, :child_records, :is_nested_field, :nested_table_name
 
       def initialize(attributes = {})
+        if attributes[:layout_type].present? && attributes[:layout].nil? && attributes[:partial].nil?
+          case attributes[:layout_type]
+          when 'cm_association_index'
+            attributes[:layout] = '/cm_admin/main/associated_index'
+            attributes[:partial] = '/cm_admin/main/associated_table'
+          when 'cm_association_show'
+            attributes[:layout] = '/cm_admin/main/associated_show'
+          end
+        end
+        set_default_values
         attributes.each do |key, value|
           self.send("#{key.to_s}=", value)
         end
       end
 
+      def set_default_values
+        self.is_nested_field = false
+      end
+
       class << self
         def find_by(model, search_hash)
           model.available_actions.find { |i| i.name == search_hash[:name] }

data/lib/cm_admin/models/cm_show_section.rb

@@ -0,0 +1,20 @@
+module CmAdmin
+  module Models
+    class CmShowSection
+
+      attr_accessor :section_name, :available_section_fields
+
+      def initialize(section_name, &block)
+        @available_section_fields = []
+        @section_name = section_name
+        puts "-- reached here --"
+        instance_eval(&block)
+      end
+
+      def field(field_name, options={})
+        puts "For printing field #{field_name}"
+        @available_section_fields << CmAdmin::Models::Field.new(field_name, options)
+      end
+    end
+  end
+end

data/lib/cm_admin/models/column.rb

@@ -1,14 +1,59 @@
 module CmAdmin
   module Models
     class Column
-      attr_accessor :db_column_name, :column_type, :header, :format, :prefix, :exportable
+      attr_accessor :field_name, :field_type, :header, :format, :prefix, :suffix, :exportable, :round,
+      :cm_css_class, :link, :url, :custom_method, :helper_method, :managable, :lockable
 
-      def initialize(db_column_name, attributes = {})
-        @db_column_name = db_column_name
+      def initialize(field_name, attributes = {})
+        @field_name = field_name
+        set_default_values
         attributes.each do |key, value|
           self.send("#{key.to_s}=", value)
         end
-        @exportable = true if attributes[:exportable].nil?
+
+        #formatting header (either field_name or value present in header attribute)
+        self.send("header=", format_header)
+      end
+
+      #returns a string value as a header (either field_name or value present in header attribute)
+      def format_header
+        self.header.present? ? self.header.to_s.gsub(/_/, ' ')&.upcase : self.field_name.to_s.gsub(/_/, ' ').upcase
+      end
+
+      def set_default_values
+        self.exportable = true
+        self.managable = true
+        self.lockable = false
+      end
+
+      #formatting value for different data types
+      def self.format_data_type(column, value)
+        case column.column_type
+        when :string
+          if column.format.present?
+            column.format = [column.format] if column.format.is_a? String
+            column.format.each do |formatter|
+              value = value.send(formatter)
+            end
+          end
+        when :datetime
+          format_value = column.format.present? ? column.format.to_s : '%d/%m/%Y'
+          value = value.strftime(format_value)
+        when :enum
+          value = value.titleize
+        when :decimal
+          round_to = column.round.present? ? column.round.to_i : 2
+          value = value.round(round_to)
+        when :custom
+
+        end
+        return value
+      end
+
+      class << self
+        def find_by(model, search_hash)
+          model.available_fields.find { |i| i.name == search_hash[:name] }
+        end
       end
 
     end