motor-admin 0.1.12 → 0.1.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7905a9e6d289a069f10e5980bd861b2aec8da549e397bcd3b666c8fa8c75479
-  data.tar.gz: 233b3747ee84e99c6c27ce72c9783c549d70a1ed12b568896bf8bef26d702ff5
+  metadata.gz: 3f394e032aa3ede14570c098e604143b439bd73c52b1c6fa2cfa800d413efcce
+  data.tar.gz: edd3909478589fc8cba218c1286fe00e18732b085435a7e02bfdf824c1f363ff
 SHA512:
-  metadata.gz: f62a5bfc817a1e339774277027a18e0c28f147fbd2c7078bfd013ec72a60b5aafebc28e065e064d0bf60cc63e18f48e7d7424ce3ba0c484d9489a107528cc7bf
-  data.tar.gz: '01830208623fa1a67ea1c2e681a89b574c7c0ec62ff30ec2e3973918779e5c52913a81494ce0c9998dfd6d4a1cb3825cecab5c3ea1915d46b6a4eb922365ab9a'
+  metadata.gz: aed05763bda0b00ceb45839f224720ed0c199d09590d439843557967c26eb4b3fed2a38cea39f81d2d8b39c8f90cca8a7df04e07475002b6dc7130dcc7513292
+  data.tar.gz: b744249ec9ef523f8c8563d3d98f782e4667ac90e00dc2b82ef9d59fe873838125f5298a7dcbc15c9901c57d9e74611199631e906a33dddaea490229ce058ff1

data/app/controllers/motor/active_storage_attachments_controller.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Motor
+  class ActiveStorageAttachmentsController < ApiBaseController
+    wrap_parameters :data, except: %i[include fields]
+
+    load_and_authorize_resource :attachment, class: 'ActiveStorage::Attachment', parent: false
+
+    def create
+      if @attachment.record.respond_to?("#{@attachment.name}_attachment=") || @attachment.record.respond_to?("#{@attachment.name}_attachments=")
+        @attachment.record.public_send(@attachment.name).attach(
+          io: StringIO.new(params.dig(:data, :file, :io).to_s.encode('ISO-8859-1')),
+          filename: params.dig(:data, :file, :filename)
+        )
+
+        head :ok
+      else
+        head :unprocessable_entity
+      end
+    end
+
+    private
+
+    def attachment_params
+      params.require(:data).except(:file).permit!
+    end
+  end
+end

data/app/controllers/motor/alerts_controller.rb

@@ -2,6 +2,8 @@
 
 module Motor
   class AlertsController < ApiBaseController
+    wrap_parameters :data, except: %i[include fields]
+
     load_and_authorize_resource :alert, only: %i[index show update destroy]
 
     before_action :build_alert, only: :create

data/app/controllers/motor/configs_controller.rb

@@ -2,6 +2,8 @@
 
 module Motor
   class ConfigsController < ApiBaseController
+    wrap_parameters :data, except: %i[include fields]
+
     load_and_authorize_resource
 
     def index

data/app/controllers/motor/dashboards_controller.rb

@@ -2,6 +2,8 @@
 
 module Motor
   class DashboardsController < ApiBaseController
+    wrap_parameters :data, except: %i[include fields]
+
     load_and_authorize_resource :dashboard, only: %i[index show update destroy]
 
     before_action :build_dashboard, only: :create

data/app/controllers/motor/data_controller.rb

@@ -4,8 +4,11 @@ module Motor
   class DataController < ApiBaseController
     INSTANCE_VARIABLE_NAME = 'resource'
 
+    wrap_parameters :data, except: %i[include fields]
+
     before_action :load_and_authorize_resource
     before_action :load_and_authorize_association
+    before_action :wrap_io_params
 
     def index
       @resources = Motor::ApiQuery.call(@resources, params)
@@ -96,7 +99,23 @@ module Motor
     end
 
     def resource_params
-      params.fetch(:data, {}).except(resource_class.primary_key).permit!
+      if params[:data].present?
+        params.require(:data).except(resource_class.primary_key).permit!
+      else
+        {}
+      end
+    end
+
+    def wrap_io_params(hash = params)
+      hash.each do |key, value|
+        if key == 'io'
+          hash[key] = StringIO.new(value.encode('ISO-8859-1'))
+        elsif value.is_a?(ActionController::Parameters)
+          wrap_io_params(value)
+        end
+      end
+
+      hash
     end
   end
 end

data/app/controllers/motor/forms_controller.rb

@@ -2,6 +2,8 @@
 
 module Motor
   class FormsController < ApiBaseController
