alma 0.2.4 → 0.3.2

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/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,21 +1,54 @@
+# frozen_string_literal: true
+
 module Alma
   class FineSet < ResultSet
+    class ResponseError < Alma::StandardError
+    end
+
+    attr_reader :results, :raw_response
+    def_delegators :results, :empty?
+
+    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 loggable
+      { uri: @raw_response&.request&.uri.to_s
+      }.select { |k, v| !(v.nil? || v.empty?) }
+    end
 
-    def top_level_key
-      'fees'
+    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 response_records_key
-      'fee'
+    def each(&block)
+      @results.each(&block)
+    end
+
+    def success?
+      raw_response.response.code.to_s == "200"
+    end
+
+    def key
+      "fee"
     end
 
     def sum
-      @response[top_level_key].fetch('total_sum', 0)
+      fetch("total_sum", 0)
     end
 
+    alias :total_sum :sum
+
     def currency
-      @response[top_level_key].fetch('currency', nil)
+      fetch("currency", nil)
     end
-
   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