motor-admin 0.1.9

data/app/controllers/motor/queries_controller.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Motor
+  class QueriesController < ApiBaseController
+    load_and_authorize_resource :query, only: %i[index show update destroy]
+
+    before_action :build_query, only: :create
+    authorize_resource :query, only: :create
+
+    def index
+      render json: { data: Motor::ApiQuery::BuildJson.call(@queries.active, params) }
+    end
+
+    def show
+      render json: { data: Motor::ApiQuery::BuildJson.call(@query, params) }
+    end
+
+    def create
+      if Motor::Queries::Persistance.name_already_exists?(@query)
+        render json: { errors: [{ source: 'name', detail: 'Name already exists' }] }, status: :unprocessable_entity
+      else
+        ApplicationRecord.transaction { @query.save! }
+
+        render json: { data: Motor::ApiQuery::BuildJson.call(@query, params) }
+      end
+    rescue ActiveRecord::RecordNotUnique
+      retry
+    end
+
+    def update
+      Motor::Queries::Persistance.update_from_params!(@query, query_params)
+
+      render json: { data: Motor::ApiQuery::BuildJson.call(@query, params) }
+    rescue Motor::Queries::Persistance::NameAlreadyExists
+      render json: { errors: [{ source: 'name', detail: 'Name already exists' }] }, status: :unprocessable_entity
+    end
+
+    def destroy
+      @query.update!(deleted_at: Time.current)
+
+      head :ok
+    end
+
+    private
+
+    def build_query
+      @query = Motor::Queries::Persistance.build_from_params(query_params)
+    end
+
+    def query_params
+      params.require(:data).permit(:name, :sql_body, :description, preferences: {}, tags: [])
+    end
+  end
+end

data/app/controllers/motor/resource_methods_controller.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Motor
+  class ResourceMethodsController < ApiBaseController
+    before_action :authorize_resource
+
+    def show
+      render json: { data: ActiveRecordUtils::FetchMethods.call(resource_class) }
+    end
+
+    private
+
+    def resource_class
+      @resource_class ||= Motor::BuildSchema::Utils.classify_slug(params[:resource])
+    end
+
+    def authorize_resource
+      authorize!(resource_class, :manage)
+    end
+  end
+end

data/app/controllers/motor/resources_controller.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Motor
+  class ResourcesController < ApiBaseController
+    load_and_authorize_resource
+
+    def index
+      render json: { data: Motor::ApiQuery::BuildJson.call(@resources, params) }
+    end
+
+    def create
+      Motor::BuildSchema::PersistResourceConfigs.call(@resource)
+
+      render json: { data: Motor::ApiQuery::BuildJson.call(@resource, params) }
+    end
+
+    private
+
+    def resource_params
+      params.require(:data).permit!
+    end
+  end
+end

data/app/controllers/motor/run_queries_controller.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Motor
+  class RunQueriesController < ApiBaseController
+    load_and_authorize_resource :query, only: :show, parent: false
+
+    before_action :build_query, only: :create
+    authorize_resource :query, only: :create
+
+    rescue_from 'ActiveRecord::StatementInvalid' do |e|
+      render json: { errors: [{ detail: e.message }] }, status: :unprocessable_entity
+    end
+
+    def show
+      render json: query_result_hash(query_result)
+    end
+
+    def create
+      render json: query_result_hash(query_result)
+    end
+
+    private
+
+    def query_result
+      Queries::RunQuery.call(@query, variables_hash: params[:variables])
+    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
+  end
+end

data/app/controllers/motor/schemas_controller.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Motor
+  class SchemasController < ApiBaseController
+    def show
+      render json: Motor::BuildSchema.call
+    end
+
+    def update; end
+  end
+end

data/app/controllers/motor/send_alerts_controller.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Motor
+  class SendAlertsController < ApiBaseController
+    before_action :build_alert, only: :create
+    authorize_resource :alert, only: :create
+
+    def create
+      AlertsMailer.alert_email(@alert).deliver_now!
+
+      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)
+    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 }
+    end
+  end
+end

