motor-admin 0.1.9

data/lib/motor/active_record_utils/types.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Motor
+  module ActiveRecordUtils
+    module Types
+      MUTEX = Mutex.new
+      DEFAULT_TYPE = 'string'
+
+      UNIFIED_TYPES = {
+        'smallint' => 'integer',
+        'int' => 'integer',
+        'int8' => 'integer',
+        'int16' => 'integer',
+        'bigint' => 'integer',
+        'numeric' => 'float',
+        'decimal' => 'float',
+        'text' => 'string',
+        'citext' => 'string',
+        'jsonb' => 'json',
+        'timestamp' => 'datetime'
+      }.freeze
+
+      module_function
+
+      def all
+        @all || MUTEX.synchronize do
+          @all ||= build_types_hash
+        end
+      end
+
+      def find_class_for_name(name)
+        all.invert[name.to_s]
+      end
+
+      def find_name_for_class(klass)
+        name = all[klass.to_s]
+
+        return UNIFIED_TYPES.fetch(name, name) if name
+
+        DEFAULT_TYPE
+      end
+
+      def build_types_hash
+        type_map = ActiveRecord::Base.connection.send(:type_map)
+
+        type_map.instance_variable_get('@mapping').map do |name, type|
+          next unless name.is_a?(String)
+
+          [type.call.class.to_s, name]
+        end.compact.to_h
+      end
+    end
+  end
+end

data/lib/motor/admin.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Motor
+  class Admin < ::Rails::Engine
+    initializer 'motor.alerts.scheduler' do
+      next if defined?(Sidekiq) && Sidekiq.server?
+
+      Motor::Alerts::Scheduler::SCHEDULER_TASK.execute
+      Motor::Alerts::ScheduledAlertsCache::UPDATE_ALERTS_TASK.execute
+    end
+  end
+end

data/lib/motor/alerts.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative './alerts/scheduler'
+require_relative './alerts/scheduled_alerts_cache'
+require_relative './alerts/persistance'
+
+module Motor
+  module Alerts
+  end
+end

data/lib/motor/alerts/persistance.rb

