alma 0.2.8 → 0.3.1

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

@@ -11,5 +11,16 @@ module Alma::Error
   def error
     @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,15 @@
+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,43 +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 :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 each
-      @response.fetch(key, []).map{|item| Alma::AlmaRecord.new(item)}
+    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
-    alias list each
 
-    def size
-      each.count
+    def each(&block)
+       @results.each(&block)
     end
 
-    def sum
-      fetch('total_sum', 0)
+    def success?
+      raw_response.response.code.to_s == "200"
     end
-    alias :total_sum :sum
 
-    def currency
-      fetch('currency', nil)
+    def key
+      "fee"
     end
 
-    def total_record_count
-      fetch('total_record_count', 0)
+    def sum
+      fetch("total_sum", 0)
     end
-    alias :total_records :total_record_count
 
+    alias :total_sum :sum
 
+    def currency
+      fetch("currency", nil)
+    end
   end
 end

data/lib/alma/item_request_options.rb

@@ -0,0 +1,22 @@
+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/loan.rb

@@ -1,11 +1,16 @@
 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
@@ -14,5 +19,18 @@ module Alma
       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