motor-admin-cstham8 0.4.35

data/app/controllers/motor/run_api_requests_controller.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Motor
+  class RunApiRequestsController < ApiBaseController
+    JWT_TTL = 2.hours
+
+    wrap_parameters :data
+
+    def show
+      respond_with_result
+    end
+
+    def create
+      respond_with_result
+    end
+
+    private
+
+    # rubocop:disable Metrics/AbcSize
+    def respond_with_result
+      response = Motor::ApiConfigs.run(find_or_initialize_api_config,
+                                       method: request_params[:method],
+                                       path: request_params[:path],
+                                       body: request_params[:body],
+                                       params: request_params[:params],
+                                       headers: { 'Authorization' => "Bearer #{current_user_jwt}" })
+      response.to_hash.each do |key, (value)|
+        next if key.casecmp('transfer-encoding').zero?
+
+        headers[key] = value
+      end
+
+      self.response_body = response.body
+      self.status = response.code.to_i
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def find_or_initialize_api_config
+      Motor::ApiConfig.find_by(name: request_params[:api_config_name]) ||
+        Motor::ApiConfig.new(url: request_params[:api_config_name])
+    end
+
+    def current_user_jwt
+      return '' unless defined?(JWT)
+      return '' unless current_user
+
+      payload = { uid: current_user.id, email: current_user.email, exp: JWT_TTL.from_now.to_i }
+
+      JWT.encode(payload, Rails.application.credentials.secret_key_base)
+    end
+
+    def request_params
+      params.require(:data).permit!
+    end
+  end
+end

data/app/controllers/motor/run_graphql_requests_controller.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Motor
+  class RunGraphqlRequestsController < ApiBaseController
+    JWT_TTL = 2.hours
+
+    wrap_parameters :data
+
+    def create
+      respond_with_result
+    end
+
+    private
+
+    def respond_with_result
+      response = Motor::ApiConfigs.run_grapql(find_or_initialize_api_config,
+                                              query: request_params[:query],
+                                              variables: request_params[:variables],
+                                              headers: { 'Authorization' => "Bearer #{current_user_jwt}" })
+      response.to_hash.each do |key, (value)|
+        next if key.casecmp('transfer-encoding').zero?
+
+        headers[key] = value
+      end
+
+      self.response_body = response.body
+      self.status = response.code.to_i
+    end
+
+    def find_or_initialize_api_config
+      Motor::ApiConfig.find_by(name: request_params[:api_config_name]) ||
+        Motor::ApiConfig.new(url: request_params[:api_config_name])
+    end
+
+    def current_user_jwt
+      return '' unless defined?(JWT)
+      return '' unless current_user
+
+      payload = { uid: current_user.id, email: current_user.email, exp: JWT_TTL.from_now.to_i }
+
+      JWT.encode(payload, Rails.application.credentials.secret_key_base)
+    end
+
+    def request_params
+      params.require(:data).permit!
+    end
+  end
+end

data/app/controllers/motor/run_queries_controller.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Motor
+  class RunQueriesController < ApiBaseController
+    wrap_parameters :data
+
+    load_and_authorize_resource :query, only: :show, parent: false
+
+    before_action :build_query, only: :create
+    authorize_resource :query, only: :create
+
+    def show
+      render_result
+    end
+
+    def create
+      render_result
+    end
+
+    private
+
+    def render_result
+      authorize_queries!(@query)
+
+      query_result = Queries::RunQuery.call(@query, variables_hash: variables_params.to_unsafe_h,
+                                                    limit: params[:limit].presence,
+                                                    filters: filter_params)
+
+      if query_result.error
+        render json: { errors: [{ detail: query_result.error }] }, status: :unprocessable_entity
+      else
+        render json: query_result_hash(query_result)
+      end
+    end
+
+    def authorize_queries!(query)
+      query.sql_body.to_s.scan(/query_\d+/).each do |name|
+        Motor::Query.accessible_by(current_ability).find(name.split('_').last)
+      end
+    end
+
+    def current_user_variables
+      return {} unless current_user
+
+      current_user
+        .attributes
+        .slice('id', 'email')
+        .transform_keys { |key| "current_user_#{key}" }
+        .compact
+    end
+
+    def query_result_hash(query_result)
+      {
+        data: query_result.data,
+        meta: {
+          columns: query_result.columns
+        }
+      }
+    end
+
+    def build_query
+      @query = Motor::Queries::Persistance.build_from_params(query_params)
+    end
+
+    def query_params
+      params.require(:data).permit(:sql_body, preferences: {})
+    end
+
+    def variables_params
+      params.fetch(:variables, {}).merge(current_user_variables)
+    end
+
+    def filter_params
+      (params[:filter] || params[:filters])&.to_unsafe_h
+    end
+  end
+end

