motor-admin-cstham8 0.4.35

data/lib/motor/api_query/filter.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Motor
+  module ApiQuery
+    module Filter
+      LIKE_FILTER_VALUE_REGEXP = /\A%?(.*?)%?\z/.freeze
+      DISTINCT_RESTRICTED_COLUMN_TYPES = %i[json point].freeze
+
+      module_function
+
+      def call(rel, params)
+        return rel if params.blank?
+
+        normalized_params = normalize_params(Array.wrap(params))
+
+        rel = apply_filters(rel, normalized_params)
+        rel = rel.distinct if can_apply_distinct?(rel)
+
+        rel
+      end
+
+      def clean_filters(value)
+        if value.class.name == 'ActionController::Parameters'
+          value.to_unsafe_h
+        elsif value.is_a?(Array)
+          value.map { |v| clean_filters(v) }
+        else
+          value
+        end
+      end
+
+      def apply_predicates(rel, filters)
+        joins = ActiveRecord::PredicateBuilder.filter_joins(rel.klass, filters)
+
+        joins.flatten.reduce(rel) do |acc, j|
+          if j.is_a?(String) || j.is_a?(Arel::Nodes::Join)
+            acc.joins(j)
+          elsif j.present?
+            acc.left_outer_joins(j)
+          else
+            acc
+          end
+        end
+      end
+
+      def apply_filters(rel, filters)
+        filters = clean_filters(filters)
+
+        rel = apply_predicates(rel, filters)
+
+        alias_tracker = ActiveRecord::Associations::AliasTracker.create(rel.connection, rel.table.name, [])
+        filter_clause_factory = ActiveRecord::Relation::FilterClauseFactory.new(rel.klass, rel.predicate_builder)
+
+        where_clause = filter_clause_factory.build(filters, alias_tracker)
+
+        rel_values = rel.instance_variable_get(:@values)
+
+        if rel_values[:where]
+          rel_values[:where] += where_clause
+        else
+          rel_values[:where] = where_clause
+        end
+
+        rel
+      end
+
+      def normalize_params(params)
+        params.map do |item|
+          next item if item.is_a?(String)
+          next normalize_params(item) if item.is_a?(Array)
+
+          item = item.to_unsafe_h if item.respond_to?(:to_unsafe_h)
+
+          item.transform_values do |filter|
+            if filter.is_a?(Hash)
+              normalize_filter_hash(filter)
+            else
+              filter
+            end
+          end
+        end.split('OR').product(['OR']).flatten(1)[0...-1]
+      end
+
+      def normalize_filter_hash(hash)
+        hash.each_with_object({}) do |(action, value), acc|
+          new_action, new_value =
+            if value.is_a?(Hash)
+              [action, normalize_filter_hash(value)]
+            else
+              normalize_action(action, value)
+            end
+
+          acc[new_action] = new_value
+
+          acc
+        end
+      end
+
+      def can_apply_distinct?(rel)
+        rel.columns.none? do |column|
+          DISTINCT_RESTRICTED_COLUMN_TYPES.include?(column.type)
+        end
+      end
+
+      def normalize_action(action, value)
+        case action
+        when 'includes'
+          ['contains', value]
+        when 'contains'
+          ['ilike', value.sub(LIKE_FILTER_VALUE_REGEXP, '%\1%')]
+        when 'starts_with'
+          ['ilike', value.sub(LIKE_FILTER_VALUE_REGEXP, '\1%')]
+        when 'ends_with'
+          ['ilike', value.sub(LIKE_FILTER_VALUE_REGEXP, '%\1')]
+        when 'eqnull'
+          ['eq', nil]
+        when 'neqnull'
+          ['neq', nil]
+        else
+          [action, value]
+        end
+      end
+    end
+  end
+end

data/lib/motor/api_query/paginate.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Motor
+  module ApiQuery
+    module Paginate
+      MAX_PER_PAGE = 500
+
+      module_function
+
+      def call(rel, params)
+        params ||= {}
+
+        rel = rel.limit([MAX_PER_PAGE, (params[:limit] || MAX_PER_PAGE).to_i].min)
+
+        rel.offset(params[:offset].to_i)
+      end
+    end
+  end
+end

