growthtribe_xapi 0.0.1

data/lib/xapi/result.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+require 'active_support/duration'
+
+module Xapi
+  # Result Model class
+  class Result
+
+    attr_accessor :score, :success, :completion, :duration, :response, :extensions
+
+    def initialize(options={}, &block)
+      json = options.fetch(:json, nil)
+      if json
+        attributes = JSON.parse(json)
+        self.score = Xapi::Score.new(json: attributes['score'].to_json) if attributes['score']
+        self.success = attributes['success'] unless attributes['success'].nil?
+        self.completion = attributes['completion'] unless attributes['completion'].nil?
+        self.duration = ActiveSupport::Duration.parse(attributes['duration']) if attributes['duration']
+        self.response = attributes['response'] if attributes['response']
+        self.extensions = attributes['extensions'] if attributes['extensions']
+      else
+        self.score = options.fetch(:score, nil)
+        self.success = options.fetch(:success, nil)
+        self.completion = options.fetch(:completion, nil)
+        self.duration = options.fetch(:duration, nil)
+        self.response = options.fetch(:response, nil)
+        self.extensions = options.fetch(:extensions, nil)
+
+        if block_given?
+          block[self]
+        end
+      end
+    end
+
+    def serialize(version)
+      node = {}
+      node['score'] = score.serialize(version) if score
+      node['success'] = success unless success.nil?
+      node['completion'] = completion unless completion.nil?
+      node['duration'] = duration.iso8601 if duration
+      node['response'] = response if response
+      node['extensions'] = extensions if extensions
+
+      node
+    end
+  end
+end

data/lib/xapi/score.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module Xapi
+  # Score model class
+  class Score
+
+    attr_accessor :scaled, :raw, :min, :max
+
+    def initialize(options={}, &block)
+      json = options.fetch(:json, nil)
+      if json
+        attributes = JSON.parse(json)
+        self.scaled = attributes['scaled'] if attributes['scaled']
+        self.raw = attributes['raw'] if attributes['raw']
+        self.min = attributes['min'] if attributes['min']
+        self.max = attributes['max'] if attributes['max']
+      else
+        self.scaled = options.fetch(:scaled, nil)
+        self.raw = options.fetch(:raw, nil)
+        self.min = options.fetch(:min, nil)
+        self.max = options.fetch(:max, nil)
+
+        if block_given?
+          block[self]
+        end
+      end
+
+    end
+
+    def serialize(version)
+      node = {}
+      node['scaled'] = scaled if scaled
+      node['raw'] = raw if raw
+      node['min'] = min if min
+      node['max'] = max if max
+      node
+    end
+
+  end
+end

data/lib/xapi/statement.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+module Xapi
+  # Statement Class
+  class Statement < Statements::StatementsBase
+
+    attr_accessor :id, :stored, :authority, :version, :voided
+
+    def initialize(options={}, &block)
+      super(options, &block)
+      json = options.fetch(:json, nil)
+      if json
+        attributes = JSON.parse(json)
+        self.id = attributes['id'] if attributes['id']
+        self.stored =  Time.parse(attributes['stored']) if attributes['stored']
+        self.authority = Xapi::Agent.new(json: attributes['authority'].to_json) if attributes['authority']
+        self.version = attributes['version'] if attributes['version']
+        self.voided = attributes['voided'] if attributes['voided']
+      else
+        self.id = options.fetch(:id, nil)
+        self.stored = options.fetch(:stored, nil)
+        self.authority = options.fetch(:authority, nil)
+        self.version = options.fetch(:version, nil)
+        self.voided = options.fetch(:voided, nil)
+
+        if block_given?
+          block[self]
+        end
+      end
+    end
+
+    def serialize(version)
+      node = super(version)
+
+      node['id'] = id if id
+      node['stored'] = stored.strftime('%FT%T%:z') if stored
+      node['authority'] = authority.serialize(version) if authority
+
+      if version == Xapi::TCAPIVersion::V095
+        node['voided'] = voided if voided
+      end
+
+      if version.ordinal >= Xapi::TCAPIVersion::V100.ordinal
+        node['version'] = version.to_s if version
+      end
+      node
+    end
+
+    def stamp(id: SecureRandom.uuid, timestamp: Time.now)
+      @id = id
+      @timestamp = timestamp
+    end
+  end
+end

