motor-admin-cstham8 0.4.35

data/lib/motor/build_schema/merge_schema_configs.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Motor
+  module BuildSchema
+    module MergeSchemaConfigs
+      module_function
+
+      # @param schema [Array<HashWithIndifferentAccess>]
+      # @param cache_keys [Hash]
+      # @return [Array<HashWithIndifferentAccess>]
+      def call(schema, cache_keys = {})
+        configs = load_configs(cache_keys)
+
+        schema.map do |model|
+          merge_model(model, configs.fetch(model[:name], {}))
+        end
+      end
+
+      # @param model [HashWithIndifferentAccess]
+      # @param configs [HashWithIndifferentAccess]
+      # @return [HashWithIndifferentAccess]
+      def merge_model(model, configs)
+        updated_model = model.merge(configs.slice(*Resources::RESOURCE_ATTRS))
+
+        merge_actions!(updated_model, configs)
+        merge_associations!(updated_model, configs)
+        merge_columns!(updated_model, configs)
+        merge_tabs!(updated_model, configs)
+        merge_scopes!(updated_model, configs)
+
+        updated_model
+      end
+
+      # @param model [HashWithIndifferentAccess]
+      # @param configs [HashWithIndifferentAccess]
+      # @return [HashWithIndifferentAccess]
+      def merge_associations!(model, configs)
+        model[:associations] = merge_by_name(
+          model[:associations],
+          configs[:associations],
+          ASSOCIATION_DEFAULTS,
+          ->(scope) { !scope[:virtual] }
+        )
+
+        model
+      end
+
+      # @param model [HashWithIndifferentAccess]
+      # @param configs [HashWithIndifferentAccess]
+      # @return [HashWithIndifferentAccess]
+      def merge_columns!(model, configs)
+        model[:columns] = merge_by_name(
+          merge_custom_sql_columns(model[:columns], configs[:custom_sql]),
+          configs[:columns],
+          COLUMN_DEFAULTS,
+          ->(scope) { !scope[:virtual] }
+        )
+
+        model
+      end
+
+      # @param model [HashWithIndifferentAccess]
+      # @param configs [HashWithIndifferentAccess]
+      # @return [HashWithIndifferentAccess]
+      def merge_actions!(model, configs)
+        model[:actions] = merge_by_name(
+          model[:actions],
+          configs[:actions],
+          ACTION_DEFAULTS
+        )
+
+        model
+      end
+
+      # @param model [HashWithIndifferentAccess]
+      # @param configs [HashWithIndifferentAccess]
+      # @return [HashWithIndifferentAccess]
+      def merge_tabs!(model, configs)
+        model[:tabs] = merge_by_name(
+          model[:tabs],
+          configs[:tabs],
+          TAB_DEFAULTS
+        )
+
+        model
+      end
+
+      # @param model [HashWithIndifferentAccess]
+      # @param configs [HashWithIndifferentAccess]
+      # @return [HashWithIndifferentAccess]
+      def merge_scopes!(model, configs)
+        model[:scopes] = merge_by_name(
+          model[:scopes],
+          configs[:scopes],
+          SCOPE_DEFAULTS,
+          ->(scope) { scope[:scope_type] != 'filter' }
+        )
+
+        model
+      end
+
+      # @param defaults [Array<HashWithIndifferentAccess>]
+      # @param configs [Array<HashWithIndifferentAccess>]
+      # @return [Array<HashWithIndifferentAccess>]
+      def merge_by_name(defaults, configs, default_attrs = {}, default_item_check = nil)
+        return defaults if configs.blank?
+
+        (defaults.pluck(:name) + configs.pluck(:name)).uniq.map do |name|
+          config_item = configs.find { |e| e[:name] == name }
+          default_item = defaults.find { |e| e[:name] == name }
+
+          next if default_item.nil? && default_item_check&.call(config_item)
+
+          (default_item || default_attrs).merge(config_item || {})
+        end.compact
+      end
+
+      # @param columns [Array<HashWithIndifferentAccess>]
+      # @param sql [String]
+      # @return [Array<HashWithIndifferentAccess>]
+      def merge_custom_sql_columns(columns, sql)
+        return columns if sql.blank?
+
+        query_columns = Resources::CustomSqlColumnsCache.call(sql)
+
+        columns_index = columns.index_by { |e| e[:name] }
+
+        merged_columns =
+          query_columns.map do |column|
+            existing_column = columns_index.delete(column[:name])
+
+            next existing_column if existing_column
+
+            column.merge(COLUMN_DEFAULTS).merge(
+              access_type: ColumnAccessTypes::READ_ONLY,
+              column_source: ColumnSources::QUERY,
+              virtual: false
+            ).with_indifferent_access
+          end
+
+        reflection_columns = columns_index.values.select { |c| c[:column_source] == ColumnSources::REFLECTION }
+
+        reflection_columns + merged_columns
+      end
+
+      # @param cache_keys [Hash]
+      # @return [HashWithIndifferentAccess<String, HashWithIndifferentAccess>]
+      def load_configs(cache_keys)
+        resources = Motor::Configs::LoadFromCache.load_resources(cache_key: cache_keys[:resources])
+
+        resources.each_with_object(ActiveSupport::HashWithIndifferentAccess.new) do |resource, acc|
+          acc[resource.name] = resource.preferences
+        end
+      end
+    end
+  end
+end