data/lib/motor/api_query/search.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Motor
+  module ApiQuery
+    module Search
+      STRING_COLUMN_TYPES = %i[text string citext].freeze
+      NUMBER_COLUMN_TYPES = %i[integer float].freeze
+
+      module_function
+
+      def call(rel, keyword)
+        return rel if keyword.blank?
+
+        filters = fetch_filters(rel, keyword)
+
+        arel_where = build_arel_or_query(filters)
+
+        rel.where(arel_where)
+      end
+
+      def fetch_filters(rel, keyword)
+        klass = rel.klass
+
+        selected_columns = find_searchable_columns(klass)
+
+        build_arel_filters(klass, selected_columns, keyword)
+      end
+
+      def build_arel_filters(model, column_names, keyword)
+        arel_table = model.arel_table
+
+        column_names.map do |name|
+          column_type = model.columns_hash[name]&.type
+
+          next unless column_type
+
+          if STRING_COLUMN_TYPES.include?(column_type)
+            arel_table[name].matches("%#{keyword}%")
+          elsif NUMBER_COLUMN_TYPES.include?(column_type)
+            arel_table[name].eq(keyword.to_f) if keyword.match?(/\A\d/)
+          else
+            arel_table[name].eq(keyword)
+          end
+        end.compact
+      end
+
+      def build_arel_or_query(filter_array)
+        filter_array.reduce(nil) do |acc, filter|
+          next acc = filter unless acc
+
+          acc.or(filter)
+        end
+      end
+
+      def find_searchable_columns(model)
+        model.try(:motor_searchable_columns) || Motor::BuildSchema::FindSearchableColumns.call(model)
+      end
+    end
+  end
+end

data/lib/motor/api_query/sort.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Motor
+  module ApiQuery
+    module Sort
+      FIELD_PARSE_REGEXP = /\A(-)?(.*)\z/.freeze
+
+      module_function
+
+      def call(rel, param)
+        return rel if param.blank?
+
+        arel_order = build_arel_order(rel.klass, param)
+        join_params = build_join_params(rel.klass, param)
+
+        rel = rel.left_joins(join_params) if join_params.present?
+
+        rel.reorder(arel_order)
+      end
+
+      def build_join_params(_model, param)
+        param.split(',').each_with_object({}) do |field, result|
+          key = field[FIELD_PARSE_REGEXP, 2]
+          *path, _ = key.split('.')
+
+          path.reduce(result) do |acc, fragment|
+            hash = {}
+
+            acc[fragment] = hash
+
+            hash
+          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]
+
+          arel_direction = direction.present? ? arel_column.desc : arel_column.asc
+
+          maybe_add_null_last(model, arel_direction)
+        end
+      end
+
+      def maybe_add_null_last(model, arel_direction)
+        if arel_direction.respond_to?(:nulls_last) &&
+           model.connection.class.name == 'ActiveRecord::ConnectionAdapters::PostgreSQLAdapter'
+          arel_direction.nulls_last
+        else
+          arel_direction
+        end
+      end
+    end
+  end
+end

data/lib/motor/api_query.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Motor
+  module ApiQuery
+    module_function
+
+    def call(rel, params)
+      rel = ApiQuery::Sort.call(rel, params[:sort] || params[:order])
+      rel = ApiQuery::Paginate.call(rel, params[:page])
+      rel = ApiQuery::Filter.call(rel, params[:filter] || params[:filters])
+      rel = ApiQuery::ApplyScope.call(rel, params[:scope])
+
+      ApiQuery::Search.call(rel, params[:q] || params[:search] || params[:query])
+    end
+  end
+end
+
+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'

data/lib/motor/assets.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Motor
+  module Assets
+    InvalidPathError = Class.new(StandardError)
+
+    ASSETS_PATH = Pathname.new(__dir__).join('../../ui/dist')
+    MANIFEST_PATH = ASSETS_PATH.join('manifest.json')
+    DEV_SERVER_URL = 'http://localhost:9090/'
+
+    CACHE_STORE =
+      if Rails.env.production?
+        ActiveSupport::Cache::MemoryStore.new(size: 5.megabytes)
+      else
+        ActiveSupport::Cache::NullStore.new
+      end
+
+    module_function
+
+    def manifest
+      CACHE_STORE.fetch('manifest') do
+        JSON.parse(MANIFEST_PATH.read)
+      end
+    end
+
+    def icons
+      manifest.select do |k, v|
+        !k.ends_with?('.gz') && v.starts_with?('icons/') && v.exclude?('DS_Store')
+      end.keys
+    end
+
+    def asset_path(path)
+      Motor::Admin.routes.url_helpers.motor_asset_path(manifest[path])
+    end
+
+    def load_asset(filename, gzip: false)
+      if Motor.development?
+        load_from_dev_server(filename)
+      else
+        load_from_disk(filename, gzip: gzip)
+      end
+    end
+
+    def load_from_disk(filename, gzip:)
+      filename += '.gz' if gzip
+
+      raise InvalidPathError if filename.include?('..')
+
+      path = ASSETS_PATH.join(filename)
+
+      raise InvalidPathError unless path.to_s.starts_with?(ASSETS_PATH.to_s)
+
+      path.read
+    end
+
+    def load_from_dev_server(filename)
+      uri = URI(DEV_SERVER_URL + filename)
+
+      Net::HTTP.get_response(uri).body
+    end
+  end
+end

