cm-admin 0.2.0 → 0.3.0

data/lib/cm_admin/constants.rb

@@ -0,0 +1,33 @@
+module CmAdmin
+  DEFAULT_ACTIONS = {
+    index: {
+      verb: :get,
+      path: '/'
+    },
+    new: {
+      verb: :get,
+      path: 'new'
+    },
+    show: {
+      verb: :get,
+      path: ':id'
+    },
+    create: {
+      verb: :post,
+      path: '/'
+    },
+    edit: {
+      verb: :get,
+      path: ':id/edit'
+    },
+    update: {
+      verb: :patch,
+      path: ':id'
+    },
+    destroy: {
+      verb: :delete,
+      path: ':id'
+    }
+  }
+  REJECTABLE_FIELDS = %w(id created_at updated_at)
+end

data/lib/cm_admin/engine.rb

@@ -0,0 +1,38 @@
+require 'rails'
+module CmAdmin
+  class Engine < Rails::Engine
+    isolate_namespace CmAdmin
+
+    config.app_middleware.use(
+      Rack::Static,
+      # note! this varies from the webpacker/engine documentation
+      urls: ["/cm-admin-packs"], root: CmAdmin::Engine.root.join("public")
+    )
+
+    initializer 'RailsAdmin precompile hook', group: :all do |app|
+      app.config.assets.precompile += %w(
+        cm_admin/cm_admin.css
+      )
+    end
+
+    initializer "webpacker.proxy" do |app|
+      insert_middleware = begin
+        CmAdmin.webpacker.config.dev_server.present?
+      rescue
+        nil
+      end
+      next unless insert_middleware
+
+      app.middleware.insert_before(
+        0, Webpacker::DevServerProxy, # "Webpacker::DevServerProxy" if Rails version < 5
+        ssl_verify_none: true,
+        webpacker: CmAdmin.webpacker
+      )
+    end
+
+    def mount_path
+      CmAdmin::Engine.routes.find_script_name({})
+    end
+
+  end
+end

data/lib/cm_admin/model.rb

@@ -0,0 +1,262 @@
+require_relative 'constants'
+require_relative 'models/action'
+require_relative 'models/field'
+require_relative 'models/blocks'
+require_relative 'models/column'
+require_relative 'models/filter'
+require_relative 'models/export'
+require 'pagy'
+require 'axlsx'
+
+
+module CmAdmin
+  class Model
+    include Pagy::Backend
+    include Models::Blocks
+    attr_accessor :available_actions, :actions_set, :available_fields, :permitted_fields, :current_action, :params, :filters
+    attr_reader :name, :ar_model
+
+    # Class variable for storing all actions
+    # CmAdmin::Model.all_actions
+    singleton_class.send(:attr_accessor, :all_actions)
+
+    def initialize(entity, &block)
+      @name = entity.name
+      @ar_model = entity
+      @available_actions ||= []
+      @current_action = nil
+      @available_fields ||= {index: [], show: [], edit: [], new: []}
+      @params = nil
+      @filters ||= []
+      instance_eval(&block) if block_given?
+      actions unless @actions_set
+      $available_actions = @available_actions.dup
+      self.class.all_actions.push(@available_actions)
+      define_controller
+    end
+
+    class << self
+      def all_actions
+        @all_actions || []
+      end
+    end
+
+    # Insert into actions according to config block
+    def actions(only: [], except: [])
+      acts = CmAdmin::DEFAULT_ACTIONS.keys
+      acts = acts & (Array.new << only).flatten if only.present?
+      acts = acts - (Array.new << except).flatten if except.present?
+      acts.each do |act|
+        action_defaults = CmAdmin::DEFAULT_ACTIONS[act]
+        @available_actions << CmAdmin::Models::Action.new(name: act.to_s, verb: action_defaults[:verb], path: action_defaults[:path])
+      end
+      @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
+    # If model is User, controller will be UsersController
+    def define_controller
+      klass = Class.new(CmAdmin::ApplicationController) do
+
+        $available_actions.each do |action|
+          define_method action.name.to_sym do
+
+            # controller_name & action_name from ActionController
+            @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)
+            respond_to do |format|
+              if %w(show index new edit).include?(action_name)
+                if request.xhr? && action_name.eql?('index')
+                  format.html { render partial: '/cm_admin/main/table' }
+                else
+                  format.html { render '/cm_admin/main/'+action_name }
+                end
+              elsif %w(create update destroy).include?(action_name)
+                if @ar_object.save
+                  format.html { redirect_to  CmAdmin::Engine.mount_path + "/#{@model.name.underscore.pluralize}" }
+                else
+                  format.html { render '/cm_admin/main/new' }
+                end
+              elsif action.layout.present?
+                if action.partial.present?
+                  render partial: action.partial, layout: action.layout
+                else
+                  render layout: action.layout
+                end
+              end
+            end
+          end
+        end
+      end if $available_actions.present?
+      CmAdmin.const_set "#{@name}Controller", klass
+    end
+
+    def filter_params(params)
+      params.require(:filters).permit(:search) if params[:filters]
+    end
+  end
+end

