motor-admin-cstham8 0.4.35

data/app/controllers/motor/assets_controller.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Motor
+  class AssetsController < ActionController::Metal
+    CACHE_STORE = ActiveSupport::Cache::MemoryStore.new
+
+    GZIP_TYPES = [
+      'application/javascript',
+      'text/css',
+      'image/svg+xml'
+    ].freeze
+
+    MIME_TYPES = {
+      '.js' => 'application/javascript',
+      '.css' => 'text/css',
+      '.svg' => 'image/svg+xml',
+      '.png' => 'image/png',
+      '.woff2' => 'font/woff2'
+    }.freeze
+
+    def show
+      filename = params[:filename]
+
+      return [404, {}, ''] unless Motor::Assets.manifest.value?(filename)
+
+      assign_headers(filename)
+
+      self.response_body = CACHE_STORE.fetch(filename) do
+        Motor::Assets.load_asset(filename, gzip: headers['Content-Encoding'] == 'gzip')
+      end
+    end
+
+    private
+
+    def assign_headers(filename)
+      content_type = MIME_TYPES[File.extname(filename)]
+
+      headers['Content-Type'] = content_type
+      headers['Content-Encoding'] = 'gzip' if !Motor.development? && GZIP_TYPES.include?(content_type)
+      headers['Cache-Control'] = 'max-age=31536000'
+    end
+  end
+end

data/app/controllers/motor/audits_controller.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Motor
+  class AuditsController < ApiBaseController
+    load_and_authorize_resource :audit
+
+    def index
+      audits = Motor::ApiQuery.call(@audits, params)
+
+      render json: {
+        data: Motor::ApiQuery::BuildJson.call(audits, params, current_ability),
+        meta: Motor::ApiQuery::BuildMeta.call(audits, params)
+      }
+    end
+  end
+end

data/app/controllers/motor/auth_tokens_controller.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Motor
+  class AuthTokensController < ApiBaseController
+    GENERIC_TOKEN_TTL = 2.hours
+
+    skip_authorization_check
+
+    def create
+      return render json: {} unless current_user
+
+      if defined?(Devise::JWT)
+        respond_with_devise_jwt
+      elsif defined?(JWT)
+        respond_with_generic_jwt
+      else
+        render json: {}
+      end
+    end
+
+    private
+
+    def respond_with_devise_jwt
+      warden.set_user(current_user)
+
+      render json: { token: request.env['warden-jwt_auth.token'] }
+    end
+
+    def respond_with_generic_jwt
+      payload = { uid: current_user.id, exp: GENERIC_TOKEN_TTL.from_now.to_i }
+      token = JWT.encode(payload, Rails.application.credentials.secret_key_base)
+
+      render json: { token: token }
+    end
+  end
+end

data/app/controllers/motor/configs_controller.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Motor
+  class ConfigsController < ApiBaseController
+    wrap_parameters :data, except: %i[include fields]
+
+    load_and_authorize_resource
+
+    def index
+      render json: { data: Motor::ApiQuery::BuildJson.call(@configs, params, current_ability) }
+    end
+
+    def create
+      @config =
+        Motor::Config.find_or_initialize_by(key: @config.key).tap do |config|
+          config.value = @config.value
+        end
+
+      @config.save!
+      Motor::Configs::WriteToFile.call
+
+      render json: { data: Motor::ApiQuery::BuildJson.call(@config, params, current_ability) }
+    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,64 @@
+# frozen_string_literal: true
+
+module Motor
+  class DashboardsController < ApiBaseController
+    wrap_parameters :data, except: %i[include fields]
+
+    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, current_ability) }
+    end
+
+    def show
+      render json: { data: Motor::ApiQuery::BuildJson.call(@dashboard, params, current_ability) }
+    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! }
+        Motor::Configs::WriteToFile.call
+
+        render json: { data: Motor::ApiQuery::BuildJson.call(@dashboard, params, current_ability) }
+      end
+    rescue ActiveRecord::RecordNotUnique
+      retry
+    end
+
+    def update
+      Motor::Dashboards::Persistance.update_from_params!(@dashboard, dashboard_params)
+      Motor::Configs::WriteToFile.call
+
+      render json: { data: Motor::ApiQuery::BuildJson.call(@dashboard, params, current_ability) }
+    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)
+
+      Motor::Configs::WriteToFile.call
+
+      head :ok
+    end
+
+    private
+
+    def build_dashboard
+      @dashboard = Motor::Dashboards::Persistance.build_from_params(dashboard_params)
+
+      @dashboard.define_singleton_method(:tags) do
+        taggable_tags.map(&:tag)
+      end
+    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,88 @@
+# frozen_string_literal: true
+
+module Motor
+  class DataController < ApiBaseController
+    wrap_parameters :data, except: %i[include fields]
+
+    include Motor::WrapIoParams
+    include Motor::LoadAndAuthorizeDynamicResource
+
+    def index
+      @resources = Motor::ApiQuery.call(@resources, params)
+
+      if params[:format] == 'csv'
+        render plain: Motor::ActiveRecordUtils.generate_csv_for_relation(@resources, reset_limit: true)
+      else
+        render json: {
+          data: Motor::ApiQuery::BuildJson.call(@resources, params, current_ability),
+          meta: Motor::ApiQuery::BuildMeta.call(@resources, params)
+        }
+      end
+    end
+
+    def show
+      render json: { data: Motor::ApiQuery::BuildJson.call(@resource, params, current_ability) }
+    end
+
+    def create
+      if @associated_resource
+        if @resource_class.reflections[params[:association]].through_reflection?
+          @associated_resource.save!
+
+          @resource = @associated_resource
+        else
+          @resource.public_send(params[:association].to_sym).create!(resource_params) do |resource|
+            @resource = resource
+          end
+        end
+      else
+        @resource.save!
+      end
+
+      render json: { data: Motor::ApiQuery::BuildJson.call(@resource, params, current_ability) }
+    rescue ActiveRecord::RecordInvalid
+      render json: { errors: @resource.errors }, status: :unprocessable_entity
+    end
+
+    def update
+      @resource.update!(resource_params)
+
+      render json: { data: Motor::ApiQuery::BuildJson.call(@resource, params, current_ability) }
+    rescue ActiveRecord::RecordInvalid
+      render json: { errors: @resource.errors }, status: :unprocessable_entity
+    end
+
+    def destroy
+      if @resource.respond_to?(:deleted_at)
+        @resource.update(deleted_at: Time.current)
+      elsif @resource.respond_to?(:archived_at)
+        @resource.update(archived_at: Time.current)
+      else
+        @resource.destroy!
+      end
+
+      head :ok
+    end
+
+    def execute
+      resource_preferences = Motor::Resource.find_by(name: @resource.class.name.underscore).preferences
+      resource_action = resource_preferences[:actions].find { |a| a.dig(:preferences, :method_name) == params[:method] }
+
+      authorize!(resource_action[:name].to_sym, @resource)
+
+      @resource.public_send(params[:method].to_sym)
+
+      head :ok
+    end
+
+    private
+
+    def resource_params
+      if params[:data].present?
+        params.require(:data).permit!
+      else
+        {}
+      end
+    end
+  end
+end

