scorm_engine 0.1.0

data/lib/scorm_engine/api/endpoints/registrations/launch_history.rb

@@ -0,0 +1,47 @@
+module ScormEngine
+  module Api
+    module Endpoints
+      module Registrations
+        module LaunchHistory
+          #
+          # Get launch history data associated with this registration
+          #
+          # @see http://rustici-docs.s3.amazonaws.com/engine/2017.1.x/api.html#tenant__registrations__registrationId__launchHistory_get
+          #
+          # @param [Hash] options
+          #
+          # @option options [String] :registration_id
+          #   ID for the registration.
+          #
+          # @option options [String] :instance ()
+          #   The instance of this registration to use. If not provided, the
+          #   latest instance will be used.
+          #
+          # @option options [Boolean] :include_history_log (false)
+          #   Whether to include the history log in the launch history. The
+          #   history log is a blob of XML that shows all of the SCORM-related
+          #   calls inside the course. Depending on the course itself, these logs
+          #   can get very large if a lot of calls are being made.
+          #
+          # @return [Array<ScormEngine::Models::RegistrationLaunchHistory>]
+          #
+          def get_registration_launch_history(options = {})
+            require_options(options, :registration_id)
+
+            options = options.dup
+            registration_id = options.delete(:registration_id)
+            options[:includeHistoryLog] = !!options.delete(:include_history_log)
+
+            response = get("registrations/#{registration_id}/launchHistory", options)
+
+            result = response.success? && response.body["launchHistory"].map do |history|
+              ScormEngine::Models::RegistrationLaunchHistory.new_from_api(history)
+            end
+
+            Response.new(raw_response: response, result: result)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/scorm_engine/client.rb

@@ -0,0 +1,17 @@
+require_relative "faraday/connection"
+require_relative "faraday/request"
+
+module ScormEngine
+  class Client
+
+    include Faraday::Connection
+    include Faraday::Request
+    include Api::Endpoints
+
+    attr_reader :tenant
+
+    def initialize(tenant:)
+      @tenant = tenant
+    end
+  end
+end

data/lib/scorm_engine/configuration.rb

@@ -0,0 +1,43 @@
+require "logger"
+
+module ScormEngine
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+
+  class Configuration
+    # http://rustici-docs.s3.amazonaws.com/engine/2017.1.x/api.html
+    attr_accessor :host, :path_prefix
+
+    # http://rustici-docs.s3.amazonaws.com/engine/2017.1.x/Architecture-API.html#api-authentication
+    attr_accessor :username, :password
+
+    # defaults to /dev/null
+    # https://github.com/lostisland/faraday/blob/5f1687abbe9eb1c96284b31e303e80f1a22acd09/lib/faraday/response/logger.rb#L7
+    attr_accessor :logger, :log_options
+
+    def initialize
+      reset
+    end
+
+    def reset
+      @host = ENV["SCORM_ENGINE_HOST"]
+      @path_prefix = "/ScormEngineInterface/api/v1/"
+
+      @username = ENV["SCORM_ENGINE_USERNAME"]
+      @password = ENV["SCORM_ENGINE_PASSWORD"]
+
+      @logger = ::Logger.new(ENV.fetch("SCORM_ENGINE_LOGFILE", "/dev/null"))
+
+      @log_options = begin
+                       JSON.parse(ENV.fetch("SCORM_ENGINE_LOG_OPTIONS"))
+                     rescue KeyError, JSON::ParserError
+                       { headers: false, bodies: false }
+                     end
+    end
+  end
+end

data/lib/scorm_engine/faraday/connection.rb

@@ -0,0 +1,35 @@
+require "faraday"
+require "faraday_middleware"
+
+module ScormEngine
+  module Faraday
+    module Connection
+      private
+
+      def connection
+        @connection ||= ::Faraday.new(url: base_uri.to_s) do |faraday|
+          faraday.headers["Content-Type"] = "application/json"
+          faraday.headers["User-Agent"] = "ScormEngine Ruby Gem #{ScormEngine::VERSION}"
+
+          faraday.basic_auth(ScormEngine.configuration.username, ScormEngine.configuration.password)
+
+          faraday.request :multipart
+          faraday.request :json
+
+          faraday.response :json, content_type: /\bjson$/
+          faraday.response :logger, ScormEngine.configuration.logger, ScormEngine.configuration.log_options
+
+          faraday.adapter ::Faraday.default_adapter
+        end
+      end
+
+      def base_uri
+        uri = URI("")
+        uri.scheme = "https" # TODO: Make configurable
+        uri.host = ScormEngine.configuration.host
+        uri.path = ScormEngine.configuration.path_prefix
+        uri
+      end
+    end
+  end
+end

data/lib/scorm_engine/faraday/request.rb