data/lib/motor/build_schema/active_storage_attachment_schema.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Motor
+  module BuildSchema
+    module ActiveStorageAttachmentSchema
+      module_function
+
+      # rubocop:disable Metrics/MethodLength
+      def call
+        model = ActiveStorage::Attachment
+
+        {
+          name: model.name.underscore,
+          slug: Utils.slugify(model),
+          class_name: model.name,
+          table_name: model.table_name,
+          primary_key: model.primary_key,
+          display_name: model.model_name.human(count: 2, default: 'Attachments'),
+          display_column: 'id',
+          icon: 'paperclip',
+          columns: [
+            {
+              name: 'id',
+              display_name: 'ID',
+              column_type: 'integer',
+              access_type: 'read_only',
+              default_value: nil,
+              validators: [],
+              format: {},
+              is_array: false,
+              reference: nil,
+              virtual: false
+            },
+            {
+              name: 'path',
+              display_name: model.human_attribute_name(:path),
+              column_type: 'string',
+              access_type: 'read_only',
+              default_value: nil,
+              validators: [],
+              format: {},
+              is_array: false,
+              reference: nil,
+              virtual: true
+            },
+            {
+              name: 'name',
+              display_name: model.human_attribute_name(:name),
+              column_type: 'string',
+              access_type: 'read_write',
+              default_value: nil,
+              validators: [],
+              format: {},
+              is_array: false,
+              reference: nil,
+              virtual: false
+            },
+            {
+              name: 'record_type',
+              display_name: model.human_attribute_name(:record_type),
+              column_type: 'string',
+              access_type: 'read_write',
+              default_value: nil,
+              validators: [],
+              format: {},
+              is_array: false,
+              reference: nil,
+              virtual: false
+            },
+            {
+              name: 'record_id',
+              display_name: model.human_attribute_name(:record),
+              column_type: 'integer',
+              access_type: 'read_write',
+              default_value: nil,
+              validators: [],
+              format: {},
+              is_array: false,
+              reference: {
+                name: 'record',
+                display_name: model.human_attribute_name(:record),
+                model_name: nil,
+                reference_type: 'belongs_to',
+                foreign_key: 'record_id',
+                polymorphic: true
+              },
+              virtual: false
+            },
+            {
+              name: 'file',
+              display_name: model.human_attribute_name(:file),
+              column_type: 'file',
+              access_type: 'write_only',
+              default_value: nil,
+              validators: [],
+              format: {},
+              is_array: false,
+              reference: nil,
+              virtual: false
+            },
+            {
+              name: 'created_at',
+              display_name: model.human_attribute_name(:created_at),
+              column_type: 'datetime',
+              access_type: 'read_only',
+              default_value: nil,
+              validators: [],
+              format: {},
+              is_array: false,
+              reference: nil,
+              virtual: false
+            }
+          ],
+          associations: [],
+          scopes: [],
+          preferences: {},
+          actions: Motor::BuildSchema::Defaults.actions.reject { |e| e[:name] == 'edit' },
+          tabs: Motor::BuildSchema::Defaults.tabs,
+          visible: false
+        }.with_indifferent_access
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+  end
+end

