alma 0.2.6 → 0.3.3

data/lib/alma/api_defaults.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Alma
+  module ApiDefaults
+    def apikey
+      Alma.configuration.apikey
+    end
+
+    def region
+      Alma.configuration.region
+    end
+
+    def headers
+      { "Authorization": "apikey #{self.apikey}",
+      "Accept": "application/json",
+      "Content-Type": "application/json" }
+    end
+
+    def bibs_base_path
+      "#{self.region}/almaws/v1/bibs"
+    end
+
+    def users_base_path
+      "#{self.region}/almaws/v1/users"
+    end
+
+    def items_base_path
+      "#{self.region}/almaws/v1/items"
+    end
+
+    def configuration_base_path
+      "#{self.region}/almaws/v1/conf"
+    end
+
+    def timeout
+      Alma.configuration.timeout
+    end
+  end
+end

data/lib/alma/availability_response.rb

@@ -1,91 +1,88 @@
-require 'xmlsimple'
+# frozen_string_literal: true
+
+require "xmlsimple"
 
 module Alma
   class AvailabilityResponse
-
-
     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 structure for holdings information of bib records.
     # A hash with mms ids as keys, with values of an array of
     # one or more hashes of holdings info
     def parse_bibs_data(bibs)
       bibs.reduce(Hash.new) { |acc, bib|
-        acc.merge({"#{bib.id}" => {holdings: build_holdings_for(bib)}})
+        acc.merge({ "#{bib.id}" => { holdings: build_holdings_for(bib) } })
       }
     end
 
     def build_holdings_for(bib)
       get_inventory_fields_for(bib).map do |inventory_field|
         # Use the mapping for this inventory type
-        subfield_codes = Alma::INVENTORY_SUBFIELD_MAPPING[inventory_field['tag']]
-         
+        subfield_codes = Alma::INVENTORY_SUBFIELD_MAPPING[inventory_field["tag"]]
+
         inventory_field.
           # Get all the subfields for this inventory field
-          fetch('subfield', []).
+          fetch("subfield", []).
           # Limit to only subfields codes for which we have a mapping