+    wrap_parameters :data, except: %i[include fields]
+
     load_and_authorize_resource :form, only: %i[index show update destroy]
 
     before_action :build_form, only: :create

data/app/controllers/motor/queries_controller.rb

@@ -2,6 +2,8 @@
 
 module Motor
   class QueriesController < ApiBaseController
+    wrap_parameters :data, except: %i[include fields]
+
     load_and_authorize_resource :query, only: %i[index show update destroy]
 
     before_action :build_query, only: :create

data/app/controllers/motor/resources_controller.rb

@@ -2,6 +2,8 @@
 
 module Motor
   class ResourcesController < ApiBaseController
+    wrap_parameters :data, except: %i[include fields]
+
     load_and_authorize_resource
 
     def index

data/app/controllers/motor/run_queries_controller.rb

@@ -2,6 +2,8 @@
 
 module Motor
   class RunQueriesController < ApiBaseController
+    wrap_parameters :data
+
     load_and_authorize_resource :query, only: :show, parent: false
 
     before_action :build_query, only: :create

data/app/controllers/motor/send_alerts_controller.rb

@@ -2,6 +2,8 @@
 
 module Motor
   class SendAlertsController < ApiBaseController
+    wrap_parameters :data
+
     before_action :build_alert, only: :create
     authorize_resource :alert, only: :create
 

data/config/routes.rb

@@ -13,6 +13,7 @@ Motor::Admin.routes.draw do
       resources :dashboards, only: %i[index show create update destroy]
       resources :forms, only: %i[index show create update destroy]
       resources :alerts, only: %i[index show create update destroy]
+      resources :active_storage_attachments, only: %i[create], path: 'data/active_storage__attachments'
       resource :schema, only: %i[show update]
       resources :resources, path: '/data/:resource',
                             only: %i[index show update create destroy],

data/lib/motor.rb

@@ -6,6 +6,7 @@ require 'js_regex'
 require 'fugit'
 require 'csv'
 require 'active_record/filter'
+require 'base64'
 
 module Motor
   PATH = Pathname.new(__dir__)

data/lib/motor/active_record_utils.rb

@@ -2,6 +2,8 @@
 
 require_relative './active_record_utils/types'
 require_relative './active_record_utils/fetch_methods'
+require_relative './active_record_utils/defined_scopes_extension'
+require_relative './active_record_utils/active_storage_links_extension'
 
 module ActiveRecordUtils
 end

data/lib/motor/active_record_utils/active_storage_links_extension.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Motor
+  module ActiveRecordUtils
+    module ActiveStorageLinksExtension
+      def path
+        Rails.application.routes.url_helpers.rails_blob_path(self)
+      end
+
+      def url
+        Rails.application.routes.url_helpers.url_for(self)
+      end
+    end
+  end
+end

data/lib/motor/active_record_utils/defined_scopes_extension.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Motor
+  module ActiveRecordUtils
+    module DefinedScopesExtension
+      def scope(name, _body)
+        (@__scopes__ ||= []) << name
+
+        super
+      end
+
+      def defined_scopes
+        @__scopes__ || []
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.extend(Motor::ActiveRecordUtils::DefinedScopesExtension)

data/lib/motor/admin.rb

@@ -2,11 +2,22 @@
 
 module Motor
   class Admin < ::Rails::Engine
+    initializer 'motor.filter_params' do
+      Rails.application.config.filter_parameters += %i[io]
+    end
+
     initializer 'motor.alerts.scheduler' do
-      next if defined?(Sidekiq) && Sidekiq.server?
+      config.after_initialize do |_app|
+        next unless defined?(Rails::Server)
+
+        Motor::Alerts::Scheduler::SCHEDULER_TASK.execute
+      end
+    end
 
-      Motor::Alerts::Scheduler::SCHEDULER_TASK.execute
-      Motor::Alerts::ScheduledAlertsCache::UPDATE_ALERTS_TASK.execute
+    initializer 'motor.active_storage.extensions' do
+      ActiveSupport.on_load(:active_storage_attachment) do
+        ActiveStorage::Attachment.include(Motor::ActiveRecordUtils::ActiveStorageLinksExtension)
+      end
     end
   end
 end

data/lib/motor/alerts/scheduled_alerts_cache.rb

@@ -3,10 +3,6 @@
 module Motor
   module Alerts
     module ScheduledAlertsCache
-      UPDATE_ALERTS_TASK = Concurrent::TimerTask.new(
-        execution_interval: 2.minutes
-      ) { Motor::Alerts::ScheduledAlertsCache.load_alerts }
-
       CACHE_STORE = ActiveSupport::Cache::MemoryStore.new(size: 5.megabytes)
 
       module_function