data/app/controllers/motor/forms_controller.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Motor
+  class FormsController < ApiBaseController
+    wrap_parameters :data, except: %i[include fields]
+
+    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, current_ability) }
+    end
+
+    def show
+      render json: { data: Motor::ApiQuery::BuildJson.call(@form, params, current_ability) }
+    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! }
+        Motor::Configs::WriteToFile.call
+
+        render json: { data: Motor::ApiQuery::BuildJson.call(@form, params, current_ability) }
+      end
+    rescue ActiveRecord::RecordNotUnique
+      retry
+    end
+
+    def update
+      Motor::Forms::Persistance.update_from_params!(@form, form_params)
+      Motor::Configs::WriteToFile.call
+
+      render json: { data: Motor::ApiQuery::BuildJson.call(@form, params, current_ability) }
+    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)
+
+      Motor::Configs::WriteToFile.call
+
+      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,
+                                   :api_config_name, preferences: {}, tags: [])
+    end
+  end
+end

data/app/controllers/motor/icons_controller.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Motor
+  class IconsController < ApiBaseController
+    skip_authorization_check
+
+    CACHE_STORE = ActiveSupport::Cache::MemoryStore.new
+
+    def index
+      data = CACHE_STORE.fetch('icons') do
+        Motor::Assets.icons.map do |icon|
+          svg = Motor::Assets.load_asset(icon, gzip: !Motor.development?)
+          svg = ActiveSupport::Gzip.decompress(svg) unless Motor.development?
+
+          [icon.split('/').last, svg]
+        end
+      end
+
+      render json: { data: data }
+    end
+  end
+end

data/app/controllers/motor/note_tags_controller.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Motor
+  class NoteTagsController < ApiBaseController
+    wrap_parameters :data, except: %i[include fields]
+
+    load_and_authorize_resource :note_tag
+
+    def index
+      render json: { data: @note_tags.to_a }
+    end
+  end
+end

