qalam_ims_lti 0.0.2

data/lib/ims/lti/models/content_items/content_item.rb

@@ -0,0 +1,32 @@
+module IMS::LTI::Models::ContentItems
+  class ContentItem < IMS::LTI::Models::LTIModel
+
+    add_attributes :text, :title, :url, :confirmUrl
+    add_attribute :media_type, json_key: 'mediaType'
+    add_attribute :type, json_key: '@type'
+    add_attribute :id, json_key: '@id'
+    add_attribute :icon, relation: 'IMS::LTI::Models::Image'
+    add_attribute :placement_advice, json_key:'placementAdvice', relation: 'IMS::LTI::Models::ContentItemPlacement'
+    add_attribute :thumbnail, relation: 'IMS::LTI::Models::Image'
+
+    TYPE = "ContentItem"
+
+    def initialize(attributes = {})
+      super(attributes)
+      self.type = TYPE
+    end
+
+    def self.from_json(json)
+      data = json.is_a?(String) ? JSON.parse(json) : json
+      case data['@type']
+      when 'FileItem'
+        FileItem.new.from_json(data)
+      when 'LtiLinkItem', 'LtiLink'
+        LtiLinkItem.new.from_json(data)
+      else
+        ContentItem.new.from_json(data)
+      end
+    end
+
+  end
+end

data/lib/ims/lti/models/content_items/file_item.rb

@@ -0,0 +1,15 @@
+module IMS::LTI::Models::ContentItems
+  class FileItem < ContentItem
+
+    add_attribute :copy_advice, json_key: 'copyAdvice'
+    add_attribute :expires_at, json_key: 'expiresAt'
+
+    TYPE = "FileItem"
+
+    def initialize(attributes = {})
+      super(attributes)
+      self.type = TYPE
+    end
+
+  end
+end

data/lib/ims/lti/models/content_items/lti_link_item.rb

@@ -0,0 +1,14 @@
+module IMS::LTI::Models::ContentItems
+  class LtiLinkItem < ContentItem
+
+    add_attributes :custom
+
+    TYPE = "LtiLinkItem"
+
+    def initialize(attributes = {})
+      super(attributes)
+      self.type = TYPE
+    end
+
+  end
+end

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

@@ -0,0 +1,7 @@
+module IMS::LTI::Models
+  module ContentItems
+    require_relative 'content_items/content_item'
+    require_relative 'content_items/file_item'
+    require_relative 'content_items/lti_link_item'
+  end
+end

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

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

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

@@ -0,0 +1,6 @@
+module IMS::LTI::Models
+  class IconInfo < LTIModel
+    add_attributes :key, :icon_style
+    add_attribute :default_location, relation: 'IMS::LTI::Models::IconEndpoint'
+  end
+end

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

@@ -0,0 +1,7 @@
+module IMS::LTI::Models
+  class Image < LTIModel
+    add_attribute :id, json_key: '@id'
+    add_attributes :height, :width
+
+  end
+end

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

@@ -0,0 +1,12 @@
+module IMS::LTI::Models
+  class LocalizedName < LTIModel
+    add_attributes :default_value, :key
+
+    def initialize(default_value = nil, key = nil)
+      @default_value = default_value
+      @key = key
+      super()
+    end
+
+  end
+end

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

@@ -0,0 +1,12 @@
+module IMS::LTI::Models
+  class LocalizedText < LTIModel
+    add_attributes :default_value, :key
+
+    def initialize(default_value = nil, key = nil)
+      super()
+      @default_value = default_value
+      @key = key
+    end
+
+  end
+end

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

