lms-api 1.17.0

data/lib/canvas_api/render.rb

@@ -0,0 +1,74 @@
+require "canvas_api/js_graphql_helpers"
+require "canvas_api/js_helpers"
+require "canvas_api/ruby_helpers"
+require "canvas_api/rb_graphql_helpers"
+require "byebug"
+module CanvasApi
+
+  class Render
+    include CanvasApi::GraphQLHelpers
+    include CanvasApi::JsHelpers
+    include CanvasApi::RubyHelpers
+    attr_accessor :template, :description, :resource, :api_url, :operation,
+                  :args, :method, :api, :name, :resource_name, :resource_api,
+                  :nickname, :notes, :content, :summary, :model, :model_name
+
+    def initialize(template, api, resource, resource_api, operation, parameters, content, model)
+      @template = File.read(File.expand_path(template, __dir__))
+      if api
+        @api         = api
+        @name        = @api["path"].gsub("/", "").gsub(".json", "")
+        @description = @api["description"]
+      end
+      if resource
+        @resource      = resource
+        @resource_name = resource["resourcePath"].gsub("/", "")
+      end
+      if resource_api
+        @resource_api = resource_api
+        @api_url      = resource_api["path"].gsub("/v1/", "")
+        @args         = args(@api_url)
+      end
+      if operation
+        nickname = operation["nickname"]
+        nickname = "#{@name}_#{nickname}" if [
+          "upload_file",
+          "query_by_course",
+          "preview_processed_html",
+          "create_peer_review_courses",
+          "create_peer_review_sections",
+          "set_extensions_for_student_quiz_submissions"
+        ].include?(nickname)
+
+        @method    = operation["method"]
+        @operation = operation
+        @nickname  = nickname
+        @notes     = operation["notes"].gsub("\n", "\n// ")
+        @summary   = operation["summary"]
+      end
+      if parameters
+        @parameters = parameters.map { |p| p.delete("description"); p }
+      end
+      @content = content
+      @model = model
+    end
+
+    def args(api_url)
+      api_url.split("/").map do |part|
+        if part[0] == "{"
+          part.gsub(/[\{\}]/, "")
+        end
+      end.compact
+    end
+
+    def render
+      ERB.new(@template, nil, "-").result(binding).strip
+    end
+
+    def save(file)
+      File.write(file, render)
+    end
+
+  end
+
+end

data/lib/canvas_api/ruby_helpers.rb

@@ -0,0 +1,9 @@
+module CanvasApi
+  module RubyHelpers
+
+    def ruby_api_url(api_url)
+      api_url.gsub("{", "#\{")
+    end
+
+  end
+end

data/lib/canvas_api/templates/constant.erb

@@ -0,0 +1,10 @@
+<% parameters_doc = parameters_doc(operation, @method.downcase) -%>
+// <%=@summary%>
+// <%=@notes%>
+//
+// API Docs: https://canvas.instructure.com/doc/api/<%=@resource_name%>.html
+// API Url: <%=@api_url%>
+//
+// Example:<%=parameters_doc%>
+// return canvasRequest(<%=@nickname%>, {<%=@args.present? ? @args.join(', ') : ""%><%= @method.downcase == "get" && parameters_doc.present? ? ", ...query" : ""%>}<%= @method.downcase != "get" && parameters_doc.present? ? ", body" : ""%>);
+export const <%=@nickname.camelcase(:lower)%> = { type: '<%=@nickname.upcase%>', method: '<%=@method.downcase%>', key: '<%=reducer_key(@nickname, @args)%>', required: <%=js_args(@args)%> };

data/lib/canvas_api/templates/constants.erb

@@ -0,0 +1,4 @@
+//
+// <%= @description %>
+//
+<%=@content.join("\n\n")%>

data/lib/canvas_api/templates/course_id_required.erb

@@ -0,0 +1 @@
+"<%=@nickname.upcase%>"

data/lib/canvas_api/templates/course_ids_required.erb

@@ -0,0 +1,5 @@
+module LMS
+  COURSE_REQUIRED_ENDPOINTS = [
+    <%=@content.join(",\n    ")%>
+  ].freeze
+end

data/lib/canvas_api/templates/ex_action.erb

@@ -0,0 +1 @@
+def <%=@nickname.downcase%>, do: "<%=@nickname.upcase%>"

data/lib/canvas_api/templates/ex_default_action.erb

