motor-admin 0.1.55 → 0.1.61

data/lib/motor/build_schema/find_display_column.rb

@@ -55,6 +55,7 @@ module Motor
       def fetch_column_names(model)
         model.columns.map do |column|
           next unless column.type.in?(BuildSchema::SEARCHABLE_COLUMN_TYPES)
+          next if column.respond_to?(:array?) && column.array?
 
           column.name
         end.compact

data/lib/motor/build_schema/find_icon.rb

@@ -35,6 +35,7 @@ module Motor
       'token' => 'key',
       'secret' => 'lock',
       'automation' => 'manual-gearbox',
+      'workflow' => 'manual-gearbox',
       'relationship' => 'hierarchy',
       'person' => 'user',
       'people' => 'users',
@@ -96,6 +97,8 @@ module Motor
       'page' => 'brand-pagekit',
       'date' => 'calendar-event',
       'customer' => 'users',
+      'client' => 'users',
+      'ticket' => 'ticket',
       'contact' => 'users',
       'member' => 'users',
       'admin' => 'user-check',
@@ -107,7 +110,8 @@ module Motor
       'product' => 'building-store',
       'html' => 'code',
       'stripe' => 'brand-stripe',
-      'email' => 'mail'
+      'email' => 'mail',
+      'status' => 'hash'
     }.freeze
 
     DEFAULT_ICON = 'database'

data/lib/motor/cancan_utils.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module CancanUtils
+end
+
+require_relative './cancan_utils/ability_patch'
+require_relative './cancan_utils/can_manage_all'

data/lib/motor/cancan_utils/ability_patch.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Motor
+  module CancanUtils
+    module AbilityPatch
+      def serialized_rules
+        @rules.map do |rule|
+          {
+            base_behavior: rule.base_behavior,
+            actions: expand_actions(rule.actions),
+            subjects: rule.subjects.map(&:to_s),
+            attributes: rule.attributes,
+            conditions: rule.conditions.as_json
+          }
+        end
+      end
+
+      def rules_hash
+        serialized_rules.hash
+      end
+
+      private
+
+      def default_alias_actions
+        super.merge(destroy: %i[remove delete])
+      end
+    end
+  end
+end

data/lib/motor/cancan_utils/can_manage_all.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Motor
+  module CancanUtils
+    class CanManageAll
+      include CanCan::Ability
+      prepend CancanUtils::AbilityPatch
+
+      def initialize(_ = nil)
+        can :manage, :all
+      end
+    end
+  end
+end

data/lib/motor/configs/build_ui_app_tag.rb

@@ -12,57 +12,67 @@ module Motor
 
       module_function
 
-      def call(current_user = nil)
+      def call(current_user = nil, current_ability = nil)
         cache_keys = LoadFromCache.load_cache_keys
 
         CACHE_STORE.fetch("#{cache_keys.hash}#{current_user&.id}") do
           CACHE_STORE.clear
 
-          Motor::ApplicationController.helpers.tag.div('', id: 'app', data: build_data(cache_keys, current_user))
+          data = build_data(cache_keys, current_user, current_ability)
+          Motor::ApplicationController.helpers.tag.div('', id: 'app', data: data)
         end
       end
 
       # @return [Hash]
-      def build_data(cache_keys = {}, current_user = nil)
+      def build_data(cache_keys = {}, current_user = nil, current_ability = nil)
         {
           current_user: current_user&.as_json(only: %i[id email]),
+          current_rules: current_ability.serialized_rules,
           audits_count: Motor::Audit.count,
           base_path: Motor::Admin.routes.url_helpers.motor_path,
-          schema: Motor::BuildSchema.call(cache_keys),
+          schema: Motor::BuildSchema.call(cache_keys, current_ability),
           header_links: header_links_data_hash(cache_keys[:configs]),
-          queries: queries_data_hash(cache_keys[:queries]),
-          dashboards: dashboards_data_hash(cache_keys[:dashboards]),
-          alerts: alerts_data_hash(cache_keys[:alerts]),
-          forms: forms_data_hash(cache_keys[:forms])
+          queries: queries_data_hash(build_cache_key(cache_keys, :queries, current_user, current_ability),
+                                     current_ability),
+          dashboards: dashboards_data_hash(build_cache_key(cache_keys, :dashboards, current_user, current_ability),
+                                           current_ability),
+          alerts: alerts_data_hash(build_cache_key(cache_keys, :alerts, current_user, current_ability),
+                                   current_ability),
+          forms: forms_data_hash(build_cache_key(cache_keys, :forms, current_user, current_ability), current_ability)
         }
       end
 