@@ -0,0 +1,227 @@
+module IMS::LTI::Models
+    require 'uri'
+  
+  class LTIModel
+    LTI_VERSION_2P0 = 'LTI-2p0'.freeze
+    LTI_VERSION_2P1 = 'LTI-2p1'.freeze
+
+    def initialize(attributes = {})
+      @ext_attributes = {}
+      @unknown_attributes = {}
+      self.attributes = attributes
+    end
+
+    def self.add_attributes(attribute, *attrs)
+      attrs.unshift(attribute)
+      attrs -= self.attributes
+      if attrs.size > 0
+        self.attributes += attrs
+        attr_accessor(attrs.shift, *attrs)
+      end
+    end
+
+    def self.add_attribute(attribute, options = {})
+      @serialization_options ||= {}
+      keys = @serialization_options.keys + options.keys
+      keys.each do |k|
+        @serialization_options[k] ||= {}
+        options.has_key?(k) ? @serialization_options[k][attribute] = options[k] : @serialization_options[k].delete(attribute)
+      end
+      unless self.attributes.include? attribute
+        self.attributes += [attribute]
+        attr_accessor(attribute)
+      end
+    end
+
+    def self.inherit_attributes(attrs)
+      attributes ||= []
+      self.attributes += attrs
+    end
+
+    def self.inherited(subclass)
+      subclass.inherit_attributes(self.attributes)
+      super
+    end
+
+    def self.from_json(json)
+      new.from_json(json)
+    end
+
+    def attributes
+      attrs = {}
+      self.class.attributes.each do |a|
+        value = instance_variable_get("@#{a.to_s}")
+        attrs[a.to_s] = value unless value == nil
+      end
+      attrs
+    end
+
+    def attributes=(attrs)
+      attrs.each do |k, v|
+        if self.class.attributes.include?(k.to_sym)
+          send(("#{k}=").to_sym, v)
+        elsif k.to_s =~ /^ext_/
+          @ext_attributes[k.to_sym] = v
+        else
+          warn("Unknown attribute '#{k}'")
+          @unknown_attributes[k.to_sym] = v
+        end
+      end
+    end
+
+    def as_json(options = {})
+      json_hash = attributes
+      serialization_attrs_for(:json_key).each { |attr| json_hash.delete(attr.to_s) }
+      serialization_attrs_for(:relation).each do |attr|
+        val = attributes[attr.to_s]
+        if val && val.is_a?(Array)
+          json_hash[json_key(attr)] = val.map { |v| v.as_json }
+        elsif val
+          json_hash[json_key(attr)] = val.as_json
+        end
+      end
+      json_hash = @unknown_attributes.merge(json_hash)
+      json_hash = @ext_attributes.merge(json_hash)
+      json_hash.merge! to_json_conversions
+      json_hash.merge! to_json_keys
+      json_hash
+    end
+
+    def to_json
+      self.as_json.to_json
+    end
+
+    def from_json(json)
+      json = json.to_json unless json.is_a?(String)
+      begin
+        data = JSON.parse(json)
+      rescue
+        data = JSON.parse(URI.unescape(json))
+      end
+
+      if data.is_a? Array
+        data.map { |hash| self.class.from_json(hash.to_json) }
+      else
+        process_json_hash(data)
+      end
+    end
+
+    def method_missing(meth, *args, &block)
+      proc = ->(attr, hash) {meth =~ /=$/ ? hash[attr] = args[0] : hash[attr] }
+      if (match = /^ext_([^=$]*)/.match(meth))
+        proc.call(match.to_s.to_sym, @ext_attributes)
+      elsif (match = /([^=$]*)/.match(meth))
+        proc.call(match.to_s.to_sym, @unknown_attributes)
+      else
+        super
+      end
+    end
+
+    private
+
+    def process_json_hash(hash)
+      change_json_keys_to_attrs!(hash)
+      hash.merge! from_json_conversions(hash)
+      deserialize_json_relations!(hash)
+      self.attributes=(hash)
+      self
+    end
+
+    def serialization_attrs_for(*keys)
+      Array.new(serialization_options.keys & keys).map { |opt| serialization_options[opt].keys }.flatten.uniq
+    end
+
+    def to_json_conversions
+      result = {}
+      if converters = serialization_options[:json_converter]
+        converters.each do |attr, converter|
+          value = attributes[attr.to_s]
+          result[json_key(attr)] = get_constant(converter).to_json_value(value) if value
+        end
+      end
+      result
+    end
+
+    def to_json_keys
+      result = {}
+      if attrs = serialization_attrs_for(:json_key)
+        conversion_attrs = serialization_attrs_for(:json_converter)
+        relation_attrs = serialization_attrs_for(:relation)
+        attrs.each { |attr| result[json_key(attr)] = attributes[attr.to_s] unless (conversion_attrs | relation_attrs).include?(attr) || attributes[attr.to_s].nil? }
+      end
+      result
+    end
+
+    def change_json_keys_to_attrs!(json_hash)
+      if attrs = serialization_attrs_for(:json_key)
+        attrs.each do |attr|
+          key = json_key(attr)
+          json_hash[attr.to_s] = json_hash.delete(key) if json_hash.has_key?(key)
+        end
+      end
+    end
+
+    def from_json_conversions(hash)
+      result = {}
+      if converters = serialization_options[:json_converter]
+        converters.each do |attr, converter|
+          result[attr] = get_constant(converter).from_json_value(hash[attr.to_s]) if hash[attr.to_s]
+        end
+      end
+      result
+    end
+
+    def deserialize_json_relations!(hash)
+      if relations = serialization_options[:relation]
+        attrs = {}
+        relations.each do |attr, relation|
+          hash_val = hash.delete(attr.to_s)
+          attrs[attr.to_s] = get_constant(relation).new.from_json(hash_val.to_json) if hash_val
+        end
+        self.attributes = attrs
+      end
+    end
+
+    def json_key(attr)
+      if json_keys = serialization_options[:json_key]
+        json_keys[attr] || attr
+      else
+        attr
+      end.to_s
+    end
+
+    def self.attributes
+      if self == LTIModel
+        @attributes || []
+      else
+        superclass.send(:attributes) | (@attributes || [])
+      end
+    end
+
+    def self.attributes=(attribs)
+      @attributes = attribs
+    end
+
+    def self.serialization_options()
+      @serialization_options ||= {}
+      if name == "IMS::LTI::Models::LTIModel"
+        @serialization_options
+      else
+        opts = superclass.send(:serialization_options) || {}
+        keys = opts.keys | @serialization_options.keys
+        keys.each_with_object({}) { |k, h| h[k] = (opts[k] || {}).merge(@serialization_options[k] || {}) }
+      end
+    end
+
+    def serialization_options
+      self.class.serialization_options
+    end
+
+    def get_constant(constant)
+      obj = Object
+      constant.split('::').each { |c| obj = obj.const_get(c) }
+      obj
+    end
+
+  end
+end