@@ -0,0 +1 @@
+def action(type), do: raise InvalidCanvasActionException, message: "Invalid Canvas API Action: #{type}}"

data/lib/canvas_api/templates/ex_url.erb

@@ -0,0 +1,18 @@
+def action("<%=@nickname.upcase%>"), do: %{ uri: fn(<%= @args.present? ? "%{" : "" %><%=@args.map{|a| "\"#{a}\" => #{a}"}.join(', ')%><%= @args.present? ? "}" : "" %>) -> "<%=ruby_api_url(@api_url)%>" end, method: :<%=@method%>, parameters: [<%= @parameters.map do |p|
+      str = []
+      p.each do |property, value|
+        fixed_val = if value.is_a?(Hash)
+          "%#{value}"
+        elsif value.is_a?(String)
+          "\"#{value}\""
+        elsif value.nil?
+          "nil"
+        else
+          value
+        end
+
+        str << "\"#{property}\" => #{fixed_val}"
+      end
+      "%{ #{str.join(", ")} }"
+    end.join(", ")
+    %>] }

data/lib/canvas_api/templates/ex_urls.erb

@@ -0,0 +1,3 @@
+defmodule Canvas.Actions do
+  <%=@content.join("\n  ")%>
+end

data/lib/canvas_api/templates/js_graphql_model.erb

@@ -0,0 +1,9 @@
+const <%=@model['id']%> = new GraphQLObjectType({
+  name: "<%=@model['id']%>",
+  description: "<%=@description%>. API Docs: https://canvas.instructure.com/doc/api/<%=@name%>.html",
+  fields() {
+    return {
+      <%=graphql_fields(@model, @resource_name).join(",\n      ")%>
+    };
+  }
+});

data/lib/canvas_api/templates/js_graphql_mutations.erb

@@ -0,0 +1,6 @@
+const Mutuation = new GraphQLObjectType({
+  name: 'Canvas Api Mutations',
+  fields: {
+    <%=@content.join("\n\n")%>
+  }
+});

data/lib/canvas_api/templates/js_graphql_queries.erb

@@ -0,0 +1,7 @@
+const Query = new GraphQLObjectType({
+  name: 'Canvas Api Queries',
+  description: "Root of the Canvas Api",
+  fields: () => ({
+    <%=@content.join("\n\n")%>
+  })
+});

data/lib/canvas_api/templates/js_graphql_query.erb

@@ -0,0 +1,7 @@
+<%=@nickname%>: {
+  type: new GraphQLList(Post),
+  description: "<%=@description%>",
+  resolve: function(context, args) {
+    return canvasRequest(context, args, urls.<%=@nickname.upcase%>);
+  }
+}

data/lib/canvas_api/templates/js_graphql_types.erb

@@ -0,0 +1,100 @@
+import {
+  GraphQLBoolean,
+  GraphQLFloat,
+  GraphQLID,
+  GraphQLInt,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLObjectType,
+  GraphQLSchema,
+  GraphQLString
+} from 'graphql';
+
+import {
+  connectionArgs,
+  connectionDefinitions,
+  connectionFromArray,
+  fromGlobalId,
+  globalIdField,
+  mutationWithClientMutationId,
+  nodeDefinitions,
+  connectionFromPromisedArray
+} from 'graphql-relay';
+
+import {
+  GraphQLLimitedString,
+  GraphQLDateTime
+} from 'graphql-custom-types';
+
+/**
+ * We get the node interface and field from the Relay library.
+ *
+ * The first method defines the way we resolve an ID to its object.
+ * The second defines the way we resolve an object to its GraphQL type.
+ */
+var {nodeInterface, nodeField} = nodeDefinitions(
+  (globalId) => {
+    var {type, id} = fromGlobalId(globalId);
+    if (type === 'User') {
+      return getUser(id);
+    } else if (type === 'Widget') {
+      return getWidget(id);
+    } else {
+      return null;
+    }
+  },
+  (obj) => {
+    if (obj instanceof User) {
+      return userType;
+    } else if (obj instanceof Widget)  {
+      return widgetType;
+    } else {
+      return null;
+    }
+  }
+);
+
+<%=@content.join("\n\n")%>
+
+const Query = new GraphQLObjectType({
+  name: 'Query',
+  description: 'Root query',
+  fields: () => ({
+    node: nodeField,
+    peopleRelay: {
+      type: PersonConnection,
+      description: 'Person connection test',
+      args: connectionArgs,
+      resolve (root, args) {
+        return connectionFromPromisedArray(Db.models.person.findAll(), args);
+      }
+    },
+    person: {
+       type: personType,
+       resolve (root, args) {
+         return Db.models.person.findOne({ where: args });
+       }
+     },
+    people: {
+       type: new GraphQLList(personType),
+       args: {
+         id: {
+           type: GraphQLInt
+         },
+         email: {
+           type: GraphQLString
+         }
+       },
+       resolve (root, args) {
+         return Db.models.person.findAll({ where: args });
+       }
+     }
+  })
+});
+
+const Schema = new GraphQLSchema({
+  query: Query,
+  //mutation: Mutuation
+});
+
+export default Schema;

