motor-admin-cstham8 0.4.35

data/lib/motor/configs/build_ui_app_tag.rb

@@ -0,0 +1,177 @@
+# 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(current_user = nil, current_ability = nil, cache_keys: LoadFromCache.load_cache_keys)
+        CACHE_STORE.fetch(app_tag_cache_key(cache_keys, current_user, current_ability)) do
+          CACHE_STORE.clear
+
+          data = build_data(cache_keys, current_user, current_ability)
+          Motor::ApplicationController.helpers.tag.div('', id: 'app', data: data)
+        end
+      end
+
+      def app_tag_cache_key(cache_keys, current_user, current_ability)
+        key = "#{I18n.locale}#{cache_keys.hash}#{current_user&.id}#{current_ability&.rules_hash}"
+
+        key += Motor::DefineArModels.defined_models_schema_md5.to_s if defined?(Motor::DefineArModels)
+
+        if Rails.env.development?
+          key += Digest::MD5.hexdigest(ActiveRecord::Base.descendants.map(&:object_id).sort.join)
+        end
+
+        key
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
+      # @return [Hash]
+      def build_data(cache_keys = {}, current_user = nil, current_ability = nil)
+        configs_cache_key = cache_keys[:configs]
+
+        { version: Motor::VERSION,
+          current_user: serialize_current_user(current_user),
+          current_rules: current_ability.serialized_rules,
+          audits_count: Motor::Audit.count,
+          i18n: i18n_data,
+          base_path: Motor::Admin.routes.url_helpers.motor_path,
+          cable_path: Motor::Admin.routes.url_helpers.try(:motor_cable_path),
+          admin_settings_path: Rails.application.routes.url_helpers.try(:admin_settings_general_path),
+          active_storage_direct_uploads_enabled: ENV['MOTOR_ACTIVE_STORAGE_DIRECT_UPLOADS_ENABLED'].present?,
+          schema: Motor::BuildSchema.call(cache_keys, current_ability),
+          header_links: header_links_data_hash(current_user, current_ability, configs_cache_key),
+          homepage_layout: homepage_layout_data_hash(configs_cache_key),
+          databases: database_names,
+          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
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
+
+      def i18n_data
+        I18n.t('motor', default: I18n.t('motor', locale: :en))
+      end
+
+      def serialize_current_user(user)
+        return unless user
+
+        attrs = user.as_json(only: %i[id email first_name last_name])
+
+        attrs['role'] = user.role if user.respond_to?(:role)
+        attrs['role_names'] = user.role_names if user.respond_to?(:role_names)
+
+        attrs
+      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(current_user, current_ability, cache_key = nil)
+        configs = Motor::Configs::LoadFromCache.load_configs(cache_key: cache_key)
+
+        links = configs.find { |c| c.key == 'header.links' }&.value || []
+        links = add_default_links(links)
+
+        return links unless current_user
+        return links if current_ability.can?(:manage, :all)
+
+        filter_links_for_user(current_user, links)
+      end
+
+      def add_default_links(links)
+        new_links = links.clone
+
+        unless links.find { |l| l['link_type'] == 'forms' }
+          new_links.unshift({ 'name' => I18n.t('motor.forms'), 'link_type' => 'forms' })
+        end
+
+        unless links.find { |l| l['link_type'] == 'reports' }
+          new_links.unshift({ 'name' => I18n.t('motor.reports'), 'link_type' => 'reports' })
+        end
+
+        new_links
+      end
+
+      def filter_links_for_user(current_user, links)
+        links.select do |link|
+          conditions = link['conditions']
+
+          next true if conditions.blank?
+
+          conditions.all? do |cond|
+            field_name =
+              if cond['field'] == 'role' && !current_user.respond_to?(:role)
+                :role_names
+              else
+                cond['field'].to_sym
+              end
+
+            next false unless field_name.in?(%i[email role role_names])
+            next false unless current_user.respond_to?(field_name)
+
+            Array.wrap(current_user.public_send(field_name)).intersection(Array.wrap(cond['value'])).present?
+          end
+        end
+      end
+
+      def homepage_layout_data_hash(cache_key = nil)
+        configs = Motor::Configs::LoadFromCache.load_configs(cache_key: cache_key)
+
+        configs.find { |c| c.key == 'homepage.layout' }&.value || []
+      end
+
+      def database_names
+        if defined?(Motor::EncryptedConfig)
+          Motor::DatabaseClasses.constants.map { |e| e.to_s.titleize }
+        elsif ActiveRecord::Base.configurations.try(:configurations)
+          ActiveRecord::Base.configurations.configurations
+                            .select { |c| c.env_name == Rails.env }
+                            .map { |c| c.try(:name) || c.try(:spec_name) }.compact
+        else
+          ['primary']
+        end
+      end
+
+      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, 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, 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, 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
+    end
+  end
+end

data/lib/motor/configs/load_from_cache.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Motor
+  module Configs
+    module LoadFromCache
+      CACHE_HASH = ActiveSupport::HashWithIndifferentAccess.new
+
+      module_function
+
+      def call
+        cache_keys = load_cache_keys
+
+        {
+          configs: load_configs(cache_key: cache_keys[:configs]),
+          resources: load_resources(cache_key: cache_keys[:resources]),
+          queries: load_queries(cache_key: cache_keys[:queries]),
+          dashboards: load_dashboards(cache_key: cache_keys[:dashboards]),
+          alerts: load_alerts(cache_key: cache_keys[:alerts]),
+          forms: load_forms(cache_key: cache_keys[:forms])
+        }
+      end
+
+      def load_configs(cache_key: nil)
+        maybe_fetch_from_cache('configs', cache_key) do
+          Motor::Config.all.load
+        end
+      end
+
+      def load_resources(cache_key: nil)
+        maybe_fetch_from_cache('resources', cache_key) do
+          Motor::Resource.all.load
+        end
+      end
+
+      def load_queries(cache_key: nil, current_ability: nil)
+        maybe_fetch_from_cache('queries', cache_key) do
+          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, current_ability: nil)
+        maybe_fetch_from_cache('dashboards', cache_key) do
+          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, current_ability: nil)
+        maybe_fetch_from_cache('alerts', cache_key) do
+          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, current_ability: nil)
+        maybe_fetch_from_cache('forms', cache_key) do
+          rel = Motor::Form.all.active.preload(:tags)
+          rel = rel.accessible_by(current_ability) if current_ability
+
+          rel.load
+        end
+      end
+
+      def load_api_configs(cache_key: nil)
+        maybe_fetch_from_cache('forms', cache_key) do
+          Motor::ApiConfig.all.active.load
+        end
+      end
+
+      def maybe_fetch_from_cache(type, cache_key)
+        return yield unless cache_key
+
+        if CACHE_HASH[type] && CACHE_HASH[type][:key] == cache_key
+          CACHE_HASH[type][:value]
+        else
+          result = yield
+
+          CACHE_HASH[type] = { key: cache_key, value: result }
+
+          result
+        end
+      end
+
+      def load_cache_keys
+        result = ActiveRecord::Base.connection.exec_query(cache_keys_sql).rows
+
+        result.to_h.with_indifferent_access
+      end
+
+      def cache_keys_sql
+        [
+          Motor::Config.select("'configs', MAX(updated_at)").to_sql,
+          Motor::Resource.select("'resources', MAX(updated_at)").to_sql,
+          Motor::Dashboard.select("'dashboards', MAX(updated_at)").to_sql,
+          Motor::Alert.select("'alerts', MAX(updated_at)").to_sql,
+          Motor::Query.select("'queries', MAX(updated_at)").to_sql,
+          Motor::Form.select("'forms', MAX(updated_at)").to_sql,
+          Motor::ApiConfig.select("'api_configs', MAX(updated_at)").to_sql
+        ].join(' UNION ')
+      end
+    end
+  end
+end