data/lib/motor/api_query.rb

@@ -4,6 +4,7 @@ require_relative './api_query/sort'
 require_relative './api_query/paginate'
 require_relative './api_query/filter'
 require_relative './api_query/search'
+require_relative './api_query/apply_scope'
 require_relative './api_query/build_meta'
 require_relative './api_query/build_json'
 
@@ -15,6 +16,7 @@ module Motor
       rel = ApiQuery::Sort.call(rel, params[:sort])
       rel = ApiQuery::Paginate.call(rel, params[:page])
       rel = ApiQuery::Filter.call(rel, params[:filter])
+      rel = ApiQuery::ApplyScope.call(rel, params[:scope])
 
       ApiQuery::Search.call(rel, params[:q] || params[:search] || params[:query])
     end

data/lib/motor/api_query/apply_scope.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Motor
+  module ApiQuery
+    module ApplyScope
+      module_function
+
+      def call(rel, scope)
+        return rel if scope.blank?
+
+        scope_symbol = scope.to_sym
+
+        if rel.klass.defined_scopes.include?(scope_symbol)
+          rel.public_send(scope_symbol)
+        else
+          configs = Motor::Resource.find_by_name(rel.klass.name.underscore)
+          scope_configs = configs.preferences[:scopes].find { |s| s[:name] == scope }
+
+          return rel unless scope_configs
+
+          ApiQuery::Filter.call(rel, scope_configs[:preferences][:filter])
+        end
+      end
+    end
+  end
+end

data/lib/motor/api_query/build_json.rb

@@ -49,26 +49,27 @@ module Motor
 
         params[:fields].each do |key, fields|
           fields = fields.split(',') if fields.is_a?(String)
-          fields_hash = build_fields_hash(model, fields)
 
           if key == model_name || model_name.split('/').last == key
-            json_params.merge!(fields_hash)
+            json_params.merge!(build_fields_hash(model, fields))
           else
             hash = find_key_in_params(json_params, key)
 
+            fields_hash = build_fields_hash(model.reflections[key]&.klass, fields)
+
             hash.merge!(fields_hash)
           end
         end
       end
 
       def build_fields_hash(model, fields)
-        columns = model.columns.map(&:name)
+        columns = model ? model.columns.map(&:name) : []
         fields_hash = { 'only' => [], 'methods' => [] }
 
         fields.each_with_object(fields_hash) do |field, acc|
           if field.in?(columns)
             acc['only'] << field
-          else
+          elsif model.nil? || model.instance_methods.include?(field.to_sym)
             acc['methods'] << field
           end
         end

data/lib/motor/api_query/sort.rb

@@ -7,19 +7,39 @@ module Motor
 
       module_function
 
-      def call(rel, params)
-        return rel if params.blank?
+      def call(rel, param)
+        return rel if param.blank?
 
-        normalized_params = build_params(params)
+        arel_order = build_arel_order(rel.klass, param)
+        join_params = build_join_params(rel.klass, param)
 
-        rel.order(normalized_params)
+        rel.order(arel_order).left_joins(join_params)
       end
 
-      def build_params(param)
-        param.split(',').each_with_object({}) do |field, hash|
-          direction, name = field.match(FIELD_PARSE_REGEXP).captures
+      def build_join_params(_model, param)
+        param.split(',').each_with_object({}) do |field, result|
+          key = field[FIELD_PARSE_REGEXP, 2]
+          *path, _ = key.split('.')
 
-          hash[name] = direction.present? ? :desc : :asc
+          path.reduce(result) do |acc, fragment|
+            acc[fragment] = {}
+          end
+        end
+      end
+
+      def build_arel_order(model, param)
+        param.split(',').map do |field|
+          direction, key = field.match(FIELD_PARSE_REGEXP).captures
+          *path, field = key.split('.')
+
+          reflection_model =
+            path.reduce(model) do |acc, fragment|
+              acc.reflections[fragment].klass
+            end
+
+          arel_column = reflection_model.arel_table[field]
+
+          direction.present? ? arel_column.desc : arel_column.asc
         end
       end
     end

data/lib/motor/build_schema.rb

@@ -1,16 +1,61 @@
 # frozen_string_literal: true
 
-require_relative './build_schema/load_from_rails'
-require_relative './build_schema/find_display_column'
-require_relative './build_schema/persist_resource_configs'
-require_relative './build_schema/reorder_schema'
-require_relative './build_schema/merge_schema_configs'
-require_relative './build_schema/utils'
-
 module Motor
   module BuildSchema