data/app/controllers/motor/schema_controller.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Motor
+  class SchemaController < ApiBaseController
+    skip_authorization_check
+
+    before_action :authorize_resource, only: :show
+
+    def index
+      render json: { data: schema }
+    end
+
+    def show
+      render json: { data: schema.find { |model| model[:name] == resource_class.name.underscore } }
+    end
+
+    private
+
+    def schema
+      @schema ||= Motor::BuildSchema.call(Configs::LoadFromCache.load_cache_keys, current_ability)
+    end
+
+    def resource_class
+      @resource_class ||= Motor::BuildSchema::Utils.classify_slug(params[:resource])
+    end
+
+    def authorize_resource
+      authorize!(resource_class, :read)
+    end
+  end
+end

data/app/controllers/motor/send_alerts_controller.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Motor
+  class SendAlertsController < ApiBaseController
+    wrap_parameters :data
+
+    before_action :build_alert, only: :create
+    authorize_resource :alert, only: :create
+
+    def create
+      Motor::Alerts.send_alert(@alert)
+
+      head :ok
+    end
+
+    private
+
+    def build_alert
+      @alert = Motor::Alerts::Persistance.build_from_params(alert_params)
+    end
+
+    def alert_params
+      params.require(:data).permit(:query_id, :name, :to_emails, :description, preferences: {})
+    end
+  end
+end

data/app/controllers/motor/sessions_controller.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Motor
+  class SessionsController < ApiBaseController
+    include ActionController::Cookies
+
+    skip_authorization_check
+
+    def show
+      render json: {
+        current_user_email: current_user&.email,
+        current_user_id: current_user&.id
+      }
+    end
+
+    def destroy
+      session.clear
+      cookies.clear
+
+      head :ok
+    end
+  end
+end

data/app/controllers/motor/slack_conversations_controller.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Motor
+  class SlackConversationsController < ApiBaseController
+    def index
+      authorize!(:create, Motor::Alert)
+
+      render json: { data: Motor::Slack.conversations }
+    end
+  end
+end

data/app/controllers/motor/tags_controller.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Motor
+  class TagsController < ApiBaseController
+    load_and_authorize_resource :tag
+
+    def index
+      render json: { data: @tags.to_a }
+    end
+  end
+end

data/app/controllers/motor/ui_controller.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Motor
+  class UiController < ApplicationController
+    layout 'motor/application'
+
+    helper_method :current_user, :current_ability, :cache_keys, :custom_html
+
+    before_action :set_i18n_locale
+
+    def index
+      render_ui
+    end
+
+    def show
+      render_ui
+    end
+
+    def new
+      render_ui
+    end
+
+    private
+
+    def render_ui
+      Motor.reload! if Motor.development?
+
+      Motor::Configs::SyncFromFile.call
+
+      render :show
+    end
+
+    def custom_html
+      Motor::Admin.config.custom_html.presence || begin
+        configs = Motor::Configs::LoadFromCache.load_configs(cache_key: cache_keys[:configs])
+
+        configs.find { |c| c.key == 'ui.custom_html' }&.value
+      end
+    end
+
+    def set_i18n_locale
+      configs = Motor::Configs::LoadFromCache.load_configs(cache_key: cache_keys[:configs])
+
+      I18n.locale = configs.find { |c| c.key == 'language' }&.value&.to_sym || I18n.locale
+    end
+
+    def cache_keys
+      @cache_keys ||= Configs::LoadFromCache.load_cache_keys
+    end
+  end
+end

data/app/controllers/motor/users_for_autocomplete_controller.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Motor
+  class UsersForAutocompleteController < ApiBaseController
+    def index
+      authorize!(:create, Motor::Note)
+
+      render json: { data: user_emails }
+    end
+
+    private
+
+    def user_emails
+      user_class   = Motor::AdminUser if defined?(Motor::AdminUser)
+      user_class ||= AdminUser if defined?(AdminUser)
+      user_class ||= User if defined?(User)
+
+      return user_class.distinct.limit(100).pluck(:email) if user_class
+
+      []
+    end
+  end
+end

