moodle2cc 0.1.12 → 0.2.0

data/lib/moodle2cc/moodle2/parsers/glossary_parser.rb

@@ -0,0 +1,78 @@
+module Moodle2CC::Moodle2::Parsers
+  class GlossaryParser
+    include ParserHelper
+
+    GLOSSARY_XML = 'glossary.xml'
+    GLOSSARY_MODULE_NAME = 'glossary'
+
+    def initialize(backup_dir)
+      @backup_dir = backup_dir
+    end
+
+    def parse
+      activity_dirs = activity_directories(@backup_dir, GLOSSARY_MODULE_NAME)
+      activity_dirs.map { |dir| parse_glossary(dir) }
+    end
+
+    private
+
+    def parse_glossary(dir)
+      glossary = Moodle2CC::Moodle2::Models::Glossary.new
+      activity_dir = File.join(@backup_dir, dir)
+      File.open(File.join(activity_dir, GLOSSARY_XML)) do |f|
+        glossary_xml = Nokogiri::XML(f)
+        glossary.id = glossary_xml.at_xpath('/activity/glossary/@id').value
+        glossary.module_id = glossary_xml.at_xpath('/activity/@moduleid').value
+        glossary.name = parse_text(glossary_xml, '/activity/glossary/name')
+        glossary.intro = parse_text(glossary_xml, '/activity/glossary/intro')
+        glossary.intro_format = parse_text(glossary_xml, '/activity/glossary/introformat')
+        glossary.allow_duplicated_entries = parse_text(glossary_xml, '/activity/glossary/allowduplicatedentries')
+        glossary.display_format = parse_text(glossary_xml, '/activity/glossary/displayformat')
+        glossary.main_glossary = parse_text(glossary_xml, '/activity/glossary/mainglossary')
+        glossary.show_special = parse_text(glossary_xml, '/activity/glossary/showspecial')
+        glossary.show_alphabet = parse_text(glossary_xml, '/activity/glossary/showalphabet')
+        glossary.show_all = parse_text(glossary_xml, '/activity/glossary/showall')
+        glossary.allow_comments = parse_text(glossary_xml, '/activity/glossary/allowcomments')
+        glossary.allow_printview = parse_text(glossary_xml, '/activity/glossary/allowprintview')
+        glossary.use_dynalink = parse_text(glossary_xml, '/activity/glossary/usedynalink')
+        glossary.default_approval = parse_text(glossary_xml, '/activity/glossary/defaultapproval')
+        glossary.global_glossary = parse_text(glossary_xml, '/activity/glossary/globalglossary')
+        glossary.ent_by_page = parse_text(glossary_xml, '/activity/glossary/entbypage')
+        glossary.edit_always = parse_text(glossary_xml, '/activity/glossary/editalways')
+        glossary.rss_type = parse_text(glossary_xml, '/activity/glossary/rsstype')
+        glossary.rss_articles = parse_text(glossary_xml, '/activity/glossary/rssarticles')
+        glossary.assessed = parse_text(glossary_xml, '/activity/glossary/assessed')
+        glossary.assess_time_start = parse_text(glossary_xml, '/activity/glossary/assesstimestart')
+        glossary.assess_time_finish = parse_text(glossary_xml, '/activity/glossary/assesstimefinish')
+        glossary.scale = parse_text(glossary_xml, '/activity/glossary/scale')
+        glossary.completion_entries = parse_text(glossary_xml, '/activity/glossary/completionentries')
+        glossary.entries += parse_glossary_entry(glossary_xml.search('/activity/glossary/entries/entry'))
+      end
+      parse_module(activity_dir, glossary)
+
+      glossary
+    end
+
+    def parse_glossary_entry(entry_nodes)
+      entry_nodes.map do |node|
+        entry = Moodle2CC::Moodle2::Models::GlossaryEntry.new
+        entry.id = node.at_xpath('@id').value
+        entry.user_id = parse_text(node, 'userid')
+        entry.concept = parse_text(node, 'concept')
+        entry.definition = parse_text(node, 'definition')
+        entry.definition_format = parse_text(node, 'definitionformat')
+        entry.definition_trust = parse_text(node, 'definitiontrust')
+        entry.attachment = parse_text(node, 'attachment')
+        entry.teacher_entry = parse_text(node, 'teacherentry')
+        entry.source_glossary_id = parse_text(node, 'sourceglossaryid')
+        entry.use_dynalink = parse_text(node, 'usedynalink')
+        entry.case_sensitive = parse_text(node, 'casesensitive')
+        entry.full_match = parse_text(node, 'fullmatch')
+        entry.approved = parse_text(node, 'approved')
+
+        entry
+      end
+    end
+
+  end
+end