data/app/controllers/motor/notes_controller.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Motor
+  class NotesController < ApiBaseController
+    wrap_parameters :data, except: %i[include fields]
+
+    load_and_authorize_resource :note, only: %i[index show update destroy]
+    before_action :build_note, only: :create
+    authorize_resource :note, only: :create
+
+    def index
+      @notes = Motor::ApiQuery.call(@notes.active.order(created_at: :asc), params)
+
+      render json: { data: Motor::ApiQuery::BuildJson.call(@notes, params, current_ability) }
+    end
+
+    def show
+      render json: { data: Motor::ApiQuery::BuildJson.call(@note, params, current_ability) }
+    end
+
+    def create
+      Motor::Notes::Persist.call(@note, current_user)
+      Motor::NotifyNoteMentionsJob.perform_later(@note, current_user)
+
+      render json: { data: Motor::ApiQuery::BuildJson.call(@note, params, current_ability) }
+    end
+
+    def update
+      @note.assign_attributes(note_params)
+
+      Motor::Notes::Persist.call(@note, current_user)
+      Motor::NotifyNoteMentionsJob.perform_later(@note, current_user)
+
+      render json: { data: Motor::ApiQuery::BuildJson.call(@note, params, current_ability) }
+    end
+
+    def destroy
+      @note.update!(deleted_at: Time.current)
+
+      Motor::NotesChannel.broadcast_to(
+        @note.values_at(:record_type, :record_id).join(':'),
+        ['remove', @note.as_json(only: %i[id body created_at updated_at])]
+      )
+
+      head :ok
+    end
+
+    private
+
+    def build_note
+      @note = Motor::Note.new(note_params.merge(author: current_user))
+    end
+
+    def note_params
+      params.require(:data).permit(:body, :record_id, :record_type)
+    end
+  end
+end

data/app/controllers/motor/notifications_controller.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Motor
+  class NotificationsController < ApiBaseController
+    wrap_parameters :data, except: %i[include fields]
+
+    load_and_authorize_resource :notification
+
+    def index
+      @notifications =
+        Motor::ApiQuery.call(@notifications.where(recipient: current_user).order(created_at: :desc), params)
+
+      render json: {
+        data: Motor::ApiQuery::BuildJson.call(@notifications, params, current_ability),
+        meta: Motor::ApiQuery::BuildMeta.call(@notifications, params)
+      }
+    end
+
+    def update
+      @notification.update!(notification_params)
+
+      Motor::NotificationsChannel.broadcast_to(current_user, ['update', @notification.as_json(include: %i[record])])
+
+      render json: { data: Motor::ApiQuery::BuildJson.call(@notification, params, current_ability) }
+    end
+
+    private
+
+    def notification_params
+      params.require(:data).permit(:status)
+    end
+  end
+end

data/app/controllers/motor/queries_controller.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Motor
+  class QueriesController < ApiBaseController
+    wrap_parameters :data, except: %i[include fields]
+
+    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, current_ability) }
+    end
+
+    def show
+      render json: { data: Motor::ApiQuery::BuildJson.call(@query, params, current_ability) }
+    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 do
+          Motor::Queries::Persistance.assign_or_create_api_config!(@query)
+          @query.save!
+        end
+
+        Motor::Configs::WriteToFile.call
+
+        render json: { data: Motor::ApiQuery::BuildJson.call(@query, params, current_ability) }
+      end
+    rescue ActiveRecord::RecordNotUnique
+      retry
+    end
+
+    def update
+      Motor::Queries::Persistance.update_from_params!(@query, query_params)
+      Motor::Configs::WriteToFile.call
+
+      render json: { data: Motor::ApiQuery::BuildJson.call(@query, params, current_ability) }
+    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)
+
+      Motor::Configs::WriteToFile.call
+
+      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/reminders_controller.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Motor
+  class RemindersController < ApiBaseController
+    wrap_parameters :data, except: %i[include fields]
+
+    load_and_authorize_resource :reminder
+
+    def create
+      @reminder.update!(author: current_user, recipient: current_user)
+
+      broadcast_note_update(@reminder.record)
+
+      render json: { data: Motor::ApiQuery::BuildJson.call(@reminder, params, current_ability) }
+    end
+
+    def destroy
+      @reminder.destroy!
+
+      broadcast_note_update(@reminder.record)
+
+      head :ok
+    end
+
+    private
+
+    def broadcast_note_update(note)
+      Motor::NotesChannel.broadcast_to(
+        note.values_at(:record_type, :record_id).join(':'),
+        ['update', note.as_json(include: %i[author tags reminders])]
+      )
+    end
+
+    def reminder_params
+      params.require(:data).permit(:record_id, :record_type, :scheduled_at)
+    end
+  end
+end

data/app/controllers/motor/resource_default_queries_controller.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Motor
+  class ResourceDefaultQueriesController < ApiBaseController
+    skip_authorization_check
+
+    before_action :authorize_resource
+
+    def show
+      render json: { data: { sql: resource_class.all.to_sql } }
+    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/resource_methods_controller.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Motor
+  class ResourceMethodsController < ApiBaseController
+    skip_authorization_check
+
+    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,26 @@
+# frozen_string_literal: true
+
+module Motor
+  class ResourcesController < ApiBaseController
+    wrap_parameters :data, except: %i[include fields]
+
+    load_and_authorize_resource
+
+    def index
+      render json: { data: Motor::ApiQuery::BuildJson.call(@resources, params, current_ability) }
+    end
+
+    def create
+      Motor::Resources::PersistConfigs.call(@resource)
+      Motor::Configs::WriteToFile.call
+
+      render json: { data: Motor::ApiQuery::BuildJson.call(@resource, params, current_ability) }
+    end
+
+    private
+
+    def resource_params
+      params.require(:data).permit!
+    end
+  end
+end