tin_can_api 0.0.1

data/lib/tin_can_api/client.rb

@@ -0,0 +1,402 @@
+# encoding: utf-8
+require 'faraday'
+require 'addressable/uri'
+require 'tin_can_api/tcapi_version'
+module TinCanApi
+  # Class used to communicate with a TCAPI endpoint synchronously
+  class Client
+    include TinCanApi::TCAPIVersion
+
+    VALID_PARAMS = %w(end_point user_name password version)
+
+    attr_accessor :end_point, :user_name, :password, :version
+
+    def initialize(options={}, &block)
+      setup_options(options)
+      yield_or_eval(&block) if block_given?
+      @version ||= latest_version
+    end
+
+    def about
+      response = connection.get("#{path}about")
+      LrsResponse.new do |lrs|
+        lrs.status = response.status
+        if response.status== 200
+          lrs.content = About.new(json: response.body)
+          lrs.success = true
+        else
+          lrs.success = false
+        end
+      end
+    end
+
+    def save_statement(statement)
+      # TODO: Complete this
+      if statement.id
+        response = connection.put do |req|
+          req.url("#{path}statements")
+          req.headers['Content-Type'] = 'application/json'
+          req.params.merge!({'statementId' => statement.id})
+          req.body = statement.serialize(latest_version).to_json
+        end
+      else
+        response = connection.post do |req|
+          req.url("#{path}statements")
+          req.headers['Content-Type'] = 'application/json'
+          req.body = statement.serialize(latest_version).to_json
+        end
+      end
+      LrsResponse.new do |lrs|
+        lrs.status = response.status
+        lrs.content = statement
+        if response.status == 200
+          statement.id = JSON.parse(response.body).first
+          lrs.success = true
+        elsif response.status == 204
+          lrs.success = true
+        else
+          lrs.success = false
+        end
+      end
+    end
+
+    def save_statements(statements)
+      # TODO: Complete this
+      if statements.empty?
+        return LrsResponse.new do |lrs|
+          lrs.success = true
+        end
+      end
+      response = connection.post do |req|
+        req.url("#{path}statements")
+        req.headers['Content-Type'] = 'application/json'
+        req.body = statements.map {|s| s.serialize(latest_version)}.to_json
+      end
+      LrsResponse.new do |lrs|
+        lrs.status = response.status
+        if response.status == 200
+          lrs.content = statements
+          ids = JSON.parse(response.body)
+          statements.each_with_index do |statement, index|
+            statement.id = ids[index]
+          end
+          lrs.success = true
+        else
+          lrs.success = false
+        end
+      end
+    end
+
+    def retrieve_statement(id)
+      get_statement(id, 'statementId')
+    end
+
+    def retrieve_voided_statement(id)
+      param_name = version == TCAPIVersion.V095 ? 'statementId' : 'voidedStatementId'
+      get_statement(id, param_name)
+    end
+
+    def query_statements(statement_query)
+      # TODO: Complete this
+      query = statement_query
+      unless query
+        query = version == TCAPIVersion::V095 ? StatementsQueryV095.new : StatementsQuery.new
+      end
+      # Error if the query parameters don't match the LRS version
+      raise Errors::IncompatibleTCAPIVersion, "Attempted to issue #{version} query using a #{query.version} set of query parameters." unless version == query.version
+
+      response = connection.get do |req|
+        req.url("#{path}statements")
+        req.params.merge!(query.parameter_map)
+      end
+      LrsResponse.new do |lrs|
+        lrs.status = response.status
+        if response.status == 200
+          # TODO: FIX THIS
+          lrs.success = true
+          lrs.content = StatementsResult.new(json: response.body)
+        else
+          lrs.success = false
+        end
+      end
+    end
+
+    def more_statements(more_url)
+      # TODO: Complete this
+      # more_url is relative to the endpoint's server root
+      response = connection.get do |req|
+        req.url("#{path}#{more_url}")
+      end
+      LrsResponse.new do |lrs|
+        lrs.status = response.status
+        if response.status == 200
+          # TODO: FIX THIS
+          lrs.success = true
+          lrs.content = StatementsResult.new(json: response.body)
+        else
+          lrs.success = false
+        end
+      end
+    end
+
+    def retrieve_state_ids(activity, agent, registration)
+      # TODO: Complete this
+      query_params = {
+          'activityId' =>  activity.id,
+          'agent' => agent.serialize(version).to_json
+      }
+      query_params['registration'] = registration if registration
+      get_profile_keys('activities/state', query_params)
+    end
+
+    def retrieve_state(id, activity, agent, registration)
+      # TODO: Complete this
+      query_params = {
+          'stateId' => id,
+          'activityId' => activity.id,
+          'agent' => agent.serialize(version).to_json
+      }
+      document = StateDocument.new do |sd|
+        sd.id = id
+        sd.activity = activity
+        sd.agent = agent
+      end
+      lrs_response = get_document('activities/state', query_params, document)
+      if lrs_response.status == 200
+        lrs_response.content = document
+      end
+      lrs_response
+    end
+
+    def save_state(state)
+      # TODO: Complete this
+      query_params = {
+          'stateId' => state.id,
+          'activityId' => state.activity.id,
+          'agent' => state.agent.serialize(version).to_json
+      }
+      save_document('activities/state', query_params, state)
+    end
+
+    def delete_state(state)
+      # TODO: Complete this
+      query_params = {
+          'stateId' => state.id,
+          'activityId' => state.activity.id,
+          'agent' => state.agent.serialize(version).to_json
+      }
+      query_params['registration'] = state.registration if state.registration
+      delete_document('activities/state', query_params)
+    end
+
+    def clear_state(activity, agent, registration)
+      # TODO: Complete this
+      query_params = {
+          'activityId' => activity.id,
+          'agent' => agent.serialize(version).to_json
+      }
+      query_params['registration'] = registration if registration
+      delete_document('activities/state', query_params)
+    end
+
+    def retrieve_activity_profile_ids(activity)
+      # TODO: Complete this
+      query_params = {
+          'activityId' => activity.id
+      }
+      get_profile_keys('activities/profile', query_params)
+    end
+
+    def retrieve_activity_profile(id, activity)
+      # TODO: Complete this
+      query_params = {
+          'profileId' => id,
+          'activityId' => activity.id,
+      }
+      document = ActivityProfileDocument.new do |apd|
+        apd.id = id
+        apd.activity = activity
+      end
+      lrs_response = get_document('activities/profile', query_params, document)
+      if lrs_response.status == 200
+        lrs_response.content = document
+      end
+      lrs_response
+    end
+
+    def save_activity_profile(profile)
+      # TODO: Complete this
+      query_params = {
+          'profileId' => profile.id,
+          'activityId' => profile.activity.id,
+      }
+      save_document('activities/profile', query_params, profile)
+    end
+
+    def delete_activity_profile(profile)
+      # TODO: Complete this
+      query_params = {
+          'profileId' => profile.id,
+          'activityId' => profile.activity.id,
+      }
+      delete_document('activities/profile', query_params)
+    end
+
+    def retrieve_agent_profile_ids(agent)
+      # TODO: Complete this
+      query_params = {
+          'agent' => agent.serialize(version).to_json
+      }
+      get_profile_keys('agents/profile', query_params)
+    end
+
+    def retrieve_agent_profile(id, agent)
+      # TODO: Complete this
+      query_params = {
+          'profileId' => id,
+          'agent' => agent.serialize(version).to_json
+      }
+      document = AgentProfileDocument.new do |apd|
+        apd.id = id
+        apd.agent = agent
+      end
+      lrs_response = get_document('agents/profile', query_params, document)
+      if lrs_response.status == 200
+        lrs_response.content = document
+      end
+      lrs_response
+    end
+
+    def save_agent_profile(profile)
+      # TODO: Complete this
+      query_params = {
+          'profileId' => profile.id,
+          'agent' => profile.agent.serialize(version).to_json
+      }
+      save_document('agents/profile', query_params, profile)
+    end
+
+    def delete_agent_profile(profile)
+      # TODO: Complete this
+      query_params = {
+          'profileId' => profile.id,
+          'agent' => profile.agent.serialize(version).to_json
+      }
+      delete_document('agents/profile', query_params)
+    end
+
+    private
+
+    def setup_options(options={})
+      options.each_pair do |key, value|
+        if value && VALID_PARAMS.include?(key.to_s)
+          instance_variable_set("@#{key}", value)
+        end
+      end
+    end
+
+    def yield_or_eval(&block)
+      return unless block
+      block.arity < 1 ? instance_eval(&block) : block[self]
+    end
+
+    def uri
+      @uri ||= Addressable::URI.parse(end_point)
+    end
+
+    def path
+      @path ||= uri.path
+      @path += '/' unless @path.end_with?('/')
+      @path
+    end
+
+    def connection
+      base_url = "#{uri.scheme}://#{uri.host}"
+      base_url = "#{base_url}:#{uri.port}" if uri.port
+      @connection ||= Faraday.new(:url => base_url) do |faraday|
+        faraday.request  :url_encoded             # form-encode POST params
+        faraday.response :logger                  # log requests to STDOUT
+        faraday.adapter  Faraday.default_adapter  # make requests with Net::HTTP
+        faraday.headers['X-Experience-API-Version'] = version.to_s
+        faraday.basic_auth(user_name, password)
+      end
+    end
+
+    def get_statement(id, parameter)
+      response = connection.get do |req|
+        req.url("#{path}statements")
+        req.headers['Content-Type'] = 'application/json'
+        req.params.merge!({parameter => id})
+      end
+      LrsResponse.new do |lrs|
+        lrs.status = response.status
+        if response.status== 200
+          lrs.content = Statement.new(json: response.body)
+          lrs.success = true
+        else
+          lrs.success = false
+        end
+      end
+    end
+
+    def get_document(resource, params, document)
+      response = connection.get do |req|
+        req.url("#{path}#{resource}")
+        req.params.merge!(params)
+      end
+      LrsResponse.new do |lrs|
+        lrs.status = response.status
+        if response.status == 200
+          lrs.success = true
+          # TODO FIX THIS
+        elsif response.status == 404
+          lrs.success = true
+        else
+          lrs.success = false
+        end
+      end
+    end
+
+    def delete_document(resource, params)
+      response = connection.delete do |req|
+        req.url("#{path}#{resource}")
+        req.params.merge!(params)
+      end
+      LrsResponse.new do |lrs|
+        lrs.status = response.status
+        if response.status == 204
+          lrs.success = true
+        else
+          lrs.success = false
+        end
+      end
+    end
+
+    def save_document(resource, params, document)
+      # TODO: Complete this
+      response = connection.put do |req|
+        req.url("#{path}#{resource}")
+        req.headers['Content-Type'] = 'application/json'
+        req.headers['If-Match'] = document.etag if document.etag
+        req.params.merge!(params)
+        req.body = document.content
+      end
+      LrsResponse.new do |lrs|
+        lrs.status = response.status
+        if response.status == 204
+          lrs.success = true
+        else
+          lrs.success = false
+        end
+      end
+    end
+
+    def get_profile_keys(resource, params)
+      # TODO FIX THIS
+      connection.get do |req|
+        req.url("#{path}#{resource}")
+        req.params.merge!(params)
+      end
+    end
+  end
+end

