lusi_api 0.1.11

data/lib/lusi_api/core/util.rb

@@ -0,0 +1,102 @@
+require 'date'
+
+
+module LUSI
+  module API
+    module Core
+      module Util
+
+
+        # Converts a LUSI year identity code into a numeric or LUSI::API::Calendar::Year instance representing the year
+        # If a lookup service is supplied, the identity code is resolved by a LUSI API call.
+        # Otherwise, the year is calculated as: year = year_identity.to_i + 1900
+        # @param year_identity [String] the year identity code
+        # @param lookup [LUSI::API::Lookup::LookupService] the LUSI lookup service
+        # @param as_instance [Boolean] if true, return a LUSI::API::Calendar::Year instance instead of a year
+        # @param offset [Integer] an offset (in years) to apply to the year
+        # @return [Integer] the year represented by the year identity code
+        def lusi_year(year_identity = nil, lookup = nil, as_instance: false, offset: 0)
+
+          # Convert the year identity to an integer
+          case
+            when year_identity.is_a?(LUSI::API::Calendar::Week)
+              year_identity = year_identity.year.identity.to_i
+            when year_identity.is_a?(LUSI::API::Calendar::Year)
+              year_identity = year_identity.identity.to_i
+            when year_identity.is_a?(String) && year_identity.length == 6
+              # Assume a 6-character string is an identity code
+              year_identity = year_identity.to_i
+            else
+              # Assume anything else is a year and convert it to an identity
+              year_identity = lusi_year_identity(year.to_i)
+          end
+
+          # Apply the offset
+          year_identity += offset.to_i
+
+          year_identity = "%06d" % year_identity
+          if lookup
+            year = lookup.lookup(:year, year_identity)
+            if as_instance
+              year
+            else
+              year ? year.full_year.to_i : nil
+            end
+          else
+            # Year identities are (year - 1900) zero-padded to six digits
+            year = year_identity.to_i + 1900
+            if as_instance
+              yy = year % 100
+              description = "%02s/%02s" % [yy, (yy + 1) % 100]
+              LUSI::API::Calendar::Year.new(nil, lookup, code: year_identity, description: description,
+                                            full_year: year.to_s)
+            else
+              year
+            end
+          end
+
+        end
+
+        # Converts a year into a LUSI year identity code
+        # @param year [Date, DateTime, Numeric, String, LUSI::API::Calendar::Week, LUSI::API::Calendar::Year] the year
+        # @param offset [Integer] an offset (in years) to apply to the year
+        # @return [String] the year identity code
+        def lusi_year_identity(year = nil, offset: 0)
+
+          offset = offset.to_i
+
+          # Get the year as an integer
+          # If the year is provided as an identity, it's converted to a numeric year
+          year_identity = nil
+          case
+            when year.is_a?(LUSI::API::Calendar::Week)
+              year_identity = year.year.identity
+            when year.is_a?(LUSI::API::Calendar::Year)
+              year_identity = year.identity
+            when year.is_a?(Date) || year.is_a?(DateTime) || year.is_a?(Time)
+              year = year.year
+            when year.is_a?(String)
+              if year.length == 6
+                year_identity = year
+              else
+                year = year.to_i
+              end
+            when year.is_a?(Numeric)
+              year = year.to_i
+            else
+              year = Time.now.year
+          end
+          year = year_identity.to_i + 1900 if year_identity
+
+          # Return the year identity for the year with offset applied
+          "%06d" % (year + offset - 1900)
+
+        end
+
+        # Creates a LUSI Year instance from a year
+        #
+
+      end
+    end
+  end
+end

data/lib/lusi_api/core/xml.rb

@@ -0,0 +1,168 @@
+require 'date'
+require 'nokogiri'
+
+
+module LUSI
+  module API
+    module Core
+      module XML
+
+        NAMESPACE = 'Uol.Cis.Lusi.WebService'
+
+        def self.lookup(xml = nil, lookup = nil, service = nil,  path = nil, default = nil, &block)
+          return default if xml.nil? || lookup.nil? || service.nil?
+          key = xml_content_at(xml, path)
+          result = lookup.lookup(service, key, default)
+          yield(result) if block_given?
+          result
+        end
+
+        def self.xml(xml = nil, path = nil, default = nil, filter: nil, &block)
+          _xml(xml, path, default, single: false, content: false, filter: filter, &block)
+        end
+
+        def self.xml_at(xml = nil, path = nil, default = nil, &block)
+          _xml(xml, path, default, single: true, content: false, &block)
+        end
+
+        def self.xml_boolean(xml = nil, path = nil, default = nil, &block)
+          content = xml_content(xml, path, default)
+          content.map { |str| xml_boolean_parse(str, default) }
+        end
+
+        def self.xml_boolean_at(xml = nil, path = nil, default = nil, &block)
+          xml_boolean_parse(xml_content_at(xml, path, default), default)
+        end
+
+        def self.xml_boolean_parse(boolstr = nil, default = nil, true_values = nil, false_values = nil, &block)
+          boolstr = boolstr.to_s.downcase
+          false_values ||= ['false', 'n', 'no']
+          true_values ||= ['true', 'y', 'yes']
+          if true_values.include?(boolstr)
+            true
+          elsif false_values.include?(boolstr)
+            false
+          else
+            default
+          end
+        end
+
+        def self.xml_content(xml = nil, path = nil, default = nil, &block)
+          _xml(xml, path, default, single: false, content: true, &block)
+        end
+
+        def self.xml_content_at(xml = nil, path = nil, default = nil, &block)
+          _xml(xml, path, default, single: true, content: true, &block)
+        end
+
+        def self.xml_datetime(xml = nil, path = nil, default = nil, format = nil, &block)
+          content = xml_content(xml, path, default)
+          content.map { |str| xml_datetime_parse(str, default, format) }
+        end
+
+        def self.xml_datetime_at(xml = nil, path = nil, default = nil, format = nil, &block)
+          xml_datetime_parse(xml_content_at(xml, path, default), default, format)
+        end
+
+        def self.xml_datetime_parse(datestr = nil, default = nil, format = nil, &block)
+          return default if datestr.nil?
+          format ||= '%Y-%m-%dT%H:%M:%S'
+          begin
+            DateTime.strptime(datestr, format)
+          rescue Exception
+            default
+          end
+        end
+
+        def self.xml_float(xml = nil, path = nil, default = nil, &block)
+          content = xml_content(xml, path, default)
+          content.map { |str| xml_float_parse(str, default) }
+        end
+
+        def self.xml_float_at(xml = nil, path = nil, default = nil, &block)
+          xml_float_parse(xml_content_at(xml, path, default), default)
+        end
+
+        def self.xml_float_parse(floatstr, default = nil)
+          begin
+            floatstr.to_f
+          rescue
+            default
+          end
+        end
+
+        def self.xml_int(xml = nil, path = nil, default = nil, &block)
+          content = xml_content(xml, path, default)
+          content.map { |str| xml_int_parse(str, default) }
+        end
+
+        def self.xml_int_at(xml = nil, path = nil, default = nil, &block)
+          xml_int_parse(xml_content_at(xml, path, default), default)
+        end
+
+        def self.xml_int_parse(intstr, default = nil)
+          begin
+            intstr.to_i
+          rescue
+            default
+          end
+        end
+
+        protected
+
+        def self._xml(xml = nil, path = nil, default = nil, single: false, content: true, filter: nil, &block)
+
+          # Return the default value if no XML is given
+          return default if xml.nil?
+
+          # Return the XML value itself if it's not an accepted XML instance
+          return xml unless xml.is_a?(Nokogiri::XML::Node) or xml.is_a?(Nokogiri::XML::NodeSet)
+
+          if single
+            # Return the first matching node
+            result = xml.at_xpath(path)
+            if result.nil?
+              default
+            else
+              content ? result.content.to_s : result
+            end
+          else
+            # If a code block is provided, return an array of results of applying the block to each node, or an empty
+            # array if no matches exist.
+            # Otherwise return the matching nodeset, or nil of no matches exist
+            nodeset = xml.xpath(path)
+            if block
+              if nodeset.nil? then
+                # Return an empty array for an empty nodeset
+                []
+              elsif filter.nil?
+                # Apply the block to every node
+                if content
+                  nodeset.to_a.map { |node| block.call(node.content.to_s) }
+                else
+                  nodeset.to_a.map(&block)
+                end
+              else
+                # Apply the block only to nodes for which the filter returns true
+                result = []
+                if content
+                  nodeset.each { |node| result.push(node.content.to_s) if filter.call(node) }
+                else
+                  nodeset.each { |node| result.push(block.call(node)) if filter.call(node) }
+                end
+                result
+              end
+            else
+              if content
+                nodeset.to_a.map { |node| node.content.to_s }
+              else
+                nodeset
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/lusi_api/country.rb