data/lib/ims/lti/models/membership_service/agent.rb

@@ -0,0 +1,11 @@
+module IMS::LTI::Models::MembershipService
+  class Agent
+    include IMS::LTI::Models::Serializable
+
+    attr_reader :id
+
+    def initialize(opts={})
+      @id = opts[:id]
+    end
+  end
+end

data/lib/ims/lti/models/membership_service/container.rb

@@ -0,0 +1,11 @@
+module IMS::LTI::Models::MembershipService
+  class Container
+    include IMS::LTI::Models::Serializable
+
+    attr_reader :membership_predicate, :membership_subject
+
+    def initialize(opts={})
+      @membership_subject = opts[:membership_subject]
+    end
+  end
+end

data/lib/ims/lti/models/membership_service/context.rb

@@ -0,0 +1,11 @@
+module IMS::LTI::Models::MembershipService
+  class Context < Organization
+    attr_reader :context_id
+
+    def initialize(opts={})
+      super(opts)
+      @type = 'Context'
+      @context_id = opts[:context_id]
+    end
+  end
+end

data/lib/ims/lti/models/membership_service/lis_membership_container.rb

@@ -0,0 +1,13 @@
+module IMS::LTI::Models::MembershipService
+  class LISMembershipContainer < Container
+    attr_reader :context, :type, :id
+
+    def initialize(opts={})
+      super(opts)
+      @id = opts[:id]
+      @context = 'http://purl.imsglobal.org/ctx/lis/v2/MembershipContainer'
+      @type = 'LISMembershipContainer'
+      @membership_predicate = 'http://www.w3.org/ns/org#membership'
+    end
+  end
+end

