motor-admin 0.1.34 → 0.1.40

data/lib/generators/motor/templates/install.rb

@@ -13,9 +13,9 @@ class <%= migration_class_name %> < ActiveRecord::Migration[<%= ActiveRecord::Mi
 
       t.index :updated_at
       t.index 'lower(name)',
-        name: 'motor_queries_lower_name_unique_index',
-        unique: true,
-        where: 'deleted_at IS NULL'
+              name: 'motor_queries_lower_name_unique_index',
+              unique: true,
+              where: 'deleted_at IS NULL'
     end
 
     create_table :motor_dashboards, force: true do |t|
@@ -30,9 +30,9 @@ class <%= migration_class_name %> < ActiveRecord::Migration[<%= ActiveRecord::Mi
 
       t.index :updated_at
       t.index 'lower(title)',
-        name: 'motor_dashboards_lower_title_unique_index',
-        unique: true,
-        where: 'deleted_at IS NULL'
+              name: 'motor_dashboards_lower_title_unique_index',
+              unique: true,
+              where: 'deleted_at IS NULL'
     end
 
     create_table :motor_forms, force: true do |t|
@@ -49,9 +49,9 @@ class <%= migration_class_name %> < ActiveRecord::Migration[<%= ActiveRecord::Mi
 
       t.index :updated_at
       t.index 'lower(name)',
-        name: 'motor_forms_lower_name_unique_index',
-        unique: true,
-        where: 'deleted_at IS NULL'
+              name: 'motor_forms_lower_name_unique_index',
+              unique: true,
+              where: 'deleted_at IS NULL'
     end
 
     create_table :motor_resources, force: true do |t|
@@ -87,9 +87,9 @@ class <%= migration_class_name %> < ActiveRecord::Migration[<%= ActiveRecord::Mi
 
       t.index :updated_at
       t.index 'lower(name)',
-        name: 'motor_alerts_lower_name_unique_index',
-        unique: true,
-        where: 'deleted_at IS NULL'
+              name: 'motor_alerts_lower_name_unique_index',
+              unique: true,
+              where: 'deleted_at IS NULL'
     end
 
     create_table :motor_alert_locks, force: true do |t|
@@ -107,8 +107,8 @@ class <%= migration_class_name %> < ActiveRecord::Migration[<%= ActiveRecord::Mi
       t.timestamps
 
       t.index 'lower(name)',
-        name: 'motor_tags_lower_name_unique_index',
-        unique: true
+              name: 'motor_tags_lower_name_unique_index',
+              unique: true
     end
 
     create_table :motor_taggable_tags, force: true do |t|
@@ -117,12 +117,36 @@ class <%= migration_class_name %> < ActiveRecord::Migration[<%= ActiveRecord::Mi
       t.column :taggable_type, :string, null: false
 
       t.index %i[taggable_id taggable_type tag_id],
-        name: 'motor_polymorphic_association_tag_index',
-        unique: true
+              name: 'motor_polymorphic_association_tag_index',
+              unique: true
     end
+
+    create_table :motor_audits, force: true do |t|
+      t.column :auditable_id, :integer
+      t.column :auditable_type, :string
+      t.column :associated_id, :integer
+      t.column :associated_type, :string
+      t.column :user_id, :integer
+      t.column :user_type, :string
+      t.column :username, :string
+      t.column :action, :string
+      t.column :audited_changes, :text
+      t.column :version, :integer, default: 0
+      t.column :comment, :string
+      t.column :remote_address, :string
+      t.column :request_uuid, :string
+      t.column :created_at, :datetime
+    end
+
+    add_index :motor_audits, %i[auditable_type auditable_id version], name: 'motor_auditable_index'
+    add_index :motor_audits, %i[associated_type associated_id], name: 'motor_auditable_associated_index'
+    add_index :motor_audits, %i[user_id user_type], name: 'motor_auditable_user_index'
+    add_index :motor_audits, :request_uuid
+    add_index :motor_audits, :created_at
   end
 
   def self.down
+    drop_table :motor_audits
     drop_table :motor_alert_locks
     drop_table :motor_alerts
     drop_table :motor_taggable_tags

data/lib/motor.rb

@@ -1,11 +1,17 @@
 # frozen_string_literal: true
 
+require 'concurrent/executor/fixed_thread_pool'
+require 'concurrent/timer_task'
 require 'cancancan'
 require 'ar_lazy_preload'
 require 'js_regex'
 require 'fugit'
 require 'csv'
 require 'active_record/filter'
+require 'audited'
+require 'uri'
+require 'net/http'
+require 'net/https'
 
 module Motor
   PATH = Pathname.new(__dir__)
@@ -17,7 +23,8 @@ module Motor
       Dir[PATH.join('./motor/**/*.rb')].each do |f|
         next if f.ends_with?('alerts/scheduler.rb')
         next if f.ends_with?('alerts/scheduled_alerts_cache.rb')
-        next if f.ends_with?('ui_configs.rb')
+        next if f.ends_with?('configs/load_from_cache.rb')
+        next if f.ends_with?('configs/sync_from_file.rb')
 
         load f
       end
@@ -49,10 +56,12 @@ require 'motor/assets'
 require 'motor/build_schema'
 require 'motor/api_query'
 require 'motor/tags'
-require 'motor/ui_configs'
+require 'motor/configs'
 require 'motor/queries'
 require 'motor/dashboards'
 require 'motor/forms'
 require 'motor/alerts'
 require 'motor/hash_serializer'
 require 'motor/active_record_utils'
+require 'motor/net_http_utils'
+require 'motor/railtie'

data/lib/motor/admin.rb

@@ -28,6 +28,14 @@ module Motor
       end
     end
 
+    initializer 'motor.configs.sync_middleware' do
+      next if Motor::Configs::SYNC_ACCESS_KEY.blank?
+
+      require 'motor/configs/sync_middleware'
+
+      Rails.application.config.middleware.insert_after(Rails::Rack::Logger, Motor::Configs::SyncMiddleware)
+    end
+
     initializer 'motor.filter_params' do
       Rails.application.config.filter_parameters += %i[io]
     end

data/lib/motor/alerts/persistance.rb

@@ -43,30 +43,44 @@ module Motor
         retry
       end
 
-      def update_from_params!(alert, params)
+      def update_from_params!(alert, params, force_replace: false)
+        tag_ids = alert.tags.ids
+
         alert = assign_attributes(alert, params)
 
-        raise NameAlreadyExists if name_already_exists?(alert)
+        raise NameAlreadyExists if !force_replace && name_already_exists?(alert)
         raise InvalidInterval unless alert.cron
 
         ApplicationRecord.transaction do
+          archive_with_existing_name(alert) if force_replace
+
           alert.save!
         end
 
-        alert.tags.reload
+        alert.touch if tags_changed?(tag_ids, alert) && params[:updated_at].blank?
 
         alert
       rescue ActiveRecord::RecordNotUnique
         retry
       end
 
+      def tags_changed?(previous_ids, alert)
+        previous_ids.sort != alert.tags.reload.ids.sort
+      end
+
       def assign_attributes(alert, params)
         alert.assign_attributes(params.slice(*ALERT_ATTRIBUTES))
         alert.preferences[:interval] = normalize_interval(alert.preferences[:interval])
+        alert.updated_at = [params[:updated_at], Time.current].min if params[:updated_at].present?
 
         Motor::Tags.assign_tags(alert, params[:tags])
       end
 
+      def archive_with_existing_name(alert)
+        Motor::Alert.where(['lower(name) = ? AND id != ?', alert.name.to_s.downcase, alert.id])
+                    .update_all(deleted_at: Time.current)
+      end
+
       def normalize_interval(interval)
         interval.to_s.gsub(NORMALIZE_INTERVAL_REGEXP, 'every ')
       end

data/lib/motor/alerts/scheduler.rb

@@ -22,7 +22,7 @@ module Motor
             Motor::AlertSendingJob.perform_later(alert).job_id
           end
         rescue StandardError => e
-          Rials.logger.error(e)
+          Rails.logger.error(e)
         end
       end
     end

data/lib/motor/api_query/sort.rb

@@ -13,7 +13,7 @@ module Motor
         arel_order = build_arel_order(rel.klass, param)
         join_params = build_join_params(rel.klass, param)
 
-        rel.order(arel_order).left_joins(join_params)
+        rel.reorder(arel_order).left_joins(join_params)
       end
 
       def build_join_params(_model, param)

data/lib/motor/build_schema.rb

@@ -58,11 +58,11 @@ module Motor
 
     module_function
 
-    def call
+    def call(cache_keys = {})
       schema = LoadFromRails.call
-      schema = MergeSchemaConfigs.call(schema)
+      schema = MergeSchemaConfigs.call(schema, cache_keys)
 
-      ReorderSchema.call(schema)
+      ReorderSchema.call(schema, cache_keys)
     end
   end
 end

data/lib/motor/build_schema/load_from_rails.rb

@@ -11,7 +11,7 @@ module Motor
         models.map do |model|
           build_model_schema(model)
         rescue StandardError, NotImplementedError => e
-          Rails.logger.error(e)
+          Rails.logger.error(e) if model.name != 'Audited::Audit'
 
           next
         end.compact
@@ -24,6 +24,7 @@ module Motor
         models = models.reject(&:abstract_class)
 
         models -= Motor::ApplicationRecord.descendants
+        models -= [Motor::Audit]
         models -= [ActiveRecord::SchemaMigration] if defined?(ActiveRecord::SchemaMigration)
         models -= [ActiveStorage::Blob] if defined?(ActiveStorage::Blob)
         models -= [ActiveStorage::VariantRecord] if defined?(ActiveStorage::VariantRecord)

data/lib/motor/build_schema/merge_schema_configs.rb

@@ -12,9 +12,10 @@ module Motor
       module_function
 
       # @param schema [Array<HashWithIndifferentAccess>]
+      # @param cache_keys [Hash]
       # @return [Array<HashWithIndifferentAccess>]
-      def call(schema)
-        configs = load_configs
+      def call(schema, cache_keys = {})
+        configs = load_configs(cache_keys)
 
         schema.map do |model|
           merge_model(model, configs.fetch(model[:name], {}))
@@ -120,9 +121,12 @@ module Motor
         end.compact
       end
 
+      # @param cache_keys [Hash]
       # @return [HashWithIndifferentAccess<String, HashWithIndifferentAccess>]
-      def load_configs
-        Motor::Resource.all.each_with_object(HashWithIndifferentAccess.new) do |resource, acc|
+      def load_configs(cache_keys)
+        resources = Motor::Configs::LoadFromCache.load_resources(cache_key: cache_keys[:resources])
+
+        resources.each_with_object(HashWithIndifferentAccess.new) do |resource, acc|
           acc[resource.name] = resource.preferences
         end
       end

data/lib/motor/build_schema/reorder_schema.rb

@@ -16,10 +16,11 @@ module Motor
 
     module_function
 
+    # @param cache_keys [Hash]
     # @param schema [Array<HashWithIndifferentAccess>]
     # @return [Array<HashWithIndifferentAccess>]
-    def call(schema)
-      configs = load_configs
+    def call(schema, cache_keys = {})
+      configs = load_configs(cache_keys)
 
       schema = sort_by_name(schema, configs['resources.order'])
 
@@ -64,6 +65,8 @@ module Motor
       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)
@@ -72,9 +75,12 @@ module Motor
       end.flatten.compact
     end
 
+    # @param cache_keys [Hash]
     # @return [Hash<String, HashWithIndifferentAccess>]
-    def load_configs
-      Motor::Config.all.each_with_object({}) do |config, acc|
+    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

data/lib/motor/configs.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Motor
+  module Configs
+    FILE_PATH = 'config/motor.yml'
+    SYNC_API_PATH = '/motor_configs_sync'
+    SYNC_ACCESS_KEY = ENV.fetch('MOTOR_SYNC_API_KEY', '')
+  end
+end
+
+require_relative './configs/load_from_cache'
+require_relative './configs/build_ui_app_tag'
+require_relative './configs/build_configs_hash'
+require_relative './configs/write_to_file'
+require_relative './configs/sync_from_hash'
+require_relative './configs/sync_from_file'
+require_relative './configs/sync_with_remote'

data/lib/motor/configs/build_configs_hash.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Motor
+  module Configs
+    module BuildConfigsHash
+      module_function
+
+      def call
+        cache_keys = LoadFromCache.load_cache_keys
+
+        normalize_hash(
+          app_version: Motor::VERSION,
+          file_version: cache_keys.values.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])
+        )
+      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])
+              .merge(tags: form.tags.map(&:name), updated_at: form.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, 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

data/lib/motor/configs/build_ui_app_tag.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Motor
+  module Configs
+    module BuildUiAppTag
+      CACHE_STORE =
+        if Motor.development?
+          ActiveSupport::Cache::NullStore.new
+        else
+          ActiveSupport::Cache::MemoryStore.new(size: 5.megabytes)
+        end
+
+      module_function
+
+      def call
+        cache_keys = LoadFromCache.load_cache_keys
+
+        CACHE_STORE.fetch(cache_keys.hash) do
+          CACHE_STORE.clear
+
+          Motor::ApplicationController.helpers.content_tag(
+            :div, '', id: 'app', data: build_data(cache_keys)
+          )
+        end
+      end
+
+      # @return [Hash]
+      def build_data(cache_keys = {})
+        {
+          base_path: Motor::Admin.routes.url_helpers.motor_path,
+          schema: Motor::BuildSchema.call(cache_keys),
+          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])
+        }
+      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)
+                                     .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)
+                                     .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)
+                                     .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)
+                                     .as_json(only: %i[id name updated_at],
+                                              include: { tags: { only: %i[id name] } })
+      end
+    end
+  end
+end