+      # @return [String]
+      def build_cache_key(cache_keys, key, current_user, current_ability)
+        "#{cache_keys[key].hash}#{current_user&.id}#{current_ability&.rules_hash}"
+      end
+
       def header_links_data_hash(cache_key = nil)
         configs = Motor::Configs::LoadFromCache.load_configs(cache_key: cache_key)
 
         configs.find { |c| c.key == 'header.links' }&.value || []
       end
 
-      def queries_data_hash(cache_key = nil)
-        Motor::Configs::LoadFromCache.load_queries(cache_key: cache_key)
+      def queries_data_hash(cache_key = nil, current_ability = nil)
+        Motor::Configs::LoadFromCache.load_queries(cache_key: cache_key, current_ability: current_ability)
                                      .as_json(only: %i[id name updated_at],
                                               include: { tags: { only: %i[id name] } })
       end
 
-      def dashboards_data_hash(cache_key = nil)
-        Motor::Configs::LoadFromCache.load_dashboards(cache_key: cache_key)
+      def dashboards_data_hash(cache_key = nil, current_ability = nil)
+        Motor::Configs::LoadFromCache.load_dashboards(cache_key: cache_key, current_ability: current_ability)
                                      .as_json(only: %i[id title updated_at],
                                               include: { tags: { only: %i[id name] } })
       end
 
-      def alerts_data_hash(cache_key = nil)
-        Motor::Configs::LoadFromCache.load_alerts(cache_key: cache_key)
+      def alerts_data_hash(cache_key = nil, current_ability = nil)
+        Motor::Configs::LoadFromCache.load_alerts(cache_key: cache_key, current_ability: current_ability)
                                      .as_json(only: %i[id name is_enabled updated_at],
                                               include: { tags: { only: %i[id name] } })
       end
 
-      def forms_data_hash(cache_key = nil)
-        Motor::Configs::LoadFromCache.load_forms(cache_key: cache_key)
+      def forms_data_hash(cache_key = nil, current_ability = nil)
+        Motor::Configs::LoadFromCache.load_forms(cache_key: cache_key, current_ability: current_ability)
                                      .as_json(only: %i[id name updated_at],
                                               include: { tags: { only: %i[id name] } })
       end

data/lib/motor/configs/load_from_cache.rb

@@ -32,27 +32,39 @@ module Motor
         end
       end
 
-      def load_queries(cache_key: nil)
+      def load_queries(cache_key: nil, current_ability: nil)
         maybe_fetch_from_cache('queries', cache_key) do
-          Motor::Query.all.active.preload(:tags).load
+          rel = Motor::Query.all.active.preload(:tags)
+          rel = rel.accessible_by(current_ability) if current_ability
+
+          rel.load
         end
       end
 
-      def load_dashboards(cache_key: nil)
+      def load_dashboards(cache_key: nil, current_ability: nil)
         maybe_fetch_from_cache('dashboards', cache_key) do
-          Motor::Dashboard.all.active.preload(:tags).load
+          rel = Motor::Dashboard.all.active.preload(:tags)
+          rel = rel.accessible_by(current_ability) if current_ability
+
+          rel.load
         end
       end
 
-      def load_alerts(cache_key: nil)
+      def load_alerts(cache_key: nil, current_ability: nil)
         maybe_fetch_from_cache('alerts', cache_key) do
-          Motor::Alert.all.active.preload(:tags).load
+          rel = Motor::Alert.all.active.preload(:tags)
+          rel = rel.accessible_by(current_ability) if current_ability
+
+          rel.load
         end
       end
 
-      def load_forms(cache_key: nil)
+      def load_forms(cache_key: nil, current_ability: nil)
         maybe_fetch_from_cache('forms', cache_key) do
-          Motor::Form.all.active.preload(:tags).load
+          rel = Motor::Form.all.active.preload(:tags)
+          rel = rel.accessible_by(current_ability) if current_ability
+
+          rel.load
         end
       end
 

