motor-admin-cstham8 0.4.35

data/lib/motor/admin.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Motor
+  class Admin < ::Rails::Engine
+    config.custom_html = ''
+
+    ActiveSupport.cache_format_version = Rails.version.to_f
+
+    if !Motor.development? && Rails.env.development?
+      config.eager_load_paths.delete(File.expand_path('../../app/controllers', __dir__))
+      config.eager_load_paths.delete(File.expand_path('../../app/controllers/concerns', __dir__))
+      config.eager_load_paths.delete(File.expand_path('../../app/models', __dir__))
+
+      config.autoload_once_paths << File.expand_path('../../app/models', __dir__)
+      config.autoload_once_paths << File.expand_path('../../app/controllers', __dir__)
+      config.autoload_once_paths << File.expand_path('../../app/controllers/concerns', __dir__)
+    end
+
+    initializer 'motor.startup_message' do
+      config.after_initialize do
+        next unless Motor.server?
+
+        Rails.application.reload_routes!
+
+        if Rails.application.routes.url_helpers.respond_to?(:motor_admin_path)
+          url =
+            begin
+              Rails.application.routes.url_helpers.motor_admin_url
+            rescue ArgumentError
+              Rails.application.routes.url_helpers.motor_admin_path
+            end
+
+          puts
+          puts "⚡ Motor::Admin is starting under #{url}"
+        else
+          puts
+          puts '⚠️  Motor::Admin is not mounted.'
+          puts 'Add the following line to your config/routes.rb:'
+          puts
+          puts "    mount Motor::Admin => '/admin'"
+        end
+
+        puts
+      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 += [/\Aio\z/]
+    end
+
+    initializer 'motor.alerts.scheduler' do
+      config.after_initialize do
+        next unless Motor.server?
+        next unless Rails.env.production?
+
+        Motor::Alerts::Scheduler::SCHEDULER_TASK.execute
+        Motor::Notes::RemindersScheduler::SCHEDULER_TASK.execute
+      end
+    end
+
+    initializer 'motor.basic_auth' do
+      next if ENV['MOTOR_AUTH_PASSWORD'].blank?
+
+      config.middleware.use Rack::Auth::Basic do |username, password|
+        ActiveSupport::SecurityUtils.secure_compare(
+          ::Digest::SHA256.hexdigest(username),
+          ::Digest::SHA256.hexdigest(ENV['MOTOR_AUTH_USERNAME'].to_s)
+        ) &
+          ActiveSupport::SecurityUtils.secure_compare(
+            ::Digest::SHA256.hexdigest(password),
+            ::Digest::SHA256.hexdigest(ENV['MOTOR_AUTH_PASSWORD'].to_s)
+          )
+      end
+    end
+
+    initializer 'warden.configure.dispatch_requests' do
+      next unless defined?(Warden::JWTAuth)
+
+      config.after_initialize do
+        Warden::JWTAuth.configure do |config|
+          config.dispatch_requests += [
+            ['POST', /\A#{Regexp.escape(Motor::Admin.routes.url_helpers.motor_api_auth_tokens_path)}\z/]
+          ]
+        end
+      end
+    end
+
+    initializer 'action_cable.connection_class' do
+      config.after_initialize do
+        next if defined?(::ApplicationCable::Connection)
+        next unless defined?(::ActionCable)
+
+        ActionCable.server.config.connection_class = -> { Motor::ApplicationCable::Connection }
+      end
+    end
+
+    initializer 'motor.active_storage.extensions' do
+      config.after_initialize do
+        next unless defined?(ActiveStorage::Engine)
+
+        ActiveSupport.on_load(:active_storage_attachment) do
+          ActiveStorage::Attachment.include(Motor::ActiveRecordUtils::ActiveStorageLinksExtension)
+        end
+
+        ActiveSupport.on_load(:active_storage_blob) do
+          ActiveStorage::Blob.singleton_class.prepend(Motor::ActiveRecordUtils::ActiveStorageBlobPatch)
+        end
+
+        ActiveStorage::Attachment.include(Motor::ActiveRecordUtils::ActiveStorageLinksExtension)
+        ActiveStorage::Blob.singleton_class.prepend(Motor::ActiveRecordUtils::ActiveStorageBlobPatch)
+      end
+    end
+
+    initializer 'motor.upgrade' do
+      ActiveSupport.on_load(:motor_query) do
+        next unless Motor.server?
+
+        unless Motor::Query.table_exists?
+          puts
+          puts '  => Run `rails g motor:install && rake db:migrate` in order to create Motor Admin configuration tables'
+          puts
+        end
+
+        if !Motor::ApiConfig.table_exists? || !Motor::Note.table_exists?
+          puts
+          puts '  => Run `rails g motor:upgrade && rake db:migrate` ' \
+               'to perform data migration and enable the latest features'
+          puts
+        end
+      end
+    end
+  end
+end

data/lib/motor/alerts/persistance.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Motor
+  module Alerts
+    module Persistance
+      ALERT_ATTRIBUTES = %i[
+        query_id
+        name
+        description
+        preferences
+        is_enabled
+        to_emails
+      ].freeze
+
+      NameAlreadyExists = Class.new(StandardError)
+      InvalidInterval = Class.new(StandardError)
+
+      NORMALIZE_INTERVAL_REGEXP = /\A(?:every\s+)?/i.freeze
+
+      module_function
+
+      def build_from_params(params, current_user = nil)
+        alert = assign_attributes(Alert.new, params)
+
+        alert.author = current_user
+
+        alert
+      end
+
+      def create_from_params!(params, current_user = nil)
+        raise NameAlreadyExists if Alert.exists?(name: params[:name])
+
+        alert = build_from_params(params, current_user)
+
+        raise InvalidInterval unless alert.cron
+
+        ApplicationRecord.transaction do
+          alert.save!
+        end
+
+        alert
+      rescue ActiveRecord::RecordNotUnique
+        retry
+      end
+
+      def update_from_params!(alert, params, force_replace: false)
+        tag_ids = alert.tags.ids
+
+        alert = assign_attributes(alert, params)
+
+        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.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(['name = ? AND id != ?', alert.name, alert.id])
+                    .update_all(deleted_at: Time.current)
+      end
+
+      def normalize_interval(interval)
+        interval.to_s.gsub(NORMALIZE_INTERVAL_REGEXP, 'every ')
+      end
+
+      def name_already_exists?(alert)
+        if alert.new_record?
+          Alert.exists?(name: alert.name, deleted_at: nil)
+        else
+          Alert.exists?(['name = ? AND id != ? AND deleted_at IS NULL', alert.name, alert.id])
+        end
+      end
+    end
+  end
+end

data/lib/motor/alerts/scheduled_alerts_cache.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Motor
+  module Alerts
+    module ScheduledAlertsCache
+      CACHE_STORE = ActiveSupport::Cache::MemoryStore.new(size: 5.megabytes)
+
+      module_function
+
+      def all
+        ActiveRecord::Base.logger.silence do
+          cache_key = Motor::Alert.maximum(:updated_at)
+
+          return [] if cache_key.nil?
+
+          CACHE_STORE.fetch(cache_key) do
+            clear
+
+            Motor::Alert.all.active.enabled.to_a
+          end
+        end
+      end
+
+      def clear
+        CACHE_STORE.clear
+      end
+    end
+  end
+end

data/lib/motor/alerts/scheduler.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Motor
+  module Alerts
+    module Scheduler
+      SCHEDULER_INTERVAL = 1.minute
+      CHECK_BEHIND_DURATION = 15.minutes
+
+      SCHEDULER_TASK = Concurrent::TimerTask.new(
+        execution_interval: SCHEDULER_INTERVAL
+      ) { Motor::Alerts::Scheduler.call }
+
+      ALREADY_PROCESSED_CACHE = ActiveSupport::Cache::MemoryStore.new(size: 5.megabytes)
+
+      module_function
+
+      def call
+        ScheduledAlertsCache.find_each do |alert|
+          next unless (CHECK_BEHIND_DURATION.ago..Time.current).cover?(alert.cron.previous_time.to_local_time)
+
+          ALREADY_PROCESSED_CACHE.fetch("#{alert.id}-#{alert.cron.previous_time.to_i}") do
+            Motor::AlertSendingJob.perform_later(alert).job_id
+          end
+        rescue StandardError => e
+          Rails.logger.error(e)
+        end
+      end
+    end
+  end
+end

data/lib/motor/alerts/slack_sender.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Motor
+  module Alerts
+    module SlackSender
+      MARKDOWN_LINK_TRANSFORM_REGEXP = /\[(.+?)\]\((.+?)\)/.freeze
+      MARKDOWN_PATHS_TRANSFORM_REGEXP = /\n\s*\#{1,5}\s*(.*)\n?/.freeze
+      MARKDOWN_HEADING_TRANSFORM_REGEXP = /\n\s*\#{1,5}\s*(.*)\n?/.freeze
+      MARKDOWN_BOLD_TRANSFORM_REGEXP = /[*_]{2}/.freeze
+
+      DEFAULT_FILENAME = 'data.csv'
+
+      module_function
+
+      def call(alert, conversation_id, slack_user: nil)
+        query_result = load_data(alert, slack_user)
+
+        if alert.query.preferences[:visualization] == 'markdown'
+          text = [build_query_link(alert), render_markdown(alert, query_result)].join
+
+          Slack::Client.send_message(channel: conversation_id,
+                                     as_user: slack_user.present?,
+                                     text: text)
+        else
+          Slack::Client.send_message(channel: conversation_id,
+                                     as_user: slack_user.present?,
+                                     text: build_alert_message(alert))
+          Slack::Client.send_file(channels: conversation_id,
+                                  content: generate_csv(query_result),
+                                  filename: DEFAULT_FILENAME)
+        end
+      end
+
+      def build_alert_message(alert)
+        <<~MARKDOWN
+          #{build_query_link(alert)}
+          #{alert.description}
+        MARKDOWN
+      end
+
+      def build_query_link(alert)
+        link = Motor::Admin.routes.url_helpers.motor_ui_query_url(alert.query_id, host: Motor.app_host)
+
+        "*<#{link}|#{alert.name}>*"
+      end
+
+      def render_markdown(alert, query_result)
+        params = query_result.columns.pluck(:name).zip(query_result.data[0]).to_h.symbolize_keys
+
+        markdown =
+          ["\n", Mustache.render(alert.query.preferences[:visualization_options][:markdown], **params)].join
+
+        markdown.gsub(/\((.*)\)/, "(http://#{Motor.app_host}\\1)")
+                .gsub(MARKDOWN_LINK_TRANSFORM_REGEXP, '<\2|\1>')
+                .gsub(MARKDOWN_HEADING_TRANSFORM_REGEXP, "\n\n*\\1*")
+                .gsub(MARKDOWN_BOLD_TRANSFORM_REGEXP, '*')
+      end
+
+      def generate_csv(query_result)
+        rows = [query_result.columns.pluck(:name)] + query_result.data
+
+        rows.map(&:to_csv).join
+      end
+
+      def load_data(alert, slack_user = nil)
+        if slack_user
+          Queries::RunQuery.call(alert.query, variables_hash: { current_user_email: slack_user['email'] })
+        else
+          Queries::RunQuery.call(alert.query)
+        end
+      end
+    end
+  end
+end

data/lib/motor/alerts.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Motor
+  module Alerts
+    module_function
+
+    def send_alert(alert)
+      if alert.preferences[:adapter] == 'slack'
+        send_slack_alert(alert)
+      else
+        send_email_alert(alert)
+      end
+    end
+
+    def send_email_alert(alert)
+      alert.to_emails.split(',').each do |email|
+        if email.include?('@')
+          Motor::AlertsMailer.alert_email(alert, email: email).deliver_now!
+        else
+          send_query_email_alerts(alert, email.gsub(/[{}]/, ''))
+        end
+      end
+    end
+
+    def send_query_email_alerts(alert, column_name)
+      result = Queries::RunQuery.call(alert.query)
+
+      column_index = result.columns.find_index { |c| c[:name] == column_name }
+
+      emails = result.data.pluck(column_index).uniq
+
+      emails.each do |email|
+        Motor::AlertsMailer.alert_email(alert, email: email).deliver_now!
+      end
+    end
+
+    def send_slack_alert(alert)
+      slack_users = Slack::Client.load_users(limit: Slack::ITEMS_LIMIT)['members']
+
+      alert.preferences[:slack_conversation_ids].each do |conversation_id|
+        user = slack_users.find { |u| u['id'] == conversation_id }
+
+        Motor::Alerts::SlackSender.call(alert, conversation_id, slack_user: user)
+      end
+    end
+  end
+end
+
+require_relative 'alerts/scheduler'
+require_relative 'alerts/scheduled_alerts_cache'
+require_relative 'alerts/persistance'
+require_relative 'alerts/slack_sender'

data/lib/motor/api_configs.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Motor
+  module ApiConfigs
+    METHODS = %w[get post put delete].freeze
+
+    DEFAULT_HEADERS = { 'Content-Type' => 'application/json' }.freeze
+
+    InvalidHttpMethod = Class.new(StandardError)
+
+    module_function
+
+    def run(api_config, method: nil, path: nil, body: nil, params: {}, headers: {})
+      method ||= 'get'
+
+      raise InvalidHttpMethod unless METHODS.include?(method.downcase)
+
+      Motor::NetHttpUtils.public_send(
+        method.downcase.to_sym,
+        api_config.url.to_s.sub(%r{/?\z}, '/') + path.delete_prefix('/'),
+        params,
+        DEFAULT_HEADERS.merge(headers).merge(api_config.headers),
+        body&.to_json
+      )
+    end
+
+    def run_grapql(api_config, query:, variables: {}, headers: {})
+      body = {
+        query: query,
+        variables: variables.merge(form_data: variables)
+      }
+
+      Motor::NetHttpUtils.post(
+        api_config.url,
+        {},
+        DEFAULT_HEADERS.merge(headers).merge(api_config.headers),
+        body.to_json
+      )
+    end
+  end
+end

data/lib/motor/api_query/apply_scope.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Motor
+  module ApiQuery
+    module ApplyScope
+      module_function
+
+      def call(rel, scope)
+        return rel if scope.blank?
+
+        scope_symbol = scope.to_sym
+
+        if rel.klass.defined_scopes.include?(scope_symbol)
+          rel.public_send(scope_symbol)
+        else
+          apply_filter_scope(rel, scope)
+        end
+      end
+
+      def apply_filter_scope(rel, scope)
+        configs = Motor::Resource.find_by(name: rel.klass.name.underscore)
+
+        return rel unless configs
+
+        scope_configs = configs.preferences[:scopes].find { |s| s[:name] == scope }
+
+        return rel unless scope_configs
+        return rel unless scope_configs[:preferences]
+
+        rel = ApiQuery::Filter.call(rel, scope_configs[:preferences][:filter])
+
+        apply_order(rel, scope_configs[:preferences][:sort])
+      end
+
+      def apply_order(rel, params)
+        return rel if params.blank?
+
+        sort_key, sort_order = params.values_at(:key, :order)
+
+        rel.order(sort_key => sort_order)
+      end
+    end
+  end
+end

data/lib/motor/api_query/build_json.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Motor
+  module ApiQuery
+    module BuildJson
+      module_function
+
+      # @param rel [ActiveRecord::Base, ActiveRecord::Relation]
+      # @param params [Hash]
+      # @param current_ability [CanCan::Ability]
+      # @return [Hash]
+      def call(rel, params, current_ability = Motor::CancanUtils::CanManageAll.new)
+        rel = rel.none if limit_zero_params?(params)
+        rel = rel.preload_associations_lazily if rel.is_a?(ActiveRecord::Relation)
+
+        model = rel.is_a?(ActiveRecord::Relation) ? rel.klass : rel.class
+
+        include_hash = build_include_hash(params['include'])
+        models_index = build_models_index(model, include_hash)
+
+        json_params = normalize_include_params(include_hash)
+
+        assign_fields_params!(json_params, model, params, current_ability, models_index)
+
+        rel.as_json(json_params.with_indifferent_access)
+      end
+
+      # @param include_params [Hash]
+      # @return [Hash]
+      def build_include_hash(include_params)
+        return {} if include_params.blank?
+
+        if include_params.is_a?(String)
+          build_hash_from_string_path(include_params)
+        else
+          include_params
+        end
+      end
+
+      # @param json_params [Hash]
+      # @param model [Class<ActiveRecord::Base>]
+      # @param params [Hash]
+      # @param current_ability [CanCan::Ability]
+      # @param models_index [Hash]
+      # @return [void]
+      def assign_fields_params!(json_params, model, params, current_ability, models_index)
+        return if params[:fields].blank?
+
+        params[:fields].each do |key, fields|
+          fields_model = models_index[key]
+
+          next unless model
+
+          fields = fields.split(',') if fields.is_a?(String)
+
+          fields_hash = fields_model == model ? json_params : find_key_in_params(json_params, key)
+
+          fields_hash.merge!(build_fields_hash(fields_model, fields, current_ability))
+        end
+      end
+
+      # @param model [Class<ActiveRecord::Base>]
+      # @param fields [Hash]
+      # @param current_ability [CanCan::Ability]
+      # @return [Hash]
+      def build_fields_hash(model, fields, current_ability)
+        return { 'methods' => fields } unless model
+
+        column_names = model.column_names.map(&:to_sym)
+        instance_methods = model.instance_methods
+        permitted_attributes = current_ability.permitted_attributes(:read, model)
+        is_permitted_all = column_names == permitted_attributes
+
+        fields_hash = { 'only' => [], 'methods' => [] }
+
+        fields.each_with_object(fields_hash) do |field, acc|
+          field_symbol = field.to_sym
+
+          next if !is_permitted_all && permitted_attributes.exclude?(field_symbol)
+
+          if model.columns_hash[field]
+            acc['only'] << field
+          elsif instance_methods.include?(field_symbol)
+            acc['methods'] << field
+          end
+        end
+      end
+
+      # @param params [Hash]
+      # @param key [String]
+      # @return [Hash]
+      def find_key_in_params(params, key)
+        params = params['include']
+
+        return {} if params.blank?
+        return params[key] if params[key]
+
+        params.keys.reduce(nil) do |acc, k|
+          acc || find_key_in_params(params[k], key)
+        end
+      end
+
+      # @param params [Hash]
+      # @return [Hash]
+      def normalize_include_params(params)
+        case params
+        when Array
+          params.index_with do |_|
+            { 'include' => {} }
+          end
+        when String
+          { params => { 'include' => {} } }
+        when Hash
+          include_hash =
+            params.transform_values do |value|
+              normalize_include_params(value)
+            end
+
+          { 'include' => include_hash }
+        else
+          raise ArgumentError, "Wrong include param type #{params.class}"
+        end
+      end
+
+      # @param model [Class<ActiveRecord::Base>]
+      # @param includes_hash [Hash]
+      # @return [Hash]
+      def build_models_index(model, includes_hash)
+        default_index = {
+          model.name.underscore => model,
+          model.name.underscore.split('/').last => model
+        }
+
+        includes_hash.reduce(default_index) do |acc, (key, value)|
+          reflection = model.reflections[key]
+
+          next acc unless reflection
+          next acc if reflection.polymorphic?
+
+          acc[key] = reflection.klass
+
+          acc.merge(build_models_index(reflection.klass, value))
+        end
+      end
+
+      # @param string_path [String]
+      # @return [Hash]
+      def build_hash_from_string_path(string_path)
+        string_path.split(',').reduce({}) do |accumulator, path|
+          hash = {}
+
+          path.split('.').reduce(hash) do |acc, part|
+            acc_hash = {}
+
+            acc[part] = acc_hash
+
+            acc_hash
+          end
+
+          accumulator.deep_merge(hash)
+        end
+      end
+
+      # @param params [Hash]
+      # @return [Boolean]
+      def limit_zero_params?(params)
+        params.dig(:page, :limit).then { |limit| limit.present? && limit.to_i.zero? }
+      end
+    end
+  end
+end

data/lib/motor/api_query/build_meta.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Motor
+  module ApiQuery
+    module BuildMeta
+      module_function
+
+      def call(rel, params)
+        meta = {}
+
+        if params[:meta].to_s.include?('count')
+          meta[:count] =
+            rel.limit(nil).offset(nil).reorder(nil).select(rel.klass.arel_table[rel.klass.primary_key]).count
+        end
+
+        meta
+      end
+    end
+  end
+end