@@ -0,0 +1,84 @@
+# 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?(['lower(name) = ?', params[:name].to_s.downcase])
+
+        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)
+        raise NameAlreadyExists if name_already_exists?(alert)
+
+        alert = assign_attributes(alert, params)
+
+        raise InvalidInterval unless alert.cron
+
+        ApplicationRecord.transaction do
+          alert.save!
+        end
+
+        alert.tags.reload
+
+        alert
+      rescue ActiveRecord::RecordNotUnique
+        retry
+      end
+
+      def assign_attributes(alert, params)
+        alert.assign_attributes(params.slice(*ALERT_ATTRIBUTES))
+        alert.preferences[:interval] = normalize_interval(alert.preferences[:interval])
+
+        Motor::Tags.assign_tags(alert, params[:tags])
+      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?(['lower(name) = ?', alert.name.to_s.downcase])
+        else
+          Alert.exists?(['lower(name) = ? AND id != ?', alert.name.to_s.downcase, 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
+      UPDATE_ALERTS_TASK = Concurrent::TimerTask.new(
+        execution_interval: 2.minutes
+      ) { Motor::Alerts::ScheduledAlertsCache.load_alerts }
+
+      CACHE_STORE = ActiveSupport::Cache::MemoryStore.new(size: 5.megabytes)
+
+      module_function
+
+      def all
+        ActiveRecord::Base.logger.silence do
+          CACHE_STORE.fetch(Motor::Alert.all.maximum(:updated_at)) 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 = 10.seconds
+      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.all.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
+          Rials.logger.error(e)
+        end
+      end
+    end
+  end
+end

data/lib/motor/api.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Motor
+  class Api < ::Rails::Engine
+  end
+end

data/lib/motor/api_query.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative './api_query/sort'
+require_relative './api_query/paginate'
+require_relative './api_query/filter'
+require_relative './api_query/search'
+require_relative './api_query/build_meta'
+require_relative './api_query/build_json'
+
+module Motor
+  module ApiQuery
+    module_function
+
+    def call(rel, params)
+      rel = ApiQuery::Sort.call(rel, params[:sort])
+      rel = ApiQuery::Paginate.call(rel, params[:page])
+      rel = ApiQuery::Filter.call(rel, params[:filter])
+
+      ApiQuery::Search.call(rel, params[:q] || params[:search] || params[:query])
+    end
+  end
+end

data/lib/motor/api_query/build_json.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Motor
+  module ApiQuery
+    module BuildJson
+      module_function
+
+      def call(rel, params)
+        rel = rel.none if params.dig(:page, :limit).yield_self { |limit| limit.present? && limit.to_i.zero? }
+
+        rel = rel.preload_associations_lazily if rel.is_a?(ActiveRecord::Relation)
+
+        json_params = {}
+
+        assign_include_params(json_params, rel, params)
+        assign_fields_params(json_params, rel, params)
+
+        rel.as_json(json_params.with_indifferent_access)
+      end
+
+      def assign_include_params(json_params, _rel, api_params)
+        return if api_params['include'].blank?
+
+        include_params = api_params['include']
+
+        if include_params.is_a?(String)
+          include_params =
+            include_params.split(',').reduce({}) do |accumulator, path|
+              hash = {}
+
+              path.split('.').reduce(hash) do |acc, part|
+                acc[part] = {}
+
+                acc[part]
+              end
+
+              accumulator.deep_merge(hash)
+            end
+        end
+
+        json_params.deep_merge!(normalize_include_params(include_params))
+      end
+
+      def assign_fields_params(json_params, rel, params)
+        return if params[:fields].blank?
+
+        model = rel.is_a?(ActiveRecord::Relation) ? rel.klass : rel.class
+        model_name = model.name.underscore
+
+        params[:fields].each do |key, fields|
+          fields = fields.split(',') if fields.is_a?(String)
+          fields_hash = build_fields_hash(model, fields)
+
+          if key == model_name || model_name.split('/').last == key
+            json_params.merge!(fields_hash)
+          else
+            hash = find_key_in_params(json_params, key)
+
+            hash.merge!(fields_hash)
+          end
+        end
+      end
+
+      def build_fields_hash(model, fields)
+        columns = model.columns.map(&:name)
+        fields_hash = { 'only' => [], 'methods' => [] }
+
+        fields.each_with_object(fields_hash) do |field, acc|
+          if field.in?(columns)
+            acc['only'] << field
+          else
+            acc['methods'] << field
+          end
+        end
+      end
+
+      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
+
+      def normalize_include_params(params)
+        case params
+        when Array
+          params.each_with_object({}) do |name, hash|
+            hash[name] = { '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
+    end
+  end
+end

data/lib/motor/api_query/build_meta.rb

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

data/lib/motor/api_query/filter.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Motor
+  module ApiQuery
+    module Filter
+      LIKE_FILTER_VALUE_REGEXP = /\A%?(.*?)%?\z/.freeze
+
+      module_function
+
+      def call(rel, params)
+        return rel if params.blank?
+
+        normalized_params = normalize_params(Array.wrap(params))
+
+        rel.filter(normalized_params).distinct
+      end
+
+      def normalize_params(params)
+        params.map do |item|
+          next item if item.is_a?(String)
+          next normalize_params(item) if item.is_a?(Array)
+
+          item = item.to_unsafe_h if item.respond_to?(:to_unsafe_h)
+
+          item.transform_values do |filter|
+            if filter.is_a?(Hash)
+              normalize_filter_hash(filter)
+            else
+              filter
+            end
+          end
+        end.split('OR').product(['OR']).flatten(1)[0...-1]
+      end
+
+      def normalize_filter_hash(hash)
+        hash.each_with_object({}) do |(action, value), acc|
+          acc[action] =
+            if value.is_a?(Hash)
+              normalize_filter_hash(value)
+            else
+              normalize_action_value(action, value)
+            end
+        end
+      end
+
+      def normalize_action_value(action, value)
+        if %w[like ilike].include?(action)
+          value.sub(LIKE_FILTER_VALUE_REGEXP, '%\1%')
+        else
+          value
+        end
+      end
+    end
+  end
+end