atomic_admin 1.1.1 → 2.0.0.beta.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b625a67a9d862fc3a6de28702d21bcff133db94852681e71e53fb5550dc34b7b
-  data.tar.gz: 70ba323f076abdfcf245005cbfcdb55c882866bb1626ceab0909591b8afd1904
+  metadata.gz: 2877b41feec63fee9094438e6f3567435f0be06d1fd38935c572b17e607a8591
+  data.tar.gz: 83ff3c84cddad21e5f3799934df38ccd3b54d7b0457388bf6d34f8314da788fc
 SHA512:
-  metadata.gz: 405ba65b9b8ad2d229b89a3d4f176173af15cc42005685d403b9b1524b0902701103ee8a49b2bb6c1013b37d097cc3495c70dec02e9a1a6266fbd3a52193720e
-  data.tar.gz: b2006e527199b2619ba4809b99d41e99e999fff209bd731413ae7647bcba13f5a9fb4beb95af9a1c69308120fda89fd7603d16eee97f01c07cf7a04f15dfff80
+  metadata.gz: 0ce24f660fc4df2bce27318395eacd4debae6dc22a190271dd039b611902139ea1a9c6b6dba3d9e4191d1f864379e55d9567e8bd1298324d6567bd837e262975
+  data.tar.gz: 93c96f5d173f20a59af47ed1740f1f5a0c9bbe5f03b9eed2111f88bf4b1e0cae42224eb554734bfb5942bb6de9e6d67dbb3951b7d00a56041ca56d4b133b1702

data/app/controllers/atomic_admin/api/admin/v1/application_instances_controller.rb

@@ -0,0 +1,3 @@
+module AtomicAdmin::Api::Admin::V1
+  ApplicationInstancesController = AtomicAdmin::V1::ApplicationInstancesController
+end

data/app/controllers/atomic_admin/api/admin/v1/applications_controller.rb

@@ -0,0 +1,3 @@
+module AtomicAdmin::Api::Admin::V1
+  ApplicationsController = AtomicAdmin::V1::ApplicationsController
+end

data/app/controllers/atomic_admin/api/admin/v1/lti_installs_controller.rb

@@ -0,0 +1,3 @@
+module AtomicAdmin::Api::Admin::V1
+  LtiInstallsController = AtomicAdmin::V1::LtiInstallsController
+end

data/app/controllers/atomic_admin/api/admin/v1/lti_platforms_controller.rb

@@ -0,0 +1,3 @@
+module AtomicAdmin::Api::Admin::V1
+  LtiPlatformsController = AtomicAdmin::V1::LtiPlatformsController
+end

data/app/controllers/atomic_admin/api/admin/v1/sites_controller.rb

@@ -0,0 +1,3 @@
+module AtomicAdmin::Api::Admin::V1
+  SitesController = AtomicAdmin::V1::SitesController
+end

data/app/controllers/atomic_admin/api/admin/v1/tenant_client_id_strategies_controller.rb

@@ -0,0 +1,3 @@
+module AtomicAdmin::Api::Admin::V1
+  TenantClientIdStrategiesController = AtomicAdmin::V1::TenantClientIdStrategiesController
+end

data/app/controllers/atomic_admin/api/admin/v1/tenant_deployments_controller.rb

@@ -0,0 +1,3 @@
+module AtomicAdmin::Api::Admin::V1
+  TenantDeploymentsController = AtomicAdmin::V1::TenantDeploymentsController
+end

data/app/controllers/atomic_admin/api/admin/v1/tenant_platform_guid_strategies_controller.rb

@@ -0,0 +1,3 @@
+module AtomicAdmin::Api::Admin::V1
+  TenantPlatformGuidStrategiesController = AtomicAdmin::V1::TenantPlatformGuidStrategiesController
+end

data/app/controllers/atomic_admin/v1/admin_controller.rb

