canvas_cc 0.0.1

data/lib/canvas_cc/canvas_cc/multiple_blanks_question_writer.rb

@@ -0,0 +1,51 @@
+module CanvasCc::CanvasCC
+  class MultipleBlanksQuestionWriter < QuestionWriter
+    register_writer_type 'fill_in_multiple_blanks_question'
+
+    private
+
+    def self.write_responses(presentation_node, question)
+      resp_idents = question.answers.map{|a| a.resp_ident}.uniq
+      resp_idents.each do |resp_ident|
+        presentation_node.response_lid(:ident => resp_ident, :rcardinality => 'Single') do |response_node|
+          response_node.render_choice do |choice_node|
+            question.answers.select{|a| a.resp_ident == resp_ident}.each do |answer|
+              choice_node.response_label(:ident => answer.id) do |label_node|
+                label_node.material do |material_node|
+                  material_node.mattext answer.answer_text, :texttype => 'text/html'
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def self.write_response_conditions(processing_node, question)
+      # Feedback
+      question.answers.each do |answer|
+        next unless answer.feedback && answer.feedback.strip.length > 0
+        processing_node.respcondition(:continue => 'Yes') do |condition_node|
+          condition_node.conditionvar do |var_node|
+            var_node.varequal answer.id, :respident => answer.resp_ident
+          end
+          condition_node.displayfeedback(:feedbacktype => 'Response', :linkrefid => "#{answer.id}_fb")
+        end
+      end
+
+      # Scores
+      question.answers.each do |answer|
+        processing_node.respcondition(:continue => 'No') do |condition_node|
+          condition_node.conditionvar do |var_node|
+            var_node.varequal answer.id, :respident => answer.resp_ident
+          end
+          condition_node.setvar(convert_fraction_to_score(answer.fraction), :varname => 'SCORE', :action => 'Set')
+        end
+      end
+    end
+
+    def self.write_additional_nodes(item_node, question)
+      write_standard_answer_feedbacks(item_node, question)
+    end
+  end
+end

data/lib/canvas_cc/canvas_cc/multiple_choice_question_writer.rb

@@ -0,0 +1,48 @@
+module CanvasCc::CanvasCC
+  class MultipleChoiceQuestionWriter < QuestionWriter
+    register_writer_type 'multiple_choice_question'
+
+    private
+
+    def self.write_responses(presentation_node, question)
+      presentation_node.response_lid(:ident => 'response1', :rcardinality => 'Single') do |response_node|
+        response_node.render_choice do |choice_node|
+          question.answers.each do |answer|
+            choice_node.response_label(:ident => answer.id) do |label_node|
+              label_node.material do |material_node|
+                material_node.mattext answer.answer_text, :texttype => 'text/html'
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def self.write_response_conditions(processing_node, question)
+      # Feedback
+      question.answers.each do |answer|
+        next unless answer.feedback && answer.feedback.strip.length > 0
+        processing_node.respcondition(:continue => 'Yes') do |condition_node|
+          condition_node.conditionvar do |var_node|
+            var_node.varequal answer.id, :respident => 'response1'
+          end
+          condition_node.displayfeedback(:feedbacktype => 'Response', :linkrefid => "#{answer.id}_fb")
+        end
+      end
+
+      # Scores
+      question.answers.each do |answer|
+        processing_node.respcondition(:continue => 'No') do |condition_node|
+          condition_node.conditionvar do |var_node|
+            var_node.varequal answer.id, :respident => 'response1'
+          end
+          condition_node.setvar(convert_fraction_to_score(answer.fraction), :varname => 'SCORE', :action => 'Set')
+        end
+      end
+    end
+
+    def self.write_additional_nodes(item_node, question)
+      write_standard_answer_feedbacks(item_node, question)
+    end
+  end
+end

data/lib/canvas_cc/canvas_cc/multiple_dropdowns_question_writer.rb