data/lib/motor/queries/render_sql_template.rb

@@ -22,9 +22,19 @@ module Motor
             variable_name = Regexp.last_match[1]
 
             index = selected_variables.index { |name, _| name == variable_name }
-            selected_variables << [variable_name, variables[variable_name]] unless index
+            variable_values = variables[variable_name]
 
-            "$#{selected_variables.size}"
+            if variable_values.is_a?(Array)
+              first_variable_index = selected_variables.size + 1
+
+              variable_values.each { |value| selected_variables << [variable_name, value] } unless index
+
+              (first_variable_index..selected_variables.size).map { |i| "$#{i}" }.join(', ')
+            else
+              selected_variables << [variable_name, variables[variable_name]] unless index
+
+              "$#{selected_variables.size}"
+            end
           end
 
         [rendered, selected_variables]

data/lib/motor/queries/run_query.rb

@@ -7,25 +7,33 @@ module Motor
 
       QueryResult = Struct.new(:data, :columns, :error, keyword_init: true)
 
-      WITH_STATEMENT_START = 'WITH __query__ AS ('
+      CTE_NAME = '__query__'
+
+      WITH_STATEMENT_START = "WITH #{CTE_NAME} AS ("
 
       WITH_STATEMENT_TEMPLATE = <<~SQL
         #{WITH_STATEMENT_START}%<sql_body>s
-        ) SELECT * FROM __query__ LIMIT %<limit>s;
+        )
       SQL
 
+      STATEMENT_VARIABLE_REGEXP = /\$\d+/.freeze
       PG_ERROR_REGEXP = /\APG.+ERROR:/.freeze
 
+      RESERVED_VARIABLES = %w[current_user_id current_user_email].freeze
+
       module_function
 
       # @param query [Motor::Query]
       # @param variables_hash [Hash]
       # @param limit [Integer]
+      # @param filters [Hash]
       # @return [Motor::Queries::RunQuery::QueryResult]
-      def call!(query, variables_hash: nil, limit: DEFAULT_LIMIT)
+      def call!(query, variables_hash: nil, limit: nil, filters: nil)
         variables_hash ||= {}
+        limit ||= DEFAULT_LIMIT
+        filters ||= {}
 
-        result = execute_query(query, limit, variables_hash)
+        result = execute_query(query, limit, variables_hash, filters)
 
         QueryResult.new(data: result.rows, columns: build_columns_hash(result))
       end
@@ -34,8 +42,8 @@ module Motor
       # @param variables_hash [Hash]
       # @param limit [Integer]
       # @return [Motor::Queries::RunQuery::QueryResult]
-      def call(query, variables_hash: nil, limit: DEFAULT_LIMIT)
-        call!(query, variables_hash: variables_hash, limit: limit)
+      def call(query, variables_hash: nil, limit: nil, filters: nil)
+        call!(query, variables_hash: variables_hash, limit: limit, filters: filters)
       rescue ActiveRecord::StatementInvalid => e
         QueryResult.new(error: build_error_message(e))
       end
@@ -49,10 +57,11 @@ module Motor
       # @param query [Motor::Query]
       # @param limit [Integer]
       # @param variables_hash [Hash]
+      # @param filters [Hash]
       # @return [ActiveRecord::Result]
-      def execute_query(query, limit, variables_hash)
+      def execute_query(query, limit, variables_hash, filters)
         result = nil
-        statement = prepare_sql_statement(query, limit, variables_hash)
+        statement = prepare_sql_statement(query, limit, variables_hash, filters)
 
         ActiveRecord::Base.transaction do
           result =
@@ -60,6 +69,8 @@ module Motor
             when 'ActiveRecord::ConnectionAdapters::PostgreSQLAdapter'
               PostgresqlExecQuery.call(ActiveRecord::Base.connection, statement)
             else
+              statement = normalize_statement_for_sql(statement)
+
               ActiveRecord::Base.connection.exec_query(*statement)
             end
 
@@ -86,35 +97,78 @@ module Motor
       # @param query [Motor::Query]
       # @param limit [Integer]
       # @param variables_hash [Hash]
+      # @param filters [Hash]
       # @return [Array]
