github-to-canvas 0.0.58 → 0.1.4

data/bin/github-to-canvas

@@ -1,6 +1,10 @@
 #!/usr/bin/env ruby
+
+require 'byebug'
+
 require 'optparse'
 require 'github-to-canvas'
+
 options = {}
 OptionParser.new do |opts|
   opts.banner = <<-EOBANNER
@@ -29,23 +33,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-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    
+    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.
+
+    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| 
@@ -57,12 +78,15 @@ OptionParser.new do |opts|
           end
   opts.on("-tTYPE", "--type TYPE", 
           "Sets the type Canvas lesson to be created (page or assignment). If no type, type decided based on repository structure") do |type| 
-            if type == 'page' || type == 'assignment' || type == 'discussion'
-              options[:type] = type
-            else
-              puts "Invalid type. Defaulting to page"
-              options[:type] = "page"
-            end
+            # byebug
+            options[:type] = type.downcase
+            abort if type == 'quiz' || type == 'discussion'
+            # if type == 'page' || type == 'assignment' || type == 'discussion' || type == 'quiz' || type == 'Page' || type == 'Assignment' || type == 'Discussion' || type == 'Quiz'
+              
+            # else
+            #   puts "Invalid type. Defaulting to page"
+            #   options[:type] = "page"
+            # end
           end
   opts.on("-fFILE", "--file FILE", 
           "Looks for and uses a markdown file in the currentt folder as source for conversion. Default file is README.md. Skips writing .canvas to repository") do |file| 
@@ -84,6 +108,10 @@ OptionParser.new do |opts|
           "Adds additional Flatiron School HTML after markdown conversion") do |f|
             options[:fis] = true
           end
+  opts.on("--aaq", 
+          "Adds AAQ flag to HTML header appended with --fis-links") do |aaq|
+            options[:aaq] = aaq
+          end
   opts.on("--forkable",
           "Used with --fis-links, adds fork button to HTML header injected into Canvas lesson") do |remote|
             options[:forkable] = true
@@ -93,8 +121,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,28 +136,178 @@ 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("--urls-only", 
+          "Use with --map. Outputs repo URLs instead of YAML") do |urls|
+            options[:urls_only] = urls
+          end
+#  opts.on("--csv COURSE", 
+#          "Returns a course's lesson struction as CSV") do |course|
+#            options[:csv] = course
+#          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
+  opts.on("--clone-from-yaml YAML_FILE", 
+          "Iterates over provided course YAML file and clones repos locally") do |file|
+            options[:clone_from_yaml] = file
+          end
+  opts.on("--contains-html", 
+          "Escapes all HTML included in source markdown by replacing '<' and '>' with HTML charset values") do |html|
+            options[:contains_html] = html
           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],
+                    remove_header_and_footer: !!options[:remove_header_and_footer],
+                    forkable: !!options[:forkable],
+                    fis_links: !!options[:fis],
+                    aaq: !!options[:aaq],
+                    contains_html: options[:contains_html])
+  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],
+                      name: options[:name],
+                      remove_header_and_footer: !!options[:remove_header_and_footer],
+                      forkable: !!options[:forkable],
+                      fis_links: !!options[:fis],
+                      aaq: !!options[:aaq],
+                      contains_html: options[:contains_html])
+  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],
+                      name: options[:name],
+                      remove_header_and_footer: !!options[:remove_header_and_footer],
+                      forkable: !!options[:forkable],
+                      fis_links: !!options[:fis],
+                      aaq: !!options[:aaq],
+                      contains_html: options[:contains_html])
+  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],
+                      urls_only: !!options[:urls_only])
+  abort
+end
+
+if options[:csv]
+  GithubToCanvas.new(mode: 'csv', file_to_convert: options[:csv])
+  abort
+end
+
+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],
+                    aaq: !!options[:aaq],
+                    forkable: !!options[:forkable])
+  abort
 end
 
-if options[:remote]
-  if !options[:course] || !options[:id]
-    puts "Both --course and --id required when using --remote"
-    abort
+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],
+                      aaq: !!options[:aaq],
+                      contains_html: options[:contains_html])
+  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],
+                    aaq: !!options[:aaq],
+                    contains_html: options[:contains_html])
+  abort
+end
+
+if options[:clone_from_yaml]
+  GithubToCanvas.new(mode: 'clone_course', 
+                    file_to_convert: options[:clone_from_yaml])
+  abort
 end
 
 if !options[:type]
@@ -174,7 +352,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], 
@@ -184,12 +362,14 @@ if options[:create_lesson]
                     fis_links: !!options[:fis], 
                     remove_header_and_footer: !!options[:remove_header_and_footer],
                     only_update_content: !!options[:only_content],
-                    forkable: !!options[:forkable])
+                    forkable: !!options[:forkable],
+                    aaq: !!options[:aaq],
+                    contains_html: options[:contains_html])
 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], 
@@ -200,5 +380,7 @@ if options[:align]
                     fis_links: !!options[:fis], 
                     remove_header_and_footer: !!options[:remove_header_and_footer],
                     only_update_content: !!options[:only_content],
-                    forkable: !!options[:forkable])
+                    forkable: !!options[:forkable],
+                    aaq: !!options[:aaq],
+                    contains_html: options[:contains_html])
 end

data/lib/github-to-canvas.rb

@@ -1,56 +1,160 @@
+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)
+    when 'csv'
+      CanvasInterface.csv(options[:file_to_convert])
+    when 'canvas_read'
+      puts CanvasInterface.read_lesson(options[:filepath])
+    when 'github_read'
+      html = RepositoryConverter.remote_file_conversion(options)
+      puts RepositoryConverter.adjust_converted_html(options, html)
+    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 = options[:name] ? 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 = options[:name] ? 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 = options[:name] ? 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)
+        }
+      }
+    when 'clone_course'
+      course_yaml = YAML.load(File.read(options[:file_to_convert]))
+      new_dir = "#{course_yaml[:name].downcase.gsub(' ','-')}"
+      cmd = "mkdir #{new_dir}"
+      `#{cmd}`
+      course_yaml[:modules].each { |module_info|
+      puts "Cloning #{module_info[:name]}"
+        module_info[:lessons].each { |lesson|
+        if lesson["repository"] == ""
+          puts "No repository found for #{lesson['title']}"
+          next
+        else
+          cmd = "git clone #{lesson['repository']}"
+          puts cmd
+          GithubInterface.cd_into_and(new_dir, cmd)
+        end
+        }
+      }
+    else
+      puts VERSION
     end
   end
-
+  
 end