github-to-canvas 0.0.58 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef90c29bdb5096d81deb8c51acdf5e53ff2c58da6c968f220d9be7df5eef795a
-  data.tar.gz: dfdd350bcc6877d9e3c2d42b76096c6b6ac8abe9f4e96c77d48726cf5aa51748
+  metadata.gz: cae13e5551446c7306ce3d8d90a12fa47a3caedbcebdc749b1852456b558c695
+  data.tar.gz: 2501db731b91ab03fafae8a42eeaed104228cab7f5dcffaf21723558e9ac03f3
 SHA512:
-  metadata.gz: 82c2f07ef261dccdabc60c938b0165a92d5f9853e2c1cb1f80783784918ea177b5c681093c6e4004211beee622e060afa2b760cc1f8ba56718b6513044008032
-  data.tar.gz: 71d0b3e3de82994df654e595a6d9e0a9f6bc8c6c3d81e404f7991cac47795109ec73f2d6f04a853e624e4bf7c83c3b7c7cb092220e8d9175331139478f058ef7
+  metadata.gz: daf5758513ab73925cb7b7f402112ead3e9c0b3bcb4a59d6f227d5eb04ab710c7c9ecf06d3edf9326172d5758a8625a158e508f6eb68e740f8c5efd8cf31bc31
+  data.tar.gz: 38cf70d8025eed5b8128e7885bb21ac9c8a25b94c89a0bd2fb00df7421ecc80df02615c26e335cb86bdce16d1d5653898617332a31249ce0478050b5a89f3818

data/bin/github-to-canvas

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 require 'optparse'
 require 'github-to-canvas'
+
 options = {}
 OptionParser.new do |opts|
   opts.banner = <<-EOBANNER
@@ -29,23 +30,40 @@ OptionParser.new do |opts|
     Run these commands from inside a local GitHub repository. This gem is built for Flatiron School's internal use.
     Some default behaviors assume this, like the default Canvas API path.
 
-    Example usage:
+    Create and Update Canvas Lessons From Inside a Local GitHub Repo Folder:
+
+    github-to-canvas --create-lesson 154                                                           -> Creates a lesson in course 154, derives the name and type from the local repo
+    github-to-canvas --create-lesson 154 --name "Fetch Lab"                                        -> Creates a lesson in course 154 with the provided name, derives the type from the local repo
+    github-to-canvas --create-lesson 154 --name "Fetch Lab" --type assignment                      -> Creates an assignment in course 154 with the provided name
+    github-to-canvas --create-lesson 154 --name "Fetch Lab" --branch solution                      -> Creates a lesson in course 154 with the provided name, uses the repository's solution branch and derives the type from the local repo
+    github-to-canvas --align                                                                       -> Patches existing lessons in Canvas based on the .canvas file  
+    github-to-canvas --align --fis-links                                                           -> Patches existing lessons in Canvas based on the .canvas file, adds additional Flatiron School specific HTML and meta-data
+    github-to-canvas --align --remove-header-and-footer                                            -> Patches existing lessons in Canvas based on the .canvas file, removes top lesson header before converting to HTML    
+
+    Get Info on a Canvas Course, Lesson or GitHub Repo:
+    
+    github-to-canvas --query COURSE                                                                -> Displays a course's modules and their lessons in course order as YAML
+    github-to-canvas --map YAML                                                                    -> Uses a YAML file created with --query to retrieve repositories that were associated with Canvas lessons using --fis-links. Returns an updated YAML.
+    github-to-canvas --read-from-canvas CANVAS_LESSON_URL                                          -> Retrieves a lesson's contents and information from Canvas
+    github-to-canvas --read-from-github GITHUB_URL                                                 -> Retrieves the provided GitHub markdown file, converted into HTML
+
+    Create and Update Canvas Lessons Using Remote GitHub Repositories:
+
+    github-to-canvas --create-from-github GITHUB_URL --course COURSE_ID --type TYPE                -> Creates a lesson in the provided course using the remote GitHub URL. Source must be from a public repo.
+    github-to-canvas --align-from-github GITHUB_URL --course COURSE_ID --id LESSON_ID --type TYPE  -> Updates a lesson in the provided course using the remote GitHub URL. Source must be from a public repo.
 