@@ -0,0 +1,49 @@
+module AtomicAdmin::V1
+  class AdminController < ActionController::API
+    include RequireJwtToken
+    before_action :only_admins!
+
+    rescue_from ActiveRecord::RecordNotFound, with: :record_not_found
+    def record_not_found
+      render_error(:not_found)
+    end
+
+
+    protected
+
+    def json_for(resource)
+      resource.as_json
+    end
+
+    def json_for_collection(collection)
+      collection.map { |resource| json_for(resource) }
+    end
+
+    private
+
+    def render_error(type, message: nil)
+      case type
+      when :not_found
+        [404, { type: "not_found", message: "Record not found" }]
+      else
+        [500, { type: "unknown", message: "An error occurred" }]
+      end => [status, error]
+
+      if message.present?
+        error[:message] = message
+      end
+
+      render json: error, status: status
+    end
+
+    def only_admins!
+      return if is_atomic_admin?
+
+      user_not_authorized if current_user.blank? && !current_user.admin?
+    end
+
+    def user_not_authorized(message = "Not Authorized")
+      render json: { message: message, }, status: 401
+    end
+  end
+end

data/app/controllers/atomic_admin/v1/application_instances_controller.rb

@@ -0,0 +1,127 @@
+module AtomicAdmin::V1
+  class ApplicationInstancesController < AdminController
+    include Filtering
+
+    allowed_sort_columns %w[nickname]
+    allowed_search_columns %w[nickname]
+
+    def index
+      @application_instances = ApplicationInstance.where(application_id: params[:application_id])
+      @application_instances =
+        if type == "paid"
+          @application_instances.where.not(paid_at: nil)
+        else
+          @application_instances.where(paid_at: nil)
+        end
+
+      @application_instances, meta = filter(@application_instances)
+
+      render json: {
+        application_instances: json_for_collection(@application_instances),
+        meta:
+      }
+    end
+
+    def stats
+      render json: { stats: [] }
+    end
+
+    def show
+      @application_instance = ApplicationInstance.find(params[:id])
+      render json: { application_instance: json_for(@application_instance) }
+    end
+
+    def create
+      application = Application.find(params[:application_id])
+      instance = application.application_instances.new(create_params)
+
+      if instance.save
+        render json: { application_instance: json_for(instance) }
+      else
+        render json: { errors: instance.errors }, status: 422
+      end
+    end
+
+    def update
+      instance = ApplicationInstance.find(params[:id])
+      instance.update(update_params)
+
+      if params[:application_instance][:is_paid] && instance.paid_at.nil?
+        instance.paid_at = DateTime.now
+      elsif params[:application_instance][:is_paid] == false && instance.paid_at.present?
+        instance.paid_at = nil
+      end
+
+      if instance.save
+        render json: { application_instance: json_for(instance) }
+      else
+        render json: { errors: instance.errors }, status: 422
+      end
+    end
+
+    def destroy
+      instance = ApplicationInstance.find(params[:id])
+      instance.destroy
+      render json: { success: true }
+    end
+
+    def interactions
+      instance = ApplicationInstance.find(params[:id])
+      interactions = AtomicAdmin.application_instance_interactions.resolve(application_instance: instance)
+      render json: { interactions: interactions }
+    end
+
+    def json_for(instance)
+      json = instance.as_json(include: [:application, :site])
+
+      json["trial_start_date"] = instance.trial_start_date&.strftime("%Y-%m-%d") if instance.respond_to?(:trial_start_date)
+      json["trial_end_date"] = instance.trial_end_date&.strftime("%Y-%m-%d") if instance.respond_to?(:trial_end_date)
+      json["license_start_date"] = instance.license_start_date&.strftime("%Y-%m-%d") if instance.respond_to?(:license_start_date)
+      json["license_end_date"] = instance.license_end_date&.strftime("%Y-%m-%d") if instance.respond_to?(:license_end_date)
+      json["is_paid"] = instance.paid_at.present? if instance.respond_to?(:paid_at)
+      json["lti_config_xml"] = instance.lti_config_xml if instance.respond_to?(:lti_config_xml)
+
+      json
+    end
+
+    protected
+
+    def sortable_columns
+      [
+        "created_at",
+        "trial_end_date",
+        "trial_users",
+        "license_end_date",
+        "licensed_users",
+        "nickname",
+      ]
+    end
+
+    def sort_column
+      sortable_columns.include?(params[:sort_on]) ? params[:sort_on] : "created_at"
+    end
+
+    def sort_direction
+      {
+        "ascending" => "asc",
+        "descending" => "desc",
+      }.fetch(params[:sort_direction], "desc")
+    end
+
+    def type
+      params[:type] == "paid" ? "paid" : "evals"
+    end
+
+    def search
+      params[:search]
+    end
+
+    def create_params
+      params.require(:application_instance).except(:is_paid, :lti_config_xml, :site, :application).permit!
+    end
+
+    def update_params
+      create_params
+    end
+  end
+end