data/app/jobs/motor/alert_sending_job.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Motor
+  class AlertSendingJob < ApplicationJob
+    def perform(alert)
+      Motor::AlertLock.create!(alert_id: alert.id, lock_timestamp: alert.cron.previous_time.to_i)
+
+      Motor::Alerts.send_alert(alert)
+    rescue ActiveRecord::RecordNotUnique
+      nil
+    end
+  end
+end

data/app/jobs/motor/application_job.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Motor
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/jobs/motor/notify_note_mentions_job.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Motor
+  class NotifyNoteMentionsJob < ApplicationJob
+    def perform(note, current_user)
+      Motor::Notes::NotifyMentions.call(note, current_user)
+    end
+  end
+end

data/app/jobs/motor/notify_reminder_job.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Motor
+  class NotifyReminderJob < ApplicationJob
+    def perform(reminder)
+      Motor::Notes::NotifyReminder.call(reminder)
+    end
+  end
+end

data/app/mailers/motor/alerts_mailer.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Motor
+  class AlertsMailer < ApplicationMailer
+    SenderAddressNotSet = Class.new(StandardError)
+    SENDER_NOT_SET_ERROR_MESSAGE =
+      'Please specify your sender address via MOTOR_ALERTS_FROM_ADDRESS environment variable'
+
+    def alert_email(alert, email: nil)
+      @alert = alert
+      @query_result = Queries::RunQuery.call(alert.query,
+                                             variables_hash: { current_user_email: email })
+
+      return if @alert.preferences[:send_empty].blank? && @query_result.data.blank?
+
+      assign_attachment(@alert, @query_result)
+
+      raise SenderAddressNotSet, SENDER_NOT_SET_ERROR_MESSAGE unless from_address
+
+      mail(
+        from: from_address,
+        to: email || alert.to_emails,
+        subject: alert.name.presence || @alert.query.name
+      )
+    end
+
+    private
+
+    def assign_attachment(alert, query_result)
+      attachments["#{alert.name.presence || 'data'}.csv"] = generate_csv(query_result)
+    end
+
+    def generate_csv(query_result)
+      rows = [query_result.columns.pluck(:name)] + query_result.data
+
+      rows.map(&:to_csv).join
+    end
+  end
+end

data/app/mailers/motor/application_mailer.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Motor
+  class ApplicationMailer < ActionMailer::Base
+    layout 'motor/mailer'
+
+    private
+
+    def from_address
+      from = ENV['MOTOR_ALERTS_FROM_ADDRESS'].presence || ENV['MOTOR_EMAIL_ADDRESS'].presence
+
+      from ||= application_mailer_default_from
+      from ||= mailer_config_from_address
+      from ||= "reports@#{ENV['HOST'].delete_prefix('www.')}" if ENV['HOST'].present?
+
+      from ||= 'reports@example.com' if Rails.env.development?
+
+      from
+    end
+
+    def application_mailer_default_from
+      return if !defined?(::ApplicationMailer) || ::ApplicationMailer.default[:from].to_s.include?('example.com')
+
+      ::ApplicationMailer.default[:from].presence
+    end
+
+    def mailer_config_from_address
+      return if Rails.application.config.action_mailer.default_url_options&.dig(:host).blank?
+
+      "reports@#{Rails.application.config.action_mailer.default_url_options[:host].delete_prefix('www.')}"
+    end
+  end
+end

data/app/mailers/motor/notifications_mailer.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Motor
+  class NotificationsMailer < ApplicationMailer
+    def notify_mention_email(notification)
+      @notification = notification
+
+      @note = notification.record
+
+      subject =
+        "#{@note.author&.email || 'Anonymous'} mentioned you in " \
+        "#{@note.record.class.model_name.human} ##{@note.record.id}"
+
+      mail(
+        from: from_address,
+        to: notification.recipient.email,
+        subject: subject
+      )
+    end
+
+    def notify_reminder_email(notification)
+      @notification = notification
+
+      @note = notification.record.record
+
+      mail(
+        from: from_address,
+        to: notification.recipient.email,
+        subject: "Reminder for #{@note.record.class.model_name.human} ##{@note.record.id}"
+      )
+    end
+  end
+end