-    github-to-canvas --create-lesson 154                                      -> Creates a lesson in course 154, derives the name and type from the local repo
-    github-to-canvas --create-lesson 154 --name "Fetch Lab"                   -> Creates a lesson in course 154 with the provided name, derives the type from the local repo
-    github-to-canvas --create-lesson 154 --name "Fetch Lab" --type assignment -> Creates an assignment in course 154 with the provided name
-    github-to-canvas --create-lesson 154 --name "Fetch Lab" --branch solution -> Creates a lesson in course 154 with the provided name, uses the repository's solution branch and derives the type from the local repo
-    github-to-canvas --align                                                  -> Patches existing lessons in Canvas based on the .canvas file  
-    github-to-canvas --align --fis-links                                      -> Patches existing lessons in Canvas based on the .canvas file, adds additional Flatiron School specific HTML and meta-data
-    github-to-canvas --align --remove-header-and-footer                       -> Patches existing lessons in Canvas based on the .canvas file, removes top lesson header before converting to HTML
-    github-to-canvas --info COURSE                                            -> Displays a course's lesson and assignment names    
+    Create and Update Canvas Courses From YAML:
+
+    github-to-canvas --build-course YAML_FILE                                                     -> Uses the provided YAML file to create a course, add modules and populate them with lessons using remote GitHub repositories
+    github-to-canvas --add-to-course YAML_FILE --course                                           -> Uses a YAML file to a modules and lessons to an existing course.
+    github-to-canvas --update-course YAML_FILE                                                    -> Uses a YAML file to update lessons using their associated GitHub repositories (ignores module/course structure in YAML file)
 
   EOBANNER
 
   opts.on("-cCOURSE", "--create-lesson COURSE", 
           "Creates a new canvas lesson, converting the local repository's README.md to HTML. Adds .canvas file to remote repository") do |course| 
             options[:create_lesson] = true
-            options[:course] = course
+            options[:course_id] = course
           end
   opts.on("-bBRANCH", "--branch BRANCH", 
           "Sets the repository branch used for lesson creation") do |branch| 
@@ -93,8 +111,8 @@ OptionParser.new do |opts|
             options[:remove_header_and_footer] = true
           end
   opts.on("--course COURSE",
-          "For align functionality only - updates the HTML content of a lesson using the provided course ID. Use with --id.") do |course|
-            options[:course] = course
+          "For align functionality only - updates the HTML content of a lesson using the provided course ID. Use with --id.") do |course_id|
+            options[:course_id] = course_id
           end
   opts.on("--id ID",
           "For align functionality only - updates the HTML content of a lesson using the provided assignment or page ID. Use with --course.") do |id|
@@ -108,30 +126,134 @@ OptionParser.new do |opts|
           "Displays a course's lessons and assignments") do |course|
             options[:query] = course
           end
-  opts.on("--remote",
-          "Retrieves a Canvas lesson. Requires --course and --id") do |remote|
-            options[:remote] = true
+  opts.on("--map YAML_FILE", 
+          "REQUIRES -f or --file Associates canvas lessons with repositories. Use query to create required YAML file") do |file|
+            options[:map] = file
+          end
+  opts.on("--read-from-canvas CANVAS_URL",
+          "Retrieves an existing Canvas lesson using the provided URL") do |url|
+            options[:read_from_canvas] = url
+          end
+  opts.on("--read-from-github GITHUB_URL",
+          "Converts an existing GitHub Readme to HTML using the provided URL. URL must be for a GitHub markdown file") do |url|
+            options[:read_from_github] = url
+          end
+  opts.on("--create-from-github GITHUB_URL",
+          "Creates a new Canvas lesson from a remote GitHub Readme. --course and --type options required") do |url|
+            options[:create_from_github] = url
+          end
+  opts.on("--create-quiz-from-github GITHUB_URL",
+          "Creates a new Canvas quiz from a remote GitHub YAML file. --course option required") do |url|
+            options[:quiz_from_github] = url
+          end
+  opts.on("--align-from-github GITHUB_URL",
+          "Aligns an existing Canvas lesson using a remote GitHub Readme. --course, --id, and --type options required") do |url|
+            options[:align_from_github] = url
+          end
+  opts.on("--build-course YAML_FILE", 
+          "Creates Canvas course using provided YAML file") do |file|
+            options[:build_course] = file
+          end
+  opts.on("--add-to-course YAML_FILE", 
+          "Creates Canvas course using provided YAML file") do |file|
+            options[:add_to_course] = file
+          end
+  opts.on("--update-course-lessons YAML_FILE", 
+          "Updates all lessons in a course using remote repos in provided YAML file") do |file|
+            options[:update_course_lessons] = file
           end