@@ -0,0 +1,30 @@
+module CanvasCc::CanvasCC
+  class MultipleDropdownsQuestionWriter < QuestionWriter
+    register_writer_type 'multiple_dropdowns_question'
+
+    private
+
+    def self.write_responses(presentation_node, question)
+      question.responses.each do |response|
+        presentation_node.response_lid(:ident => "response_#{response[:id]}") do |response_node|
+          response_node.material do |material_node|
+            material_node.mattext(response[:id], :texttype => 'text/plain')
+          end
+          response_node.render_choice do |choice_node|
+            response[:choices].each do |choice|
+              choice_node.response_label(:ident => choice[:id]) do |label_node|
+                label_node.material do |material_node|
+                  material_node.mattext(choice[:text], :texttype => 'text/plain')
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def self.write_response_conditions(processing_node, question)
+      # this is always an answerless questionnaire question (for now), so no response conditions are necessary
+    end
+  end
+end

data/lib/canvas_cc/canvas_cc/numerical_question_writer.rb

@@ -0,0 +1,40 @@
+module CanvasCc::CanvasCC
+  class NumericalQuestionWriter < QuestionWriter
+    register_writer_type 'numerical_question'
+
+    private
+
+    def self.write_responses(presentation_node, question)
+      presentation_node.response_str(:rcardinality => 'Single', :ident => 'response1') do |response_node|
+        response_node.render_fib(:fibtype => 'Decimal') do |render_fib_node|
+          render_fib_node.response_label(:ident => 'answer1')
+        end
+      end
+    end
+
+    def self.write_response_conditions(processing_node, question)
+      question.answers.each do |answer|
+        tolerance = question.tolerances[answer.id]
+        processing_node.respcondition(:continue => 'No') do |condition_node|
+          condition_node.conditionvar do |var_node|
+            var_node.or do |or_node|
+              or_node.varequal answer.answer_text, :respident => 'response1'
+              or_node.and do |and_node|
+                and_node.vargte answer.answer_text.to_f - tolerance.to_f, :respident => 'response1'
+                and_node.varlte answer.answer_text.to_f + tolerance.to_f, :respident => 'response1'
+              end
+            end
+          end
+          condition_node.setvar(convert_fraction_to_score(answer.fraction), :varname => "SCORE", :action => 'Set')
+          if answer.feedback && answer.feedback.strip.length > 0
+            condition_node.displayfeedback(:feedbacktype => 'Response', :linkrefid => "#{answer.id}_fb")
+          end
+        end
+      end
+    end
+
+    def self.write_additional_nodes(item_node, question)
+      write_standard_answer_feedbacks(item_node, question)
+    end
+  end
+end

data/lib/canvas_cc/canvas_cc/page_writer.rb

@@ -0,0 +1,38 @@
+module CanvasCc::CanvasCC
+  class PageWriter
+
+    def initialize(work_dir, *pages)
+      @work_dir = work_dir
+      @pages = pages
+    end
+
+    def write
+      Dir.mkdir(File.join(@work_dir, CanvasCc::CanvasCC::Models::Page::WIKI_CONTENT))
+      @pages.each { |page| write_html(page) }
+    end
+
+
+    private
+
+    def write_html(page)
+      builder = Nokogiri::HTML::Builder.new(:encoding => 'UTF-8') do |doc|
+        doc.html { |html|
+          html.head { |head|
+            head.meta('http-equiv' => 'Content-Type', content: 'text/html; charset=utf-8')
+            head.meta(name: 'identifier', content: page.identifier)
+            head.meta(name: 'editing_roles', content: page.editing_roles)
+            head.meta(name: 'workflow_state', content: page.workflow_state)
+            head.title page.title
+          }
+          html.body { |body|
+            body << Nokogiri::HTML::fragment(page.body)
+          }
+        }
+      end
+      file = File.join(@work_dir, page.href)
+      FileUtils.mkdir_p(File.dirname(file))
+      File.open(file, 'w') { |f| f.write(builder.to_html) }
+    end
+
+  end
+end

data/lib/canvas_cc/canvas_cc/question_bank_writer.rb

