qalam_ims_lti 0.0.2

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

@@ -0,0 +1,84 @@
+module IMS::LTI::Services
+  class ToolProxyRegistrationService
+    def initialize(registration_request)
+      @registration_request = registration_request
+    end
+
+    def tool_consumer_profile
+      return @tool_consumer_profile if @tool_consumer_profile
+
+      connection = Faraday.new
+      response = connection.get(@registration_request.tc_profile_url)
+      @tool_consumer_profile = IMS::LTI::Models::ToolConsumerProfile.new.from_json(response.body)
+    end
+
+    def service_profiles
+      tool_consumer_profile.services_offered.map(&:profile)
+    end
+
+    def register_tool_proxy(tool_proxy, reregistration_confirm_url = nil, shared_secret = nil)
+      service = tool_consumer_profile.services_offered.find { |s| s.formats.include?('application/vnd.ims.lti.v2.toolproxy+json') && s.actions.include?('POST') }
+
+      SimpleOAuth::Header::ATTRIBUTE_KEYS << :body_hash unless SimpleOAuth::Header::ATTRIBUTE_KEYS.include? :body_hash
+      tool_proxy_json = tool_proxy.to_json
+      body_hash = Digest::SHA1.base64digest tool_proxy_json
+
+      if reregistration?
+        consumer_key = tool_proxy.tool_proxy_guid
+        consumer_secret = shared_secret
+      else
+        consumer_key = @registration_request.reg_key
+        consumer_secret = @registration_request.reg_password
+      end
+
+      conn = Faraday.new do |conn|
+        conn.request :oauth, {:consumer_key => consumer_key, :consumer_secret => consumer_secret, :body_hash => body_hash}
+        conn.adapter :net_http
+      end
+
+      response = conn.post do |req|
+        req.url service.endpoint
+        req.headers['Content-Type'] = 'application/vnd.ims.lti.v2.toolproxy+json'
+        req.headers['VND-IMS-CONFIRM-URL'] = reregistration_confirm_url if reregistration_confirm_url
+        req.body = tool_proxy_json
+      end
+
+      if response.status == 201 || (response.status == 200 && reregistration?)
+        IMS::LTI::Models::ToolProxy.new.from_json(tool_proxy.to_json).from_json(response.body)
+      else
+        raise IMS::LTI::Errors::ToolProxyRegistrationError.new(response.status, response.body)
+      end
+    end
+
+
+    def remove_invalid_capabilities!(message_handler)
+      {
+        invalid_capabilities: remove_capabilites!(message_handler),
+        invalid_parameters: remove_params!(message_handler)
+      }
+    end
+
+    private
+
+    def remove_params!(message_handler)
+      orig_parameters = message_handler.parameter || []
+      parameters = orig_parameters.select {|p| p.fixed? || tool_consumer_profile.capability_offered.include?(p.variable)}
+      message_handler.parameter = parameters
+      orig_parameters - parameters
+    end
+
+    def remove_capabilites!(message_handler)
+      orig_capabilities = message_handler.enabled_capability || []
+      capabilites = orig_capabilities & tool_consumer_profile.capability_offered
+      capabilites.reject! { |cap| IMS::LTI::Models::ToolConsumerProfile::MESSAGING_CAPABILITIES.include? cap }
+      message_handler.enabled_capability = capabilites
+      orig_capabilities - capabilites
+    end
+
+    def reregistration?
+      @registration_request.is_a?(IMS::LTI::Models::Messages::ToolProxyUpdateRequest)
+    end
+
+
+  end
+end

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

