ams_migration 0.1.3

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

@@ -0,0 +1,35 @@
+# 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 Stimulus < NewQuestion
+          def to_h
+            @question
+          end
+
+          def combined_stimulus
+            "<p><strong>Instructions</strong></p><p>#{@question.dig(:entry,
+                                                                    :instructions)}</p><p><strong>#{@question.dig(
+                                                                      :entry, :title
+                                                                    )}</strong></p>#{@question.dig(:entry, :body)}"
+          end
+
+          def convert
+            super
+            begin
+              @converted_question = substitute_mathml(combined_stimulus)
+            rescue => e
+              @conversion_errors << e.message
+            end
+            post_convert
+            format
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ams_migration/canvas/converter/new_quiz/true_false.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 TrueFalse < MultipleChoice
+          def options
+            @question[:entry][:interaction_data].map do |answer|
+              if answer[0] == :true_choice
+                {
+                  label: "True",
+                  value: "0"
+                }
+              else
+                {
+                  label: "False",
+                  value: "1"
+                }
+              end
+            end
+          end
+
+          def correct_answer
+            @question[:entry][:scoring_data][:value] ? ["0"] : ["1"]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# 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
+        # Implementation for when Canvas QuizItem question_type is unknown.
+        # Allows the Quiz conversion to continue uninterrupted. See MCE-23091.
+        class Unknown < NewQuestion
+          def convert
+            begin
+              @question = JSON.parse(@question_json).deep_symbolize_keys
+              entry_type = @question[:entry_type]
+              question_type = @question.dig(:entry, :interaction_type_slug)
+
+              @conversion_errors << "Unsupported entry type: #{entry_type}" if entry_type
+              @conversion_errors << "Unknown question type: #{question_type}" if question_type
+            rescue JSON::ParserError => e
+              @question = ""
+              @conversion_errors << e.message
+            end
+            format
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ams_migration/canvas/converter/question_type.rb

@@ -0,0 +1,30 @@
+# 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
+    class QuestionType
+      # NOTE: These are not necessarily all the names, just some that are referenced
+      # in the code.
+      NAMES = [
+        CHOICE_MULTI_TYPE = "CHOICE_MULTI".freeze,
+        CHOICE_TYPE = "CHOICE".freeze,
+        EXTENDED_TEXT_TYPE = "EXTENDED_TEXT".freeze,
+        GAP_MATCH_TYPE = "GAP_MATCH".freeze,
+        GRAPHIC_GAP_FILL_TYPE = "GRAPHIC_GAP_FILL".freeze,
+        INLINE_CHOICE_TYPE = "INLINE_CHOICE".freeze,
+        LETTER_SCORE_TYPE = "LETTER_SCORE".freeze,
+        MCQ_TYPE = "mcq".freeze,
+        MULTI_CHOICE_TYPE = "MULTI_CHOICE".freeze,
+        MULTI_SELECT_TYPE = "MULTI_SELECT".freeze,
+        ORDER_TYPE = "ORDER".freeze,
+        RUBRIC_CRITERIA_TYPE = "RUBRIC_CRITERIA".freeze,
+        TEXT_ENTRY_TYPE = "TEXT_ENTRY".freeze,
+        TRUE_FALSE_QTI_TYPE = "TRUE_FALSE_QTI".freeze,
+        TRUE_FALSE_TYPE = "TRUE_FALSE".freeze,
+        UNSUPPORTED_CANVAS_TYPE = "unsupported_canvas_question_type".freeze
+      ].freeze
+    end
+  end
+end

data/lib/ams_migration/services/README.md

@@ -0,0 +1,26 @@
+# How to use
+
+Assuming you implemented a data provider for NQ or CQ, you can use the following  code snipped to run the migration service
+```
+    quiz_id = nil # all quizzes in the course
+    course_id = 21
+    shard_id = 1
+    root_account_uuid = data_provider.root_account_uuid
+
+    learnosity_consumer_key = "YOUR_LEARNOSITY_CONSUMER_KEY"
+    learnosity_consumer_secret = "YOUR_LEARNOSITY_CONSUMER_SECRET"
+    learnosity_organisation_id = 1455
+
+    data_provider = Ams::DataProvider.new({ shard_id:, course_id:, quiz_id: })
+    destination = AmsMigration::Services::LearnositySink.new({
+                                                               consumer_key: learnosity_consumer_key,
+                                                               consumer_secret: learnosity_consumer_secret,
+                                                               domain: "localhost",
+                                                               organization_id: learnosity_organisation_id,
+                                                               replace_images: true,
+                                                               new_image_prefix: root_account_uuid
+                                                             })
+
+    transformer = AmsMigration::Services::NewQuizLearnosityTransformer.new(root_account_uuid:)
+    AmsMigration::Services::MigrationService.new(data_provider:, transformer:, destination:).run
+```

data/lib/ams_migration/services/data_provider.rb

@@ -0,0 +1,26 @@
+# 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 Services
+    class DataProvider
+      # returns serialized data according to NQ Public API.
+      # [{
+      #  "quiz": { response compatible with https://developerdocs.instructure.com/services/canvas/file.all_resources/new_quizzes },
+      #  "quiz_items": [{ an array of quiz items. https://developerdocs.instructure.com/services/canvas/file.all_resources/new_quiz_items}],
+      # }]
+      def quizzes
+        raise NotImplementedError, "This method should be implemented in a subclass"
+      end
+
+      def items
+        raise NotImplementedError, "This method should be implemented in a subclass"
+      end
+
+      def banks
+        raise NotImplementedError, "This method should be implemented in a subclass"
+      end
+    end
+  end
+end

data/lib/ams_migration/services/learnosity_bank_cleaner.rb

@@ -0,0 +1,44 @@
+# 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 "net/http"
+require "json"
+require "learnosity/sdk/request/init"
+
+module AmsMigration
+  module Services
+    # Allows to completely "clean" Learnosity bank
+    # by archiving all items and activities
+    # NOTE: In learnosity, it is not possible to hard delete content. You can only archive it.
+    # also it is not possible to archive a question or a feature. These entities don't have status field.
+    class LearnosityBankCleaner
+      attr_reader :client
+
+      def initialize(config = {})
+        @client = LearnosityDataApiClient.new(config.slice(:consumer_key,
+                                                           :consumer_secret,
+                                                           :domain,
+                                                           :data_api_url,
+                                                           :organization_id))
+      end
+
+      def clean
+        archive "activities"
+        archive "items"
+      end
+
+      private
+
+      def archive(enum)
+        client.entity_enumerator(enum, { status: %w[published unpublished] }).each_slice(50) do |batch|
+          batch.each { |entity| entity["status"] = "archived" }
+
+          request = { enum => batch }
+
+          client.post_request(request, enum, "set")
+        end
+      end
+    end
+  end
+end

data/lib/ams_migration/services/learnosity_data_api_client.rb

@@ -0,0 +1,135 @@
+# 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 "logger"
+
+require "learnosity/sdk/request/init"
+require "marcel"
+
+module AmsMigration
+  module Services
+    # Learnosity client for API requests
+    class LearnosityDataApiClient
+      DEFAULT_DATA_API_URL = "https://data-or.learnosity.com/v2025.1.LTS".freeze
+      DEFAULT_DOMAIN = "localhost".freeze
+
+      attr_reader :consumer_key, :consumer_secret, :domain, :data_api_url, :organization_id, :logger, :log_responses
+
+      def initialize(config)
+        @consumer_key = config[:consumer_key]
+        @consumer_secret = config[:consumer_secret]
+        @domain = config.fetch(:domain, DEFAULT_DOMAIN)
+        @data_api_url = config.fetch(:data_api_url, DEFAULT_DATA_API_URL)
+        @organization_id = config[:organization_id]
+        @logger = config.fetch(:logger, Logger.new($stdout))
+        @log_responses = config.fetch(:log_responses, false)
+
+        validate!
+      end
+
+      def post_request(request, endpoint, method = "get")
+        request = request.merge({ "organisation_id" => organization_id })
+        init = Learnosity::Sdk::Request::Init.new("data", security_packet, consumer_secret, request, method)
+        signed_request = init.generate
+
+        request_url = "#{@data_api_url}/itembank/#{endpoint}"
+        response = Net::HTTP.post_form URI(request_url), signed_request
+
+        handle_response response
+      end
+
+      def entity_enumerator(endpoint, params = {})
+        Enumerator.new do |yielder|
+          next_token = nil
+
+          loop do
+            request_data = {
+              limit: 50,
+              next: next_token
+            }.merge(params)
+
+            response = post_request(request_data, endpoint, "get")
+            break unless response["data"]&.any?
+
+            response["data"].each do |entity|
+              yielder << entity
+            end
+
+            next_token = response.dig("meta", "next")
+            break unless next_token
+          end
+        end
+      end
+
+      protected
+
+      def security_packet
+        @security_packet ||= {
+          consumer_key:,
+          domain:
+        }.with_indifferent_access
+      end
+
+      def log(message, level: :debug)
+        logger.send(level, "#LearnosityBase: #{message}")
+      end
+
+      def validate!
+        raise ArgumentError, "Missing consumer_key" if consumer_key.blank?
+        raise ArgumentError, "Missing consumer_secret" if consumer_secret.blank?
+        raise ArgumentError, "Missing domain" if domain.blank?
+        raise ArgumentError, "Missing data_api_url" if data_api_url.blank?
+        raise ArgumentError, "Missing organization_id" if organization_id.blank?
+      end
+
+      def handle_response(response)
+        response_json = parse_response(response)
+        log_response(response, response_json) if log_responses
+        log_result(response, response_json)
+
+        response_json
+      end
+
+      private
+
+      def parse_response(response)
+        return nil if response.body.blank?
+
+        JSON.parse(response.body)
+      rescue JSON::ParserError => e
+        log("Failed to parse response: #{e.message}", level: :error)
+        nil
+      end
+
+      def log_response(response, response_json)
+        log "\n--- API Response ---"
+        log "HTTP Status: #{response.code} #{response.message}"
+        log "Response Body: #{JSON.pretty_generate(response_json)}"
+      end
+
+      def log_result(response, response_json)
+        if successful_response?(response, response_json)
+          log "\nSuccess."
+        else
+          log_error_details(response_json)
+        end
+      end
+
+      def successful_response?(response, response_json)
+        response.is_a?(Net::HTTPSuccess) &&
+          (response_json.blank? || response_json.dig("meta", "status") == true)
+      end
+
+      def log_error_details(response_json)
+        log "\nRequest failed."
+        if (meta = response_json.dig("meta", "message"))
+          log "Error Message: #{meta}"
+        end
+        if (errors = response_json["errors"])
+          log "API Errors: #{JSON.pretty_generate(errors)}"
+        end
+      end
+    end
+  end
+end

data/lib/ams_migration/services/learnosity_sink.rb

