qalam_ims_lti 0.0.2

data/lib/ims/lti/extensions/content.rb

@@ -0,0 +1,209 @@
+module IMS::LTI
+  module Extensions
+
+    # An LTI extension that adds support for content back to the consumer
+    #
+    #     # Initialize TP object with OAuth creds and post parameters
+    #     provider = IMS::LTI::ToolProvider.new(consumer_key, consumer_secret, params)
+    #     # add extension
+    #     provider.extend IMS::LTI::Extensions::Content::ToolProvider
+    #
+    # If the tool was launched as an content request and it supports the content extension
+    # you can redirect the user to the tool consumer using the return url helper methods.
+    # The tool consumer is then responsible for consuming the content.
+    #
+    #     #Check if a certain response type is available
+    #     if provider.accepts_url? do
+    #       #Generate the URL for the user
+    #       redirect provider.url_content_return_url(url)
+    #     end
+    #
+    module Content
+      module ToolProvider
+        include IMS::LTI::Extensions::ExtensionBase
+        include Base
+
+        # a list of the supported outcome data types
+        def accepted_content_types
+          return @content_types if @content_types
+          @content_types = []
+          if val = @ext_params["content_return_types"]
+            @content_types = val.split(',').map {|i| i.to_sym}
+          end
+
+          @content_types
+        end
+
+        def accepted_file_extensions
+          return @file_extensions if @file_extensions
+          @file_extensions = []
+          if val = @ext_params["content_file_extensions"]
+            @file_extensions = val.split(',').map {|i| i.downcase.strip}
+          end
+
+          @file_extensions
+        end
+
+        def accepts_file?(file_name = nil)
+          accepted_content_types.include?(:file) &&
+            ( file_name.nil? ||
+              accepted_file_extensions.empty? ||
+              accepted_file_extensions.any?{|ext| file_name.downcase[/#{ext}$/]} )
+        end
+
+        def accepts_url?
+          accepted_content_types.include?(:url)
+        end
+
+        def accepts_lti_launch_url?
+          accepted_content_types.include?(:lti_launch_url)
+        end
+
+        def accepts_image_url?
+          accepted_content_types.include?(:image_url)
+        end
+
+        def accepts_iframe?
+          accepted_content_types.include?(:iframe)
+        end
+
+        def accepts_oembed?
+          accepted_content_types.include?(:oembed)
+        end
+
+        def content_intended_use
+          @ext_params["content_intended_use"].to_sym if  @ext_params["content_intended_use"]
+        end
+
+        # check if the content extension is supported
+        def accepts_content?
+          !!@ext_params["content_return_types"]
+        end
+
+        # check if the consumer accepts a given type of content
+        def accepts_content_type?(content_type)
+          accepted_content_types.include? content_type.to_sym
+        end
+
+        #check the use of the content
+        def is_content_for? (intended_use)
+          content_intended_use == intended_use
+        end
+
+        def content_return_url
+          @ext_params["content_return_url"]
+        end
+
+        #generates the return url for file submissions
+        def file_content_return_url(url, text, content_type = nil)
+          url = CGI::escape(url)
+          text = CGI::escape(text)
+          content_type = CGI::escape(content_type) if content_type
+
+          return_url = "#{content_return_url}?return_type=file&url=#{url}&text=#{text}"
+          return_url = "#{return_url}&content_type=#{content_type}" if content_type
+
+          return return_url
+        end
+
+        #generates the return url for url submissions
+        def url_content_return_url(url, title = nil, text = 'link', target = '_blank')
+          url = CGI::escape(url)
+          text = CGI::escape(text)
+          target = CGI::escape(target)
+
+          return_url = "#{content_return_url}?return_type=url&url=#{url}&text=#{text}&target=#{target}"
+          return_url = "#{return_url}&title=#{CGI::escape(title)}" if title
+
+          return return_url
+        end
+
+        #generates the return url for lti launch submissions
+        def lti_launch_content_return_url(url, text='link', title=nil)
+          url = CGI::escape(url)
+          text = CGI::escape(text)
+
+          return_url = "#{content_return_url}?return_type=lti_launch_url&url=#{url}&text=#{text}"
+          return_url = "#{return_url}&title=#{CGI::escape(title)}" if title
+
+          return return_url
+        end
+
+        #generates the return url for image submissions
+        def image_content_return_url(url, width, height, alt = '')
+          url = CGI::escape(url)
+          width = CGI::escape(width.to_s)
+          height = CGI::escape(height.to_s)
+          alt = CGI::escape(alt)
+
+          "#{content_return_url}?return_type=image_url&url=#{url}&width=#{width}&height=#{height}&alt=#{alt}"
+        end
+
+        #generates the return url for iframe submissions
+        def iframe_content_return_url(url, width, height, title = nil)
+          url = CGI::escape(url)
+          width = CGI::escape(width.to_s)
+          height = CGI::escape(height.to_s)
+
+          return_url = "#{content_return_url}?return_type=iframe&url=#{url}&width=#{width}&height=#{height}"
+          return_url = "#{return_url}&title=#{CGI::escape(title)}" if title
+
+          return return_url
+        end
+
+        #generates the return url for oembed submissions
+        def oembed_content_return_url(url, endpoint)
+          url = CGI::escape(url)
+          endpoint = CGI::escape(endpoint)
+
+          "#{content_return_url}?return_type=oembed&url=#{url}&endpoint=#{endpoint}"
+        end
+      end
+
+      module ToolConsumer
+        include IMS::LTI::Extensions::ExtensionBase
+        include Base
+        
+        # a list of the content types accepted
+        #
+        #    tc.add_content_return_types=(['url', 'text'])
+        #    tc.add_content_return_types=("url,text")
+        def content_return_types=(val)
+          val = val.join(',') if val.is_a? Array
+          set_ext_param('content_return_types', val)
+        end
+
+        # a comma-separated string of the supported outcome data types
+        def content_return_types
+          get_ext_param('content_return_types')
+        end
+
+        def content_intended_use=(val)
+          set_ext_param('content_intended_use', val)
+        end
+
+        def content_intended_use
+          get_ext_param('content_intended_use')
+        end
+
+        # convenience method for setting support for homework content
+        def support_homework_content!
+          self.content_intended_use = 'homework'
+          self.content_return_types = 'file,url'
+        end
+
+        # convenience method for setting support for embed content
+        def support_embed_content!
+          self.content_intended_use = 'embed'
+          self.content_return_types = 'oembed,lti_launch_url,url,image_url,iframe'
+        end
+
+        # convenience method for setting support for navigation content
+        def support_navigation_content!
+          self.content_intended_use = 'navigation'
+          self.content_return_types = 'lti_launch_url'
+        end
+      end
+    end
+  end
+end

data/lib/ims/lti/extensions/outcome_data.rb

@@ -0,0 +1,216 @@
+module IMS::LTI
+  module Extensions
+
+    # An LTI extension that adds support for sending data back to the consumer
+    # in addition to the score.
+    #
+    #     # Initialize TP object with OAuth creds and post parameters
+    #     provider = IMS::LTI::ToolProvider.new(consumer_key, consumer_secret, params)
+    #     # add extension
+    #     provider.extend IMS::LTI::Extensions::OutcomeData::ToolProvider
+    #
+    # If the tool was launch as an outcome service and it supports the data extension
+    # you can POST a score to the TC.
+    # The POST calls all return an OutcomeResponse object which can be used to
+    # handle the response appropriately.
+    #
+    #     # post the score to the TC, score should be a float >= 0.0 and <= 1.0
+    #     # this returns an OutcomeResponse object
+    #     if provider.accepts_outcome_text?
+    #       response = provider.post_extended_replace_result!(score: score, text: "submission text")
+    #     else
+    #       response = provider.post_replace_result!(score)
+    #     end
+    #     if response.success?
+    #       # grade write worked
+    #     elsif response.processing?
+    #     elsif response.unsupported?
+    #     else
+    #       # failed
+    #     end
+    module OutcomeData
+
+      #IMS::LTI::Extensions::OutcomeData::ToolProvider
+      module Base
+        def outcome_request_extensions
+          super + [IMS::LTI::Extensions::OutcomeData::OutcomeRequest]
+        end
+      end
+
+      module ToolProvider
+        include IMS::LTI::Extensions::ExtensionBase
+        include Base
+
+        # a list of the supported outcome data types
+        def accepted_outcome_types
+          return @outcome_types if @outcome_types
+          @outcome_types = []
+          if val = @ext_params["outcome_data_values_accepted"]
+            @outcome_types = val.split(',')
+          end
+
+          @outcome_types
+        end
+
+        # check if the outcome data extension is supported
+        def accepts_outcome_data?
+          !!@ext_params["outcome_data_values_accepted"]
+        end
+
+        # check if the consumer accepts text as outcome data
+        def accepts_outcome_text?
+          accepted_outcome_types.member?("text")
+        end
+
+        # check if the consumer accepts a url as outcome data
+        def accepts_outcome_url?
+          accepted_outcome_types.member?("url")
+        end
+
+        # check if the consumer accepts a submitted at date as outcome data
+        def accepts_submitted_at?
+          accepted_outcome_types.member?("submitted_at")
+        end
+
+        def accepts_outcome_lti_launch_url?
+          accepted_outcome_types.member?("lti_launch_url")
+        end
+
+        def accepts_outcome_result_total_score?
+          !!@ext_params["outcome_result_total_score_accepted"]
+        end
+
+        # POSTs the given score to the Tool Consumer with a replaceResult and
+        # adds the specified data. The data hash can have the keys "text", "cdata_text", "url", "submitted_at" or "lti_launch_url"
+        #
+        # If both cdata_text and text are sent, cdata_text will be used
+        #
+        # If score is nil, the replace result XML will not contain a resultScore node
+        #
+        # Creates a new OutcomeRequest object and stores it in @outcome_requests
+        #
+        # @return [OutcomeResponse] the response from the Tool Consumer
+        # @deprecated Use #post_extended_replace_result! instead
+        def post_replace_result_with_data!(score = nil, data={})
+          data[:score] = score if score
+          post_extended_replace_result!(data)
+        end
+
+        # POSTs the given score to the Tool Consumer with a replaceResult and
+        # adds the specified data. The options hash can have the keys
+        # :text, :cdata_text, :url, :submitted_at, :lti_launch_url, :score, or :total_score
+        #
+        # If both cdata_text and text are sent, cdata_text will be used
+        # If both total_score and score are sent, total_score will be used
+        # If score is nil, the replace result XML will not contain a resultScore node
+        #
+        # Creates a new OutcomeRequest object and stores it in @outcome_requests
+        #
+        # @return [OutcomeResponse] the response from the Tool Consumer
+        def post_extended_replace_result!(options = {})
+          opts = {}
+          options.each {|k,v| opts[k.to_sym] = v}
+
+          req = new_request
+          req.outcome_cdata_text = opts[:cdata_text]
+          req.outcome_text = opts[:text]
+          req.outcome_url = opts[:url]
+          req.submitted_at = opts[:submitted_at]
+          req.outcome_lti_launch_url = opts[:lti_launch_url]
+          req.total_score = opts[:total_score]
+          req.post_replace_result!(opts[:score])
+        end
+      end
+
+      module ToolConsumer
+        include IMS::LTI::Extensions::ExtensionBase
+        include Base
+
+        OUTCOME_DATA_TYPES = %w{text url lti_launch_url submitted_at}
+
+        # a list of the outcome data types accepted, currently only 'url', 'submitted_at' and
+        # 'text' are valid
+        #
+        #    tc.outcome_data_values_accepted(['url', 'text'])
+        #    tc.outcome_data_valued_accepted("url,text")
+        def outcome_data_values_accepted=(val)
+          if val.is_a? Array
+            val = val.join(',')
+          end
+
+          set_ext_param('outcome_data_values_accepted', val)
+        end
+
+        # a comma-separated string of the supported outcome data types
+        def outcome_data_values_accepted
+          get_ext_param('outcome_data_values_accepted')
+        end
+
+        # convenience method for setting support for all current outcome data types
+        def support_outcome_data!
+          self.outcome_data_values_accepted = OUTCOME_DATA_TYPES
+        end
+      end
+
+      module OutcomeRequest
+        include IMS::LTI::Extensions::ExtensionBase
+        include Base
+
+        attr_accessor :outcome_text, :outcome_url, :submitted_at, :outcome_lti_launch_url, :outcome_cdata_text, :total_score
+
+        def result_values(node)
+          super
+
+          if total_score
+            node.resultTotalScore do |res_total_score|
+              res_total_score.language "en" # 'en' represents the format of the number
+              res_total_score.textString total_score.to_s
+            end
+          end
+
+          if outcome_text || outcome_url || outcome_cdata_text || outcome_lti_launch_url
+            node.resultData do |res_data|
+              if outcome_cdata_text
+                res_data.text {
+                  res_data.cdata! outcome_cdata_text
+                }
+              elsif outcome_text
+                res_data.text outcome_text
+              elsif outcome_lti_launch_url
+                res_data.ltiLaunchUrl outcome_lti_launch_url
+              end
+              res_data.url outcome_url if outcome_url
+            end
+          end
+        end
+
+        def details(node)
+          super
+          return unless has_details_data?
+
+          node.submittedAt submitted_at
+        end
+
+        def score
+          total_score ? nil : @score
+        end
+
+        def has_result_data?
+          !!outcome_text || !!outcome_url || !!outcome_lti_launch_url || !!outcome_cdata_text || !!total_score || super
+        end
+
+        def has_details_data?
+          !!submitted_at
+        end
+
+        def extention_process_xml(doc)
+          super
+          @outcome_text = doc.get_text("//resultRecord/result/resultData/text")
+          @outcome_url = doc.get_text("//resultRecord/result/resultData/url")
+          @outcome_lti_launch_url = doc.get_text("//resultRecord/result/resultData/ltiLaunchUrl")
+        end
+      end
+
+    end
+  end
+end

data/lib/ims/lti/extensions.rb

@@ -0,0 +1,45 @@
+
+module IMS::LTI
+  module Extensions
+    
+    # Base functionality for creating LTI extension modules
+    # See the test for this class for a simple example of how to create an extension module
+    module Base
+      def outcome_request_extensions
+        []
+      end
+      
+      def outcome_response_extensions
+        []
+      end
+      
+      def extend_outcome_request(request)
+        outcome_request_extensions.each do |ext|
+          request.extend(ext)
+        end
+        request
+      end
+      
+      def extend_outcome_response(response)
+        outcome_response_extensions.each do |ext|
+          response.extend(ext)
+        end
+        response
+      end
+    end
+
+    module ExtensionBase
+      def outcome_request_extensions
+        super
+      end
+
+      def outcome_response_extensions
+        super
+      end
+    end
+  end
+end
+
+require 'ims/lti/extensions/outcome_data'
+require 'ims/lti/extensions/content'
+require 'ims/lti/extensions/canvas'

data/lib/ims/lti/launch_params.rb

@@ -0,0 +1,166 @@
+module IMS::LTI
+  # Mixin module for managing LTI Launch Data
+  #
+  # Launch data documentation:
+  # http://www.imsglobal.org/lti/v1p1pd/ltiIMGv1p1pd.html#_Toc309649684
+  module LaunchParams
+
+    # List of the standard launch parameters for an LTI launch
+    LAUNCH_DATA_PARAMETERS = %w{
+      accept_media_types
+      accept_multiple
+      accept_presentation_document_targets
+      accept_unsigned
+      auto_create
+      content_item_return_url
+      context_id
+      context_label
+      context_title
+      context_type
+      launch_presentation_css_url
+      launch_presentation_document_target
+      launch_presentation_height
+      launch_presentation_locale
+      launch_presentation_return_url
+      launch_presentation_width
+      lis_course_offering_sourcedid
+      lis_course_section_sourcedid
+      lis_outcome_service_url
+      lis_person_contact_email_primary
+      lis_person_name_family
+      lis_person_name_full
+      lis_person_name_given
+      lis_person_sourcedid
+      lis_result_sourcedid
+      lti_message_type
+      lti_version
+      oauth_callback
+      oauth_consumer_key
+      oauth_nonce
+      oauth_signature
+      oauth_signature_method
+      oauth_timestamp
+      oauth_version
+      resource_link_description
+      resource_link_id
+      resource_link_title
+      roles
+      role_scope_mentor
+      tool_consumer_info_product_family_code
+      tool_consumer_info_version
+      tool_consumer_instance_contact_email
+      tool_consumer_instance_description
+      tool_consumer_instance_guid
+      tool_consumer_instance_name
+      tool_consumer_instance_url
+      user_id
+      user_image
+    }
+
+    LAUNCH_DATA_PARAMETERS.each { |p| attr_accessor p }
+
+    # Hash of custom parameters, the keys will be prepended with "custom_" at launch
+    attr_accessor :custom_params
+
+    # Hash of extension parameters, the keys will be prepended with "ext_" at launch
+    attr_accessor :ext_params
+
+    # Hash of parameters to add to the launch. These keys will not be prepended
+    # with any value at launch
+    attr_accessor :non_spec_params
+
+    # Set the roles for the current launch
+    #
+    # Full list of roles can be found here:
+    # http://www.imsglobal.org/LTI/v1p1pd/ltiIMGv1p1pd.html#_Toc309649700
+    #
+    # LIS roles include:
+    # * Student
+    # * Faculty
+    # * Member
+    # * Learner
+    # * Instructor
+    # * Mentor
+    # * Staff
+    # * Alumni
+    # * ProspectiveStudent
+    # * Guest
+    # * Other
+    # * Administrator
+    # * Observer
+    # * None
+    #
+    # @param roles_list [String,Array] An Array or comma-separated String of roles
+    def roles=(roles_list)
+      if roles_list
+        if roles_list.is_a?(Array)
+          @roles = roles_list
+        else
+          @roles = roles_list.split(",")
+        end
+      else
+        @roles = nil
+      end
+    end
+
+    def set_custom_param(key, val)
+      @custom_params[key] = val
+    end
+
+    def get_custom_param(key)
+      @custom_params[key]
+    end
+
+    def set_non_spec_param(key, val)
+      @non_spec_params[key] = val
+    end
+
+    def get_non_spec_param(key)
+      @non_spec_params[key]
+    end
+
+    def set_ext_param(key, val)
+      @ext_params[key] = val
+    end
+
+    def get_ext_param(key)
+      @ext_params[key]
+    end
+
+    # Create a new Hash with all launch data. Custom/Extension keys will have the
+    # appropriate value prepended to the keys and the roles are set as a comma
+    # separated String
+    def to_params
+      params = launch_data_hash.merge(add_key_prefix(@custom_params, 'custom')).merge(add_key_prefix(@ext_params, 'ext')).merge(@non_spec_params)
+      params["roles"] = @roles.join(",") if @roles
+      params
+    end
+
+    # Populates the launch data from a Hash
+    #
+    # Only keys in LAUNCH_DATA_PARAMETERS and that start with 'custom_' or 'ext_'
+    # will be pulled from the provided Hash
+    def process_params(params)
+      params.each_pair do |key, val|
+        if LAUNCH_DATA_PARAMETERS.member?(key)
+          self.send("#{key}=", val)
+        elsif key =~ /\Acustom_(.+)\Z/
+          @custom_params[$1] = val
+        elsif key =~ /\Aext_(.+)\Z/
+          @ext_params[$1] = val
+        end
+      end
+    end
+
+    private
+
+    def launch_data_hash
+      LAUNCH_DATA_PARAMETERS.inject({}) { |h, k| h[k] = self.send(k) if self.send(k); h }
+    end
+
+    def add_key_prefix(hash, prefix)
+      hash.keys.inject({}) { |h, k| h["#{prefix}_#{k}"] = hash[k]; h }
+    end
+
+  end
+end

data/lib/ims/lti/models/base_url_choice.rb

@@ -0,0 +1,15 @@
+module IMS::LTI::Models
+  class BaseUrlChoice < LTIModel
+    add_attributes :default_base_url, :secure_base_url
+    add_attribute :selector, relation:'IMS::LTI::Models::BaseUrlSelector'
+
+    def default_message_url
+      if selector.nil? || (selector.applies_to && selector.applies_to.include?('MessageHandler'))
+        secure_base_url || default_base_url || ''
+      else
+        ''
+      end
+    end
+
+  end
+end

data/lib/ims/lti/models/base_url_selector.rb

@@ -0,0 +1,5 @@
+module IMS::LTI::Models
+  class BaseUrlSelector < LTIModel
+    add_attribute :applies_to
+  end
+end

data/lib/ims/lti/models/contact.rb

@@ -0,0 +1,5 @@
+module IMS::LTI::Models
+  class Contact < LTIModel
+    add_attributes :email
+  end
+end

data/lib/ims/lti/models/content_item_container.rb

@@ -0,0 +1,14 @@
+module IMS::LTI::Models
+  class ContentItemContainer < IMS::LTI::Models::LTIModel
+    add_attribute :context, json_key: '@context'
+    add_attribute :graph, json_key: '@graph', relation: 'IMS::LTI::Models::ContentItems::ContentItem'
+
+    CONTENT_ITEM_CONTAINER_CONTEXT = 'http://purl.imsglobal.org/ctx/lti/v1/ContentItem'
+
+    def initialize(opts = {})
+      super(opts)
+      self.context = CONTENT_ITEM_CONTAINER_CONTEXT
+    end
+
+  end
+end

data/lib/ims/lti/models/content_item_placement.rb

@@ -0,0 +1,20 @@
+module IMS::LTI::Models
+  class ContentItemPlacement < LTIModel
+
+    DOCUMENT_TARGETS = {
+      embed: 'http://purl.imsglobal.org/vocab/lti/v2/lti#embed',
+      frame: 'http://purl.imsglobal.org/vocab/lti/v2/lti#frame',
+      iframe: 'http://purl.imsglobal.org/vocab/lti/v2/lti#iframe',
+      none: 'http://purl.imsglobal.org/vocab/lti/v2/lti#none',
+      overlay: 'http://purl.imsglobal.org/vocab/lti/v2/lti#overlay',
+      popup: 'http://purl.imsglobal.org/vocab/lti/v2/lti#popup',
+      window: 'http://purl.imsglobal.org/vocab/lti/v2/lti#window'
+    }
+
+    add_attribute :display_height, json_key: 'displayHeight'
+    add_attribute :display_width, json_key: 'displayWidth'
+    add_attribute :window_target, json_key: 'windowTarget'
+    add_attribute :presentation_document_target, json_key: 'presentationDocumentTarget'
+
+  end
+end