motor-admin 0.1.13 → 0.1.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9dca132c3a2481191219a518fe66e581988245cbe3212fb105c220285d1a5fa
-  data.tar.gz: e2cb07a305545d2fb01e0c94101f6bdabd705628b8043b8a8a40b320427bc7e9
+  metadata.gz: ba0120981ee7e496773ab8ac05d28e9edab1a2155cacec19636c99c088329065
+  data.tar.gz: 0766e8cef48de36d468baa8c189757e64bc1ea77361741f45aacb80fc19e74a4
 SHA512:
-  metadata.gz: dcce9c0ad1fff7e751a91ab366174174421f038ee3ed848e32618d663d1955221295e0cc79904a0702b939630ab4e6b6873b2b141e01b6ac4bc8361233ef265f
-  data.tar.gz: b20916892df27d1a6c5eef23452824034d0559e5954fe44726034269496409358a3755f3b53dcd489d61953743b511e66f4f93c4bea2ea894f6dae856575492b
+  metadata.gz: b657cd07a7c14867bf112d07ebd2caa7d0076fa650f5803bb710188aab4ed29df37cce6f63905f5bedde77ca6558800d3f57ceaefe14625b74de11c05b9b683e
+  data.tar.gz: be4bde0b32f4ff911569e9acc95f55757ef1a316d0940fd33c270e3b54ddc94043d0826cd21d54def98f3a75f7aa443f497ad07c3a3875e91a3a78b540c0f80d

data/app/controllers/motor/data_controller.rb

@@ -8,6 +8,7 @@ module Motor
 
     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)
@@ -98,7 +99,23 @@ module Motor
     end
 
     def resource_params
-      params.require(: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/lib/motor/admin.rb

@@ -8,10 +8,9 @@ module Motor
 
     initializer 'motor.alerts.scheduler' do
       config.after_initialize do |_app|
-        next if defined?(Sidekiq) && Sidekiq.server?
+        next unless defined?(Rails::Server)
 
         Motor::Alerts::Scheduler::SCHEDULER_TASK.execute
-        Motor::Alerts::ScheduledAlertsCache::UPDATE_ALERTS_TASK.execute
       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/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/active_storage_attachment_schema.rb

@@ -26,7 +26,7 @@ module Motor
           access_type: 'read_only',
           default_value: nil,
           validators: [],
-          virtual: false
+          virtual: true
         },
         {
           name: 'name',

data/lib/motor/build_schema/load_from_rails.rb

@@ -76,22 +76,67 @@ module Motor
       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
@@ -108,8 +153,6 @@ module Motor
             display_name: name.humanize,
             slug: name.underscore,
             model_name: model_class.name.underscore,
-            model_slug: Utils.slugify(model_class),
-            association_type: fetch_association_type(ref),
             foreign_key: ref.foreign_key,
             polymorphic: ref.polymorphic? || model_class.name == 'ActiveStorage::Attachment',
             visible: true
@@ -117,21 +160,6 @@ module Motor
         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/persist_resource_configs.rb

@@ -13,6 +13,7 @@ module Motor
       COLUMN_DEFAULTS = {
         access_type: 'read_write',
         default_value: nil,
+        reference: nil,
         validators: []
       }.with_indifferent_access
 

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>]
@@ -19,7 +31,7 @@ module Motor
         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),
@@ -39,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.13'
+  VERSION = '0.1.18'
 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-8f36a2746422efd1e8a8.css.gz": "main-8f36a2746422efd1e8a8.css.gz",
-  "main-8f36a2746422efd1e8a8.js.LICENSE.txt": "main-8f36a2746422efd1e8a8.js.LICENSE.txt",
-  "main-8f36a2746422efd1e8a8.js.gz": "main-8f36a2746422efd1e8a8.js.gz",
-  "main.css": "main-8f36a2746422efd1e8a8.css",
-  "main.js": "main-8f36a2746422efd1e8a8.js"
+  "main-ca8fcc97a95fcfa80394.css.gz": "main-ca8fcc97a95fcfa80394.css.gz",
+  "main-ca8fcc97a95fcfa80394.js.LICENSE.txt": "main-ca8fcc97a95fcfa80394.js.LICENSE.txt",
+  "main-ca8fcc97a95fcfa80394.js.gz": "main-ca8fcc97a95fcfa80394.js.gz",
+  "main.css": "main-ca8fcc97a95fcfa80394.css",
+  "main.js": "main-ca8fcc97a95fcfa80394.js"
 }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: motor-admin
 version: !ruby/object:Gem::Version
-  version: 0.1.13
+  version: 0.1.18
 platform: ruby
 authors:
 - Pete Matsyburka
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-29 00:00:00.000000000 Z
+date: 2021-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord-filter
@@ -213,8 +213,8 @@ files:
 - lib/motor/ui_configs.rb
 - lib/motor/version.rb
 - ui/dist/fonts/ionicons.woff2
-- ui/dist/main-8f36a2746422efd1e8a8.css.gz
-- ui/dist/main-8f36a2746422efd1e8a8.js.gz
+- ui/dist/main-ca8fcc97a95fcfa80394.css.gz
+- ui/dist/main-ca8fcc97a95fcfa80394.js.gz
 - ui/dist/manifest.json
 homepage:
 licenses: