rails-xapi 0.1.2

data/app/models/rails_xapi/context.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+# The optional property context.
+# See: https://github.com/adlnet/xAPI-Spec/blob/master/xAPI-Data.md#246-context
+class RailsXapi::Context < ApplicationRecord
+  include Serializable
+
+  belongs_to :instructor, class_name: "RailsXapi::Actor", optional: true
+  belongs_to :team, class_name: "RailsXapi::Actor", optional: true
+  belongs_to :statement, class_name: "RailsXapi::Statement", dependent: :destroy
+  belongs_to :statement_ref,
+             class_name: "RailsXapi::Statement",
+             foreign_key: :statement_ref,
+             optional: true
+  has_many :context_activities, dependent: :destroy
+  has_many :extensions, as: :extendable, dependent: :destroy
+
+  before_validation :validate_platform
+
+  def contextActivities=(context_activities_hash)
+    context_activities_hash.each do |activity_type, activities|
+      activities.each do |activity|
+        # Create the object and update it if necessary.
+        object =
+          RailsXapi::Object.find_or_create(activity) do
+            object.activity_definition = activity[:definition] if activity[
+              :definition
+            ].present?
+          end
+
+        object.update(activity)
+        # Create the ContextActivity object.
+        context_activity =
+          RailsXapi::ContextActivity.new(
+            activity_type: activity_type.to_s,
+            object: object
+          )
+        context_activities << context_activity
+      end
+    end
+  end
+
+  # Set the instructor value and create the actor if provided.
+  def instructor=(value)
+    return if value.blank?
+
+    actor = find_or_create_actor_with_account(value)
+    super(actor) if actor.present?
+  end
+
+  # Set the team value and create the actor if provided.
+  def team=(value)
+    return if value.blank?
+
+    actor = find_or_create_actor_with_account(value, "Group")
+    super(actor) if actor.present?
+  end
+
+  # Set the statement_ref value if provided.
+  # RailsXapi::Context needs a setter to save the "statement" data. However, it also
+  # belongs to a RailsXapi::Statement. Therefore, we use the attribute :statement_ref.
+  def statement=(value)
+    return unless value.is_a?(Hash) && value[:objectType] == "StatementRef"
+
+    id = value[:id]
+    return if id.nil?
+
+    statement_row = RailsXapi::Statement.find_by(id: id)
+    self[:statement_ref] = statement_row.id if statement_row&.id.present?
+  end
+
+  def extensions=(extensions_data)
+    unless extensions_data.is_a?(Hash)
+      raise RailsXapi::Errors::XapiError,
+            I18n.t(
+              "rails_xapi.errors.attribute_must_be_a_hash",
+              name: "extensions"
+            )
+    end
+
+    extensions_data.each do |iri, data|
+      extensions.build(iri: iri, value: serialized_value(data))
+    end
+  end
+
+  def as_json
+    context_attributes = {}
+    context_attributes[:registration] = registration if registration.present?
+    context_attributes[:instructor] = instructor if instructor.present?
+    context_attributes[:team] = team if team.present?
+
+    if context_activities.present?
+      grouped = context_activities.group_by(&:activity_type)
+      # convert string keys to symbols
+      context_attributes[:contextActivities] = grouped
+        .transform_keys(&:to_sym)
+        .transform_values { |activities| activities.map(&:as_json) }
+    end
+
+    context_attributes[
+      :statement
+    ] = statement_ref.id if statement_ref&.id.present?
+
+    context_attributes
+  end
+
+  private
+
+  def find_or_create_actor_with_account(value, object_type = nil)
+    home_page = value.dig(:account, :homePage)
+    existing_account =
+      RailsXapi::Account.find_by(home_page: home_page) if home_page.present?
+
+    # Set the params to search an existing row.
+    actor_params = {
+      mbox: value[:mbox],
+      mbox_sha1sum: value[:mbox_sha1sum],
+      openid: value[:openid]
+    }
+    actor_params[:account] = existing_account if existing_account.present?
+
+    RailsXapi::Actor.find_or_create_by(actor_params) do |actor|
+      actor.name = value[:name] if value[:name].present?
+      actor.object_type = object_type if object_type.present?
+      actor.account = RailsXapi::Account.new(value[:account]) if value[
+        :account
+      ].present?
+    end
+  end
+
+  # The "platform" property MUST only be used if the Statement's Object is an Activity.
+  # See: https://github.com/adlnet/xAPI-Spec/blob/master/xAPI-Data.md#requirements-10
+  def validate_platform
+    ref_statement =
+      statement_ref ? RailsXapi::Statement.find_by(id: statement_ref) : nil
+
+    ref_statement ||= statement_ref
+
+    self[:platform] = nil if !ref_statement&.object&.activity?
+  end
+end
+
+# == Schema Information
+#
+# Table name: rails_xapi_contexts
+#
+#  id            :integer          not null, primary key
+#  language      :string
+#  platform      :string
+#  registration  :string
+#  revision      :string
+#  statement_ref :bigint
+#  instructor_id :bigint
+#  statement_id  :bigint           not null
+#  team_id       :bigint
+#
+# Indexes
+#
+#  index_rails_xapi_contexts_on_instructor_id  (instructor_id)
+#  index_rails_xapi_contexts_on_statement_id   (statement_id)
+#  index_rails_xapi_contexts_on_statement_ref  (statement_ref)
+#  index_rails_xapi_contexts_on_team_id        (team_id)
+#

data/app/models/rails_xapi/context_activity.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# The optional context activity.
+# See: https://github.com/adlnet/xAPI-Spec/blob/master/xAPI-Data.md#246-context
+class RailsXapi::ContextActivity < ApplicationRecord
+  belongs_to :context, class_name: "RailsXapi::Context"
+  belongs_to :object, class_name: "RailsXapi::Object"
+
+  validates :activity_type,
+            presence: true,
+            inclusion: {
+              in: %w[parent grouping category other]
+            }
+
+  def as_json
+    { id: object_id, objectType: object&.object_type }.tap do |hash|
+      hash[
+        :definition
+      ] = object&.definition&.as_json if object&.definition.present?
+    end
+  end
+end
+
+# == Schema Information
+#
+# Table name: rails_xapi_context_activities
+#
+#  id            :integer          not null, primary key
+#  activity_type :string           not null
+#  context_id    :bigint           not null
+#  object_id     :string           not null
+#
+# Indexes
+#
+#  index_rails_xapi_context_activities_on_context_id  (context_id)
+#  index_rails_xapi_context_activities_on_object_id   (object_id)
+#

data/app/models/rails_xapi/errors/xapi_error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class RailsXapi::Errors::XapiError < StandardError
+end

data/app/models/rails_xapi/extension.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# The object optional activity definition's extensions.
+# See: https://github.com/adlnet/xAPI-Spec/blob/master/xAPI-Data.md#41-extensions
+class RailsXapi::Extension < ApplicationRecord
+  belongs_to :extendable, polymorphic: true
+
+  validates :iri, presence: true
+  validates :value, presence: true
+
+  def as_json
+    { iri => value }.compact
+  end
+end
+
+# == Schema Information
+#
+# Table name: rails_xapi_extensions
+#
+#  id              :integer          not null, primary key
+#  extendable_type :string
+#  iri             :string           not null
+#  value           :text             not null
+#  extendable_id   :integer
+#
+# Indexes
+#
+#  index_rails_xapi_extensions_on_extendable  (extendable_type,extendable_id)
+#

data/app/models/rails_xapi/group_member.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class RailsXapi::GroupMember < ApplicationRecord
+  belongs_to :group, class_name: "RailsXapi::Actor", dependent: :destroy
+  belongs_to :actor, class_name: "RailsXapi::Actor", dependent: :destroy
+end
+
+# == Schema Information
+#
+# Table name: rails_xapi_group_members
+#
+#  id         :integer          not null, primary key
+#  created_at :datetime         not null
+#  actor_id   :bigint           not null
+#  group_id   :bigint           not null
+#
+# Indexes
+#
+#  index_rails_xapi_group_members_on_actor_id  (actor_id)
+#  index_rails_xapi_group_members_on_group_id  (group_id)
+#