@@ -0,0 +1,44 @@
+module CanvasCc::CanvasCC
+  class QuestionBankWriter
+
+    def initialize(work_dir, *question_banks)
+      @work_dir = work_dir
+      @question_banks = question_banks
+    end
+
+    def write
+      @question_banks.each do |bank|
+        write_bank(bank)
+      end
+    end
+
+    private
+
+    def write_bank(bank)
+      bank_resource = bank.question_bank_resource
+
+      xml = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
+        xml.questestinterop("xmlns" => "http://www.imsglobal.org/xsd/ims_qtiasiv1p2",
+          "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance",
+          "xsi:schemaLocation"=> "http://www.imsglobal.org/xsd/ims_qtiasiv1p2 http://www.imsglobal.org/xsd/ims_qtiasiv1p2p1.xsd"
+        ) { |xml|
+          xml.objectbank(:ident => bank_resource.identifier) { |xml|
+            xml.qtimetadata { |xml|
+              xml.qtimetadatafield { |xml|
+                xml.fieldlabel 'bank_title'
+                xml.fieldentry bank.title
+              }
+            }
+            bank.questions.each do |question|
+              CanvasCc::CanvasCC::QuestionWriter.write_question(xml, question)
+            end
+          }
+        }
+      end.to_xml
+
+      file_path = File.join(@work_dir, bank_resource.href)
+      FileUtils.mkdir_p(File.dirname(file_path)) unless File.exists?(File.dirname(file_path))
+      File.open(file_path, 'w') { |f| f.write(xml) }
+    end
+  end
+end

data/lib/canvas_cc/canvas_cc/question_group_writer.rb

@@ -0,0 +1,23 @@
+module CanvasCc::CanvasCC
+  class QuestionGroupWriter
+
+    def self.write_question_group(node, question_group)
+      node.section(:title => question_group.title, :ident => question_group.identifier) do |section_node|
+        section_node.selection_ordering do |so_node|
+          so_node.selection do |s_node|
+            s_node.selection_number question_group.selection_number
+            if question_group.points_per_item
+              s_node.selection_extension do |se_node|
+                se_node.points_per_item question_group.points_per_item
+              end
+            end
+          end
+        end
+
+        question_group.questions.each do |question|
+          CanvasCc::CanvasCC::QuestionWriter.write_question(section_node, question)
+        end
+      end
+    end
+  end
+end

data/lib/canvas_cc/canvas_cc/question_writer.rb

@@ -0,0 +1,129 @@
+module CanvasCc::CanvasCC
+  class QuestionWriter
+
+    @@subclasses = {}
+
+    def self.write_question(node, question)
+      if c = @@subclasses[question.question_type]
+        c.write_question_item_xml(node, question)
+      else
+        raise "Unknown question writer type: #{question.question_type}"
+      end
+    end
+
+    def self.register_writer_type(name)
+      @@subclasses[name] = self
+    end
+
+    def self.write_question_item_xml(node, question)
+      node.item(:title => question.title, :ident => question.identifier) do |item_node|
+        write_qti_metadata(item_node, question)
+        write_presentation(item_node, question)
+        write_resprocessing(item_node, question)
+        write_general_feedback(item_node, question)
+        write_additional_nodes(item_node, question)
+      end
+    end
+
+    private
+
+    def self.write_qti_metadata(item_node, question)
+      item_node.itemmetadata do |meta_node|
+        meta_node.qtimetadata do |qtime_node|
+          CanvasCc::CanvasCC::Models::Question::QTI_META_ATTRIBUTES.each do |attr|
+            value = question.send(attr).to_s
+            if value && value.length > 0
+              qtime_node.qtimetadatafield do |field_node|
+                field_node.fieldlabel attr.to_s
+                field_node.fieldentry value
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def self.write_presentation(item_node, question)
+      item_node.presentation do |presentation_node|
+        presentation_node.material do |material_node|
+          material_node.mattext(question.material, :texttype => 'text/html')
+        end
+
+        write_responses(presentation_node, question)
+      end
+    end
+
+    def self.write_responses(presentation_node, question)
+      raise "needs to be implemented in question writer subclass"
+    end
+
+    def self.write_resprocessing(item_node, question)
+      item_node.resprocessing do |processing_node|
+        processing_node.outcomes do |outcomes_node|
+          outcomes_node.decvar(:maxvalue => '100', :minvalue => '0', :varname => 'SCORE', :vartype => 'Decimal')
+        end
+        if question.general_feedback
+          processing_node.respcondition(:continue => 'Yes') do |condition_node|
+            condition_node.conditionvar do |var_node|
+              var_node.other
+            end
+            condition_node.displayfeedback(:feedbacktype => 'Response', :linkrefid => 'general_fb')
+          end
+        end
+        write_response_conditions(processing_node, question)
+      end
+    end
+
+    def self.write_response_conditions(processing_node, question)
+      raise "needs to be implemented in question writer subclass"
+    end
+
+    def self.write_general_feedback(item_node, question)
+      if question.general_feedback && question.general_feedback.length > 0
+        item_node.itemfeedback(:ident => 'general_fb') do |fb_node|
+          fb_node.flow_mat do |flow_node|
+            flow_node.material do |material_node|
+              material_node.mattext(question.general_feedback, :texttype => 'text/html')
+            end
+          end
+        end
+      end
+    end
+
+    def self.write_additional_nodes(item_node, question)
+      # implement in sub-classes if needed
+    end
+
+    # used for 'multiple_choice_question', 'numerical_question', 'short_answer_question', 'true_false_question'
+    def self.write_standard_answer_feedbacks(item_node, question)
+      question.answers.each do |answer|
+        next unless answer.feedback && answer.feedback.strip.length > 0
+        item_node.itemfeedback(:ident => "#{answer.id}_fb") do |feedback_node|
+          feedback_node.flow_mat do |flow_node|
+            flow_node.material do |material_node|
+              material_node.mattext answer.feedback, :texttype => 'text/html'
+            end
+          end
+        end
+      end
+    end
+
+    # helper
+    def self.convert_fraction_to_score(fraction)
+      return 100 if fraction.nil?
+      (100 * fraction).to_i
+    end
+  end
+end
+
+require_relative 'calculated_question_writer'
+require_relative 'essay_question_writer'
+require_relative 'matching_question_writer'
+require_relative 'multiple_answers_question_writer'
+require_relative 'multiple_blanks_question_writer'
+require_relative 'multiple_choice_question_writer'
+require_relative 'multiple_dropdowns_question_writer'
+require_relative 'numerical_question_writer'
+require_relative 'short_answer_question_writer'
+require_relative 'text_only_question_writer'
+require_relative 'true_false_question_writer'

