qalam_ims_lti 0.0.2

data/lib/ims/lti/serializers/base.rb

@@ -0,0 +1,125 @@
+module IMS::LTI::Serializers
+  class Base
+    class Filter
+      def initialize
+        @optionals = Set.new
+        @keys = {}
+        @serializables = Set.new
+        @serializable_lists = Set.new
+      end
+
+      def add_filter(name, opts={})
+        @optionals.add(name) if opts[:optional]
+        @keys[name] = opts[:key] if opts[:key]
+        @serializables.add(name) if opts[:serializable]
+        @serializable_lists.add(name) if opts[:list_of_serializables]
+      end
+
+      def options_for_attribute(attribute)
+        options = {}
+        options[:optional] = @optionals.include?(attribute) ? true : false
+        options[:key] = @keys[attribute]
+        options[:has_serializable] = @serializables.include?(attribute) ? true : false
+        options[:has_list_of_serializables] = @serializable_lists.include?(attribute) ? true : false
+        options
+      end
+
+      def filter(hash)
+        hash = optionals(hash)
+        hash = serializables(hash)
+        hash = serializable_lists(hash)
+        keys(hash) # Needs to happen last
+      end
+
+      private
+      def optionals(hash)
+        hash.reject { |k, v| @optionals.include?(k) && v.nil? }
+      end
+
+      def serializables(hash)
+        hash.reduce({}) do |memo, (k, v)|
+          memo[k] = @serializables.include?(k) ? serialize_serializable(v) : v
+          memo
+        end
+      end
+
+      def serialize_serializable(serializable)
+        return if serializable.nil?
+        serializable.as_json
+      end
+
+      def serializable_lists(hash)
+        hash.reduce({}) do |memo, (k, v)|
+          memo[k] = @serializable_lists.include?(k) ? serialize_serializable_list(v) : v
+          memo
+        end
+      end
+
+      def serialize_serializable_list(list)
+        return if list.nil?
+        list.map(&:as_json)
+      end
+
+      def keys(hash)
+        hash.reduce({}) do |memo, (k, v)|
+          key = @keys.include?(k) ? @keys[k] : k
+          memo[key] = v
+          memo
+        end
+      end
+    end
+
+    @filter = Filter.new
+    @attributes = Set.new
+
+    def self.inherited(subclass)
+      subclass.instance_variable_set(:@filter, Filter.new)
+      subclass.instance_variable_set(:@attributes, Set.new)
+    end
+
+    def self.set_attribute(name, opts={})
+      @attributes.add(name)
+      @filter.add_filter(name, opts)
+    end
+
+    def self.set_attributes(*names)
+      names.each { |name| set_attribute(name) }
+    end
+
+    def self.has_serializable(name, opts={})
+      opts[:serializable] = true
+      opts[:list_of_serializables] = false
+      set_attribute(name, opts)
+    end
+
+    def self.has_list_of_serializables(name, opts={})
+      opts[:list_of_serializables] = true
+      opts[:serializable] = false
+      set_attribute(name, opts)
+    end
+
+    def self.as_json(obj)
+      @filter.filter(base_hash(obj))
+    end
+
+    def self.to_json(obj)
+      as_json(obj).to_json
+    end
+
+    def self.options_for_attribute(attribute)
+      @filter.options_for_attribute(attribute)
+    end
+
+    def self.attributes
+      @attributes
+    end
+
+    private
+
+    def self.base_hash(obj)
+      h = {}
+      @attributes.each { |attribute| h[attribute] = obj.send(attribute) }
+      h
+    end
+  end
+end

data/lib/ims/lti/serializers/membership_service/agent_serializer.rb

@@ -0,0 +1,5 @@
+module IMS::LTI::Serializers::MembershipService
+  class AgentSerializer < IMS::LTI::Serializers::Base
+    set_attribute :id, key: :@id
+  end
+end

