github-to-canvas 0.0.55 → 0.1.1

data/lib/github-to-canvas.rb

@@ -1,56 +1,141 @@
 require_relative './github-to-canvas/create_canvas_lesson'
 require_relative './github-to-canvas/update_canvas_lesson'
+require_relative './github-to-canvas/canvas_dotfile'
+require_relative './github-to-canvas/repository_interface'
 require_relative './github-to-canvas/repository_converter'
 require_relative './github-to-canvas/github_interface'
 require_relative './github-to-canvas/canvas_interface'
-require_relative './github-to-canvas/canvas_dotfile'
+require_relative './github-to-canvas/course_creation_interface'
+
 require_relative './github-to-canvas/version'
 
+require 'yaml'
+
 class GithubToCanvas
 
-  def initialize(mode:, 
-                course:nil, 
-                id:nil,
-                filepath:Dir.pwd, 
-                file_to_convert:'README.md',
-                branch:'master',
-                name:File.basename(Dir.getwd), 
-                type:"page", 
-                save_to_github:false, 
-                fis_links:false,
-                remove_header_and_footer:false,
-                only_update_content: false,
-                forkable: false)
-
-    if mode == 'version'
+  def initialize(options)
+    case options[:mode]
+    when 'version'
       puts VERSION
-    end
-
-    if mode == 'query'
-      CanvasInterface.get_course_info(course, id)
-    end
-
-    if mode == 'remote'
-      lesson_data = CanvasInterface.get_lesson_info(course, id)
-      if !lesson_data[1]
-        puts "No lesson with id #{id} was found in course #{course}."
-      else
-        pp lesson_data[0]
-        puts "\nLesson Type: #{lesson_data[1]}"
-      end
+    when 'query'
+      CanvasInterface.get_course_info(options[:course_id], options[:id])
+    when 'map'
+      CanvasInterface.map_course_info(options[:file_to_convert])
+    when 'canvas_read'
+      puts CanvasInterface.read_lesson(options[:filepath])
+    when 'github_read'
+      markdown = GithubInterface.read_remote(options[:filepath])
+      puts RepositoryConverter.convert_to_html(markdown)
+    when 'create' # used with a local repo
+      html = RepositoryConverter.local_file_conversion(options)
+      name = RepositoryInterface.get_name(options[:filepath], html)
+      html = RepositoryConverter.adjust_converted_html(options, html)
+      response = CanvasInterface.create_lesson(options, name, html)
+      RepositoryInterface.local_repo_post_submission(options, response)
+      puts "Canvas lesson created. Lesson available at #{response['html_url']}"
+    when 'align' # used with a local repo
+      html = RepositoryConverter.local_file_conversion(options)
+      name = RepositoryInterface.get_name(options[:filepath], html)
+      html = RepositoryConverter.adjust_converted_html(options, html)
+      CanvasInterface.update_all_related_lessons(options, name, html)
       
+    when 'github_create'
+      html = RepositoryConverter.remote_file_conversion(options)
+      name = RepositoryInterface.get_name(options[:filepath], html)
+      html = RepositoryConverter.adjust_converted_html(options, html)
       
-    end
+      response = CanvasInterface.create_lesson(options, name, html)
+      
+      puts "Canvas lesson created. Lesson available at #{response['html_url']}"
+    when 'github_align'
+      html = RepositoryConverter.remote_file_conversion(options)
+      name = RepositoryInterface.get_name(options[:filepath], html)
+      html = RepositoryConverter.adjust_converted_html(options, html)
+      response = CanvasInterface.update_existing_lesson(options, name, html)
+      puts "Canvas lesson updated. Lesson available at #{response['html_url']}"
+    when 'build_course'
+      course_yaml = YAML.load(File.read(options[:file_to_convert]))
+      # Create Course
+      created_course_info = CanvasInterface.create_course(course_yaml)
+      puts "Course created - #{created_course_info["id"]}"
 