data/lib/canvas_cc/canvas_cc/short_answer_question_writer.rb

@@ -0,0 +1,42 @@
+module CanvasCc::CanvasCC
+  class ShortAnswerQuestionWriter < QuestionWriter
+    register_writer_type 'short_answer_question'
+
+    private
+
+    def self.write_responses(presentation_node, question)
+      presentation_node.response_str(:rcardinality => 'Single', :ident => 'response1') do |response_node|
+        response_node.render_fib do |render_node|
+          render_node.response_label(:ident => 'answer1', :rshuffle => 'No')
+        end
+      end
+    end
+
+    def self.write_response_conditions(processing_node, question)
+      # Feedback
+      question.answers.each do |answer|
+        next unless answer.feedback && answer.feedback.strip.length > 0
+        processing_node.respcondition(:continue => 'Yes') do |condition_node|
+          condition_node.conditionvar do |var_node|
+            var_node.varequal answer.answer_text, :respident => 'response1'
+          end
+          condition_node.displayfeedback(:feedbacktype => 'Response', :linkrefid => "#{answer.id}_fb")
+        end
+      end
+
+      # Conditions
+      question.answers.each do |answer|
+        processing_node.respcondition(:continue => 'No') do |condition_node|
+          condition_node.conditionvar do |var_node|
+            var_node.varequal answer.answer_text, :respident => 'response1'
+          end
+          condition_node.setvar(convert_fraction_to_score(answer.fraction), :varname => 'SCORE', :action => "Set")
+        end
+      end
+    end
+
+    def self.write_additional_nodes(item_node, question)
+      write_standard_answer_feedbacks(item_node, question)
+    end
+  end
+end

data/lib/canvas_cc/canvas_cc/text_only_question_writer.rb

@@ -0,0 +1,19 @@
+module CanvasCc::CanvasCC
+  class TextOnlyQuestionWriter < QuestionWriter
+
+    register_writer_type 'text_only_question'
+
+    private
+
+    def self.write_question_item_xml(node, question)
+      node.item(:title => question.title, :ident => question.identifier) do |item_node|
+        write_qti_metadata(item_node, question)
+        item_node.presentation do |presentation_node|
+          presentation_node.material do |material_node|
+            material_node.mattext(question.material, :texttype => 'text/html')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/canvas_cc/canvas_cc/true_false_question_writer.rb