data/app/controllers/atomic_admin/v1/applications_controller.rb

@@ -0,0 +1,49 @@
+module AtomicAdmin::V1
+  class ApplicationsController < AdminController
+    include Filtering
+
+    allowed_sort_columns %w[name]
+    allowed_search_columns %w[name]
+
+    def index
+      @applications, meta = filter(Application.all.lti)
+      render json: { applications:  json_for_collection(@applications), meta: }
+    end
+
+    def show
+      @application = Application.find(params[:id])
+      render json: { application: json_for(@application) }
+    end
+
+    def update
+      @application = Application.find(params[:id])
+
+      # Strong params doesn't allow abritrary json, so we need to set the values manually
+      @application.default_config = params[:default_config]
+      @application.canvas_api_permissions = params[:canvas_api_permissions]
+
+      @application.update!(update_params)
+      render json: { application: json_for(@application) }
+    end
+
+    def interactions
+      application = Application.find(params[:id])
+      interactions = AtomicAdmin.application_interactions.resolve(application: application)
+      render json: { interactions: interactions }
+    end
+
+    def json_for(application)
+      json = application.as_json.with_indifferent_access
+      secret = json[:oauth_secret]
+      json[:oauth_secret_preview] = secret[0..2] + '*' * (secret.length - 3) if secret
+
+      json
+    end
+
+    protected
+
+    def update_params
+      params.require(:application).permit!
+    end
+  end
+end

data/app/controllers/atomic_admin/{atomic_lti_install_controller.rb → v1/lti_installs_controller.rb}

@@ -1,19 +1,11 @@
-module AtomicAdmin
-  class AtomicLtiInstallController < ApplicationController
-    def install_params
-      params.permit(:iss, :client_id)
-    end
-
-    def find_install
-      AtomicLti::Install.find_by(id: params[:id])
-    end
-
+module AtomicAdmin::V1
+  class LtiInstallsController < AdminController
     def index
       render json: AtomicLti::Install.all.order(:id).paginate(page: params[:page], per_page: 30)
     end
 
     def create
-      AtomicLti::Install.create!(install_params)
+      AtomicLti::Install.create!(create_params)
     end
 
     def show
@@ -23,7 +15,7 @@ module AtomicAdmin
 
     def update
       install = find_install
-      result = install.update!(install_params)
+      result = install.update!(update_params)
       render json: result
     end
 
@@ -32,5 +24,19 @@ module AtomicAdmin
       install.destroy
       render json: install
     end
+
+    protected
+
+    def find_install
+      AtomicLti::Install.find_by(id: params[:id])
+    end
+
+    def create_params
+      params.require(:install).permit!
+    end
+
+    def update_params
+      params.require(:install).permit!
+    end
   end
 end

data/app/controllers/atomic_admin/v1/lti_platforms_controller.rb