data/app/models/rails_xapi/interaction_activity.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+# The optional structure for interactions or assessments.
+# See: https://github.com/adlnet/xAPI-Spec/blob/master/xAPI-Data.md#interaction-activities
+class RailsXapi::InteractionActivity < ApplicationRecord
+  belongs_to :activity_definition, class_name: "RailsXapi::ActivityDefinition"
+  has_many :interaction_components,
+           foreign_key: :interaction_activity_id,
+           dependent: :destroy
+
+  INTERACTION_COMPONENT_TYPES = %w[scale choices source target steps]
+  INTERACTION_KEYS =
+    %w[interactionType correctResponsesPattern] + INTERACTION_COMPONENT_TYPES
+
+  validates :interaction_type,
+            presence: true,
+            inclusion: {
+              in: %w[
+                true-false
+                choice
+                fill-in
+                long-fill-in
+                matching
+                performance
+                sequencing
+                likert
+                numeric
+                other
+              ]
+            }
+
+  attribute :correct_responses_pattern, :string, default: -> { [].to_json }
+
+  def assign_interaction_components(interaction_attrs)
+    return unless interaction_attrs.present?
+
+    interaction_components.where(
+      component_type: INTERACTION_COMPONENT_TYPES
+    ).destroy_all
+
+    INTERACTION_COMPONENT_TYPES.each do |component_type|
+      Array(interaction_attrs[component_type]).each do |data|
+        interaction_components.build(
+          component_type: component_type,
+          component_id: data["id"],
+          description: data["description"].to_json,
+          interaction_activity: self
+        )
+      end
+    end
+  end
+
+  def correct_responses_pattern
+    JSON.parse(super || "[]")
+  end
+
+  def correct_responses_pattern=(value)
+    super(value.to_json)
+  end
+
+  def components_by_interaction_type
+    case interaction_type
+    when "likert"
+      { "scale" => component_hash }
+    when "choice"
+      { "choice" => component_hash }
+    else
+      {}
+    end
+  end
+
+  def as_json
+    {
+      interactionType: interaction_type,
+      correctResponsesPattern: correct_responses_pattern
+    }.merge(components_by_interaction_type)
+  end
+
+  private
+
+  def component_hash
+    interaction_components.map do |component|
+      {
+        "id" => component.component_id,
+        "description" => component.parsed_description
+      }
+    end
+  end
+end
+
+# == Schema Information
+#
+# Table name: rails_xapi_interaction_activities
+#
+#  id                        :integer          not null, primary key
+#  correct_responses_pattern :text
+#  interaction_type          :string           not null
+#  activity_definition_id    :bigint           not null
+#
+# Indexes
+#
+#  idx_on_activity_definition_id_0cc615114b  (activity_definition_id)
+#

data/app/models/rails_xapi/interaction_component.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# The optional structure for interactions or assessments.
+# See: https://github.com/adlnet/xAPI-Spec/blob/master/xAPI-Data.md#interaction-components
+class RailsXapi::InteractionComponent < ApplicationRecord
+  belongs_to :interaction_activity, class_name: "RailsXapi::InteractionActivity"
+
+  validates_with RailsXapi::Validators::LanguageMapValidator,
+                 attributes: %i[description]
+
+  def parsed_description
+    return {} unless description.present?
+    begin
+      JSON.parse(description)
+    rescue StandardError
+      {}
+    end
+  end
+end
+
+# == Schema Information
+#
+# Table name: rails_xapi_interaction_components
+#
+#  id                      :integer          not null, primary key
+#  component_type          :string           not null
+#  description             :text
+#  component_id            :string           not null
+#  interaction_activity_id :bigint           not null
+#
+# Indexes
+#
+#  idx_on_interaction_activity_id_863e21bede  (interaction_activity_id)
+#