data/lib/moodle2cc/moodle2/parsers/label_parser.rb

@@ -0,0 +1,36 @@
+module Moodle2CC::Moodle2
+  class Parsers::LabelParser
+    include Parsers::ParserHelper
+
+    LABEL_XML = 'label.xml'
+    LABEL_MODULE_NAME = 'label'
+
+    def initialize(backup_dir)
+      @backup_dir = backup_dir
+    end
+
+    def parse
+      activity_dirs = activity_directories(@backup_dir, LABEL_MODULE_NAME)
+      activity_dirs.map { |dir| parse_label(dir) }
+    end
+
+    private
+
+    def parse_label(dir)
+      label = Models::Label.new
+      activity_dir = File.join(@backup_dir, dir)
+      File.open(File.join(activity_dir, LABEL_XML)) do |f|
+        label_xml = Nokogiri::XML(f)
+        label.id = label_xml.at_xpath('/activity/label/@id').value
+        label.module_id = label_xml.at_xpath('/activity/@moduleid').value
+        label.name = parse_text(label_xml, '/activity/label/name')
+        label.intro = parse_text(label_xml, '/activity/label/intro')
+        label.intro_format = parse_text(label_xml, '/activity/label/introformat')
+      end
+      parse_module(activity_dir, label)
+      label
+    end
+
+
+  end
+end

data/lib/moodle2cc/moodle2/parsers/page_parser.rb

@@ -0,0 +1,45 @@
+module Moodle2CC::Moodle2::Parsers
+  class PageParser
+    include ParserHelper
+
+    PAGE_XML = 'page.xml'
+    PAGE_MODULE_NAME = 'page'
+
+    def initialize(backup_dir)
+      @backup_dir = backup_dir
+    end
+
+    def parse
+      activity_dirs = activity_directories(@backup_dir, PAGE_MODULE_NAME)
+      activity_dirs.map { |dir| parse_page(dir) }
+    end
+
+    private
+
+    def parse_page(dir)
+      page = Moodle2CC::Moodle2::Models::Page.new
+      activity_dir = File.join(@backup_dir, dir)
+      File.open(File.join(activity_dir, PAGE_XML)) do |f|
+        page_xml = Nokogiri::XML(f)
+        page.id = page_xml.at_xpath('/activity/page/@id').value
+        page.module_id = page_xml.at_xpath('/activity/@moduleid').value
+        page.name = parse_text(page_xml, '/activity/page/name')
+        page.intro = parse_text(page_xml, '/activity/page/intro')
+        page.intro_format = parse_text(page_xml, '/activity/page/introformat')
+        page.content = parse_text(page_xml, '/activity/page/content')
+        page.content_format = parse_text(page_xml, '/activity/page/contentformat')
+        page.legacy_files = parse_text(page_xml, '/activity/page/legacyfiles')
+        page.legacy_files_last = parse_text(page_xml, '/activity/page/legacyfileslast')
+        page.display = parse_text(page_xml, '/activity/page/display')
+        page.display_options = parse_text(page_xml, '/activity/page/displayoptions')
+        page.revision = parse_text(page_xml, '/activity/page/revision')
+        page.time_modified = parse_text(page_xml, '/activity/page/timemodified')
+      end
+      parse_module(activity_dir, page)
+
+      page
+    end
+
+  end
+
+end

data/lib/moodle2cc/moodle2/parsers/parser_helper.rb

@@ -0,0 +1,37 @@
+module Moodle2CC::Moodle2::Parsers
+  module ParserHelper
+
+    FILES_XML = 'inforef.xml'
+    XML_NULL_VALUE = '$@NULL@$'
+    MODULE_XML = 'module.xml'
+
+    def activity_directories(work_dir, activity_types)
+      File.open(File.join(work_dir, Moodle2CC::Moodle2::Extractor::MOODLE_BACKUP_XML)) do |f|
+        moodle_backup_xml = Nokogiri::XML(f)
+        activities = moodle_backup_xml./('/moodle_backup/information/contents/activities').xpath("activity[modulename = '#{activity_types}']")
+        activities.map { |forum| forum./('directory').text }
+      end
+    end
+
+    def parse_text(node, xpath, use_xpath=false)
+      if v_node = (use_xpath && node.at_xpath(xpath)) || (!use_xpath && node.%(xpath))
+        value = v_node.text
+        value unless value == XML_NULL_VALUE
+      end
+    end
+
+    def parse_boolean(node, xpath)
+      value = parse_text(node, xpath)
+      value && (value == '1' || value.downcase == 'true') ? true : false
+    end
+
+    def parse_module(activity_dir, activity)
+      File.open(File.join(activity_dir, MODULE_XML)) do |f|
+        xml = Nokogiri::XML(f)
+        activity.visible = parse_boolean(xml, '/module/visible')
+      end
+      activity
+    end
+
+  end
+end