data/lib/ims/lti/serializers/membership_service/container_serializer.rb

@@ -0,0 +1,6 @@
+module IMS::LTI::Serializers::MembershipService
+  class ContainerSerializer < IMS::LTI::Serializers::Base
+    set_attribute :membership_predicate, key: :membershipPredicate
+    has_serializable :membership_subject, key: :membershipSubject
+  end
+end

data/lib/ims/lti/serializers/membership_service/context_serializer.rb

@@ -0,0 +1,9 @@
+module IMS::LTI::Serializers::MembershipService
+  class ContextSerializer < IMS::LTI::Serializers::Base
+    set_attribute :id, key: :@id
+    set_attribute :name
+    set_attribute :type, key: :@type
+    set_attribute :context_id, key: :contextId
+    has_list_of_serializables :membership
+  end
+end

data/lib/ims/lti/serializers/membership_service/lis_membership_container_serializer.rb

@@ -0,0 +1,9 @@
+module IMS::LTI::Serializers::MembershipService
+  class LISMembershipContainerSerializer < IMS::LTI::Serializers::Base
+    set_attribute :membership_predicate, key: :membershipPredicate
+    has_serializable :membership_subject, key: :membershipSubject
+    set_attribute :id, key: :@id
+    set_attribute :context, key: :@context
+    set_attribute :type, key: :@type
+  end
+end

data/lib/ims/lti/serializers/membership_service/lis_person_serializer.rb

@@ -0,0 +1,12 @@
+module IMS::LTI::Serializers::MembershipService
+  class LISPersonSerializer < IMS::LTI::Serializers::Base
+    set_attribute :id, key: :@id
+    set_attributes :name, :img, :email
+    set_attribute :family_name, key: :familyName
+    set_attribute :given_name, key: :givenName
+    set_attribute :result_sourced_id, key: :resultSourcedId
+    set_attribute :sourced_id, key: :sourcedId
+    set_attribute :user_id, key: :userId
+    set_attribute :sis_id, key: :sisId, optional: true
+  end
+end

data/lib/ims/lti/serializers/membership_service/membership_serializer.rb

@@ -0,0 +1,7 @@
+module IMS::LTI::Serializers::MembershipService
+  class MembershipSerializer < IMS::LTI::Serializers::Base
+    set_attribute :id, key: :@id
+    set_attributes :status, :role
+    has_serializable :member
+  end
+end

data/lib/ims/lti/serializers/membership_service/organization_serializer.rb

@@ -0,0 +1,8 @@
+module IMS::LTI::Serializers::MembershipService
+  class OrganizationSerializer < IMS::LTI::Serializers::Base
+    set_attribute :id, key: :@id
+    set_attribute :name
+    set_attribute :type, key: :@type
+    has_list_of_serializables :membership
+  end
+end

data/lib/ims/lti/serializers/membership_service/page_serializer.rb

@@ -0,0 +1,10 @@
+module IMS::LTI::Serializers::MembershipService
+  class PageSerializer < IMS::LTI::Serializers::Base
+    set_attribute :id, key: :@id
+    set_attribute :type, key: :@type
+    set_attribute :context, key: :@context
+    set_attribute :differences
+    set_attribute :next_page, key: :nextPage
+    has_serializable :page_of, key: :pageOf
+  end
+end

data/lib/ims/lti/serializers/membership_service/person_serializer.rb

@@ -0,0 +1,8 @@
+module IMS::LTI::Serializers::MembershipService
+  class PersonSerializer < IMS::LTI::Serializers::Base
+    set_attribute :id, key: :@id
+    set_attributes :name, :img
+    set_attribute :family_name, key: :familyName
+    set_attribute :given_name, key: :givenName
+  end
+end

data/lib/ims/lti/serializers/membership_service.rb

