motor-admin-cstham8 0.4.35

data/lib/motor/resources/persist_configs.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+module Motor
+  module Resources
+    module PersistConfigs
+      COLUMN_DEFAULTS = BuildSchema::COLUMN_DEFAULTS
+      ACTION_DEFAULTS = BuildSchema::ACTION_DEFAULTS
+      TAB_DEFAULTS = BuildSchema::TAB_DEFAULTS
+      SCOPE_DEFAULTS = BuildSchema::SCOPE_DEFAULTS
+      ASSOCIATION_DEFAULTS = BuildSchema::ASSOCIATION_DEFAULTS
+
+      module_function
+
+      # @param resource [Motor::Resource]
+      # @return [Motor::Resource]
+      def call(resource)
+        preferences = resource.preferences
+
+        resource = Motor::Resource.find_or_initialize_by(name: resource.name)
+
+        assign_preferences!(resource, preferences)
+
+        resource.save!
+
+        resource
+      rescue ActiveRecord::RecordNotUnique
+        retry
+      end
+
+      # @param resource [Motor::Resource]
+      # @param preferences [HashWithIndifferentAccess]
+      # @return [Motor::Resource]
+      def assign_preferences!(resource, preferences)
+        default_schema = fetch_default_schema(resource.name)
+
+        resource.preferences = normalize_preferences(
+          default_schema,
+          resource.preferences,
+          preferences
+        )
+
+        resource
+      end
+
+      # @param default_prefs [HashWithIndifferentAccess]
+      # @param existing_prefs [HashWithIndifferentAccess]
+      # @param new_prefs [HashWithIndifferentAccess]
+      # @return [HashWithIndifferentAccess]
+      def normalize_preferences(default_prefs, existing_prefs, new_prefs)
+        normalized_preferences = new_prefs.slice(*RESOURCE_ATTRS).with_indifferent_access
+        normalized_preferences = existing_prefs.merge(normalized_preferences)
+        normalized_preferences = reject_default(default_prefs, normalized_preferences)
+
+        normalize_configs!(normalized_preferences, :columns, default_prefs, existing_prefs, new_prefs)
+        normalize_configs!(normalized_preferences, :associations, default_prefs, existing_prefs, new_prefs)
+        normalize_configs!(normalized_preferences, :actions, default_prefs, existing_prefs, new_prefs)
+        normalize_configs!(normalized_preferences, :tabs, default_prefs, existing_prefs, new_prefs)
+        normalize_configs!(normalized_preferences, :scopes, default_prefs, existing_prefs, new_prefs)
+
+        normalized_preferences.compact
+      end
+
+      def normalize_configs!(preferences, configs_name, default_prefs, existing_prefs, new_prefs)
+        return preferences if new_prefs[configs_name].blank?
+
+        normalized_configs = public_send(:"normalize_#{configs_name}",
+                                         default_prefs[configs_name],
+                                         existing_prefs.fetch(configs_name, []),
+                                         new_prefs.fetch(configs_name, []))
+
+        preferences[configs_name] = normalized_configs
+
+        preferences
+      end
+
+      # @param default_columns [Array<HashWithIndifferentAccess>]
+      # @param existing_columns [Array<HashWithIndifferentAccess>]
+      # @param new_columns [Array<HashWithIndifferentAccess>]
+      # @return [Array<HashWithIndifferentAccess>]
+      def normalize_columns(default_columns, existing_columns, new_columns)
+        fetch_update_names(existing_columns, new_columns).uniq.map do |name|
+          new_column = safe_fetch_by_name(new_columns, name)
+
+          next if new_column[:_remove]
+
+          existing_column = safe_fetch_by_name(existing_columns, name)
+          default_column = safe_fetch_by_name(default_columns, name)
+          column_attrs = new_column.slice(*COLUMN_ATTRS)
+
+          normalized_column = existing_column.merge(column_attrs)
+          normalized_column = reject_default(default_column, normalized_column)
+
+          next if normalized_column.blank?
+
+          normalized_column[:name] ||= name
+
+          normalized_column
+        end.compact.presence
+      end
+
+      # @param default_actions [Array<HashWithIndifferentAccess>]
+      # @param existing_actions [Array<HashWithIndifferentAccess>]
+      # @param new_actions [Array<HashWithIndifferentAccess>]
+      # @return [Array<HashWithIndifferentAccess>]
+      def normalize_actions(default_actions, existing_actions, new_actions)
+        fetch_update_names(existing_actions, new_actions).map do |name|
+          new_action = safe_fetch_by_name(new_actions, name)
+
+          next if new_action[:_remove]
+
+          existing_action = safe_fetch_by_name(existing_actions, name)
+          default_action = safe_fetch_by_name(default_actions, name)
+          action_attrs = new_action.slice(*ACTION_ATTRS)
+
+          normalized_action = existing_action.merge(action_attrs)
+          normalized_action = reject_default(default_action.presence || ACTION_DEFAULTS, normalized_action)
+
+          next if normalized_action.blank?
+
+          normalized_action[:name] ||= name
+
+          normalized_action
+        end.compact.presence
+      end
+
+      # @param default_tabs [Array<HashWithIndifferentAccess>]
+      # @param existing_tabs [Array<HashWithIndifferentAccess>]
+      # @param new_tabs [Array<HashWithIndifferentAccess>]
+      # @return [Array<HashWithIndifferentAccess>]
+      def normalize_tabs(default_tabs, existing_tabs, new_tabs)
+        fetch_update_names(existing_tabs, new_tabs).uniq.map do |name|
+          new_tab = safe_fetch_by_name(new_tabs, name)
+
+          next if new_tab[:_remove]
+
+          existing_tab = safe_fetch_by_name(existing_tabs, name)
+          default_tab = safe_fetch_by_name(default_tabs, name)
+          tab_attrs = new_tab.slice(*TAB_ATTRS)
+
+          normalized_tab = existing_tab.merge(tab_attrs)
+          normalized_tab = reject_default(default_tab.presence || TAB_DEFAULTS, normalized_tab)
+
+          next if normalized_tab.blank?
+
+          normalized_tab[:name] ||= name
+
+          normalized_tab
+        end.compact.presence
+      end
+
+      # @param default_scopes [Array<HashWithIndifferentAccess>]
+      # @param existing_scopes [Array<HashWithIndifferentAccess>]
+      # @param new_scopes [Array<HashWithIndifferentAccess>]
+      # @return [Array<HashWithIndifferentAccess>]
+      def normalize_scopes(default_scopes, existing_scopes, new_scopes)
+        fetch_update_names(existing_scopes, new_scopes).uniq.map do |name|
+          new_scope = safe_fetch_by_name(new_scopes, name)
+
+          next if new_scope[:_remove]
+
+          existing_scope = safe_fetch_by_name(existing_scopes, name)
+          default_scope = safe_fetch_by_name(default_scopes, name)
+          scope_attrs = new_scope.slice(*SCOPE_ATTRS)
+
+          normalized_scope = existing_scope.merge(scope_attrs)
+          normalized_scope = reject_default(default_scope.presence || SCOPE_DEFAULTS, normalized_scope)
+
+          next if normalized_scope.blank?
+
+          normalized_scope[:name] ||= name
+
+          normalized_scope
+        end.compact.presence
+      end
+
+      # @param default_assocs [Array<HashWithIndifferentAccess>]
+      # @param existing_assocs [Array<HashWithIndifferentAccess>]
+      # @param new_assocs [Array<HashWithIndifferentAccess>]
+      # @return [Array<HashWithIndifferentAccess>]
+      def normalize_associations(default_assocs, existing_assocs, new_assocs)
+        (existing_assocs.pluck(:name) + new_assocs.pluck(:name)).uniq.map do |name|
+          new_assoc = safe_fetch_by_name(new_assocs, name)
+
+          next if new_assoc[:_remove]
+
+          existing_assoc = safe_fetch_by_name(existing_assocs, name)
+          default_assoc = safe_fetch_by_name(default_assocs, name)
+          assoc_attrs = new_assoc.slice(*ASSOCIATION_ATTRS)
+
+          normalized_assoc = existing_assoc.merge(assoc_attrs)
+          normalized_assoc = reject_default(default_assoc.presence || ASSOCIATION_DEFAULTS, normalized_assoc)
+
+          normalized_assoc.merge(name: name) if normalized_assoc.present?
+        end.compact.presence
+      end
+
+      def fetch_update_names(existing_items, new_items)
+        new_names = new_items.map { |e| e[:_update] || e[:name] }
+
+        (existing_items.pluck(:name) + new_names).uniq
+      end
+
+      def safe_fetch_by_name(list, name)
+        list.find { |e| e[:_update] == name || e[:name] == name } || {}
+      end
+
+      # @param resource_name [String]
+      # @return [HashWithIndifferentAccess]
+      def fetch_default_schema(resource_name)
+        model = resource_name.classify.constantize
+
+        BuildSchema::LoadFromRails.build_model_schema(model).merge(custom_sql: model.all.to_sql)
+      end
+
+      # @param default [HashWithIndifferentAccess]
+      # @param new [HashWithIndifferentAccess]
+      # @return [HashWithIndifferentAccess]
+      def reject_default(default, new)
+        return new unless default
+
+        new.reject do |key, value|
+          default[key].to_json ==
+            if value.is_a?(Hash) || value.is_a?(ActiveSupport::HashWithIndifferentAccess)
+              value.select { |_, v| v.present? }.to_json
+            else
+              value.to_json
+            end
+        end
+      end
+    end
+  end
+end

data/lib/motor/resources.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Motor
+  module Resources
+    RESOURCE_ATTRS = %w[display_name display_column icon custom_sql visible display_primary_key
+                        searchable_columns preferences].freeze
+    COLUMN_ATTRS = %w[name display_name column_type access_type default_value reference virtual format
+                      validators description].freeze
+    ASSOCIATION_ATTRS = %w[name display_name model_name icon visible foreign_key primary_key options virtual
+                           polymorphic slug].freeze
+    SCOPE_ATTRS = %w[name display_name scope_type preferences visible].freeze
+    ACTION_ATTRS = %w[name display_name action_type preferences apply_on visible].freeze
+    TAB_ATTRS = %w[name display_name tab_type preferences visible].freeze
+  end
+end
+
+require_relative 'resources/fetch_configured_model'
+require_relative 'resources/persist_configs'
+require_relative 'resources/custom_sql_columns_cache'

data/lib/motor/slack/client.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Motor
+  module Slack
+    module Client
+      BASE_API_URL = 'https://slack.com/api'
+      POST_MESSAGE_ENPOINT = "#{BASE_API_URL}/chat.postMessage"
+      LOAD_CONVERSATIONS_ENPOINT = "#{BASE_API_URL}/conversations.list"
+      LOAD_USERS_ENPOINT = "#{BASE_API_URL}/users.list"
+      SEND_FILE_ENPOINT = "#{BASE_API_URL}/files.upload"
+
+      ApiError = Class.new(StandardError)
+
+      module_function
+
+      def send_message(params = {})
+        resp = Motor::NetHttpUtils.post(POST_MESSAGE_ENPOINT, params.merge(token: auth_token))
+
+        parse_json_response_or_throw_error(resp)
+      end
+
+      def send_file(params = {})
+        content = params.delete(:content)
+        body = { content: content }.to_query
+
+        resp = Motor::NetHttpUtils.post(SEND_FILE_ENPOINT, params.merge(token: auth_token), {}, body)
+
+        parse_json_response_or_throw_error(resp)
+      end
+
+      def load_conversations(params = {})
+        resp = Motor::NetHttpUtils.get(LOAD_CONVERSATIONS_ENPOINT, params.merge(token: auth_token))
+
+        parse_json_response_or_throw_error(resp)
+      end
+
+      def load_users(params = {})
+        resp = Motor::NetHttpUtils.get(LOAD_USERS_ENPOINT, params.merge(token: auth_token))
+
+        parse_json_response_or_throw_error(resp)
+      end
+
+      def parse_json_response_or_throw_error(resp)
+        data = JSON.parse(resp.body)
+
+        raise ApiError, resp.body unless data['ok']
+
+        data
+      end
+
+      def auth_token
+        return ENV['SLACK_AUTH_TOKEN'] unless defined?(Motor::EncryptedConfig)
+
+        config = Motor::EncryptedConfig.find_by(key: EncryptedConfig::SLACK_CREDENTIALS_KEY)
+
+        return '' unless config
+
+        config.value[:api_key]
+      end
+    end
+  end
+end

data/lib/motor/slack.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Motor
+  module Slack
+    ITEMS_LIMIT = 1000
+
+    module_function
+
+    def conversations
+      Slack::Client.load_conversations(limit: ITEMS_LIMIT)['channels'] +
+        Slack::Client.load_users(limit: ITEMS_LIMIT)['members']
+    end
+  end
+end
+
+require_relative 'slack/client'

data/lib/motor/tags.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Motor
+  module Tags
+    module_function
+
+    def assign_tags(taggable, tags)
+      return taggable unless tags
+
+      tags.each do |tag_name|
+        next if taggable.taggable_tags.find { |tt| tt.tag.name.casecmp(tag_name).zero? }
+
+        tag = Tag.find_or_initialize_by(name: tag_name)
+
+        taggable.taggable_tags.new(tag: tag)
+      end
+
+      remove_missing_tags(taggable, tags) if taggable.persisted?
+
+      taggable
+    end
+
+    def remove_missing_tags(taggable, tags)
+      downcase_tags = tags.map(&:downcase)
+      tags_to_remove = taggable.tags.reject { |tt| tt.name.downcase.in?(downcase_tags) }
+
+      taggable.tags -= tags_to_remove
+
+      taggable
+    end
+  end
+end

data/lib/motor/tasks/motor.rake

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+namespace :motor do
+  desc 'Create migratione and add route'
+
+  task install: :environment do
+    Rails::Generators.invoke('motor:install')
+  end
+
+  desc 'Update configs/motor.yml file'
+
+  task dump: :environment do
+    Motor::Configs::WriteToFile.write_with_lock
+
+    puts '✅ configs/motor.yml has been updated'
+  end
+
+  desc 'Load configs from configs/motor.yml file'
+
+  task load: :environment do
+    Motor::Configs::SyncFromFile.call(with_exception: true)
+
+    puts '✅ configs have been loaded from configs/motor.yml'
+  end
+
+  desc 'Reload configs from configs/motor.yml file'
+
+  task reload: :environment do
+    ActiveRecord::Base.transaction do
+      Motor::Configs.clear
+      Motor::Configs::SyncFromFile.call(with_exception: true)
+    end
+
+    puts '✅ configs have been loaded from configs/motor.yml'
+  end
+
+  desc 'Synchronize configs with remote application'
+
+  task sync: :environment do
+    remote_url = ENV['MOTOR_SYNC_REMOTE_URL']
+    api_key = ENV['MOTOR_SYNC_API_KEY']
+
+    raise 'Specify target app url using `MOTOR_SYNC_REMOTE_URL` env variable' if remote_url.blank?
+    raise 'Specify sync api key using `MOTOR_SYNC_API_KEY` env variable' if api_key.blank?
+
+    Motor::Configs::SyncWithRemote.call(remote_url, api_key)
+    Motor::Configs::WriteToFile.write_with_lock
+
+    puts "✅ Motor Admin configurations have been synced with #{remote_url}"
+  rescue Motor::Configs::SyncWithRemote::ApiNotFound
+    puts '⚠️  Synchronization failed: you need to specify `MOTOR_SYNC_API_KEY` ' \
+         'env variable in your remote app in order to enable this feature'
+  end
+end

