motor-admin 0.1.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2d6f58a141ea2313b151ee2648a4b98ea3327b8f81b5d7473d8f4a36e6ffb7a4
+  data.tar.gz: b30868890700641a08cff0abc865e736823def3b066ca8bf38c4968dddd3e2b4
+SHA512:
+  metadata.gz: cc33e35f237bc0d15c57da84d67276efa2b26bc09d6b19845a1f6438f81c4e42ec0d5a64274aecaa817faacbde7d5f5c11245b3a0c81f97e3c3e99c808e8b7ec
+  data.tar.gz: 44152701924a0f006ed102080b612db45a9ca76caf6180c58ad04ec4eb6f8e2210e667a9ceec5228d7a9854a77fca67bf86d0660b655c7715bd71875e4d4a4d7

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2021 Pete Matsyburka
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,32 @@
+# Motor
+
+Admin UI and Business Analytics.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'motor-admin'
+```
+
+And then execute:
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+```bash
+$ gem install motor-admin
+```
+
+Create and run migration:
+```bash
+$ rails generate motor:install && rake db:migrate
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+APP_RAKEFILE = File.expand_path('test/dummy/Rakefile', __dir__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/app/controllers/motor/alerts_controller.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Motor
+  class AlertsController < ApiBaseController
+    load_and_authorize_resource :alert, only: %i[index show update destroy]
+
+    before_action :build_alert, only: :create
+    authorize_resource :alert, only: :create
+
+    def index
+      render json: { data: Motor::ApiQuery::BuildJson.call(@alerts.active, params) }
+    end
+
+    def show
+      render json: { data: Motor::ApiQuery::BuildJson.call(@alert, params) }
+    end
+
+    def create
+      ApplicationRecord.transaction { @alert.save! }
+      Motor::Alerts::ScheduledAlertsCache.clear
+
+      render json: { data: Motor::ApiQuery::BuildJson.call(@alert, params) }
+    rescue Motor::Alerts::Persistance::NameAlreadyExists
+      name_already_exists_response
+    rescue Motor::Alerts::Persistance::InvalidInterval
+      invalid_interval_response
+    end
+
+    def update
+      Motor::Alerts::Persistance.update_from_params!(@alert, alert_params)
+      Motor::Alerts::ScheduledAlertsCache.clear
+
+      render json: { data: Motor::ApiQuery::BuildJson.call(@alert, params) }
+    rescue Motor::Alerts::Persistance::NameAlreadyExists
+      name_already_exists_response
+    rescue Motor::Alerts::Persistance::InvalidInterval
+      invalid_interval_response
+    end
+
+    def destroy
+      @alert.update!(deleted_at: Time.current)
+
+      head :ok
+    end
+
+    private
+
+    def name_already_exists_response
+      render json: { errors: [{ source: 'name', detail: 'Name already exists' }] },
+             status: :unprocessable_entity
+    end
+
+    def invalid_interval_response
+      render json: { errors: [{ source: 'preferences.interval', detail: 'Invalid interval' }] },
+             status: :unprocessable_entity
+    end
+
+    def build_alert
+      @alert = Motor::Alerts::Persistance.build_from_params(alert_params)
+    end
+
+    def alert_params
+      params.require(:data).permit(
+        :query_id,
+        :name,
+        :description,
+        :to_emails,
+        :is_enabled,
+        preferences: {},
+        tags: []
+      )
+    end
+  end
+end

data/app/controllers/motor/api_base_controller.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Motor
+  class ApiBaseController < ActionController::API
+    def current_user
+      if defined?(current_admin)
+        current_admin
+      elsif defined?(current_admin_user)
+        current_admin_user
+      elsif defined?(super)
+        super
+      end
+    end
+
+    def current_ability
+      klass = Class.new
+      klass.include(CanCan::Ability)
+      klass.define_method(:initialize) do |_user|
+        can :manage, :all
+      end
+
+      klass.new(current_user)
+    end
+  end
+end

data/app/controllers/motor/application_controller.rb

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

data/app/controllers/motor/assets_controller.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Motor
+  class AssetsController < ActionController::Metal
+    CACHE_STORE = ActiveSupport::Cache::MemoryStore.new
+
+    GZIP_TYPES = [
+      'application/javascript',
+      'text/css'
+    ].freeze
+
+    def show
+      filename = params[:filename]
+
+      return [404, {}, ''] unless Motor::Assets.manifest.values.include?(filename)
+
+      self.response_body = CACHE_STORE.fetch(filename) do
+        Motor::Assets.load_asset(filename)
+      end
+
+      headers['Content-Type'] = Marcel::MimeType.for(name: filename)
+
+      headers['Content-Encoding'] = 'gzip' if !Motor.development? && GZIP_TYPES.include?(headers['Content-Type'])
+
+      headers['Cache-Control'] = 'max-age=31536000'
+    end
+  end
+end

data/app/controllers/motor/configs_controller.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Motor
+  class ConfigsController < ApiBaseController
+    load_and_authorize_resource
+
+    def index
+      render json: { data: Motor::ApiQuery::BuildJson.call(@configs, params) }
+    end
+
+    def create
+      @config =
+        Motor::Config.find_or_initialize_by(key: @config.key).tap do |config|
+          config.value = @config.value
+        end
+
+      @config.save!
+
+      render json: { data: Motor::ApiQuery::BuildJson.call(@config, params) }
+    rescue ActiveRecord::RecordNotUnique
+      retry
+    end
+
+    private
+
+    def config_params
+      params.require(:data).permit!
+    end
+  end
+end

data/app/controllers/motor/dashboards_controller.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Motor
+  class DashboardsController < ApiBaseController
+    load_and_authorize_resource :dashboard, only: %i[index show update destroy]
+
+    before_action :build_dashboard, only: :create
+    authorize_resource :dashboard, only: :create
+
+    def index
+      render json: { data: Motor::ApiQuery::BuildJson.call(@dashboards.active, params) }
+    end
+
+    def show
+      render json: { data: Motor::ApiQuery::BuildJson.call(@dashboard, params) }
+    end
+
+    def create
+      if Motor::Dashboards::Persistance.title_already_exists?(@dashboard)
+        render json: { errors: [{ source: 'title', detail: 'Title already exists' }] }, status: :unprocessable_entity
+      else
+        ApplicationRecord.transaction { @dashboard.save! }
+
+        render json: { data: Motor::ApiQuery::BuildJson.call(@dashboard, params) }
+      end
+    rescue ActiveRecord::RecordNotUnique
+      retry
+    end
+
+    def update
+      Motor::Dashboards::Persistance.update_from_params!(@dashboard, dashboard_params)
+
+      render json: { data: Motor::ApiQuery::BuildJson.call(@dashboard, params) }
+    rescue Motor::Dashboards::Persistance::TitleAlreadyExists
+      render json: { errors: [{ source: 'title', detail: 'Title already exists' }] }, status: :unprocessable_entity
+    end
+
+    def destroy
+      @dashboard.update!(deleted_at: Time.current)
+
+      head :ok
+    end
+
+    private
+
+    def build_dashboard
+      @dashboard = Motor::Dashboards::Persistance.build_from_params(dashboard_params)
+    end
+
+    def dashboard_params
+      params.require(:data).permit(:title, :description, preferences: {}, tags: [])
+    end
+  end
+end

data/app/controllers/motor/data_controller.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Motor
+  class DataController < ApiBaseController
+    INSTANCE_VARIABLE_NAME = 'resource'
+
+    before_action :load_and_authorize_resource
+    before_action :load_and_authorize_association
+
+    def index
+      @resources = Motor::ApiQuery.call(@resources, params)
+
+      render json: {
+        data: Motor::ApiQuery::BuildJson.call(@resources, params),
+        meta: Motor::ApiQuery::BuildMeta.call(@resources, params)
+      }
+    end
+
+    def show
+      render json: { data: Motor::ApiQuery::BuildJson.call(@resource, params) }
+    end
+
+    def create
+      @resource.save!
+
+      render json: { data: Motor::ApiQuery::BuildJson.call(@resource, params) }
+    end
+
+    def update
+      @resource.update!(resource_params)
+
+      render json: { data: Motor::ApiQuery::BuildJson.call(@resource, params) }
+    end
+
+    def destroy
+      if @resource.respond_to?(:deleted_at)
+        @resource.update(deleted_at: Time.current)
+      else
+        @resource.destroy!
+      end
+
+      head :ok
+    end
+
+    def execute
+      @resource.public_send(params[:method].to_sym)
+
+      head :ok
+    rescue StandardError => e
+      render json: { message: e.message }, status: :unprocessable_entity
+    end
+
+    private
+
+    def resource_class
+      @resource_class ||= Motor::BuildSchema::Utils.classify_slug(params[:resource])
+    end
+
+    def load_and_authorize_resource
+      options = {
+        class: resource_class,
+        parent: false,
+        instance_name: INSTANCE_VARIABLE_NAME
+      }
+
+      if params[:resource_id].present?
+        options = options.merge(
+          parent: true,
+          id_param: :resource_id
+        )
+      end
+
+      CanCan::ControllerResource.new(
+        self,
+        options
+      ).load_and_authorize_resource
+    end
+
+    def load_and_authorize_association
+      return if params[:association].blank?
+
+      association = resource_class.reflections[params[:association]]
+
+      if association
+        CanCan::ControllerResource.new(
+          self,
+          class: association.klass,
+          parent: false,
+          through: :resource,
+          through_association: params[:association].to_sym,
+          instance_name: INSTANCE_VARIABLE_NAME
+        ).load_and_authorize_resource
+      else
+        render json: { message: 'Unknown association' }, status: :not_found
+      end
+    end
+
+    def resource_params
+      params.fetch(:data, {}).except(resource_class.primary_key).permit!
+    end
+  end
+end

data/app/controllers/motor/forms_controller.rb

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