data/app/models/motor/alert.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Motor
+  class Alert < ::Motor::ApplicationRecord
+    audited
+
+    belongs_to :query
+    belongs_to :author, polymorphic: true, optional: true
+
+    has_many :alert_locks, dependent: :destroy
+    has_many :taggable_tags, as: :taggable, dependent: :destroy
+    has_many :tags, through: :taggable_tags, class_name: 'Motor::Tag'
+
+    attribute :preferences, default: -> { ActiveSupport::HashWithIndifferentAccess.new }
+
+    if Rails.version.to_f >= 7.1
+      serialize :preferences, coder: HashSerializer
+    else
+      serialize :preferences, HashSerializer
+    end
+
+    scope :active, -> { where(deleted_at: nil) }
+    scope :enabled, -> { where(is_enabled: true) }
+
+    def cron
+      @cron ||=
+        Fugit::Nat.parse("#{preferences[:interval]} #{ActiveSupport::TimeZone::MAPPING[preferences[:timezone]]}")
+    end
+  end
+end

data/app/models/motor/alert_lock.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Motor
+  class AlertLock < ::Motor::ApplicationRecord
+    belongs_to :alert
+  end
+end

data/app/models/motor/api_config.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Motor
+  class ApiConfig < ::Motor::ApplicationRecord
+    encrypts :credentials if defined?(::Motor::EncryptedConfig)
+
+    attribute :preferences, default: -> { ActiveSupport::HashWithIndifferentAccess.new }
+    attribute :credentials, default: -> { ActiveSupport::HashWithIndifferentAccess.new }
+
+    if Rails.version.to_f >= 7.1
+      serialize :credentials, coder: Motor::HashSerializer
+      serialize :preferences, coder: Motor::HashSerializer
+    else
+      serialize :credentials, Motor::HashSerializer
+      serialize :preferences, Motor::HashSerializer
+    end
+
+    has_one :form, dependent: nil, foreign_key: :api_config_name, primary_key: :name, inverse_of: :api_config
+
+    scope :active, -> { where(deleted_at: nil) }
+
+    def headers
+      credentials.fetch(:headers, []).each_with_object({}) do |item, acc|
+        acc[item[:key]] = item[:value]
+      end
+    end
+  end
+end

data/app/models/motor/application_record.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Motor
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+    self.table_name_prefix = 'motor_'
+
+    def self.audited(*args)
+      default_class = Audited.audit_class
+
+      Audited.audit_class = 'Motor::Audit'
+
+      super
+    ensure
+      Audited.audit_class = default_class
+    end
+  end
+end

data/app/models/motor/audit.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Motor
+  class Audit < Audited::Audit
+    self.table_name = 'motor_audits'
+
+    if Rails.version.to_f >= 7.1
+      serialize :audited_changes, coder: HashSerializer
+    else
+      serialize :audited_changes, HashSerializer
+    end
+  end
+end

data/app/models/motor/config.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Motor
+  class Config < ::Motor::ApplicationRecord
+    audited
+
+    if Rails.version.to_f >= 7.1
+      serialize :value, coder: HashSerializer
+    else
+      serialize :value, HashSerializer
+    end
+  end
+end

data/app/models/motor/dashboard.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Motor
+  class Dashboard < ::Motor::ApplicationRecord
+    audited
+
+    belongs_to :author, polymorphic: true, optional: true
+
+    has_many :taggable_tags, as: :taggable, dependent: :destroy
+    has_many :tags, through: :taggable_tags, class_name: 'Motor::Tag'
+
+    attribute :preferences, default: -> { ActiveSupport::HashWithIndifferentAccess.new }
+
+    if Rails.version.to_f >= 7.1
+      serialize :preferences, coder: HashSerializer
+    else
+      serialize :preferences, HashSerializer
+    end
+
+    scope :active, -> { where(deleted_at: nil) }
+
+    def queries
+      Motor::Query.where(id: preferences[:layout].pluck(:query_id))
+    end
+  end
+end

data/app/models/motor/form.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Motor
+  class Form < ::Motor::ApplicationRecord
+    audited
+
+    belongs_to :author, polymorphic: true, optional: true
+    belongs_to :api_config, foreign_key: :api_config_name, primary_key: :name, inverse_of: :form
+
+    has_many :taggable_tags, as: :taggable, dependent: :destroy
+    has_many :tags, through: :taggable_tags, class_name: 'Motor::Tag'
+
+    attribute :preferences, default: -> { ActiveSupport::HashWithIndifferentAccess.new }
+
+    if Rails.version.to_f >= 7.1
+      serialize :preferences, coder: HashSerializer
+    else
+      serialize :preferences, HashSerializer
+    end
+
+    scope :active, -> { where(deleted_at: nil) }
+  end
+end