rails-xapi 0.1.2

data/app/models/rails_xapi/result.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+# Represents a result containing response, success, and score data.
+class RailsXapi::Result < ApplicationRecord
+  require "active_support/duration"
+  require "uri"
+  include Serializable
+
+  belongs_to :statement, class_name: "RailsXapi::Statement", dependent: :destroy
+  has_many :extensions, as: :extendable, dependent: :destroy
+
+  attr_reader :duration_in_seconds
+
+  validates :score_scaled,
+            numericality: {
+              greater_than_or_equal_to: -1,
+              less_than_or_equal_to: 1
+            },
+            allow_nil: true
+  validate :completion_attribute_must_be_boolean, if: -> { completion.present? }
+  validate :success_attribute_must_be_boolean, if: -> { success.present? }
+  validate :correct_duration, if: -> { duration.present? }
+
+  before_validation :calculate_scaled
+
+  # Store the score object in the results table for convenience reasons.
+  #
+  # @param [Hash] value The result hash values.
+  def score=(value)
+    validate_score(value)
+
+    self.score_scaled = value[:scaled]
+    self.score_raw = value[:raw]
+    self.score_min = value[:min]
+    self.score_max = value[:max]
+  end
+
+  def score
+    {
+      scaled: score_scaled,
+      raw: score_raw,
+      min: score_min,
+      max: score_max
+    }.compact
+  end
+
+  # Transform a duration in seconds into a ISO 8601 string.
+  # This is an optional attribute meant to bring more convenience for some systems.
+  #
+  # @param [String|Number] value The duration in seconds.
+  def duration_in_seconds=(value)
+    self.duration =
+      ActiveSupport::Duration.build(value).iso8601 if value.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
+
+  private
+
+  # Validations in regard to the score
+  # See: https://github.com/adlnet/xAPI-Spec/blob/master/xAPI-Data.md#2451-score
+  #
+  # @param [Hash] value The result's score hash values.
+  def validate_score(value)
+    if value[:scaled].present? && !value[:scaled]&.between?(-1, 1)
+      raise RailsXapi::Errors::XapiError,
+            I18n.t(
+              "rails_xapi.errors.invalid_score_value",
+              value: I18n.t("rails_xapi.validations.score.scaled")
+            )
+    end
+
+    min_value = value[:min].to_i if value[:min].present?
+    max_value = value[:max].to_i if value[:max].present?
+
+    if value[:raw].present? &&
+         !value[:raw]&.between?(
+           min_value || -Float::INFINITY,
+           max_value || Float::INFINITY
+         )
+      raise RailsXapi::Errors::XapiError,
+            I18n.t(
+              "rails_xapi.errors.invalid_score_value",
+              value: I18n.t("rails_xapi.validations.score.raw")
+            )
+    end
+
+    if max_value.present? && min_value && min_value >= max_value
+      raise RailsXapi::Errors::XapiError,
+            I18n.t(
+              "rails_xapi.errors.invalid_score_value",
+              value: I18n.t("rails_xapi.validations.score.min")
+            )
+    end
+  end
+
+  # Validates the duration accordign to the specifications.
+  # See: https://github.com/adlnet/xAPI-Spec/blob/master/xAPI-Data.md#46-iso-8601-durations
+  #
+  # @param [String] duration The duration string to validate.
+  # @return [ActiveSupport::Duration::ISO8601Parser::ParsingError] If invalid string is provided.
+  def correct_duration
+    ActiveSupport::Duration.parse(duration) if duration.present?
+  end
+
+  def completion_attribute_must_be_boolean
+    unless [true, false].include?(completion)
+      raise RailsXapi::Errors::XapiError,
+            I18n.t(
+              "rails_xapi.errors.invalid_score_value",
+              value:
+                I18n.t(
+                  "rails_xapi.errors.wrong_attribute_type",
+                  name: "completion",
+                  value: completion
+                )
+            )
+    end
+  end
+
+  def success_attribute_must_be_boolean
+    unless [true, false].include?(success)
+      raise RailsXapi::Errors::XapiError,
+            I18n.t(
+              "rails_xapi.errors.invalid_score_value",
+              value:
+                I18n.t(
+                  "rails_xapi.errors.wrong_attribute_type",
+                  name: "success",
+                  value: success
+                )
+            )
+    end
+  end
+
+  # Automatically set a score_scaled if not provided.
+  def calculate_scaled
+    return if score_scaled.present? || score_max.blank? || score_raw.blank?
+
+    self.score_scaled = (score_raw.to_f / score_max.to_f)
+  end
+end
+
+# == Schema Information
+#
+# Table name: rails_xapi_results
+#
+#  id           :integer          not null, primary key
+#  completion   :boolean          default(FALSE)
+#  duration     :string
+#  response     :text
+#  score_max    :integer
+#  score_min    :integer
+#  score_raw    :integer
+#  score_scaled :decimal(3, 2)
+#  success      :boolean          default(FALSE)
+#  statement_id :bigint           not null
+#
+# Indexes
+#
+#  index_rails_xapi_results_on_statement_id  (statement_id)
+#