data/lib/tin_can_api/context.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+module TinCanApi
+  # Context Class Description
+  class Context
+
+    attr_accessor :registration, :instructor, :team, :context_activities, :revision
+    attr_accessor :platform, :language, :statement, :extensions
+
+    def initialize(options={}, &block)
+      json = options.fetch(:json, nil)
+      if json
+        attributes = JSON.parse(json)
+        self.registration = attributes['registration'] if attributes['registration']
+        self.instructor = TinCanApi::Agent.new(json: attributes['instructor'].to_json) if attributes['instructor']
+        self.team = TinCanApi::Agent.new(json: attributes['team'].to_json) if attributes['team']
+        self.context_activities = TinCanApi::ContextActivities.new(json: attributes['contextActivities'].to_json) if attributes['contextActivities']
+        self.revision = attributes['revision'] if attributes['revision']
+        self.platform = attributes['platform'] if attributes['platform']
+        self.language = attributes['language'] if attributes['language']
+        self.statement = TinCanApi::StatementRef.new(json: attributes['statement'].to_json) if attributes['statement']
+        self.extensions = attributes['extensions'] if attributes['extensions']
+      else
+        self.registration = options.fetch(:registration, nil)
+        self.instructor = options.fetch(:instructor, nil)
+        self.team = options.fetch(:team, nil)
+        self.context_activities = options.fetch(:context_activities, nil)
+        self.revision = options.fetch(:revision, nil)
+        self.platform = options.fetch(:platform, nil)
+        self.language = options.fetch(:language, nil)
+        self.extensions = options.fetch(:extensions, nil)
+
+        if block_given?
+          block[self]
+        end
+      end
+    end
+
+    def serialize(version)
+      node = {}
+      node['registration'] = registration if registration
+      node['instructor'] = instructor.serialize(version) if instructor
+      node['team'] = team.serialize(version) if team
+      node['contextActivities'] = context_activities.serialize(version) if context_activities
+      node['revision'] = revision if revision
+      node['platform'] = platform if platform
+      node['language'] = language if language
+      node['statement'] = statement.serialize(version) if statement
+      node['extensions'] = extensions if extensions
+
+      node
+    end
+
+  end
+end

