alma 0.2.6 → 0.3.3

data/lib/alma/electronic/README.md

@@ -0,0 +1,20 @@
+## Alma::Electronic
+
+A wrapper for the Alma::Electronic API.
+
+The main entry point is the get methods.
+
+### To get a list of all the collections.
+
+```
+Alma::Electronic.get()
+```
+
+Will also accept these params:
+
+| Parameter | Type      | Required  | Description |
+| --------- | ----------| --------- | ---------------------------------------------------------------------------------------------------------------|
+| q         | xs:string | Optional. | Search query. Optional. Searching for words in interface_name, keywords, name or po_line_id (see Brief Search) |
+| limit     | xs:int    | Optional. | Default: 10Limits the number of results. Optional. Valid values are 0-100. Default value: 10. |
+| offset    | xs:int    | Optional. | Default: 0Offset of the results returned. Optional. Default value: 0, which methodseans that the first results will be returned. |
+

data/lib/alma/electronic/batch_utils.rb

@@ -0,0 +1,224 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "alma/electronic"
+
+# Contains batch processing utils for Alma Electronic APIs.
+#
+# This class and its methods are used to iterate over Alma Electronic IDs to
+# process and fetch Alma electronic objects via the Alma Electronic APIs.  The
+# https calls are logged and can be used to rerun the batch process without
+# making any further http calls or to just rerun parts of the full batch.
+module Alma
+  class Electronic::BatchUtils
+    attr_reader :notes, :type
+
+    # @param [Hash] options The options to create a batch instance.
+    # @option [true, false] :chain true indicates a new instance of self returned.
+    # @option [Array<String>] :ids List of collection ids.
+    # @option ["collection", "service", "portfolio"] :type The Alma Electronic object type.
+    # @option [String] :tag  A string used to tag the batch session.
+    # @option [Logger] :logger A logger used t
+    def initialize(options = {})
+      options ||= options {}
+      @chain = options.fetch(:chain, false)
+      @ids = options.fetch(:ids, [])
+      @type = options.fetch(:type, "collection")
+      @tag = options.fetch(:tag, Time.now.to_s)
+
+      @@logger = options[:logger] || Logger.new("log/electronic_batch_process.log")
+    end
+
+    def get_collection_notes(ids = nil, options = {})
+      ids ||= @ids
+      get_notes(options.merge(ids: make_collection_ids(ids), type: "collection"))
+    end
+
+    def get_service_notes(ids = nil, options = {})
+      ids ||= @ids
+      get_notes(options.merge(ids: get_service_ids(ids, options), type: "service"))
+    end
+
+    def get_portfolio_notes(ids = nil, options = {})
+      ids ||= @ids
+      get_notes(options.merge(ids: get_portfolio_ids(ids, options, type: "portfolio")))
+    end
+
+    def get_notes(options = {})
+      options ||= {}
+      chain = options.fetch(:chain, @chain)
+      ids = options[:ids] || (chain ? build_ids(options) : @ids)
+
+      type = options.fetch(:type, @type)
+      tag = options.fetch(:tag, @tag)
+      @notes = ids.inject({}) do |notes, params|
+        id = get_id(type, params)
+        start = Time.now
+
+        begin
+          item = Alma::Electronic.get(params)
+        rescue StandardError => e
+          item = { "error" => e.message }
+        end
+
+        data = ["error", "authentication_note", "public_note"].reduce({}) do |acc, field|
+          acc[field] = item[field] if item[field].present?
+          acc
+        end
+
+        unavailable = item.dig("service_temporarily_unavailable", "value")
+        if unavailable == "1" || unavailable == "true"
+          data.merge!(item.slice("service_temporarily_unavailable", "service_unavailable_date", "service_unavailable_reason"))
+        end
+
+        if data.present?
+          log(params.merge(data).merge(type: type, start: start, tag: tag))
+
+          notes[id] = data unless data["error"].present?
+        end
+
+        notes
+      end
+
+      self.class.new(options.merge(
+                       chain: chain,
+                       ids: ids,
+                       type: type,
+                       tag: tag,
+                       notes: notes,
+                       logger: @@logger,
+      ))
+    end
+
+    def get_service_ids(ids = @ids, options = {})
+      tag = options.fetch(:tag, @tag)
+      start = Time.now
+
+      make_collection_ids(ids)
+        .map { |id| id.merge(type: "services") }
+        .inject([]) do |service_ids, params|
+        params.merge!(tag: tag)
+
+        begin
+          item = Alma::Electronic.get(params)
+
+          if item["errorList"]
+            log params.merge(item["errorList"])
+              .merge(start: start)
+          else
+            item["electronic_service"].each { |service|
+              service_id = { service_id: service["id"].to_s }
+              service_ids << params.slice(:collection_id)
+                .merge(service_id)
+
+              log params.merge(service_id)
+                .merge(start: start)
+            }
+          end
+
+        rescue StandardError => e
+          log params.merge("error" => e.message)
+            .merge(start: start)
+        end
+
+        service_ids
+      end
+    end
+
+    # Builds the notes object using the logs.
+    def build_notes(options = {})
+      options ||= {}
+      type ||= options.fetch(:type, "collection")
+
+      get_logged_items(options)
+        .select { |item| item.slice("authentication_note", "public_note").values.any?(&:present?) }
+        .inject({}) do |nodes, item|
+
+        id = item["#{type}_id"]
+        nodes.merge(id => item.slice("authentication_note", "public_note"))
+      end
+    end
+
+    # Builds list of ids from logs based on failed attempts.
+    # Useful for rebuilding part of collection.
+    def build_failed_ids(options = {})
+      successful_ids = build_successful_ids(options)
+      get_logged_items(options)
+        .select { |item| item.slice("authentication_note", "public_note").values.all?(&:nil?) }
+        .map { |item| item["collection_id"] }
+        .select { |id| !successful_ids.include? id }
+        .uniq
+    end
+
+    # Builds list of ids from logs based on successful attempts.
+    # Useful for verifying that failed ids have always failed.
+    def build_successful_ids(options = {})
+      get_logged_items(options)
+        .select { |item| item.slice("authentication_note", "public_note").values.present? }
+        .map { |item| item["collection_id"] }
+        .uniq
+    end
+
+    # Builds a list of all ids for a specific session.
+    # Useful for analytics purpose or rebuilds.
+    def build_ids(options = {})
+      build_failed_ids(options) + build_successful_ids(options)
+    end
+
+    def print_notes(options = {})
+      options ||= {}
+      chain = options.fetch(:chain, @chain)
+      notes = options[:notes] || chain ? build_notes(options) : @notes
+      type = options.fetch(:type, @type)
+      tag = options.fetch(:tag, @tag)
+
+      filename = options.fetch(:filename, "spec/fixtures/#{type}_notes.json")
+
+      File.open(filename, "w") do |file|
+        file.write(JSON.pretty_generate(notes))
+      end
+
+      self.class.new(options.merge(
+                       chain: chain,
+                       notes: notes,
+                       type: type,
+                       tag: tag,
+                       logger: @@logger,
+      ))
+    end
+
+  private
+    def log(params)
+      if defined?(LogUtils)
+        LogUtils.json_request_logger(@@logger, params)
+      else
+        @@logger.info(params)
+      end
+    end
+
+    def get_id(type, params = {})
+      id = "#{type}_id".to_sym
+      params[id]
+    end
+
+    def make_collection_ids(ids = @ids)
+      ids.map { |id|
+        id.class == Hash ? id : { collection_id: id.to_s }
+      }
+    end
+
+    # Returns JSON parsed list of logged items
+    def get_logged_items(options = {})
+      options ||= {}
+      type ||= options.fetch(:type, "collection")
+      tag ||= options.fetch(:tag, @tag)
+      filename = (@@logger.instance_variable_get :@logdev).filename
+      File.readlines(filename)
+        .map { |log| log.match(/{.*}/).to_s }
+        .select(&:present?)
+        .map { |json| JSON.parse(json) }
+        .select { |item| item["tag"] == tag }
+        .select { |item| item["type"] == type }
+    end
+  end
+end

data/lib/alma/electronic/business.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "alma/electronic"
+
+module Alma
+  # Holds some custom business logic for our Alma Electronic API.
+  # This class is not intended for public use.
+  class Electronic::Business
+    # The Service ID is usually the Collection ID grouped by
+    # 2 digits with the first number incremented by 1 and the
+    # fifth number decremented by 1.
+    #
+    # @note However, this pattern does not hold for all cases.
+    #
+    # @param collection_id [String] The electronic collection id.
+    def service_id(collection_id)
+      collection_id.scan(/.{1,2}/).each_with_index.map { |char, index|
+        if index == 0
+          "%02d" % (char.to_i + 1)
+        elsif index == 4
+          "%02d" % (char.to_i - 1)
+        else
+          char
+        end
+      }.join
+    end
+  end
+end

data/lib/alma/electronic.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require "httparty"
+require "active_support"
+require "active_support/core_ext"
+require "alma/config"
+
+module Alma
+  # Alma::Electronic APIs wrapper.
+  class Electronic
+    class ElectronicError < ArgumentError
+    end
+
+    def self.get(params = {})
+      retries_count = 0
+      response = nil
+      while retries_count < http_retries do
+        begin
+          response = get_api(params)
+          break;
+
+        rescue Net::ReadTimeout
+          retries_count += 1
+          log.error("Retrying http after timeout with : #{params}")
+          no_more_retries_left = retries_count == http_retries
+
+          raise Net::ReadTimeout.new("Failed due to net timeout after #{http_retries}: #{params}") if no_more_retries_left
+        end
+      end
+
+      return response
+    end
+
+    def self.get_totals
+      @totals ||= get(limit: "0").data["total_record_count"]
+    end
+
+    def self.log
+      Alma.configuration.logger
+    end
+
+    def self.get_ids
+      total = get_totals()
+      limit = 100
+      offset = 0
+      log.info("Retrieving #{total} collection ids.")
+      groups = Array.new(total / limit + 1, limit)
+      @ids ||= groups.map { |limit|
+        prev_offset = offset
+        offset += limit
+        { offset: prev_offset, limit: limit }
+      }
+        .map { |params|  Thread.new { self.get(params) } }
+        .map(&:value).map(&:data)
+        .map { |data| data["electronic_collection"].map { |coll| coll["id"] } }
+        .flatten.uniq
+    end
+
+    def self.http_retries
+      Alma.configuration.http_retries
+    end
+
+  private
+    class ElectronicAPI
+      include ::HTTParty
+      include ::Enumerable
+      extend ::Forwardable
+
+      REQUIRED_PARAMS = []
+      RESOURCE = "/almaws/v1/electronic"
+
+      attr_reader :params, :data
+      def_delegators :@data, :each, :each_pair, :fetch, :values, :keys, :dig,
+        :slice, :except, :to_h, :to_hash, :[], :with_indifferent_access
+
+      def initialize(params = {})
+        @params = params
+        headers = self.class::headers
+        log.info(url: url, query: params)
+        response = self.class::get(url, headers: headers, query: params, timeout: timeout)
+        @data = JSON.parse(response.body) rescue {}
+      end
+
+      def url
+        "#{Alma.configuration.region}#{resource}"
+      end
+
+      def timeout
+        Alma.configuration.timeout
+      end
+
+      def log
+        Alma::Electronic.log
+      end
+
+      def resource
+        @params.inject(self.class::RESOURCE) { |path, param|
+          key = param.first
+          value = param.last
+
+          if key && value
+            path.gsub(/:#{key}/, value.to_s)
+          else
+            path
+          end
+        }
+      end
+
+      def self.can_process?(params = {})
+        type = self.to_s.split("::").last.parameterize
+        self::REQUIRED_PARAMS.all? { |param| params.include? param } &&
+          params[:type].blank? || params[:type] == type
+      end
+
+    private
+      def self.headers
+        { "Authorization": "apikey #{apikey}",
+         "Accept": "application/json",
+         "Content-Type": "application/json" }
+      end
+
+      def self.apikey
+        Alma.configuration.apikey
+      end
+    end
+
+    class Portfolio < ElectronicAPI
+      REQUIRED_PARAMS = [ :collection_id, :service_id, :portfolio_id ]
+      RESOURCE = "/almaws/v1/electronic/e-collections/:collection_id/e-services/:service_id/portfolios/:portfolio_id"
+    end
+
+    class Service < ElectronicAPI
+      REQUIRED_PARAMS = [ :collection_id, :service_id ]
+      RESOURCE = "/almaws/v1/electronic/e-collections/:collection_id/e-services/:service_id"
+    end
+
+    class Services < ElectronicAPI
+      REQUIRED_PARAMS = [ :collection_id, :type ]
+      RESOURCE = "/almaws/v1/electronic/e-collections/:collection_id/e-services"
+    end
+
+    class Collection < ElectronicAPI
+      REQUIRED_PARAMS = [ :collection_id ]
+      RESOURCE = "/almaws/v1/electronic/e-collections/:collection_id"
+    end
+
+    # Catch all Electronic API.
+    # By default returns all collections
+    class Collections < ElectronicAPI
+      REQUIRED_PARAMS = []
+      RESOURCE = "/almaws/v1/electronic/e-collections"
+
+      def self.can_process?(params = {})
+        true
+      end
+    end
+
+    # Order matters because parameters can repeat.
+    REGISTERED_APIs = [Portfolio, Service, Services, Collection, Collections]
+
+    def self.get_api(params)
+      REGISTERED_APIs
+        .find { |m| m.can_process? params }
+        .new(params)
+    end
+  end
+end

data/lib/alma/error.rb

@@ -1,15 +1,27 @@
-module Alma::Error
+# frozen_string_literal: true
 
+module Alma::Error
   def has_error?
     !error.empty?
   end
 
   def error_message
-    (has_error?) ? error['errorList']['error']['errorMessage'] : ''
+    (has_error?) ? error["errorList"]["error"]["errorMessage"] : ""
   end
 
   def error
-    @response.fetch('web_service_result', {})
+    @response.fetch("web_service_result", {})
   end
+end
 
-end
+module Alma
+  class StandardError < ::StandardError
+    def initialize(message, loggable = {})
+      if Alma.configuration.enable_loggable
+        message = { error: message }.merge(loggable).to_json
+      end
+
+      super message
+    end
+  end
+end

data/lib/alma/fine.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Alma
+  class Fine < AlmaRecord
+    extend Alma::ApiDefaults
+
+    def self.where_user(user_id, args = {})
+      response = HTTParty.get("#{users_base_path}/#{user_id}/fees", query: args, headers: headers, timeout: timeout)
+      if response.code == 200
+        Alma::FineSet.new(response)
+      else
+        raise StandardError, get_body_from(response)
+      end
+    end
+  end
+end

data/lib/alma/fine_set.rb

@@ -1,39 +1,54 @@
+# frozen_string_literal: true
+
 module Alma
-  class FineSet
-    extend Forwardable
-    include Enumerable
-    #include Alma::Error
+  class FineSet < ResultSet
+    class ResponseError < Alma::StandardError
+    end
 
-    attr_reader :response
-    def_delegators :list, :each, :size
-    def_delegators :response, :[], :fetch
+    attr_reader :results, :raw_response
+    def_delegators :results, :empty?
 
-    def initialize(response_body_hash)
-      @response = response_body_hash
+    def initialize(raw_response)
+      @raw_response = raw_response
+      @response = raw_response.parsed_response
+      validate(raw_response)
+      @results = @response.fetch(key, [])
+        .map { |item| single_record_class.new(item) }
     end
 
-    def key
-      'fee'
+    def loggable
+      { uri: @raw_response&.request&.uri.to_s
+      }.select { |k, v| !(v.nil? || v.empty?) }
     end
 
-    def list
-      fetch(key, [])
+    def validate(response)
+      if response.code != 200
+        message = "Could not find fines."
+        log = loggable.merge(response.parsed_response)
+        raise ResponseError.new(message, log)
+      end
     end
 
-    def sum
-      fetch('total_sum', 0)
+    def each(&block)
+      @results.each(&block)
     end
-    alias :total_sum :sum
 
-    def currency
-      fetch('currency', nil)
+    def success?
+      raw_response.response.code.to_s == "200"
     end
 
-    def total_record_count
-      fetch('total_record_count', 0)
+    def key
+      "fee"
     end
-    alias :total_records :total_record_count
 
+    def sum
+      fetch("total_sum", 0)
+    end
+
+    alias :total_sum :sum
 
+    def currency
+      fetch("currency", nil)
+    end
   end
 end

data/lib/alma/item_request_options.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Alma
+  class ItemRequestOptions < RequestOptions
+    class ResponseError < Alma::StandardError
+    end
+
+    def self.get(mms_id, holding_id = nil, item_pid = nil, options = {})
+      url = "#{bibs_base_path}/#{mms_id}/holdings/#{holding_id}/items/#{item_pid}/request-options"
+      options.select! { |k, _|  REQUEST_OPTIONS_PERMITTED_ARGS.include? k }
+      response = HTTParty.get(url, headers: headers, query: options, timeout: timeout)
+      new(response)
+    end
+
+    def validate(response)
+      if response.code != 200
+        message = "Could not get item request options."
+        log = loggable.merge(response.parsed_response)
+        raise ResponseError.new(message, log)
+      end
+    end
+  end
+end

data/lib/alma/library.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Alma
+  class Library < AlmaRecord
+    extend Alma::ApiDefaults
+
+    def self.all(args: {})
+      response = HTTParty.get("#{configuration_base_path}/libraries", query: args, headers: headers, timeout: timeout)
+      if response.code == 200
+        LibrarySet.new(response)
+      else
+        raise StandardError, get_body_from(response)
+      end
+    end
+
+    def self.find(library_code:, args: {})
+      response = HTTParty.get("#{configuration_base_path}/libraries/#{library_code}", query: args, headers: headers, timeout: timeout)
+      if response.code == 200
+        AlmaRecord.new(response)
+      else
+        raise StandardError, get_body_from(response)
+      end
+    end
+
+    def self.get_body_from(response)
+      JSON.parse(response.body)
+    end
+  end
+end

data/lib/alma/library_set.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Alma
+  class LibrarySet < ResultSet
+    def_delegators :results, :[], :empty?
+
+    def each(&block)
+      results.each(&block)
+    end
+
+    def results
+      @results ||= @response.fetch(key, [])
+         .map { |item| single_record_class.new(item) }
+    end
+
+    protected
+      def key
+        "library"
+      end
+  end
+end

data/lib/alma/loan.rb

@@ -1,9 +1,38 @@
+# frozen_string_literal: true
+
 module Alma
   class Loan < AlmaRecord
+    extend Alma::ApiDefaults
+
+
+    def renewable?
+      !!renewable
+    end
+
+    def renewable
+      response.fetch("renewable", false)
+    end
+
+    def overdue?
+      loan_status == "Overdue"
+    end
 
     def renew
-      Alma::User.renew_loan({user_id: user_id, loan_id: loan_id})
+      Alma::User.renew_loan({ user_id: user_id, loan_id: loan_id })
     end
 
+    def self.where_user(user_id, args = {})
+      # Always expand renewable unless you really don't want to
+      args[:expand] ||= "renewable"
+      # Default to upper limit
+      args[:limit] ||= 100
+      response = HTTParty.get(
+        "#{users_base_path}/#{user_id}/loans",
+        query: args,
+        headers: headers,
+        timeout: timeout
+        )
+      Alma::LoanSet.new(response, args)
+    end
   end
-end
+end