+    module ColumnAccessTypes
+      ALL = [
+        READ_ONLY = 'read_only',
+        WRITE_ONLY = 'write_only',
+        READ_WRITE = 'read_write',
+        HIDDEN = 'hidden'
+      ].freeze
+    end
+
     SEARCHABLE_COLUMN_TYPES = %i[citext text string bitstring].freeze
 
+    COLUMN_NAME_ACCESS_TYPES = {
+      id: ColumnAccessTypes::READ_ONLY,
+      created_at: ColumnAccessTypes::READ_ONLY,
+      updated_at: ColumnAccessTypes::READ_ONLY,
+      deleted_at: ColumnAccessTypes::READ_ONLY
+    }.with_indifferent_access.freeze
+
+    DEFAULT_SCOPE_TYPE = 'default'
+
+    DEFAULT_ACTIONS = [
+      {
+        name: 'create',
+        display_name: 'Create',
+        action_type: 'default',
+        preferences: {},
+        visible: true
+      },
+      {
+        name: 'edit',
+        display_name: 'Edit',
+        action_type: 'default',
+        preferences: {},
+        visible: true
+      },
+      {
+        name: 'remove',
+        display_name: 'Remove',
+        action_type: 'default',
+        preferences: {},
+        visible: true
+      }
+    ].freeze
+
+    DEFAULT_TABS = [
+      {
+        name: 'summary',
+        display_name: 'Summary',
+        tab_type: 'default',
+        preferences: {},
+        visible: true
+      }
+    ].freeze
+
     module_function
 
     def call
@@ -21,3 +66,11 @@ module Motor
     end
   end
 end
+
+require_relative './build_schema/active_storage_attachment_schema'
+require_relative './build_schema/load_from_rails'
+require_relative './build_schema/find_display_column'
+require_relative './build_schema/persist_resource_configs'
+require_relative './build_schema/reorder_schema'
+require_relative './build_schema/merge_schema_configs'
+require_relative './build_schema/utils'

data/lib/motor/build_schema/active_storage_attachment_schema.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Motor
+  module BuildSchema
+    ACTIVE_STORAGE_ATTACHMENT_SCHEMA = {
+      name: 'active_storage/attachment',
+      slug: 'active_storage__attachments',
+      table_name: 'active_storage_attachments',
+      primary_key: 'id',
+      display_name: 'Attachments',
+      display_column: 'filename',
+      columns: [
+        {
+          name: 'id',
+          display_name: 'Id',
+          column_type: 'integer',
+          access_type: 'read_only',
+          default_value: nil,
+          validators: [],
+          virtual: false
+        },
+        {
+          name: 'path',
+          display_name: 'Path',
+          column_type: 'string',
+          access_type: 'read_only',
+          default_value: nil,
+          validators: [],
+          virtual: true
+        },
+        {
+          name: 'name',
+          display_name: 'Name',
+          column_type: 'string',
+          access_type: 'read_write',
+          default_value: nil,
+          validators: [],
+          virtual: false
+        },
+        {
+          name: 'record_type',
+          display_name: 'Record type',
+          column_type: 'string',
+          access_type: 'read_write',
+          default_value: nil,
+          validators: [],
+          virtual: false
+        },
+        {
+          name: 'record_id',
+          display_name: 'Record',
+          column_type: 'integer',
+          access_type: 'read_write',
+          default_value: nil,
+          validators: [],
+          virtual: false
+        },
+        {
+          name: 'file',
+          display_name: 'File',
+          column_type: 'file',
+          access_type: 'write_only',
+          default_value: nil,
+          validators: [],
+          virtual: false
+        },
+        {
+          name: 'created_at',
+          display_name: 'Created at',
+          column_type: 'datetime',
+          access_type: 'read_only',
+          default_value: nil,
+          validators: [],
+          virtual: false
+        }
+      ],
+      associations: [],
+      scopes: [],
+      actions: Motor::BuildSchema::DEFAULT_ACTIONS.reject { |e| e[:name] == 'edit' },
+      tabs: Motor::BuildSchema::DEFAULT_TABS,
+      visible: true
+    }.with_indifferent_access
+  end
+end

data/lib/motor/build_schema/load_from_rails.rb

@@ -3,56 +3,6 @@
 module Motor
   module BuildSchema
     module LoadFromRails