@@ -0,0 +1,111 @@
+require 'lusi_api/core/code'
+require 'lusi_api/core/xml'
+
+
+module LUSI
+  module API
+    module Country
+
+      # Represents a country in the LUSI API
+      class Country < LUSI::API::Core::Code
+
+        # @!attribute [rw] iso_alpha2_code
+        #   @return [String, nil] the ISO alpha-2 code for the country
+        attr_accessor :iso_alpha2_code
+
+        # Initialises a new Country instance
+        # @param (see LUSI::API::Core::Code#initialize)
+        # @param iso_alpha2_code [String, nil] the default ISO alpha-2 code for the country
+        # @return [void]
+        def initialize(xml = nil, lookup = nil, iso_alpha2_code: nil, **kwargs)
+          super(xml, lookup, **kwargs)
+          @iso_alpha2_code = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:ISOAlpha2Code', iso_alpha2_code)
+        end
+
+        # Returns a string representation of the Country instance
+        # @return [String] the string representation of the Country instance
+        def to_s
+          @description
+        end
+
+      end
+
+
+      # Represents the country component of an address in the LUSI API
+      class AddressCountry < Country
+
+        # @!attribute [rw] region
+        #   @return [String. nil] the text description of the region of the address
+        attr_accessor :region
+
+        # Returns AddressCountry instances matching the supplied parameters
+        # @param (see LUSI::API::Country::Country#get_instance)
+        # @param iso_alpha2_code [String, nil] the ISO alpha-2 code to search for
+        # @param region [String, nil] the region to search for
+        # @return [Array<AddressCountry>, nil] the matching AddressCountry instances
+        # @yield [obj] Passes the AddressCountry instance to the block
+        # @yieldparam obj [LUSI::API::Country::AddressCountry] the AddressCountry instance
+        def self.get_instance(api = nil, lookup = nil, iso_alpha2_code: nil, region: nil, **kwargs)
+          super(api, lookup, 'LUSIReference', 'Lookup.asmx', 'GetAddressCountries', 'xmlns:AddressCountry',
+                iso_alpha2_code: iso_alpha2_code, region: region, **kwargs)
+        end
+
+        # Initialises a new AddressCountry instance
+        # @param (see Country#initialize)
+        # @param region [String, nil] the default region
+        # @return [void]
+        def initialize(xml = nil, lookup = nil, region: nil, **kwargs)
+          super(xml, lookup, **kwargs)
+          @region = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:Region', region)
+        end
+
+        protected
+
+        # Returns a parameter hash for the LUSI API call
+        # @params (see #get_instance)
+        # @return [Hash<String, any] the parameter hash for the LUSI API call
+        def self.get_instance_params(**kwargs)
+          params = super(**kwargs)
+          params[:ISOAlpha2Code] = kwargs[:iso_alpha2_code] || ''
+          params[:Region] = kwargs[:region] || ''
+          params
+        end
+
+      end
+
+
+      # Represents a nationality in the LUSI API
+      # @see Country
+      class Nationality < Country
+
+        # Returns Nationality instances matching the specified parameters
+        # @param api [LUSI::API::Core::API] the LUSI API instance
+        # @param lookup [LUSI::API::Core::Lookup::LookupService, nil] the lookup service for object resolution
+        # @param identity [String, nil] the identity to search for
+        # @param description [String, nil] the description to search for
+        # @param iso_alpha2_code [String, nil] the ISO alpha-2 code to search for
+        # @return [Array<Nationality>, nil] the matching Nationality instances
+        # @yield [obj] Passes the Nationality instance to the block
+        # @yieldparam obj [LUSI::API::Country::Nationality] the Nationality instance
+        def self.get_instance(api = nil, lookup = nil, iso_alpha2_code: nil, **kwargs)
+          super(api, lookup, 'LUSIReference', 'Lookup.asmx', 'GetNationalities', 'xmlns:Nationality',
+                iso_alpha2_code: iso_alpha2_code, **kwargs)
+        end
+
+        protected
+
+        # Returns a parameter hash for the LUSI API call
+        # @param (see #get_instance)
+        # @param iso_alpha2_code [String, nil] the ISO alpha-2 code to search for
+        # @return [Hash<String, any>] the parameter hash for the LUSI API call
+        def self.get_instance_params(iso_alpha2_code: nil, **kwargs)
+          params = super(**kwargs)
+          params[:ISOAlpha2Code] = kwargs[:iso_alpha2_code] || ''
+          params
+        end
+
+      end
+
+    end
+  end
+end

data/lib/lusi_api/course.rb

@@ -0,0 +1,1300 @@
+require 'lusi_api/core/code'
+require 'lusi_api/core/xml'
+require 'lusi_api/enrolment'
+require 'lusi_api/organisation'
+require 'lusi_api/person/staff'
+
+
+module LUSI
+  module API
+    module Course
+
+      public
+
+      # Represents the identity of a module or scheme of study
+      class Identity
+
+        # @!attribute [rw] asp
+        #   @return [String, nil] the academically-significant period (ASP)
+        attr_accessor :asp
+
+        # @!attribute [rw] course
+        #   @return [String, nil] the identity code of the module or scheme of study
+        attr_accessor :course
+
+        # @!attribute [rw] year
+        #   @return [String, nil] the identity code of the academic year
+        attr_accessor :year
+
+        # Initialises a new Identity instance
+        # @param xml [Nokogiri::XML::Document, Nokogiri::XML::Node] the parsed XML root of the identity
+        # @param lookup [LUSI::API::Core::Lookup::LookupService, nil] the lookup service for object resolution
+        # @param asp [String, nil] the default academically-significant period (ASP)
+        # @param course [String, nil] the default identity of the module or schemem of study
+        # @param year [String, nil] the default academic year identity code
+        # @return [void]
+        def initialize(xml = nil, lookup = nil, asp: nil, course: nil, year: nil)
+          @asp = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:ASP', asp)
+          @course = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:Course', course)
+          @year = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:Year', year)
+        end
+
+        # Returns a string suitable for use as a hash lookup key
+        # @return [String] the lookup key
+        def lookup_key
+          "#{course}-#{year}"
+        end
+
+        # Returns a string representation of the Identity instance
+        # @return [String] the string representation of the Identity instance
+        def to_s
+          "lusi-#{lookup_key}"
+        end
+
+      end
+
+
+      # Represents a module or scheme of study enrolment identity in the LUSI API
+      class EnrolmentIdentity < Identity
+
+        # @!attribute [rw] cohort
+        #   @return [Integer, nil] the identity code of the cohort for this course instance
+        attr_accessor :cohort
+
+        # Initialises a new EnrolmentIdentity instance
+        # @param (see LUSI::API::Course::Identity)
+        # @param cohort [Integer, nil] the default cohort identity code
+        # @return [void]
+        def initialize(xml = nil, lookup = nil, cohort: nil, **kwargs)
+          super(xml, lookup, **kwargs)
+          @cohort = LUSI::API::Core::XML.xml_int_at(xml, 'xmlns:Cohort', cohort)
+        end
+
+        # (see LUSI::API::Course::Identity#lookup_key)
+        def lookup_key
+          "#{super}-#{cohort}"
+        end
+
+      end
+
+
+      # The abstract base class of Module and SchemeOfStudy
+      # @abstract Subclass and define:
+      #   identity_class = the class representing identity
+      #   lusi_ws_endpoint = the LUSI API endpoint
+      #   lusi_ws_method = the LUSI API method to retrieve instance data
+      #   lusi_ws_path = the LUSI API URL path
+      #   lusi_ws_xml_root = the root element name of the LUSI API XML response
+      class ModuleBase
+
+        extend LUSI::API::Core::Endpoint
+
+        # @!attribute [rw] category_level
+        #   @return [String, nil] the category (e.g. 'UG', 'PG')
+        attr_accessor :category_level
+
+        # @!attribute [rw] cohorts
+        #   @return [Array<LUSI::API::Course::Cohort>, nil] the list of associated cohorts
+        attr_accessor :cohorts
+
+        # @!attribute [rw] course_departments
+        #   @return [Array<LUSI::API::Course::CourseDepartment>, nil] the list of associated course departments
+        attr_accessor :course_departments
+
+        # @!attribute [rw] course_documents
+        #   @return [Array<LUSI::API::Course::CourseDocument>, nil] the list of associated course documents
+        attr_accessor :course_documents
+
+        # @!attribute [rw] credit
+        #   @return [String, nil] the credit point value
+        attr_accessor :credit
+
+        # @!attribute [rw] delivery_mode
+        #   @return [LUSI::API::Core::Code, nil] the mode of delivery
+        attr_accessor :delivery_mode
+
+        # @!attribute [rw] display_long_title
+        #   @return [String, nil] the long course title
+        attr_accessor :display_long_title
+
+        # @!attribute [rw] display_short_title
+        #   @return [String, nil] the short course title
+        attr_accessor :display_short_title
+
+        # @!attribute [rw] enrolled_students
+        #   @return [Integer, nil] the number of enrolled students
+        attr_accessor :enrolled_students
+
+        # @!attribute [rw] external_course_identity
+        #   @return [String, nil] the external course identity
+        attr_accessor :external_course_identity
+
+        # @!attribute [rw] identity
+        #   @return [LUSI::API::Course::Identity, nil] the course identity
+        attr_accessor :identity
+
+        # @!attribute [r] identity_class
+        #   @return [Class, nil] the class representing module/scheme of study identity
+        attr_reader :identity_class
+
+        # @!attribute [rw] learning_hours
+        #   @return [Integer, nil] the total number of learning hours
+        attr_accessor :learning_hours
+
+        # @!attribute [rw] mnemonic
+        #   @return [String, nil] the mnemonic for the course
+        attr_accessor :mnemonic
+
+        # @!attribute [rw] status
+        #   @return [String, nil] the status ('Live', 'Dormant', 'Draft' etc.)
+        attr_accessor :status
+
+        # @!attribute [rw] syllabus_rules
+        #   @return [Array<LUSI::API::Course::SyllabusRule>, nil] the list of associated syllabus rules
+        attr_accessor :syllabus_rules
+
+        # @!attribute [rw] teaching_institution
+        #   @return [LUSI::API::Organisation::Unit, nil] the teaching institution
+        attr_accessor :teaching_institution
+
+        # @!attribute [rw] title
+        #   @return [String, nil] the title
+        attr_accessor :title
+
+        # @!attribute [rw] year
+        #   @return [String, nil] the academic year
+        attr_accessor :year
+
+        # Returns an array of enrolment lookup table indices to search for this module/scheme of study
+        def enrolment_lookup_indices
+          []
+        end
+
+        # Returns an array of enrolment lookup table keys for this module/scheme of study
+        # @return [Array<String>] the enrolment lookup table keys
+        def enrolment_lookup_keys
+          self.cohorts.map { |cohort| "#{self.identity.lookup_key}-#{cohort.identity}" }
+        end
+
+        # Returns an array of instances matching the specified search criteria
+        # @param api [LUSI::API::Core::API] the LUSI API instance to use for searching
+        # @param (see #get_instance_params)
+        # @return [<Array<LUSI::API::Course::Module, LUSI::API::Course::SchemeOfStudy>] the list of matching instances
+        # @yield [obj] Passes the instance to the block
+        # @yieldparam obj [LUSI::API::Course::Module, LUSI::API::Course::SchemeOfStudy] the instance
+        def self.get_instance(api, lookup = nil, **kwargs)
+          # active_vle_spaces_only: nil)
+          params = get_instance_params(**kwargs)
+          xml = api.call(self.lusi_ws_path, self.lusi_ws_endpoint, self.lusi_ws_method, **params)
+          LUSI::API::Core::XML.xml(xml, "xmlns:#{self.lusi_ws_xml_root}") do |m|
+            obj = self.new(m, lookup)
+            yield(obj) if block_given?
+            obj
+          end
+        end
+
+        # Initialises a new ModuleBase instance
+        # @param xml [Nokogiri::XML::Document, Nokogiri::XML::Node] the parsed XML root of the module or scheme of study
+        # @param lookup [LUSI::API::Core::Lookup::LookupService, nil] the lookup service for object resolution
+        # @param category_level [String, nil] the default category
+        # @param cohort [LUSI::API::Course::Cohort, nil] the default cohort
+        # @param course_departments [Array<LUSI::API::Course::CourseDepartment>, nil] the default course departments
+        # @param course_documents [Array<LUSI::API::Course::CourseDocument>, nil] the default course documents
+        # @param credit [String, nil] the default credit point value
+        # @param delivery_mode [LUSI::API::Core::Code, nil] the default delivery mode
+        # @param display_long_title [String, nil] the default long title
+        # @param display_short_title [String, nil] the default short title
+        # @param enrolled_students [Integer, nil] the default number of enrolled students
+        # @param external_course_identity [String, nil] the default external course identity code
+        # @param identity [String, nil] the default identity code
+        # @param learning_hours [Integer, nil] the default number of learning hours
+        # @param mnemonic [String, nil] the default mnemonic
+        # @param subjects [Array<LUSI::API::Course::Subject>, nil] the default subjects
+        # @param status [String, nil] the default status
+        # @param syllabus_rules [Array<SyllabusRule>, nil] the default syllabus rules
+        # @param teaching_institution [LUSI::API::Organisation::Unit, nil] the default teaching institution
+        # @param title [String, nil] the default title
+        # @param year [String, nil] the default year
+        # @return [void]
+        def initialize(xml = nil, lookup = nil, category_level: nil, cohort: nil, course_departments: nil,
+                       course_documents: nil, credit: nil, delivery_mode: nil, display_long_title: nil,
+                       display_short_title: nil, enrolled_students: nil, external_course_identity: nil, identity: nil,
+                       learning_hours: nil, mnemonic: nil, subjects: nil, status: nil, syllabus_rules: nil,
+                       teaching_institution: nil, title: nil, year: nil)
+          @category_level = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:CategoryLevel', category_level)
+          @cohorts = LUSI::API::Core::XML.xml(xml, 'xmlns:Cohorts/xmlns:Cohort', cohort) { |c| Cohort.new(c, lookup) }
+          @course_departments = LUSI::API::Core::XML.xml(xml, 'xmlns:CourseDepartments/xmlns:CourseDepartment',
+                                                         course_departments) { |d| CourseDepartment.new(d, lookup) }
+          @course_documents = LUSI::API::Core::XML.xml(xml, 'xmlns:CourseDocuments/xmlns:CourseDocument',
+                                                       course_documents) { |c| CourseDocument.new(c, lookup) }
+          @credit = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:Credit', credit)
+          @delivery_mode = LUSI::API::Core::Code.new(LUSI::API::Core::XML.xml_at(xml, 'xmlns:DeliveryMode',
+                                                                                 delivery_mode), lookup)
+          @display_long_title = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:DisplayLongTitle', display_long_title)
+          @display_short_title = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:DisplayShortTitle',
+                                                                     display_short_title)
+          @external_course_identity = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:ExternalCourseIdentity',
+                                                                          external_course_identity)
+          @identity = Identity.new(LUSI::API::Core::XML.xml_at(xml, 'xmlns:Identity', identity), lookup)
+          @learning_hours = LUSI::API::Core::XML.xml_int_at(xml, 'xmlns:LearningHours', learning_hours)
+          @mnemonic = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:Mnemonic', mnemonic)
+          @status = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:Status', status)
+          @subjects = LUSI::API::Core::XML.xml(xml, 'xmlns:Subjects/xmlns:Subject', subjects) { |s| Subject.new(s, lookup) }
+          @syllabus_rules = LUSI::API::Core::XML.xml(xml, 'xmlns:SyllabusRules/xmlns:SyllabusRule',
+                                                     syllabus_rules) { |s| SyllabusRule.new(s, lookup) }
+          @teaching_institution = LUSI::API::Core::XML.lookup(xml, lookup, :institution,
+                                                              'xmlns:TeachingInstitution/xmlns:Identity',
+                                                              teaching_institution)
+          @title = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:Title', title)
+          @year = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:Year', year)
+        end
+
+
+        # Returns a hash of parameters for the LUSI API call. Subclasses may extend or override this method.
+        # @param asp_identity [String, nil] return instances matching this academic significant period (ASP)
+        # @param cohort_identity (String, nil) return instances matching this cohort identity
+        # @param course_identity [String, nil] return instances matching this course identity
+        # @param department_identity (String, nil) return instances matching this department identity
+        # @param external_course_identity [String, nil] return instances matching this external course identity
+        # @param include_course_documentation [Boolean, nil] include course documentation if true, otherwise omit it
+        # @param include_syllabus_rules [Boolean, nil] include syllabus rules if true, otherwise omit them
+        # @param live_only [Boolean, nil] return only live (active) instances if true, otherwise return all instances
+        # @param teaching_institution_id (String, nil) return instances matching this teaching institution
+        # @param year_identity (String, nil) return instances matching this year identity
+        # @return [Hash<String, String>] the parameter hash for the LUSI API call
+        def self.get_instance_params(**kwargs)
+          result = {
+            ASPIdentity: kwargs.fetch(:asp_identity, ''),
+            CohortIdentity: kwargs.fetch(:cohort_identity, ''),
+            CourseIdentity: kwargs.fetch(:course_identity, ''),
+            DepartmentIdentity: kwargs.fetch(:department_identity, ''),
+            ExternalCourseIdentity: kwargs.fetch(:external_course_identity, ''),
+            IncludeCourseDocumentation: kwargs.fetch(:include_course_documentation, false) ? 'true' : 'false',
+            IncludeSyllabusRules: kwargs.fetch(:include_syllabus_rules, false) ? 'true' : 'false',
+            LiveOnly: kwargs.fetch(:live_only, true) ? 'true' : 'false',
+            TeachingInstitutionId: kwargs.fetch(:teaching_institution_id, ''),
+            YearIdentity: kwargs.fetch(:year_identity, '')
+          }
+          if self.lusi_ws_endpoint == 'General.asmx'
+            # The General.asmx endpoint methods GetModuleDetails and GetSchemesOfStudy require an extra parameter
+            result[:ActiveVLESpaceOnly] = kwargs.fetch(:active_vle_space_only, true) ? 'true' : 'false'
+          end
+          result
+        end
+
+        #
+        # Returns the major departments for the module/scheme of study
+        # @return [Array<LUSI::API::Course::CourseDepartment>] the major departments
+        def major_departments
+          self.course_departments.select { |course_department| course_department.is_major_department }
+        end
+
+        protected
+
+        # Returns the class representing module/scheme of study identity
+        # @return [Class] the identity class
+        def self.identity_class
+          Identity
+        end
+
+        # @see (LUSI::API::Core::Endpoint#lusi_ws_endpoint)
+        def self.lusi_ws_endpoint
+          'CourseManager.asmx'
+        end
+
+        # @see (LUSI::API::Core::Endpoint#lusi_ws_path)
+        def self.lusi_ws_path
+          'LUSIReference'
+        end
+
+      end
+
+
+      #
+      #
+      # # The base class of ModuleEnrolment and SchemeOfStudyEnrolment
+      # class ModuleEnrolmentBase
+      #
+      #   # @!attribute [rw] module_identity
+      #   #   @return [LUSI::API::Course::EnrolmentIdentity, nil] the module identity
+      #   attr_accessor :identity
+      #
+      #   # @!attribute [rw] display_long_title
+      #   #   @return [String, nil] the long title of the module
+      #   attr_accessor :display_long_title
+      #
+      #   # @!attribute [rw] display_short_title
+      #   #   @return [String, nil] the short title of the module
+      #   attr_accessor :display_short_title
+      #
+      #   # @!attribute [rw] enrol_year
+      #   #  @return [String, nil] the year of enrolment
+      #   attr_accessor :enrol_year
+      #
+      #   # @!attribute [rw] mnemonic
+      #   #   @return [String, nil] the mnemonic of the module
+      #   attr_accessor :mnemonic
+      #
+      #   # @!attribute [rw] title
+      #   #   @return [String, nil] the title of the module
+      #   attr_accessor :title
+      #
+      #   # @!attribute [rw] cohort_end_date
+      #   #   @return [DateTime, nil] the end date of the cohort in local time
+      #   attr_accessor :cohort_end_date
+      #
+      #   # @!attribute [rw] cohort_end_date_utc
+      #   #   @return [DateTime, nil] the end date of the cohort in UTC
+      #   attr_accessor :cohort_end_date_utc
+      #
+      #   # @!attribute [rw] cohort_start_date
+      #   #   @return [DateTime, nil] the start date of the cohort in local time
+      #   attr_accessor :cohort_start_date
+      #
+      #   # @!attribute [rw] cohort_start_date_utc
+      #   #   @return [DateTime, nil] the start date of the cohort in UTC
+      #   attr_accessor :cohort_start_date_utc
+      #
+      #   # Initialises a new ModuleEnrolment instance
+      #   # @param xml [Nokogiri::XML::Document, Nokogiri::XML::Node] the parsed XML root of the module enrolment
+      #   # @param lookup [LUSI::API::Core::LookupTable, nil] the lookup service for object resolution
+      #   # @param student_identity [String, nil] the default student identity
+      #   # @param identity [LUSI::API::Course::EnrolmentIdentity, nil] the default enrolment identity
+      #   # @param display_long_title [String, nil] the default module long title
+      #   # @param display_short_title [String, nil] the default module short title
+      #   # @param enrol_year [String, nil] the default enrol year
+      #   # @param mnemonic [String, nil] the default module mnemonic
+      #   # @param title [String, nil] the default module title
+      #   # @param cohort_end_date [DateTime, nil] the default local-time cohort end date
+      #   # @param cohort_end_date_utc [DateTime, nil] the default UTC cohort end date
+      #   # @param cohort_start_date [DateTime, nil] the default local-time codhort start date
+      #   # @param cohort_start_date_utc [DateTime, nil] the default UTC cohort start date
+      #   # @return [void]
+      #   def initialize(xml = nil, lookup = nil, student_identity: nil, identity: nil, display_long_title: nil,
+      #                  display_short_title: nil, enrol_year: nil, mnemonic: nil, title: nil, department: nil,
+      #                  year_sos: nil, study_type: nil, talis_code: nil, cohort_end_date: nil, cohort_end_date_utc: nil,
+      #                  cohort_start_date: nil, cohort_start_date_utc: nil)
+      #     @student_identity = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:StudentIdentity', student_identity)
+      #     @identity = EnrolmentIdentity.new(LUSI::API::Core::XML.xml_at(xml, 'xmlns:Identity', identity), lookup)
+      #     @display_long_title = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:DisplayLongTitle', display_long_title)
+      #     @display_short_title = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:DisplayShortTitle',
+      #                                                                display_short_title)
+      #     @enrol_year = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:EnrolYear', enrol_year)
+      #     @mnemonic = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:Mnemonic', mnemonic)
+      #     @title = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:Title', title)
+      #     @cohort_end_date = LUSI::API::Core::XML.xml_datetime_at(xml, 'xmlns:CohortEndDate', cohort_end_date)
+      #     @cohort_end_date_utc = LUSI::API::Core::XML.xml_datetime_at(xml, 'xmlns:CohortEndDateUTC',
+      #                                                                 cohort_end_date_utc)
+      #     @cohort_start_date = LUSI::API::Core::XML.xml_datetime_at(xml, 'xmlns:CohortStartDate', cohort_start_date)
+      #     @cohort_start_date_utc = LUSI::API::Core::XML.xml_datetime_at(xml, 'xmlns:CohortStartDateUTC',
+      #                                                                   cohort_start_date_utc)
+      #   end
+      #
+      # end
+
+
+      # Mixin for staff user details
+      module StaffEndpoint
+        # @see (LUSI::API::Core::Endpoint#lusi_ws_path)
+        def lusi_ws_endpoint
+          'Staff.asmx'
+        end
+      end
+
+
+      # Mixin for student user details
+      module StudentEndpoint
+        # @see (LUSI::API::Core::Endpoint#lusi_ws_path)
+        def lusi_ws_endpoint
+          'Student.asmx'
+        end
+      end
+
+
+      public
+
+      # Represents a module assessment proportion in the LUSI API
+      class AssessmentProportion
+
+        # @!attribute [rw] assessment_type
+        #   @return [LUSI::API::Core::Code, nil] the assessment type
+        attr_accessor :assessment_type
+
+        # @!attribute [rw] percentage
+        #   @return [Integer, nil] the percentage value
+        attr_accessor :percentage
+
+        # @!attribute [rw] assessment_status
+        #   @return [LUSI::API::Core::Code, nil] the assessment status
+        attr_accessor :assessment_status
+
+        # Initialises a new AssessmentProportion instance
+        # @param xml [Nokogiri::XML::Document, Nokogiri::XML::Node] the parsed XML root of the assessment proportion
+        # @param lookup [LUSI::API::Core::Lookup::LookupService, nil] the lookup service for object resolution
+        # @param assessment_status [LUSI::API::Core::Code, nil] the default assessment status
+        # @param assessment_type [LUSI::API::Core::Code, nil] the default assessment_type
+        # @param percentage [Integer, nil] the default percentage value
+        # @return [void]
+        def initialize(xml = nil, lookup = nil, assessment_status: nil, assessment_type: nil, percentage: nil)
+          @assessment_status = LUSI::API::Core::Code.new(LUSI::API::Core::XML.xml_at(xml, 'xmlns:AssessmentStatus',
+                                                                                     assessment_status), lookup)
+          @assessment_type = LUSI::API::Core::Code.new(LUSI::API::Core::XML.xml_at(xml, 'xmlns:AssessmentType',
+                                                                                   assessment_type), lookup)
+          @percentage = LUSI::API::Core::XML.xml_int_at(xml, 'xmlns:Percentage', percentage)
+        end
+
+        # Returns a string representation of the AssessmentProportion instance
+        # @return [String] the string representation of the AssessmentProportion instance
+        def to_s
+          "#{@assessment_type.description} #{percentage}%"
+        end
+
+      end
+
+
+      # Represents a cohort (student intake) in the LUSI API
+      class Cohort
+
+        # @!attribute [rw] display_long_title
+        #   @return [String, nil] the long title of the cohort
+        attr_accessor :display_long_title
+
+        # @!attribute [rw] display_short_title
+        #   @return [String, nil] the short title of the cohort
+        attr_accessor :display_short_title
+
+        # @!attribute [rw] end_date
+        #   @return [DateTime, nil] the end date of study
+        attr_accessor :end_date
+
+        # @!attribute [rw] identity
+        #   @return [Integer, nil] the identity code of the cohort
+        attr_accessor :identity
+
+        # @!attribute [rw] start_date
+        #   @return [DateTime, nil] the start date of study
+        attr_accessor :start_date
+
+        # Initialises a new Cohort instance
+        # @param xml [Nokogiri::XML::Document, Nokogiri::XML::Node] the parsed XML root of the cohort
+        # @param lookup [LUSI::API::Core::Lookup::LookupService, nil] the lookup service for object resolution
+        # @param display_long_title [String, nil] the default long title
+        # @param display_short_title [String, nil] the default short title
+        # @param end_date [DateTime, nil] the default end-of-study date
+        # @param identity [Integer, nil] the default identity code
+        # @param start_date [DateTime, nil] the default start-of-study date
+        # @return [void]
+        def initialize(xml = nil, lookup = nil, display_long_title: nil, display_short_title: nil, end_date: nil,
+                       identity: nil, start_date: nil)
+          @display_long_title = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:DisplayLongTitle', display_long_title)
+          @display_short_title = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:DisplayShortTitle', display_short_title)
+          @end_date = LUSI::API::Core::XML.xml_datetime_at(xml, 'xmlns:EndDate', end_date)
+          @identity = LUSI::API::Core::XML.xml_int_at(xml, 'xmlns:Identity', identity)
+          @start_date = LUSI::API::Core::XML.xml_datetime_at(xml, 'xmlns:StartDate', start_date)
+        end
+
+        # Returns a string representation of the Cohort instance
+        # @return [String] the string representation of the Cohort instance
+        def to_s
+          end_date = @end_date ? @end_date.strftime('%d-%m-%Y') : ''
+          start_date = @start_date ? @start_date.strftime('%d-%m-%Y') : ''
+          "#{@display_long_title || @display_short_title} #{start_date}-#{end_date}"
+        end
+  
+      end
+
+
+      # Represents a department participating in a course
+      class CourseDepartment
+
+        # @!attribute [rw] org_unit
+        #   @return [LUSI::API::Organisation::Unit] the organisation unit representing the department
+        attr_accessor :org_unit
+
+        # @!attribute [rw] identity
+        #   @return [String] the course department identity code
+        attr_accessor :identity
+
+        # @!attribute [rw] is_major_department
+        #   @return [Boolean] true if the department is the major (administering) department, otherwise false
+        attr_accessor :is_major_department
+
+        # @!attribute [rw] title
+        #   @return [String] the course department's title
+        attr_accessor :title
+
+        # Initialises a new CourseDepartment instance
+        # @param identity [String] the course department's identity code
+        # @param org_unit [LUSI::API::Organisation::Unit] the default organisation unit for the department
+        # @param is_major_department [Boolean, nil] the major (administering) department flag
+        # @param title [String] the course department's title
+        # @return [void]
+        def initialize(xml = nil, lookup = nil, identity: nil, is_major_department: nil, org_unit: nil, title: nil)
+          is_major_department = is_major_department ? true : false
+          @identity = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:Identity', identity)
+          @is_major_department = LUSI::API::Core::XML.xml_boolean_at(xml, 'xmlns:IsMajorDepartment', is_major_department)
+          @org_unit = LUSI::API::Core::XML.lookup(xml, lookup, :department, 'xmlns:Identity', org_unit)
+          @title = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:Title', title)
+        end
+
+      end
+
+
+      # Represents a course document in the LUSI API
+      class CourseDocument
+
+        # @!attribute [rw] type
+        #   @return [LUSI::API::Core::Code, nil] the course document type
+        attr_accessor :type
+
+        # @!attribute [rw] html_text
+        #  @return [String, nil] the text document as pre-formatted HTML
+        attr_accessor :html_text
+
+        # Initialises a new CourseDocument instance
+        # @param xml [Nokogiri::XML::Document, Nokogiri::XML::Node] the parsed XML root of the course document
+        # @param lookup [LUSI::API::Core::Lookup::LookupService, nil] the lookup service for object resolution
+        # @param type [LUSI::API::Core::Code, nil] the default document type
+        # @param html_text [String, nil] the default document text
+        # @return [void]
+        def initialize(xml = nil, lookup = nil, type: nil, html_text: nil)
+          @type = LUSI::API::Core::Code.new(LUSI::API::Core::XML.xml_at(xml, 'xmlns:Type', type), lookup)
+          @html_text = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:HTMLText', html_text)
+        end
+
+        # Returns a string representation of the CourseDocument instance
+        # @return [String] the string representation of the CourseDocument instance
+        def to_s
+          @type.description
+        end
+
+      end
+
+
+      # Represents the credit points for a scheme of study
+      class CreditPoints
+
+        # @!attribute [rw] total_part_1
+        #   @return [Integer, nil] the total number of credit points required at Part 1
+        attr_accessor :total_part_1
+
+        # @!attribute [rw] part_2_year_2
+        #   @return [Integer, nil] the number of Part 2 credit points required in year 2
+        attr_accessor :part_2_year_2
+
+        # @!attribute [rw] part_2_year_3
+        #   @return [Integer, nil] the number of Part 2 credit points required in year 3
+        attr_accessor :part_2_year_3
+
+        # @!attribute [rw] part_2_year_4
+        #   @return [Integer, nil] the number of Part 2 credit points required in year 4
+        attr_accessor :part_2_year_4
+
+        # @!attribute [rw] part_2_year_5
+        #   @return [Integer, nil] the number of Part 2 credit points required in year 5
+        attr_accessor :part_2_year_5
+
+        # @!attribute [rw] total_part_2
+        #   @return [Integer, nil] the total number of credit points required at Part 2
+        attr_accessor :total_part_2
+
+        # @!attribute [rw] total_overall
+        #   @return [Integer, nil] the total number of credit points required for the scheme of study
+        attr_accessor :total_overall
+
+        # Initialises a new CreditPoints instance
+        # @param xml [Nokogiri::XML::Document, Nokogiri::XML::Node] the parsed XML root of the credit points
+        # @param lookup [LUSI::API::Core::Lookup::LookupService, nil] the lookup service for object resolution
+        # @param part_2_year_2 [Integer, nil] the default part 2 year 2 credit points
+        # @param part_2_year_3 [Integer, nil] the default part 2 year 3 credit points
+        # @param part_2_year_4 [Integer, nil] the default part 2 year 4 credit points
+        # @param part_2_year_5 [Integer, nil] the default part 2 year 5 credit points
+        # @param total_overall [Integer, nil] the default overall total credit points
+        # @param total_part_1 [Integer, nil] the default part 1 total credit points
+        # @param total_part_2 [Integer, nil] the default part 2 total
+        # @return [void]
+        def initialize(xml = nil, lookup = nil, part_2_year_2: 0, part_2_year_3: 0, part_2_year_4: 0, part_2_year_5: 0,
+                       total_overall: 0, total_part_1: 0, total_part_2: 0)
+          @part_2_year_2 = LUSI::API::Core::XML.xml_int_at(xml, 'xmlns:Part2Year2', part_2_year_2)
+          @part_2_year_3 = LUSI::API::Core::XML.xml_int_at(xml, 'xmlns:Part2Year3', part_2_year_3)
+          @part_2_year_4 = LUSI::API::Core::XML.xml_int_at(xml, 'xmlns:Part2Year4', part_2_year_4)
+          @part_2_year_5 = LUSI::API::Core::XML.xml_int_at(xml, 'xmlns:Part2Year5', part_2_year_5)
+          @total_overall = LUSI::API::Core::XML.xml_int_at(xml, 'xmlns:TotalOverall', total_overall)
+          @total_part_1 = LUSI::API::Core::XML.xml_int_at(xml, 'xmlns:TotalPart1', total_part_1)
+          @total_part_2 = LUSI::API::Core::XML.xml_int_at(xml, 'xmlns:TotalPart2', total_part_2)
+        end
+
+        # Returns a string representation of the CreditPoints instance
+        # @return [String] the string representation of the CreditPoints instance
+        def to_s
+          "#{@total_overall}"
+        end
+
+      end
+
+
+      # Represents the length of a scheme of study
+      class Length
+
+        # @!attribute [rw] absolute_maximum
+        #   @return [String, nil] the absolute maximum scheme length
+        attr_accessor :absolute_maximum
+
+        # @!attribute [rw] maximum
+        #   @return [String, nil] the maximum scheme length
+        attr_accessor :maximum
+
+        # @!attribute [rw] minimum
+        #   @return [String, nil] the minimum scheme length
+        attr_accessor :minimum
+
+        # Initialises a new Length instance
+        # @param xml [Nokogiri::XML::Document, Nokogiri::XML::Node] the parsed XML root of the length
+        # @param lookup [LUSI::API::Core::Lookup::LookupService, nil] the lookup service for object resolution
+        # @param absolute_maximum [String, nil] the default absolute maximum scheme length
+        # @param maximum [String, nil] the default maximum scheme length
+        # @param minimum [String, nil] the default minimum scheme length
+        # @return [void]
+        def initialize(xml = nil, lookup = nil, absolute_maximum: nil, maximum: nil, minimum: nil)
+          @absolute_maximum = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:AbsoluteMaximum', absolute_maximum)
+          @maximum = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:Maximum', maximum)
+          @minimum = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:Minimum', minimum)
+        end
+
+        # Returns a string representation of the Length instance
+        # @return [String] the string representation of the SchemeLength instance
+        def to_s
+          "#{minimum} - #{maximum} (#{absolute_maximum})"
+        end
+
+      end
+
+
+      # Represents a module mark in the LUSI API
+      class Mark
+
+        # @!attribute [rw] overall_percentage
+        #   @return [Float, nil] the overall percentage mark for the module
+        attr_accessor :overall_percentage
+
+        # @!attribute [rw] overall_aggregation
+        #   @return [Float, nil] the overall aggregation score for the module
+        attr_accessor :overall_aggregation
+
+        # Initialises a new Mark instance
+        # @param xml [Nokogir::XML::Document, Nokogiri::XML::Node] the parsed XML root of the mark
+        # @param lookup [LUSI::API::Core::Lookup::LookupService, nil] the lookup service for object resolution
+        # @param overall_aggregation [Float, int] the default overall aggregation
+        # @param overall_percentage [Float, int] the default overall percentage
+        # @return [void]
+        def initialize(xml = nil, lookup = nil, overall_percentage: nil, overall_aggregation: nil)
+          @overall_percentage = LUSI::API::Core::XML.xml_float_at(xml, 'xmlns:OverallPercentage', overall_percentage)
+          @overall_aggregation = LUSI::API::Core::XML.xml_float_at(xml, 'xmlns:OverallAggregation',
+                                                                   overall_aggregation)
+        end
+
+        # Returns a string representation of the Mark instance
+        # @return [String] the string representation of the Mark instance
+        def to_s
+          "#{@overall_aggregation} (#{@overall_percentage}%)"
+        end
+
+      end
+
+
+      # # Represents a module enrolment in the LUSI API
+      # class ModuleEnrolment < ModuleEnrolmentBase
+      #
+      #   # @!attribute [rw] module_identity
+      #   # @see (#identity)
+      #   alias module_identity identity
+      #
+      #   # @!attribute [rw] department
+      #   #   @return [LUSI::API::Organisation::Unit, nil] the major department
+      #   attr_accessor :department
+      #
+      #   # @!attribute [rw] year_sos
+      #   #   @return [Integer, nil] the year of study on the scene(1 = first year etc.)
+      #   attr_accessor :year_sos
+      #
+      #   # @!attribute [rw] study_type
+      #   #   @return [String, nil] the type of study (e.g. 'Major', 'Minor')
+      #   attr_accessor :study_type
+      #
+      #   # @!attribute [rw] talis_code
+      #   #   @return [String, nil] the Talis Aspire reading list code
+      #   attr_accessor :talis_code
+      #
+      #   # @!attribute [rw] mark
+      #   #   @return [LUSI::API::Course::Mark, nil] the mark for the module
+      #   attr_accessor :mark
+      #
+      #   # Initalises a new ModuleEnrolment instance
+      #   # @param (see LUSI::API::Course::ModuleEnrolmentBase#initialize)
+      #   # @param department [LUSI::API::Organisation::Unit] the default major department
+      #   # @param year_sos [Integer, nil] the default year of scheme of study
+      #   # @param study_type [String, nil] the default study type
+      #   # @param talis_code [String, nil] the default Talis Aspire reading list code
+      #   # @param mark [LUSI::API::Course::Mark, nil] the default mark for the module
+      #   # @return [void]
+      #   def initialize(xml = nil, lookup = nil, department: nil, year_sos: nil, study_type: nil, talis_code: nil,
+      #                  mark: nil, **kwargs)
+      #     super(xml, lookup, **kwargs)
+      #     @department = LUSI::API::Core::XML.lookup(xml, lookup, :department, 'xmlns:Department/xmlns:Identity',
+      #                                               department)
+      #     @year_sos = LUSI::API::Core::XML.xml_int_at(xml, 'xmlns:YearSos', year_sos)
+      #     @study_type = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:StudyType', study_type)
+      #     @talis_code = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:TalisCode', talis_code)
+      #     @mark = Mark.new(LUSI::API::Core::XML.xml_at(xml, 'xmlns:Mark', mark))
+      #   end
+      #
+      # end
+
+
+      # The abstract base class for module/scheme of study enrolments
+      # @abstract Subclasses must implement lookup_index and alias :course_identity to the accessor for the
+      #   subclass-specific identity.
+      class CourseEnrolment < LUSI::API::Enrolment::EnrolmentBase
+
+        # Returns the index name used for the module/scheme of study identity
+        # @return [Symbol] the module/scheme of study index name
+        def self.lookup_index
+          raise NotImplementedError
+        end
+
+        # @see (LUSI::API::Enrolment::EnrolmentBase#lookup_indices)
+        def lookup_indices
+          super.push(self.lookup_index)
+        end
+
+        # @see (LUSI::API::Enrolment::EnrolmentBase#lookup_key)
+        def lookup_key(index)
+          # self.course_identity should be defined by all subclasses
+          if index == self.lookup_index
+            self.course_identity.lookup_key
+          else
+            super(index)
+          end
+        end
+
+      end
+
+
+      # Represents a module enrolment in the LUSI API
+      class ModuleEnrolment < CourseEnrolment
+
+        # @!attribute [rw] module_identity
+        #   @return [LUSI::API::Course::EnrolmentIdentity] the enrolment's module identity
+        attr_accessor :module_identity
+        alias :course_identity :module_identity
+
+        # @see (LUSI::API::Core::Endpoint#lusi_ws_method)
+        def self.lusi_ws_method
+          'BulkGetModuleEnrolments'
+        end
+
+        # @see (LUSI::API::Core::Endpoint#lusi_ws_xml_root)
+        def self.lusi_ws_xml_root
+          'BulkModuleEnrolment'
+        end
+
+        # @see (LUSI::API::Enrolment::EnrolmentBase#initialize)
+        # @param module_identity [LUSI::API::Course::EnrolmentIdentity] the enrolment's module identity
+        def initialize(xml = nil, lookup = nil, module_identity: nil, **kwargs)
+          super(xml, lookup, **kwargs)
+          @module_identity = EnrolmentIdentity.new(LUSI::API::Core::XML.xml_at(xml, 'xmlns:ModuleIdentity',
+                                                                               module_identity), lookup)
+        end
+
+      end
+
+
+      # Represents a module evaluation cohort in the LUSI API
+      class ModuleEvaluationCohort
+
+        # @!attribute [rw] cohort identity
+        #   @return [String, nil] the identity code of the cohort
+        attr_accessor :cohort_identity
+
+        # @!attribute [rw] evaluation_date
+        #   @return [DateTime, nil] the start date of module evaluation for the cohort
+        attr_accessor :evaluation_date
+
+        # @!attribute [rw] week_identity
+        #   @return [String, nil] the starting week identity of module evaluation for the cohort
+        attr_accessor :week_identity
+
+        # Initialises a new ModuleEvaluationCohort instance
+        # @param xml [Nokogiri::XML::Document, Nokogiri::XML::Node] the parsed XML root of the module evaluation cohort
+        # @param lookup [LUSI::API::Core::Lookup::LookupService, nil] the lookup service for object resolution
+        # @param cohort_identity [String, nil] the default cohort identity code
+        # @param evaluation_date [DateTime, nil] the default evaluation start date
+        # @param week_identity [String, nil] the default evaluation start week identity
+        # @return [void]
+        def initialize(xml = nil, lookup = nil, cohort_identity: nil, evaluation_date: nil, week_identity: nil)
+          @cohort_identity = LUSI::API::Core::XML.xml_int_at(xml, 'xmlns:CohortIdentity', cohort_identity)
+          @evaluation_date = LUSI::API::Core::XML.xml_datetime_at(xml, 'xmlns:EvaluationDate', evaluation_date)
+          @week_identity = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:WeekIdentity', week_identity)
+        end
+
+        # Returns a string representation of the ModuleEvaluationCohort instance
+        # @return [String] the string representation of the ModuleEvaluationCohort instance
+        def to_s
+          "#{@cohort_identity}: #{@evaluation_date}"
+        end
+
+      end
+
+
+      # # Represents a scheme of study enrolment in the LUSI API
+      # class SchemeOfStudyEnrolment < ModuleEnrolmentBase
+      #
+      #   # @!attribute [rw] qualification
+      #   #   @return [String, nil] the qualification (e.g. 'BSc Hons')
+      #   attr_accessor :qualification
+      #
+      #   # @!attribute [rw] mode_of_study
+      #   #   @return [String, nil] the mode of study (e.g. 'Full Time')
+      #   attr_accessor :mode_of_study
+      #
+      #   # @!attribute scheme_length
+      #   #   @return [String, nil] the length of the scheme of study
+      #   attr_accessor :scheme_length
+      #
+      #   # Initialises a new SchemeOfStudyEnrolment instance
+      #   # @param (see LUSI::API::Course::ModuleEnrolmentBase#initialize)
+      #   # @param qualification [String, nil] the default qualification
+      #   # @param mode_of_study [String. nil] the default mode of study
+      #   # @param scheme_length [String, nil] the default scheme length
+      #   # @return [void]
+      #   def initialize(xml = nil, lookup = nil, mode_of_study: nil, qualification: nil, scheme_length: nil, **kwargs)
+      #     super(xml, lookup, **kwargs)
+      #     @mode_of_study = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:ModeOfStudy', mode_of_study)
+      #     @qualification = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:Qualification', qualification)
+      #     @scheme_length = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:SchemeLength', scheme_length)
+      #   end
+      #
+      # end
+
+
+      # Represents a module enrolment in the LUSI API
+      class SchemeOfStudyEnrolment < CourseEnrolment
+
+        # @!attribute [rw] scheme_identity
+        #   @return [LUSI::API::Course::EnrolmentIdentity] the enrolment's scheme of study identity
+        attr_accessor :scheme_identity
+        alias :course_identity :scheme_identity
+
+        # @see (LUSI::API::Course::CourseEnrolment#lookup_index)
+        def self.lookup_index
+          raise NotImplementedError
+        end
+
+        # @see (LUSI::API::Core::Endpoint#lusi_ws_method)
+        def self.lusi_ws_method
+          'BulkGetSchemeOfStudyEnrolments'
+        end
+
+        # @see (LUSI::API::Core::Endpoint#lusi_ws_xml_root)
+        def self.lusi_ws_xml_root
+          'BulkSchemeOfStudyEnrolment'
+        end
+
+        # @see (LUSI::API::Enrolment::EnrolmentBase#initialize)
+        # @param scheme_identity [LUSI::API::Course::EnrolmentIdentity] the enrolment's scheme of study identity
+        def initialize(xml = nil, lookup = nil, scheme_identity: nil, **kwargs)
+          super(xml, lookup, **kwargs)
+          @scheme_identity = EnrolmentIdentity.new(LUSI::API::Core::XML.xml_at(xml, 'xmlns:SchemeIdentity',
+                                                                               scheme_identity), lookup)
+        end
+
+      end
+
+
+      # Represents a staff module enrolment in the LUSI API
+      class StaffModuleEnrolment < ModuleEnrolment
+
+        extend StaffEndpoint
+
+        # @see (LUSI::API::Course::ModuleEnrolment#lookup_index)
+        def lookup_index
+          :module_staff
+        end
+
+      end
+
+
+      # Represents a staff scheme of study enrolment in the LUSI API
+      class StaffSchemeOfStudyEnrolment < SchemeOfStudyEnrolment
+
+        extend StaffEndpoint
+
+        # @see (LUSI::API::Course::ModuleEnrolment#lookup_index)
+        def lookup_index
+          :scheme_staff
+        end
+
+      end
+
+
+      # Represents a student module enrolment in the LUSI API
+      class StudentModuleEnrolment < ModuleEnrolment
+
+        extend StudentEndpoint
+
+        # @see (LUSI::API::Course::ModuleEnrolment#lookup_index)
+        def lookup_index
+          :module_student
+        end
+
+      end
+
+
+      # Represents a student scheme of study enrolment in the LUSI API
+      class StudentSchemeOfStudyEnrolment < SchemeOfStudyEnrolment
+
+        extend StudentEndpoint
+
+        # @see (LUSI::API::Course::ModuleEnrolment#lookup_index)
+        def lookup_index
+          :scheme_student
+        end
+
+      end
+
+
+      # Represents a subject in the LUSI API
+      class Subject
+
+        # @!attribute [rw] identity
+        #   @return [String, nil] the identity code of the subject
+        attr_accessor :identity
+
+        # @!attribute [rw] mnemonic
+        #   @return [String, nil] the mnemonic for the subject
+        attr_accessor :mnemonic
+
+        # @!attribute [rw] title
+        #   @return [String, nil] the title of the subject
+        attr_accessor :title
+
+        # @!attribute [rw] group
+        #   @return [String, nil] the group type of the subject
+        attr_accessor :group
+
+        # @!attribute [rw] department
+        #   @return [LUSI::API::Organisation::Unit, nil] the department associated with the subject
+        attr_accessor :department
+
+        # Initialises a new Subject instance
+        # @param xml [Nokogiri::XML::Document, Nokogiri::XML::Node] the parsed XML root of the subject
+        # @param lookup [LUSI::API::Core::LookupTable, nil] the lookup table for department resolution
+        # @param department [LUSI::API::Organisation::Unit, nil] the default department
+        # @param group [String, nil] the default group type
+        # @param identity [String, nil] the default identity code
+        # @param mnemonic [String, nil] the default mnemonic
+        # @param title [String, title] the default title
+        # @return [void]
+        def initialize(xml = nil, lookup = nil, department: nil, group: nil, identity: nil, mnemonic: nil, title: nil)
+          @department = LUSI::API::Core::XML.lookup(xml, lookup, :department, 'xmlns:Department/xmlns:Identity',
+                                                    department)
+          @group = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:Group', group)
+          @identity = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:Identity', identity)
+          @mnemonic = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:Mnemonic', mnemonic)
+          @title = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:Title', title)
+        end
+
+        # Returns a string representation of the Subject instance
+        # @return [String] the string representationn of the Subject instance
+        def to_s
+          @title
+        end
+
+      end
+
+
+      # Represents a syllabus rule in the LUSI API
+      class SyllabusRuleModule
+
+        # @!attribute [rw] identity
+        #   @return [LUSI::API::Course::Identity, nil] the identity code of the associatied module or scheme of study
+        attr_accessor :identity
+
+        # @!attribute [rw] display_long_title
+        #   @return [String, nil] the long title of the rule
+        attr_accessor :display_long_title
+
+        # @!attribute [rw] display_short_title
+        #   @return [String, nil] the short title of the rule
+        attr_accessor :display_short_title
+
+        # Initialises a new SyllabusRuleModule instance
+        # @param xml [Nokogiri::XML::Document, Nokogiri::XML::Node] the parsed XML root of the syllabus rule module
+        # @param lookup [LUSI::API::Core::Lookup::LookupService, nil] the lookup service for object resolution
+        # @param identity [String, nil] the default identity code
+        # @param display_long_title [String, nil] the default long title
+        # @param display_short_title [String, nil] the default short title
+        # @return [void]
+        def initialize(xml = nil, lookup = nil, display_long_title: nil, display_short_title: nil, identity: nil)
+          @display_long_title = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:DisplayLongTitle', display_long_title)
+          @display_short_title = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:DisplayShortTitle', display_short_title)
+          @identity = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:Identity', identity)
+        end
+
+        # Returns a string representation to the SyllabusRuleModule instance
+        # @return [String] the string representation to the SyllabusRuleModule instance
+        def to_s
+          @display_long_title
+        end
+
+      end
+
+
+      # Represents a syllabus rule type in the LUSI API
+      class SyllabusRuleType < LUSI::API::Core::Code
+
+        # @!attribute [rw] category
+        #   @return [String, nil] the rule type category (short description)
+        attr_accessor :category
+
+        # Initialises a new SyllabusRuleType instance
+        # @param (see LUSI::API::Core::Code)
+        # @param category [String, nil] the default rule type category (short description)
+        # @return [void]
+        def initialize(xml = nil, lookup = nil, category: nil, **kwargs)
+          super(xml, **kwargs)
+          @category = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:Category', category)
+        end
+
+        # Returns a string representation of the SyllabusRuleType instance
+        # @return [String] the string representation of the SyllabusRuleType instance
+        def to_s
+          "[#{@category}]: #{@description}"
+        end
+
+      end
+
+
+      # Represents a syllabus rule in the LUSI API
+      class SyllabusRule
+
+        # @!attribute [rw] level
+        #   @return [String, nil] the level this rule applies to ('Module', 'Part II Year 3' etc.)
+        attr_accessor :level
+
+        # @!attribute [rw] type
+        #   @return [LUSI::API::Course::SyllabusRuleType] the rule type
+        attr_accessor :type
+
+        # @!attribute [rw] syllabus_rule_modules
+        #   @return [Array<LUSI::API::Course::SyllabusRuleModule>, nil] the list of modules included with this rule
+        attr_accessor :syllabus_rule_modules
+
+        # Initialises a new SyllabusRule instance
+        # @param xml [Nokogiri::XML::Document, Nokogiri::XML::Node] the parsed XML root of the syllabus rule
+        # @param lookup [LUSI::API::Core::Lookup::LookupService, nil] the lookup service for object resolution
+        # @param level [String, nil] the default rule level
+        # @param type [LUSI::API::Course::SyllabusRuleType, nil] the default rule type
+        # @param syllabus_rule_modules [Array<LUSI::API::Course::SyllabusRuleModule>, nil] the default rule modules
+        # @return [void]
+        def initialize(xml = nil, lookup = nil, level: nil, syllabus_rule_modules: nil, type: nil)
+          @level = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:Level', level)
+          @syllabus_rule_modules = LUSI::API::Core::XML.xml(xml, 'xmlns:SyllabusRuleModuless/xmlns:SyllabusRuleModule',
+                                                            syllabus_rule_modules) { |s| SyllabusRuleModule.new(s, lookup) }
+          @type = SyllabusRuleType.new(LUSI::API::Core::XML.xml_at(xml, 'xmlns:Type', type), lookup)
+        end
+
+        # Returns a string representation of the SyllabusRule instance
+        # @return [String] the string representation of the SyllabusRule instance
+        def to_s
+          "#{@level} #{@type}"
+        end
+
+      end
+
+
+      # Represents a module in the LUSI API
+      class Module < ModuleBase
+
+        # @!attribute [rw] assessment_proportions
+        #   @return [Array<LUSI::API::Course::AssessmentProportion>, nil] the assessment proportions for the module
+        attr_accessor :assessment_proportions
+
+        # @!attribute [rw] course_convenors
+        #   @return [Array<LUSI::API::Person::StaffMember>] the course convenor(s)
+        attr_accessor :course_convenors
+
+        # @!attribute [rw] lecture_capture_enabled
+        #   @return [Boolean, nil] true if automated lecture capture is available for the module, otherwise false
+        attr_accessor :lecture_capture_enabled
+
+        # @!attribute [rw] module_evaluation_cohorts
+        #   @return [Array<LUSI::API::Course::ModuleEvaluationCohort>, nil] the evaluation cohorts for the module
+        attr_accessor :module_evaluation_cohorts
+
+        # @!attribute [rw] partner_module_leaders
+        #   @return [Array<LUSI::API::Person::StaffMember>, nil] the staff members leading the module
+        attr_accessor :partner_module_leaders
+
+        # @!attribute [rw] validating_institution
+        #   @return [LUSI::API::Organisation::Unit, nil] the validating institution for the module
+        attr_accessor :validating_institution
+
+        # Initialises a new Module instance
+        # @param (see LUSI::API::Course::ModuleBase#initialize)
+        # @param assessment_proportions [Array<LUSI::API::Course::AssessmentProportion>, nil] the default assessment
+        #   proportions
+        # @param course_convenors [Array<LUSI::API::Person::StaffMember>, nil] the default course convenors
+        # @param lecture_capture_enabled [Boolean, nil] the default lecture-capture-enabled flag
+        # @param module_evaluation_cohorts [Array<LUSI::API::Course::ModuleEvaluationCohort>, nil] the default
+        #   module evaluation cohorts
+        # @param partner_module_leaders [Array<LUSI::API::Person::StaffMember>, nil] the default partner module leaders
+        # @param validating_institution [LUSI::API::Organisation::Unit] the default validating institution
+        def initialize(xml = nil, lookup = nil, assessment_proportions: nil, course_convenors: nil,
+                       lecture_capture_enabled: nil, module_evaluation_cohorts: nil, partner_module_leaders: nil,
+                       validating_institution: nil, **kwargs)
+          super(xml, lookup, **kwargs)
+          @assessment_proportions = LUSI::API::Core::XML.xml(xml,
+                                                             'xmlns:AssessmentProportions/xmlns:AssessmentProportion',
+                                                              assessment_proportions) { |a| AssessmentProportion.new(a, lookup) }
+          @course_convenors = LUSI::API::Core::XML.xml(xml, 'xmlns:CourseConvenor/xmlns:StaffMember',
+                                                       course_convenors) { |s| LUSI::API::Person::StaffMember.new(s, lookup) }
+          @lecture_caputure_enabled = LUSI::API::Core::XML.xml_boolean_at(xml, 'xmlns:LectureCaptureEnabled',
+                                                                         lecture_capture_enabled)
+          @module_evaluation_cohorts = LUSI::API::Core::XML.xml(xml, 'xmlns:ModuleEvaluationCohorts/xmlns:ModuleEvaluationCohort',
+                                                                module_evaluation_cohorts) { |m| ModuleEvaluationCohort.new(m, lookup) }
+          @partner_module_leaders = LUSI::API::Core::XML.xml(xml, 'xmlns:PartnerModuleLeader/xmlns:StaffMember',
+                                                             partner_module_leaders) { |s| LUSI::API::Person::StaffMember.new(s, lookup) }
+          @validating_institution = LUSI::API::Core::XML.lookup(xml, lookup, :institution,
+                                                                'xmlns:ValidatingInstitution/xmlns:Identity',
+                                                                validating_institution)
+        end
+
+        # @see (LUSI::API::Course::ModuleBase#enrolment_lookup_indices)
+        def enrolment_lookup_indices
+          [:module_staff, :module_student]
+        end
+
+        # Returns a hash of parameters for the LUSI API call
+        # @param (see LUSI::API::Course::ModuleBase#get_instance_params)
+        # @param awarding_institution_id [String, nil] the awarding institution identity code
+        def self.get_instance_params(validating_institution_id: nil, **kwargs)
+          params = super(**kwargs)
+          params[:ValidatingInstitutionId] = kwargs.fetch(:validating_institution_id, '')
+          params
+        end
+
+        # Returns the LUSI API endpoint
+        # @return [String] the LUSI API endpoint
+        def self.lusi_ws_endpoint
+          'CourseManager.asmx'
+        end
+
+        # Returns the LUSI API method
+        # @return [String] the LUSI API method
+        def self.lusi_ws_method
+          'GetModuleFullDetails'
+        end
+
+        # Returns the root element name of the LUSI API XML response
+        # @return [String] the root element name of the LUSI API XML response
+        def self.lusi_ws_xml_root
+          'ModuleRecord'
+        end
+
+      end
+
+
+      # Represents a scheme (or programme) of study in the LUSI API
+      class SchemeOfStudy < ModuleBase
+
+        # @!attribute [rw] awarding_institution
+        #   @return [LUSI::API::Organisation::Unit, nil] the awarding institution for the scheme of study
+        attr_accessor :awarding_institution
+
+        # @!attribute [rw] credit_points
+        #   @return [LUSI::API::Course::CreditPoints, nil] the required credit points for the scheme of study
+        attr_accessor :credit_points
+
+        # @!attribute [rw] length
+        #   @return [LUSI::API::Course::Length, nil] the length of the scheme of study
+        attr_accessor :length
+
+        # @!attribute [rw] mode_of_study
+        #   @return [LUSI::API::Core::Code, nil] the scheme's mode of study
+        attr_accessor :mode_of_study
+
+        # @!attribute [rw] qualification
+        #   @return [String, nil] the qualification awarded by the scheme of study
+        attr_accessor :qualification
+
+        # @!attribute [rw] ucas_course_code
+        #   @return [String, nil] the UCAS course code for the scheme of study
+        attr_accessor :ucas_course_code
+
+        # Initialises a new SchemeOfStudy instance
+        # @param (see LUSI::API::Course::ModuleBase#initialize)
+        # @param awarding_institution [LUSI::API::Organisation::Unit, nil] the default awarding institution
+        # @param credit_points [LUSI::API::Course::CreditPoints, nil] the default credit points
+        # @param director_of_studies [Array<LUSI::API::Person::StaffMember>, nil] the default director-of-studies list
+        # @param length [LUSI::API::Course::Length] the default scheme of study length
+        # @param mode_of_study [LUSI::API::Core::Code] the default mode of study
+        # @param qualification [String, nil] the default qualification
+        # @param ucas_course_code [String, nil] the default UCAS course code
+        # @return [void]
+        def initialize(xml = nil, lookup = nil, awarding_institution: nil, credit_points: nil, director_of_studies: nil,
+                       length: nil, mode_of_study: nil, qualification: nil, ucas_course_code: nil, **kwargs)
+          super(xml, lookup, **kwargs)
+          @awarding_institution = LUSI::API::Core::XML.lookup(xml, lookup, :organisation,
+                                                              'xmlns:AwardingInstitution/xmlns:Identity',
+                                                              awarding_institution)
+          @credit_points = CreditPoints.new(LUSI::API::Core::XML.xml_at(xml, 'xmlns:CreditPoints', credit_points), lookup)
+          @director_of_studies = LUSI::API::Core::XML.xml(xml, 'xmlns:DirectorOfStudies/xmlns:StaffMember',
+                                                          director_of_studies) { |s| LUSI::API::Person::StaffMember.new(s, lookup) }
+          @length = Length.new(LUSI::API::Core::XML.xml_at(xml, 'xmlns:Length', length), lookup)
+          @mode_of_study = LUSI::API::Core::Code.new(LUSI::API::Core::XML::xml_at(xml, 'xmlns:ModeOfStudy',
+                                                                                  mode_of_study), lookup)
+          @qualification = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:Qualification', qualification)
+          @ucas_course_code = LUSI::API::Core::XML.xml_content_at(xml, 'xmlns:UCASCourseCode', ucas_course_code)
+        end
+
+        # @see (LUSI::API::Course::ModuleBase#enrolment_lookup_indices)
+        def enrolment_lookup_indices
+          [:scheme_staff, :scheme_student]
+        end
+
+        protected
+
+        # Returns a hash of parameters for the LUSI API call
+        # @param (see LUSI::API::Course::ModuleBase#get_instance_params)
+        # @param awarding_institution_id [String, nil] the awarding institution identity code
+        def self.get_instance_params(awarding_institution_id: nil, **kwargs)
+          params = super(**kwargs)
+          params[:AwardingInstitutionId] = kwargs.fetch(:awarding_institution_id, '')
+          params
+        end
+
+        # Returns the LUSI API endpoint
+        # @return [String] the LUSI API endpoint
+        def self.lusi_ws_endpoint
+          'General.asmx'
+        end
+
+        # Returns the LUSI API method
+        # @return [String] the LUSI API method
+        def self.lusi_ws_method
+          'GetSchemesOfStudy'
+        end
+
+        # Returns the root element name of the LUSI API XML response
+        # @return [String] the root element name of the LUSI API XML response
+        def self.lusi_ws_xml_root
+          'SchemeOfStudy'
+        end
+
+      end
+
+
+    end
+  end
+end