lms-api 1.19.0 → 1.23.0

data/lib/canvas_api/rb_graphql_helpers.rb

@@ -9,7 +9,7 @@ module CanvasApi
       if property["$ref"]
         canvas_name(property['$ref'], input_type)
       elsif property["allowableValues"]
-        enum_class_name(model, name)
+        enum_class_name(model, name, input_type)
       else
         type = property["type"].downcase
         case type
@@ -41,11 +41,13 @@ module CanvasApi
                       "[#{canvas_name(property["items"]["$ref"], input_type)}]"
                     end
                   else
-                    graphql_primitive(name, property["items"]["type"].downcase, property["items"]["format"])
+                    array_type = graphql_primitive(name, property["items"]["type"].downcase, property["items"]["format"])
+                    array_type = "[#{array_type}]" if array_type != "[ID]"
+                    array_type
                   end
           rescue
             puts "Unable to discover list type for '#{name}' ('#{property}'). Defaulting to String"
-            type = "String"
+            type = "[String]"
           end
           type
         when "object"
@@ -104,11 +106,11 @@ module CanvasApi
       end
     end
 
-    def enum_class_name(model, field_name)
-      "#{model['id'].classify}#{field_name.classify}Enum"
+    def enum_class_name(model, field_name, input_type)
+      "#{model['id'].classify}#{input_type ? 'Input' : ''}#{field_name.classify}Enum"
     end
 
-    def graphql_field_enums(model)
+    def graphql_field_enums(model, input_type = false)
       return unless model["properties"]
       enums = model["properties"].map do |name, property|
         if property["allowableValues"]
@@ -116,7 +118,7 @@ module CanvasApi
             "value \"#{value}\""
           end.join("\n          ")
           <<-CODE
-        class #{enum_class_name(model, name)} < ::GraphQL::Schema::Enum
+        class #{enum_class_name(model, name, input_type)} < ::GraphQL::Schema::Enum
           #{values}
         end
           CODE
@@ -198,7 +200,7 @@ field :#{name.underscore}, #{type}, "#{description}", resolver_method: :resolve_
     end
 
     def make_file_name(str)
-      str.underscore.split("/").last.split("|").first.gsub("canvas_", "").gsub(" ", "_").strip.singularize
+      str.underscore.split("/").last.split("|").first.gsub(/^canvas_?/, "").gsub(" ", "_").strip.singularize
     end
 
     def require_from_operation(operation)
@@ -230,22 +232,6 @@ field :#{name.underscore}, #{type}, "#{description}", resolver_method: :resolve_
       str.gsub('"', "'")
     end
 
-    def nested_arg(str)
-      # TODO/HACK we are replacing values from the string here to get things to work for now.
-      # However, removing these symbols means that the methods that use the arguments
-      # generated herein will have bugs and be unusable.
-      str.gsub("[", "_").
-        gsub("]", "").
-        gsub("*", "star").
-        gsub("<", "_").
-        gsub(">", "_").
-        gsub("`", "").
-        gsub("https://canvas.instructure.com/lti/", "").
-        gsub("https://www.instructure.com/", "").
-        gsub("https://purl.imsglobal.org/spec/lti/claim/", "").
-        gsub(".", "")
-    end
-
     def params_as_string(parameters, paramTypes)
       filtered = parameters.select{ |p| paramTypes.include?(p["paramType"]) }
       if filtered && !filtered.empty?

data/lib/canvas_api/render.rb

@@ -1,20 +1,26 @@
+require "canvas_api/helpers"
 require "canvas_api/js_graphql_helpers"
 require "canvas_api/js_helpers"
 require "canvas_api/ruby_helpers"
 require "canvas_api/rb_graphql_helpers"
+require "canvas_api/go_helpers"
 require "byebug"
+
 module CanvasApi
 
   class Render
+    include CanvasApi
     include CanvasApi::GraphQLHelpers
     include CanvasApi::JsHelpers
     include CanvasApi::RubyHelpers
+    include CanvasApi::GoHelpers
     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)