-      def prepare_sql_statement(query, limit, variables_hash)
+      def prepare_sql_statement(query, limit, variables_hash, filters)
         variables = merge_variable_default_values(query.preferences.fetch(:variables, []), variables_hash)
 
         sql, query_variables = RenderSqlTemplate.call(query.sql_body, variables)
+        cte_sql = format(WITH_STATEMENT_TEMPLATE, sql_body: sql.strip.delete_suffix(';'))
+        cte_select_sql = build_cte_select_sql(limit, filters)
 
         attributes = build_statement_attributes(query_variables)
 
-        [format(WITH_STATEMENT_TEMPLATE, sql_body: sql.strip.delete_suffix(';'), limit: limit), 'SQL', attributes]
+        [[cte_sql, cte_select_sql].join, 'SQL', attributes]
+      end
+
+      # @param limit [Number]
+      # @param filters [Hash]
+      # @return [String]
+      def build_cte_select_sql(limit, filters)
+        table = Arel::Table.new(CTE_NAME)
+
+        arel_filters = build_filters_arel(filters)
+
+        expresion = table.project(table[Arel.star])
+        expresion = expresion.where(arel_filters) if arel_filters.present?
+
+        expresion.take(limit.to_i).to_sql
+      end
+
+      # @param filters [Hash]
+      # @return [Arel::Nodes, nil]
+      def build_filters_arel(filters)
+        return nil if filters.blank?
+
+        table = Arel::Table.new(CTE_NAME)
+
+        arel_filters = filters.map { |key, value| table[key].in(value) }
+
+        arel_filters[1..].reduce(arel_filters.first) { |acc, arel| acc.and(arel) }
       end
 
       # @param variables [Array<(String, Object)>]
       # @return [Array<ActiveRecord::Relation::QueryAttribute>]
       def build_statement_attributes(variables)
         variables.map do |variable_name, value|
-          ActiveRecord::Relation::QueryAttribute.new(
-            variable_name,
-            value,
-            ActiveRecord::Type::Value.new
-          )
-        end
+          [value].flatten.map do |val|
+            ActiveRecord::Relation::QueryAttribute.new(
+              variable_name,
+              val,
+              ActiveRecord::Type::Value.new
+            )
+          end
+        end.flatten
+      end
+
+      # @param array [Array]
+      # @return [Array]
+      def normalize_statement_for_sql(statement)
+        sql, _, attributes = statement
+
+        sql = ActiveRecord::Base.sanitize_sql([sql.gsub(STATEMENT_VARIABLE_REGEXP, '?'), attributes.map(&:value)])
+
+        [sql, 'SQL', attributes]
       end
 
       # @param variable_configs [Array<Hash>]
-      # @param variable_hash [Hash]
+      # @param variables_hash [Hash]
       # @return [Hash]
       def merge_variable_default_values(variable_configs, variables_hash)
-        variable_configs.each_with_object({}) do |variable, acc|
-          acc[variable[:name]] = variables_hash[variable[:name]] || variable[:default_value]
+        variable_configs.each_with_object(variables_hash.slice(*RESERVED_VARIABLES)) do |variable, acc|
+          next if RESERVED_VARIABLES.include?(variable[:name])
+
+          acc[variable[:name]] ||= variables_hash[variable[:name]] || variable[:default_value]
         end
       end
     end

data/lib/motor/version.rb

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

data/ui/dist/manifest.json

@@ -2068,11 +2068,11 @@
   "mail-opened.svg": "icons/mail-opened.svg",
   "mail.svg": "icons/mail.svg",
   "mailbox.svg": "icons/mailbox.svg",
-  "main-4d659b311d92611ad5f6.css.gz": "main-4d659b311d92611ad5f6.css.gz",
-  "main-4d659b311d92611ad5f6.js.LICENSE.txt": "main-4d659b311d92611ad5f6.js.LICENSE.txt",
-  "main-4d659b311d92611ad5f6.js.gz": "main-4d659b311d92611ad5f6.js.gz",
-  "main.css": "main-4d659b311d92611ad5f6.css",
-  "main.js": "main-4d659b311d92611ad5f6.js",
+  "main-fd0f75f789196ce24ffd.css.gz": "main-fd0f75f789196ce24ffd.css.gz",
+  "main-fd0f75f789196ce24ffd.js.LICENSE.txt": "main-fd0f75f789196ce24ffd.js.LICENSE.txt",
+  "main-fd0f75f789196ce24ffd.js.gz": "main-fd0f75f789196ce24ffd.js.gz",
+  "main.css": "main-fd0f75f789196ce24ffd.css",
+  "main.js": "main-fd0f75f789196ce24ffd.js",
   "man.svg": "icons/man.svg",
   "manual-gearbox.svg": "icons/manual-gearbox.svg",
   "map-2.svg": "icons/map-2.svg",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: motor-admin
 version: !ruby/object:Gem::Version
