alma 0.2.8 → 0.3.1

data/lib/alma/availability_response.rb

@@ -7,7 +7,7 @@ module Alma
     attr_accessor :availability
 
     def initialize(response)
-      @availability = parse_bibs_data(response.list)
+      @availability = parse_bibs_data(response.each)
     end
 
     # Data structure for holdings information of bib records.    

data/lib/alma/bib.rb

@@ -1,5 +1,6 @@
 module Alma
   class  Bib
+    extend Alma::ApiDefaults
     extend Forwardable
     
     def self.find(ids, args)
@@ -9,8 +10,9 @@ module Alma
     def self.get_bibs(ids, args={})
       response = HTTParty.get(
         self.bibs_base_path, 
-        query: {mms_id: ids_from_array(ids)}, 
-        headers: headers
+        query: {mms_id: ids_from_array(ids) }.merge(args),
+        headers: headers,
+        timeout: timeout
         )
 
       if response.code == 200
@@ -48,33 +50,13 @@ module Alma
 
       private
 
-      def self.bibs_base_path
-        "#{self.region}/almaws/v1/bibs"
-      end
-
       def bibs_base_path
         self.class.bibs_base_path
       end
 
-      def self.headers
-        { "Authorization": "apikey #{self.apikey}",
-        "Accept": "application/json",
-        "Content-Type": "application/json" }
-      end
-  
-  
       def headers
         self.class.headers
       end
-  
-  
-      def self.apikey
-        Alma.configuration.apikey
-      end
-      
-      def self.region
-        Alma.configuration.region
-      end
 
       def self.get_body_from(response)
         JSON.parse(response.body)

data/lib/alma/bib_item.rb

@@ -1,6 +1,7 @@
 require 'alma/bib_item_set'
 module Alma
   class BibItem
+    extend Alma::ApiDefaults
     extend Forwardable
 
     attr_reader :item
@@ -15,8 +16,8 @@ module Alma
       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)
-      BibItemSet.new(response)
+      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 initialize(item)
@@ -51,7 +52,6 @@ module Alma
       in_temp_location? ? temp_location_name : holding_location_name
     end
 
-
     def holding_library
       item_data.dig("library", "value")
     end
@@ -93,13 +93,11 @@ module Alma
     end
 
     def call_number
-        if has_temp_call_number?
-          holding_data.fetch("temp_call_number")
-        elsif has_alt_call_number?
-          alt_call_number
-        else
-          holding_data.fetch("call_number","")
-        end
+      if has_temp_call_number?
+        holding_data.fetch("temp_call_number")
+      else
+        holding_data.fetch("call_number","")
+      end
     end
 
     def has_alt_call_number?
@@ -149,26 +147,5 @@ module Alma
     def public_note
       item_data.fetch("public_note", "")
     end
-
-    private
-
-    def self.region
-      Alma.configuration.region
-    end
-
-    def self.bibs_base_path
-      "#{region}/almaws/v1/bibs"
-    end
-
-    def self.headers
-      { "Authorization": "apikey #{apikey}",
-       "Accept": "application/json",
-       "Content-Type": "application/json" }
-    end
-
-    def self.apikey
-      Alma.configuration.apikey
-    end
   end
-
 end

data/lib/alma/bib_item_set.rb

@@ -1,23 +1,41 @@
+# frozen_string_literal: true
+
 module Alma
-  class BibItemSet
-    extend Forwardable
 
-    # Let BibItemSet respond to the Enumerable duck type
-    # by delegating responsibility for #each to items
-    include Enumerable
-    attr_accessor :items
-    def_delegators :items, :each
+  class BibItemSet < ResultSet
 
-    def_delegators :items,:[], :[]=, :empty?, :size
+    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)
+    def initialize(response, options={})
       @raw_response = response
-      parsed = JSON.parse(response.body)
+      parsed = response.parsed_response
       @total_record_count = parsed["total_record_count"]
-      @items = parsed.fetch("item",[]).map {|item| BibItem.new(item)}
+      @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,
+        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
@@ -29,5 +47,36 @@ module Alma
       clone.items = reject(&:missing_or_lost?)
       clone
     end
+
+    def all
+      Enumerator.new do |yielder|
+        offset = 0
+        loop do
+          r = (offset == 0) ? self : single_record_class.find(@mms_id, options=@options.merge({limit: 100, offset: offset}))
+          unless r.empty?
+            r.map { |item| yielder << item }
+            offset += 100
+          else
+            raise StopIteration
+          end
+        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
   end
 end

data/lib/alma/bib_set.rb

@@ -1,31 +1,17 @@
-module Alma
-  class BibSet
-
-    extend Forwardable
-    include Enumerable
-    #include Alma::Error
-
-    attr_reader :response
-    def_delegators :list, :each, :size
-    def_delegators :response, :[], :fetch
-
-    def initialize(response_body_hash)
-      @response = response_body_hash
-    end
+# frozen_string_literal: true
 
-    def list
-      @list ||= response.fetch(key, []).map do |record|
-        Alma::Bib.new(record)
-      end
+module Alma
+  class BibSet < ResultSet
+    def key
+      "bib"
     end
 
-    def key
-      'bib'
+    def single_record_class
+      Alma::Bib
     end
 
     def total_record_count
       size
     end
-
   end
 end

data/lib/alma/config.rb

@@ -9,12 +9,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'
+      @enable_loggable = false
+      @timeout = 5
+      @http_retries = 3
+      @logger = Logger.new(STDOUT)
     end
-
   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