@@ -0,0 +1,182 @@
+module IMS::LTI::Services
+  class ToolProxyValidator
+
+    attr_reader :tool_proxy
+
+    def initialize(tool_proxy)
+      @tool_proxy = tool_proxy
+    end
+
+    def tool_consumer_profile
+      return @tool_consumer_profile if @tool_consumer_profile
+
+      connection = Faraday.new
+      response = connection.get(tool_proxy.tool_consumer_profile)
+      @tool_consumer_profile = IMS::LTI::Models::ToolConsumerProfile.new.from_json(response.body)
+      @tool_consumer_profile
+    end
+
+    def tool_consumer_profile=(tcp)
+      tcp = IMS::LTI::Models::ToolConsumerProfile.from_json(tcp) unless tcp.is_a?(IMS::LTI::Models::ToolConsumerProfile)
+      if tool_proxy.tool_consumer_profile != tcp.id
+        raise IMS::LTI::Errors::InvalidToolConsumerProfile, "Tool Consumer Profile @id doesn't match the Tool Proxy"
+      end
+      @tool_consumer_profile = tcp
+    end
+
+    def capabilities_offered
+      tool_consumer_profile.capabilities_offered
+    end
+
+    def invalid_services
+      services = tool_proxy.security_contract.services
+      services_used = services.each_with_object({}) do |s, hash|
+        hash[s.service.split('#').last.strip] = s.actions
+        hash
+      end
+      services_offered = tool_consumer_profile.services_offered.each_with_object({}) do |s, hash|
+        hash[s.id.split(':').last.split('#').last.strip] = s.actions
+        hash
+      end
+      invalid_services = services_used.each_with_object({}) do |(id, actions), hash|
+        if services_offered.keys.include?(id)
+          actions_used = normalize_strings(*services_offered[id])
+          actions_offered = normalize_strings(*actions)
+          invalid_actions = actions_offered - actions_used
+          hash[id] = invalid_actions unless invalid_actions.empty?
+        else
+          hash[id] = actions
+        end
+        hash
+      end
+      invalid_services
+    end
+
+    def invalid_message_handlers
+      ret_val = {}
+      tool_profile = tool_proxy.tool_profile
+      #singleton_message_handlers = tool_profile.messages
+      invalid_rhs = validate_resource_handlers(tool_profile.resource_handlers)
+      ret_val[:resource_handlers] = invalid_rhs unless invalid_rhs.empty?
+      invalid_singleton_message_handlers = validate_singleton_message_handlers(tool_profile.messages)
+      ret_val[:singleton_message_handlers] = invalid_singleton_message_handlers unless invalid_singleton_message_handlers.empty?
+      ret_val
+    end
+
+    def invalid_capabilities
+      tool_proxy.enabled_capabilities - capabilities_offered
+    end
+
+    def invalid_security_contract
+      ret_val = {}
+
+      is_split_secret_capable = tool_proxy.enabled_capabilities.include?('Security.splitSecret')
+      has_shared_secret = tool_proxy.security_contract.shared_secret != nil && !tool_proxy.security_contract.shared_secret.empty?
+      has_split_secret = tool_proxy.security_contract.tp_half_shared_secret != nil && !tool_proxy.security_contract.tp_half_shared_secret.empty?
+
+      if is_split_secret_capable
+        ret_val[:missing_secret] = :tp_half_shared_secret unless has_split_secret
+        ret_val[:invalid_secret_type] = :shared_secret if has_shared_secret
+      else
+        ret_val[:missing_secret] = :shared_secret unless has_shared_secret
+        ret_val[:invalid_secret_type] = :tp_half_shared_secret if has_split_secret
+      end
+
+      ret_val
+    end
+
+    def invalid_security_profiles
+      security_profiles = tool_proxy.tool_profile.security_profiles
+      array = security_profiles.each_with_object([]) do |sp, array|
+        tcp_sp = tool_consumer_profile.security_profile_by_name(security_profile_name: sp.security_profile_name)
+        if tcp_sp
+          supported_algorithms = sp.digest_algorithms & tcp_sp.digest_algorithms
+          unsupported_algorithms = sp.digest_algorithms - supported_algorithms
+          unless unsupported_algorithms.empty?
+            array << { name: sp.security_profile_name, algorithms: unsupported_algorithms }
+          end
+        else
+          array << { name: sp.security_profile_name }
+        end
+      end
+      array
+    end
+
+    def errors
+      ret_val = {}
+      ret_val[:invalid_security_contract] = invalid_security_contract unless invalid_security_contract.empty?
+      ret_val[:invalid_capabilities] = invalid_capabilities unless invalid_capabilities.empty?
+      ret_val[:invalid_message_handlers] = invalid_message_handlers unless invalid_message_handlers.empty?
+      ret_val[:invalid_services] = invalid_services unless invalid_services.empty?
+      ret_val[:invalid_security_profiles] = invalid_security_profiles unless invalid_security_profiles.empty?
+      ret_val
+    end
+
+    def valid?
+      errors.keys.empty?
+    end
+
+    private
+
+    def normalize_strings(string, *strings)
+      strings.push(string)
+      normalized = strings.map {|s| s.upcase.strip}
+      normalized
+    end
+
+    def validate_message_handlers(message_handlers)
+      message_handlers.each_with_object([]) do |mh, array|
+        invalid_capabilities = mh.enabled_capabilities - capabilities_offered
+        invalid_parameters = validate_parameters(mh.parameters)
+        if !invalid_parameters.empty? || !invalid_capabilities.empty?
+          hash = { message_type: mh.message_type, }
+          hash[:invalid_capabilities] = invalid_capabilities unless invalid_capabilities.empty?
+          hash[:invalid_parameters] = invalid_parameters unless invalid_parameters.empty?
+          array << hash
+        end
+        array
+      end
+    end
+
+    def validate_parameters(parameters)
+      parameters.each_with_object([]) do |p, array|
+        if !p.fixed? && !capabilities_offered.include?(p.variable)
+          array << { name: p.name, variable: p.variable }
+        end
+      end
+    end
+
+    def validate_message_types(message_handlers)
+      message_handlers.each_with_object([]) do |mh, array|
+        array << mh.message_type unless capabilities_offered.include?(mh.message_type)
+        array
+      end
+    end
+
+    def validate_resource_handlers(resource_handlers)
+      resource_handlers.each_with_object([]) do |rh, array|
+        invalid_message_types = validate_message_types(rh.messages)
+        invalid_mhs = validate_message_handlers(rh.messages)
+        if !invalid_mhs.empty? || !invalid_message_types.empty?
+          hash = {
+            code: rh.resource_type.code,
+          }
+          hash[:messages] = invalid_mhs unless invalid_mhs.empty?
+          hash[:invalid_message_types] = invalid_message_types unless invalid_message_types.empty?
+          array << hash
+        end
+        array
+      end
+    end
+
+    def validate_singleton_message_handlers(message_handlers)
+      hash = {}
+      invalid_messages = validate_message_handlers(message_handlers)
+      invalid_message_types = validate_message_types(message_handlers)
+      hash[:messages] = invalid_messages unless invalid_messages.empty?
+      hash[:invalid_message_types] = invalid_message_types unless invalid_message_types.empty?
+      hash
+    end
+
+  end
+end