data/lib/motor/build_schema/adjust_devise_model_schema.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Motor
+  module BuildSchema
+    module AdjustDeviseModelSchema
+      HIDDEN_COLUMNS = %w[
+        encrypted_password
+        reset_password_token
+        confirmation_token
+      ].freeze
+
+      READ_ONLY_COLUMNS = %w[
+        reset_password_sent_at
+        remember_created_at
+        sign_in_count
+        current_sign_in_at
+        last_sign_in_at
+        current_sign_in_ip
+        last_sign_in_ip
+        confirmed_at
+        confirmation_sent_at
+      ].freeze
+
+      module_function
+
+      def call(schema, devise_modules)
+        modify_column_access_types!(schema[:columns])
+        add_password_column!(schema[:columns]) if devise_modules.include?(:database_authenticatable)
+
+        schema
+      end
+
+      def modify_column_access_types!(columns)
+        columns.each do |column|
+          column[:access_type] =
+            case column[:name]
+            when *HIDDEN_COLUMNS
+              ColumnAccessTypes::HIDDEN
+            when *READ_ONLY_COLUMNS
+              ColumnAccessTypes::READ_ONLY
+            else
+              column[:access_type]
+            end
+        end
+      end
+
+      def add_password_column!(columns)
+        columns << {
+          name: 'password',
+          display_name: I18n.t('motor.password'),
+          column_type: 'string',
+          access_type: 'write_only',
+          default_value: nil,
+          validators: [],
+          virtual: true
+        }
+      end
+    end
+  end
+end

data/lib/motor/build_schema/apply_permissions.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Motor
+  module BuildSchema
+    module ApplyPermissions
+      module_function
+
+      def call(schema, ability)
+        schema.map do |model|
+          klass = model[:class_name].constantize
+
+          next unless ability.can?(:read, klass)
+
+          model[:associations] = filter_associations(model[:associations], ability)
+          model[:columns] = filter_columns(klass, model[:columns], ability)
+          model[:actions] = filter_actions(klass, model[:actions], ability)
+          model[:tabs] = filter_tabs(klass, model[:tabs], ability)
+
+          model
+        end.compact
+      end
+
+      def filter_associations(associations, ability)
+        associations.select do |assoc|
+          model_class = assoc[:model_name].classify.safe_constantize
+
+          model_class && ability.can?(:read, model_class)
+        end
+      end
+
+      def filter_tabs(_model, tabs, ability)
+        tabs = tabs.reject { |t| t[:name] == 'audits' } unless ability.can?(:read, Motor::Audit)
+        tabs = tabs.reject { |t| t[:name] == 'notes' } unless ability.can?(:read, Motor::Note)
+
+        tabs
+      end
+
+      def filter_columns(model, columns, ability)
+        columns.map do |column|
+          next unless ability.can?(:read, model, column[:name])
+
+          reference_model_name = column.dig(:reference, :model_name)
+          model_class = reference_model_name&.classify&.safe_constantize
+
+          next if reference_model_name &&
+                  (model_class.nil? || !ability.can?(:read, model_class))
+
+          if !ability.can?(:update, model, column[:name]) &&
+             column[:access_type] != BuildSchema::ColumnAccessTypes::HIDDEN
+            column = column.merge(access_type: BuildSchema::ColumnAccessTypes::READ_ONLY)
+          end
+
+          column
+        end.compact
+      end
+
+      def filter_actions(model, actions, ability)
+        actions.select do |action|
+          ability.can?(action[:name].to_sym, model)
+        end
+      end
+    end
+  end
+end

data/lib/motor/build_schema/defaults.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Motor
+  module BuildSchema
+    module Defaults
+      module_function
+
+      # rubocop:disable Metrics/MethodLength
+      def actions
+        [
+          {
+            name: 'create',
+            display_name: I18n.t('motor.create'),
+            action_type: BuildSchema::DEFAULT_TYPE,
+            preferences: {},
+            apply_on: 'collection',
+            visible: true
+          },
+          {
+            name: 'edit',
+            display_name: I18n.t('motor.edit'),
+            action_type: BuildSchema::DEFAULT_TYPE,
+            preferences: {},
+            apply_on: 'member',
+            visible: true
+          },
+          {
+            name: 'remove',
+            display_name: I18n.t('motor.remove'),
+            action_type: BuildSchema::DEFAULT_TYPE,
+            preferences: {},
+            apply_on: 'member',
+            visible: true
+          }
+        ].freeze
+      end
+
+      def tabs
+        [
+          {
+            name: 'details',
+            display_name: I18n.t('motor.details'),
+            tab_type: BuildSchema::DEFAULT_TYPE,
+            preferences: {},
+            visible: true
+          },
+          {
+            name: 'audits',
+            display_name: I18n.t('motor.audits'),
+            tab_type: BuildSchema::DEFAULT_TYPE,
+            preferences: {},
+            visible: true
+          },
+          {
+            name: 'notes',
+            display_name: I18n.t('motor.notes'),
+            tab_type: BuildSchema::DEFAULT_TYPE,
+            preferences: {},
+            visible: true
+          }
+        ].freeze
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+  end
+end