data/lib/canvas_api/templates/js_url.erb

@@ -0,0 +1 @@
+  <%=@nickname.upcase%>: { uri: function(args){return <%=js_url_parts(@api_url).join(' + ')%>}, method: "<%=@method%>", parameters: <%=@parameters.to_json%> }

data/lib/canvas_api/templates/js_urls.erb

@@ -0,0 +1,3 @@
+module.exports = {
+  <%=@content.join(",\n  ")%>
+};

data/lib/canvas_api/templates/rb_forward_declarations.erb

@@ -0,0 +1,14 @@
+require_relative "canvas_base_type"
+require_relative "canvas_base_input_type"
+
+# The various types and input types generated for Canvas end up with circular dependencies
+# We use a forward declaration here to overcome the problem.
+# For example, the generate User class depends on Enrollment and Enrollment depends on User
+# so we have a circular dependency.
+module LMSGraphQL
+  module Types
+    module Canvas
+      <%= @content.join("\n      ") %>
+    end
+  end
+end

data/lib/canvas_api/templates/rb_graphql_field.erb

@@ -0,0 +1,3 @@
+        field :<%= @nickname %>,
+          resolver: LMSGraphQL::Resolvers::Canvas::<%= @nickname.classify %>,
+          description: "<%= @summary %>. <%= @notes.gsub(/\n+/, " ").gsub("//", " ").gsub('"', "'") %>"

data/lib/canvas_api/templates/rb_graphql_input_type.erb

@@ -0,0 +1,14 @@
+require_relative "../canvas_base_input_type"
+<%= require_from_properties(@model) %>
+
+module LMSGraphQL
+  module Types
+    module Canvas
+<%=graphql_field_enums(@model)-%>
+      class Canvas<%=@model['id'].singularize%>Input < BaseInputObject
+        description "<%=@description%>. API Docs: https://canvas.instructure.com/doc/api/<%=@name%>.html"
+      <%=graphql_fields(@model, @resource_name, true, true).join("      ")%>
+      end
+    end
+  end
+end

data/lib/canvas_api/templates/rb_graphql_mutation.erb

@@ -0,0 +1,20 @@
+require_relative "../canvas_base_mutation"
+<%= require_from_operation(operation) -%>
+
+module LMSGraphQL
+  module Mutations
+    module Canvas
+      class <%= @nickname.classify %> < BaseMutation
+<%= @parameters.map{|p| "        argument :#{nested_arg(p["name"])}, #{graphql_type(p["name"], p, false, nil, true)}, required: #{p["required"]}"}.join("\n") %>
+        field :<%= name_from_operation(operation) %>, <%= type_from_operation(operation) %>, null: false
+        def resolve(<%= @parameters.map{|p| "#{nested_arg(p['name'])}#{p['required'] ? ':' : ': nil'}"}.join(", ") %>)
+          context[:canvas_api].call("<%= @nickname.upcase %>").proxy(
+            "<%= @nickname.upcase %>",
+<%=  params_as_string(@parameters, ["query", "path"])-%>,
+<%=  params_as_string(@parameters, ["form"])-%>,
+          ).parsed_response
+        end
+      end
+    end
+  end
+end

data/lib/canvas_api/templates/rb_graphql_mutation_include.erb

@@ -0,0 +1 @@
+field :<%= @nickname %>, mutation: LMSGraphQL::Mutations::Canvas::<%= @nickname.classify %>

data/lib/canvas_api/templates/rb_graphql_mutations.erb