-    if mode == 'create'
-      puts "github-to-canvas will now create a Canvas lesson based on the current repo"
-      CreateCanvasLesson.new(course, filepath, file_to_convert, branch, name, type, save_to_github, fis_links, remove_header_and_footer, forkable)
-    end
+      course_yaml[:modules].each { |module_info|
+        # Create each module
+        created_module_info = CanvasInterface.create_module(created_course_info["id"], module_info)
+        puts "Module created - #{created_module_info['name']}"
+        module_info[:lessons].each { |lesson|
+          # Create each lesson
+          options[:type] = lesson["type"].downcase
+          options[:course_id] = created_course_info["id"]
+          options[:filepath] = lesson["repository"]
+          
+          
+          html = RepositoryConverter.remote_file_conversion(options)
+          # Add each lesson to it's module
+          
+          html = RepositoryConverter.adjust_converted_html(options, html)
+          created_lesson_info = CanvasInterface.create_lesson(options, lesson["title"], html)
+          lesson = lesson.merge(created_lesson_info)
+          
+          lesson["page_url"] = lesson["url"] if !lesson["page_url"]
+
+          response = CanvasInterface.add_to_module(created_course_info["id"], created_module_info, lesson)
+          
+          puts "Lesson added to #{created_module_info['name']} - #{lesson['title']}"
+          sleep(1)
+        }
+      }
+    when 'add_to_course'
+      course_yaml = YAML.load(File.read(options[:file_to_convert]))
 
-    if mode == 'align'
-      puts "github-to-canvas will now align any existing Canvas lessons based on the current repo. NOTE: .canvas file must be present"
-      UpdateCanvasLesson.new(course, filepath, file_to_convert, branch, name, type, save_to_github, fis_links, remove_header_and_footer, only_update_content, id, forkable)
+      course_yaml[:modules].each { |module_info|
+        # Create each module
+        created_module_info = CanvasInterface.create_module(options[:course_id], module_info)
+        puts "Module created - #{created_module_info['name']}"
+        module_info[:lessons].each { |lesson|
+          # Create each lesson
+
+          options[:type] = lesson["type"].downcase
+          options[:filepath] = lesson["repository"]
+          html = RepositoryConverter.remote_file_conversion(options)
+          # Add each lesson to it's module
+          html = RepositoryConverter.adjust_converted_html(options, html)
+          created_lesson_info = CanvasInterface.create_lesson(options, lesson["title"], html)
+          lesson = lesson.merge(created_lesson_info)
+          response = CanvasInterface.add_to_module(options[:course_id], created_module_info, lesson)
+          
+          puts "Lesson added to #{created_module_info['name']} - #{lesson['title']}"
+          sleep(1)
+        }
+      }
+    when 'update_course_lessons'
+      course_yaml = YAML.load(File.read(options[:file_to_convert]))
+      options[:course_id] = course_yaml[:id]
+      course_yaml[:modules].each { |module_info|
+        puts "Updating #{module_info[:name]}"
+        module_info[:lessons].each { |lesson|
+          if lesson["repository"] == ""
+            puts "No repository found for #{lesson['title']}"
+            next
+          end
+          options[:id] = lesson['id']
+          options[:type] = lesson["type"].downcase
+          options[:filepath] = lesson["repository"]
+          options[:branch] = 'master'
+          html = RepositoryConverter.remote_file_conversion(options)
+          
+          html = RepositoryConverter.adjust_converted_html(options, html)
+          created_lesson_info = CanvasInterface.update_existing_lesson(options, lesson["title"], html)
+          lesson = lesson.merge(created_lesson_info)
+          
+          
+          puts "Lesson updated - #{lesson['title']}"
+          sleep(1)
+        }
+      }
+    else
+      puts VERSION
     end
   end
-
+  
 end

data/lib/github-to-canvas/canvas_dotfile.rb

@@ -5,21 +5,21 @@ class CanvasDotfile
     File.file?(".canvas")
   end
 
-  def self.update_or_create(filepath, response, course, type)
+  def self.update_or_create(options, response)
     if self.exists?
-      if type == "assignment" || type == "discussion"
-        canvas_data = self.update_assignment_data(response, course, type)
+      if options[:type] == "assignment" || options[:type] == "discussion"
+        canvas_data = self.update_assignment_data(response, options[:course_id], options[:type])
       else
-        canvas_data = self.update_page_data(response, course, type)
+        canvas_data = self.update_page_data(response, options[:course_id], options[:type])
       end
     else
-      if type == "assignment" || type == "discussion"
-        canvas_data = self.create_assignment_data(response, course, type)
+      if options[:type] == "assignment" || options[:type] == "discussion"
+        canvas_data = self.create_assignment_data(response, options[:course_id], options[:type])
       else
-        canvas_data = self.create_page_data(response, course, type)
+        canvas_data = self.create_page_data(response, options[:course_id], options[:type])
       end
     end