-  version: 0.1.55
+  version: 0.1.61
 platform: ruby
 authors:
 - Pete Matsyburka
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-06-01 00:00:00.000000000 Z
+date: 2021-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord-filter
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.9'
+        version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.9'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: cancancan
   requirement: !ruby/object:Gem::Requirement
@@ -121,6 +121,7 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- app/controllers/concerns/motor/current_ability.rb
 - app/controllers/concerns/motor/current_user_method.rb
 - app/controllers/concerns/motor/load_and_authorize_dynamic_resource.rb
 - app/controllers/concerns/motor/wrap_io_params.rb
@@ -130,6 +131,7 @@ files:
 - app/controllers/motor/application_controller.rb
 - app/controllers/motor/assets_controller.rb
 - app/controllers/motor/audits_controller.rb
+- app/controllers/motor/auth_tokens_controller.rb
 - app/controllers/motor/configs_controller.rb
 - app/controllers/motor/dashboards_controller.rb
 - app/controllers/motor/data_controller.rb
@@ -139,7 +141,6 @@ files:
 - app/controllers/motor/resource_methods_controller.rb
 - app/controllers/motor/resources_controller.rb
 - app/controllers/motor/run_queries_controller.rb
-- app/controllers/motor/schemas_controller.rb
 - app/controllers/motor/send_alerts_controller.rb
 - app/controllers/motor/tags_controller.rb
 - app/controllers/motor/ui_controller.rb
@@ -168,7 +169,8 @@ files:
 - lib/motor-admin.rb
 - lib/motor.rb
 - lib/motor/active_record_utils.rb
-- lib/motor/active_record_utils/active_record_filter.rb
+- lib/motor/active_record_utils/active_record_connection_column_patch.rb
+- lib/motor/active_record_utils/active_record_filter_patch.rb
 - lib/motor/active_record_utils/active_storage_blob_patch.rb
 - lib/motor/active_record_utils/active_storage_links_extension.rb
 - lib/motor/active_record_utils/defined_scopes_extension.rb
@@ -191,6 +193,7 @@ files:
 - lib/motor/build_schema.rb
 - lib/motor/build_schema/active_storage_attachment_schema.rb
 - lib/motor/build_schema/adjust_devise_model_schema.rb
+- lib/motor/build_schema/apply_permissions.rb
 - lib/motor/build_schema/find_display_column.rb
 - lib/motor/build_schema/find_icon.rb
 - lib/motor/build_schema/load_from_rails.rb
@@ -198,6 +201,9 @@ files:
 - lib/motor/build_schema/persist_resource_configs.rb
 - lib/motor/build_schema/reorder_schema.rb
 - lib/motor/build_schema/utils.rb
+- lib/motor/cancan_utils.rb
+- lib/motor/cancan_utils/ability_patch.rb
+- lib/motor/cancan_utils/can_manage_all.rb
 - lib/motor/configs.rb
 - lib/motor/configs/build_configs_hash.rb
 - lib/motor/configs/build_ui_app_tag.rb
@@ -1485,8 +1491,8 @@ files:
 - ui/dist/icons/zoom-money.svg.gz
 - ui/dist/icons/zoom-out.svg.gz
 - ui/dist/icons/zoom-question.svg.gz
-- ui/dist/main-4d659b311d92611ad5f6.css.gz
-- ui/dist/main-4d659b311d92611ad5f6.js.gz
+- ui/dist/main-fd0f75f789196ce24ffd.css.gz
+- ui/dist/main-fd0f75f789196ce24ffd.js.gz
 - ui/dist/manifest.json
 homepage:
 licenses: