lusi_alma_course_loader 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2bb1e3748b483363c5f660babc78160130e15aaa
+  data.tar.gz: db8ba8021b5fc706e7917fa021b2996c42b32956
+SHA512:
+  metadata.gz: 9fba3d46e754484a80f06ed7c60fa0eec77cedb957a022b5d0c977cb7531f4f656acdea76a60dfe48e6a0e8cfb81c64e39a60270a815bcb63734831cd7e1a32a
+  data.tar.gz: a099ae6638521d92e4b580e2de612fe14ea671438d7a2d2edc18019242ca93ccc94afa8f2db7317ac1e39c4e9516a86ef88709a8a35d8507f2127c9097de0012

data/.gitignore

@@ -0,0 +1,62 @@
+# IntelliJ files
+.idea/
+*.iml
+*.iws
+
+# Created by https://www.gitignore.io/api/ruby
+
+### Ruby ###
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+.env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# Test output files
+/test/fixtures/diff_test_delete.csv
+/test/fixtures/diff_test_update.csv

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.1
+before_install: gem install bundler -v 1.14.6

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at Sh3d0fd00m. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lusi_alma_course_loader.gemspec
+gemspec
+
+# Lancaster University LUSI API
+gem 'lusi_api', '>=0.1.10', git: 'https://github.com/lulibrary/lusi_api'
+
+# Redis-backed Hash
+gem 'redis_hash', '>=0.1.0', git: 'https://github.com/lulibrary/redis_hash'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 lbaajh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,152 @@
+# LUSIAlmaCourseLoader
+
+This gem implements an Alma course loader which reads course data from Lancaster
+University's LUSI student records system.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'lusi_alma_course_loader'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install lusi_alma_course_loader
+
+## Usage
+
+The course loader is a command-line script:
+
+```bash
+course_loader [-d|--delete]
+              [-e|--env=env-file]
+              [-f|--filter=filter]...
+              [-F]
+              [-l|--log-file=log-file]
+              [-L|--log-level=debug|error|fatal|info|warn]
+              [-o|--out-file=output-file]
+              [-p|--password=lusi-password]
+              [-r|--rollover]
+              [-t|--time-period=time-period]...
+              [-u|--user=lusi-username]
+```
+
+##### `-d | --delete`
+
+Adds the `DELETE` operation to the course loader file, causing all entries in
+the file to be deleted when the file is processed by Alma.
+
+##### `-e env-file | --env=env-file`
+
+Specifies a file of environment variable definitions for configuration
+
+##### `-f filter | --filter=filter`
+
+Specifies a filter restricting the courses to be exported. See *Filter
+specification strings* for the filter syntax. This flag may be repeated to
+specify multiple filters; a course must pass every filter to be included in the
+export. 
+
+##### `-F`
+
+Lists the fields available to filters and exits.
+
+##### `-h | --help`
+
+Displays a help page for the command-line interface.
+
+##### `-l log-file | --log-file=log-file`
+
+Specifies a file for logging course loader activity
+
+##### `-L log-level | --log-level=log-level`
+
+Specifies the logging level: `fatal|error|warn|info|debug`
+
+##### `-o out-file | --out-file=out-file`
+
+Specifies the output course loader file
+
+##### `-p lusi-password | --password=lusi-password`
+ 
+Specifies the password for the LUSI web service. If not specified, the value of
+the `LUSI_API_PASSWORD` environment variable is used.
+
+##### `-r | --rollover`
+
+Adds the `ROLLOVER` operation and previous course code/section to the course
+loader file, triggering Alma's course rollover processing for the specified
+courses. 
+
+##### `-t time-period | --time-period=time-period`
+
+Specifies the course time period covered by the export. This flag may be
+repeated to specify multiple time periods. 
+The exact syntax and meaning of `time-period` is left to clients of this gem.
+
+##### `-u lusi-username | --user=lusi-username` 
+
+Specifies the username for the LUSI web service. If not specified, the value of
+the `LUSI_API_USER` environment variable is used.
+
+### Filter specification strings
+ 
+The general form of a filter specification string is:
+
+```[!][field [op ]]value```
+
+where:
+ * `!` negates the condition
+ * `field` is the name of a defined field extractor,
+ * `op` is one of the following operators:
+   * `<`, `<=`, `==`, `!=`, `>=`, `>` the value of field is less than (etc.)
+     value
+   * `~`, `!~` the value of field matches/does not match the regular expression
+     value  
+   * `in` the value of field is a key (if value is a hash) or a value (if value
+     is any other type) in value; equivalent to value.include?(field)
+   * `keyin` the value of field is a key of the value hash; equivalent
+     to value.key?(field)
+   * `valuein` the value of field is a value in the value hash; equivalent to
+     value.value?(field)      
+ * `value` is either a JSON string (which must include double-quotes around string
+literal values and may specify arrays and hashes) or a regular expression
+delimited by `/`.
+
+Examples:
+
+```ruby
+# Course code must exactly match CS101
+course_code == "CS101"    
+
+# Course code must be one of CS101, CS102 or CS103
+course_code in ["CS101", "CS102", "CS103"]
+
+# Year must not be 2015 or 2016
+! year in [2015, 2016]
+
+# Course code must begin with CS
+course_code ~ /^CS/
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/lusi_alma_course_loader. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "lusi_alma_course_loader"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/course_loader

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'lusi_alma_course_loader'
+
+dsn = ENV['SENTRY_DSN']
+unless dsn.nil? || dsn.empty?
+  require 'raven'
+  Raven.configure { |config| config.dsn = dsn }
+end
+LUSIAlmaCourseLoader::CLI::CourseLoader.run

data/lib/lusi_alma_course_loader.rb

@@ -0,0 +1,11 @@
+require 'lusi_api/calendar'
+require 'lusi_api/core/api'
+require 'lusi_api/core/lookup'
+require 'lusi_api/core/util'
+require 'lusi_api/course'
+require 'lusi_api/organisation'
+
+require 'alma_course_loader/writer'
+
+require 'lusi_alma_course_loader/reader'
+require 'lusi_alma_course_loader/version'

data/lib/lusi_alma_course_loader/cli/course_loader.rb

@@ -0,0 +1,138 @@
+require 'date'
+
+require 'lusi_api/core/api'
+
+require 'alma_course_loader/cli/course_loader'
+
+require 'lusi_alma_course_loader/reader'
+
+module LUSIAlmaCourseLoader
+  module CLI
+    # Field extractors for LUSI course objects
+    module Extractors
+      # Convert
+      def self.date_to_s(date)
+        date.strftime('%Y-%m-%dT%H:%M:%S')
+      end
+
+      # Named field value extractors
+      EXTRACTORS = {
+        accessdate: proc do |_year, course, _cohort|
+          date_to_s(course.student_access_date)
+        end,
+        accessdateutc: proc do |_year, course, _cohort|
+          date_to_s(course.student_access_date_utc)
+        end,
+        conv: proc do |_year, course, _cohort|
+          course.is_conversion_space.to_s
+        end,
+        copy: proc do |_year, course, _cohort|
+          course.copy_course_materials_from_prev_session.to_s
+        end,
+        coursetype: proc { |_year, course, _cohort| course.course_type },
+        createspacedate: proc do |_year, course, _cohort|
+          date_to_s(course.create_space_date)
+        end,
+        createspacedateutc: proc do |_year, course, _cohort|
+          date_to_s(course.create_space_date_utc)
+        end,
+        enddate: proc do |_year, _course, cohort|
+          date_to_s(cohort.end_date)
+        end,
+        enddateutc: proc do |_year, _course, cohort|
+          date_to_s(cohort.end_date_utc)
+        end,
+        hide: proc do |_year, course, _cohort|
+          course.hide_content_on_rollover.to_s
+        end,
+        longtitle: proc { |_year, course, _cohort| course.display_long_title },
+        shorttitle: proc do |_year, course, _cohort|
+          course.display_short_title
+        end,
+        spacetype: proc { |_year, course, _cohort| course.space_type },
+        startdate: proc do |_year, _course, cohort|
+          date_to_s(cohort.start_date)
+        end,
+        startdateutc: proc do |_year, _course, cohort|
+          date_to_s(cohort.start_date_utc)
+        end,
+        status: proc { |_year, course, _cohort| course.status },
+        vlespaceid: proc { |_year, course, _cohort| course.lusi_vle_space_id },
+        year: proc { |_year, course, _cohort| course.lusi_year_id }
+      }.freeze
+
+      EXTRACTOR_DETAILS = {
+        accessdate: 'start date of student access (local time)',
+        accessdateutc: 'start date of student access (UTC)',
+        conv: '"true" for conversion spaces, else "false"',
+        copy: '"true" if copied from previous space, else "false"',
+        coursetype: 'CMOD=course module, SOS=scheme of study',
+        createdate: 'creation date of VLE space (local time)',
+        createdateutc: 'creation date of VLE space (UTC)',
+        enddate: 'end of course date (local time)',
+        enddateutc: 'end of course date (UTC)',
+        hide: '"true" if content hidden on rollover, else "false"',
+        longtitle: 'VLE space long title',
+        shorttitle: 'VLE space short title',
+        spacetype: 'SHARED=shared VLE space, SINGLE=single VLE space',
+        startdate: 'start of course date (local time)',
+        startdateutc: 'start of course date (UTC)',
+        vlespaceid: 'LUSI VLE space identity',
+        year: 'LUSI year identity'
+      }.freeze
+      EXTRACTOR_DETAILS.each_value(&:freeze)
+    end
+
+    # Implements the course loader command-line interface
+    class CourseLoader < ::AlmaCourseLoader::CLI::CourseLoader
+      include Extractors
+
+      option %w[-p --password], 'LUSI_PASSWORD', 'the LUSI web service password'
+      option %w[-u --user], 'LUSI_USER', 'the LUSI web service username'
+
+      # Returns a hash of named field value extractor details
+      # @return [Hash<String|Symbol, String>] the field extractor details
+      def extractor_details
+        EXTRACTOR_DETAILS
+      end
+
+      # Returns a hash of named field value extractors
+      # @return [Hash<String|Symbol, Method|Proc>] the field extractors
+      def extractors
+        EXTRACTORS
+      end
+
+      # Creates a Reader instance to retrieve course data
+      # @return [LUSIAlmaCourseLoader::Reader] the Reader instance
+      def reader
+        return @reader unless @reader.nil?
+        api = lusi_api
+        lookup = lusi_lookup(api)
+        @reader = ::LUSIAlmaCourseLoader::Reader.new(
+          api, lookup, *time_period_list,
+          current_year: current_time_period,
+          filters: filter_list
+        )
+      end
+
+      # Creates a LUSI API instance
+      # @return [LUSI::API::Core::API] the LUSI API instance
+      def lusi_api
+        api_password = password || ENV['LUSI_API_PASSWORD']
+        api_user = user || ENV['LUSI_API_USER']
+        ::LUSI::API::Core::API.new(api_user: api_user,
+                                   api_password: api_password,
+                                   logger: logger)
+      end
+
+      # Creates a LUSI LookupService instance
+      # @param api [LUSI::API::Core::API] the LUSI API instance
+      # @return [LUSI::API::Core::Lookup::LookupService] the LUSI lookup service
+      def lusi_lookup(api)
+        lookup = LUSI::API::Core::Lookup::LookupService.new(api || lusi_api)
+        lookup.load
+        lookup
+      end
+    end
+  end
+end

data/lib/lusi_alma_course_loader/reader.rb

@@ -0,0 +1,314 @@
+require 'alma_course_loader/reader'
+require 'lusi_api/core/util'
+require 'lusi_api/course'
+require 'lusi_api/vle'
+
+module LUSIAlmaCourseLoader
+  # Methods for handling LUSI data
+  module Helpers
+    include LUSI::API::Core::Util
+
+    # Course ID year offsets
+    COURSE_ID_OFFSETS = {
+      next: 1,
+      previous: -1,
+      rollover: -1
+    }.freeze
+
+    # LUSI instructor roles
+    INSTRUCTOR_ROLES = {
+      'administrative staff'.to_sym => true,
+      'co-course convenor'.to_sym => true,
+      'course convenor'.to_sym => true,
+      'partner administrative staff'.to_sym => true,
+      'partner course convenor'.to_sym => true,
+      'teaching staff (not timetabled)'.to_sym => true,
+      'teaching staff (timetabled)'.to_sym => true,
+    }.freeze
+
+    # Returns the major department for the course
+    # @param course [LUSI::API::Course::Module] the LUSI course module
+    # @return [LUSI::API::Course::CourseDepartment] the major department
+    def course_department(course)
+      return nil unless course && course.course_departments
+      # There should only be one major department
+      course.course_departments.select(&:is_major_department)[0]
+    end
+
+    # Returns the Moodle course ID for a given course/cohort
+    # @param course [LUSI::API::VLE::VLESpace] the course
+    # @param cohort [LUSI::API::Course::Cohort] the course cohort
+    # @param offset [Integer, Symbol] a numerical year offset or symbol
+    #   specifying the number of years from the current course year for which
+    #   the ID is required. This allows generation of course IDs for years
+    #   other than the specified course.
+    #   The following symbols are shorthand for numeric offsets:
+    #     :previous, :rollover - equivalent to offset: -1
+    #     :next                - equivalent to offset: 1
+    # @return [String] the Moodle course ID
+    def course_id(course, cohort, offset = nil)
+      offset = COURSE_ID_OFFSETS[offset] || offset.to_i
+      year = if offset != 0
+               # Get the year identity
+               lusi_year_identity(course.lusi_year_id, offset: offset)
+             else
+               course.lusi_year_id
+             end
+      if course.space_type == 'SHARED'
+        "lusi-#{course.lusi_vle_space_id}-#{year}"
+      else
+        c = course.vle_space_courses[0]
+        "lusi-#{c.identity.course}-#{year}-#{c.identity.cohort}"
+      end
+    end
+
+    # Returns the organisation unit for a course department
+    # @param course [LUSI::API::Course::Module] the LUSI course module
+    # @return [LUSI::API::Organisation::Unit] the organisation unit instance of
+    #   the major department for the course
+    def department(course = nil)
+      dept = course_department(course)
+      dept ? dept.org_unit : nil
+    end
+
+    # Returns the organisation units from LUSI
+    def departments
+      return @departments unless @departments.nil?
+      organisation = LUSI::API::Organisation::Organisation.new
+      organisation.load(@lusi_api, in_use_only: false)
+      @departments = {}
+      organisation.each(:department) { |o| @departments[o.talis_code] = o }
+      @departments
+    end
+
+    # Returns a string row field trimmed to the specified length
+    # @param value [String] the field value
+    # @param length [Integer] the maximum field length
+    # @param empty [Object, nil] the value to return if the field value is nil
+    #   or empty
+    # @return [String] the formatted field value
+    def field(value, length = nil, empty = nil)
+      value = empty if value.nil? || value.empty?
+      length && value ? value[0...length] : value
+    end
+
+    # Returns a list of instructor enrolments for the course/cohort
+    # @param year [LUSI::API::Calendar::Year] the course year
+    # @param course [LUSI::API::VLE::VLESpace] the course
+    # @param cohort [LUSI::API::Course::Cohort] the course cohort
+    # @return [Array<LUSI::API::Course::StaffModuleEnrolment>] the course
+    #   instructors
+    def instructor_enrolments(year, course, cohort)
+      result = []
+      course.vle_space_courses.each do |c|
+        enrolments = LUSI::API::Course::StaffModuleEnrolment.get_instance(
+          @lusi_api, @lusi_lookup,
+          active_vle_space_only: false,
+          course_identity: c.identity.course,
+          cohort_identity: c.identity.cohort,
+          require_username: true,
+          year_identity: c.identity.year
+        )
+        e = enrolments.select do |e|
+          @instructor_roles.key?(e.enrolment_role.identity)
+        end
+        result.concat(e)
+      end
+      result
+    end
+
+    # Returns course instructor roles from the :staff_course_roles lookup table
+    # @return [Hash<String, LUSI::API::Person::StaffCourseRole>] the roles
+    def instructor_roles
+      roles = @lusi_lookup.service(:staff_course_role)
+      return [] if roles.nil?
+      roles.select do |_k, v|
+        INSTRUCTOR_ROLES.include?(v.description.downcase.to_sym)
+      end
+    end
+
+    # Returns a comma-separated list of instructor usernames
+    # @param usernames [Array<String>] the instructor usernames
+    # @return [String, nil] the comma-separated list of instructor usernames
+    def instructor_usernames(usernames)
+      result = usernames.join(',')
+      result.nil? || result.empty? ? nil : result
+    end
+
+    # Returns the ancestor organisation units of the course's major department
+    # @param course [LUSI::API::Course::Module] the LUSI course module
+    # @return [Array<LUSI::API::Organisation::Unit>] the organisation units in
+    #   furthest-to-nearest order [institution, faculty, dept]
+    def org_units(course = nil)
+      dept = department(course)
+      result = []
+      until dept.nil?
+        result.unshift(dept)
+        dept = dept.parent
+      end
+      result
+    end
+  end
+
+  # Reads course information from LUSI
+  class Reader < AlmaCourseLoader::Reader
+    include Helpers
+
+    # Alma processing department code
+    PROCESSING_DEPARTMENT = 'Library'.freeze
+
+    # Alma term codes
+    TERMS = {
+      lusi_lent: 'LENT',
+      lusi_mich: 'MICHAELMAS',
+      lusi_summ: 'SUMMER'
+    }.freeze
+
+    # Initializes a new Reader instance
+    # @param lusi_api [LUSI::API::Core::API] the LUSI API instance
+    # @param lusi_lookup [LUSI::API::Core::Lookup::LookupService] the LUSI
+    #   lookup service
+    # @return [void]
+    def initialize(lusi_api = nil, lusi_lookup = nil, *years, **kwargs)
+      # Set the LUSI API and lookup properties for use with subsequent methods
+      @lusi_api = lusi_api
+      @lusi_lookup = lusi_lookup
+      super(*years, **kwargs)
+      @departments = departments
+      @instructor_roles = instructor_roles
+    end
+
+    # Returns a list of LUSI year instances
+    # @param year [LUSI::API::Calendar::Year] the base year (defaults to the
+    #   current academic year)
+    # @param years_previous [Integer] the number of years preceding the base
+    #   year
+    # @param years_next [Integer] the number of years following the base year
+    def years(year = nil, years_previous: nil, years_next: nil)
+      years_next = years_next.to_i
+      years_previous = years_previous.to_i
+      result = []
+      result.push(*(year.previous(years_previous))) if years_previous > 0
+      result.push(*(year.next(years_next))) if years_next > 0
+      result
+    end
+
+    protected
+
+    # Returns a list of courses for the specified year
+    # @param year [Integer, String, LUSI::API::Calendar::Year] the course year
+    # @return [Array<LUSI::API::VLE::VLESpace>] the courses for the year
+    def courses(year)
+      year = year_identity(year)
+      LUSI::API::VLE::VLESpace.get_instance(@lusi_api, @lusi_lookup,
+                                            active_vle_space_only: false,
+                                            year_identity: year)
+    end
+
+    # Returns a list of cohorts for the specified course
+    # @param year [Integer, String, LUSI::API::Calendar::Year] the course year
+    # @param course [LUSI::API::Course::Module] the course
+    # @return [Array<LUSI::API::Course::Cohort>] the cohorts for the course
+    def course_cohorts(year, course)
+      # A single VLE space is always associated with a single course cohort
+      nil
+    end
+
+    # Returns the current academic year
+    # @return [LUSI::API::Calendar::Year] the current academic year
+    def current_academic_year
+      LUSI::API::Calendar::Year.get_current_academic_year(@lusi_api,
+                                                          @lusi_lookup)
+    end
+
+    # Returns a list of instructor usernames for the course/cohort
+    # @param year [LUSI::API::Calendar::Year] the course year
+    # @param course [LUSI::API::Course::Module] the course
+    # @param cohort [LUSI::API::Course::Cohort] the course cohort
+    # @return [Array<String>] the course instructors
+    def instructors(year, course, cohort)
+      enrolments = instructor_enrolments(year, course, cohort)
+      result = enrolments.map(&:username)
+      result.uniq!
+      result
+    end
+
+    # Populates the CSV row (array) for a specific course/cohort
+    # @param data [Array<String>] the CSV row (array)
+    # @param year [LUSI::API::Calendar::Year] the course year
+    # @param course [LUSI::API::Course::Module] the course
+    # @param cohort [LUSI::API::Course::Cohort] the course cohort
+    # @param instructors [Array<LUSI::API::Course::StaffModuleEnrolment>] the
+    #   course instructors
+    def row_data(data, year, course, cohort, instructors)
+      # The code of the major (administering) department for the course.
+      # Department codes are the talis_code of LUSI::API::Organisation::Unit
+      institution, faculty, department = org_units(course).map(&:talis_code)
+      # Course title
+      data[1] = course.display_long_title
+      # Term 1-4 (data[5..8]) are left empty
+      # Number of participants (data[11]) is left empty
+      # Weekly hours (data[12]) is left empty
+      # Instructor 1-10 (data[17..26]) are left empty
+      # All instructors
+      data[27] = instructor_usernames(instructors)
+      # Operation (data[28]) is left empty
+      row_data_course_id(data, course, cohort)
+      row_data_dates(data, course, cohort)
+      row_data_departments(data, department)
+      row_data_ids(data, course, cohort, institution, faculty)
+      row_data_rollover(data, course, cohort)
+    end
+
+    def row_data_course_id(data, course, cohort)
+      # Course code
+      data[0] = course_id(course, cohort)
+      # Section ID - not currently used, set a default value for all courses
+      data[2] = '1'
+    end
+
+    def row_data_dates(data, course, cohort)
+      # Start date
+      data[9] = course.start_date_utc ? course.start_date_utc.strftime('%Y-%m-%d') : nil
+      # End date
+      data[10] = course.end_date_utc ? course.end_date_utc.strftime('%Y-%m-%d') : nil
+      # Year
+      data[13] = lusi_year(course.lusi_year_id)
+    end
+
+    def row_data_departments(data, department)
+      # Academic departments
+      data[3] = department
+      # Processing department
+      data[4] = PROCESSING_DEPARTMENT
+    end
+
+    def row_data_ids(data, course, cohort, institution, faculty)
+      # Searchable ID 1
+      # - get the course from the short title {course}-{cohort}-{year}
+      title = course.display_short_title
+      data[14] = if title && title.count('-') > 1
+                   title.split('-')[0...-2].join('-')
+                 else
+                   title
+                 end
+      # Searchable ID 2
+      data[15] = faculty
+      # Searchable ID 3
+      data[16] = institution
+    end
+
+    def row_data_rollover(data, course, cohort)
+      # Rollover course code
+      data[29] = course_id(course, cohort, :rollover)
+      # Rollover course section - use the current section ID
+      data[30] = data[2]
+    end
+
+    # Returns the LUSI year identity code for the specified year. If year is
+    # not specified, returns the identity of the current academic year
+    def year_identity(year = nil)
+      year ? lusi_year_identity(year) : current_academic_year.identity
+    end
+  end
+end

data/lib/lusi_alma_course_loader/version.rb

@@ -0,0 +1,3 @@
+module LUSIAlmaCourseLoader
+  VERSION = '0.2.0'.freeze
+end

data/lusi_alma_course_loader.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lusi_alma_course_loader/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lusi_alma_course_loader'
+  spec.version       = LUSIAlmaCourseLoader::VERSION
+  spec.authors       = ['Lancaster University Library']
+  spec.email         = ['library.dit@lancaster.ac.uk']
+
+  spec.summary       = 'Generates Alma course loader files from LUSI'
+  spec.description   = 'This gem provides a script to generate Alma course ' \
+                       "loader files from Lancaster University's LUSI student" \
+                       'records system.'
+  spec.homepage      = 'https://github.com/lulibrary/lusi_alma_course_loader'
+  spec.license       = 'MIT'
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'clamp'
+  spec.add_dependency 'alma_course_loader', '~> 0.9.1'
+
+  spec.add_development_dependency 'bundler', '~> 1.14'
+  spec.add_development_dependency 'dotenv'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'minitest', '~> 5.0'
+  spec.add_development_dependency 'minitest-hooks'
+  spec.add_development_dependency 'minitest-reporters'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'sentry-raven'
+end

metadata

@@ -0,0 +1,201 @@
+--- !ruby/object:Gem::Specification
+name: lusi_alma_course_loader
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Lancaster University Library
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-09-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: clamp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: alma_course_loader
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-hooks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sentry-raven
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This gem provides a script to generate Alma course loader files from
+  Lancaster University's LUSI studentrecords system.
+email:
+- library.dit@lancaster.ac.uk
+executables:
+- course_loader
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/course_loader
+- lib/lusi_alma_course_loader.rb
+- lib/lusi_alma_course_loader/cli/course_loader.rb
+- lib/lusi_alma_course_loader/reader.rb
+- lib/lusi_alma_course_loader/version.rb
+- lusi_alma_course_loader.gemspec
+homepage: https://github.com/lulibrary/lusi_alma_course_loader
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Generates Alma course loader files from LUSI
+test_files: []