+    def initialize(template, api, resource, resource_api, operation, parameters, content, model, api_path)
       @template = File.read(File.expand_path(template, __dir__))
+      @api_path = api_path
       if api
         @api         = api
         @name        = @api["path"].gsub("/", "").gsub(".json", "")
@@ -47,7 +53,12 @@ module CanvasApi
         @summary   = operation["summary"]
       end
       if parameters
-        @parameters = parameters.map { |p| p.delete("description"); p }
+        # Keep a copy of full parameters for code that will include the description
+        @full_parameters = Marshal.load Marshal::dump(parameters)
+        # Strip description from parameters so that canvas_urls.rb
+        # doesn't error out on bad chars in the descriptions
+        tmp_params = Marshal.load Marshal::dump(parameters)
+        @parameters = tmp_params.map { |p| p.delete("description"); p }
       end
       @content = content
       @model = model

data/lib/canvas_api/templates/go_action.erb

@@ -0,0 +1,241 @@
+<% string_utils_required = @parameters.any?{|p| p["enum"] && !is_x_param?(p["name"]) } -%>
+<% errors_required = @parameters.any?{|p| p["enum"] || is_required_field(p) }-%>
+<% query_params = go_query_params(@parameters) -%>
+<% path_params = go_path_params(@parameters) -%>
+<% form_params = go_form_params(@parameters) -%>
+<% return_type = go_return_type(operation) -%>
+package requests
+
+import (
+  <% if return_type && return_type != "bool" && return_type != "string" || @nickname == "assign_unassigned_members" || form_params -%>
+  "encoding/json"
+  <% end -%>
+  <% if path_params || errors_required -%>
+  "fmt"
+  <% end -%>
+  <% if !!return_type -%>
+  "io/ioutil"
+  <% end -%>
+  <% if is_paged?(@operation) -%>
+  "net/http"
+  <% end -%>
+  "net/url"
+  <% if return_type == "int64" -%>
+  "strconv"
+  <% end -%>
+  <% if errors_required || path_params -%>
+  "strings"
+  <% end -%>
+  <% if time_required?(@parameters) -%>
+  "time"
+  <% end -%>
+
+  <% if query_params || go_form_params(@parameters) -%>
+  "github.com/google/go-querystring/query"
+  <% end -%>
+
+  "github.com/atomicjolt/canvasapi"
+  <% if go_require_models(@parameters, @nickname, return_type)-%>
+  "github.com/atomicjolt/canvasapi/models"
+  <% end -%>
+  <% if string_utils_required -%>
+  "github.com/atomicjolt/string_utils"
+  <% end -%>
+)
+
+// <%= go_name(@nickname) %> <%= @notes %>
+// https://canvas.instructure.com/doc/api<%=@api_path.gsub(".json", ".html")%>
+<% if params = go_path_params(@full_parameters)-%>
+//
+// Path Parameters:
+// <%= params.map { |p| go_parameter_doc(p) }.join("\n// ") %>
+<% end -%>
+<% if params = go_query_params(@full_parameters) -%>
+//
+// Query Parameters:
+// <%= params.map { |p| go_parameter_doc(p) }.join("\n// ") %>
+<% end -%>
+<% if params = go_form_params(@full_parameters) -%>
+//
+// Form Parameters:
+// <%= params.map { |p| go_parameter_doc(p) }.join("\n// ") %>
+<% end -%>
+//
+type <%= struct_name(@nickname) %> struct {
+  <% if params = go_path_params(@parameters) -%>
+  Path struct {
+    <%= go_struct_fields(@nickname, params) %>
+  } `json:"path"`
+  <% end -%>
+
+  <% if query_params -%>
+  Query struct {
+    <%= go_struct_fields(@nickname, query_params) %>
+  } `json:"query"`
+  <% end -%>
+
+  <% if form_params -%>
+  Form struct {
+    <%= go_struct_fields(@nickname, form_params) %>
+  } `json:"form"`
+  <% end -%>
+}
+
+func (t *<%= struct_name(@nickname) %>) GetMethod() string {
+  return "<%=@method%>"
+}
+
+func (t *<%= struct_name(@nickname) %>) GetURLPath() string {
+  <% if params = go_path_params(@parameters) -%>
+  path := "<%= go_api_url %>"
+  <% params.each do |p| -%>
+  path = strings.ReplaceAll(path, "{<%=p["name"]%>}", fmt.Sprintf("%v", t.Path.<%=go_name(p["name"])%>))
+  <% end -%>
+	return path
+  <% else -%>
+  return ""
+  <% end -%>
+}
+
+func (t *<%= struct_name(@nickname) %>) GetQuery()(string, error) {
+  <% if query_params -%>
+    v, err := query.Values(t.Query)
+    if err != nil {
+      return "", err
+    }
+    return v.Encode(), nil
+  <% else -%>
+    return "", nil
+  <% end -%>
+}
+
+func (t *<%= struct_name(@nickname) %>) GetBody() (url.Values, error) {
+  <% if form_params -%>
+	return query.Values(t.Form)
+  <% else -%>
+  return nil, nil
+  <% end -%>
+}
+
+func (t *<%= struct_name(@nickname) %>) GetJSON() ([]byte, error) {
+  <% if form_params -%>
+  j, err := json.Marshal(t.Form)
+  if err != nil {
+    return nil, nil
+  }
+  return j, nil
+  <% else -%>
+  return nil, nil
+  <% end -%>
+}
+
+func (t *<%= struct_name(@nickname) %>) HasErrors() error {
+  <% if errors_required -%>
+  errs := []string{}
+  <% end -%>
+  <% @parameters.each do |p| -%>
+    <% type = go_type(p["name"], p) -%>
+    <% if is_required_field(p) -%>
+      <% if type == "time.Time" -%>
+        if t.<%=go_param_path(p)%>.IsZero() {
+          errs = append(errs, "'<%=go_param_path(p)%>' is required")
+        }
+      <% else -%>
+        if t.<%=go_param_path(p)%> == <%=go_param_empty_value(p)%> {
+          errs = append(errs, "'<%=go_param_path(p)%>' is required")
+        }
+      <% end -%>
+    <% end -%>
+    <% if p["enum"] && ["string", "[]string"].include?(type) -%>
+      <% if p["type"] == "array" || type == "[]string" -%>
+        for _, v := range t.<%=go_param_path(p)%> {
+          if v != "" && !string_utils.Include([]string{"<%= p["enum"].join("\", \"") %>"}, v) {
+            errs = append(errs, "<%=go_name(p["name"])%> must be one of <%= p["enum"].join(", ") %>")
+          }
+        }
+      <% elsif !is_x_param?(p["name"]) -%>
+        if t.<%=go_param_path(p)%> != "" && !string_utils.Include([]string{"<%= p["enum"].join("\", \"") %>"}, t.<%=go_param_path(p)%>) {
+          errs = append(errs, "<%=go_name(p["name"])%> must be one of <%= p["enum"].join(", ") %>")
+        }
+      <% end -%>
+    <% end -%>
+  <% end -%>
+  <% if errors_required -%>
+  if len(errs) > 0 {
+    return fmt.Errorf(strings.Join(errs, ", "))
+  }
+  <% end -%>
+  return nil
+}
+
+func (t *<%= struct_name(@nickname) %>) Do(c *canvasapi.Canvas<%=next_param(@operation)%>) <%=go_do_return_value(@operation, @nickname)%> {
+  <% ret_type = go_return_type(@operation, true) -%>
+  <% if ret_type -%>
+    <% if is_paged?(@operation) -%>
+      var err error
+      var response *http.Response
+      if next != nil {
+        response, err = c.Send(next, t.GetMethod(), nil)
+      } else {
+        response, err = c.SendRequest(t)
+      }
+
+      if err != nil {
+        return nil, nil, err
+      }
+    <% else -%>
+      response, err := c.SendRequest(t)
+    <% end -%>
+  <% else -%>
+  _, err := c.SendRequest(t)
+  <% end -%>
+	if err != nil {
+		<%= go_do_return_statement(operation, @nickname) %>
+	}
+
+  <% if ret_type -%>
+  body, err := ioutil.ReadAll(response.Body)
+  response.Body.Close()
+  if err != nil {
+    <%= go_do_return_statement(operation, @nickname) %>
+  }
+  <% if @nickname == "assign_unassigned_members" -%>
+    groupMembership := models.GroupMembership{}
+    progress := models.Progress{}
+    if t.Form.Sync {
+      err = json.Unmarshal(body, &groupMembership)
+      if err != nil {
+        return nil, nil, err
+      }
+    } else {
+      err = json.Unmarshal(body, &progress)
+      if err != nil {
+        return nil, nil, err
+      }
+    }
+  <% elsif ret_type == "bool" -%>
+  ret := string(body) == "true"
+  <% elsif ret_type == "string" -%>
+  ret := string(body)
+  <% elsif ret_type == "int64" -%>
+  ret := strconv.ParseInt(string(body), 10, 64)
+  <% else -%>
+  ret := <%=ret_type%>
+  err = json.Unmarshal(body, &ret)
+  if err != nil {
+    <%= go_do_return_statement(operation, @nickname) %>
+  }
+  <% end -%>
+  <% end -%>
+
+  <% if @operation["type"] == "array" -%>
+  pagedResource, err := canvasapi.ExtractPagedResource(response.Header)
+	if err != nil {
+		return nil, nil, err
+	}
+  <% end -%>
+
+  <%= go_do_final_return_statement(operation, @nickname) %>
+}
+
+<%= go_render_child_structs %>