@@ -0,0 +1,50 @@
+module AtomicAdmin::V1
+  class LtiPlatformsController < AdminController
+    include Filtering
+
+    allowed_search_columns %w[iss]
+    allowed_sort_columns %w[iss]
+
+    def index
+      platforms, meta = filter(AtomicLti::Platform.all)
+
+      render json: { platforms:, meta: }
+    end
+
+    def create
+      platform = AtomicLti::Platform.create!(create_params)
+      render json: { platform: platform }
+    end
+
+    def show
+      platform = find_platform
+      render json: platform
+    end
+
+    def update
+      platform = find_platform
+      platform.update!(update_params)
+      render json: { platform: find_platform }
+    end
+
+    def destroy
+      platform = find_platform
+      platform.destroy
+      render json: platform
+    end
+
+    protected
+
+    def create_params
+      params.require(:platform).permit!
+    end
+
+    def update_params
+      params.require(:platform).permit!
+    end
+
+    def find_platform
+      AtomicLti::Platform.find_by(id: params[:id])
+    end
+  end
+end

data/app/controllers/atomic_admin/v1/sites_controller.rb

@@ -0,0 +1,46 @@
+module AtomicAdmin::V1
+  class SitesController < AdminController
+    include Filtering
+
+    allowed_search_columns %w[url]
+    allowed_sort_columns %w[url]
+
+    def index
+      @sites = Site.all
+      sites, meta = filter(@sites)
+      render json: { sites: json_for_collection(sites), meta: }
+    end
+
+    def create
+      @site = Site.create!(create_params)
+      render json: { site: json_for(@site) }
+    end
+
+    def update
+      @site = Site.find(params[:id])
+      @site.update!(update_params)
+      render json: { site: json_for(@site) }
+    end
+
+    def destroy
+      @site = Site.find(params[:id])
+      @site.destroy!
+      render json: { site: json_for(@site) }
+    end
+
+    protected
+
+    def json_for(site)
+      site.as_json
+    end
+
+    def create_params
+      params.require(:site).permit!
+    end
+
+    def update_params
+      binding.break
+      params.require(:site).permit!
+    end
+  end
+end

data/app/controllers/atomic_admin/v1/tenant_client_id_strategies_controller.rb

@@ -0,0 +1,48 @@
+module AtomicAdmin::V1
+  class TenantClientIdStrategiesController < AdminController
+    include Filtering
+
+    allowed_search_columns %w[client_id, iss]
+    allowed_sort_columns %w[client_id, iss]
+
+    def index
+      query = AtomicTenant::PinnedClientId.where(application_instance_id:)
+      page, meta = filter(query)
+
+      render json: {
+        pinned_client_ids: page,
+        meta:
+      }
+    end
+
+    def show
+      pinned_client_id = find_pinned_client_id
+      render json: {pinned_client_id: pinned_client_id}
+    end
+
+    def create
+      result = AtomicTenant::PinnedClientId.create!({**create_params, application_instance_id:})
+      render json: { pinned_client_id: result }
+    end
+
+    def destroy
+      pinned_client_id = find_pinned_client_id
+      pinned_client_id.destroy
+      render json: { pinned_client_id: pinned_client_id }
+    end
+
+    protected
+
+    def application_instance_id
+      params[:application_instance_id] || params[:application_instance_id]
+    end
+
+    def create_params
+      params.require(:pinned_client_id).permit!
+    end
+
+    def find_pinned_client_id
+      AtomicTenant::PinnedClientId.find_by(id: params[:id])
+    end
+  end
+end

data/app/controllers/atomic_admin/v1/tenant_deployments_controller.rb

@@ -0,0 +1,47 @@
+module AtomicAdmin::V1
+  class TenantDeploymentsController < AdminController
+    include Filtering
+
+    allowed_search_columns %w[deployment_id, iss]
+    allowed_sort_columns %w[deployment_id, iss]
+
+    def index
+      page, meta = filter(AtomicTenant::LtiDeployment.where(application_instance_id:))
+
+      render json: {
+        deployments: page,
+        meta:
+      }
+    end
+
+    def create
+      result = AtomicTenant::LtiDeployment.create!({**create_params, application_instance_id:})
+      render json: { deployment: result }
+    end
+
+    def show
+      deployment = find_deployment
+      render json: { deployment: deployment }
+    end
+
+    def destroy
+      deployment = find_deployment
+      deployment.destroy
+      render json: { deployment: deployment }
+    end
+
+    protected
+
+    def application_instance_id
+      params[:application_instance_id]
+    end
+
+    def create_params
+      params.require(:deployment).permit!
+    end
+
+    def find_deployment
+      AtomicTenant::LtiDeployment.find_by(id: params[:id])
+    end
+  end
+end