data/lib/cm_admin/models/action.rb

@@ -0,0 +1,22 @@
+require_relative 'actions/blocks'
+
+module CmAdmin
+  module Models
+    class Action
+      include Actions::Blocks
+      attr_accessor :name, :verb, :layout, :partial, :path, :page_title, :page_description
+
+      def initialize(attributes = {})
+        attributes.each do |key, value|
+          self.send("#{key.to_s}=", value)
+        end
+      end
+
+      class << self
+        def find_by(model, search_hash)
+          model.available_actions.find { |i| i.name == search_hash[:name] }
+        end
+      end
+    end
+  end
+end

data/lib/cm_admin/models/actions/blocks.rb

@@ -0,0 +1,25 @@
+module CmAdmin
+  module Models
+    module Actions
+      module Blocks
+        extend ActiveSupport::Concern
+
+        included do
+          attr_accessor :title
+        end
+
+        def set_layout(name)
+          self.layout = name
+        end
+
+        def set_partial(name)
+          self.partial = name
+        end
+
+        def set_title(name)
+          self.title = name
+        end
+      end
+    end
+  end
+end

data/lib/cm_admin/models/blocks.rb

@@ -0,0 +1,19 @@
+module CmAdmin
+  module Models
+    module Blocks
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :menu, :title
+      end
+
+      def set_menu(state)
+        self.menu = state.to_s == 'on' ? true : false
+      end
+
+      def set_title(name)
+        self.title = name
+      end
+    end
+  end
+end

data/lib/cm_admin/models/column.rb

@@ -0,0 +1,16 @@
+module CmAdmin
+  module Models
+    class Column
+      attr_accessor :db_column_name, :column_type, :header, :format, :prefix, :exportable
+
+      def initialize(db_column_name, attributes = {})
+        @db_column_name = db_column_name
+        attributes.each do |key, value|
+          self.send("#{key.to_s}=", value)
+        end
+        @exportable = true if attributes[:exportable].nil?
+      end
+
+    end
+  end
+end

data/lib/cm_admin/models/export.rb

@@ -0,0 +1,43 @@
+module CmAdmin
+  module Models
+    class Export
+      class << self
+        def generate_excel(klass_name, columns = [])
+          klass = klass_name.constantize
+          records = get_records(klass, columns)
+          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)
+          records = klass
+          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)
+        end
+
+        def create_workbook(records, class_name, file_path)
+          flattened_records = records.map { |record| CmAdmin::Utils.flatten_hash(record) }
+          columns = flattened_records.map{|x| x.keys}.flatten.uniq.sort
+          size_arr = []
+          columns.size.times { size_arr << 22 }
+          xl = Axlsx::Package.new
+          xl.workbook.add_worksheet do |sheet|
+            sheet.add_row columns&.map(&:titleize), b: true
+            flattened_records.each do |record|
+              sheet.add_row(columns.map { |column| record[column] })
+            end
+          sheet.column_widths(*size_arr)
+          end
+          xl.serialize(file_path)
+        end
+
+        def exportable_columns(klass)
+          klass.available_fields[:index].map{|x| x.exportable ? x.db_column_name : ""}.reject { |c| c.empty? }
+        end
+
+      end
+    end
+  end
+end