data/lib/motor/build_schema/reorder_schema.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+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 cache_keys [Hash]
+    # @param schema [Array<HashWithIndifferentAccess>]
+    # @return [Array<HashWithIndifferentAccess>]
+    def call(schema, cache_keys = {})
+      configs = load_configs(cache_keys)
+
+      schema = sort_by_name(schema, configs['resources.order'])
+
+      schema.map { |model| reorder_model(model, configs) }
+    end
+
+    def reorder_model(model, configs)
+      order_configs = build_order_configs(model[:name], configs)
+
+      model.merge(
+        columns: sort_by_name(sort_columns(model[:columns]), order_configs[:columns], sort_alphabetically: false),
+        associations: sort_by_name(model[:associations], order_configs[:associations]),
+        actions: sort_by_name(model[:actions], order_configs[:actions], sort_alphabetically: false),
+        tabs: sort_by_name(model[:tabs], order_configs[:tabs], sort_alphabetically: false),
+        scopes: sort_by_name(model[:scopes], order_configs[:scopes])
+      )
+    end
+
+    def build_order_configs(model_name, configs)
+      {
+        columns: configs["resources.#{model_name}.columns.order"],
+        associations: configs["resources.#{model_name}.associations.order"],
+        actions: configs["resources.#{model_name}.actions.order"],
+        tabs: configs["resources.#{model_name}.tabs.order"],
+        scopes: configs["resources.#{model_name}.scopes.order"]
+      }
+    end
+
+    # @param list [Array<HashWithIndifferentAccess>]
+    # @param sort_alphabetically [Boolean]
+    # @param order [Array<String>]
+    # @return [Array<HashWithIndifferentAccess>]
+    def sort_by_name(list, order, sort_alphabetically: true)
+      return list if order.blank? && !sort_alphabetically
+
+      list.sort_by do |item|
+        if order.present?
+          order.index(item[:name]) || Float::MAX
+        else
+          item[:display_name].to_s
+        end
+      end
+    end
+
+    # @param columns [Array<HashWithIndifferentAccess>]
+    # @return [Array<HashWithIndifferentAccess>]
+    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
+
+    # @param cache_keys [Hash]
+    # @return [Hash<String, HashWithIndifferentAccess>]
+    def load_configs(cache_keys = {})
+      configs = Motor::Configs::LoadFromCache.load_configs(cache_key: cache_keys[:configs])
+
+      configs.each_with_object({}) do |config, acc|
+        acc[config.key] = config.value
+      end
+    end
+  end
+end

data/lib/motor/build_schema/utils.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Motor
+  module BuildSchema
+    module Utils
+      ABBREVIATIONS = {
+        'Id' => 'ID',
+        'Uuid' => 'UUID',
+        'Url' => 'URL',
+        'Iso' => 'ISO',
+        'vip' => 'VIP',
+        'Ip' => 'IP',
+        'Zip' => 'ZIP'
+      }.freeze
+
+      module_function
+
+      def slugify(model)
+        model.name.underscore.pluralize.gsub('/', '__')
+      end
+
+      def classify_slug(slug)
+        slug.singularize.gsub('__', '/').classify.constantize
+      end
+
+      def humanize_column_name(column_name)
+        ABBREVIATIONS.fetch(column_name, column_name.humanize)
+      end
+    end
+  end
+end