-    self.create_canvas_dotfile(filepath, canvas_data)
+    self.create_canvas_dotfile(options[:filepath], canvas_data)
   end
 
   def self.create_canvas_dotfile(filepath, canvas_data)
@@ -64,7 +64,7 @@ class CanvasDotfile
 
   def self.update_page_data(response, course, type)
     canvas_data = YAML.load(File.read(".canvas"))
-    if canvas_data[:lessons].none? { |lesson| lesson[:page_id] == response['page_id'] && lesson[:course_id] == course.to_i && lesson[:canvas_url] == response['html_url']}
+    if canvas_data[:lessons].none? { |lesson| lesson[:id] == response['page_id'] && lesson[:course_id] == course.to_i && lesson[:canvas_url] == response['html_url']}
       lesson_data = {
         id: response['page_id'],
         course_id: course.to_i,

data/lib/github-to-canvas/canvas_interface.rb

@@ -1,7 +1,143 @@
 require 'json'
 require 'rest-client'
+require 'yaml'
 class CanvasInterface
 
+  def self.create_course(course_info)
+    # POST /api/v1/accounts/:account_id/courses
+    url = "#{ENV['CANVAS_API_PATH']}/accounts/1/courses"
+    payload = {
+      'course[name]' => course_info[:name],
+      'course[course_code]' => course_info[:course_code]
+    }
+    response = RestClient.post(url, payload, self.headers)
+    JSON.parse(response)
+  end
+
+  def self.create_module(course_id, module_info)
+    # POST /api/v1/courses/:course_id/modules
+    url = "#{ENV['CANVAS_API_PATH']}/courses/#{course_id}/modules"
+    payload = {
+      'module[name]' => module_info[:name]
+    }
+    response = RestClient.post(url, payload, headers={
+      "Authorization" => "Bearer #{ENV['CANVAS_API_KEY']}"
+    })
+    JSON.parse(response)
+  end
+
+  def self.create_lesson(options, name, html)
+    if options[:type] == 'discussion'
+      url = "#{ENV['CANVAS_API_PATH']}/courses/#{options[:course_id]}/#{options[:type]}_topics"
+    else
+      url = "#{ENV['CANVAS_API_PATH']}/courses/#{options[:course_id]}/#{options[:type]}s"
+    end
+    payload = self.build_payload(options, name, html)
+    begin
+      response = RestClient.post(url, payload, self.headers)
+    rescue
+      puts "Something went wrong while pushing lesson #{options[:id]} to course #{options[:course_id]}"
+      abort
+    end
+    if ![200, 201].include? response.code
+      puts "Canvas push failed. #{response.code} status code returned "
+      abort
+    end
+    JSON.parse(response.body)
+  end
+
+  def self.create_quiz(options, quiz_data)
+    
+  end
+
+  def self.add_to_module(course_id, module_info, lesson_info)
+    # POST /api/v1/courses/:course_id/modules/:module_id/items
+    url = "#{ENV['CANVAS_API_PATH']}/courses/#{course_id}/modules/#{module_info["id"]}/items"
+    
+    if lesson_info["type"] == "Page"
+      payload = {
+      'module_item[title]' => lesson_info["title"],
+      'module_item[type]' => lesson_info["type"],
+      'module_item[indent]' => 0,
+      'module_item[completion_requirement][type]' => 'must_view'
+    }
+    elsif lesson_info["type"] == "Quiz"
+      puts "Quiz needs to be added manually - #{lesson_info['title']} - lesson_info["
+    else
+      
+      payload = {
+        'module_item[title]' => lesson_info["title"],
+        'module_item[type]' => lesson_info["type"],
+        'module_item[indent]' => 1,
+        'module_item[completion_requirement][type]' => 'must_submit'
+      }
+    end
+    begin
+      response = RestClient.post(url, payload, self.headers)
+    rescue
+      puts "Something went wrong while add lesson #{lesson_info["id"]} to module #{module_info["id"]} in course #{course_id}" if lesson_info["type"] == "Assignment"
+      puts "Something went wrong while add lesson #{lesson_info["page_url"]} to module #{module_info["id"]} in course #{course_id}" if lesson_info["type"] == "Page"
+      abort
+    end
+
+    
+    response
+    
+  end
+
+  def self.update_existing_lesson(options, name, html)
+    if options[:type] == "discussion"
+      url = "#{ENV['CANVAS_API_PATH']}/courses/#{options[:course_id]}/#{options[:type]}_topics/#{options[:id]}"
+    else
+      url = "#{ENV['CANVAS_API_PATH']}/courses/#{options[:course_id]}/#{options[:type]}s/#{options[:id]}"
+    end
+    payload = self.build_payload(options, name, html)
+    
+    begin
+      headers = self.headers
+      if options[:type] == 'page'
+        response = RestClient.get(url, headers)
+        lesson_info = JSON.parse(response)
+        url = url.sub(/[^\/]+$/, lesson_info["page_id"].to_s)
+      end
+      response = RestClient.put(url, payload, headers)
+    rescue
+      puts "Something went wrong while pushing lesson #{options[:id]} to course #{options[:course_id]}"
+      puts "Make sure you are working on lessons that are not locked"
+      abort
+      ""
+    end
+    JSON.parse(response.body)
+  end
+
+  def self.update_all_related_lessons(options, name, html)
+    # Read the local .canvas file if --id <ID> is not used. Otherwise, use provided ID (--course <COURSE> also required)
+    if !options[:id]
+      canvas_data = CanvasDotfile.read_canvas_data
+      response = nil
+      canvas_data[:lessons] = canvas_data[:lessons].map { |lesson|
+        response = self.update_existing_lesson(lesson, name, html)
+        options[:id] = lesson[:id]
+        options[:course_id] = lesson[:course_id]
+        options[:type] = lesson[:type]
+        
+      }
+      RepositoryInterface.local_repo_post_submission(options, response)
+      puts "Canvas lesson updated. Lesson available at #{response['html_url']}"
+    else
+      # If an ID (and course) are provided, they are used instead of the .canvas file
+      # Gets the current lesson's type (page or assignment)
+
+      options[:type] = self.get_lesson_info(options[:course_id], options[:id])[1]
+
+      # Implements update on Canvas
+      response = self.update_existing_lesson(options, name, html)
+      RepositoryInterface.local_repo_post_submission(options, response)
+      puts "Canvas lesson updated. Lesson available at #{response['html_url']}"
+    end
+
+  end
+
   def self.get_lesson_info(course, id)
 
     lesson_types = ["quizzes", "assignments", "pages", "discussion_topics"]
@@ -14,6 +150,7 @@ class CanvasInterface
     info = ""
     lesson_type_urls.each do |url|
       begin
+        
         response = RestClient.get(url, headers={
           "Authorization" => "Bearer #{ENV['CANVAS_API_KEY']}"
         })
@@ -41,34 +178,64 @@ class CanvasInterface
       return
     end
 
+    url = "#{ENV['CANVAS_API_PATH']}/courses/#{course}"
+    response = RestClient.get(url, self.headers)
+    course_data = JSON.parse(response)
+
+    # /api/v1/courses/:course_id/modules
+    course_info = {
+      name: course_data['name'],
+      id: course_data['id'],
+      modules: []
+    }
+
     begin
-        results = []
         index = 1
 
         while !!index
-          url = "#{ENV['CANVAS_API_PATH']}/courses/#{course}/pages?order=asc&sort=title&page=#{index}&per_page=10"
+          url = "#{ENV['CANVAS_API_PATH']}/courses/#{course}/modules?page=#{index}&per_page=20"
           index += 1
-          response = RestClient.get(url, headers={
-            "Authorization" => "Bearer #{ENV['CANVAS_API_KEY']}"
-          })
-          pages = JSON.parse(response.body)
-          if ([200, 201].include? response.code) && (!pages.empty?)
-            results = results + pages
+          response = RestClient.get(url, self.headers)
+          modules = JSON.parse(response.body)
+          
+          if ([200, 201].include? response.code) && (!modules.empty?)
+            course_info[:modules] = course_info[:modules] + modules
           else
             index = nil
           end 
         end
-        puts ""
-        puts ""
-        puts "Info for Course #{course} from #{ENV['CANVAS_API_PATH']}"
-        puts ""
-        puts "## Pages ##"
-        puts "Title : Page ID"
-        puts ""
-
-        results.each {|result|
-          puts "#{result['title']} : #{result['page_id']}"
-        }
+        
+        course_info[:modules] = course_info[:modules].map do |mod|
+          new_mod = {
+            id: mod['id'],
+            name: mod['name'],
+            lessons: []
+          }
+          index = 1
+          while !!index
+            url = "#{ENV['CANVAS_API_PATH']}/courses/#{course}/modules/#{mod['id']}/items?page=#{index}&per_page=20"
+            index += 1
+            response = RestClient.get(url, headers={
+              "Authorization" => "Bearer #{ENV['CANVAS_API_KEY']}"
+            })
+            lessons = JSON.parse(response.body)
+            lessons = lessons.map do |lesson|
+              lesson = lesson.slice("id","title","name","indent","type","html_url","page_url","url","completion_requirement", "published")
+              lesson["repository"] = ""
+              lesson['id'] = lesson['url'].gsub(/^(.*[\\\/])/,'')
+              lesson
+            end
+            if ([200, 201].include? response.code) && (!lessons.empty?)
+              new_mod[:lessons] = new_mod[:lessons] + lessons
+            else
+              index = nil
+            end
+            
+          end
+          new_mod
+        end
+
+        puts course_info.to_yaml
       
     rescue
       puts "Something went wrong while getting info about course #{course}"
@@ -76,82 +243,174 @@ class CanvasInterface
     end
   end
 
-  def self.submit_to_canvas(course_id, type, name, readme)
-    response = self.push_to_canvas(course_id, type, name, readme)
-    if ![200, 201].include? response.code
-      puts "Canvas push failed. #{response.code} status code returned "
-      abort
-    end
-    JSON.parse(response.body)
-  end
+  def self.map_course_info(file_to_convert)
+    course_info = YAML.load(File.read("#{Dir.pwd}/#{file_to_convert}"))
+    course_info[:modules] = course_info[:modules].map do |mod|
+      mod[:lessons] = mod[:lessons].map do |lesson|
 
-  def self.push_to_canvas(course_id, type, name, new_readme)
-    if type == 'discussion'
-      url = "#{ENV['CANVAS_API_PATH']}/courses/#{course_id}/#{type}_topics"
-    else
-      url = "#{ENV['CANVAS_API_PATH']}/courses/#{course_id}/#{type}s"
-    end
-    payload = self.build_payload(type, name, new_readme, false)
-    begin
-      RestClient.post(url, payload, headers={
-        "Authorization" => "Bearer #{ENV['CANVAS_API_KEY']}"
-      })
-    rescue
-      puts "Something went wrong while pushing lesson #{id} to course #{course_id}"
-      abort
+        url = lesson["url"]
+        response = RestClient.get(url, headers={
+          "Authorization" => "Bearer #{ENV['CANVAS_API_KEY']}"
+        })
+        begin
+          lesson_data = JSON.parse(response)
+          contents = lesson_data["body"] if lesson["type"] == "Page"
+          contents = lesson_data["message"] if lesson["type"] == "Discussion"
+          contents = lesson_data["description"] if lesson["type"] == "Assignment" || lesson["type"] == "Quiz"
+          if contents.nil?
+            repo = ""
+          else
+            if contents[/data-repo=\"(.*?)"/]
+              repo = contents[/data-repo=\"(.*?)"/]
+              repo = repo.slice(11..-2)
+            elsif contents[/class=\"fis-git-link\" href=\"(.*?)"/]
+              repo = contents[/class=\"fis-git-link\" href=\"(.*?)"/]
+              repo = repo.slice(27..-2)
+            else
+              repo = ""
+            end
+          end
+        rescue
+          puts 'Error while mapping course info.'
+          abort
+        end
+        
+        if repo != nil && repo != ""
+          if repo.include?('https://github.com/learn-co-curriculum/')
+            lesson["repository"] = repo
+          else
+            lesson["repository"] = "https://github.com/learn-co-curriculum/" + repo
+          end
+        end
+        sleep(1)
+        lesson
+      end
+      mod
     end
+    puts course_info.to_yaml
   end
 
-  def self.update_existing_lesson(course_id, id, type, name, new_readme, only_update_content)
-    if type == "discussion"
-      url = "#{ENV['CANVAS_API_PATH']}/courses/#{course_id}/#{type}_topics/#{id}"
-    else
-      url = "#{ENV['CANVAS_API_PATH']}/courses/#{course_id}/#{type}s/#{id}"
-    end
-    payload = self.build_payload(type, name, new_readme, only_update_content)
-    begin
-      RestClient.put(url, payload, headers={
-        "Authorization" => "Bearer #{ENV['CANVAS_API_KEY']}"
-      })
-    rescue
-      puts "Something went wrong while pushing lesson #{id} to course #{course_id}"
-      nil
-    end
+  def self.submit_to_canvas(course_id, type, name, readme)
+    
   end
 
-  def self.build_payload(type, name, new_readme, only_update_content)
-    if only_update_content
-      if type == "assignment"
+  
+
+
+  def self.build_payload(options, name, html)
+    if options[:only_update_content]
+      if options[:type] == "assignment"
         payload = {
-          'assignment[description]' => new_readme
+          'assignment[description]' => html
         }
-      elsif type == "discussion"
+      elsif options[:type] == "discussion"
         payload = {
-          'message' => new_readme
+          'message' => html
         }
       else
         payload = {
-          'wiki_page[body]' => new_readme
+          'wiki_page[body]' => html
         }
       end
     else
-      if type == "assignment"
+      if options[:type] == "assignment"
         payload = {
           'assignment[name]' => name,
-          'assignment[description]' => new_readme
+          'assignment[description]' => html,
+          'assignment[submission_types][]' => "online_url",
+          'assignment[grading_type]' => 'pass_fail',
+          'assignment[points_possible]' => 1
         }
-      elsif type == "discussion"
+      elsif options[:type] == "discussion"
         payload = {
           'title' => name,
-          'message' => new_readme
+          'message' => html
         }
       else
         payload = {
           'wiki_page[title]' => name,
-          'wiki_page[body]' => new_readme,
+          'wiki_page[body]' => html,
           'wiki_page[editing_roles]' => "teachers" 
         }
       end
     end
   end
+
+  def self.read_lesson(url)
+    types = ["page", "assignment", "quiz", "discussion"]
+    type = types.find {|type| url.match(type)}
+    if !url.include?(ENV['CANVAS_API_PATH'])
+      url = url.sub(/^.*\/\/.*?\//,"#{ENV['CANVAS_API_PATH']}/")
+    end
+
+    response = RestClient.get(url, headers={
+      "Authorization" => "Bearer #{ENV['CANVAS_API_KEY']}"
+    })
+    lesson_info = JSON.parse(response)
+    lesson_info = lesson_info.slice("title",
+                                    "name",
+                                    "description",
+                                    "body",
+                                    "message",
+                                    "shuffle_answers",
+                                    "allowed_attempts",
+                                    "question_count"
+                                    )
+    lesson_info["type"] = type.capitalize
+    if lesson_info["type"] == "Quiz"
+      url = url + "/questions"
+      response = RestClient.get(url, headers={
+        "Authorization" => "Bearer #{ENV['CANVAS_API_KEY']}"
+      })
+      lesson_info["questions"] = JSON.parse(response)
+      lesson_info["questions"] = lesson_info["questions"].map do |question|
+        question.slice("id",
+                      "position",
+                      "question_name",
+                      "question_type",
+                      "question_text",
+                      "points_possible",
+                      "correct_comments_html",
+                      "incorrect_comments_html",
+                      "neutral_comments_html",
+                      "answers"
+                      )
+      end
+    end
+    lesson_info.to_yaml
+  end
+
+  def self.create_lesson_from_remote(course_id, module_id, lesson_type, raw_url, yaml_file)
+    url = "#{ENV['CANVAS_API_PATH']}/courses/#{course_id}/modules/#{module_id}/items"
+    if yaml_file
+      data = YAML.load(File.read("#{Dir.pwd}/#{yaml_file}"))
+      payload = {
+        'module_item[type]' => data["type"],
+        'module_item[title]' => data["title"]
+      }
+    else
+
+    end
+    
+  
+  end
+
+  def self.headers
+    {
+      "Authorization" => "Bearer #{ENV['CANVAS_API_KEY']}"
+    }
+  end
+
+  # def self.create_quiz_from_remote(course_id, module_id, lesson_type, raw_url)
+  #   url = "#{ENV['CANVAS_API_PATH']}/courses/#{course_id}/quizzes"
+  #   payload = {
+  #     'quiz[title]' => 
+  #   }
+  #   /api/v1/courses/:course_id/quizzes
+  #   data = YAML.load(File.read("#{Dir.pwd}/#{yaml_file}"))
+  #   payload = {
+  #     'module_item[type]' => data["type"],
+  #     'module_item[title]' => data["title"]
+  #   }
+  # end
 end