@@ -0,0 +1,190 @@
+# 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 "learnosity/sdk/request/init"
+require "marcel"
+
+module AmsMigration
+  module Services
+    class LearnositySink
+      attr_reader :replace_images, :image_path, :client, :logger
+
+      def initialize(config)
+        @client = LearnosityDataApiClient.new(config.slice(:consumer_key,
+                                                           :consumer_secret,
+                                                           :domain,
+                                                           :data_api_url,
+                                                           :organization_id))
+
+        @replace_images = config[:replace_images] || false
+        @image_path = config[:new_image_prefix] || ""
+        @logger = config[:logger] || Logger.new($stdout)
+      end
+
+      def save(package)
+        save_questions(package[:questions])
+        save_features(package[:features])
+        save_items(package[:items])
+        save_activities(package[:activities])
+      end
+
+      protected
+
+      def save_questions(questions)
+        questions = replace_images_in_questions(questions) if replace_images?
+
+        save_collection(questions, "questions")
+      end
+
+      def save_items(items)
+        save_collection(items, "items")
+      end
+
+      def save_activities(activities)
+        save_collection(activities, "activities")
+      end
+
+      def save_features(features)
+        save_collection(features, "features")
+      end
+
+      def save_collection(collection, collection_type)
+        return if collection.blank?
+
+        collection.each_slice(50) do |batch|
+          request = {
+            collection_type => batch
+          }
+
+          client.post_request(request, collection_type, "set")
+        end
+      end
+
+      def replace_images_in_questions(questions)
+        questions.map do |question|
+          map = upload_images(find_images_in_question(question))
+          replace_images_in_json(question, map)
+        end
+      end
+
+      def log(message, level: :debug)
+        logger.send(level, "#LearnositySink: #{message}")
+      end
+
+      def replace_images?
+        @replace_images
+      end
+
+      def image_sources(fragment)
+        html = Nokogiri::HTML::DocumentFragment.parse(fragment, "UTF-8")
+        html.css("img").filter_map { |img| img.attr("src") }
+      end
+
+      def find_images_in_question(question)
+        return [] unless question.is_a?(Hash)
+
+        json_data = (question["data"] || {}).with_indifferent_access
+        image_sources = find_images_in_json(json_data.slice(:stimulus, :options, :template))
+        image_sources << json_data.dig(:image, :source) if json_data[:type] == "hotspot"
+
+        image_sources
+      end
+
+      def find_images_in_json(question_json)
+        images = []
+        case question_json
+        when Hash
+          question_json.each_value { |value| images.concat(find_images_in_json(value)) }
+        when Array
+          question_json.each { |item| images.concat(find_images_in_json(item)) }
+        when String
+          images.concat(image_sources(question_json))
+        end
+        images.compact.uniq
+      end
+
+      def download_image(url)
+        uri = URI.parse(url)
+        response = Net::HTTP.get_response(uri)
+        return response.body if response.is_a?(Net::HTTPSuccess)
+
+        raise "Downloading image #{url} failed with code: #{response.code}. Response message: #{response.message}"
+      end
+
+      def upload_images(img_sources)
+        return {} if img_sources.blank?
+
+        image_map = {}
+        begin
+          img_sources.uniq.each do |download_url|
+            file_name = File.basename(URI.parse(download_url).path)
+
+            content = download_image download_url
+            content_type = Marcel::MimeType.for(content)
+
+            # Override files for now since this is a temporary solution for ICON
+            # There are no plans at the moment to store media files on Learnosity side,
+            # The plan as of now is to use InstFS.
+
+            # add extension to content type if the file doesn't have one
+            file_name += ".#{content_type.split(";").first.split("/").last}" unless /\.[a-z]+$/i.match?(file_name)
+
+            remote_key = "assets/#{@image_path}/#{file_name}"
+            request = {
+              "subkeys" => [remote_key]
+            }
+
+            result = client.post_request(request, "upload/assets", "get")
+
+            next unless result && result["data"]
+
+            learnosity_upload = result["data"].first
+            if learnosity_upload["upload"]
+              upload_image(learnosity_upload["upload"], content, content_type)
+              image_map[download_url] = learnosity_upload["public"]
+            end
+          end
+        rescue => e
+          log "Error processing image sources: #{e.message}", level: :error
+          log e.backtrace.join("\n"), level: :error
+        end
+
+        image_map
+      end
+
+      def upload_image(s3_signed_url, content, content_type)
+        uri = URI(s3_signed_url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+
+        request = Net::HTTP::Put.new(uri)
+        request.body = content
+        request["Content-Type"] = content_type
+        request["Content-Length"] = content.bytesize.to_s
+
+        response = http.request(request)
+        raise "Failed to upload image: #{response.code} #{response.message}" unless response.is_a?(Net::HTTPSuccess)
+      end
+
+      def replace_images_in_json(json, image_map)
+        return json if image_map.blank?
+
+        case json
+        when Hash
+          json.transform_values do |value|
+            replace_images_in_json(value, image_map)
+          end
+        when Array
+          json.map { |item| replace_images_in_json(item, image_map) }
+        when String
+          image_map.reduce(json) do |text, (source, url)|
+            text.gsub(source, url)
+          end
+        else
+          json
+        end
+      end
+    end
+  end
+end

data/lib/ams_migration/services/migration_service.rb

@@ -0,0 +1,37 @@
+# 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 Services
+    class MigrationService
+      attr_reader :data_provider, :transformer, :destination
+
+      def initialize(data_provider:, transformer:, destination:, logger: nil)
+        @data_provider = data_provider
+        @transformer = transformer
+        @destination = destination
+        @logger = logger
+
+        validate!
+      end
+
+      def run
+        data_provider.quizzes.each do |quiz_wrapper|
+          transformed = transformer.transform(quiz_wrapper)
+          destination.save(transformed)
+        end
+      end
+
+      protected
+
+      def validate!
+        raise ArgumentError, "Data provider is required" unless data_provider
+        raise ArgumentError, "Transformer is required" unless transformer
+        raise ArgumentError, "Destination is required" unless destination
+
+        raise "Invalid data provider" unless data_provider.is_a?(DataProvider)
+      end
+    end
+  end
+end