data/lib/motor/build_schema.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Motor
+  module BuildSchema
+    module ColumnAccessTypes
+      ALL = [
+        READ_ONLY = 'read_only',
+        WRITE_ONLY = 'write_only',
+        READ_WRITE = 'read_write',
+        HIDDEN = 'hidden'
+      ].freeze
+    end
+
+    module ColumnTypes
+      ALL = [
+        STRING = 'string',
+        INTEGER = 'integer',
+        FLOAT = 'float',
+        REFERENCE = 'reference',
+        DATETIME = 'datetime',
+        DATE = 'date',
+        BOOLEAN = 'boolean',
+        TEXTAREA = 'textarea',
+        RICHTEXT = 'richtext',
+        CURRENCY = 'currency',
+        PERCENTAGE = 'percentage',
+        CHANGE = 'change',
+        CHART = 'chart',
+        TAG = 'tag',
+        LINK = 'link',
+        COLOR = 'color',
+        IMAGE = 'image',
+        FILE = 'file',
+        JSON = 'json'
+      ].freeze
+    end
+
+    module ColumnSources
+      ALL = [
+        TABLE = 'table',
+        QUERY = 'query',
+        REFLECTION = 'reflection'
+      ].freeze
+    end
+
+    SEARCHABLE_COLUMN_TYPES = %i[citext text string bitstring].freeze
+
+    DEFAULT_TYPE = 'default'
+    DEFAULT_ICON = 'database'
+
+    COLUMN_NAME_ACCESS_TYPES = {
+      id: ColumnAccessTypes::READ_ONLY,
+      created_at: ColumnAccessTypes::READ_ONLY,
+      created_on: ColumnAccessTypes::READ_ONLY,
+      inserted_at: ColumnAccessTypes::READ_ONLY,
+      updated_at: ColumnAccessTypes::READ_ONLY,
+      updated_on: ColumnAccessTypes::READ_ONLY,
+      modified_at: ColumnAccessTypes::READ_ONLY,
+      deleted_at: ColumnAccessTypes::READ_ONLY
+    }.with_indifferent_access.freeze
+
+    COLUMN_DEFAULTS = {
+      access_type: ColumnAccessTypes::READ_WRITE,
+      column_source: ColumnSources::TABLE,
+      default_value: nil,
+      reference: nil,
+      format: {},
+      validators: [],
+      description: ''
+    }.with_indifferent_access
+
+    ACTION_DEFAULTS = {
+      visible: true,
+      apply_on: 'member',
+      preferences: {}
+    }.with_indifferent_access
+
+    TAB_DEFAULTS = {
+      visible: true,
+      tab_type: DEFAULT_TYPE,
+      preferences: {}
+    }.with_indifferent_access
+
+    SCOPE_DEFAULTS = {
+      visible: true,
+      scope_type: DEFAULT_TYPE,
+      preferences: {}
+    }.with_indifferent_access
+
+    ASSOCIATION_DEFAULTS = {
+      visible: true,
+      icon: DEFAULT_ICON,
+      options: {}
+    }.with_indifferent_access
+
+    module_function
+
+    def call(cache_keys = {}, current_ability = nil)
+      schema = LoadFromRails.call
+      schema = MergeSchemaConfigs.call(schema, cache_keys)
+      schema = ApplyPermissions.call(schema, current_ability) if current_ability
+
+      ReorderSchema.call(schema, cache_keys)
+    end
+
+    def for_model(model)
+      schema = Motor::BuildSchema::LoadFromRails.build_model_schema(model)
+      configs = Motor::Resource.find_by(name: schema[:name]).preferences
+
+      MergeSchemaConfigs.merge_model(schema, configs)
+    end
+  end
+end
+
+require_relative 'build_schema/active_storage_attachment_schema'
+require_relative 'build_schema/adjust_devise_model_schema'
+require_relative 'build_schema/load_from_rails'
+require_relative 'build_schema/find_display_column'
+require_relative 'build_schema/find_icon'
+require_relative 'build_schema/reorder_schema'
+require_relative 'build_schema/merge_schema_configs'
+require_relative 'build_schema/apply_permissions'
+require_relative 'build_schema/utils'
+require_relative 'build_schema/defaults'
+require_relative 'build_schema/find_searchable_columns'