data/lib/moodle2cc/moodle2/parsers/question_category_parser.rb

@@ -0,0 +1,47 @@
+module Moodle2CC::Moodle2
+  class Parsers::QuestionCategoryParser
+    include Parsers::ParserHelper
+
+    QUESTIONS_XML = 'questions.xml'
+
+    def initialize(backup_dir)
+      @backup_dir = backup_dir
+    end
+
+    def parse
+      File.open(File.join(@backup_dir, QUESTIONS_XML)) do |f|
+        root_xml = Nokogiri::XML(f)
+        root_xml.search('/question_categories/question_category').map { |node| question_category_parser(node) }
+      end
+    end
+
+    private
+
+    def question_category_parser(node)
+      category = Models::Quizzes::QuestionCategory.new
+      category.id = node.at_xpath('@id').value
+      category.name = parse_text(node, 'name')
+      category.context_id = parse_text(node, 'contextid')
+      category.context_level = parse_text(node, 'contextlevel')
+      category.context_instance_id = parse_text(node, 'contextinstanceid')
+      category.info = parse_text(node, 'info')
+      category.info_format = parse_text(node, 'infoformat')
+      category.stamp = parse_text(node, 'stamp')
+      category.parent = parse_text(node, 'parent')
+      category.sort_order = parse_text(node, 'sortorder')
+
+      category.questions += node.search('questions/question').map { |question_node| question_parser(question_node) }.compact
+
+      category
+    end
+
+    def question_parser(node)
+      begin
+        Parsers::QuestionParsers::QuestionParser.parse(node)
+      rescue Exception => e
+        puts e.message
+      end
+    end
+
+  end
+end

data/lib/moodle2cc/moodle2/parsers/question_parsers.rb

@@ -0,0 +1,13 @@
+module Moodle2CC::Moodle2::Parsers
+  module QuestionParsers
+    require_relative 'question_parsers/question_parser'
+    require_relative 'question_parsers/calculated_parser'
+    require_relative 'question_parsers/match_parser'
+    require_relative 'question_parsers/multianswer_parser'
+    require_relative 'question_parsers/multichoice_parser'
+    require_relative 'question_parsers/numerical_parser'
+    require_relative 'question_parsers/random_sa_parser'
+    require_relative 'question_parsers/short_answer_parser'
+    require_relative 'question_parsers/true_false_parser'
+  end
+end

data/lib/moodle2cc/moodle2/parsers/question_parsers/calculated_parser.rb

@@ -0,0 +1,43 @@
+module Moodle2CC::Moodle2
+  class Parsers::QuestionParsers::CalculatedParser < Parsers::QuestionParsers::QuestionParser
+    include Parsers::ParserHelper
+    register_parser_type('calculated')
+    register_parser_type('calculatedmulti')
+    register_parser_type('calculatedsimple')
+
+    def parse_question(node)
+      question = super(node, 'calculated')
+
+      q_node = node.at_xpath("plugin_qtype_#{question.qtype}_question")
+
+      answer_parser = Parsers::AnswerParser.new
+      question.answers += q_node.search('answers/answer').map { |n| answer_parser.parse(n) }
+
+      if question.answers.count > 1 && question.qtype == 'calculatedmulti'
+        # turn multiple choice calculated questions into standard formula questions,
+        # by ignoring the incorrect formulas
+        if correct_formula = question.answers.detect{|a| a.fraction == 1}
+          question.answers = [correct_formula]
+        end
+      end
+
+      q_node.search('dataset_definitions/dataset_definition').each do |ds_node|
+        question.dataset_definitions << {
+            :name => parse_text(ds_node, 'name'),
+            :options => parse_text(ds_node, 'options')
+        }
+      end
+
+      q_node.search('calculated_records/calculated_record').each do |cr_node|
+        next unless parse_text(cr_node, 'answer') == question.answers.first.id.to_s
+
+        question.correct_answer_format = parse_text(cr_node, 'correctanswerformat')
+        question.correct_answer_length = parse_text(cr_node, 'correctanswerlength')
+        question.tolerance = parse_text(cr_node, 'tolerance')
+      end
+
+      question
+    end
+
+  end
+end

data/lib/moodle2cc/moodle2/parsers/question_parsers/match_parser.rb