data/app/models/rails_xapi/statement.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# Statements are the evidence for any sort of experience or event which is to be tracked in xAPI.
+# See: https://github.com/adlnet/xAPI-Spec/blob/master/xAPI-Data.md#20-statements
+class RailsXapi::Statement < ApplicationRecord
+  belongs_to :actor, class_name: "RailsXapi::Actor"
+  belongs_to :verb, class_name: "RailsXapi::Verb"
+  belongs_to :object, class_name: "RailsXapi::Object"
+  has_one :result, class_name: "RailsXapi::Result", dependent: :destroy
+  has_one :context, class_name: "RailsXapi::Context", dependent: :destroy
+
+  validate :actor_valid
+  validate :verb_valid
+  validate :object_valid
+
+  default_scope do
+    includes([:actor, { actor: :account }, :verb, :object, :context, :result])
+  end
+
+  def as_json
+    {
+      actor: actor.as_json,
+      verb: verb.as_json,
+      object: object.as_json
+    }.tap do |hash|
+      hash[:result] = result.as_json if result.present?
+      hash[:context] = context.as_json if context.present?
+    end
+  end
+
+  private
+
+  def actor_valid
+    errors.add(:actor, "is invalid") if actor && !actor.valid?
+  end
+
+  def verb_valid
+    errors.add(:verb, "is invalid") if verb && !verb.valid?
+  end
+
+  def object_valid
+    errors.add(:object, "is invalid") if object && !object.valid?
+  end
+end
+
+# == Schema Information
+#
+# Table name: rails_xapi_statements
+#
+#  id         :integer          not null, primary key
+#  timestamp  :datetime
+#  created_at :datetime         not null
+#  actor_id   :string           not null
+#  object_id  :string           not null
+#  verb_id    :string           not null
+#
+# Indexes
+#
+#  index_rails_xapi_statements_on_actor_id   (actor_id)
+#  index_rails_xapi_statements_on_object_id  (object_id)
+#  index_rails_xapi_statements_on_verb_id    (verb_id)
+#