-      module ColumnAccessTypes
-        ALL = [
-          READ_ONLY = 'read_only',
-          WRITE_ONLY = 'write_only',
-          READ_WRITE = 'read_write',
-          HIDDEN = 'hidden'
-        ].freeze
-      end
-
-      COLUMN_NAME_ACCESS_TYPES = {
-        id: ColumnAccessTypes::READ_ONLY,
-        created_at: ColumnAccessTypes::READ_ONLY,
-        updated_at: ColumnAccessTypes::READ_ONLY,
-        deleted_at: ColumnAccessTypes::READ_ONLY
-      }.with_indifferent_access.freeze
-
-      DEFAULT_ACTIONS = [
-        {
-          name: 'create',
-          display_name: 'Create',
-          action_type: 'default',
-          preferences: {},
-          visible: true
-        },
-        {
-          name: 'edit',
-          display_name: 'Edit',
-          action_type: 'default',
-          preferences: {},
-          visible: true
-        },
-        {
-          name: 'remove',
-          display_name: 'Remove',
-          action_type: 'default',
-          preferences: {},
-          visible: true
-        }
-      ].freeze
-
-      DEFAULT_TABS = [
-        {
-          name: 'summary',
-          display_name: 'Summary',
-          tab_type: 'default',
-          preferences: {},
-          visible: true
-        }
-      ].freeze
-
       module_function
 
       def call
@@ -86,40 +36,107 @@ module Motor
       end
 
       def build_model_schema(model)
+        model_name = model.name
+
+        return Motor::BuildSchema::ACTIVE_STORAGE_ATTACHMENT_SCHEMA if model_name == 'ActiveStorage::Attachment'
+
         {
-          name: model.name.underscore,
+          name: model_name.underscore,
           slug: Utils.slugify(model),
           table_name: model.table_name,
+          class_name: model.name,
           primary_key: model.primary_key,
-          display_name: model.name.titleize.pluralize,
+          display_name: model_name.titleize.pluralize,
           display_column: FindDisplayColumn.call(model),
           columns: fetch_columns(model),
           associations: fetch_associations(model),
+          scopes: fetch_scopes(model),
           actions: DEFAULT_ACTIONS,
           tabs: DEFAULT_TABS,
           visible: true
         }.with_indifferent_access
       end
 
+      def fetch_scopes(model)
+        model.defined_scopes.map do |scope_name|
+          scope_name = scope_name.to_s
+
+          next if scope_name.starts_with?('with_attached')
+
+          {
+            name: scope_name,
+            display_name: scope_name.humanize,
+            scope_type: DEFAULT_SCOPE_TYPE,
+            visible: true,
+            preferences: {}
+          }
+        end.compact
+      end
+
       def fetch_columns(model)
         default_attrs = model.new.attributes
 
-        model.columns.map do |column|
+        reference_columns = fetch_reference_columns(model)
+
+        table_columns =
+          model.columns.map do |column|
+            next if reference_columns.find { |c| c[:name] == column.name }
+
+            {
+              name: column.name,
+              display_name: column.name.humanize,
+              column_type: ActiveRecordUtils::Types::UNIFIED_TYPES[column.type.to_s] || column.type.to_s,
+              access_type: COLUMN_NAME_ACCESS_TYPES.fetch(column.name, ColumnAccessTypes::READ_WRITE),
+              default_value: default_attrs[column.name],
+              validators: fetch_validators(model, column.name),
+              reference: nil,
+              virtual: false
+            }
+          end.compact
+
+        reference_columns + table_columns
+      end
+
+      def fetch_reference_columns(model)
+        default_attrs = model.new.attributes
+
+        model.reflections.map do |name, ref|
+          next if !ref.has_one? && !ref.belongs_to?
+
+          begin
+            ref.klass
+          rescue StandardError
+            next
+          end
+
+          column_name = ref.belongs_to? ? ref.foreign_key.to_s : name
+
+          next if ref.klass.name == 'ActiveStorage::Blob'
+
+          is_attachment = ref.klass.name == 'ActiveStorage::Attachment'
+
           {
-            name: column.name,
-            display_name: column.name.humanize,
-            column_type: ActiveRecordUtils::Types::UNIFIED_TYPES[column.type.to_s] || column.type.to_s,
-            access_type: COLUMN_NAME_ACCESS_TYPES.fetch(column.name, ColumnAccessTypes::READ_WRITE),
-            default_value: default_attrs[column.name],
-            validators: fetch_validators(model, column.name),
+            name: column_name,
+            display_name: column_name.humanize,
+            column_type: is_attachment ? 'file' : 'integer',
+            access_type: ref.belongs_to? || is_attachment ? ColumnAccessTypes::READ_WRITE : ColumnAccessTypes::READ_ONLY,
+            default_value: default_attrs[column_name],
+            validators: fetch_validators(model, column_name),
+            reference: {
+              name: name,
+              model_name: ref.klass.name.underscore,
+              reference_type: ref.belongs_to? ? 'belongs_to' : 'has_one',
+              foreign_key: ref.foreign_key,
+              polymorphic: ref.polymorphic? || is_attachment
+            },
             virtual: false
           }