@@ -0,0 +1,13 @@
+module IMS::LTI::Serializers
+  module MembershipService
+    require_relative 'membership_service/agent_serializer'
+    require_relative 'membership_service/container_serializer'
+    require_relative 'membership_service/context_serializer'
+    require_relative 'membership_service/lis_membership_container_serializer'
+    require_relative 'membership_service/lis_person_serializer'
+    require_relative 'membership_service/membership_serializer'
+    require_relative 'membership_service/organization_serializer'
+    require_relative 'membership_service/page_serializer'
+    require_relative 'membership_service/person_serializer'
+  end
+end

data/lib/ims/lti/serializers.rb

@@ -0,0 +1,6 @@
+module IMS::LTI
+  module Serializers
+    require_relative 'serializers/base'
+    require_relative 'serializers/membership_service'
+  end
+end

data/lib/ims/lti/services/authentication_service.rb

@@ -0,0 +1,67 @@
+module IMS::LTI::Services
+  class AuthenticationService
+
+    attr_accessor :connection, :iss, :aud, :sub, :secret, :grant_type,
+                  :additional_claims, :additional_params
+    attr_writer :secret
+
+    def initialize(iss:, aud:, sub:, secret:)
+      @iss = iss
+      @aud = aud
+      @sub = sub
+      @secret = secret
+      @additional_claims = {}
+      @additional_params = {}
+      @grant_type = 'urn:ietf:params:oauth:grant-type:jwt-bearer'
+    end
+
+    def connection
+      @connection ||= Faraday.new
+    end
+
+    def access_token
+      access_token_request['access_token']
+    end
+
+    def expiration
+      expires_in = access_token_request['expires_in'].to_i
+      @_response_time + expires_in
+    end
+
+    def expired?
+      expiration < Time.now
+    end
+
+    def invalidate!
+      @_access_token_request = nil
+      @_response_time = nil
+    end
+
+    private
+
+    def access_token_request
+      @_access_token_request ||= begin
+        assertion = JSON::JWT.new(
+          iss: iss,
+          sub: sub,
+          aud: aud.to_s,
+          iat: Time.now.to_i,
+          exp: 1.minute.from_now,
+          jti: SecureRandom.uuid
+        )
+        assertion.merge!(@additional_claims)
+        assertion = assertion.sign(@secret, :HS256).to_s
+        body = {
+          grant_type: grant_type,
+          assertion: assertion
+        }
+        body.merge!(@additional_params)
+        response = connection.post(aud, body)
+        raise IMS::LTI::Errors::AuthenticationFailedError.new(response: response) unless response.success?
+        @_response_time = Time.now
+        response.body
+      end
+    end
+
+  end
+end

data/lib/ims/lti/services/message_authenticator.rb

@@ -0,0 +1,80 @@
+module IMS::LTI::Services
+  class MessageAuthenticator
+
+    attr_reader :launch_url, :params, :message, :simple_oauth_header, :signature, :consumer_key
+
+    def initialize(launch_url, params, secret)
+      @launch_url = launch_url
+      @params = params
+      @options, @parsed_params = parse_params(params)
+      @consumer_key = @options[:consumer_key]
+      @signature = @parsed_params.delete(:oauth_signature)
+      @secret = secret
+    end
+
+
+    def valid_signature?
+       message.jwt ? valid_jwt? : simple_oauth_header.valid?(signature: signature)
+    end
+
+    def message
+      @message ||= begin
+        m = IMS::LTI::Models::Messages::Message.generate(params)
+        m.launch_url = launch_url
+        m
+      end
+    end
+
+    def simple_oauth_header
+      @simple_oauth_header ||= begin
+        @simple_oauth_header = SimpleOAuth::Header.new(
+          :post, launch_url,
+          @parsed_params,
+          @options.merge(
+            {
+              consumer_key: consumer_key,
+              consumer_secret: @secret
+            }
+          )
+        )
+        @simple_oauth_header
+      end
+    end
+
+    def base_string
+      simple_oauth_header.send(:signature_base)
+    end
+
+    def signed_params
+      simple_oauth_header.signed_attributes.merge(@parsed_params)
+    end
+
+
+    private
+
+    def valid_jwt?
+      begin
+        jwt = JSON::JWT.decode(message.jwt, @secret)
+        aud1 = Addressable::URI.parse(jwt['aud'])
+        aud2 = Addressable::URI.parse(launch_url)
+        [aud1, aud2].each{ |aud| aud.fragment = '' }
+        aud1.normalize == aud2.normalize
+      rescue JSON::JWS::VerificationFailed
+        false
+      end
+    end
+
+    def parse_params(params)
+      params.inject([{}, {}]) do |array, (k, v)|
+        attr = k.to_s.sub('oauth_', '').to_sym
+        if SimpleOAuth::Header::ATTRIBUTE_KEYS.include?(attr)
+          array[0][attr] = v
+        else
+          array[1][k.to_sym] = v
+        end
+        array
+      end
+    end
+
+  end
+end