data/app/models/rails_xapi/validators/language_map_validator.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RailsXapi
+  module Validators
+    class LanguageMapValidator < ActiveModel::Validator
+      LANGUAGE_MAP_REGEX = /\A[a-z]{2}(-[A-Z]{2})?\z/
+
+      def validate(record)
+        attributes_to_validate = options[:attributes] || []
+
+        attributes_to_validate.each do |attribute|
+          next unless record.respond_to?(attribute)
+
+          raw_value = record.public_send(attribute)
+          next unless raw_value.present?
+
+          validate_language_map_keys(record, attribute, raw_value)
+        end
+      end
+
+      private
+
+      def validate_language_map_keys(record, attribute, data)
+        data_hash =
+          case data
+          when String
+            # If it's a string, parse:
+            begin
+              JSON.parse(data)
+            rescue JSON::ParserError
+              record.errors.add(
+                attribute,
+                I18n.t("rails_xapi.errors.invalid_json")
+              )
+              return
+            end
+          when Hash
+            data
+          else
+            record.errors.add(attribute, "must be a JSON string or a Hash")
+            return
+          end
+
+        unless data_hash.is_a?(Hash)
+          raise RailsXapi::Errors::XapiError,
+                I18n.t("rails_xapi.errors.expected_hash", type: data_hash.class)
+        end
+
+        invalid_keys =
+          data_hash.keys.reject { |key| key.match?(LANGUAGE_MAP_REGEX) }
+
+        if invalid_keys.any?
+          record.errors.add(
+            attribute,
+            I18n.t(
+              "rails_xapi.errors.definition_description_invalid_keys",
+              values: invalid_keys.join(", ")
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/app/models/rails_xapi/verb.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+# The Verb defines the action between an Actor and an Activity.
+# The systems reading the statements must use the verb IRI to infer meaning.
+# See : https://github.com/adlnet/xAPI-Spec/blob/master/xAPI-Data.md#243-verb
+class RailsXapi::Verb < ApplicationRecord
+  has_many :statements, class_name: "RailsXapi::Statement", dependent: :nullify
+
+  before_validation :set_display
+
+  validates :id,
+            presence: true,
+            format: {
+              with: %r{\A\w+://\S+\z},
+              message: I18n.t("rails_xapi.errors.must_be_a_valid_iri")
+            }
+  validates_with RailsXapi::Validators::LanguageMapValidator,
+                 attributes: %i[display]
+
+  # Constants representing a mapping of xAPI activity verbs.
+  #
+  # The constant maps the activity verbs from several schemas
+  # to their corresponding human-readable output.
+  #
+  # @example Usage:
+  #   VERBS_LIST["http://activitystrea.ms/schema/1.0/accept"]  # => "accepted"
+  #   VERBS_LIST["http://activitystrea.ms/schema/1.0/access"]  # => "accessed"
+  #
+  # @note The list is build from https://registry.tincanapi.com/#home/verbs
+  VERBS_LIST = {
+    "http://activitystrea.ms/schema/1.0/accept" => "accepted",
+    "http://activitystrea.ms/schema/1.0/access" => "accessed",
+    "http://activitystrea.ms/schema/1.0/acknowledge" => "acknowledged",
+    "http://activitystrea.ms/schema/1.0/add" => "added",
+    "http://activitystrea.ms/schema/1.0/agree" => "agreed",
+    "http://activitystrea.ms/schema/1.0/append" => "appended",
+    "http://activitystrea.ms/schema/1.0/approve" => "approved",
+    "http://activitystrea.ms/schema/1.0/archive" => "archived",
+    "http://activitystrea.ms/schema/1.0/assign" => "assigned",
+    "http://activitystrea.ms/schema/1.0/at" => "was at",
+    "http://activitystrea.ms/schema/1.0/attach" => "attached",
+    "http://activitystrea.ms/schema/1.0/attend" => "attended",
+    "http://activitystrea.ms/schema/1.0/author" => "authored",
+    "http://activitystrea.ms/schema/1.0/authorize" => "authorized",
+    "http://activitystrea.ms/schema/1.0/borrow" => "borrowed",
+    "http://activitystrea.ms/schema/1.0/build" => "built",
+    "http://activitystrea.ms/schema/1.0/cancel" => "canceled",
+    "http://activitystrea.ms/schema/1.0/checkin" => "checked in",
+    "http://activitystrea.ms/schema/1.0/close" => "closed",
+    "http://activitystrea.ms/schema/1.0/complete" => "completed",
+    "http://activitystrea.ms/schema/1.0/confirm" => "confirmed",
+    "http://activitystrea.ms/schema/1.0/consume" => "consumed",
+    "http://activitystrea.ms/schema/1.0/create" => "created",
+    "http://activitystrea.ms/schema/1.0/delete" => "deleted",
+    "http://activitystrea.ms/schema/1.0/deliver" => "delivered",
+    "http://activitystrea.ms/schema/1.0/deny" => "denied",
+    "http://activitystrea.ms/schema/1.0/disagree" => "disagreed",
+    "http://activitystrea.ms/schema/1.0/dislike" => "disliked",
+    "http://activitystrea.ms/schema/1.0/experience" => "experienced",
+    "http://activitystrea.ms/schema/1.0/favorite" => "favorited",
+    "http://activitystrea.ms/schema/1.0/find" => "found",
+    "http://activitystrea.ms/schema/1.0/flag-as-inappropriate" =>
+      "flagged as inappropriate",
+    "http://activitystrea.ms/schema/1.0/follow" => "followed",
+    "http://activitystrea.ms/schema/1.0/give" => "gave",
+    "http://activitystrea.ms/schema/1.0/host" => "hosted",
+    "http://activitystrea.ms/schema/1.0/ignore" => "ignored",
+    "http://activitystrea.ms/schema/1.0/insert" => "inserted",
+    "http://activitystrea.ms/schema/1.0/install" => "installed",
+    "http://activitystrea.ms/schema/1.0/interact" => "interacted",
+    "http://activitystrea.ms/schema/1.0/invite" => "invited",
+    "http://activitystrea.ms/schema/1.0/join" => "joined",
+    "http://activitystrea.ms/schema/1.0/leave" => "left",
+    "http://activitystrea.ms/schema/1.0/like" => "liked",
+    "http://activitystrea.ms/schema/1.0/listen" => "listened",
+    "http://activitystrea.ms/schema/1.0/lose" => "lost",
+    "http://activitystrea.ms/schema/1.0/make-friend" => "made friend",
+    "http://activitystrea.ms/schema/1.0/open" => "opened",
+    "http://activitystrea.ms/schema/1.0/play" => "played",
+    "http://activitystrea.ms/schema/1.0/present" => "presented",
+    "http://activitystrea.ms/schema/1.0/purchase" => "purchased",
+    "http://activitystrea.ms/schema/1.0/qualify" => "qualified",
+    "http://activitystrea.ms/schema/1.0/read" => "read",
+    "http://activitystrea.ms/schema/1.0/receive" => "received",
+    "http://activitystrea.ms/schema/1.0/reject" => "rejected",
+    "http://activitystrea.ms/schema/1.0/remove" => "removed",
+    "http://activitystrea.ms/schema/1.0/remove-friend" => "removed friend",
+    "http://activitystrea.ms/schema/1.0/replace" => "replaced",
+    "http://activitystrea.ms/schema/1.0/request" => "requested",
+    "http://activitystrea.ms/schema/1.0/request-friend" => "requested friend",
+    "http://activitystrea.ms/schema/1.0/resolve" => "resolved",
+    "http://activitystrea.ms/schema/1.0/retract" => "retracted",
+    "http://activitystrea.ms/schema/1.0/return" => "returned",
+    "http://activitystrea.ms/schema/1.0/rsvp-maybe" => "RSVPed maybe",
+    "http://activitystrea.ms/schema/1.0/rsvp-no" => "rsvped no",
+    "http://activitystrea.ms/schema/1.0/rsvp-yes" => "rsvped yes",
+    "http://activitystrea.ms/schema/1.0/satisfy" => "satisfied",
+    "http://activitystrea.ms/schema/1.0/save" => "saved",
+    "http://activitystrea.ms/schema/1.0/schedule" => "scheduled",
+    "http://activitystrea.ms/schema/1.0/search" => "searched",
+    "http://activitystrea.ms/schema/1.0/sell" => "sold",
+    "http://activitystrea.ms/schema/1.0/send" => "sent",
+    "http://activitystrea.ms/schema/1.0/share" => "shared",
+    "http://activitystrea.ms/schema/1.0/sponsor" => "sponsored",
+    "http://activitystrea.ms/schema/1.0/start" => "started",
+    "http://activitystrea.ms/schema/1.0/stop-following" => "stopped following",
+    "http://activitystrea.ms/schema/1.0/submit" => "submitted",
+    "http://activitystrea.ms/schema/1.0/tag" => "tagged",
+    "http://activitystrea.ms/schema/1.0/terminate" => "terminated",
+    "http://activitystrea.ms/schema/1.0/tie" => "tied",
+    "http://activitystrea.ms/schema/1.0/unfavorite" => "unfavorited",
+    "http://activitystrea.ms/schema/1.0/unlike" => "unliked",
+    "http://activitystrea.ms/schema/1.0/unsatisfy" => "unsatisfied",
+    "http://activitystrea.ms/schema/1.0/unsave" => "unsaved",
+    "http://activitystrea.ms/schema/1.0/unshare" => "unshared",
+    "http://activitystrea.ms/schema/1.0/update" => "updated",
+    "http://activitystrea.ms/schema/1.0/use" => "used",
+    "http://activitystrea.ms/schema/1.0/watch" => "Watched",
+    "http://activitystrea.ms/schema/1.0/win" => "won",
+    "http://adlnet.gov/expapi/verbs/answered" => "answered",
+    "http://adlnet.gov/expapi/verbs/asked" => "asked",
+    "http://adlnet.gov/expapi/verbs/attempted" => "attempted",
+    "http://adlnet.gov/expapi/verbs/attended" => "attended",
+    "http://adlnet.gov/expapi/verbs/commented" => "commented",
+    "http://adlnet.gov/expapi/verbs/completed" => "completed",
+    "http://adlnet.gov/expapi/verbs/exited" => "exited",
+    "http://adlnet.gov/expapi/verbs/experienced" => "experienced",
+    "http://adlnet.gov/expapi/verbs/failed" => "failed",
+    "http://adlnet.gov/expapi/verbs/imported" => "imported",
+    "http://adlnet.gov/expapi/verbs/initialized" => "initialized",
+    "http://adlnet.gov/expapi/verbs/interacted" => "interacted",
+    "http://adlnet.gov/expapi/verbs/launched" => "launched",
+    "http://adlnet.gov/expapi/verbs/mastered" => "mastered",
+    "http://adlnet.gov/expapi/verbs/passed" => "passed",
+    "http://adlnet.gov/expapi/verbs/preferred" => "preferred",
+    "http://adlnet.gov/expapi/verbs/progressed" => "progressed",
+    "http://adlnet.gov/expapi/verbs/registered" => "registered",
+    "http://adlnet.gov/expapi/verbs/responded" => "responded",
+    "http://adlnet.gov/expapi/verbs/resumed" => "resumed",
+    "http://adlnet.gov/expapi/verbs/scored" => "scored",
+    "http://adlnet.gov/expapi/verbs/shared" => "shared",
+    "http://adlnet.gov/expapi/verbs/suspended" => "suspended",
+    "http://adlnet.gov/expapi/verbs/terminated" => "terminated",
+    "http://adlnet.gov/expapi/verbs/voided" => "voided",
+    "http://curatr3.com/define/verb/edited" => "edited",
+    "http://curatr3.com/define/verb/voted-down" => "voted down (with reason)",
+    "http://curatr3.com/define/verb/voted-up" => "voted up (with reason)",
+    "http://future-learning.info/xAPI/verb/pressed" => "pressed",
+    "http://future-learning.info/xAPI/verb/released" => "released",
+    "http://id.tincanapi.com/verb/adjourned" => "adjourned",
+    "http://id.tincanapi.com/verb/applauded" => "applauded",
+    "http://id.tincanapi.com/verb/arranged" => "arranged",
+    "http://id.tincanapi.com/verb/bookmarked" => "bookmarked",
+    "http://id.tincanapi.com/verb/called" => "called",
+    "http://id.tincanapi.com/verb/closed-sale" => "closed sale",
+    "http://id.tincanapi.com/verb/created-opportunity" => "created opportunity",
+    "http://id.tincanapi.com/verb/defined" => "defined",
+    "http://id.tincanapi.com/verb/disabled" => "disabled",
+    "http://id.tincanapi.com/verb/discarded" => "discarded",
+    "http://id.tincanapi.com/verb/downloaded" => "downloaded",
+    "http://id.tincanapi.com/verb/earned" => "earned",
+    "http://id.tincanapi.com/verb/enabled" => "enabled",
+    "http://id.tincanapi.com/verb/estimated-duration" =>
+      "estimated the duration",
+    "http://id.tincanapi.com/verb/expected" => "expected",
+    "http://id.tincanapi.com/verb/expired" => "expired",
+    "http://id.tincanapi.com/verb/focused" => "focused",
+    "http://id.tincanapi.com/verb/frame/entered" => "entered frame",
+    "http://id.tincanapi.com/verb/frame/exited" => "exited frame",
+    "http://id.tincanapi.com/verb/hired" => "hired",
+    "http://id.tincanapi.com/verb/interviewed" => "interviewed",
+    "http://id.tincanapi.com/verb/laughed" => "laughed",
+    "http://id.tincanapi.com/verb/marked-unread" => "unread",
+    "http://id.tincanapi.com/verb/mentioned" => "mentioned",
+    "http://id.tincanapi.com/verb/mentored" => "mentored",
+    "http://id.tincanapi.com/verb/paused" => "paused",
+    "http://id.tincanapi.com/verb/performed-offline" => "performed",
+    "http://id.tincanapi.com/verb/personalized" => "personalized",
+    "http://id.tincanapi.com/verb/previewed" => "previewed",
+    "http://id.tincanapi.com/verb/promoted" => "promoted",
+    "http://id.tincanapi.com/verb/rated" => "rated",
+    "http://id.tincanapi.com/verb/replied" => "replied",
+    "http://id.tincanapi.com/verb/replied-to-tweet" => "replied to tweet",
+    "http://id.tincanapi.com/verb/requested-attention" => "requested attention",
+    "http://id.tincanapi.com/verb/retweeted" => "retweeted",
+    "http://id.tincanapi.com/verb/reviewed" => "reviewed",
+    "http://id.tincanapi.com/verb/secured" => "secured",
+    "http://id.tincanapi.com/verb/selected" => "selected",
+    "http://id.tincanapi.com/verb/skipped" => "skipped",
+    "http://id.tincanapi.com/verb/talked-with" => "talked",
+    "http://id.tincanapi.com/verb/terminated-employment-with" =>
+      "terminated employment with",
+    "http://id.tincanapi.com/verb/tweeted" => "tweeted",
+    "http://id.tincanapi.com/verb/unfocused" => "unfocused",
+    "http://id.tincanapi.com/verb/unregistered" => "unregistered",
+    "http://id.tincanapi.com/verb/viewed" => "viewed",
+    "http://id.tincanapi.com/verb/voted-down" => "down voted",
+    "http://id.tincanapi.com/verb/voted-up" => "up voted",
+    "http://id.tincanapi.com/verb/was-assigned-job-title" =>
+      "was assigned job title",
+    "http://id.tincanapi.com/verb/was-hired-by" => "was hired by",
+    "http://risc-inc.com/annotator/verbs/annotated" => "annotated",
+    "http://risc-inc.com/annotator/verbs/modified" => "modified annotation",
+    "http://specification.openbadges.org/xapi/verbs/earned" =>
+      "earned an Open Badge",
+    "http://www.digital-knowledge.co.jp/tincanapi/verbs/drew" => "drew",
+    "http://www.tincanapi.co.uk/pages/verbs.html#cancelled_planned_learning" =>
+      "cancelled planned learning",
+    "http://www.tincanapi.co.uk/pages/verbs.html#planned_learning" => "planned",
+    "http://www.tincanapi.co.uk/verbs/enrolled_onto_learning_plan" =>
+      "enrolled onto learning plan",
+    "http://www.tincanapi.co.uk/verbs/evaluated" => "evaluated",
+    "https://brindlewaye.com/xAPITerms/verbs/added/" => "added",
+    "https://brindlewaye.com/xAPITerms/verbs/loggedin/" => "log in",
+    "https://brindlewaye.com/xAPITerms/verbs/loggedout/" => "log out",
+    "https://brindlewaye.com/xAPITerms/verbs/ran/" => "ran",
+    "https://brindlewaye.com/xAPITerms/verbs/removed/" => "removed",
+    "https://brindlewaye.com/xAPITerms/verbs/reviewed/" => "reviewed",
+    "https://brindlewaye.com/xAPITerms/verbs/walked/" => "walked"
+  }
+
+  def to_locale
+    loc = I18n.default_locale&.to_s || "en"
+    parsed = JSON.parse(display)
+    fallback = parsed&.first&.[](-1) || ""
+
+    parsed[loc] || fallback
+  end
+
+  def as_json
+    { id: id, display: display }.compact
+  end
+
+  private
+
+  def set_display
+    if display.present?
+      # Parse the data as JSON to store it
+      self.display = JSON.parse(display.gsub("=>", ":")).to_json
+    elsif VERBS_LIST.key?(id)
+      verb_list_id = VERBS_LIST[id]
+      self.display = { "en-US": verb_list_id }.to_json
+    else
+      raise RailsXapi::Errors::XapiError,
+            I18n.t("rails_xapi.errors.missing_verb_display")
+    end
+  end
+end
+
+# == Schema Information
+#
+# Table name: rails_xapi_verbs
+#
+#  id      :string           not null, primary key
+#  display :string
+#
+# Indexes
+#
+#  index_rails_xapi_verbs_on_id  (id) UNIQUE
+#

data/app/services/application_service.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class ApplicationService
+  def self.call(*, &)
+    new(*, &).call
+  end
+
+  # Set the start_date to the first day of the given month and year,
+  # and the end_date to the last day of the givenn month.
+  def self.generate_start_date_end_date(year, month)
+    start_date = Date.new(year, month, 1)
+    end_date = start_date.end_of_month
+
+    [start_date, end_date]
+  end
+end