-        end
+        end.compact
       end
 
       def fetch_associations(model)
         model.reflections.map do |name, ref|
-          next if ref.polymorphic? && !ref.belongs_to?
+          next if ref.has_one? || ref.belongs_to?
 
           begin
             ref.klass
@@ -127,37 +144,22 @@ module Motor
             next
           end
 
-          next if defined?(ActiveStorage::Blob) && ref.klass == ActiveStorage::Blob
+          model_class = ref.klass
+
+          next if model_class.name == 'ActiveStorage::Blob'
 
           {
             name: name,
             display_name: name.humanize,
             slug: name.underscore,
-            model_name: ref.klass.name.underscore,
-            model_slug: Utils.slugify(ref.klass),
-            association_type: fetch_association_type(ref),
+            model_name: model_class.name.underscore,
             foreign_key: ref.foreign_key,
-            polymorphic: ref.polymorphic?,
+            polymorphic: ref.polymorphic? || model_class.name == 'ActiveStorage::Attachment',
             visible: true
           }
         end.compact
       end
 
-      def fetch_association_type(association)
-        case association.association_class.to_s
-        when 'ActiveRecord::Associations::HasManyAssociation',
-             'ActiveRecord::Associations::HasManyThroughAssociation'
-          'has_many'
-        when 'ActiveRecord::Associations::HasOneAssociation',
-             'ActiveRecord::Associations::HasOneThroughAssociation'
-          'has_one'
-        when 'ActiveRecord::Associations::BelongsToAssociation'
-          'belongs_to'
-        else
-          raise ArgumentError, 'Unknown association type'
-        end
-      end
-
       def fetch_validators(model, column_name)
         model.validators_on(column_name).map do |validator|
           case validator

data/lib/motor/build_schema/merge_schema_configs.rb

@@ -7,6 +7,7 @@ module Motor
       COLUMN_DEFAULTS = PersistResourceConfigs::COLUMN_DEFAULTS
       ACTION_DEFAULTS = PersistResourceConfigs::ACTION_DEFAULTS
       TAB_DEFAULTS = PersistResourceConfigs::TAB_DEFAULTS
+      SCOPE_DEFAULTS = PersistResourceConfigs::SCOPE_DEFAULTS
 
       module_function
 
@@ -26,17 +27,17 @@ module Motor
       def merge_model(model, configs)
         updated_model = model.merge(configs.slice(*RESOURCE_ATTRS))
 
+        updated_model[:associations] = merge_by_name(
+          model[:associations],
+          configs[:associations]
+        )
+
         updated_model[:columns] = merge_by_name(
           model[:columns],
           configs[:columns],
           COLUMN_DEFAULTS
         )
 
-        updated_model[:associations] = merge_by_name(
-          model[:associations],
-          configs[:associations]
-        )
-
         updated_model[:actions] = merge_by_name(
           model[:actions],
           configs[:actions],
@@ -46,7 +47,13 @@ module Motor
         updated_model[:tabs] = merge_by_name(
           model[:tabs],
           configs[:tabs],
-          ACTION_DEFAULTS
+          TAB_DEFAULTS
+        )
+
+        updated_model[:scopes] = merge_by_name(
+          model[:scopes],
+          configs[:scopes],
+          SCOPE_DEFAULTS
         )
 
         updated_model

data/lib/motor/build_schema/persist_resource_configs.rb

@@ -6,12 +6,14 @@ module Motor
       RESOURCE_ATTRS = %w[display_name visible].freeze
       COLUMN_ATTRS = %w[name display_name column_type access_type default_value virtual].freeze
       ASSOCIATION_ATTRS = %w[name display_name visible].freeze
+      SCOPE_ATTRS = %w[name display_name scope_type preferences visible].freeze
       ACTION_ATTRS = %w[name display_name action_type preferences visible].freeze
       TAB_ATTRS = %w[name display_name tab_type preferences visible].freeze
 
       COLUMN_DEFAULTS = {
         access_type: 'read_write',
         default_value: nil,
+        reference: nil,
         validators: []
       }.with_indifferent_access
 
@@ -25,6 +27,12 @@ module Motor
         preferences: {}
       }.with_indifferent_access
 
+      SCOPE_DEFAULTS = {
+        visible: true,
+        scope_type: 'default',
+        preferences: {}
+      }.with_indifferent_access
+
       module_function
 
       # @param resource [Motor::Resource]
@@ -99,6 +107,14 @@ module Motor
           )
         end
 