@@ -0,0 +1,24 @@
+module Moodle2CC::Moodle2
+  class Parsers::QuestionParsers::MatchParser < Parsers::QuestionParsers::QuestionParser
+    include Parsers::ParserHelper
+    register_parser_type('match')
+
+    def parse_question(node)
+      question = super
+
+      q_node = node.at_xpath("plugin_qtype_#{question.qtype}_question")
+
+      q_node.search('matches/match').each do |m_node|
+        question.matches << {
+          :id => m_node.attributes['id'].value,
+          :question_text => parse_text(m_node, 'questiontext'),
+          :question_text_format => parse_text(m_node, 'questiontextformat'),
+          :answer_text => parse_text(m_node, 'answertext')
+        }
+      end
+
+      question
+    end
+
+  end
+end

data/lib/moodle2cc/moodle2/parsers/question_parsers/multianswer_parser.rb

@@ -0,0 +1,21 @@
+module Moodle2CC::Moodle2
+  class Parsers::QuestionParsers::MultianswerParser < Parsers::QuestionParsers::QuestionParser
+    include Parsers::ParserHelper
+    register_parser_type('multianswer')
+
+    def parse_question(node)
+      question = super
+
+      answer_parser = Parsers::AnswerParser.new
+      question.answers += node.search('answers/answer').map { |n| answer_parser.parse(n) }
+
+
+      if sequence = node.at_xpath('plugin_qtype_multianswer_question/multianswer/sequence')
+        question.embedded_question_references = sequence.text.split(',')
+      end
+
+      question
+    end
+
+  end
+end

data/lib/moodle2cc/moodle2/parsers/question_parsers/multichoice_parser.rb

@@ -0,0 +1,16 @@
+module Moodle2CC::Moodle2
+  class Parsers::QuestionParsers::MultichoiceParser < Parsers::QuestionParsers::QuestionParser
+    include Parsers::ParserHelper
+    register_parser_type('multichoice')
+
+    def parse_question(node)
+      question = super
+
+      answer_parser = Parsers::AnswerParser.new
+      question.answers += node.search('answers/answer').map { |n| answer_parser.parse(n) }
+
+      question
+    end
+
+  end
+end

data/lib/moodle2cc/moodle2/parsers/question_parsers/numerical_parser.rb

@@ -0,0 +1,24 @@
+module Moodle2CC::Moodle2
+  class Parsers::QuestionParsers::NumericalParser < Parsers::QuestionParsers::QuestionParser
+    include Parsers::ParserHelper
+    register_parser_type('numerical')
+
+    def parse_question(node)
+      question = super
+
+      q_node = node.at_xpath("plugin_qtype_#{question.qtype}_question")
+
+      answer_parser = Parsers::AnswerParser.new
+      question.answers += q_node.search('answers/answer').map { |n| answer_parser.parse(n) }
+
+      q_node.search('numerical_records/numerical_record').each do |nr_node|
+        answer_id = parse_text(nr_node, 'answer')
+        tolerance = parse_text(nr_node, 'tolerance')
+        question.tolerances[answer_id] = tolerance
+      end
+
+      question
+    end
+
+  end
+end

data/lib/moodle2cc/moodle2/parsers/question_parsers/question_parser.rb

@@ -0,0 +1,51 @@
+module Moodle2CC::Moodle2
+  class Parsers::QuestionParsers::QuestionParser
+    include Parsers::ParserHelper
+
+    @@subclasses = {}
+
+    def self.parse(node)
+      type = node.%('qtype').text
+      if c = @@subclasses[type]
+        c.new.parse_question(node)
+      else
+        raise "Unknown parser type: #{type}"
+      end
+    end
+
+    def self.register_parser_type(name)
+      @@subclasses[name] = self
+    end
+
+    # simple question types
+    register_parser_type('description')
+    register_parser_type('essay')
+
+    def parse_question(node, question_type = nil)
+      begin
+        question_type ||= parse_text(node, 'qtype')
+        question = Models::Quizzes::Question.create question_type
+
+        question.id = node.at_xpath('@id').value
+        question.parent = parse_text(node, 'parent')
+        question.name = parse_text(node, 'name')
+        question.question_text = parse_text(node, 'questiontext')
+        question.question_text_format = parse_text(node, 'questiontextformat')
+        question.general_feedback = parse_text(node, 'generalfeedback')
+        question.default_mark = parse_text(node, 'defaultmark')
+        question.penalty = parse_text(node, 'penalty')
+        question.qtype = parse_text(node, 'qtype')
+        question.length = parse_text(node, 'length')
+        question.stamp = parse_text(node, 'stamp')
+        question.version = parse_text(node, 'version')
+        question.hidden = parse_boolean(node, 'hidden')
+
+        question
+      rescue Exception => e
+        puts e.message
+      end
+    end
+
+
+  end
+end