data/lib/xapi/statement_ref.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+module Xapi
+  # StatementRef Class used when referencing another statement from a statement's object property
+  class StatementRef
+
+    attr_accessor :object_type, :id
+
+    def initialize(options={}, &block)
+      @object_type = 'StatementRef'
+      json = options.fetch(:json, nil)
+      if json
+        attributes = JSON.parse(json)
+        self.id = attributes['id'] if attributes['id']
+      else
+        self.id = options.fetch(:id, nil)
+
+        if block_given?
+          block[self]
+        end
+      end
+    end
+
+    def serialize(version)
+      node = {}
+      node['id'] = id if id
+      node['objectType'] = object_type
+      node
+    end
+
+  end
+end

data/lib/xapi/statements/statements_base.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+module Xapi
+  module Statements
+    class StatementsBase
+
+      attr_accessor :actor, :verb, :object, :result, :context, :timestamp, :attachments, :voided
+
+      def initialize(options={}, &block)
+        @attachments = []
+        json = options.fetch(:json, nil)
+        if json
+          attributes = JSON.parse(json)
+          self.actor = attributes['actor']['member'] ? Xapi::Group.new(json: attributes['actor'].to_json) : Xapi::Agent.new(json: attributes['actor'].to_json) if attributes['actor']
+          self.verb = Xapi::Verb.new(json: attributes['verb'].to_json) if attributes['verb']
+          object_node = attributes['object']
+          if object_node
+            case object_node['objectType']
+              when 'Group', 'Agent'
+                self.object = Xapi::Agent.new(json: object_node.to_json)
+              when 'StatementRef'
+                self.object = Xapi::StatementRef.new(json: object_node.to_json)
+              when 'SubStatement'
+                self.object = Xapi::SubStatement.new(json: object_node.to_json)
+              else
+                self.object = Xapi::Activity.new(json: object_node.to_json)
+            end
+          end
+          self.result = Xapi::Result.new(json: attributes['result'].to_json) if attributes['result']
+          self.context = Xapi::Context.new(json: attributes['context'].to_json) if attributes['context']
+          self.timestamp = Time.parse(attributes['timestamp']) if attributes['timestamp']
+          self.voided = attributes['voided'] if attributes['voided']
+          if attributes['attachments']
+            attributes['attachments'].each do |attachment|
+              attachments << Xapi::Attachment.new(json: attachment.to_json)
+            end
+          end
+        else
+          self.actor = options.fetch(:actor, nil)
+          self.verb = options.fetch(:verb, nil)
+          self.object = options.fetch(:object, nil)
+          self.result = options.fetch(:result, nil)
+          self.context = options.fetch(:context, nil)
+          self.timestamp = options.fetch(:timestamp, nil)
+          self.attachments = options.fetch(:attachments, nil)
+          self.voided = options.fetch(:voided, nil)
+
+          if block_given?
+            block[self]
+          end
+        end
+      end
+
+      def serialize(version)
+        node = {}
+        node['actor'] = actor.serialize(version)
+        node['verb'] = verb.serialize(version)
+        node['object'] = object.serialize(version)
+        node['result'] = result.serialize(version) if result
+        node['context'] = context.serialize(version) if context
+        node['timestamp'] = timestamp.strftime('%FT%T%:z') if timestamp
+        if version.ordinal >= Xapi::TCAPIVersion::V100.ordinal
+          if attachments && attachments.any?
+            node['attachments'] = attachments.map {|element| element.serialize(version)}
+          end
+        end
+        node
+      end
+    end
+  end
+end

data/lib/xapi/statements_query.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+module Xapi
+  class StatementsQuery
+
+    attr_accessor :version, :verb_id
+    attr_accessor :agent, :activity_id, :registration, :related_activities, :related_agents
+    attr_accessor :stored_since, :stored_until, :limit, :format, :ascending
+
+    def initialize(&block)
+      self.version = TCAPIVersion::V101
+      if block_given?
+        block[self]
+      end
+    end
+
+    def verb_id=(value)
+      if value.is_a?(Verb)
+        @verb_id = value.id
+      else
+        @verb_id = value
+      end
+    end
+
+    def parameter_map
+      params = {}
+      params['agent'] = agent.object_type.eql?("Group") ? {"account": {"homePage": agent.account.homePage, "name": agent.account.name}}.to_json : {"mbox":agent.mbox}.to_json if agent
+      params['verb'] = verb_id.to_s if verb_id
+      params['activity'] = activity_id.to_s if activity_id
+      params['registration'] = registration if registration
+      params['related_activities'] = related_activities if related_activities
+      params['related_agents'] = related_agents if related_agents
+      params['since'] = stored_since.strftime('%FT%T%:z') if stored_since
+      params['until'] = stored_until.strftime('%FT%T%:z') if stored_until
+      params['limit'] = limit if limit
+      params['format'] = format if format
+      params['ascending'] = ascending if ascending
+
+      params
+    end
+
+  end
+end