data/lib/motor/version.rb

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

data/lib/motor-admin-cstham8.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'motor'

data/lib/motor.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'concurrent/executor/fixed_thread_pool'
+require 'concurrent/timer_task'
+require 'cancancan'
+require 'ar_lazy_preload'
+require 'fugit'
+require 'csv'
+require 'audited'
+require 'uri'
+require 'net/http'
+require 'net/https'
+
+module Motor
+  PATH = Pathname.new(__dir__)
+
+  module DatabaseClasses
+  end
+
+  module_function
+
+  def reload!
+    Kernel.silence_warnings do
+      Dir[PATH.join('./motor/**/*.rb')].each do |f|
+        next if f.ends_with?('alerts/scheduler.rb')
+        next if f.ends_with?('notes/reminders_scheduler.rb')
+        next if f.ends_with?('alerts/scheduled_alerts_cache.rb')
+        next if f.ends_with?('configs/load_from_cache.rb')
+        next if f.ends_with?('configs/sync_from_file.rb')
+        next if f.ends_with?('resources/custom_sql_columns_cache.rb')
+
+        load f
+      end
+    end
+
+    true
+  end
+
+  def server?
+    defined?(::Rails::Server) ||
+      defined?(::Thin::Server) ||
+      defined?(::PhusionPassenger) ||
+      (defined?(::Puma) && File.basename($PROGRAM_NAME) == 'puma') ||
+      defined?(::Unicorn::HttpServer) ||
+      defined?(::Mongrel::HttpServer) ||
+      defined?(JRuby::Rack::VERSION) ||
+      defined?(::Trinidad::Server)
+  end
+
+  def app_host
+    Rails.application.config.action_dispatch.default_url_options&.fetch(:host) ||
+      ENV.fetch('HOST', 'example.com')
+  end
+
+  def company_name
+    'Motor Admin'
+  end
+
+  def with_public_access?
+    ENV['MOTOR_PUBLIC_ACCESS'].to_s == 'true'
+  end
+
+  def development?
+    ENV['MOTOR_DEVELOPMENT'].present?
+  end
+end
+
+require 'motor/version'
+require 'motor/admin'
+require 'motor/assets'
+require 'motor/active_record_utils'
+require 'motor/cancan_utils'
+require 'motor/build_schema'
+require 'motor/api_query'
+require 'motor/tags'
+require 'motor/configs'
+require 'motor/queries'
+require 'motor/dashboards'
+require 'motor/forms'
+require 'motor/api_configs'
+require 'motor/alerts'
+require 'motor/slack'
+require 'motor/resources'
+require 'motor/notes'
+require 'motor/hash_serializer'
+require 'motor/net_http_utils'
+require 'motor/railtie'