data/lib/ims/lti/services.rb

@@ -0,0 +1,11 @@
+module IMS::LTI
+  module Services
+    require_relative 'services/oauth2_client'
+    require_relative 'services/tool_proxy_registration_service'
+    require_relative 'services/tool_config'
+    require_relative 'services/tool_proxy_validator'
+    require_relative 'services/message_authenticator'
+    require_relative 'services/tool_consumer_profile_service'
+    require_relative 'services/authentication_service'
+  end
+end

data/lib/ims/lti/tool_base.rb

@@ -0,0 +1,29 @@
+module IMS::LTI
+  class ToolBase
+    include IMS::LTI::Extensions::Base
+    include IMS::LTI::LaunchParams
+    include IMS::LTI::RequestValidator
+
+    # OAuth credentials
+    attr_accessor :consumer_key, :consumer_secret
+
+    def initialize(consumer_key, consumer_secret, params={})
+      @consumer_key = consumer_key
+      @consumer_secret = consumer_secret
+      @custom_params = {}
+      @ext_params = {}
+      @non_spec_params = {}
+      process_params(params)
+    end
+
+    # Convenience method for doing oauth signed requests to services that
+    # aren't supported by this library
+    def post_service_request(url, content_type, body)
+      IMS::LTI::post_service_request(@consumer_key,
+                                     @consumer_secret,
+                                     url,
+                                     content_type,
+                                     body)
+    end
+  end
+end

data/lib/ims/lti/tool_config.rb