@@ -0,0 +1,15 @@
+require_relative "../../utils"
+require_relative "../../types/canvas_base_type"
+require_all(File.absolute_path(__FILE__), "../../mutations/canvas/")
+
+module LMSGraphQL
+  module Mutations
+    module Canvas
+      class MutationType < LMSGraphQL::Types::Canvas::BaseType
+        description "Canvas API mutations"
+
+        <%= @content.join("\n        ") %>
+      end
+    end
+  end
+end

data/lib/canvas_api/templates/rb_graphql_resolver.erb

@@ -0,0 +1,27 @@
+require_relative "../canvas_base_resolver"
+<%= require_from_operation(operation) -%>
+
+module LMSGraphQL
+  module Resolvers
+    module Canvas
+      class <%= @nickname.classify %> < CanvasBaseResolver
+        type <%= type_from_operation(operation) %>, null: false
+<% if operation["type"] == "array"
+%>        argument :get_all, Boolean, required: false
+<% end
+%><%= @parameters.map{|p| "        argument :#{nested_arg(p["name"])}, #{graphql_type(p["name"], p)}, required: #{p["required"]}"}.join("\n") %>
+        def resolve(<%= @parameters.map{|p| "#{nested_arg(p['name'])}#{p['required'] ? ':' : ': nil'}"}.push("get_all: false").join(", ") %>)
+          result = context[:canvas_api].call("<%= @nickname.upcase %>").proxy(
+            "<%= @nickname.upcase %>",
+            {
+<%= @parameters.map{|p| "              \"#{p['name']}\": #{nested_arg(p['name'])}"}.join(",\n") -%>
+            },
+            nil,
+            get_all,
+          )
+          get_all ? result : result.parsed_response
+        end
+      end
+    end
+  end
+end

data/lib/canvas_api/templates/rb_graphql_root_query.erb

@@ -0,0 +1,14 @@
+require_relative "../../utils"
+require_relative "../canvas_base_type"
+require_all(File.absolute_path(__FILE__), "../../resolvers/canvas/")
+
+module LMSGraphQL
+  module Types
+    module Canvas
+      class QueryType < BaseType
+        description "The root query of Canvas schema"
+        <%= @content.join("\n\n        ") %>
+      end
+    end
+  end
+end

data/lib/canvas_api/templates/rb_graphql_type.erb

@@ -0,0 +1,14 @@
+require_relative "../canvas_base_type"
+<%= require_from_properties(@model) %>
+
+module LMSGraphQL
+  module Types
+    module Canvas
+<%=graphql_field_enums(@model)-%>
+      class Canvas<%=@model['id'].singularize%> < BaseType
+        description "<%=@description%>. API Docs: https://canvas.instructure.com/doc/api/<%=@name%>.html"
+      <%=graphql_fields(@model, @resource_name).join("      ")%>
+      end
+    end
+  end
+end

data/lib/canvas_api/templates/rb_url.erb

@@ -0,0 +1 @@
+    "<%=@nickname.upcase%>" => { uri: ->(<%=@args.map{|a| "#{a}:"}.join(', ')%>) { "<%=ruby_api_url(@api_url)%>" }, method: "<%=@method%>", parameters: <%=@parameters%> }

data/lib/canvas_api/templates/rb_urls.erb

@@ -0,0 +1,5 @@
+module LMS
+  CANVAS_URLs = {
+    <%=@content.join(",\n    ")%>
+  }
+end

data/lib/lms/canvas.rb