data/lib/tin_can_api/context_activities.rb

@@ -0,0 +1,102 @@
+# encoding: utf-8
+module TinCanApi
+  # ContextActivities Model class
+  class ContextActivities
+
+    attr_accessor :parent, :grouping, :other, :category
+
+    def initialize(options={}, &block)
+      json = options.fetch(:json, nil)
+      if json
+        attributes = JSON.parse(json)
+        if attributes['parent']
+          if attributes['parent'].is_a?(Array)
+            self.parent = attributes['parent'].map {|element| Activity.new(json: element.to_json)}
+          else
+            self.parent = [Activity.new(json: attributes['parent'].to_json)]
+          end
+        end
+
+        if attributes['grouping']
+          if attributes['grouping'].is_a?(Array)
+            self.grouping = attributes['grouping'].map {|element| Activity.new(json: element.to_json)}
+          else
+            self.grouping = [Activity.new(json: attributes['grouping'].to_json)]
+          end
+        end
+
+        if attributes['other']
+          if attributes['other'].is_a?(Array)
+            self.other = attributes['other'].map {|element| Activity.new(json: element.to_json)}
+          else
+            self.other = [Activity.new(json: attributes['other'].to_json)]
+          end
+        end
+
+        if attributes['category']
+          if attributes['category'].is_a?(Array)
+            self.category = attributes['category'].map {|element| Activity.new(json: element.to_json)}
+          else
+            self.category = [Activity.new(json: attributes['category'].to_json)]
+          end
+        end
+      else
+        self.parent = options.fetch(:parent, nil)
+        self.grouping = options.fetch(:grouping, nil)
+        self.other = options.fetch(:other, nil)
+        self.category = options.fetch(:category, nil)
+
+        if block_given?
+          block[self]
+        end
+      end
+    end
+
+    def serialize(version)
+      node = {}
+      if parent && parent.any?
+        if version == TinCanApi::TCAPIVersion::V095 && parent.size > 1
+          raise TinCanApi::Errors::IncompatibleTCAPIVersion, "Version #{version.to_s} doesn't support lists of activities (parent)"
+        end
+        if version == TinCanApi::TCAPIVersion::V095
+          node['parent'] = parent.first.serialize(version)
+        else
+          node['parent'] = parent.map {|element| element.serialize(version)}
+        end
+      end
+
+      if grouping && grouping.any?
+        if version == TinCanApi::TCAPIVersion::V095 && grouping.size > 1
+          raise TinCanApi::Errors::IncompatibleTCAPIVersion, "Version #{version.to_s} doesn't support lists of activities (grouping)"
+        end
+        if version == TinCanApi::TCAPIVersion::V095
+          node['grouping'] = grouping.first.serialize(version)
+        else
+          node['grouping'] = grouping.map {|element| element.serialize(version)}
+        end
+      end
+
+      if other && other.any?
+        if version == TinCanApi::TCAPIVersion::V095 && other.size > 1
+          raise TinCanApi::Errors::IncompatibleTCAPIVersion, "Version #{version.to_s} doesn't support lists of activities (other)"
+        end
+        if version == TinCanApi::TCAPIVersion::V095
+          node['other'] = other.first.serialize(version)
+        else
+          node['other'] = other.map {|element| element.serialize(version)}
+        end
+      end
+
+      if category && category.any?
+        if version.ordinal <= TinCanApi::TCAPIVersion::V100.ordinal
+          node['category'] = category.map {|element| element.serialize(version)}
+        else
+          raise TinCanApi::Errors::IncompatibleTCAPIVersion, "Version #{version.to_s} doesn't support the category context activity"
+        end
+      end
+
+      node
+    end
+
+  end
+end