@@ -0,0 +1,231 @@
+module IMS::LTI
+  # 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::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::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)
+          set_options(properties, vendor_ext_node)
+          self.set_ext_params(platform, properties)
+        end
+
+      end
+    end
+
+    # Generate XML from the current settings
+    def to_xml(opts = {})
+      raise IMS::LTI::InvalidLTIConfigError, "A launch url is required for an LTI configuration." unless self.launch_url || self.secure_launch_url
+
+      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|
+                nest_xml(ext_node, key, ext_params[key])
+              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 nest_xml(ext_node, key, value)
+      if value.is_a?(Hash)
+        ext_node.lticm(:options, :name => key) do |type_node|
+          value.keys.sort.each do |sub_key|
+            nest_xml(type_node, sub_key, value[sub_key])
+          end
+        end
+      else
+        ext_node.lticm :property, value, 'name' => key
+      end
+    end
+
+    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
+
+    def set_options(hash, node)
+      REXML::XPath.each(node, 'lticm:options', LTI_NAMESPACES) do |options_node|
+        opt_name = options_node.attributes['name']
+        options = {}
+        set_properties(options, options_node)
+        set_options(options, options_node)
+        hash[opt_name] = options
+      end
+    end
+
+  end
+end

data/lib/ims/lti/tool_consumer.rb

@@ -0,0 +1,86 @@
+module IMS::LTI
+  # Class for implementing an LTI Tool Consumer
+  class ToolConsumer < ToolBase
+    attr_accessor :launch_url, :timestamp, :nonce
+
+    # Create a new ToolConsumer
+    #
+    # @param consumer_key [String] The OAuth consumer key
+    # @param consumer_secret [String] The OAuth consumer secret
+    # @param params [Hash] Set the launch parameters as described in LaunchParams
+    def initialize(consumer_key, consumer_secret, params={})
+      super(consumer_key, consumer_secret, params)
+      @launch_url = params['launch_url']
+    end
+    
+    def process_post_request(post_request)
+      request = extend_outcome_request(OutcomeRequest.new)
+      request.process_post_request(post_request)
+    end
+
+    # Set launch data from a ToolConfig
+    #
+    # @param config [ToolConfig]
+    def set_config(config)
+      @launch_url ||= config.secure_launch_url
+      @launch_url ||= config.launch_url
+      # any parameters already set will take priority
+      @custom_params = config.custom_params.merge(@custom_params)
+    end
+
+    # Check if the required parameters for a tool launch are set
+    def has_required_params?
+      @consumer_key && @consumer_secret && @resource_link_id && @launch_url
+    end
+
+    # Generate the launch data including the necessary OAuth information
+    #
+    #
+    def generate_launch_data
+      raise IMS::LTI::InvalidLTIConfigError, "Not all required params set for tool launch" unless has_required_params?
+
+      params = self.to_params
+      params['lti_version'] ||= 'LTI-1p0'
+      params['lti_message_type'] ||= 'basic-lti-launch-request'
+      uri = URI.parse(@launch_url)
+
+      if uri.port == uri.default_port
+        host = uri.host
+      else
+        host = "#{uri.host}:#{uri.port}"
+      end
+
+      consumer = OAuth::Consumer.new(@consumer_key, @consumer_secret, {
+              :site => "#{uri.scheme}://#{host}",
+              :signature_method => "HMAC-SHA1"
+      })
+
+      path = uri.path
+      path = '/' if path.empty?
+      if uri.query && uri.query != ''
+        CGI.parse(uri.query).each do |query_key, query_values|
+          unless params[query_key]
+            params[query_key] = query_values.first
+          end
+        end
+      end
+      options = {
+              :scheme => 'body',
+              :timestamp => @timestamp,
+              :nonce => @nonce
+      }
+      request = consumer.create_signed_request(:post, path, nil, options, params)
+
+      # the request is made by a html form in the user's browser, so we
+      # want to revert the escapage and return the hash of post parameters ready
+      # for embedding in a html view
+      hash = {}
+      request.body.split(/&/).each do |param|
+        key, val = param.split(/=/).map { |v| CGI.unescape(v) }
+        hash[key] = val
+      end
+      hash
+    end
+
+  end
+end