japanda 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8b6f742d4af878f7abb31f306a4eb627dac08ee7
-  data.tar.gz: 1f9002401e828188a0de0a37c0e8585043e5d8b5
+  metadata.gz: c88d5e552e2c67042dd5da76188c48ffefc2f8b7
+  data.tar.gz: b871098f94298c6ad6c0acb22c7d12a01a6bbd25
 SHA512:
-  metadata.gz: 1640cc2ebf9a6e41fa780dff1fdff3b0d5c7b53513ef0e15bba66acd8ca50c353d84846bf7259e863f4c0284bcdc5c21e1c0a929fda2d1a8b2b13343db9a50cd
-  data.tar.gz: b95aa945713407aab3ea9b3bad1bebe94a81a186dc632a9cd10027a8e5d02f270ce59726498f07109b61bfc95294bc0497520fe1310ef36746b5af74c39ea50f
+  metadata.gz: cdbcc9424cd02a9923fed5121c7d74638888ab9cb37e25e7286f1ecaa0b70a9c46109ee688fdcfa149c28f81bbccca3eba977d613f8d979a1bad148c692c8012
+  data.tar.gz: e4c24a8f9858ebd769ce85723066772e46be305456020c90d6ebdba950cab3f5f53f5753d9569b8c87cdab79d27742e6d6bdb15100824171bea160757533414c

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    japanda (0.1.3)
+    japanda (0.1.4)
       rest-client
 
 GEM
@@ -11,6 +11,7 @@ GEM
     domain_name (0.5.24)
       unf (>= 0.0.5, < 1.0.0)
     dotenv (2.0.2)
+    hashie (2.0.5)
     http-cookie (1.0.2)
       domain_name (~> 0.5)
     mime-types (2.6.2)
@@ -43,9 +44,10 @@ PLATFORMS
 DEPENDENCIES
   bundler (>= 1.0.0)
   dotenv
+  hashie
   japanda!
   rake (~> 10.0)
   rspec
 
 BUNDLED WITH
-   1.10.5
+   1.10.6

data/README.md

@@ -1,20 +1,21 @@
 # Japanda
-Japanda provides an object oriented wrapper and functional wrapper around canvas api
-Disclaimer: For testing purposes only
 
-v0.1.3: Features
-a) Create canvas learner user and admin user
-b) Create canvas course
-c) Add sections to canvas
-d) Add module(s) with assignment(s)
+Japanda provides an object-oriented wrapper and functional wrapper around Instructure Canvas Api's
+
+Disclaimer: For testing purposes only.
+
+v0.1.3 Features
+
+1. Create canvas learner user and admin user
+2. Create canvas course
+3. Add sections to canvas
+4. Add module(s) with assignment(s)
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
-```ruby
-gem 'japanda'
-```
+    gem 'japanda'
 
 And then execute:
 
@@ -25,34 +26,45 @@ Or install it yourself as:
     $ gem install japanda
 
 ## Usage
+
 Set a few enviroment variables( or use .env.example file)
 
-```ruby
-export CANVAS_API_HOST=
-export CANVAS_API_TOKEN=
-export CANVAS_ACCOUNT_ID=
-```
+    export CANVAS_API_HOST=
+    export CANVAS_API_TOKEN=
+    export CANVAS_ACCOUNT_ID=
+
+To create a new course
 