+        if new_prefs[:scopes].present?
+          normalized_preferences[:scopes] = normalize_scopes(
+            default_prefs[:scopes],
+            existing_prefs.fetch(:scopes, []),
+            new_prefs.fetch(:scopes, [])
+          )
+        end
+
         normalized_preferences.compact
       end
 
@@ -138,7 +154,7 @@ module Motor
           action_attrs = new_action.slice(*ACTION_ATTRS)
 
           normalized_action = existing_action.merge(action_attrs)
-          normalized_action = reject_default(default_action.presence || TAB_DEFAULTS, normalized_action)
+          normalized_action = reject_default(default_action.presence || ACTION_DEFAULTS, normalized_action)
 
           normalized_action.merge(name: name) if normalized_action.present?
         end.compact.presence
@@ -165,6 +181,27 @@ module Motor
         end.compact.presence
       end
 
+      # @param default_scopes [Array<HashWithIndifferentAccess>]
+      # @param existing_scopes [Array<HashWithIndifferentAccess>]
+      # @param new_scopes [Array<HashWithIndifferentAccess>]
+      # @return [Array<HashWithIndifferentAccess>]
+      def normalize_scopes(default_scopes, existing_scopes, new_scopes)
+        (existing_scopes.pluck(:name) + new_scopes.pluck(:name)).uniq.map do |name|
+          new_scope = safe_fetch_by_name(new_scopes, name)
+
+          next if new_scope[:_remove]
+
+          existing_scope = safe_fetch_by_name(existing_scopes, name)
+          default_scope = safe_fetch_by_name(default_scopes, name)
+          scope_attrs = new_scope.slice(*SCOPE_ATTRS)
+
+          normalized_scope = existing_scope.merge(scope_attrs)
+          normalized_scope = reject_default(default_scope.presence || SCOPE_DEFAULTS, normalized_scope)
+
+          normalized_scope.merge(name: name) if normalized_scope.present?
+        end.compact.presence
+      end
+
       # @param default_assocs [Array<HashWithIndifferentAccess>]
       # @param existing_assocs [Array<HashWithIndifferentAccess>]
       # @param new_assocs [Array<HashWithIndifferentAccess>]

data/lib/motor/build_schema/reorder_schema.rb

@@ -2,6 +2,18 @@
 
 module Motor
   module ReorderSchema
+    COLUMNS_DEFAULT_ORDER_WEIGHTS = {
+      id: 0,
+      updated_at: 2,
+      edited_at: 2,
+      created_at: 3,
+      inserted_at: 3,
+      deleted_at: 4,
+      archived_at: 4
+    }.with_indifferent_access
+
+    COLUMNS_DEFAULT_ORDER_WEIGHT = 1
+
     module_function
 
     # @param schema [Array<HashWithIndifferentAccess>]
@@ -16,12 +28,14 @@ module Motor
         associations_order = configs["resources.#{model[:name]}.associations.order"]
         actions_order = configs["resources.#{model[:name]}.actions.order"]
         tabs_order = configs["resources.#{model[:name]}.tabs.order"]
+        scopes_order = configs["resources.#{model[:name]}.scopes.order"]
 
         model.merge(
-          columns: sort_by_name(model[:columns], columns_order, sort_alphabetically: false),
+          columns: sort_by_name(sort_columns(model[:columns]), columns_order, sort_alphabetically: false),
           associations: sort_by_name(model[:associations], associations_order),
           actions: sort_by_name(model[:actions], actions_order, sort_alphabetically: false),
-          tabs: sort_by_name(model[:tabs], tabs_order, sort_alphabetically: false)
+          tabs: sort_by_name(model[:tabs], tabs_order, sort_alphabetically: false),
+          scopes: sort_by_name(model[:scopes], scopes_order)
         )
       end
     end
@@ -37,11 +51,19 @@ module Motor
         if order.present?
           order.index(item[:name]) || Float::MAX
         else
-          item[:display_name]
+          item[:display_name].to_s
         end
       end
     end
 
+    def sort_columns(columns)
+      columns.each_with_object([]) do |column, acc|
+        weight = COLUMNS_DEFAULT_ORDER_WEIGHTS.fetch(column[:name], COLUMNS_DEFAULT_ORDER_WEIGHT)
+
+        (acc[weight] ||= []) << column
+      end.flatten.compact
+    end
+
     # @return [Hash<String, HashWithIndifferentAccess>]
     def load_configs
       Motor::Config.all.each_with_object({}) do |config, acc|

data/lib/motor/queries/run_query.rb

@@ -57,11 +57,16 @@ module Motor
             "$#{index}"
           end
 