@@ -0,0 +1,447 @@
+require "httparty"
+require "active_support"
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/object/to_query"
+require "active_support/core_ext/hash/keys"
+require "active_support/core_ext/hash/indifferent_access"
+require "ostruct"
+
+require "lms/canvas_urls"
+require "lms/helper_urls"
+
+module LMS
+
+  class Canvas
+
+    # a model that encapsulates authentication state. By default, it
+    # is nil, but it may be set to any object that responds to:
+    #   - #transaction { .. }
+    #   - #lock(true) -> returns self
+    #   - #find(id) -> returns an authentication object (see
+    #     the `authentication` parameter of #initialize, below).
+    class <<self
+      attr_accessor :auth_state_model
+    end
+
+    # instance accessor, for convenience
+    def auth_state_model
+      self.class.auth_state_model
+    end
+
+    # callback must accept a single parameter (the API object itself)
+    # and return the new authentication object.
+    def self.on_auth(callback = nil, &block)
+      @@on_auth = callback || block
+    end
+
+    # set up a default auth callback. It assumes that #auth_state_model
+    # is set. If #auth_state_model will not be set, the client app must
+    # define a custom on_auth callback.
+    on_auth do |api|
+      api.lock do |record|
+        if record.token == api.authentication.token
+          record.update token: api.refresh_token
+        end
+      end
+    end
+
+    attr_reader :authentication
+
+    # The authentication parameter must be either a string (indicating
+    # a token), or an object that responds to:
+    #   - #id
+    #   - #token
+    #   - #update(hash) -- which should update #token with hash[:token]:noh
+    def initialize(lms_uri, authentication, refresh_token_options = nil)
+      @per_page = 100
+      @lms_uri = lms_uri
+      @refresh_token_options = refresh_token_options
+      @authentication = if authentication.is_a?(String)
+                          OpenStruct.new(token: authentication)
+                        else
+                          authentication
+                        end
+
+      if refresh_token_options.present?
+        required_options = [:client_id, :client_secret, :redirect_uri, :refresh_token]
+        extra_options = @refresh_token_options.keys - required_options
+        unless extra_options.empty?
+          raise InvalidRefreshOptionsException,
+                "Invalid option(s) provided: #{extra_options.join(', ')}"
+        end
+        missing_options = required_options - @refresh_token_options.keys
+        unless missing_options.empty?
+          raise InvalidRefreshOptionsException,
+                "Missing required option(s): #{missing_options.join(', ')}"
+        end
+      end
+    end
+
+    # Obtains a lock (via the API.auth_state_model interface) and
+    # yields an authentication object corresponding to
+    # self.authentication.id. The object is returned when the block
+    # finishes.
+    def lock
+      auth_state_model.transaction do
+        record = auth_state_model.
+          lock(true).
+          find(authentication.id)
+
+        yield record
+
+        record
+      end
+    end
+
+    def headers(additional_headers = {})
+      {
+        "Authorization" => "Bearer #{@authentication.token}",
+        "User-Agent" => "LMS-API Ruby"
+      }.merge(additional_headers)
+    end
+
+    def full_url(api_url, use_api_prefix = true)
+      if api_url[0...4] == "http"
+        api_url
+      elsif use_api_prefix
+        "#{@lms_uri}/api/v1/#{api_url}"
+      else
+        "#{@lms_uri}/#{api_url}"
+      end
+    end
+
+    def api_put_request(api_url, payload, additional_headers = {})
+      url = full_url(api_url)
+      refreshably do
+        HTTParty.put(url, headers: headers(additional_headers), body: payload)
+      end
+    end
+
+    def api_post_request(api_url, payload, additional_headers = {})
+      url = full_url(api_url)
+      refreshably do
+        HTTParty.post(url, headers: headers(additional_headers), body: payload)
+      end
+    end
+
+    def api_get_request(api_url, additional_headers = {})
+      url = full_url(api_url)
+      refreshably do
+        HTTParty.get(url, headers: headers(additional_headers))
+      end
+    end
+
+    def api_delete_request(api_url, additional_headers = {})
+      url = full_url(api_url)
+      refreshably do
+        HTTParty.delete(url, headers: headers(additional_headers))
+      end
+    end
+
+    def api_get_all_request(api_url, additional_headers = {})
+      [].tap do |results|
+        api_get_blocks_request(api_url, additional_headers) do |result|
+          results.concat(result)
+        end
+      end
+    end
+
+    def api_get_blocks_request(api_url, additional_headers = {})
+      connector = api_url.include?("?") ? "&" : "?"
+      next_url = "#{api_url}#{connector}per_page=#{@per_page}"
+      while next_url
+        result = api_get_request(next_url, additional_headers)
+        yield result
+        next_url = get_next_url(result.headers["link"])
+      end
+    end
+
+    def force_refresh
+      @authentication = @@on_auth.call(self)
+    end
+
+    def refreshably
+      refresh_attempts = 0
+
+      begin
+        result = yield
+        check_result(result)
+      rescue LMS::Canvas::RefreshTokenRequired => ex
+        raise ex if @refresh_token_options.blank?
+
+        refresh_attempts += 1
+
+        @authentication = @@on_auth.call(self)
+
+        if refresh_attempts < 2
+          retry
+        else
+          raise LMS::Canvas::InvalidTokenException.new(
+            "Refreshing the token gives an invalid token. The developer key may have been disabled.",
+            result&.response&.code&.to_i,
+            result,
+            @authentication
+          )
+        end
+      end
+    end
+
+    def refresh_token
+      payload = {
+        grant_type: "refresh_token"
+      }.merge(@refresh_token_options)
+      url = full_url("login/oauth2/token", false)
+      result = HTTParty.post(url, headers: headers, body: payload)
+      code = result.response.code.to_i
+      if code >= 500
+        raise LMS::Canvas::RefreshToken500Exception.new(api_error(result), code, result, @authentication)
+      end
+
+      if code > 201
+        raise LMS::Canvas::RefreshTokenFailedException.new(api_error(result), code, result, @authentication)
+      end
+      result["access_token"]
+    end
+
+    def check_result(result)
+      code = result.response.code.to_i
+
+      return result if [200, 201, 202, 203, 204, 205, 206].include?(code)
+
+      if code == 401 && result.headers["www-authenticate"] == 'Bearer realm="canvas-lms"'
+        raise LMS::Canvas::RefreshTokenRequired.new("", nil, result, @authentication)
+      end
+
+      raise LMS::Canvas::InvalidAPIRequestException.new(api_error(result), code, result)
+    end
+
+    def api_error(result)
+      error = "Status: #{result.headers['status']} \n"
+      error << "Http Response: #{result.response.code} \n"
+      error << "Error: #{result.response.message} \n"
+    end
+
+    def get_next_url(link)
+      return nil if link.blank?
+      if url = link.split(",").detect { |l| l.split(";")[1].strip == 'rel="next"' }
+        url.split(";")[0].gsub(/[\<\>\s]/, "")
+      end
+    end
+
+    def multi_proxy(type, params, payload = nil, get_all = false)
+      # Helper methods call several Canvas methods to return a block of data to the client
+      if helper = CANVAS_HELPER_URLs[type]
+        result = self.send(helper)
+        return OpenStruct.new(
+          code: 200,
+          headers: {},
+          body: result.to_json
+        )
+      end
+    end
+
+    def single_proxy(type, params, payload = nil, get_all = false)
+      additional_headers = {
+        "Content-Type" => "application/json"
+      }
+      payload = {} if payload.blank?
+      payload_json = payload.is_a?(String) ? payload : payload.to_json
+      parsed_payload = payload.is_a?(String) ? JSON.parse(payload) : payload
+      parsed_payload = parsed_payload.with_indifferent_access
+
+      method = LMS::CANVAS_URLs[type][:method]
+      url = LMS::Canvas.lms_url(type, params, parsed_payload)
+
+      case method
+      when "GET"
+        if block_given?
+          api_get_blocks_request(url, additional_headers) do |result|
+            yield result
+          end
+        elsif get_all
+          api_get_all_request(url, additional_headers)
+        else
+          api_get_request(url, additional_headers)
+        end
+      when "POST"
+        api_post_request(url, payload_json, additional_headers)
+      when "PUT"
+        api_put_request(url, payload_json, additional_headers)
+      when "DELETE"
+        api_delete_request(url, additional_headers)
+      else
+        raise LMS::Canvas::InvalidAPIMethodRequestException "Invalid method type: #{method}"
+      end
+
+    rescue LMS::Canvas::InvalidAPIRequestException => ex
+      error = "#{ex.message} \n"
+      error << "API Request Url: #{url} \n"
+      error << "API Request Params: #{params} \n"
+      error << "API Request Payload: #{payload} \n"
+      error << "API Request Result: #{ex.result.body} \n"
+      new_ex = LMS::Canvas::InvalidAPIRequestFailedException.new(error, ex.status, ex.result)
+      new_ex.set_backtrace(ex.backtrace)
+      raise new_ex
+    end
+
+    def proxy(type, params, payload = nil, get_all = false, &block)
+      multi_proxy(type, params, payload, get_all) ||
+        single_proxy(type, params, payload, get_all, &block)
+    end
+
+    # Ignore required params for specific calls. For example, the external tool calls
+    # have required params "name, privacy_level, consumer_key, shared_secret". However, those
+    # params are not required if the call specifies config_type: "by_xml".
+    def self.ignore_required(type)
+      [
+        "CREATE_EXTERNAL_TOOL_COURSES",
+        "CREATE_EXTERNAL_TOOL_ACCOUNTS",
+      ].include?(type)
+    end
+
+    # These methods allow custom paths to be appended to the API endpoint.
+    def self.allow_scoped_path(type)
+      [
+        "STORE_CUSTOM_DATA",
+        "LOAD_CUSTOM_DATA",
+        "DELETE_CUSTOM_DATA",
+      ].include?(type)
+    end
+
+    def self.lms_url(type, params, payload = nil)
+      endpoint = LMS::CANVAS_URLs[type]
+      parameters = endpoint[:parameters]
+
+      # Make sure all required parameters are present
+      missing = []
+      if !ignore_required(type)
+        parameters.select { |p| p["required"] }.map { |p| p["name"] }.each do |p|
+          if p.include?("[") && p.include?("]")
+            parts = p.split("[")
+            parent = parts[0].to_sym
+            child = parts[1].gsub("]", "").to_sym
+            missing << p unless (params[parent].present? && params[parent][child].present?) ||
+                (payload.present? && payload[parent].present? && payload[parent][child].present?)
+          else
+            missing << p unless params[p.to_sym].present? ||
+                (payload.present? && !payload.is_a?(String) && payload[p.to_sym].present?)
+          end
+        end
+      end
+
+      if !missing.empty?
+        raise LMS::Canvas::MissingRequiredParameterException,
+              "Missing required parameter(s): #{missing.join(', ')}"
+      end
+
+      # Generate the uri. Only allow path parameters
+      uri_proc = endpoint[:uri]
+      path_parameters = parameters.select { |p| p["paramType"] == "path" }.
+        map { |p| p["name"].to_sym }
+      args = params.slice(*path_parameters).deep_symbolize_keys
+      uri = args.blank? ? uri_proc.call : uri_proc.call(**args)
+
+      # Handle scopes in the url. These API endpoints allow for additional path
+      # information to be added to their urls.
+      # ie "users/#{user_id}/custom_data/favorite_color/green"
+      if allow_scoped_path(type) &&
+        scope = params[:scope]&.gsub("../", "").gsub("..", "") # Don't allow moving up in the path
+        uri = File.join(uri, scope)
+      end
+
+      # Generate the query string
+      query_parameters = parameters.select { |p| p["paramType"] == "query" }.
+        map { |p| p["name"].to_sym }
+
+      # always allow paging parameters
+      query_parameters << :per_page
+      query_parameters << :page
+      query_parameters << :as_user_id
+
+      allowed_params = params.
+        slice(*query_parameters).
+        reject { |key, value| value.nil? }
+
+      if allowed_params.present?
+        "#{uri}?#{allowed_params.to_query}"
+      else
+        uri
+      end
+    end
+
+    #
+    # Helper methods
+    #
+
+    # Get all accounts including sub accounts
+    def all_accounts
+      all = []
+      single_proxy("LIST_ACCOUNTS", {}, nil, true).each do |account|
+        all << account
+        sub_accounts = single_proxy("GET_SUB_ACCOUNTS_OF_ACCOUNT",
+                             {
+                                account_id: account["id"],
+                                recursive: true,
+                             },
+                             nil,
+                             true)
+        all = all.concat(sub_accounts)
+      end
+      all
+    end
+
+    #
+    # Exceptions
+    #
+
+    class CanvasException < RuntimeError
+      attr_reader :status
+      attr_reader :message
+      attr_reader :result
+
+      def initialize(message = "", status = nil, result = nil)
+        super(message)
+
+        @message = message
+        @status = status
+        @result = result
+      end
+    end
+
+    class TokenException < CanvasException
+      attr_reader :auth
+
+      def initialize(message = "", status = nil, result = nil, auth = nil)
+        super(message, status, result)
+        @auth = auth
+      end
+    end
+
+    class RefreshTokenRequired < TokenException
+    end
+
+    class RefreshTokenFailedException < TokenException
+    end
+
+    class RefreshToken500Exception < TokenException
+    end
+
+    class InvalidRefreshOptionsException < CanvasException
+    end
+
+    class InvalidAPIRequestException < CanvasException
+    end
+
+    class InvalidAPIRequestFailedException < CanvasException
+    end
+
+    class InvalidAPIMethodRequestException < CanvasException
+    end
+
+    class MissingRequiredParameterException < CanvasException
+    end
+
+    class InvalidTokenException < TokenException
+    end
+  end
+end