data/lib/ims/lti/models/membership_service/lis_person.rb

@@ -0,0 +1,14 @@
+module IMS::LTI::Models::MembershipService
+  class LISPerson < Person
+    attr_reader :email, :result_sourced_id, :sourced_id, :user_id, :sis_id
+
+    def initialize(opts={})
+      super(opts)
+      @email = opts[:email]
+      @result_sourced_id = opts[:result_sourced_id]
+      @sourced_id = opts[:sourced_id]
+      @user_id = opts[:user_id]
+      @sis_id = opts[:sis_id]
+    end
+  end
+end

data/lib/ims/lti/models/membership_service/membership.rb

@@ -0,0 +1,14 @@
+module IMS::LTI::Models::MembershipService
+  class Membership
+    include IMS::LTI::Models::Serializable
+
+    attr_reader :id, :status, :member, :role
+
+    def initialize(opts={})
+      @id = opts[:id]
+      @status = opts[:status]
+      @member = opts[:member]
+      @role = opts[:role]
+    end
+  end
+end

data/lib/ims/lti/models/membership_service/organization.rb

@@ -0,0 +1,14 @@
+module IMS::LTI::Models::MembershipService
+  class Organization
+    include IMS::LTI::Models::Serializable
+
+    attr_reader :id, :membership, :name, :type
+
+    def initialize(opts={})
+      @id = opts[:id]
+      @membership = opts[:membership]
+      @name = opts[:name]
+      @type = 'Organization'
+    end
+  end
+end

data/lib/ims/lti/models/membership_service/page.rb

@@ -0,0 +1,16 @@
+module IMS::LTI::Models::MembershipService
+  class Page
+    include IMS::LTI::Models::Serializable
+
+    attr_reader :id, :type, :context, :differences, :page_of, :next_page
+
+    def initialize(opts={})
+      @id = opts[:id]
+      @type = 'Page'
+      @context = 'http://purl.imsglobal.org/ctx/lis/v2/MembershipContainer'
+      @differences = opts[:differences]
+      @page_of = opts[:page_of]
+      @next_page = opts[:next_page]
+    end
+  end
+end

data/lib/ims/lti/models/membership_service/person.rb

@@ -0,0 +1,13 @@
+module IMS::LTI::Models::MembershipService
+  class Person < Agent
+    attr_reader :family_name, :name, :img, :given_name
+
+    def initialize(opts={})
+      super(opts)
+      @family_name = opts[:family_name]
+      @name = opts[:name]
+      @img = opts[:img]
+      @given_name = opts[:given_name]
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module IMS::LTI::Models
+  module MembershipService
+    require_relative 'membership_service/agent'
+    require_relative 'membership_service/person'
+    require_relative 'membership_service/lis_person'
+
+    require_relative 'membership_service/container'
+    require_relative 'membership_service/lis_membership_container'
+
+    require_relative 'membership_service/organization'
+    require_relative 'membership_service/context'
+
+    require_relative 'membership_service/membership'
+    require_relative 'membership_service/page'
+  end
+end

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

@@ -0,0 +1,14 @@
+module IMS::LTI::Models
+  class MessageHandler < LTIModel
+    add_attributes :message_type, :path, :enabled_capability
+    add_attribute :parameter, relation:'IMS::LTI::Models::Parameter'
+
+    def enabled_capabilities
+      [*enabled_capability]
+    end
+
+    def parameters
+      [*parameter]
+    end
+  end
+end

data/lib/ims/lti/models/messages/basic_lti_launch_request.rb

@@ -0,0 +1,24 @@
+module IMS::LTI::Models::Messages
+  class BasicLTILaunchRequest < RequestMessage
+
+    add_required_params :resource_link_id
+    add_recommended_params :context_id, :launch_presentation_return_url, :tool_consumer_instance_guid
+    add_optional_params :context_type, :role_scope_mentor, :user_image,
+                      :lis_outcome_service_url, :lis_person_sourced_id, :lis_result_sourcedid
+    add_deprecated_params :context_title, :context_label, :resource_link_title, :resource_link_description,
+                      :lis_person_name_given, :lis_person_name_family, :lis_person_name_full,
+                      :lis_person_contact_email_primary, :user_image, :lis_person_sourcedid,
+                      :lis_course_offering_sourcedid, :lis_course_section_sourcedid,
+                      :tool_consumer_info_product_family_code, :tool_consumer_info_product_family_version,
+                      :tool_consumer_instance_name, :tool_consumer_instance_description, :tool_consumer_instance_url,
+                      :tool_consumer_instance_contact_email, :tool_consumer_info_version
+
+    MESSAGE_TYPE = 'basic-lti-launch-request'
+
+    def initialize(attrs = {})
+      super(attrs)
+      self.lti_message_type = MESSAGE_TYPE
+    end
+
+  end
+end

data/lib/ims/lti/models/messages/content_item_selection.rb

@@ -0,0 +1,32 @@
+module IMS::LTI::Models::Messages
+  class ContentItemSelection < Message
+    add_optional_params :content_items, :data, :lti_msg, :lti_log, :lti_errormsg, :lti_errorlog
+
+    MESSAGE_TYPE = 'ContentItemSelection'
+
+    def initialize(attrs = {})
+      super(attrs)
+      self.lti_message_type = MESSAGE_TYPE
+    end
+
+    def content_items=(ci)
+      if ci.instance_of? String
+        container = IMS::LTI::Models::ContentItemContainer.from_json ci
+        @content_items = container.graph
+      else
+        @content_items = ci
+      end
+    end
+
+    def parameters
+      if content_items
+        params = self.class.send("parameters")
+        params.delete('content_items')
+        collect_attributes(params).merge({'content_items' => IMS::LTI::Models::ContentItemContainer.new(graph: content_items).to_json})
+      else
+        super
+      end
+    end
+
+  end
+end

data/lib/ims/lti/models/messages/content_item_selection_request.rb

@@ -0,0 +1,26 @@
+module IMS::LTI::Models::Messages
+  class ContentItemSelectionRequest < RequestMessage
+
+    add_required_params :accept_media_types, :accept_presentation_document_targets, :content_item_return_url
+    add_recommended_params :context_id,  :tool_consumer_instance_guid
+    add_optional_params :context_type, :role_scope_mentor, :user_image, :accept_unsigned, :accept_multiple,
+                        :accept_copy_advice, :text, :title, :data
+    add_deprecated_params :context_title, :context_label,
+                          :lis_person_name_given, :lis_person_name_family, :lis_person_name_full,
+                          :lis_person_contact_email_primary, :user_image, :lis_person_sourcedid,
+                          :lis_course_offering_sourcedid, :lis_course_section_sourcedid,
+                          :tool_consumer_info_product_family_code, :tool_consumer_info_product_family_version,
+                          :tool_consumer_instance_name, :tool_consumer_instance_description,
+                          :tool_consumer_instance_url, :tool_consumer_instance_contact_email,
+                          :tool_consumer_info_version
+
+    MESSAGE_TYPE = 'ContentItemSelectionRequest'
+
+    def initialize(attrs = {})
+      super(attrs)
+      self.lti_message_type = MESSAGE_TYPE
+    end
+
+
+  end
+end