data/app/models/rails_xapi/object.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+# The Object defines the thing that was acted on.
+# See: https://github.com/adlnet/xAPI-Spec/blob/master/xAPI-Data.md#244-object
+# The Object of a Statement can be an Activity, Agent/Group, SubStatement, or Statement Reference.
+class RailsXapi::Object < ApplicationRecord
+  OBJECT_TYPES = %w[Activity Agent Group SubStatement StatementRef]
+
+  attr_accessor :objectType,
+                :actor,
+                :verb,
+                :object,
+                :result,
+                :context,
+                :timestamp
+
+  has_one :definition,
+          class_name: "RailsXapi::ActivityDefinition",
+          dependent: :destroy
+  has_many :statements, class_name: "RailsXapi::Statement", dependent: :nullify
+  belongs_to :statement, class_name: "RailsXapi::Statement", optional: true
+
+  validates :id, presence: true
+  validates :object_type, presence: true, inclusion: { in: OBJECT_TYPES }
+  validates :statement, presence: true, if: -> { object_type == "SubStatement" }
+  validates :actor, presence: true, if: -> { object_type == "SubStatement" }
+  validates :object, presence: true, if: -> { object_type == "SubStatement" }
+  validates :verb, presence: true, if: -> { object_type == "SubStatement" }
+
+  before_validation :set_defaults, :create_statement_for_substatement
+
+  accepts_nested_attributes_for :definition
+
+  def definition=(definition_hash)
+    return unless definition_hash.present?
+
+    # Build or create the associated object.
+    build_definition if definition.nil?
+    definition.assign_from_json_definition(definition_hash)
+  end
+
+  # Find an Object by its id or create a new one.
+  #
+  # @param [Hash] attributes The attributes of the requested object.
+  # @return [RailsXapi::Object] The found or created object.
+  def self.find_or_create(attributes)
+    find_by(id: attributes[:id]) || create(attributes)
+  end
+
+  # Update the ActivityDefinition if it's existing.
+  def update_definition(definition_data)
+    return unless definition_data.present?
+
+    definition = self.definition || create_definition
+    definition.assign_from_json_definition(definition_data)
+    definition.save!
+  end
+
+  def activity?
+    return true if object_type == "Activity"
+
+    false
+  end
+
+  def as_json
+    { id: id, objectType: object_type }.tap do |hash|
+      hash[:definition] = definition.as_json if definition.present?
+    end
+  end
+
+  private
+
+  def set_defaults
+    self.object_type ||= objectType.presence || "Activity"
+
+    if new_record? && object_type == "SubStatement"
+      self.actor = actor
+      self.verb = verb
+      self.object = object
+      self.result = result
+      self.context = context
+      self.timestamp = timestamp
+    end
+  end
+
+  def create_statement_for_substatement
+    return unless object_type == "SubStatement" && statement.nil?
+
+    # Generate a random primary key in place of the object ID
+    self.id = Digest::SHA1.hexdigest([Time.zone.now, rand(111..999)].join)
+
+    # Then, create the substatement
+    substatement_actor = create_or_find_actor
+    substatement_verb = create_or_find_verb
+    substatement_object = create_or_find_object
+    substatement_result = create_result
+    substatement_context = create_context
+
+    self.statement =
+      RailsXapi::Statement.create!(
+        actor: substatement_actor,
+        verb: substatement_verb,
+        object: substatement_object,
+        result: substatement_result,
+        context: substatement_context,
+        timestamp: timestamp
+      )
+  end
+
+  def create_or_find_actor
+    if actor.blank?
+      raise RailsXapi::Errors::XapiError,
+            I18n.t("rails_xapi.errors.missing_actor")
+    end
+
+    RailsXapi::Actor.by_iri_or_create(actor)
+  end
+
+  def create_or_find_verb
+    RailsXapi::Verb.find_or_create_by(id: verb[:id]) { |v| v.attributes = verb }
+  end
+
+  def create_or_find_object
+    RailsXapi::Object.find_or_create_by(id: object[:id]) do |o|
+      o.attributes = object
+    end
+  end
+
+  def create_result
+    RailsXapi::Result.new(result) if result.present?
+  end
+
+  def create_context
+    RailsXapi::Context.new(context)
+  end
+end
+
+# == Schema Information
+#
+# Table name: rails_xapi_objects
+#
+#  id           :string           not null, primary key
+#  object_type  :string           not null
+#  statement_id :bigint
+#
+# Indexes
+#
+#  index_rails_xapi_objects_on_id            (id) UNIQUE
+#  index_rails_xapi_objects_on_statement_id  (statement_id)
+#