@@ -0,0 +1,38 @@
+module CanvasCc::CanvasCC
+  class TrueFalseQuestionWriter < QuestionWriter
+
+    register_writer_type 'true_false_question'
+
+    private
+
+    def self.write_responses(presentation_node, question)
+      presentation_node.response_lid(:rcardinality => 'Single', :ident => 'response1') do |response_node|
+        response_node.render_choice do |render_choice_node|
+          question.answers.each do |answer|
+            render_choice_node.response_label(:ident => answer.id) do |response_label_node|
+              response_label_node.material do |material_node|
+                material_node.mattext(answer.answer_text, :texttype => 'text/html')
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def self.write_response_conditions(processing_node, question)
+      question.answers.each do |answer|
+        processing_node.respcondition(:continue => 'No') do |condition_node|
+          condition_node.conditionvar do |var_node|
+            var_node.varequal answer.id, :respident => 'response1'
+          end
+          condition_node.displayfeedback(:feedbacktype => 'Response', :linkrefid => "#{answer.id}_fb") if answer.feedback && answer.feedback.strip.length > 0
+          condition_node.setvar(convert_fraction_to_score(answer.fraction), :varname => 'SCORE', :action => "Set")
+        end
+      end
+    end
+
+    def self.write_additional_nodes(item_node, question)
+      write_standard_answer_feedbacks(item_node, question)
+    end
+  end
+end

data/lib/canvas_cc/cc/assessment.rb

@@ -0,0 +1,25 @@
+module CanvasCc::CC
+  class Assessment
+    include CCHelper
+    include Resource
+
+    def initialize(mod, position=0)
+      super
+    end
+
+    def create_resource_node(resources_node)
+      resources_node.resource(
+        :identifier => identifier,
+        :type => ASSESSMENT_TYPE
+      ) do |resource_node|
+        create_resource_sub_nodes(resource_node)
+      end
+    end
+
+    def create_resource_sub_nodes(resource_node)
+    end
+
+    def create_files(export_dir)
+    end
+  end
+end

data/lib/canvas_cc/cc/assignment.rb

@@ -0,0 +1,61 @@
+module CanvasCc::CC
+  class Assignment
+    include CCHelper
+    include Resource
+
+    attr_accessor :body, :meta_fields
+
+    def initialize(mod, position=0)
+      super
+      @body = convert_file_path_tokens(mod.description)
+      @meta_fields = build_meta_fields(mod)
+      @rel_path = File.join(CC_ASSIGNMENT_FOLDER, "#{file_slug(@title)}.html")
+      @resource_type = nil
+    end
+    
+    # Common Cartridge doesn't have anywhere to put assignment meta data like this
+    # So add them as HTML meta fields in the HTML file
+    def build_meta_fields(mod)
+      fields = {}
+      %w{mod_type assignment_type}.each do |key|
+        fields[key] = mod.send(key) if mod.respond_to?(key)
+      end
+      if mod.grade_item
+        CanvasCc::Moodle::GradeItem::PROPERTIES.each do |key|
+          fields[key] = mod.grade_item.send(key) if mod.grade_item.respond_to?(key)
+        end
+      end
+      
+      fields
+    end
+
+    def create_resource_node(resources_node)
+      resources_node.resource(
+        :href => @rel_path,
+        :type => @resource_type || WEBCONTENT,
+        :identifier => identifier
+      ) do |resource_node|
+        resource_node.file(:href => @rel_path)
+        create_resource_sub_nodes(resource_node)
+        # todo if CC 1.2 add assignment meta tag
+      end
+    end
+
+    def create_resource_sub_nodes(resource_node)
+    end
+
+    def create_files(export_dir)
+      create_html(export_dir)
+    end
+
+    def create_html(export_dir)
+      template = File.expand_path('../templates/assignment.html.erb', __FILE__)
+      path = File.join(export_dir, @rel_path)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.open(path, 'w') do |file|
+        erb = ERB.new(File.read(template))
+        file.write(erb.result(binding))
+      end
+    end
+  end
+end