data/lib/tin_can_api/documents/activity_profile_document.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module TinCanApi
+  module Documents
+    class ActivityProfileDocument < Document
+
+      attr_accessor :activity
+
+      def initialize(&block)
+        super(&block)
+      end
+
+    end
+  end
+end
+

data/lib/tin_can_api/documents/agent_profile_document.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module TinCanApi
+  module Documents
+    class AgentProfileDocument < Document
+
+      attr_accessor :agent
+
+      def initialize(&block)
+        super(&block)
+      end
+
+    end
+  end
+end
+

data/lib/tin_can_api/documents/document.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+module TinCanApi
+  module Documents
+    class Document
+
+      attr_accessor :id, :etag, :timestamp, :content_type, :content
+
+      def initialize(&block)
+        if block_given?
+          block[self]
+        end
+      end
+
+    end
+  end
+end
+
+require_relative 'activity_profile_document'
+require_relative 'agent_profile_document'
+require_relative 'state_document'

data/lib/tin_can_api/documents/state_document.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module TinCanApi
+  module Documents
+    class StateDocument < Document
+
+      attr_accessor :activity, :agent, :registration
+
+      def initialize(&block)
+        super(&block)
+      end
+
+    end
+  end
+end
+

data/lib/tin_can_api/enum.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+module TinCanApi
+  module Enum
+    CONVERT_PROC = Proc.new do
+      @values = constants.collect{|c| const_get(c)}.freeze
+
+      @values.each_with_index do |value, idx|
+        the_symbol = constants.find{|c| const_get(c) == value}
+        sig = class << value ; self end
+        sig.send :define_method, :name, proc{the_symbol}
+        sig.send :define_method, :ordinal, proc{idx}
+
+        if value.is_a? Hash
+          value.each do |k, v|
+            sig.send :define_method, k, (v.is_a?(Proc) ? v : proc{v})
+          end
+        end
+        value.freeze
+      end
+
+      class << self
+        alias :value_of :const_get
+      end
+
+      module_function
+      def each
+        @values.each { |v| yield v }
+      end
+      def values
+        @values
+      end
+      extend Enumerable
+
+      freeze
+    end
+
+    def self.extended extending_obj
+      extending_obj.module_eval &CONVERT_PROC
+    end
+  end
+
+end

data/lib/tin_can_api/errors.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+module TinCanApi
+  module Errors
+
+    # Raised when an incompatible version is used
+    IncompatibleTCAPIVersion = Class.new(StandardError)
+
+  end
+end