data/lib/ims/lti/services/oauth2_client.rb

@@ -0,0 +1,18 @@
+module IMS::LTI::Services
+
+  class OAuth2Client
+    attr_accessor :token, :base_url
+    attr_writer :connection
+
+    def initialize(token:, base_url: nil)
+      @base_url = base_url
+      @token = token
+    end
+
+    def connection
+      @connection ||= Faraday.new base_url do |conn|
+        conn.authorization :Bearer, token
+      end
+    end
+  end
+end

data/lib/ims/lti/services/tool_config.rb

@@ -0,0 +1,223 @@
+module IMS::LTI::Services
+  # Class used to represent an LTI configuration
+  #
+  # It can create and read the Common Cartridge XML representation of LTI links
+  # as described here: http://www.imsglobal.org/LTI/v1p1pd/ltiIMGv1p1pd.html#_Toc309649689
+  #
+  # == Usage
+  # To generate an XML configuration:
+  #
+  #    # Create a config object and set some options
+  #    tc = IMS::LTI::Services::ToolConfig.new(:title => "Example Sinatra Tool Provider", :launch_url => url)
+  #    tc.description = "This example LTI Tool Provider supports LIS Outcome pass-back."
+  #
+  #    # generate the XML
+  #    tc.to_xml
+  #
+  # Or to create a config object from an XML String:
+  #
+  #    tc = IMS::LTI::Services::ToolConfig.create_from_xml(xml)
+  class ToolConfig
+    attr_reader :custom_params, :extensions
+
+    attr_accessor :title, :description, :launch_url, :secure_launch_url,
+                  :icon, :secure_icon, :cartridge_bundle, :cartridge_icon,
+                  :vendor_code, :vendor_name, :vendor_description, :vendor_url,
+                  :vendor_contact_email, :vendor_contact_name
+
+    # Create a new ToolConfig with the given options
+    #
+    # @param opts [Hash] The initial options for the ToolConfig
+    def initialize(opts={})
+      @custom_params = opts.delete("custom_params") || {}
+      @extensions = opts.delete("extensions") || {}
+
+      opts.each_pair do |key, val|
+        self.send("#{key}=", val) if self.respond_to?("#{key}=")
+      end
+    end
+
+    # Create a ToolConfig from the given XML
+    #
+    # @param xml [String]
+    def self.create_from_xml(xml)
+      tc = ToolConfig.new
+      tc.process_xml(xml)
+
+      tc
+    end
+
+    def set_custom_param(key, val)
+      @custom_params[key] = val
+    end
+
+    def get_custom_param(key)
+      @custom_params[key]
+    end
+
+    # Set the extension parameters for a specific vendor
+    #
+    # @param ext_key [String] The identifier for the vendor-specific parameters
+    # @param ext_params [Hash] The parameters, this is allowed to be two-levels deep
+    def set_ext_params(ext_key, ext_params)
+      raise ArgumentError unless ext_params.is_a?(Hash)
+      @extensions[ext_key] = ext_params
+    end
+
+    def get_ext_params(ext_key)
+      @extensions[ext_key]
+    end
+
+    def set_ext_param(ext_key, param_key, val)
+      @extensions[ext_key] ||= {}
+      @extensions[ext_key][param_key] = val
+    end
+
+    def get_ext_param(ext_key, param_key)
+      @extensions[ext_key] && @extensions[ext_key][param_key]
+    end
+
+    # Namespaces used for parsing configuration XML
+    LTI_NAMESPACES = {
+      "xmlns" => 'http://www.imsglobal.org/xsd/imslticc_v1p0',
+      "blti" => 'http://www.imsglobal.org/xsd/imsbasiclti_v1p0',
+      "lticm" => 'http://www.imsglobal.org/xsd/imslticm_v1p0',
+      "lticp" => 'http://www.imsglobal.org/xsd/imslticp_v1p0',
+    }
+
+    # Parse tool configuration data out of the Common Cartridge LTI link XML
+    def process_xml(xml)
+      doc = REXML::Document.new xml
+      if root = REXML::XPath.first(doc, 'xmlns:cartridge_basiclti_link')
+        @title = get_node_text(root, 'blti:title')
+        @description = get_node_text(root, 'blti:description')
+        @launch_url = get_node_text(root, 'blti:launch_url')
+        @secure_launch_url = get_node_text(root, 'blti:secure_launch_url')
+        @icon = get_node_text(root, 'blti:icon')
+        @secure_icon = get_node_text(root, 'blti:secure_icon')
+        @cartridge_bundle = get_node_att(root, 'xmlns:cartridge_bundle', 'identifierref')
+        @cartridge_icon = get_node_att(root, 'xmlns:cartridge_icon', 'identifierref')
+
+        if vendor = REXML::XPath.first(root, 'blti:vendor')
+          @vendor_code = get_node_text(vendor, 'lticp:code')
+          @vendor_description = get_node_text(vendor, 'lticp:description')
+          @vendor_name = get_node_text(vendor, 'lticp:name')
+          @vendor_url = get_node_text(vendor, 'lticp:url')
+          @vendor_contact_email = get_node_text(vendor, '//lticp:contact/lticp:email')
+          @vendor_contact_name = get_node_text(vendor, '//lticp:contact/lticp:name')
+        end
+
+        if custom = REXML::XPath.first(root, 'blti:custom', LTI_NAMESPACES)
+          set_properties(@custom_params, custom)
+        end
+
+        REXML::XPath.each(root, 'blti:extensions', LTI_NAMESPACES) do |vendor_ext_node|
+          platform = vendor_ext_node.attributes['platform']
+          properties = {}
+          set_properties(properties, vendor_ext_node)
+          REXML::XPath.each(vendor_ext_node, 'lticm:options', LTI_NAMESPACES) do |options_node|
+            opt_name = options_node.attributes['name']
+            options = {}
+            set_properties(options, options_node)
+            properties[opt_name] = options
+          end
+
+          self.set_ext_params(platform, properties)
+        end
+
+      end
+    end
+
+    # Generate XML from the current settings
+    def to_xml(opts = {})
+      builder = Builder::XmlMarkup.new(:indent => opts[:indent] || 0)
+      builder.instruct!
+      builder.cartridge_basiclti_link("xmlns" => "http://www.imsglobal.org/xsd/imslticc_v1p0",
+                                      "xmlns:blti" => 'http://www.imsglobal.org/xsd/imsbasiclti_v1p0',
+                                      "xmlns:lticm" => 'http://www.imsglobal.org/xsd/imslticm_v1p0',
+                                      "xmlns:lticp" => 'http://www.imsglobal.org/xsd/imslticp_v1p0',
+                                      "xmlns:xsi" => "http://www.w3.org/2001/XMLSchema-instance",
+                                      "xsi:schemaLocation" => "http://www.imsglobal.org/xsd/imslticc_v1p0 http://www.imsglobal.org/xsd/lti/ltiv1p0/imslticc_v1p0.xsd http://www.imsglobal.org/xsd/imsbasiclti_v1p0 http://www.imsglobal.org/xsd/lti/ltiv1p0/imsbasiclti_v1p0p1.xsd http://www.imsglobal.org/xsd/imslticm_v1p0 http://www.imsglobal.org/xsd/lti/ltiv1p0/imslticm_v1p0.xsd http://www.imsglobal.org/xsd/imslticp_v1p0 http://www.imsglobal.org/xsd/lti/ltiv1p0/imslticp_v1p0.xsd"
+      ) do |blti_node|
+
+        %w{title description launch_url secure_launch_url icon secure_icon}.each do |key|
+          blti_node.blti key.to_sym, self.send(key) if self.send(key)
+        end
+
+        vendor_keys = %w{name code description url}
+        if vendor_keys.any? { |k| self.send("vendor_#{k}") } || vendor_contact_email
+          blti_node.blti :vendor do |v_node|
+            vendor_keys.each do |key|
+              v_node.lticp key.to_sym, self.send("vendor_#{key}") if self.send("vendor_#{key}")
+            end
+            if vendor_contact_email
+              v_node.lticp :contact do |c_node|
+                c_node.lticp :name, vendor_contact_name
+                c_node.lticp :email, vendor_contact_email
+              end
+            end
+          end
+        end
+
+        if !@custom_params.empty?
+          blti_node.tag!("blti:custom") do |custom_node|
+            @custom_params.keys.sort.each do |key|
+              val = @custom_params[key]
+              custom_node.lticm :property, val, 'name' => key
+            end
+          end
+        end
+
+        if !@extensions.empty?
+          @extensions.keys.sort.each do |ext_platform|
+            ext_params = @extensions[ext_platform]
+            blti_node.blti(:extensions, :platform => ext_platform) do |ext_node|
+              ext_params.keys.sort.each do |key|
+                val = ext_params[key]
+                if val.is_a?(Hash)
+                  ext_node.lticm(:options, :name => key) do |type_node|
+                    val.keys.sort.each do |p_key|
+                      p_val = val[p_key]
+                      type_node.lticm :property, p_val, 'name' => p_key
+                    end
+                  end
+                else
+                  ext_node.lticm :property, val, 'name' => key
+                end
+              end
+            end
+          end
+        end
+
+        blti_node.cartridge_bundle(:identifierref => @cartridge_bundle) if @cartridge_bundle
+        blti_node.cartridge_icon(:identifierref => @cartridge_icon) if @cartridge_icon
+
+      end
+    end
+
+    private
+
+    def get_node_text(node, path)
+      if val = REXML::XPath.first(node, path, LTI_NAMESPACES)
+        val.text
+      else
+        nil
+      end
+    end
+
+    def get_node_att(node, path, att)
+      if val = REXML::XPath.first(node, path, LTI_NAMESPACES)
+        val.attributes[att]
+      else
+        nil
+      end
+    end
+
+    def set_properties(hash, node)
+      REXML::XPath.each(node, 'lticm:property', LTI_NAMESPACES) do |prop|
+        hash[prop.attributes['name']] = prop.text
+      end
+    end
+
+  end
+end

data/lib/ims/lti/services/tool_consumer_profile_service.rb

@@ -0,0 +1,16 @@
+module IMS::LTI::Services
+  class ToolConsumerProfileService
+
+    attr_accessor :tcp
+
+    def initialize(tool_consumer_profile)
+      @tcp = tool_consumer_profile
+    end
+
+    def supports_capabilities?(capability, *capabilities)
+      capabilities.unshift(capability)
+      (capabilities - tcp.capabilities_offered).empty?
+    end
+
+  end
+end