ams_migration 0.1.3

data/lib/ams_migration/canvas/converter/new_quiz/formula.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 Formula < 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 Formula 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/hotspot.rb

@@ -0,0 +1,166 @@
+# 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.
+
+require "fastimage"
+
+module AmsMigration
+  module Canvas
+    module Converter
+      module NewQuiz
+        class Hotspot < NewQuestion
+          DEFAULT_IMAGE_SIZE = [500, 500].freeze
+          AREA_ATTRIBUTES = {
+            global: {
+              fill: "rgba(12, 176, 216, 0.48)",
+              stroke: "rgba(25, 90, 107, 0.83)"
+            }
+          }.freeze
+
+          def to_h
+            @question
+          end
+
+          def image_url
+            @question&.dig(:entry, :interaction_data, :image_url)
+          end
+
+          def image_dimensions
+            return @image_dimensions if defined? @image_dimensions
+
+            dimensions = FastImage.size(image_url)
+            @image_dimensions = dimensions.nil? ? DEFAULT_IMAGE_SIZE : dimensions
+
+            @image_dimensions
+          end
+
+          def points_possible
+            @question[:points_possible]
+          end
+
+          # We multiply by 100 because the canvas coordinates are a percentage of the image size whereas the
+          # MC coordinates are a full integer percentage of the image size
+          def canvas_coords(value)
+            value[:coordinates].map do |coord|
+              {
+                x: coord[:x] * 100,
+                y: coord[:y] * 100
+              }
+            end
+          end
+
+          def values
+            value = @question.dig(:entry, :scoring_data, :value)
+            return value if value.is_a?(Array)
+
+            [value]
+          end
+
+          def coordinates(value)
+            type = value[:type]
+
+            case type
+            when "square"
+              square_coordinates(value)
+            when "oval"
+              oval_coordinates(value)
+            when "polygon"
+              canvas_coords(value)
+            else
+              raise "Unknown hotspot type: #{type}"
+            end
+          end
+
+          def square_coordinates(value)
+            canvas_coordinates = canvas_coords(value)
+
+            x1 = canvas_coordinates[0][:x]
+            y1 = canvas_coordinates[0][:y]
+            x2 = canvas_coordinates[1][:x]
+            y2 = canvas_coordinates[1][:y]
+
+            [
+              {
+                x: x1,
+                y: y1
+              },
+              {
+                x: x1,
+                y: y2
+              },
+              {
+                x: x2,
+                y: y2
+              },
+              {
+                x: x2,
+                y: y1
+              }
+            ]
+          end
+
+          def oval_coordinates(value)
+            canvas_coordinates = canvas_coords(value)
+            x1 = canvas_coordinates[0][:x]
+            y1 = canvas_coordinates[0][:y]
+            x2 = canvas_coordinates[1][:x]
+            y2 = canvas_coordinates[1][:y]
+
+            oval_center = [(x1 + x2) / 2, (y1 + y2) / 2]
+            horizontal_radius = (x2 - x1) / 2
+            vertical_radius = (y2 - y1) / 2
+
+            # Going to approximate the oval with a polygon with 16 points
+            oval_coords = []
+
+            16.times do |i|
+              angle = (2 * Math::PI) * (i / 16.0)
+              x = oval_center[0] + (horizontal_radius * Math.cos(angle))
+              y = oval_center[1] + (vertical_radius * Math.sin(angle))
+              oval_coords << { x:, y: }
+            end
+
+            oval_coords
+          end
+
+          def areas
+            values.map { |value| coordinates(value) }
+          end
+
+          def convert
+            super
+            begin
+              @converted_question = {
+                type: "hotspot",
+                stimulus:,
+                image: {
+                  source: image_url,
+                  width: image_dimensions[0],
+                  height: image_dimensions[1]
+                },
+                areas:,
+                area_attributes: AREA_ATTRIBUTES,
+                validation: {
+                  scoring_type: "exactMatch",
+                  valid_response: {
+                    score: points_possible,
+                    value: ["0"]
+                  }
+                },
+                is_math: true
+              }
+
+              @image_sources << image_url
+
+              @notifications << "Hotspot items will need additional configuration."
+            rescue => e
+              @conversion_errors << e.message
+            end
+            post_convert
+            format
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# 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 Matching < NewQuestion
+          def initialize(question)
+            super
+            @distractors = []
+          end
+
+          def to_h
+            @question
+          end
+
+          def possible_responses
+            @question.dig(:entry, :interaction_data, :answers).map do |answer|
+              answer
+            end
+          end
+
+          def stimulus_list
+            @question.dig(:entry, :interaction_data, :questions).map do |question|
+              question[:item_body]
+            end
+          end
+
+          def answer_value
+            @question.dig(:entry, :scoring_data, :edit_data, :matches).map do |answer|
+              answer[:answer_body]
+            end
+          end
+
+          def scoring_type
+            case @question.dig(:entry, :scoring_algorithm)
+            when "PartialDeep"
+              "partialMatchV2"
+            else
+              "exactMatch"
+            end
+          end
+
+          def distractors
+            @distractors = @question.dig(:entry, :scoring_data, :edit_data, :distractors)
+          end
+
+          def convert
+            super
+            begin
+              @converted_question = {
+                possible_responses:,
+                stimulus_list:,
+                stimulus:,
+                type: "association",
+                validation: {
+                  valid_response: {
+                    score: point_value,
+                    value: answer_value
+                  },
+                  scoring_type:
+                },
+                metadata: {
+                  distractor_rationale_response_level: distractors
+                }
+              }
+
+              if distractors.length.positive?
+                @converted_question[:metadata] = {
+                  distractor_rationale_response_level: @distractors
+                }
+              end
+            rescue => e
+              @conversion_errors << e.message
+            end
+            post_convert
+            format
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ams_migration/canvas/converter/new_quiz/multiple_answer.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 NewQuiz
+        class MultipleAnswer < MultipleChoice
+          def correct_answer
+            @question[:entry][:scoring_data][:value]
+          end
+
+          def convert
+            begin
+              multiple_answer = super
+              multiple_answer[:question][:multiple_responses] = true if multiple_answer[:errors].empty?
+            rescue => e
+              @conversion_errors << e.message
+            end
+            post_convert
+            format
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# 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 MultipleChoice < NewQuestion
+          def initialize(question)
+            super
+            @distractors = []
+          end
+
+          def to_h
+            @question
+          end
+
+          def options
+            options = []
+            @question[:entry][:interaction_data][:choices].each do |answer|
+              label = answer[:item_body]
+              options << {
+                label:,
+                value: answer[:id].to_s
+              }
+              unless @question[:entry][:answer_feedback][answer[:id].to_sym].nil?
+                @distractors << @question[:entry][:answer_feedback][answer[:id].to_sym]
+              end
+            end
+            options
+          end
+
+          def correct_answer
+            [@question[:entry][:scoring_data][:value]]
+          end
+
+          def convert
+            super
+            begin
+              @converted_question = {
+                stimulus:,
+                options:,
+                type: "mcq",
+                validation: {
+                  valid_response: {
+                    score: point_value,
+                    value: correct_answer
+                  },
+                  scoring_type: "exactMatch"
+                }
+              }
+
+              if @distractors.length.positive?
+                @converted_question[:metadata] = {
+                  distractor_rationale_response_level: @distractors
+                }
+              end
+            rescue => e
+              @conversion_errors << e.message
+            end
+
+            post_convert
+            format
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+# 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
+  require "nokogiri"
+  module Canvas
+    module Converter
+      module NewQuiz
+        class NewQuestion
+          attr_reader :notifications, :image_sources
+
+          def initialize(question)
+            @question_json = question
+            @question = nil
+            @is_math = nil
+            @converted_question = {}
+            @conversion_errors = []
+            @notifications = []
+            @image_sources = []
+            @uri_parser = URI::DEFAULT_PARSER
+          end
+
+          def title
+            return nil if @question.blank?
+
+            @question[:question_name] || @question[:title] || @question.dig(:entry, :title) || ""
+          end
+
+          def stimulus
+            @question[:entry][:item_body]
+          end
+
+          def convert
+            begin
+              @question = JSON.parse(@question_json).deep_symbolize_keys
+            rescue JSON::ParserError => e
+              @question = ""
+              @conversion_errors << e.message
+            end
+            format
+          end
+
+          def point_value
+            point_value = @question[:points_possible] || 0
+            if point_value % 1 != 0
+              @notifications << "Partial points are not supported.  After conversion points have been rounded to the nearest whole number."
+            end
+            point_value.round(0)
+          end
+
+          def post_convert
+            process_question_text
+          end
+
+          def process_question_text
+            if @converted_question.is_a?(Hash)
+              if @converted_question.key?(:stimulus)
+                @converted_question[:stimulus] = substitute_mathml(@converted_question[:stimulus])
+                get_image_sources(@converted_question[:stimulus])
+              end
+              if @converted_question.key?(:template)
+                @converted_question[:template] = substitute_mathml(@converted_question[:template])
+                get_image_sources(@converted_question[:template])
+              end
+
+              if @converted_question.key?(:options)
+                @converted_question[:options].each do |option|
+                  option[:label] = substitute_mathml(option[:label])
+                  get_image_sources(option[:label])
+                  option[:value] = substitute_mathml(option[:value])
+                  get_image_sources(option[:value])
+                end
+              end
+
+              if @converted_question.key?(:list)
+                @converted_question[:list].each_with_index do |each_list, index|
+                  @converted_question[:list][index] = substitute_mathml(each_list)
+                  get_image_sources(@converted_question[:list][index])
+                end
+              end
+
+              @converted_question[:is_math] = @converted_question[:is_math] || @is_math
+              @converted_question.compact!
+            else
+              @converted_question = substitute_mathml(@converted_question) unless @converted_question.nil?
+              get_image_sources(@converted_question) unless @converted_question.nil?
+            end
+          end
+
+          def substitute_mathml(fragment)
+            html = Nokogiri::HTML::DocumentFragment.parse(fragment, "UTF-8")
+
+            if @is_math.nil?
+              @is_math = html.css("img.equation_image").empty? ? nil : true
+            end
+
+            html.css("img.equation_image[data-equation-content]").each do |img|
+              img.replace("\\(#{img.attr("data-equation-content")}\\)")
+            end
+
+            html.to_xhtml(indent: 0).delete("\n")
+          end
+
+          def get_image_sources(fragment)
+            html = Nokogiri::HTML::DocumentFragment.parse(fragment, "UTF-8")
+            html.css("img").each { |img| @image_sources << img.attr("src") if img.attr("src") }
+          end
+
+          def tags
+            @question.is_a?(Hash) ? @question[:tags] || [] : []
+          end
+
+          def to_h
+            @question
+          end
+
+          protected
+
+          def format
+            {
+              question: @converted_question,
+              title:,
+              errors: @conversion_errors,
+              tags:,
+              image_sources:
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# 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 Numerical < NewQuestion
+          def math?
+            @question[:entry][:scoring_data][:value].any? do |value|
+              %w[withinARange marginOfError].include?(value[:type])
+            end
+          end
+
+          def correct_values
+            values = []
+            @question[:entry][:scoring_data][:value].map do |answer|
+              case answer[:type]
+              when "exactResponse"
+                values << {
+                  method: "equivLiteral",
+                  value: answer[:value],
+                  options: {
+                    ignoreOrder: false,
+                    inverseResult: false
+                  }
+                }
+              when "marginOfError"
+                @notifications << 'Numeric items with "Margin Of Error" may need additional configuration'
+
+                value = answer[:value].to_f
+                margin = answer[:margin].to_f
+
+                margin = (value * margin / 100).round(2) if answer[:margin_type] == "percent"
+
+                values << {
+                  method: "equivValue",
+                  value: "#{value}\\pm#{margin}",
+                  options: {
+                    ignoreOrder: false,
+                    inverseResult: false
+                  }
+                }
+              when "withinARange"
+                @notifications << 'Numeric items with "Within A Range" may need additional configuration'
+                if answer[:end] && answer[:start]
+                  mid_point = (answer[:end].to_f + answer[:start].to_f) / 2
+                  margin_of_error = (answer[:end].to_f - answer[:start].to_f) / 2
+                  values << {
+                    method: "equivValue",
+                    value: "#{mid_point}\\pm#{margin_of_error}",
+                    options: {
+                      ignoreOrder: false,
+                      inverseResult: false
+                    }
+                  }
+                end
+              when "preciseResponse"
+                @notifications << 'Numeric items with "Precise Response" may need additional configuration'
+
+                value = answer[:value].to_f
+                precision = answer[:precision].to_i
+
+                if answer[:precision_type] == "significantDigits"
+                  whole_num_digits = value.to_i.to_s.length
+                  decimal_places = [precision - whole_num_digits, 0].max
+                else
+                  decimal_places = precision
+                end
+
+                values << {
+                  method: "equivValue",
+                  value: answer[:value].to_s,
+                  options: {
+                    decimalPlaces: decimal_places
+                  }
+                }
+              else
+                raise JSON::ParserError, "Invalid scoring type for Numeric"
+              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]
+                  }
+                },
+                response_containers: []
+              }
+
+              @converted_question[:is_math] = true if math?
+            rescue => e
+              @conversion_errors << e.message
+            end
+            post_convert
+            format
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# 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 Ordering < NewQuestion
+          def to_h
+            @question
+          end
+
+          def list
+            list = []
+            # already shuffled list (fixed list, not random) coming from API
+            @question[:entry][:interaction_data][:choices].each_value do |answer|
+              list << answer[:item_body]
+            end
+            list
+          end
+
+          def correct_answer
+            if !@question[:entry][:properties][:top_label].empty? || !@question[:entry][:properties][:bottom_label].empty?
+              @notifications << "Please review this item. Top and bottom labels on Ordering questions are not supported."
+            end
+            answers = @question[:entry][:scoring_data][:value]
+            choices = @question[:entry][:interaction_data][:choices]
+            answers.map { |id| choices.keys.index(:"#{id}") }
+          end
+
+          def scoring_type
+            "exactMatch"
+          end
+
+          def ui_style
+            {
+              type: @question[:entry][:properties][:display_answers_paragraph] ? "inline" : "list"
+            }
+          end
+
+          def convert
+            super
+            begin
+              @converted_question = {
+                list:,
+                stimulus:,
+                type: "orderlist",
+                validation: {
+                  scoring_type:,
+                  valid_response: {
+                    score: point_value,
+                    value: correct_answer
+                  }
+                },
+                ui_style:
+              }
+            rescue => e
+              @conversion_errors << e.message
+            end
+            post_convert
+            format
+          end
+        end
+      end
+    end
+  end
+end