data/app/controllers/atomic_admin/v1/tenant_platform_guid_strategies_controller.rb

@@ -0,0 +1,63 @@
+module AtomicAdmin::V1
+  class TenantPlatformGuidStrategiesController < AdminController
+    include Filtering
+
+    allowed_search_columns %w[platform_guid, iss]
+    allowed_sort_columns %w[platform_guid, iss]
+
+    def index
+      query = AtomicTenant::PinnedPlatformGuid.where(application_instance_id:)
+      page, meta = filter(query)
+
+      render json: {
+        pinned_platform_guids: page,
+        meta:
+      }
+    end
+
+    def create
+      result = AtomicTenant::PinnedPlatformGuid.create!({**create_params, application_instance_id:, application_id:})
+      render json: { pinned_platform_guid: result }
+    end
+
+    def show
+      pinned_platform_guid = find_pinned_platform_guid
+      render json: {pinned_platform_guid: pinned_platform_guid}
+    end
+
+    def update
+      pinned_platform_guid = find_pinned_platform_guid
+      pinned_platform_guid.update!(update_params)
+
+      render json: {pinned_platform_guid: find_pinned_platform_guid}
+    end
+
+    def destroy
+      pinned_platform_guid = find_pinned_platform_guid
+      pinned_platform_guid.destroy
+      render json: { pinned_platform_guid: pinned_platform_guid }
+    end
+
+    protected
+
+    def application_id
+      params[:application_id]
+    end
+
+    def application_instance_id
+      params[:application_instance_id]
+    end
+
+    def create_params
+      params.require(:pinned_platform_guid).permit!
+    end
+
+    def update_params
+      params.require(:pinned_platform_guid).permit!
+    end
+
+    def find_pinned_platform_guid
+      AtomicTenant::PinnedPlatformGuid.find(params[:id])
+    end
+  end
+end

data/app/controllers/concerns/filtering.rb

@@ -0,0 +1,54 @@
+module Filtering
+  extend ActiveSupport::Concern
+
+  included do
+    class_variable_set(:@@allowed_sort_columns, [])
+    class_variable_set(:@@allowed_search_columns, [])
+  end
+
+  class_methods do
+    def allowed_sort_columns(names)
+      class_variable_set(:@@allowed_sort_columns, names)
+    end
+
+    def allowed_search_columns(names)
+      class_variable_set(:@@allowed_search_columns, names)
+    end
+  end
+
+  def query_params
+    params.
+      permit(:search, :sort_on, :sort_direction, :page, :per_page, :search_on).
+      with_defaults(sort_direction: "asc", page: 1, per_page: 30)
+  end
+
+  def filter(relation)
+    params = query_params
+    allowed_search_columns = self.class.class_variable_get(:@@allowed_search_columns)
+
+    if params[:search].present? && params[:search_on].present? && allowed_search_columns.include?(params[:search_on])
+      relation = relation.where("lower(#{params[:search_on]}) LIKE ?", "%#{params[:search].downcase}%")
+    end
+
+    allowed_sort_columns = self.class.class_variable_get(:@@allowed_sort_columns)
+    if params[:sort_on].present? && allowed_sort_columns.include?(params[:sort_on])
+      sort_col = params[:sort_on]
+      sort_dir = params[:sort_direction]
+      sort_dir = "asc" if sort_dir == "ascending"
+      sort_dir = "desc" if sort_dir == "descending"
+      relation = relation.order({sort_col => sort_dir})
+    end
+
+    relation = relation.paginate(page: params[:page], per_page: params[:per_page])
+
+    meta = {
+      current_page: relation.current_page,
+      next_page: relation.next_page,
+      prev_page: relation.previous_page,
+      total_pages: relation.total_pages,
+      total_items: relation.total_entries,
+    }
+
+    [relation, meta]
+  end
+end