@@ -0,0 +1,54 @@
+module ScormEngine
+  module Faraday
+    module Request
+      def get(path, options = {})
+        request(:get, path, options)
+      end
+
+      def post(path, options = {}, body = nil)
+        request(:post, path, options, body)
+      end
+
+      def put(path, options = {}, body = nil)
+        request(:put, path, options, body)
+      end
+
+      def delete(path, options = {})
+        request(:delete, path, options)
+      end
+
+      private
+
+      def request(method, path, options, body = nil)
+        # "more" pagination urls are fully qualified
+        path = "#{tenant}/#{path}" unless path =~ %r{\Ahttps?://}
+
+        options = coerce_options(options)
+
+        connection.send(method) do |request|
+          case method
+          when :get, :delete
+            request.url(path, options)
+          when :post, :put
+            if body.nil?
+              body = options.dup
+              options = {}
+            end
+            request.url(path, options)
+            request.body = body unless body.empty?
+          end
+        end
+      end
+
+      def coerce_options(options = {})
+        options.dup.each do |k, v|
+          case k
+          when :before, :since
+            options[k] = v.iso8601 if v.respond_to?(:iso8601)
+          end
+        end
+        options
+      end
+    end
+  end
+end

data/lib/scorm_engine/models.rb

@@ -0,0 +1,9 @@
+require_relative "models/course"
+require_relative "models/course_configuration"
+require_relative "models/course_import"
+require_relative "models/learner"
+require_relative "models/registration"
+require_relative "models/registration_activity_detail"
+require_relative "models/registration_configuration"
+require_relative "models/registration_launch_history"
+require_relative "models/registration_runtime_interaction"

data/lib/scorm_engine/models/course.rb

@@ -0,0 +1,66 @@
+require "time"
+
+module ScormEngine
+  module Models
+    class Course
+      attr_accessor :options
+      private :options
+
+      # TODO: Not sure we want this to be settable. Will depend on how we go
+      # about creating/updating records. For now it makes it easier to create
+      # instances from API options hash.
+      attr_accessor :id, :version, :title, :registration_count, :updated, :description,
+                    :scaled_passing_score
+
+      def self.new_from_api(options = {})
+        this = new
+
+        this.options = options.dup
+        this.id = options["id"]
+        this.version = options["version"]
+        this.title = get_title_from_api(options)
+        this.registration_count = options["registrationCount"]
+        this.updated = Time.parse(options["updated"]) if options.key?("updated")
+        this.description = options.fetch("metadata", {})["description"]
+        this.scaled_passing_score = get_scaled_passing_score_from_api(options)
+
+        this
+      end
+
+      #
+      # Extract and sanitize the title from the API options.
+      #
+      # Special consideration is given to two commonly found, but useless
+      # titles which if found will result in a blank title.
+      #
+      # @param [Hash] options
+      #   The API options hash
+      #
+      # @return [String]
+      #
+      def self.get_title_from_api(options = {})
+        title = ScormEngine::Utils.sanitized_text(options["title"])
+        title = "" if ["Title", "Captivate E-Learning Course"].include?(title)
+        title
+      end
+
+      #
+      # Extract and normalize the scaled passing score from the API options.
+      #
+      # @param [Hash] options
+      #   The API options hash
+      #
+      # @return [Integer]
+      #   An integer between 0 and 100 or nil if undefined.
+      #
+      def self.get_scaled_passing_score_from_api(options = {})
+        first_child = options.fetch("rootActivity", {}).fetch("children", [{}]).first
+        score = first_child.is_a?(Hash) ? first_child["scaledPassingScore"] : nil
+        return if score.nil?
+        score = score.to_f
+        score *= 100 if score <= 1.0
+        score.to_i
+      end
+    end
+  end
+end

data/lib/scorm_engine/models/course_configuration.rb

@@ -0,0 +1,37 @@
+module ScormEngine
+  module Models
+    class CourseConfiguration
+      attr_accessor :options
+      private :options
+
+      # TODO: Not sure we want this to be settable. Will depend on how we go
+      # about creating/updating records. For now it makes it easier to create
+      # instances from API options hash.
+      attr_accessor :settings
+
+      def self.new_from_api(options = {})
+        this = new
+
+        this.options = options.dup
+        this.settings = get_settings_from_api(options)
+        this
+      end
+
+      #
+      # Extract and normalize the settings from the API options.
+      #
+      # @param [Hash] options
+      #   The API options hash
+      #
+      # @return [Hash]
+      #   A hash of key/value pairs.
+      #
+      def self.get_settings_from_api(options = {})
+        options["configurationItems"].reduce({}) do |m, o|
+          m[o["id"]] = o["value"]
+          m
+        end
+      end
+    end
+  end
+end

data/lib/scorm_engine/models/course_import.rb

@@ -0,0 +1,42 @@
+module ScormEngine
+  module Models
+    class CourseImport
+      attr_accessor :options
+      private :options
+
+      # TODO: Not sure we want this to be settable. Will depend on how we go
+      # about creating/updating records. For now it makes it easier to create
+      # instances from API options hash.
+      attr_accessor :id, :status, :parser_warnings, :course
+
+      def self.new_from_api(options = {})
+        this = new
+        this.options = options.dup
+
+        if options.key?("importResult")
+          this.id = options["result"]
+          this.status = options.fetch("importResult", {})["status"]
+          this.parser_warnings = options.fetch("importResult", {})["parserWarnings"]
+        else
+          this.id = options["jobId"]
+          this.status = options["status"]
+          this.course = Course.new_from_api(options["course"]) if options.key?("course") # unavailable in error states
+        end
+
+        this
+      end
+
+      def running?
+        status == "RUNNING"
+      end
+
+      def error?
+        status == "ERROR"
+      end
+
+      def complete?
+        status == "COMPLETE"
+      end
+    end
+  end
+end

data/lib/scorm_engine/models/learner.rb

@@ -0,0 +1,24 @@
+module ScormEngine
+  module Models
+    class Learner
+      attr_accessor :options
+      private :options
+
+      # TODO: Not sure we want this to be settable. Will depend on how we go
+      # about creating/updating records. For now it makes it easier to create
+      # instances from API options hash.
+      attr_accessor :id, :first_name, :last_name
+
+      def self.new_from_api(options = {})
+        this = new
+
+        this.options = options.dup
+        this.id = options["id"]
+        this.first_name = options["firstName"]
+        this.last_name = options["lastName"]
+
+        this
+      end
+    end
+  end
+end

data/lib/scorm_engine/models/registration.rb

@@ -0,0 +1,82 @@
+#
+# TODO: Incorporate all the activity props from:
+#   http://rustici-docs.s3.amazonaws.com/engine/2017.1.x/api.html#tenant__registrations__registrationId__progress_get
+#   http://rustici-docs.s3.amazonaws.com/engine/2017.1.x/api.html#tenant__registrations__registrationId__progress_detail_get
+#
+# TODO: Confirmed they are the only values. Integrate them into the model.
+#       registrationCompletion: ["COMPLETED", "INCOMPLETE", "UNKNOWN"]
+#       registrationSuccess: ["Unknown", "Passed", "Failed"]
+#
+module ScormEngine
+  module Models
+    class Registration
+      attr_accessor :options
+      private :options
+
+      # TODO: Not sure we want this to be settable. Will depend on how we go
+      # about creating/updating records. For now it makes it easier to create
+      # instances from API options hash.
+      attr_accessor :id, :instance, :updated, :registration_completion, :registration_success,
+        :total_seconds_tracked, :score, :course, :learner, :activity_details,
+        :first_access_date, :last_access_date, :completed_date, :created_date,
+        :registration_completion_amount
+
+      def self.new_from_api(options = {})
+        this = new
+
+        this.options = options.dup
+        this.id = options["id"]
+        this.instance = options["instance"]
+        this.updated = Time.parse(options["updated"]) if options.key?("updated")
+        this.registration_completion = options["registrationCompletion"]
+        this.registration_success = options["registrationSuccess"]
+        this.total_seconds_tracked = options["totalSecondsTracked"]
+        this.first_access_date = Time.parse(options["firstAccessDate"]) if options.key?("firstAccessDate")
+        this.last_access_date = Time.parse(options["lastAccessDate"]) if options.key?("lastAccessDate")
+        this.created_date = Time.parse(options["createdDate"]) if options.key?("createdDate")
+        this.updated = Time.parse(options["updated"]) if options.key?("updated")
+        this.registration_completion_amount = options["registrationCompletionAmount"].to_f # Sometimes it returns "NaN"
+
+        this.score = get_score_from_api(options)
+        this.completed_date = get_completed_at_from_api(options)
+
+        this.activity_details = RegistrationActivityDetail.new_from_api(options["activityDetails"]) if options.key?("activityDetails")
+        this.course = Course.new_from_api(options["course"]) if options.key?("course")
+        this.learner = Learner.new_from_api(options["learner"]) if options.key?("learner")
+
+        this
+      end
+
+      #
+      # Extract and normalize the scaled passing score from the API options.
+      #
+      # @param [Hash] options
+      #   The API options hash
+      #
+      # @return [Float]
+      #   A float between 0 and 100 or nil if undefined.
+      #
+      def self.get_score_from_api(options = {})
+        score = options.fetch("score", {})["scaled"]
+        return if score.nil?
+        score.to_f
+      end
+
+      #
+      # Extract and normalize the completed date from the API options.
+      #
+      # @param [Hash] options
+      #   The API options hash
+      #
+      # @return [Time]
+      #   a date/time or nil if undefined.
+      #
+      def self.get_completed_at_from_api(options = {})
+        completed_date = options["completedDate"]
+        completed_date ||= options.fetch("score", {})["completedDate"]
+        return if completed_date.nil?
+        Time.parse(completed_date)
+      end
+    end
+  end
+end