data/lib/motor/configs/sync_from_file.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Motor
+  module Configs
+    module SyncFromFile
+      MUTEXT = Mutex.new
+      FILE_TIMESTAMPS_STORE = ActiveSupport::Cache::MemoryStore.new(size: 1.megabyte)
+
+      module_function
+
+      def call(with_exception: false)
+        MUTEXT.synchronize do
+          file = Pathname.new(Motor::Configs.file_path)
+
+          file_timestamp =
+            begin
+              file.ctime
+            rescue Errno::ENOENT
+              raise if with_exception
+
+              nil
+            end
+
+          next unless file_timestamp
+
+          FILE_TIMESTAMPS_STORE.fetch(file_timestamp.to_s) do
+            Motor::Configs::SyncFromHash.call(
+              YAML.safe_load(file.read, permitted_classes: [Time, Date])
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/motor/configs/sync_from_hash.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Motor
+  module Configs
+    module SyncFromHash
+      module_function
+
+      def call(configs_hash)
+        return if configs_hash.blank?
+
+        configs_hash = configs_hash.with_indifferent_access
+
+        Motor::ApplicationRecord.transaction do
+          sync_queries(configs_hash)
+          sync_alerts(configs_hash)
+          sync_dashboards(configs_hash)
+          sync_forms(configs_hash)
+          sync_configs(configs_hash)
+          sync_resources(configs_hash)
+          sync_api_configs(configs_hash)
+        end
+      end
+
+      def sync_queries(configs_hash)
+        sync_taggable(
+          Motor::Configs::LoadFromCache.load_queries,
+          configs_hash[:queries],
+          configs_hash[:file_version],
+          Motor::Queries::Persistance.method(:update_from_params!)
+        )
+      end
+
+      def sync_alerts(configs_hash)
+        sync_taggable(
+          Motor::Configs::LoadFromCache.load_alerts,
+          configs_hash[:alerts],
+          configs_hash[:file_version],
+          Motor::Alerts::Persistance.method(:update_from_params!)
+        )
+      end
+
+      def sync_forms(configs_hash)
+        sync_taggable(
+          Motor::Configs::LoadFromCache.load_forms,
+          configs_hash[:forms],
+          configs_hash[:file_version],
+          Motor::Forms::Persistance.method(:update_from_params!)
+        )
+      end
+
+      def sync_dashboards(configs_hash)
+        sync_taggable(
+          Motor::Configs::LoadFromCache.load_dashboards,
+          configs_hash[:dashboards],
+          configs_hash[:file_version],
+          Motor::Dashboards::Persistance.method(:update_from_params!)
+        )
+      end
+
+      def sync_configs(configs_hash)
+        configs_index = Motor::Configs::LoadFromCache.load_configs.index_by(&:key)
+
+        configs_hash[:configs].each do |attrs|
+          record = configs_index[attrs[:key]] || Motor::Config.new
+
+          next if record.updated_at && attrs[:updated_at] <= record.updated_at
+
+          record.update!(attrs)
+        end
+
+        ActiveRecordUtils.reset_id_sequence!(Motor::Config)
+      end
+
+      def sync_api_configs(configs_hash)
+        return if configs_hash[:api_configs].blank?
+
+        configs_index = Motor::Configs::LoadFromCache.load_api_configs.index_by(&:name)
+
+        configs_hash[:api_configs].each do |attrs|
+          record = configs_index[attrs[:name]] || Motor::ApiConfig.new
+
+          next if record.updated_at && attrs[:updated_at] <= record.updated_at
+
+          record.update!(attrs.merge(deleted_at: nil))
+        end
+
+        archive_api_configs(configs_index, configs_hash[:api_configs])
+
+        ActiveRecordUtils.reset_id_sequence!(Motor::ApiConfig)
+      end
+
+      def archive_api_configs(configs_index, api_configs)
+        configs_index.except(*api_configs.pluck('name')).each_value do |config|
+          config.update!(deleted_at: Time.current) if config.deleted_at.blank?
+        end
+      end
+
+      def sync_resources(configs_hash)
+        resources_index = Motor::Configs::LoadFromCache.load_resources.index_by(&:name)
+
+        configs_hash[:resources].each do |attrs|
+          record = resources_index.fetch(attrs[:name], Motor::Resource.new)
+
+          next if record.updated_at && attrs[:updated_at] < record.updated_at
+          next if record.updated_at &&
+                  attrs[:updated_at] == record.updated_at &&
+                  attrs[:preferences] == record.preferences
+
+          record.updated_at_will_change!
+          record.update!(attrs)
+        end
+
+        ActiveRecordUtils.reset_id_sequence!(Motor::Resource)
+      end
+
+      def sync_taggable(records, config_items, configs_timestamp, update_proc)
+        processed_records, create_items = update_taggable_items(records, config_items, update_proc)
+
+        create_taggable_items(create_items, records.klass, update_proc)
+
+        archive_taggable_items(records - processed_records, configs_timestamp)
+
+        ActiveRecordUtils.reset_id_sequence!(records.klass)
+      end
+
+      def update_taggable_items(records, config_items, update_proc)
+        record_ids_hash = records.index_by(&:id)
+
+        config_items.each_with_object([[], []]) do |attrs, (processed_acc, create_acc)|
+          record = record_ids_hash[attrs[:id]]
+
+          next create_acc << attrs unless record
+
+          processed_acc << record if record
+
+          next if record.updated_at >= attrs[:updated_at]
+
+          update_proc.call(record, attrs, force_replace: true)
+        end
+      end
+
+      def create_taggable_items(create_items, records_class, update_proc)
+        create_items.each do |attrs|
+          record = records_class.find_or_initialize_by(id: attrs[:id]).tap { |e| e.deleted_at = nil }
+
+          update_proc.call(record, attrs, force_replace: true)
+        end
+      end
+
+      def archive_taggable_items(records_to_remove, configs_timestamp)
+        records_to_remove.each do |record|
+          next if record.updated_at > configs_timestamp
+
+          record.update!(deleted_at: Time.current) if record.deleted_at.blank?
+        end
+      end
+    end
+  end
+end

data/lib/motor/configs/sync_middleware.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Motor
+  module Configs
+    class SyncMiddleware
+      KeyNotSpecified = Class.new(StandardError)
+      NotAuthenticated = Class.new(StandardError)
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        if env['PATH_INFO'] == Motor::Configs::SYNC_API_PATH
+          authenticate!(env['HTTP_X_AUTHORIZATION'])
+
+          case env['REQUEST_METHOD']
+          when 'GET'
+            respond_with_configs
+          when 'POST'
+            input = env['rack.input']
+            input.rewind
+            sync_configs(input.read)
+          else
+            @app.call(env)
+          end
+        else
+          @app.call(env)
+        end
+      rescue NotAuthenticated
+        [403, {}, ['Invalid synchronization API key']]
+      rescue KeyNotSpecified
+        [404, {}, ['Set `MOTOR_SYNC_API_KEY` environment variable in order to sync configs']]
+      end
+
+      private
+
+      def authenticate!(token)
+        raise KeyNotSpecified if Motor::Configs::SYNC_ACCESS_KEY.blank?
+        raise NotAuthenticated if token.blank?
+
+        is_token_valid =
+          ActiveSupport::SecurityUtils.secure_compare(
+            Digest::SHA256.hexdigest(token),
+            Digest::SHA256.hexdigest(Motor::Configs::SYNC_ACCESS_KEY)
+          )
+
+        raise NotAuthenticated unless is_token_valid
+      end
+
+      def respond_with_configs
+        [
+          200,
+          { 'Content-Type' => 'application/json' },
+          [Motor::Configs::BuildConfigsHash.call.to_json]
+        ]
+      rescue StandardError => e
+        [500, {}, [e.message]]
+      end
+
+      def sync_configs(body)
+        configs_hash = JSON.parse(body)
+
+        Motor::Configs::SyncFromHash.call(configs_hash)
+
+        [200, {}, []]
+      rescue StandardError => e
+        [500, {}, [e.message]]
+      end
+    end
+  end
+end

data/lib/motor/configs/sync_with_remote.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Motor
+  module Configs
+    module SyncWithRemote
+      UnableToSync = Class.new(StandardError)
+      ApiNotFound = Class.new(StandardError)
+
+      module_function
+
+      def call(remote_url, api_key)
+        url = remote_url.delete_suffix('/') + Motor::Configs::SYNC_API_PATH
+
+        sync_from_remote!(url, api_key)
+        sync_to_remote!(url, api_key)
+      end
+
+      def sync_from_remote!(remote_url, api_key)
+        response = Motor::NetHttpUtils.get(remote_url, {}, { 'X-Authorization' => api_key })
+
+        raise ApiNotFound if response.is_a?(Net::HTTPNotFound)
+        raise UnableToSync, [response.message, response.body].join(': ') unless response.is_a?(Net::HTTPSuccess)
+
+        configs_hash = JSON.parse(response.body)
+
+        Motor::Configs::SyncFromHash.call(configs_hash)
+      end
+
+      def sync_to_remote!(remote_url, api_key)
+        configs_hash = Motor::Configs::BuildConfigsHash.call
+
+        response = Motor::NetHttpUtils.post(
+          remote_url,
+          {},
+          {
+            'X-Authorization' => api_key,
+            'Content-Type' => 'application/json'
+          },
+          configs_hash.to_json
+        )
+
+        raise ApiNotFound if response.is_a?(Net::HTTPNotFound)
+        raise UnableToSync, [response.message, response.body].join(': ') unless response.is_a?(Net::HTTPSuccess)
+      end
+    end
+  end
+end

data/lib/motor/configs/write_to_file.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Motor
+  module Configs
+    module WriteToFile
+      THREAD_POOL = Concurrent::FixedThreadPool.new(1)
+
+      module_function
+
+      def call
+        return if Rails.env.test?
+        return if THREAD_POOL.queue_length.positive?
+
+        THREAD_POOL.post do
+          ActiveRecord::Base.logger.silence do
+            write_with_lock
+          end
+        rescue StandardError => e
+          Rails.logger.error(e)
+        end
+      end
+
+      def write_with_lock
+        File.open(Motor::Configs.file_path, 'w') do |file|
+          file.flock(File::LOCK_EX)
+
+          YAML.dump(Motor::Configs::BuildConfigsHash.call, file)
+
+          file.flock(File::LOCK_UN)
+
+          file
+        end.close
+      end
+    end
+  end
+end

data/lib/motor/configs.rb

@@ -0,0 +1,39 @@
+# 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', '')
+    WORKDIR_FILE_NAME = 'motor-admin.yml'
+
+    module_function
+
+    def clear
+      Motor::Resource.destroy_all
+      Motor::Alert.destroy_all
+      Motor::Query.destroy_all
+      Motor::Dashboard.destroy_all
+      Motor::Form.destroy_all
+      Motor::ApiConfig.destroy_all
+      Motor::Config.destroy_all
+    end
+
+    # @return [String]
+    def file_path
+      if defined?(MotorAdmin::Application)
+        [ENV['WORKDIR'], WORKDIR_FILE_NAME].compact.join('/')
+      else
+        Rails.root.join(FILE_PATH).to_s
+      end
+    end
+  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'