rails-xapi 0.1.2

data/app/services/rails_xapi/query.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+# This class manages the query interface for verbs.
+class RailsXapi::Query < ApplicationService
+  def initialize(query:, args: [])
+    @query = query
+    @args = args
+  end
+
+  def self.call(query:, args: [])
+    new(query: query, args: args).call
+  end
+
+  def call
+    if respond_to?(@query, true)
+      send(@query, *@args)
+    else
+      raise RailsXapi::Errors::XapiError,
+            I18n.t("rails_xapi.errors.query_not_available")
+    end
+  end
+
+  private
+
+  # @param id [Integer] The ID of the statement
+  # @return [RailsXapi::Statement] The statement record
+  def statement(id)
+    RailsXapi::Statement.find(id)
+  end
+
+  # Get a hash of all statements concerning the actors emails and object_id.
+  #
+  # @param object_id [String] The object IRI
+  # @param actor_emails [Array<String>] List of actor emails
+  # @return [ActiveRecord::Relation] Statements matching criteria
+  # @raise [ArgumentError] If no emails provided
+  def statements_by_object_and_actors(object_id, actor_emails = [])
+    if actor_emails.empty?
+      raise ArgumentError, I18n.t("rails_xapi.errors.no_emails_provided")
+    end
+
+    mailto_emails =
+      actor_emails.map do |email|
+        # Validate each email using RailsXapi::Actor's validation method
+        email if RailsXapi::Actor.new(mbox: email).validate_mbox
+      end
+
+    RailsXapi::Statement.where(
+      actor: {
+        mbox: mailto_emails
+      },
+      object: {
+        id: object_id
+      }
+    )
+  end
+
+  # Query statements by actor's email
+  #
+  # @param actor_email [String] Actor email address
+  # @return [ActiveRecord::Relation] Statements from this actor
+  # @raise [ArgumentError] If email format is invalid
+  def actor_by_email(actor_email)
+    if actor_email.start_with?("mailto:")
+      mbox_value = actor_email
+    else
+      mbox_value = "mailto:#{actor_email}"
+    end
+
+    # Validate email using RailsXapi::Actor's validation method
+    RailsXapi::Actor.new(mbox: mbox_value).validate_mbox
+
+    RailsXapi::Statement.where(actor: { mbox: mbox_value })
+  end
+
+  # Query statements by actor's mbox
+  #
+  # @param actor_mbox [String] mbox (e.g., "mailto:user@example.com")
+  # @return [ActiveRecord::Relation] Statements for this mbox
+  # @raise [ArgumentError] If mbox format is invalid
+  def actor_by_mbox(actor_mbox)
+    unless actor_mbox.match?(
+             /\Amailto:([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/
+           )
+      raise ArgumentError,
+            I18n.t("rails_xapi.errors.malformed_mbox", name: actor_mbox)
+    end
+
+    RailsXapi::Statement.where(actor: { mbox: actor_mbox })
+  end
+
+  # Query statements by actor's account homepage
+  #
+  # @param actor_account_homepage [String] Account homepage URL
+  # @return [ActiveRecord::Relation] Statements for this account
+  def actor_by_account_homepage(actor_account_homepage)
+    RailsXapi::Statement.where(
+      actor: {
+        account: {
+          home_page: actor_account_homepage
+        }
+      }
+    )
+  end
+
+  # Query statements by actor's openid
+  #
+  # @param actor_openid [String] The openID
+  # @return [ActiveRecord::Relation] Statements for this openID
+  def actor_by_openid(actor_openid)
+    RailsXapi::Statement.where(actor: { openid: actor_openid })
+  end
+
+  # Query statements by actor's mbox_sha1sum
+  #
+  # @param actor_mbox_sha1sum [String] SHA1 hash of actor's mbox
+  # @return [ActiveRecord::Relation] Statements for this mbox_sha1sum identifier
+  def actor_by_mbox_sha1sum(actor_mbox_sha1sum)
+    RailsXapi::Statement.where(actor: { mbox_sha1sum: actor_mbox_sha1sum })
+  end
+
+  # Query statements by actor's identifier per month
+  #
+  # @param actor_identifier [Hash] One key-value pair representing the identifier
+  # @param year [Integer] Year (defaults to current)
+  # @param month [Integer] Month (defaults to current)
+  # @return [ActiveRecord::Relation] Statements in the given month
+  # @raise [ArgumentError] If identifier is empty
+  def user_statements_per_month(
+    actor_identifier = {},
+    year = Date.current.year,
+    month = Date.current.month
+  )
+    if actor_identifier.first.empty?
+      raise ArgumentError,
+            I18n.t(
+              "rails_xapi.errors.exactly_one_actor_identifier_must_be_provided"
+            )
+    end
+
+    identifier_key, identifier_value = actor_identifier.first
+    start_date, end_date =
+      self.class.send(:generate_start_date_end_date, year, month)
+    RailsXapi::Statement
+      .joins(:actor)
+      .where(
+        actor: {
+          identifier_key => identifier_value
+        },
+        created_at: start_date..end_date
+      )
+      .group(:id)
+  end
+
+  # Get a list of all unique verb_id values
+  #
+  # @return [Array<Integer>] Unique verb IDs
+  def verb_ids
+    RailsXapi::Verb.pluck(:id)
+  end
+
+  # Get a list of all unique verb_display values
+  #
+  # @return [Array<String>] Unique verb display values
+  def verb_displays
+    RailsXapi::Verb.pluck(:display)
+  end
+
+  # Get a hash of all unique verbs with verb_id as keys and verb_display as values.
+  #
+  # @return [Hash{Integer => String}] verb_id => verb_display mapping
+  def verbs
+    RailsXapi::Verb.pluck(:id, :display)
+  end
+
+  # Take a collection of records and generate a number of records created each day of the given month
+  #
+  # @param resources [ActiveRecord::Relation] Statement records
+  # @param year [Integer] Year for filtering
+  # @param month [Integer] Month for filtering
+  # @return [ActiveRecord::Relation] Grouped statements by date
+  def per_month(resources, year = Date.current.year, month = Date.current.month)
+    start_date, end_date =
+      self.class.send(:generate_start_date_end_date, year, month)
+    resources.where(
+      "rails_xapi_statements.created_at": start_date..end_date
+    ).group("DATE(rails_xapi_statements.created_at)")
+  end
+
+  # @param data [Array<RailsXapi::Statement>] Statement list
+  # @param year [Integer] Year for generating the range
+  # @param month [Integer] Month for generating the range
+  # @return [Array<Hash>] Array of date/count pairs
+  def month_graph_data(
+    statements,
+    year = Date.current.year,
+    month = Date.current.month
+  )
+    start_date, end_date =
+      self.class.send(:generate_start_date_end_date, year, month)
+    month_dates = (start_date..end_date).to_a
+
+    # Create a hash with default value 0 for each date of the current month
+    complete_data = month_dates.index_with { 0 }
+
+    # Transform data to count occurrences for each date
+    data_by_date =
+      statements
+        .group_by { |statement| statement.created_at.to_date }
+        .transform_values(&:count)
+
+    # Merge the existing data with the complete data and format
+    complete_data
+      .merge(data_by_date)
+      .map { |date, count| { date: date.strftime("%Y-%m-%d"), value: count } }
+  end
+end

data/app/services/rails_xapi/statement_creator.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+class RailsXapi::StatementCreator < ApplicationService
+  def initialize(data, actor = {}, opts = {})
+    @data = data
+    @actor = actor
+    @opts = opts
+  end
+
+  def self.create(data, actor = {}, opts = {})
+    s = RailsXapi::StatementCreator.new(data, actor, opts).prepare_statement
+    # Use a job for asynchronous calls
+    return RailsXapi::CreateStatementJob.perform_now(s) if opts[:async]
+
+    s.save
+    { status: 200, statement: s }
+  end
+
+  def prepare_statement
+    actor =
+      RailsXapi::Actor.build_actor_from_data(@actor.presence || @data[:actor])
+
+    verb =
+      RailsXapi::Verb.find_or_create_by(id: @data[:verb][:id]) do |v|
+        v.display = @data[:verb][:display]
+      end
+
+    object = RailsXapi::Object.find_or_create(@data[:object])
+    object.update_definition(@data[:object][:definition])
+
+    result = RailsXapi::Result.new(@data[:result]) if @data[:result].present?
+    context = RailsXapi::Context.new(@data[:context]) if @data[
+      :context
+    ].present?
+
+    # Create the statement with the associated properties
+    statement =
+      RailsXapi::Statement.new(
+        actor: actor,
+        verb: verb,
+        object: object,
+        result: result,
+        context: context,
+        timestamp: @data[:timestamp].presence || Time.zone.now
+      )
+    unless statement.valid?
+      raise RailsXapi::Errors::XapiError,
+            statement.errors.full_messages.join(", ")
+    end
+
+    statement
+  end
+end

data/app/views/layouts/rails_xapi/application.html.erb

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Rails xAPI</title>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+  <%= stylesheet_link_tag "rails_xapi/application", media: "all" %>
+</head>
+<body>
+<%= yield %>
+</body>
+</html>

data/config/locales/rails_xapi.en.yml

@@ -0,0 +1,43 @@
+en:
+  rails_xapi:
+    errors:
+      actor_ifi_must_be_present: "at least one of mbox, mbox_sha1sum, openid, or account must be present"
+      attribute_must_be_a_hash: "attribute %{name} must be a hash"
+      attribute_must_be_a_valid_language_map: "attribute %{name} must be a language map"
+      couldnt_create_the_substatement: "couldn’t create the substatement"
+      definition_description_invalid_keys: "invalid keys in definition description: %{values}"
+      definition_description_must_be_language_map: "definition description must be a language map"
+      exactly_one_actor_identifier_must_be_provided: "exactly one actor identifier must be provided"
+      expected_hash: "expected Hash, got %{type}"
+      failed_to_create_member: "failed to create member: #{member}"
+      invalid_actor: "invalid actor"
+      invalid_actor_object_type: "invalid actor's object type: %{name}"
+      invalid_json: "invalid JSON"
+      invalid_object_object_type: "invalid object's object type: %{name}"
+      invalid_object_substatement: "invalid object substatement"
+      invalid_score_value: "invalid score value: %{value}"
+      invalid_verb_id_url: "verb_id is not a valid URL"
+      malformed_account_home_page_url: "malformed account home_page URL: %{url}"
+      malformed_email: "malformed email value: %{name}"
+      malformed_mbox: "malformed mbox value: %{name}"
+      malformed_mbox_sha1sum: "malformed mbox_sha1sum value"
+      malformed_openid_uri: "malformed openid URI: %{uri}"
+      malformed_uri: "malformed URI: %{uri}"
+      missing_actor: "missing actor in the statemement"
+      missing_object: "missing object in the statemement: %{name}"
+      missing_object_keys: "missing object keys: %{keys}"
+      missing_result_keys: "missing result keys: %{keys}"
+      missing_values_or_invalid_type: "missing values or invalid type %{values}"
+      missing_verb_display: "missing verb display"
+      must_be_a_valid_iri: "must be a valid IRI"
+      no_emails_provided: "no emails provided"
+      query_not_available: "query is not available"
+      unexpected_substatement_object_keys: "unexpected substatement object keys: %{keys}"
+      value_must_not_be_nil: "value must not be null for the key: %{name}"
+      wrong_attribute_type: "wrong attribute type for %{name}: %{value}"
+    validations:
+      score:
+        min: "min must be a decimal number lower than max"
+        raw: "raw must be a decimal between min and max inclusive"
+        scaled: "scaled must be a decimal number between -1 and 1 inclusive"
+    xapi_statement: "xAPI statement"

data/config/locales/rails_xapi.fr.yml

@@ -0,0 +1,233 @@
+fr:
+  rails_xapi:
+    errors:
+      actor_ifi_must_be_present: "au moins mbox, mbox_sha1sum, openid, ou account doit être présent"
+      attribute_must_be_a_hash: "l'attribut %{name} doit être un hash"
+      attribute_must_be_a_valid_language_map: "l'attribut %{name} doit être un language map"
+      couldnt_create_the_substatement: "la sous-déclaration n'a pas pu être créée"
+      definition_description_invalid_keys: "clés incorrectes dans la description de définition : %{values}"
+      definition_description_must_be_language_map: "la description de définitionde doit être de type language map"
+      exactly_one_actor_identifier_must_be_provided: "exactement un identifiant d'acteur doit être fourni"
+      expected_hash: "attendu Hash, fourni %{type}"
+      failed_to_create_member: "échec de création d'un membre : #{member}"
+      invalid_actor: "acteur invalide"
+      invalid_actor_object_type: "type d'objet de l'acteur incorrect : %{name}"
+      invalid_json: "JSON non valide"
+      invalid_object_object_type: "type d'objet de l'objet incorrect : %{name}"
+      invalid_object_substatement: "sous-déclaration d'objet incorrecte"
+      invalid_score_value: "valeur de score incorrecte : %{value}"
+      invalid_verb_id_url: "verb_id n'est pas une URL valide"
+      malformed_account_home_page_url: "home_page URL du compte malformée : %{url}"
+      malformed_email: "valeur email malformée : %{name}"
+      malformed_mbox: "valeur mbox malformée : %{name}"
+      malformed_mbox_sha1sum: "valeur mbox_sha1sum malformée"
+      malformed_openid_uri: "valeur openid URI malformée : %{uri}"
+      malformed_uri: "URI malformée : %{uri}"
+      missing_actor: "acteur manquant dans la déclaration"
+      missing_object: "objet manquant dans la déclaration : %{name}"
+      missing_object_keys: "clés d'objet manquantes : %{keys}"
+      missing_result_keys: "clés de résultat manquantes : %{keys}"
+      missing_values_or_invalid_type: "valeurs manquantes ou invalides : %{values}"
+      missing_verb_display: "verb display manquant"
+      must_be_a_valid_iri: "doit être un IRI valide"
+      no_emails_provided: "aucun email fourni"
+      query_not_available: "query is not available"
+      unexpected_substatement_object_keys: "clés d'objet de sous-déclaration inattendues : %{keys}"
+      value_must_not_be_nil: "la valeur ne peut être nulle pour la clé : %{name}"
+      wrong_attribute_type: "type d'attribut incorrect pour %{name} : %{value}"
+    validations:
+      score:
+        min: "min doit être un nombre décimal inférieur à max"
+        raw: "raw doit être un nombre décimal compris entre min et max inclus"
+        scaled: "scaled doit être un nombre décimal compris entre -1 and 1 inclus"
+    xapi_statement: "déclaration xAPI"
+  xapi:
+    activity: "activité"
+    "activity definition": "définition d'activité"
+    actor: "acteur"
+    agent: "agent"
+    context: "contexte"
+    context_registration: "enregistrement"
+    context_parent: "parent"
+    context_category: "catégorie"
+    context_other: "autre"
+    group: "groupe"
+    object: "objet"
+    result: "résultat"
+    statement: "déclaration"
+    substatement: "sous-déclaration"
+    verb: "verbe"
+    verbs:
+      "accepted": "accepté"
+      "accessed": "accédé"
+      "acknowledged": "reconnu"
+      "added": "ajouté"
+      "agreed": "accepté"
+      "appended": "ajouté"
+      "approved": "approuvé"
+      "archived": "archivé"
+      "assigned": "assigné"
+      "was at": "était à"
+      "attached": "attaché"
+      "attended": "assisté"
+      "authored": "rédigé"
+      "authorized": "autorisé"
+      "borrowed": "emprunté"
+      "built": "construit"
+      "canceled": "annulé"
+      "checked in": "enregistré"
+      "closed": "fermé"
+      "completed": "complété"
+      "confirmed": "confirmé"
+      "consumed": "consommé"
+      "created": "créé"
+      "deleted": "supprimé"
+      "delivered": "livré"
+      "denied": "refusé"
+      "disagreed": "désaccordé"
+      "disliked": "pas aimé"
+      "experienced": "expérimenté"
+      "favorited": "mis en favori"
+      "found": "trouvé"
+      "flagged as inappropriate": "signalé comme inapproprié"
+      "followed": "suivi"
+      "gave": "donné"
+      "hosted": "organisé"
+      "ignored": "ignoré"
+      "inserted": "inséré"
+      "installed": "installé"
+      "interacted": "interagi"
+      "invited": "invité"
+      "joined": "rejoint"
+      "left": "quitté"
+      "liked": "aimé"
+      "listened": "écouté"
+      "lost": "perdu"
+      "made friend": "fait ami"
+      "opened": "ouvert"
+      "played": "joué"
+      "presented": "présenté"
+      "purchased": "acheté"
+      "qualified": "qualifié"
+      "read": "lu"
+      "received": "reçu"
+      "rejected": "rejeté"
+      "removed": "retiré"
+      "removed friend": "retiré ami"
+      "replaced": "remplacé"
+      "requested": "demandé"
+      "requested friend": "demandé en ami"
+      "resolved": "résolu"
+      "retracted": "rétracté"
+      "returned": "retourné"
+      "RSVPed maybe": "répondu peut-être"
+      "rsvped no": "répondu non"
+      "rsvped yes": "répondu oui"
+      "satisfied": "satisfait"
+      "saved": "enregistré"
+      "scheduled": "planifié"
+      "searched": "recherché"
+      "sold": "vendu"
+      "sent": "envoyé"
+      "shared": "partagé"
+      "sponsored": "sponsorisé"
+      "started": "commencé"
+      "stopped following": "arrêté de suivre"
+      "submitted": "soumis"
+      "tagged": "étiqueté"
+      "terminated": "terminé"
+      "tied": "lié"
+      "unfavorited": "retiré des favoris"
+      "unliked": "désaimé"
+      "unsatisfied": "insatisfait"
+      "unsaved": "non enregistré"
+      "unshared": "non partagé"
+      "updated": "mis à jour"
+      "used": "utilisé"
+      "watched": "regardé"
+      "won": "gagné"
+      "answered": "répondu"
+      "asked": "demandé"
+      "attempted": "tenté"
+      "commented": "commenté"
+      "exited": "sorti"
+      "failed": "échoué"
+      "imported": "importé"
+      "initialized": "initialisé"
+      "launched": "lancé"
+      "mastered": "maîtrisé"
+      "passed": "réussi"
+      "preferred": "préféré"
+      "progressed": "progressé"
+      "registered": "enregistré"
+      "responded": "répondu"
+      "resumed": "repris"
+      "scored": "noté"
+      "suspended": "suspendu"
+      "voided": "annulé"
+      "edited": "édité"
+      "voted down (with reason)": "voté contre (avec raison)"
+      "voted up (with reason)": "voté pour (avec raison)"
+      "pressed": "pressé"
+      "released": "relâché"
+      "adjourned": "ajourné"
+      "applauded": "applaudi"
+      "arranged": "organisé"
+      "bookmarked": "mis en favori"
+      "called": "appelé"
+      "closed sale": "vente conclue"
+      "created opportunity": "créé une opportunité"
+      "defined": "défini"
+      "disabled": "désactivé"
+      "discarded": "jeté"
+      "downloaded": "téléchargé"
+      "earned": "gagné"
+      "enabled": "activé"
+      "estimated the duration": "estimé la durée"
+      "expected": "attendu"
+      "expired": "expiré"
+      "focused": "concentré"
+      "entered frame": "entré dans le cadre"
+      "exited frame": "sorti du cadre"
+      "hired": "embauché"
+      "interviewed": "interviewé"
+      "laughed": "ri"
+      "unread": "non lu"
+      "mentioned": "mentionné"
+      "mentored": "mentoré"
+      "paused": "mis en pause"
+      "performed": "effectué"
+      "personalized": "personnalisé"
+      "previewed": "prévisualisé"
+      "promoted": "promu"
+      "rated": "évalué"
+      "replied": "répondu"
+      "replied to tweet": "a répondu au tweet"
+      "requested attention": "a demandé de l'attention"
+      "retweeted": "retweeté"
+      "reviewed": "révisé"
+      "secured": "sécurisé"
+      "selected": "sélectionné"
+      "skipped": "passé"
+      "talked": "parlé"
+      "terminated employment with": "terminé l'emploi avec"
+      "tweeted": "tweeté"
+      "unfocused": "détourné"
+      "unregistered": "désinscrit"
+      "viewed": "vu"
+      "down voted": "voté contre"
+      "up voted": "voté pour"
+      "was assigned job title": "a reçu le titre de poste"
+      "was hired by": "a été embauché par"
+      "annotated": "annoté"
+      "modified annotation": "annotation modifiée"
+      "earned an Open Badge": "gagné un Open Badge"
+      "drew": "dessiné"
+      "cancelled planned learning": "a annulé l'apprentissage planifié"
+      "planned": "planifié"
+      "enrolled onto learning plan": "inscrit au plan d'apprentissage"
+      "evaluated": "évalué"
+      "log in": "connecté"
+      "log out": "déconnecté"
+      "ran": "couru"
+      "walked": "marché"

data/config/routes.rb

@@ -0,0 +1,2 @@
+RailsXapi::Engine.routes.draw do
+end

data/db/migrate/20240716144226_create_rails_xapi_actors.rb

@@ -0,0 +1,16 @@
+class CreateRailsXapiActors < ActiveRecord::Migration[7.1]
+  def up
+    create_table :rails_xapi_actors do |t|
+      t.string :object_type, null: true
+      t.string :name, null: true
+      t.string :mbox, null: true
+      t.string :mbox_sha1sum, null: true
+      t.string :openid, null: true
+      t.datetime :created_at, null: false
+    end
+  end
+
+  def down
+    drop_table :rails_xapi_actors
+  end
+end

data/db/migrate/20240716144227_create_rails_xapi_accounts.rb

@@ -0,0 +1,15 @@
+class CreateRailsXapiAccounts < ActiveRecord::Migration[7.1]
+  def up
+    create_table :rails_xapi_accounts do |t|
+      t.string :name, null: false
+      t.string :home_page, null: false
+      t.bigint :actor_id, null: false
+    end
+
+    add_index :rails_xapi_accounts, :actor_id
+  end
+
+  def down
+    drop_table :rails_xapi_accounts
+  end
+end

data/db/migrate/20240716144228_create_rails_xapi_verbs.rb

@@ -0,0 +1,14 @@
+class CreateRailsXapiVerbs < ActiveRecord::Migration[7.1]
+  def up
+    create_table :rails_xapi_verbs, id: false do |t|
+      t.string :id, null: false, primary_key: true
+      t.string :display, null: true
+    end
+
+    add_index :rails_xapi_verbs, :id, unique: true
+  end
+
+  def down
+    drop_table :rails_xapi_verbs
+  end
+end

data/db/migrate/20240716144229_create_rails_xapi_objects.rb

@@ -0,0 +1,16 @@
+class CreateRailsXapiObjects < ActiveRecord::Migration[7.1]
+  def up
+    create_table :rails_xapi_objects, id: false do |t|
+      t.string :id, null: false, primary_key: true
+      t.string :object_type, null: false
+      t.bigint :statement_id, null: true
+    end
+
+    add_index :rails_xapi_objects, :id, unique: true
+    add_index :rails_xapi_objects, :statement_id
+  end
+
+  def down
+    drop_table :rails_xapi_objects
+  end
+end

data/db/migrate/20240716144230_create_rails_xapi_activity_definitions.rb

@@ -0,0 +1,17 @@
+class CreateRailsXapiActivityDefinitions < ActiveRecord::Migration[7.1]
+  def up
+    create_table :rails_xapi_activity_definitions do |t|
+      t.string :name, null: true
+      t.text :description, null: true
+      t.string :activity_type, null: true
+      t.text :more_info, null: true
+      t.string :object_id, null: false
+    end
+
+    add_index :rails_xapi_activity_definitions, :object_id
+  end
+
+  def down
+    drop_table :rails_xapi_activity_definitions
+  end
+end

data/db/migrate/20240716144231_create_rails_xapi_extensions.rb

@@ -0,0 +1,13 @@
+class CreateRailsXapiExtensions < ActiveRecord::Migration[7.1]
+  def up
+    create_table :rails_xapi_extensions do |t|
+      t.string :iri, null: false
+      t.text :value, null: false
+      t.references :extendable, polymorphic: true
+    end
+  end
+
+  def down
+    drop_table :rails_xapi_extensions
+  end
+end

data/db/migrate/20240716144232_create_rails_xapi_statements.rb

@@ -0,0 +1,19 @@
+class CreateRailsXapiStatements < ActiveRecord::Migration[7.1]
+  def up
+    create_table :rails_xapi_statements do |t|
+      t.string :actor_id, null: false
+      t.string :verb_id, null: false
+      t.string :object_id, null: false
+      t.datetime :timestamp, null: true
+      t.datetime :created_at, null: false
+    end
+
+    add_index :rails_xapi_statements, :actor_id
+    add_index :rails_xapi_statements, :verb_id
+    add_index :rails_xapi_statements, :object_id
+  end
+
+  def down
+    drop_table :rails_xapi_statements
+  end
+end