data/app/controllers/motor/ui_controller.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Motor
+  class UiController < ApplicationController
+    layout 'motor/application'
+
+    def index
+      Motor.reload! if Motor.development?
+
+      render :show
+    end
+
+    def show
+      Motor.reload! if Motor.development?
+
+      render :show
+    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::AlertsMailer.alert_email(alert).deliver_now!
+    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/mailers/motor/alerts_mailer.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Motor
+  class AlertsMailer < ApplicationMailer
+    def alert_email(alert)
+      @alert = alert
+      @query_result = Queries::RunQuery.call(alert.query)
+
+      return if @alert.preferences[:send_empty].blank? && @query_result.data.blank?
+
+      attachments["#{alert.name.presence || 'data'}.csv"] = generate_csv(@query_result)
+
+      mail(
+        from: from_address,
+        to: alert.to_emails,
+        subject: alert.name.presence || @alert.query.name
+      )
+    end
+
+    private
+
+    def generate_csv(_query_result)
+      rows = [@query_result.columns.pluck(:name)] + @query_result.data
+
+      rows.map(&:to_csv).join
+    end
+
+    def from_address
+      from = ENV['MOTOR_ADMIN_FROM_ADDRESS'].presence
+
+      from ||= application_mailer_default_from
+      from ||= mailer_config_from_address
+      from ||= "reports@#{ENV['HOST'].sub(/\Awww\./, '')}" if ENV['HOST'].present?
+
+      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[:host].blank?
+
+      "reports@#{Rails.application.config.action_mailer.default_url_options[:host].sub(/\Awww\./, '')}"
+    end
+  end
+end

data/app/mailers/motor/application_mailer.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Motor
+  class ApplicationMailer < ActionMailer::Base
+    layout 'mailer'
+  end
+end

data/app/models/motor/alert.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Motor
+  class Alert < ApplicationRecord
+    belongs_to :query
+    belongs_to :author, polymorphic: true, optional: true
+
+    has_many :alert_locks
+    has_many :taggable_tags, as: :taggable
+    has_many :tags, through: :taggable_tags, class_name: 'Motor::Tag'
+
+    serialize :preferences, HashSerializer
+
+    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 < ApplicationRecord
+    belongs_to :alert
+  end
+end

data/app/models/motor/application_record.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Motor
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+    self.table_name_prefix = 'motor_'
+  end
+end

data/app/models/motor/config.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Motor
+  class Config < ApplicationRecord
+    serialize :value, HashSerializer
+  end
+end

data/app/models/motor/dashboard.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Motor
+  class Dashboard < ApplicationRecord
+    belongs_to :author, polymorphic: true, optional: true
+
+    has_many :taggable_tags, as: :taggable
+    has_many :tags, through: :taggable_tags, class_name: 'Motor::Tag'
+
+    serialize :preferences, HashSerializer
+
+    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,14 @@
+# frozen_string_literal: true
+
+module Motor
+  class Form < ApplicationRecord
+    belongs_to :author, polymorphic: true, optional: true
+
+    has_many :taggable_tags, as: :taggable
+    has_many :tags, through: :taggable_tags, class_name: 'Motor::Tag'
+
+    serialize :preferences, HashSerializer
+
+    scope :active, -> { where(deleted_at: nil) }
+  end
+end

data/app/models/motor/query.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Motor
+  class Query < ApplicationRecord
+    belongs_to :author, polymorphic: true, optional: true
+
+    has_many :taggable_tags, as: :taggable
+    has_many :tags, through: :taggable_tags, class_name: 'Motor::Tag'
+
+    serialize :preferences, HashSerializer
+
+    scope :active, -> { where(deleted_at: nil) }
+  end
+end

data/app/models/motor/resource.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Motor
+  class Resource < ApplicationRecord
+    serialize :preferences, HashSerializer
+  end
+end

data/app/models/motor/tag.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Motor
+  class Tag < ApplicationRecord
+    has_many :taggable_tags
+  end
+end

data/app/models/motor/taggable_tag.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Motor
+  class TaggableTag < ApplicationRecord
+    belongs_to :tag
+    belongs_to :taggable, polymorphic: true
+  end
+end

data/app/views/layouts/motor/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Motor Admin</title>
+    <meta name="viewport" content="width=device-width,initial-scale=1">
+    <link rel="stylesheet" media="all" href="<%= Motor::Assets.asset_path('main.css') %>">
+    <%= csrf_meta_tags %>
+    <%= csp_meta_tag %>
+  </head>
+  <body>
+    <%= yield %>
+    <script src="<%= Motor::Assets.asset_path('main.js') %>"></script>
+  </body>
+</html>