-          select {|sf| subfield_codes.key? sf['code'] }.
-          # Transform the array of subfields into a hash with mapped code as key 
-          reduce(Hash.new) { |acc, subfield| 
-            acc.merge({"#{subfield_codes[subfield['code']]}" => subfield['content']})
+          select { |sf| subfield_codes.key? sf["code"] }.
+          # Transform the array of subfields into a hash with mapped code as key
+          reduce(Hash.new) { |acc, subfield|
+             acc.merge({ "#{subfield_codes[subfield['code']]}" => subfield["content"] })
            }.
           # Include the inventory type
-          merge({'inventory_type' => subfield_codes['INVENTORY_TYPE']})
+          merge({ "inventory_type" => subfield_codes["INVENTORY_TYPE"] })
       end
     end
 
     def get_inventory_fields_for(bib)
-      # Return only the datafields with tags AVA, AVD, or AVE  
+      # Return only the datafields with tags AVA, AVD, or AVE
       bib.record
-        .fetch('datafield', [])
-        .select { |df| Alma::INVENTORY_SUBFIELD_MAPPING.key?(df['tag']) }
+        .fetch("datafield", [])
+        .select { |df| Alma::INVENTORY_SUBFIELD_MAPPING.key?(df["tag"]) }
     end
   end
 
   INVENTORY_SUBFIELD_MAPPING =
   {
-     'AVA' => {
-         'INVENTORY_TYPE' => 'physical',
-         'a' => 'institution',
-         'b' => 'library_code',
-         'c' => 'location',
-         'd' => 'call_number',
-         'e' => 'availability',
-         'f' => 'total_items',
-         'g' => 'non_available_items',
-         'j' => 'location_code',
-         'k' => 'call_number_type',
-         'p' => 'priority',
-         'q' => 'library',
-         't' => 'holding_info',
-         '8' => 'holding_id',  
+     "AVA" => {
+         "INVENTORY_TYPE" => "physical",
+         "a" => "institution",
+         "b" => "library_code",
+         "c" => "location",
+         "d" => "call_number",
+         "e" => "availability",
+         "f" => "total_items",
+         "g" => "non_available_items",
+         "j" => "location_code",
+         "k" => "call_number_type",
+         "p" => "priority",
+         "q" => "library",
+         "t" => "holding_info",
+         "8" => "holding_id",
      },
-     'AVD' => {
-         'INVENTORY_TYPE' => 'digital',
-         'a' => 'institution',
-         'b' => 'representations_id',
-         'c' => 'representation',
-         'd' => 'repository_name',
-         'e' => 'label',
+     "AVD" => {
+         "INVENTORY_TYPE" => "digital",
+         "a" => "institution",
+         "b" => "representations_id",
+         "c" => "representation",
+         "d" => "repository_name",
+         "e" => "label",
      },
-     'AVE' => {
-         'INVENTORY_TYPE' => 'electronic',
-         'c' => 'collection_id',
-         'e' => 'activation_status',
-         'l' => 'library_code',
-         'm' => 'collection',
-         'n' => 'public_note',
-         's' => 'coverage_statement',
-         't' => 'interface_name',
-         'u' => 'link_to_service_page',
-         '8' => 'portfolio_pid',
+     "AVE" => {
+         "INVENTORY_TYPE" => "electronic",
+         "c" => "collection_id",
+         "e" => "activation_status",
+         "l" => "library_code",
+         "m" => "collection",
+         "n" => "public_note",
+         "s" => "coverage_statement",
+         "t" => "interface_name",
+         "u" => "link_to_service_page",
+         "8" => "portfolio_pid",
      }
  }
-
-
-
 end

data/lib/alma/bib.rb

@@ -1,28 +1,32 @@
+# frozen_string_literal: true
+
 module Alma
   class  Bib
+    extend Alma::ApiDefaults
     extend Forwardable
-    
+
     def self.find(ids, args)
       get_bibs(ids, args)
     end
 
-    def self.get_bibs(ids, args={})
+    def self.get_bibs(ids, args = {})
       response = HTTParty.get(
-        self.bibs_base_path, 
-        query: {mms_id: ids_from_array(ids)}, 
-        headers: headers
+        self.bibs_base_path,
+        query: { mms_id: ids_from_array(ids) }.merge(args),
+        headers: headers,
+        timeout: timeout
         )
 
       if response.code == 200
         Alma::BibSet.new(get_body_from(response))
       else
         raise StandardError, get_body_from(response)
-      end  
+      end
     end
 
 
-    def self.get_availability(ids, args={})
-      args.merge!({expand: 'p_avail,e_avail,d_avail'})
+    def self.get_availability(ids, args = {})
+      args.merge!({ expand: "p_avail,e_avail,d_avail" })
       bibs = get_bibs(ids, args)
 
       Alma::AvailabilityResponse.new(bibs)
@@ -37,51 +41,31 @@ module Alma
 
     def initialize(response_body)
       @response = response_body
-      @id = @response['mms_id'].to_s
+      @id = @response["mms_id"].to_s
     end
 
     # The raw MARCXML record, converted to a Hash
     def record
-      @record ||= XmlSimple.xml_in(response['anies'].first)
+      @record ||= XmlSimple.xml_in(response["anies"].first)
     end
 
 
       private
 
-      def self.bibs_base_path
-        "#{self.region}/almaws/v1/bibs"
-      end
-
-      def bibs_base_path
-        self.class.bibs_base_path
-      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 headers
+          self.class.headers
+        end
 
-      def self.get_body_from(response)
-        JSON.parse(response.body)
-      end
+        def self.get_body_from(response)
+          JSON.parse(response.body)
+        end
 
-      def self.ids_from_array(ids)
-        ids.map(&:to_s).map(&:strip).join(',')
-      end
+        def self.ids_from_array(ids)
+          ids.map(&:to_s).map(&:strip).join(",")
+        end
   end
 end

data/lib/alma/bib_holding.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Alma
+  class BibHolding
+    extend Alma::ApiDefaults
+    extend Forwardable
+
+    def self.find(mms_id:, holding_id:)
+      url = "#{bibs_base_path}/#{mms_id}/holdings/#{holding_id}"
+      response = HTTParty.get(url, headers: headers, timeout: timeout)
+      new(response)
+    end
+
+    attr_reader :holding
+    def_delegators :holding, :[], :[]=, :has_key?, :keys, :to_json, :each
+
+    def initialize(holding)
+      @holding = holding
+    end
+
+    def holding_id
+      holding["holding_id"]
+    end
+  end
+end

data/lib/alma/bib_item.rb

@@ -1,22 +1,36 @@
-require 'alma/bib_item_set'
+# 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  = [
+    PERMITTED_ARGS = [
       :limit, :offset, :expand, :user_id, :current_library,
       :current_location, :q, :order_by, :direction
     ]
 
-    def self.find(mms_id, options={})
+    def self.find(mms_id, options = {})
       holding_id = options.delete(:holding_id) || "ALL"
-      options.select! {|k,_| PERMITTED_ARGS.include? k }
+      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 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)
@@ -51,7 +65,6 @@ module Alma
       in_temp_location? ? temp_location_name : holding_location_name
     end
 
-
     def holding_library
       item_data.dig("library", "value")
     end
@@ -85,7 +98,7 @@ module Alma
     end
 
     def temp_call_number
-      holding_data.fetch("temp_call_number","")
+      holding_data.fetch("temp_call_number", "")
     end
 
     def has_temp_call_number?
@@ -93,13 +106,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?
@@ -107,7 +118,7 @@ module Alma
     end
 
     def alt_call_number
-      item_data.fetch("alternative_call_number","")
+      item_data.fetch("alternative_call_number", "")
     end
 
     def has_process_type?
@@ -123,7 +134,7 @@ module Alma
     end
 
     def base_status
-      item_data.dig("base_status","value")|| ""
+      item_data.dig("base_status", "value") || ""
     end
 
     def in_place?
@@ -149,26 +160,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 @@
-module Alma
-  class BibItemSet
-    extend Forwardable
+# frozen_string_literal: true
 
-    # Let BibItemSet respond to the Enumerable duck type
-    # by delegating responsibility for #each to items
-    include Enumerable
-    attr_accessor :items
-    def_delegators :items, :each
+module Alma
+  class BibItemSet < ResultSet
+    ITEMS_PER_PAGE = 100
 
-    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.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
@@ -29,5 +47,47 @@ module Alma
       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,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

@@ -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