data/lib/motor/cancan_utils/ability_patch.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Motor
+  module CancanUtils
+    module AbilityPatch
+      def serialized_rules
+        return [] unless @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/cancan_utils.rb

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

data/lib/motor/configs/build_configs_hash.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Motor
+  module Configs
+    module BuildConfigsHash
+      module_function
+
+      def call
+        cache_keys = LoadFromCache.load_cache_keys
+
+        normalize_hash(
+          engine_version: Motor::VERSION,
+          file_version: cache_keys.values.compact.max.to_time,
+          resources: build_resources_hash(cache_keys[:resources]),
+          configs: build_configs_hash(cache_keys[:configs]),
+          queries: build_queries_hash(cache_keys[:queries]),
+          dashboards: build_dashboards_hash(cache_keys[:dashboards]),
+          forms: build_forms_hash(cache_keys[:forms]),
+          alerts: build_alerts_hash(cache_keys[:alerts]),
+          api_configs: build_api_configs_hash(cache_keys[:api_configs])
+        )
+      end
+
+      def build_queries_hash(cache_key = nil)
+        Motor::Configs::LoadFromCache.load_queries(cache_key: cache_key).sort_by(&:id).map do |query|
+          query.slice(%i[id name sql_body description preferences])
+               .merge(tags: query.tags.map(&:name), updated_at: query.updated_at.to_time)
+        end
+      end
+
+      def build_dashboards_hash(cache_key = nil)
+        Motor::Configs::LoadFromCache.load_dashboards(cache_key: cache_key).sort_by(&:id).map do |dashboard|
+          dashboard.slice(%i[id title description preferences])
+                   .merge(tags: dashboard.tags.map(&:name), updated_at: dashboard.updated_at.to_time)
+        end
+      end
+
+      def build_alerts_hash(cache_key = nil)
+        Motor::Configs::LoadFromCache.load_alerts(cache_key: cache_key).sort_by(&:id).map do |alert|
+          alert.slice(%i[id name query_id to_emails is_enabled description preferences])
+               .merge(tags: alert.tags.map(&:name), updated_at: alert.updated_at.to_time)
+        end
+      end
+
+      def build_forms_hash(cache_key = nil)
+        Motor::Configs::LoadFromCache.load_forms(cache_key: cache_key).sort_by(&:id).map do |form|
+          form.slice(%i[id name http_method api_path description preferences api_config_name])
+              .merge(tags: form.tags.map(&:name), updated_at: form.updated_at.to_time)
+        end
+      end
+
+      def build_api_configs_hash(cache_key = nil)
+        Motor::Configs::LoadFromCache.load_api_configs(cache_key: cache_key).sort_by(&:id).map do |config|
+          config.slice(%i[id name url preferences description]).merge(updated_at: config.updated_at.to_time)
+        end
+      end
+
+      def build_configs_hash(cache_key = nil)
+        Motor::Configs::LoadFromCache.load_configs(cache_key: cache_key).sort_by(&:key).map do |config|
+          {
+            key: config.key,
+            value: config.value,
+            updated_at: config.updated_at.to_time
+          }
+        end
+      end
+
+      def build_resources_hash(cache_key = nil)
+        Motor::Configs::LoadFromCache.load_resources(cache_key: cache_key).sort_by(&:name).map do |resource|
+          {
+            name: resource.name,
+            preferences: resource.preferences,
+            updated_at: resource.updated_at.to_time
+          }
+        end
+      end
+
+      def normalize_hash(value)
+        case value
+        when Hash, ActiveSupport::HashWithIndifferentAccess
+          value.to_h.stringify_keys.transform_values { |v| normalize_hash(v) }
+        when Array
+          value.map { |e| normalize_hash(e) }
+        else
+          value
+        end
+      end
+    end
+  end
+end