ams_migration 0.1.3

data/lib/ams_migration/canvas/converter/classic_quiz/multiple_dropdown.rb

@@ -0,0 +1,126 @@
+# Copyright (C) 2025 - present Instructure, Inc.
+# This code is made publicly available for educational and reference purposes only.
+# You may not copy, modify, redistribute, or use this code in any software or service without explicit permission.
+
+module AmsMigration
+  module Canvas
+    module Converter
+      module ClassicQuiz
+        class MultipleDropdown < ClassicQuestion
+          def correct_answer
+            valid_values = {}
+            alternate_values = {}
+            possible_values = {}
+            ordered_templates = []
+            stimulus.scan(/\[.*?\]/).each_with_index do |template, _index|
+              template = template.delete("[").delete("]")
+              ordered_templates << template
+              @question[:answers].select { |answer| answer[:blank_id] == template }.each_with_index do |answer, index|
+                if answer[:text] && answer[:blank_id]
+                  if possible_values[answer[:blank_id]]
+                    possible_values[answer[:blank_id]] << answer[:text]
+                  else
+                    possible_values[answer[:blank_id]] = [answer[:text]]
+                  end
+                end
+                if index.zero? && answer[:text] && answer[:blank_id]
+                  if valid_values[answer[:blank_id]]
+                    valid_values[answer[:blank_id]] << answer[:text]
+                  else
+                    valid_values[answer[:blank_id]] = [answer[:text]]
+                  end
+                elsif answer[:text] && answer[:blank_id]
+                  if alternate_values[answer[:blank_id]]
+                    alternate_values[answer[:blank_id]] << answer[:text]
+                  else
+                    alternate_values[answer[:blank_id]] = [answer[:text]]
+                  end
+                end
+              end
+            end
+
+            valid_values.values.map(&:size).max
+
+            correct_values = ordered_templates.map do |template|
+              valid_values[template].first
+            end
+
+            valid_response = {
+              score: point_value,
+              value: correct_values
+            }
+
+            alternate_responses = []
+            max_answers = alternate_values.values.map(&:size).max
+            (0..(max_answers - 1)).each do |i|
+              alternate_response = ordered_templates.filter_map do |template|
+                alternate_values&.dig(template, i)
+              end
+              alternate_responses << {
+                score: 1,
+                value: alternate_response
+              }
+            end
+
+            possible_responses = ordered_templates.map do |template|
+              possible_values[template]
+            end
+            {
+              valid_response:,
+              alternate_responses:,
+              possible_responses:
+            }
+          end
+
+          def distractors
+            results = []
+            has_distractors = false
+            @question[:answers].each do |answer|
+              distractor = answer[:comments_html] ||= ""
+              results << distractor
+              has_distractors = true if distractor != ""
+            end
+            has_distractors ? results : nil
+          end
+
+          def convert
+            super
+            begin
+              correct_values = correct_answer
+
+              @converted_question = {
+                template: stimulus.gsub("[", "{{response}}").delete("]").to_s,
+                type: "clozedropdown",
+                possible_responses: correct_values[:possible_responses],
+                validation: {
+                  valid_response: correct_values[:valid_response],
+                  scoring_type: "exactMatch",
+                  match_all_possible_responses: true
+                },
+                is_math: true,
+                response_container: {
+                  pointer: "left"
+                }
+              }
+
+              if correct_values[:alternate_responses].size.positive?
+                @converted_question[:validation][:alt_responses] = correct_values[:alternate_responses]
+              end
+
+              @converted_question[:metadata] = {
+                distractor_rationale_response_level: distractors
+              }
+            rescue => e
+              @conversion_errors << e.message
+            end
+            post_convert
+            {
+              question: @converted_question,
+              errors: @conversion_errors
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ams_migration/canvas/converter/classic_quiz/numerical.rb

@@ -0,0 +1,89 @@
+# Copyright (C) 2025 - present Instructure, Inc.
+# This code is made publicly available for educational and reference purposes only.
+# You may not copy, modify, redistribute, or use this code in any software or service without explicit permission.
+
+module AmsMigration
+  module Canvas
+    module Converter
+      module ClassicQuiz
+        class Numerical < ClassicQuestion
+          def correct_values
+            values = []
+            @question[:answers].map do |answer|
+              case answer[:numerical_answer_type]
+              when "exact_answer"
+                values << if answer[:margin].zero?
+                            {
+                              method: "equivLiteral",
+                              value: answer[:exact].to_s,
+                              options: {
+                                ignoreOrder: false,
+                                inverseResult: false
+                              }
+                            }
+                          else
+                            {
+                              method: "equivValue",
+                              value: "#{answer[:exact]}\\pm#{answer[:margin]}"
+                            }
+                          end
+              when "range_answer"
+                @notifications << 'Numeric items with "Answer in Range" may need additional configuration'
+                if answer[:end] && answer[:start]
+                  values << {
+                    method: "equivValue",
+                    value: "#{answer[:end] - answer[:start]}\\pm#{(answer[:end] - answer[:start]) / 2}",
+                    options: {
+                      ignoreOrder: false,
+                      inverseResult: false
+                    }
+                  }
+                end
+              when "precision_answer"
+                @notifications << 'Numeric items with "Answer with Precision" may need additional configuration'
+                values << {
+                  method: "equivValue",
+                  value: answer[:approximate].to_s,
+                  options: {
+                    decimalPlaces: answer[:precision]
+                  }
+                }
+              end
+            end
+            values
+          end
+
+          def convert
+            super
+            begin
+              @converted_question = {
+                stimulus:,
+                template: "{{response}}",
+                response_container: {
+                  template: ""
+                },
+                type: "clozeformula",
+                validation: {
+                  scoring_type: "exactMatch",
+                  valid_response: {
+                    score: point_value,
+                    value: [correct_values]
+                  }
+                },
+                is_math: true,
+                response_containers: []
+              }
+            rescue => e
+              @conversion_errors << e.message
+            end
+            post_convert
+            {
+              question: @converted_question,
+              errors: @conversion_errors
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ams_migration/canvas/converter/classic_quiz/text.rb

@@ -0,0 +1,28 @@
+# Copyright (C) 2025 - present Instructure, Inc.
+# This code is made publicly available for educational and reference purposes only.
+# You may not copy, modify, redistribute, or use this code in any software or service without explicit permission.
+
+module AmsMigration
+  module Canvas
+    module Converter
+      module ClassicQuiz
+        class Text < ClassicQuestion
+          # This question type only returns the stimulus as the question text
+          def convert
+            super
+            begin
+              @converted_question = stimulus
+            rescue => e
+              @conversion_errors << e.message
+            end
+            post_convert
+            {
+              question: @converted_question,
+              errors: @conversion_errors
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ams_migration/canvas/converter/classic_quiz/true_false.rb

@@ -0,0 +1,14 @@
+# Copyright (C) 2025 - present Instructure, Inc.
+# This code is made publicly available for educational and reference purposes only.
+# You may not copy, modify, redistribute, or use this code in any software or service without explicit permission.
+
+module AmsMigration
+  module Canvas
+    module Converter
+      module ClassicQuiz
+        class TrueFalse < MultipleChoice
+        end
+      end
+    end
+  end
+end

data/lib/ams_migration/canvas/converter/classic_quiz/unknown.rb

@@ -0,0 +1,31 @@
+# Copyright (C) 2025 - present Instructure, Inc.
+# This code is made publicly available for educational and reference purposes only.
+# You may not copy, modify, redistribute, or use this code in any software or service without explicit permission.
+
+module AmsMigration
+  module Canvas
+    module Converter
+      module ClassicQuiz
+        # Implementation for when Canvas QuizItem question_type is unknown.
+        # Allows the Quiz conversion to continue uninterrupted. See MCE-23091.
+        class Unknown < ClassicQuestion
+          # This question type will be skipped in the conversion process and the
+          # question will not be included in the quiz.
+          def convert
+            begin
+              @question = JSON.parse(@question_json).deep_symbolize_keys
+              @conversion_errors << "Unknown question type: #{@question[:question_type]}"
+            rescue JSON::ParserError => e
+              @question = ""
+              @conversion_errors << e.message
+            end
+            {
+              question: "",
+              errors: @conversion_errors
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ams_migration/canvas/converter/new_quiz/categorization.rb

@@ -0,0 +1,108 @@
+# Copyright (C) 2025 - present Instructure, Inc.
+# This code is made publicly available for educational and reference purposes only.
+# You may not copy, modify, redistribute, or use this code in any software or service without explicit permission.
+
+module AmsMigration
+  module Canvas
+    module Converter
+      module NewQuiz
+        # This class converts 'Categorization' questions from Canvas New Quizzes to the
+        # MasteryConnect 'Classification' question type.
+        class Categorization < NewQuestion
+          def initialize(question)
+            super
+            @distractor_lookup = []
+            @category_lookup = []
+          end
+
+          def convert
+            super
+            begin
+              @converted_question = converted_question
+            rescue => e
+              @conversion_errors << e.message
+            end
+            post_convert
+            format
+          end
+
+          def converted_question
+            @distractor_lookup = build_lookup(@question[:entry][:interaction_data][:distractors])
+            @category_lookup = build_lookup(@question[:entry][:interaction_data][:categories])
+            {
+              possible_responses:,
+              stimulus:,
+              type: "classification",
+              ui_style:,
+              validation:
+            }
+          end
+
+          def possible_responses
+            @distractor_lookup.map do |distractor|
+              distractor[:item_body]
+            end
+          end
+
+          def stimulus
+            @question[:entry][:item_body]
+          end
+
+          def ui_style
+            {
+              column_count:,
+              column_titles:
+            }
+          end
+
+          def column_count
+            @question[:entry][:interaction_data][:categories].length
+          end
+
+          def column_titles
+            @question[:entry][:interaction_data][:category_order].map do |id|
+              find_element(@category_lookup, id)[:item_body]
+            end
+          end
+
+          def validation
+            {
+              scoring_type: "exactMatch",
+              valid_response: {
+                score:,
+                value:
+              }
+            }
+          end
+
+          def score
+            @question[:points_possible].round
+          end
+
+          def value
+            @question[:entry][:interaction_data][:category_order].map do |category|
+              category = find_element(@question[:entry][:scoring_data][:value], category)
+              category[:scoring_data][:value].map do |value|
+                find_element(@distractor_lookup, value)[:index]
+              end
+            end
+          end
+
+          def build_lookup(json_data)
+            json_data.map.with_index do |(id, item), index|
+              {
+                id:,
+                item_body: item[:item_body],
+                index:
+              }
+            end
+          end
+
+          def find_element(collection, id)
+            collection.find { |item| item[:id].to_s == id }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ams_migration/canvas/converter/new_quiz/essay.rb

@@ -0,0 +1,78 @@
+# Copyright (C) 2025 - present Instructure, Inc.
+# This code is made publicly available for educational and reference purposes only.
+# You may not copy, modify, redistribute, or use this code in any software or service without explicit permission.
+
+module AmsMigration
+  module Canvas
+    module Converter
+      module NewQuiz
+        class Essay < NewQuestion
+          def to_h
+            @question
+          end
+
+          def spellcheck
+            @question.dig(:entry, :interaction_data, :spell_check)
+          end
+
+          def type
+            @question.dig(:entry, :interaction_data, :rce) ? "longtextV2" : "plaintext"
+          end
+
+          def rubric
+            @question.dig(:entry, :scoring_data, :value)
+          end
+
+          def rubric_points
+            @question[:points_possible]
+          end
+
+          def show_word_limit
+            @question.dig(:entry, :interaction_data, :word_limit_enabled)
+          end
+
+          def show_word_count
+            @question.dig(:entry, :interaction_data, :word_count)
+          end
+
+          def max_length
+            if @question.dig(:entry,
+                             :interaction_data,
+                             :word_limit_enabled)
+              @question.dig(:entry, :interaction_data, :word_limit_max).to_i
+            end
+          end
+
+          def convert
+            super
+            begin
+              @converted_question = {
+                stimulus:,
+                spellcheck:,
+                type:,
+                metadata: {
+                  rubric:,
+                  rubric_points:
+                },
+                max_length:,
+                show_word_count:
+              }
+
+              if type == "plaintext"
+                @converted_question[:show_copy] = true
+                @converted_question[:show_cut] = true
+                @converted_question[:show_paste] = true
+              end
+
+              @converted_question[:show_word_limit] = "off" unless show_word_limit
+            rescue => e
+              @conversion_errors << e.message
+            end
+            post_convert
+            format
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ams_migration/canvas/converter/new_quiz/file_upload.rb

@@ -0,0 +1,33 @@
+# Copyright (C) 2025 - present Instructure, Inc.
+# This code is made publicly available for educational and reference purposes only.
+# You may not copy, modify, redistribute, or use this code in any software or service without explicit permission.
+
+module AmsMigration
+  module Canvas
+    module Converter
+      module NewQuiz
+        class FileUpload < NewQuestion
+          # This question type will be skipped in the conversion process and the
+          # question will not be included in the quiz.  The JSON returned will be
+          # an essay question with text noting the question has been skipped.
+          def convert
+            super
+            @converted_question = {
+              stimulus: "The File upload item was removed from the quiz because there is no equivalent item type in Mastery Connect.  Please check the original quiz for this question.",
+              type: QuestionType::UNSUPPORTED_CANVAS_TYPE,
+              validation: {
+                valid_response: {
+                  score: 0,
+                  value: ""
+                },
+                scoring_type: "exactMatch"
+              },
+              is_math: true
+            }
+            format
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ams_migration/canvas/converter/new_quiz/fill_in_blank.rb

@@ -0,0 +1,180 @@
+# Copyright (C) 2025 - present Instructure, Inc.
+# This code is made publicly available for educational and reference purposes only.
+# You may not copy, modify, redistribute, or use this code in any software or service without explicit permission.
+
+module AmsMigration
+  module Canvas
+    module Converter
+      module NewQuiz
+        # This class converts 'Fill in the Blank' questions from Canvas New Quizzes to a MasteryConnect
+        # compatible question type. Mixed answer types are not supported, failing the conversion.
+        class FillInBlank < NewQuestion
+          def initialize(question)
+            super
+            @include_possible_responses = false
+            @answer_type = ""
+            @is_mixed_question_type = false
+          end
+
+          def convert
+            super
+            begin
+              @converted_question = converted_question
+            rescue => e
+              @conversion_errors << e.message
+            end
+            post_convert
+            format
+          end
+
+          def converted_question
+            determine_answer_type
+            {
+              stimulus: question_title,
+              template: convert_item_body,
+              type: @answer_type,
+              validation:,
+              possible_responses: (possible_responses if @include_possible_responses)
+            }.compact
+          end
+
+          def question_title
+            @question[:entry][:title]
+          end
+
+          def convert_item_body
+            html = Nokogiri::HTML::DocumentFragment.parse(@question[:entry][:item_body])
+
+            # Remove all HTML tags except the <span> elements with 'blank...' IDs
+            html.css('span[id^="blank_"]').each do |span|
+              span.replace("{{response}}")
+            end
+
+            html.to_xhtml(indent: 0)
+          end
+
+          def validation
+            all_responses = response_list
+            {
+              scoring_type: "exactMatch",
+              valid_response: all_responses.shift,
+              alt_responses: (all_responses unless all_responses.empty?),
+              match_all_possible_responses: (true unless all_responses.empty?)
+            }.compact
+          end
+
+          def response_list
+            response_list = Array.new(response_length) { { score: point_value, value: [] } }
+
+            # Iterate through question's value array and populate response_list
+            @question[:entry][:scoring_data][:value].each do |blank|
+              (0..(response_length - 1)).each do |i|
+                if !@is_mixed_question_type && @answer_type == "clozetext"
+                  validate_scoring_algorithm(blank[:scoring_algorithm])
+                end
+                # Retrieve value at current index if it exists
+                if blank[:scoring_data][:value].is_a?(Array)
+                  response_list[i][:value].append(val_from_array(i, blank))
+                else
+                  response_list[i][:value].append(blank[:scoring_data][:blank_text])
+                end
+              end
+            end
+
+            response_list
+          end
+
+          def validate_scoring_algorithm(scoring_algorithm)
+            valid_algorithms = %w[TextEquivalence TextInChoices]
+            return if valid_algorithms.include?(scoring_algorithm)
+
+            @notifications << "Fill in the blank question with text match option #{map_scoring_algorithm(scoring_algorithm)} has been converted to exact match"
+          end
+
+          def map_scoring_algorithm(scoring_algorithm)
+            case scoring_algorithm
+            when "TextContainsAnswer"
+              '"Contains"'
+            when "TextCloseEnough"
+              '"Close Enough"'
+            when "TextRegex"
+              '"Regular Expression Match"'
+            else
+              raise JSON::ParserError, "Invalid scoring_algorithm"
+            end
+          end
+
+          def response_length
+            @question[:entry][:scoring_data][:value].map do |blank|
+              blank[:scoring_data][:value].is_a?(Array) ? blank[:scoring_data][:value].length : 1
+            end.max || -1
+          end
+
+          def val_from_array(index, blank)
+            (index < blank[:scoring_data][:value].length) ? blank[:scoring_data][:value][index] : nil
+          end
+
+          def determine_answer_type
+            # Fix for a Canvas API bug where the `anwer_type` key is `answerType`
+            answer_type_key = @question[:entry][:interaction_data][:blanks][0][:answer_type] ? :answer_type : :answerType
+            current_answer_type = @question[:entry][:interaction_data][:blanks][0][answer_type_key]
+            @question[:entry][:interaction_data][:blanks].each do |blank|
+              next unless blank[answer_type_key] != current_answer_type
+
+              @notifications << "Fill in the blank question with mixed answer types have been converted to open entry exact match"
+              current_answer_type = "openEntry"
+              @is_mixed_question_type = true
+              break
+            end
+            @answer_type = map_answer_type_to_mc_type(current_answer_type)
+          end
+
+          def map_answer_type_to_mc_type(answer_type)
+            case answer_type
+            when "openEntry"
+              "clozetext"
+            when "dropdown"
+              @include_possible_responses = true
+              "clozedropdown"
+            when "wordbank"
+              @include_possible_responses = true
+              "clozeassociation"
+            else
+              raise JSON::ParserError, "Invalid answer type for FillInBlank"
+            end
+          end
+
+          def possible_responses
+            case @answer_type
+            when "clozedropdown"
+              dropdown_possible_responses
+            when "clozeassociation"
+              wordbank_possible_responses
+            else
+              raise JSON::ParserError, "There was an error converting this question"
+            end
+          end
+
+          def dropdown_possible_responses
+            possible_responses = Array.new(@question[:entry][:interaction_data][:blanks].length) { [] }
+            @question[:entry][:interaction_data][:blanks].each_with_index do |blank, index|
+              blank[:choices].each do |choice|
+                possible_responses[index].append(choice[:item_body])
+              end
+            end
+            possible_responses
+          end
+
+          def wordbank_possible_responses
+            choices = @question.dig(:entry, :interaction_data, :word_bank_choices)
+            unless choices
+              raise JSON::ParserError, "Could not find `word_bank_choices` property to form possible responses"
+            end
+
+            choices.map { |choice| choice[:item_body] }
+          end
+        end
+      end
+    end
+  end
+end