data/lib/xapi/statements_query_v095.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+module Xapi
+  class StatementsQueryV095
+
+    attr_reader :version, :verb_id
+    attr_accessor :object, :registration, :context, :actor, :stored_since, :stored_until, :limit
+    attr_accessor :authoritative, :sparse, :instructor, :ascending
+
+    def initialize(&block)
+      self.version = TCAPIVersion::V095
+      if block_given?
+        block[self]
+      end
+    end
+
+    def verb_id=(value)
+      if value.is_a?(Verb)
+        @verb_id = value.id
+      else
+        @verb_id = Addressable::URI.parse(value)
+      end
+    end
+
+    def parameter_map
+      params = {}
+      params['verb'] = verb_id.to_s if verb_id
+      params['object'] = object.serialize(version) if object
+      params['registration'] = registration if registration
+      params['context'] = context if context
+      params['actor'] = actor if actor
+      params['since'] = stored_since.strftime('%FT%T%:z') if stored_since
+      params['until'] = stored_until.strftime('%FT%T%:z') if stored_until
+      params['limit'] = limit if limit
+      params['authoritative'] = authoritative if authoritative
+      params['sparse'] = sparse if sparse
+      params['instructor'] = instructor.serialize(version) if instructor
+      params['ascending'] = ascending if ascending
+
+      params
+    end
+  end
+end

data/lib/xapi/statements_result.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+module Xapi
+  # Statements result model class, returned by LRS calls to get multiple statements
+  class StatementsResult
+
+    attr_accessor :statements, :more_url
+
+    def initialize(options={})
+      json = options.fetch(:json, nil)
+      self.statements = []
+      if json
+        self.statements = json['statements'].map {|statement| Statement.new(json: statement.to_json)} if json['statements']
+        self.more_url = json['more'] if json['more']
+      end
+    end
+  end
+end

data/lib/xapi/sub_statement.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+module Xapi
+  class SubStatement < Statements::StatementsBase
+
+    attr_accessor :object_type
+
+    def initialize(options={}, &block)
+      @object_type = 'SubStatement'
+      super(options, &block)
+    end
+
+    def serialize(version)
+      node = super(version)
+      node['objectType'] = object_type
+      node
+    end
+
+  end
+end

data/lib/xapi/tcapi_version.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+module Xapi
+  module TCAPIVersion
+
+    V101 = {
+        to_s: '1.0.1',
+        get_value: proc{'1.0.1'}
+    }
+
+    V100 = {
+        to_s: '1.0.0',
+        get_value: proc{'1.0.0'}
+    }
+
+    V095 = {
+        to_s: '0.95',
+        get_value: proc{'0.95'}
+    }
+
+    def latest_version
+      V101
+    end
+
+    extend Xapi::Enum
+
+  end
+end

data/lib/xapi/team.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+require 'xapi/tcapi_version'
+module Xapi
+  # Team model class
+  class Team
+
+    attr_accessor :name, :mbox, :mbox_sha1_sum, :open_id, :account, :object_type
+
+    def initialize(options={}, &block)
+      @object_type = 'Group'
+      json = options.fetch(:json, nil)
+      if json
+        attributes = JSON.parse(json)
+        self.name = attributes['name'] if attributes['name']
+        self.mbox = attributes['mbox'] if attributes['mbox']
+        self.mbox_sha1_sum = attributes['mbox_sha1sum'] if attributes['mbox_sha1sum']
+        self.open_id = attributes['openid'] if attributes['openid']
+        self.account = AgentAccount.new(json: attributes['account'].to_json) if attributes['account']
+      else
+        self.name = options.fetch(:name, nil)
+        self.mbox = options.fetch(:mbox, nil)
+        self.mbox_sha1_sum = options.fetch(:mbox_sha1_sum, nil)
+        self.open_id = options.fetch(:open_id, nil)
+        self.account = options.fetch(:account, nil)
+
+        if block_given?
+          block[self]
+        end
+      end
+    end
+
+    def serialize(version)
+      node = {}
+      node['objectType'] = object_type
+      node['name'] = name if name
+      node['mbox'] = mbox if mbox
+      node['mbox_sha1sum'] = mbox_sha1_sum if mbox_sha1_sum
+      node['openid'] = open_id if open_id
+      node['account'] = account.serialize(version) if account
+      node
+    end
+
+  end
+end