-```ruby
-new canvas course, uses default course_config
-CanvasFactory::Course.new
+    CanvasFactory::Course.new
+    
+To create a canvas course by specifying the course config
 
-create a canvas course by specifying the course config
-course_config = CanvasFactory::CourseConfig.new({ name: 'Candy Tasting' })
-course = CanvasFactory::Course.new course_config
-```
+    course_config = CanvasFactory::CourseConfig.new({ name: 'Candy Tasting' })
+    course = CanvasFactory::Course.new course_config
+    
+To create a canvas learner user
+
+    user_config = CanvasFactory::UserConfig.new(short_name: 'John Doe', password: 'Password01') 
+    user = CanvasFactory::User.new(user_config)
+    learner_user = user.create_learner_user
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bundle install` to install dependencies. Then, run `rspec` to run the tests.
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Release a new version
+
+To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/japanda. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/babababili/japanda. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
 
 
 ## License
-For testing purposes only
+
+For testing purposes only.
+
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/japanda.gemspec

@@ -6,8 +6,8 @@ require 'japanda/version'
 Gem::Specification.new do |spec|
   spec.name          = 'japanda'
   spec.version       = Japanda::VERSION
-  spec.authors       = ['Santosh Natarajan']
-  spec.email         = ['snatarajan@instructure.com']
+  spec.authors       = ['Santosh Natarajan', 'Robert Lamb']
+  spec.email         = ['snatarajan@instructure.com', 'rlamb@instructure.com']
 
   spec.summary       = %q{Library to create custom course.}
   spec.description   = %q{Library to create custom course. wip.}
@@ -30,6 +30,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler', '>= 1.0.0'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'hashie'
   spec.add_development_dependency 'dotenv'
   spec.add_dependency 'rest-client'
 end

data/lib/japanda/canvas_factory/assignment.rb

@@ -1,17 +1,31 @@
-# assignment class
 module CanvasFactory
+  # assignment class
   class Assignment
-    attr_reader :id, :name, :course_id, :html_url, :grading_type, :published, :due_at, :created_at
+    attr_reader :id, :name, :course_id, :html_url, :grading_type, :published, :due_at,
+                :created_at, :request, :response
 
-    def initialize(course_id, assignment_config = CanvasFactory::AssignmentConfig.new)
-      fail 'invalid course_id' if course_id.nil?
+    def initialize(course_id, opts = {}, merge = true)
       @course_id = course_id
-      create_assignment course_id, assignment_config
+      @request = {
+        assignment: {
+          name: "Assignment-#{Time.now.to_i}",
+          grading_type: %w(pass_fail percent letter_grade gpa_scale points).sample,
+          submission_types: ['online_text_entry'],
+          points_possible: 10,
+          due_at: (DateTime.now + 1).iso8601,
+          published: true
+        }
+      }
+      @request = Mergie.deep_merge(@request, opts, merge)
+      create_assignment
+      self
     end
 
-    def create_assignment(course_id, assignment_config)
-      assign_end_point = "#{CANVAS_API_V1}/courses/#{course_id}/assignments"
-      response = CanvasFactory.perform_post(assign_end_point, assignment_config.request_body)
+    private
+
+    def create_assignment
+      assign_end_point = "#{CANVAS_API_V1}/courses/#{@course_id}/assignments"
+      @response = CanvasFactory.perform_post(assign_end_point, @request)
       @id = response['id']
       @name = response['name']
       @html_url = response['html_url']
@@ -19,7 +33,6 @@ module CanvasFactory
       @published = response['published']
       @created_at = response['created_at']
       @due_at = response['due_at']
-      self
     end
   end
 end

data/lib/japanda/canvas_factory/course.rb

@@ -1,16 +1,78 @@
-# canvas course class
 module CanvasFactory
+  # canvas course class
   class Course
-    attr_reader :course_response, :course_id, :course_code, :course_name, :offer
+    attr_reader :course_response, :course_id, :course_code, :course_name, :course_request,
+                :sections, :modules, :assignments, :quizzes
 
-    def initialize(course_config = CanvasFactory::CourseConfig.new)
-      @offer = course_config.offer
-      create_course course_config
+    def initialize(opts = {}, merge = true)
+      @sections = []
+      @modules = []
+      @assignments = []
+      @quizzes = []
+      course_name_code = "auto#{SecureRandom.hex}"
+      @course_request = {
+        account_id: CANVAS_ACCOUNT_ID,
+        course: {
+          name: course_name_code,
+          course_code: course_name_code,
+          start_at: Time.now,
+          end_at: Time.now + (30 * 24 * 60 * 60),
+          license: 'public_domain',
+          is_public: true,
+          is_public_to_auth_users: false,
+          public_syllabus: false,
+          public_description: 'api created course',
+          allow_student_wiki_edits: true,
+          allow_wiki_comments: true,
+          allow_student_forum_attachments: true,
+          open_enrollment: true,
+          self_enrollment: false,
+          restrict_enrollments_to_course_dates: false,
+          term_id: nil,
+          # sis_course_id: '', # field is included only when user has permission to view SIS information
+          # integration_id: '', # field is included only when user has permission to view SIS information
+          hide_final_grades: true,
+          apply_assignment_group_weights: false,
+          syllabus_body: 'api syllabus',
+          grading_standard_id: nil,
+          course_format: 'online'
+        },
+        offer: true,
+        enroll_me: false,
+        enable_sis_reactivation: false
+      }
+      @course_request = Mergie.deep_merge(@course_request, opts, merge)
+      create_course
     end
 
-    def create_course(course_config)
-      course_end_point = "#{CANVAS_API_V1}/accounts/#{course_config.account_id}/courses"
-      @course_response = CanvasFactory.perform_post(course_end_point, course_config.request_body)
+    def add_section(opts = {}, merge = true)
+      section = CanvasFactory::Section.new(@course_id, opts, merge)
+      @sections << section
+    end
+
+    def add_module(opts = {}, merge = true)
+      mod = CanvasFactory::Module.new(@course_id, opts, merge)
+      @modules << mod
+      mod
+    end
+
+    def add_assignment(opts = {}, merge = true)
+      assignment = CanvasFactory::Assignment.new(@course_id, opts, merge)
+      @assignments << assignment
+      assignment
+    end
+
+    def add_quiz(opts = {}, merge = true)
+      quiz = CanvasFactory::Quiz.new(@course_id, opts, merge)
+      @quizzes << quiz
+      quiz
+    end
+
+    private
+
+    def create_course
+      course_end_point = "#{CANVAS_API_V1}/accounts/#{@course_request[:account_id]}/courses"
+      @course_response = CanvasFactory.perform_post(course_end_point, @course_request)
       @course_id = @course_response['id']
       @course_name = @course_response['name']
       @course_code = @course_response['course_code']

data/lib/japanda/canvas_factory/mergie.rb

@@ -0,0 +1,9 @@
+require 'hashie/extensions/deep_merge'
+
+class Mergie < Hash
+  include Hashie::Extensions::DeepMerge
+
+  def self.deep_merge(default_hash, given_hash, should_merge)
+    should_merge ? Mergie[default_hash].deep_merge(Mergie[given_hash]).to_h: given_hash
+  end
+end

data/lib/japanda/canvas_factory/module.rb

@@ -1,58 +1,51 @@
-# canvas module class
 module CanvasFactory
+  # canvas module class
   class Module
-    attr_reader :module, :course_id, :name, :id, :position, :unlock_at, :require_sequential_progress,
-                :publish_final_grade, :prerequisite_module_ids, :published, :items_count, :items_url,
-                :assignments
+    attr_reader :course_id, :name, :module_id, :published, :request, :response,
+                :module_items, :publish_response, :publish_request
 
-    def initialize(course_id, module_config = CanvasFactory::ModuleConfig.new)
-      @assignments = []
-      create_module course_id, module_config
-      publish_module
+    def initialize(course_id, opts = {}, merge = true)
+      @module_items = []
+      @course_id = course_id
+      @request = {
+        module: {
+          name: "module-#{Time.now.to_i}",
+          unlock_at: DateTime.now.iso8601,
+          require_sequential_progress: true
+        }
+      }
+      @request = Mergie.deep_merge(@request, opts, merge)
+      create_module
+      self
     end
 
-    def create_module(course_id, module_config)
-      m_item_end_point = "#{CANVAS_API_V1}/courses/#{course_id}/modules"
-      response = CanvasFactory.perform_post(m_item_end_point, module_config.request_body)
-      @course_id = course_id
-      @id = response['id']
-      @name = response['name']
-      @position = response['position']
-      @unlock_at = response['unlock_at']
-      @require_sequential_progress = response['require_sequential_progress']
-      @publish_final_grade = response['publish_final_grade']
-      @prerequisite_module_ids = response['prerequisite_module_ids']
-      @published = response['published']
-      @items_count = response['items_count']
-      @items_url = response['items_url']
+    def add_module_item(content, opts = {}, merge = true) # content can be assignment or quiz ...
+      module_item = CanvasFactory::ModuleItem.new(@course_id, @module_id, content, opts, merge)
+      @module_items << module_item
+      module_item
     end
 
-    def publish_module
-      body = {
+    def publish(opts = {}, merge = true)
+      @publish_request = {
         module: {
           published: true
         }
       }
-      m_p_end_point = "#{CANVAS_API_V1}/courses/#{@course_id}/modules/#{@id}"
-      response = CanvasFactory.perform_put(m_p_end_point, body)
-      @published = response['published']
+      @publish_request = Mergie.deep_merge(@publish_request, opts, merge)
+      publish_ep = "#{CANVAS_API_V1}/courses/#{@course_id}/modules/#{@module_id}"
+      @publish_response = CanvasFactory.perform_put(publish_ep, @publish_request)
+      @published = @publish_response['published']
     end
 
-    def add_module_item(module_item_request)
-      item_end_point = "#{CANVAS_API_V1}/courses/#{@course_id}/modules/#{@id}/items"
-      CanvasFactory.perform_post(item_end_point, module_item_request)
-      publish_module
-    end
+    private
 
-    def add_assignment(title = 'module_assignment', assignment_config = CanvasFactory::AssignmentConfig.new)
-      assignment = CanvasFactory::Assignment.new(@course_id, assignment_config)
-      module_item_config = CanvasFactory::ModuleItemConfig.new(module_item_type: 'Assignment',
-                                                               completion_type: 'must_view')
-      module_item_config.content_id = assignment.id
-      module_item_config.title = title
-      add_module_item(module_item_config.request_body)
-      @assignments << assignment
-      assignment
+    def create_module
+      m_item_end_point = "#{CANVAS_API_V1}/courses/#{@course_id}/modules"
+      @response = CanvasFactory.perform_post(m_item_end_point, @request)
+      @course_id = course_id
+      @module_id = response['id']
+      @name = response['name']
+      @published = response['published']
     end
   end
 end

data/lib/japanda/canvas_factory/module_item.rb

@@ -0,0 +1,37 @@
+module CanvasFactory
+  # module item class
+  class ModuleItem
+    attr_reader :item_id, :name, :course_id, :html_url, :title, :published, :type,
+                :created_at, :request, :response, :module_id
+
+    def initialize(course_id, module_id, content, opts = {}, merge = true)
+      @course_id = course_id
+      @module_id = module_id
+      @request = {
+        module_item: {
+          title: "module-item#{SecureRandom.hex}",
+          type: content.class.name.split('::').last || '',
+          content_id: content.id,
+          completion_requirement: {
+            type: 'must_view'
+          }
+        }
+      }
+      @request = Mergie.deep_merge(@request, opts, merge)
+      create_item
+      self
+    end
+
+    private
+
+    def create_item
+      item_end_point = "#{CANVAS_API_V1}/courses/#{@course_id}/modules/#{@module_id}/items"
+      @response = CanvasFactory.perform_post(item_end_point, @request)
+      @published = response['published']
+      @item_id = response['id']
+      @type = response['type']
+      @title = response['title']
+      @html_url = response['html_url']
+    end
+  end
+end

data/lib/japanda/canvas_factory/quiz.rb

@@ -0,0 +1,52 @@
+module CanvasFactory
+  # Quiz class
+  class Quiz
+    attr_reader :id, :course_id, :html_url, :published, :due_at, :title,
+                :request, :response
+
+    def initialize(course_id, opts = {}, merge = true)
+      @course_id = course_id
+      @request = {
+        quiz: {
+          title: "quiz-#{Time.now.to_i}",
+          description: 'api created quiz',
+          quiz_type: %w(practice_quiz assignment graded_survey survey).sample,
+          assignment_group_id: nil,
+          time_limit: nil,
+          shuffle_answers: true,
+          hide_results: %w(always until_after_last_attempt).sample,
+          show_correct_answers: true,
+          show_correct_answers_last_attempt: true,
+          hide_correct_answers_at: true,
+          allowed_attempts: 1,
+          scoring_policy: %w(keep_highest keep_latest).sample,
+          one_question_at_a_time: false,
+          cant_go_back: false,
+          access_code: nil,
+          ip_filter: nil,
+          due_at: (DateTime.now + 10).iso8601,
+          lock_at: (DateTime.now + 10).iso8601,
+          unlock_at: (DateTime.now).iso8601,
+          published: true,
+          one_time_results: false
+        }
+      }
+      @request = Mergie.deep_merge(@request, opts, merge)
+      create_quiz
+      self
+    end
+
+    private
+
+    def create_quiz
+      quiz_end_point = "#{CANVAS_API_V1}/courses/#{@course_id}/quizzes"
+      @response = CanvasFactory.perform_post(quiz_end_point, @request)
+      @id = response['id']
+      @title = response['title']
+      @html_url = response['html_url']
+      @published = response['published']
+      @due_at = response['due_at']
+    end
+  end
+end
+

data/lib/japanda/canvas_factory/section.rb

@@ -1,26 +1,36 @@
-# canvas section class
 module CanvasFactory
+  # canvas section class
   class Section
     attr_reader :course_id, :id, :end_at, :start_at, :name, :sis_section_id, :sis_course_id,
-                :integration_id, :sis_import_id, :nonxlist_course_id
+                :integration_id, :sis_import_id, :nonxlist_course_id, :request, :response
 
-    def initialize(course_id, section_config = CanvasFactory::SectionConfig.new)
-      create_section course_id, section_config
+    def initialize(course_id, opts = {}, merge = true)
+      @course_id = course_id
+      @request = {
+        course_section: {
+          name: "section-#{Time.now.to_i}",
+          start_at: Time.now,
+          end_at: Time.now + (30 * 24 * 60 * 60),
+          restrict_enrollments_to_section_dates: false,
+          # enable_sis_reactivation: false,
+          # sis_section_id: nil
+        }
+      }
+      @request = Mergie.deep_merge(@request, opts, merge)
+      create_section
+      self
     end
 
-    def create_section(course_id, section_config)
-      section_end_point = "#{CANVAS_API_V1}/courses/#{course_id}/sections"
-      response = CanvasFactory.perform_post(section_end_point, section_config.request_body)
+    private
+
+    def create_section
+      section_end_point = "#{CANVAS_API_V1}/courses/#{@course_id}/sections"
+      @response = CanvasFactory.perform_post(section_end_point, @request)
       @course_id = response['course_id']
       @id = response['id']
       @name = response['name']
       @end_at = response['end_at']
       @start_at = response['start_at']
-      @sis_section_id = response['sis_section_id']
-      @sis_course_id = response['sis_course_id']
-      @integration_id = response['integration_id']
-      @sis_import_id = response['sis_import_id']
-      @nonxlist_course_id = response['nonxlist_course_id']
     end
   end
 end

data/lib/japanda/canvas_factory/user.rb

@@ -1,27 +1,58 @@
-# canvas user class
 module CanvasFactory
+  # canvas user class
   class User
-    attr_reader :user_config, :user_response, :user_response_id,
-                :user_response_email_id, :user_short_name, :user_password
+    attr_reader :learner_request, :user_response, :id, :admin_request,
+                :email_id, :short_name, :password
 
-    def initialize(user_config = CanvasFactory::UserConfig.new)
-      @user_config = user_config
+    def initialize(opts = {}, merge = true)
+      unique_email = "#{@email_prefix}#{SecureRandom.hex}@example.com"
+      @learner_request = {
+        user: {
+          name: unique_email,
+          short_name: 'auto user',
+          terms_of_use: '1',
+          send_confirmation: true
+        },
+        pseudonym: {
+          unique_id: unique_email,
+          password: 'Testing01'
+        },
+        force_validations: true
+      }
+      @learner_request = Mergie.deep_merge(@learner_request, opts, merge)
+      create_learner_user
     end
 
+    private
+
     def create_learner_user
       user_end_point = "#{CANVAS_API_V1}/accounts/#{CANVAS_ACCOUNT_ID}/users"
-      @user_response = CanvasFactory.perform_post(user_end_point, @user_config.user_request_body)
-      @user_response_id = @user_response['id']
-      @user_response_email_id = @user_response['login_id']
-      @user_short_name = @user_config.short_name
-      @user_password = @user_config.password
+      @user_response = CanvasFactory.perform_post(user_end_point, @learner_request)
+      @id = @user_response['id']
+      @email_id = @user_response['login_id']
+      @short_name = @user_response['short_name']
+      @password = @learner_request[:pseudonym][:password]
+      @user_response
     end
+  end
 
-    def create_admin_user
-      create_learner_user
-      body = @user_config.admin_request_body(@user_response['id'].to_i)
+  # canvas admin user class
+  class AdminUser < User
+    def initialize(opts = {}, merge = true)
+      super(opts, merge)
+      make_admin_user
+    end
+
+    private
+
+    def make_admin_user
+      @admin_request = {
+        user_id: @id,
+        role_id: 'AccountAdmin',
+        send_confirmation: true
+      }
       admin_end_point = "#{CANVAS_API_V1}/accounts/#{CANVAS_ACCOUNT_ID}/admins"
-      CanvasFactory.perform_post(admin_end_point, body)
+      CanvasFactory.perform_post(admin_end_point, @admin_request)
     end
   end
 end

data/lib/japanda/version.rb

@@ -1,3 +1,3 @@
 module Japanda
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: japanda
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Santosh Natarajan
+- Robert Lamb
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-09-24 00:00:00.000000000 Z
+date: 2015-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +53,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: dotenv
   requirement: !ruby/object:Gem::Requirement
@@ -83,6 +98,7 @@ dependencies:
 description: Library to create custom course. wip.
 email:
 - snatarajan@instructure.com
+- rlamb@instructure.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -102,16 +118,13 @@ files:
 - lib/japanda.rb
 - lib/japanda/canvas_factory.rb
 - lib/japanda/canvas_factory/assignment.rb
-- lib/japanda/canvas_factory/assignment_config.rb
 - lib/japanda/canvas_factory/course.rb
-- lib/japanda/canvas_factory/course_config.rb
+- lib/japanda/canvas_factory/mergie.rb
 - lib/japanda/canvas_factory/module.rb
-- lib/japanda/canvas_factory/module_config.rb
-- lib/japanda/canvas_factory/module_item_config.rb
+- lib/japanda/canvas_factory/module_item.rb
+- lib/japanda/canvas_factory/quiz.rb
 - lib/japanda/canvas_factory/section.rb
-- lib/japanda/canvas_factory/section_config.rb
 - lib/japanda/canvas_factory/user.rb
-- lib/japanda/canvas_factory/user_config.rb
 - lib/japanda/version.rb
 homepage: 
 licenses: []

data/lib/japanda/canvas_factory/assignment_config.rb

@@ -1,27 +0,0 @@
-module CanvasFactory
-  class AssignmentConfig
-    attr_accessor :name, :grading_type, :submission_types, :points_possible, :due_at, :published
-
-    def initialize(opts = {})
-      @name = opts[:name] || "Assignment-#{Time.now.to_i}"
-      @grading_type = opts[:grading_type] || %w(pass_fail percent letter_grade gpa_scale points).sample
-      @submission_types = opts[:submission_types] || ['online_text_entry']
-      @points_possible = opts[:points_possible] || 10
-      @due_at = opts[:due_at] || (DateTime.now + 1).iso8601
-      @published = opts[:published] || true
-    end
-
-    def request_body
-      {
-        assignment: {
-          name: @name,
-          grading_type: @grading_type,
-          submission_types: @submission_types,
-          points_possible: @points_possible,
-          due_at: @due_at,
-          published: @published
-        }
-      }
-    end
-  end
-end

data/lib/japanda/canvas_factory/course_config.rb

@@ -1,28 +0,0 @@
-module CanvasFactory
-  class CourseConfig
-    attr_accessor :account_id, :name, :course_code, :start_at, :end_at, :offer
-
-    def initialize(opts = {})
-      course_name_code = "auto#{SecureRandom.hex}"
-      @account_id = opts[:account_id] || CANVAS_ACCOUNT_ID
-      @name = opts[:name] || course_name_code
-      @course_code = opts[:course_code] || course_name_code
-      @start_at = opts[:start_at] || Time.now
-      @end_at = opts[:end_at] || Time.now + (30 * 24 * 60 * 60)
-      @offer = opts[:offer] || true
-    end
-
-    def request_body
-      {
-        account_id: @account_id,
-        course: {
-          name: @name,
-          course_code: @course_code,
-          start_at: @start_at,
-          end_at: @end_at
-        },
-        offer: @offer
-      }
-    end
-  end
-end

data/lib/japanda/canvas_factory/module_config.rb

@@ -1,22 +0,0 @@
-module CanvasFactory
-  class ModuleConfig
-    attr_accessor :name, :unlock_at, :require_sequential_progress
-
-    def initialize(opts = {})
-      @name = opts[:name] || "module-#{Time.now.to_i}"
-      @unlock_at = opts[:unlock_at] || DateTime.now.iso8601
-      @require_sequential_progress = opts[:require_sequential_progress] || true
-      @published = opts[:published] || true
-    end
-
-    def request_body
-      {
-        module: {
-          name: @name,
-          unlock_at: @unlock_at,
-          require_sequential_progress: @require_sequential_progress
-        }
-      }
-    end
-  end
-end

data/lib/japanda/canvas_factory/module_item_config.rb

@@ -1,25 +0,0 @@
-module CanvasFactory
-  class ModuleItemConfig
-    attr_accessor :module_item_type, :content_id, :completion_type, :title
-
-    def initialize(opts = {})
-      @module_item_type = opts[:module_item_type] || 'Assignment'
-      @content_id = opts[:content_id]
-      @completion_type = opts[:completion_type] || 'must_view'
-      @title = opts[:title] || 'module_assignment'
-    end
-
-    def request_body
-      {
-        module_item: {
-          title: @title,
-          type: @module_item_type,
-          content_id: @content_id,
-          completion_requirement: {
-            type: @completion_type
-          }
-        }
-      }
-    end
-  end
-end

data/lib/japanda/canvas_factory/section_config.rb

@@ -1,21 +0,0 @@
-module CanvasFactory
-  class SectionConfig
-    attr_accessor :name, :start_at, :end_at
-
-    def initialize(opts = {})
-      @name = opts[:name] || "section-#{Time.now.to_i}"
-      @start_at = opts[:start_at] || Time.now
-      @end_at = opts[:end_at] || Time.now + (30 * 24 * 60 * 60)
-    end
-
-    def request_body
-      {
-        course_section: {
-          name: @name,
-          start_at: @start_at,
-          end_at: @end_at
-        }
-      }
-    end
-  end
-end

data/lib/japanda/canvas_factory/user_config.rb

@@ -1,41 +0,0 @@
-module CanvasFactory
-  class UserConfig
-    attr_accessor :email_prefix, :password, :short_name, :terms_of_use, :send_confirmation,
-                  :force_validations, :role_id, :email_id
-
-    def initialize(opts = {})
-      @email_prefix = opts[:email_prefix] || 'catauto'
-      @password = opts[:password] || 'Testing01'
-      @short_name = opts[:short_name] || 'cat auto'
-      @terms_of_use = opts[:terms_of_use] || '1'
-      @send_confirmation = opts[:send_confirmation] || true
-      @force_validations = opts[:force_validations] || true
-      @role_id = opts[:role_id] || 'AccountAdmin'
-      @email_id = opts[:email_id] || "#{@email_prefix}#{SecureRandom.hex}@example.com"
-    end
-
-    def user_request_body
-      {
-        user: {
-          name: @email_id,
-          short_name: @short_name,
-          terms_of_use: @terms_of_use,
-          send_confirmation: @send_confirmation
-        },
-        pseudonym: {
-          unique_id: @email_id,
-          password: @password
-        },
-        force_validations: @force_validations
-      }
-    end
-
-    def admin_request_body(id)
-      {
-        user_id: id,
-        role_id: @role_id,
-        send_confirmation: @send_confirmation
-      }
-    end
-  end
-end