-  
   
 end.parse!
 
 if options[:version]
-  GithubToCanvas.new(mode: 'version',  course: nil)
+  GithubToCanvas.new(mode: 'version',  course_id: nil)
+  abort
+end
+
+if options[:read_from_canvas]
+  GithubToCanvas.new(mode: 'canvas_read', filepath: options[:read_from_canvas])
+  abort
+end
+
+if options[:read_from_github]
+  GithubToCanvas.new(mode: 'github_read', filepath: options[:read_from_github])
+  abort
+end
+
+if options[:create_from_github]
+  if options[:course_id] && options[:type]
+    GithubToCanvas.new(mode: 'github_create', 
+                      filepath: options[:create_from_github], 
+                      course_id: options[:course_id], 
+                      type: options[:type],
+                      remove_header_and_footer: !!options[:remove_header_and_footer],
+                      forkable: !!options[:forkable],
+                      fis_links: !!options[:fis])
+  else
+    puts 'Canvas course ID and lesson type required. Example: github-to-canvas --create-from-github URL --course ID --type TYPE'
+  end
+  abort
+end
+
+if options[:align_from_github]
+  if options[:course_id] && options[:type] && options[:id]
+    GithubToCanvas.new(mode: 'github_align', 
+                      filepath: options[:align_from_github], 
+                      course_id: options[:course_id], 
+                      type: options[:type], 
+                      id: options[:id],
+                      remove_header_and_footer: !!options[:remove_header_and_footer],
+                      forkable: !!options[:forkable],
+                      fis_links: !!options[:fis])
+  else
+    puts 'Canvas course ID, lesson ID, and type required. Example: github-to-canvas --create-from-github URL --course COURSE_ID --id LESSON_ID --type TYPE'
+  end
+  abort
 end
 
 if options[:query]
-  GithubToCanvas.new(mode: 'query',  course: options[:query], id: options[:id])
+  GithubToCanvas.new(mode: 'query',  course_id: options[:query], id: options[:id])
+  abort
+end
+
+if options[:map]
+  GithubToCanvas.new(mode: 'map', file_to_convert: options[:map])
+  abort
 end
 
-if options[:remote]
-  if !options[:course] || !options[:id]
-    puts "Both --course and --id required when using --remote"
-    abort
+if options[:build_course]
+  GithubToCanvas.new(mode: 'build_course', 
+                    file_to_convert: options[:build_course],
+                    fis_links: !!options[:fis], 
+                    remove_header_and_footer: !!options[:remove_header_and_footer],
+                    forkable: !!options[:forkable])
+  abort
+end
+
+if options[:add_to_course]
+  if options[:course_id]
+    GithubToCanvas.new(mode: 'add_to_course', 
+                      course_id: options[:course_id], 
+                      file_to_convert: options[:add_to_course],
+                      fis_links: !!options[:fis], 
+                      remove_header_and_footer: !!options[:remove_header_and_footer],
+                      forkable: !!options[:forkable])
+  else
+    puts '--course required'
   end
-  GithubToCanvas.new(mode: 'remote', course: options[:course], id: options[:id])
+  abort
+end
+
+if options[:update_course_lessons]
+  GithubToCanvas.new(mode: 'update_course_lessons', 
+                    file_to_convert: options[:update_course_lessons],
+                    fis_links: !!options[:fis], 
+                    remove_header_and_footer: !!options[:remove_header_and_footer],
+                    forkable: !!options[:forkable])
+  abort
 end
 
+
 if !options[:type]
   if Dir.glob("**/*/").empty?
     options[:type] = "page"
@@ -174,7 +296,7 @@ end
 
 if options[:create_lesson]
   GithubToCanvas.new(mode: "create", 
-                    course: options[:course], 
+                    course_id: options[:course_id], 
                     filepath: Dir.pwd, 
                     file_to_convert: options[:file_to_convert],
                     branch: options[:branch], 
@@ -189,7 +311,7 @@ end
 
 if options[:align]
   GithubToCanvas.new(mode: "align", 
-                    course: options[:course], 
+                    course_id: options[:course_id], 
                     id: options[:id],
                     filepath: Dir.pwd,
                     file_to_convert: options[:file_to_convert], 

data/lib/github-to-canvas.rb

@@ -1,56 +1,142 @@
+require 'byebug'
 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,