data/lib/canvas_api/templates/go_struct.erb

@@ -0,0 +1,44 @@
+<%
+	fields, time_required = struct_fields(@model, @resource_name)
+	field_validations = go_field_validation(@model)
+-%>
+package models
+
+<% if time_required || field_validations -%>
+import (
+	<% if time_required -%>
+  "time"
+	<% end -%>
+	<% if (field_validations && field_validations.length > 0) -%>
+	"fmt"
+
+  "github.com/atomicjolt/string_utils"
+	<% end -%>
+)
+<% end -%>
+
+type <%=struct_name(@model['id'])%> struct {
+	<%=fields&.join("\n  ")%>
+}
+
+func (t *<%=struct_name(@model['id'])%>) HasErrors() error {
+	<% if field_validations && field_validations.length > 0 -%>
+		var s []string
+		errs := []string{}
+		<%field_validations.each do |name, prop|-%>
+			s = []string{<%=prop[:values].join(",")%>}
+			<% if prop[:type] == "array" %>
+				for _, v := range t.<%=go_name(name)%> {
+          if v != "" && !string_utils.Include(s, v) {
+						errs = append(errs, fmt.Sprintf("expected '<%=go_name(name)%>' to be one of %v", s))
+          }
+        }
+			<% else -%>
+				if t.<%=go_name(name)%> != "" && !string_utils.Include(s, t.<%=go_name(name)%>) {
+					errs = append(errs, fmt.Sprintf("expected '<%=go_name(name)%>' to be one of %v", s))
+				}
+			<% end -%>
+		<% end -%>
+	<% end -%>
+	return nil
+}

data/lib/canvas_api/templates/rb_graphql_field.erb

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

data/lib/canvas_api/templates/rb_graphql_input_type.erb

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

data/lib/canvas_api/templates/rb_graphql_resolver.erb

@@ -4,7 +4,7 @@ require_relative "../canvas_base_resolver"
 module LMSGraphQL
   module Resolvers
     module Canvas
-      class <%= @nickname.classify %> < CanvasBaseResolver
+      class <%= graphql_resolver_class(@nickname) %> < CanvasBaseResolver
         type <%= type_from_operation(operation) %>, null: false
 <% if operation["type"] == "array"
 %>        argument :get_all, Boolean, required: false

data/lib/canvas_api/templates/rb_graphql_type.erb

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