ims-lti 1.2.6 → 2.0.0.beta.1

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

@@ -1,209 +0,0 @@
-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

@@ -1,240 +0,0 @@
-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") ||
-            @ext_params["ext_outcome_submission_submitted_at_accepted"] == "true"
-        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
-
-        def accepts_needs_additional_review?
-          @ext_params["ext_outcome_submission_needs_additional_review_accepted"] == "true"
-        end
-
-        def accepts_prioritize_non_tool_grade?
-          @ext_params["ext_outcome_submission_prioritize_non_tool_grade_accepted"] == "true"
-        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"
-        # "needs_additional_review", "prioritize_non_tool_grade", 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,
-        # :needs_additional_review, 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.needs_additional_review = opts[:needs_additional_review]
-          req.prioritize_non_tool_grade = opts[:prioritize_non_tool_grade]
-          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,
-                      :needs_additional_review,
-                      :prioritize_non_tool_grade
-
-        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 if submitted_at
-          node.needsAdditionalReview if needs_additional_review
-          node.prioritizeNonToolGrade if prioritize_non_tool_grade
-        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 || !!needs_additional_review || !!prioritize_non_tool_grade
-        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

@@ -1,45 +0,0 @@
-
-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

@@ -1,166 +0,0 @@
-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