-        [
-          format(WITH_STATEMENT_TEMPLATE, sql_body: sql.strip.gsub(/;\z/, ''), limit: limit),
-          'SQL',
-          variables.map { |variable_name, default_value| variables_hash[variable_name] || default_value }
-        ]
+        attributes =
+          variables.map do |variable_name, default_value|
+            ActiveRecord::Relation::QueryAttribute.new(
+              variable_name,
+              variables_hash[variable_name] || default_value,
+              ActiveRecord::Type::Value.new
+            )
+          end
+
+        [format(WITH_STATEMENT_TEMPLATE, sql_body: sql.strip.gsub(/;\z/, ''), limit: limit), 'SQL', attributes]
       end
     end
   end

data/lib/motor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Motor
-  VERSION = '0.1.12'
+  VERSION = '0.1.17'
 end

data/ui/dist/manifest.json

@@ -5,9 +5,9 @@
   "fonts/ionicons.ttf?v=3.0.0-alpha.3": "fonts/ionicons.ttf",
   "fonts/ionicons.woff2?v=3.0.0-alpha.3": "fonts/ionicons.woff2",
   "fonts/ionicons.woff?v=3.0.0-alpha.3": "fonts/ionicons.woff",
-  "main-4bdedd7fcff1351efaf6.css.gz": "main-4bdedd7fcff1351efaf6.css.gz",
-  "main-4bdedd7fcff1351efaf6.js.LICENSE.txt": "main-4bdedd7fcff1351efaf6.js.LICENSE.txt",
-  "main-4bdedd7fcff1351efaf6.js.gz": "main-4bdedd7fcff1351efaf6.js.gz",
-  "main.css": "main-4bdedd7fcff1351efaf6.css",
-  "main.js": "main-4bdedd7fcff1351efaf6.js"
+  "main-c1f7e0cffddc2e2ac639.css.gz": "main-c1f7e0cffddc2e2ac639.css.gz",
+  "main-c1f7e0cffddc2e2ac639.js.LICENSE.txt": "main-c1f7e0cffddc2e2ac639.js.LICENSE.txt",
+  "main-c1f7e0cffddc2e2ac639.js.gz": "main-c1f7e0cffddc2e2ac639.js.gz",
+  "main.css": "main-c1f7e0cffddc2e2ac639.css",
+  "main.js": "main-c1f7e0cffddc2e2ac639.js"
 }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: motor-admin
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.1.17
 platform: ruby
 authors:
 - Pete Matsyburka
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-27 00:00:00.000000000 Z
+date: 2021-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord-filter
@@ -132,6 +132,7 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- app/controllers/motor/active_storage_attachments_controller.rb
 - app/controllers/motor/alerts_controller.rb
 - app/controllers/motor/api_base_controller.rb
 - app/controllers/motor/application_controller.rb
@@ -172,6 +173,8 @@ files:
 - lib/motor-admin.rb
 - lib/motor.rb
 - lib/motor/active_record_utils.rb
+- lib/motor/active_record_utils/active_storage_links_extension.rb
+- lib/motor/active_record_utils/defined_scopes_extension.rb
 - lib/motor/active_record_utils/fetch_methods.rb
 - lib/motor/active_record_utils/types.rb
 - lib/motor/admin.rb
@@ -181,6 +184,7 @@ files:
 - lib/motor/alerts/scheduler.rb
 - lib/motor/api.rb
 - lib/motor/api_query.rb
+- lib/motor/api_query/apply_scope.rb
 - lib/motor/api_query/build_json.rb
 - lib/motor/api_query/build_meta.rb
 - lib/motor/api_query/filter.rb
@@ -189,6 +193,7 @@ files:
 - lib/motor/api_query/sort.rb
 - lib/motor/assets.rb
 - lib/motor/build_schema.rb
+- lib/motor/build_schema/active_storage_attachment_schema.rb
 - lib/motor/build_schema/find_display_column.rb
 - lib/motor/build_schema/load_from_rails.rb
 - lib/motor/build_schema/merge_schema_configs.rb
@@ -208,8 +213,8 @@ files:
 - lib/motor/ui_configs.rb
 - lib/motor/version.rb
 - ui/dist/fonts/ionicons.woff2
-- ui/dist/main-4bdedd7fcff1351efaf6.css.gz
-- ui/dist/main-4bdedd7fcff1351efaf6.js.gz
+- ui/dist/main-c1f7e0cffddc2e2ac639.css.gz
+- ui/dist/main-c1f7e0cffddc2e2ac639.js.gz
 - ui/dist/manifest.json
 homepage:
 licenses: