alma 0.2.4 → 0.3.2

data/lib/alma/bib_item.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "alma/bib_item_set"
+module Alma
+  class BibItem
+    extend Alma::ApiDefaults
+    extend Forwardable
+
+    attr_reader :item
+    def_delegators :item, :[], :has_key?, :keys, :to_json
+
+    PERMITTED_ARGS = [
+      :limit, :offset, :expand, :user_id, :current_library,
+      :current_location, :q, :order_by, :direction
+    ]
+
+    def self.find(mms_id, options = {})
+      holding_id = options.delete(:holding_id) || "ALL"
+      options.select! { |k, _| PERMITTED_ARGS.include? k }
+      url = "#{bibs_base_path}/#{mms_id}/holdings/#{holding_id}/items"
+      response = HTTParty.get(url, headers: headers, query: options, timeout: timeout)
+      BibItemSet.new(response, options.merge({ mms_id: mms_id, holding_id: holding_id }))
+    end
+
+    def self.find_by_barcode(barcode)
+      response = HTTParty.get(items_base_path, headers: headers, query: { item_barcode: barcode }, timeout: timeout, follow_redirects: true)
+      new(response)
+    end
+
+    def self.scan(mms_id:, holding_id:, item_pid:, options: {})
+      url = "#{bibs_base_path}/#{mms_id}/holdings/#{holding_id}/items/#{item_pid}"
+      response = HTTParty.post(url, headers: headers, query: options)
+      new(response)
+    end
+
+    def initialize(item)
+      @item = item
+    end
+
+    def holding_data
+      @item.fetch("holding_data", {})
+    end
+
+    def item_data
+      @item.fetch("item_data", {})
+    end
+
+    def in_temp_location?
+      holding_data.fetch("in_temp_location", false)
+    end
+
+    def library
+      in_temp_location? ? temp_library : holding_library
+    end
+
+    def library_name
+      in_temp_location? ? temp_library_name : holding_library_name
+    end
+
+    def location
+      in_temp_location? ? temp_location : holding_location
+    end
+
+    def location_name
+      in_temp_location? ? temp_location_name : holding_location_name
+    end
+
+    def holding_library
+      item_data.dig("library", "value")
+    end
+
+    def holding_library_name
+      item_data.dig("library", "desc")
+    end
+
+    def holding_location
+      item_data.dig("location", "value")
+    end
+
+    def holding_location_name
+      item_data.dig("location", "desc")
+    end
+
+    def temp_library
+      holding_data.dig("temp_library", "value")
+    end
+
+    def temp_library_name
+      holding_data.dig("temp_library", "desc")
+    end
+
+    def temp_location
+      holding_data.dig("temp_location", "value")
+    end
+
+    def temp_location_name
+      holding_data.dig("temp_location", "desc")
+    end
+
+    def temp_call_number
+      holding_data.fetch("temp_call_number", "")
+    end
+
+    def has_temp_call_number?
+      !temp_call_number.empty?
+    end
+
+    def call_number
+      if has_temp_call_number?
+        holding_data.fetch("temp_call_number")
+      else
+        holding_data.fetch("call_number", "")
+      end
+    end
+
+    def has_alt_call_number?
+      !alt_call_number.empty?
+    end
+
+    def alt_call_number
+      item_data.fetch("alternative_call_number", "")
+    end
+
+    def has_process_type?
+      !process_type.empty?
+    end
+
+    def process_type
+      item_data.dig("process_type", "value") || ""
+    end
+
+    def missing_or_lost?
+      !!process_type.match(/MISSING|LOST_LOAN/)
+    end
+
+    def base_status
+      item_data.dig("base_status", "value") || ""
+    end
+
+    def in_place?
+      base_status == "1"
+    end
+
+    def circulation_policy
+      item_data.dig("policy", "desc") || ""
+    end
+
+    def non_circulating?
+      circulation_policy.include?("Non-circulating")
+    end
+
+    def description
+      item_data.fetch("description", "")
+    end
+
+    def physical_material_type
+      item_data.fetch("physical_material_type", "")
+    end
+
+    def public_note
+      item_data.fetch("public_note", "")
+    end
+  end
+end

data/lib/alma/bib_item_set.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Alma
+  class BibItemSet < ResultSet
+    ITEMS_PER_PAGE = 100
+
+    class ResponseError < ::Alma::StandardError
+    end
+
+    attr_accessor :items
+    attr_reader :raw_response, :total_record_count
+
+    def_delegators :items, :[], :[]=, :empty?, :size, :each
+    def_delegators :raw_response, :response, :request
+
+    def initialize(response, options = {})
+      @raw_response = response
+      parsed = response.parsed_response
+      @total_record_count = parsed["total_record_count"]
+      @options = options
+      @mms_id = @options.delete(:mms_id)
+
+      validate(response)
+      @items = parsed.fetch(key, []).map { |item| single_record_class.new(item) }
+    end
+
+    def loggable
+      { total_record_count: @total_record_count.to_s,
+        mms_id: @mms_id,
+        uri: @raw_response&.request&.uri.to_s
+      }.select { |k, v| !(v.nil? || v.empty?) }
+    end
+
+    def validate(response)
+      if response.code != 200
+        log = loggable.merge(response.parsed_response)
+        raise ResponseError.new("Could not get bib items.", log)
+      end
+    end
+
+    def grouped_by_library
+      group_by(&:library)
+    end
+
+    def filter_missing_and_lost
+      clone = dup
+      clone.items = reject(&:missing_or_lost?)
+      clone
+    end
+
+    def all
+      @last_page_index ||= false
+      Enumerator.new do |yielder|
+        offset = 0
+        while (!@last_page_index || @last_page_index >= offset / items_per_page) do
+          r = (offset == 0) ? self : single_record_class.find(@mms_id, options = @options.merge({ limit: items_per_page, offset: offset }))
+          unless r.empty?
+            r.map { |item| yielder << item }
+            @last_page_index = (offset / items_per_page)
+          else
+            @last_page_index = @last_page_index ? @last_page_index - 1 : -1
+          end
+
+          if r.size == items_per_page
+            @last_page_index += 1
+          end
+
+          offset += items_per_page
+        end
+      end
+    end
+
+    def each(&block)
+      @items.each(&block)
+    end
+
+    def success?
+      raw_response.response.code.to_s == "200"
+    end
+
+    def key
+      "item"
+    end
+
+    def single_record_class
+      Alma::BibItem
+    end
+
+    def items_per_page
+      ITEMS_PER_PAGE
+    end
+  end
+end

data/lib/alma/bib_set.rb

@@ -1,22 +1,17 @@
+# frozen_string_literal: true
+
 module Alma
   class BibSet < ResultSet
-
-    def top_level_key
-      'bibs'
-    end
-
-    def response_records_key
-      'bib'
+    def key
+      "bib"
     end
 
     def single_record_class
       Alma::Bib
     end
 
-    # Doesn't seem to actually return a total record count as documented.
     def total_record_count
-      (response_records.is_a? Array) ? size : 1
+      size
     end
-
   end
 end

data/lib/alma/config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Alma
   class << self
     attr_accessor :configuration
@@ -9,12 +11,16 @@ module Alma
   end
 
   class Configuration
-    attr_accessor :apikey, :region
+    attr_accessor :apikey, :region, :enable_loggable
+    attr_accessor :timeout, :http_retries, :logger
 
     def initialize
       @apikey = "TEST_API_KEY"
-      @region = 'https://api-na.hosted.exlibrisgroup.com'
+      @region = "https://api-na.hosted.exlibrisgroup.com"
+      @enable_loggable = false
+      @timeout = 5
+      @http_retries = 3
+      @logger = Logger.new(STDOUT)
     end
-
   end
-end
+end

data/lib/alma/course.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Alma
+  class Course
+    extend Alma::ApiDefaults
+    extend Forwardable
+
+    def self.all_courses(args: {})
+      response = HTTParty.get("#{courses_base_path}/courses",
+                              query: args,
+                              headers: headers,
+                              timeout: timeout)
+      if response.code == 200
+        Alma::CourseSet.new(get_body_from(response))
+      else
+        raise StandardError, get_body_from(response)
+      end
+    end
+
+    attr_accessor :response
+
+    # The Course object can respond directly to Hash like access of attributes
+    def_delegators :response, :[], :[]=, :has_key?, :keys, :to_json
+
+    def initialize(response_body)
+      @response = response_body
+    end
+
+    private
+
+      def self.get_body_from(response)
+        JSON.parse(response.body)
+      end
+
+      def self.courses_base_path
+        "https://api-na.hosted.exlibrisgroup.com/almaws/v1"
+      end
+
+      def courses_base_path
+        self.class.courses_base_path
+      end
+
+      def headers
+        self.class.headers
+      end
+  end
+end

data/lib/alma/course_set.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Alma
+  class CourseSet < ResultSet
+    def key
+      "course"
+    end
+
+    def single_record_class
+      Alma::Course
+    end
+
+    def total_record_count
+      size
+    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