alma 0.2.6 → 0.3.3

data/lib/alma/loan_set.rb

@@ -1,29 +1,76 @@
+# frozen_string_literal: true
+
 module Alma
-  class LoanSet
-    extend Forwardable
-    include Enumerable
-    #include Alma::Error
+  class LoanSet < ResultSet
+    class ResponseError < Alma::StandardError
+    end
+
+    alias :total_records :total_record_count
+
+
+    attr_reader :results, :raw_response
+    def_delegators :results, :empty?
+
+    def initialize(raw_response, search_args = {})
+      @raw_response = raw_response
+      @response = raw_response.parsed_response
+      @search_args = search_args
+      validate(raw_response)
+      @results = @response.fetch(key, [])
+        .map { |item| single_record_class.new(item) }
+      # args passed to the search that returned this set
+      # such as limit, expand, order_by, etc
+    end
+
+    def loggable
+      { search_args: @search_args,
+        uri: @raw_response&.request&.uri.to_s
+      }.select { |k, v| !(v.nil? || v.empty?) }
+    end
 
-    attr_reader :response
-    def_delegators :list, :each, :size
-    def_delegators :response, :[], :fetch
+    def validate(response)
+      if response.code != 200
+        error = "Could not find loans info."
+        log = loggable.merge(response.parsed_response)
+        raise ResponseError.new(error, log)
+      end
+    end
 
-    def initialize(response_body_hash)
-      @response = response_body_hash
+    def all
+      Enumerator.new do |yielder|
+        offset = 0
+        loop do
+          extra_args = @search_args.merge({ limit: 100, offset: offset })
+          r = (offset == 0) ? self : single_record_class.where_user(user_id, extra_args)
+          unless r.empty?
+            r.map { |item| yielder << item }
+            offset += 100
+          else
+            raise StopIteration
+          end
+        end
+      end
     end
 
-    def list
-      fetch(key, [])
+    def each(&block)
+      @results.each(&block)
+    end
+
+    def success?
+      raw_response.response.code.to_s == "200"
     end
 
     def key
-      'item_loan'
+      "item_loan"
     end
 
-    def total_record_count
-      fetch('total_record_count', 0)
+    def single_record_class
+      Alma::Loan
     end
-    alias :total_records :total_record_count
 
+    private
+      def user_id
+        @user_id ||= results.first.user_id
+      end
   end
 end

data/lib/alma/location.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Alma
+  class Location < AlmaRecord
+    extend Alma::ApiDefaults
+
+    def self.all(library_code:, args: {})
+      response = HTTParty.get("#{configuration_base_path}/libraries/#{library_code}/locations", query: args, headers: headers, timeout: timeout)
+      if response.code == 200
+        LocationSet.new(response)
+      else
+        raise StandardError, get_body_from(response)
+      end
+    end
+
+    def self.find(library_code:, location_code:, args: {})
+      response = HTTParty.get("#{configuration_base_path}/libraries/#{library_code}/locations/#{location_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/location_set.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Alma
+  class LocationSet < 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
+        "location"
+      end
+  end
+end

data/lib/alma/renewal_response.rb

@@ -1,31 +1,40 @@
+# frozen_string_literal: true
+
 module Alma
   class RenewalResponse
-
-
-
     def initialize(response)
-      @response = response
-      @success  = response.has_key?('loan_id')
+      @raw_response = response
+      @response = response.parsed_response
+      @success  = response.has_key?("loan_id")
+    end
+
+    def loggable
+      { uri: @raw_response&.request&.uri.to_s
+      }.select { |k, v| !(v.nil? || v.empty?) }
     end
 
     def renewed?
       @success
     end
 
+    def has_error?
+      !renewed?
+    end
+
     def due_date
-      @response.fetch('dueDate', '')
+      @response.fetch("due_date", "")
     end
 
 
     def due_date_pretty
-      Time.parse(due_date).strftime('%m-%e-%y %H:%M')
+      Time.parse(due_date).strftime("%m-%e-%y %H:%M")
     end
 
     def item_title
       if renewed?
-        @response['title']
+        @response["title"]
       else
-        'This Item'
+        "This Item"
       end
     end
 
@@ -38,8 +47,7 @@ module Alma
     end
 
     def error_message
-        @response unless renewed?
+      @response unless renewed?
     end
-
   end
 end

data/lib/alma/request.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Alma
+  class BibRequest
+    class  ItemAlreadyExists < Alma::StandardError
+    end
+
+    extend Alma::ApiDefaults
+
+    REQUEST_TYPES = %w[HOLD DIGITIZATION BOOKING]
+
+    def self.submit(args)
+      request = new(args)
+      response = HTTParty.post(
+        "#{bibs_base_path}/#{request.mms_id}/requests",
+        query: { user_id: request.user_id },
+        headers: headers,
+        body: request.body.to_json
+        )
+      Alma::Response.new(response)
+    end
+
+    attr_reader :mms_id, :user_id, :body, :request_type
+    def initialize(args)
+      @mms_id = args.delete(:mms_id) { raise ArgumentError.new(":mms_id option must be specified to create request") }
+      @user_id = args.delete(:user_id) { raise ArgumentError.new(":user_id option must be specified to create request") }
+      @request_type = args.fetch(:request_type, "NOT_SPECIFIED")
+      validate!(args)
+      normalize!(args)
+      @body = args
+    end
+
+
+    def normalize!(args)
+      request_type_normalization!(args)
+      additional_normalization!(args)
+    end
+
+    def request_type_normalization!(args)
+      method = "#{@request_type.downcase}_normalization".to_sym
+      send(method, args) if respond_to? method
+    end
+
+    # Intended to be overridden by subclasses, allowing extra normalization logic to be provided
+    def additional_normalization!(args)
+    end
+
+    def validate!(args)
+      unless REQUEST_TYPES.include?(request_type)
+        raise ArgumentError.new(":request_type option must be specified and one of #{REQUEST_TYPES.join(", ")} to submit a request")
+      end
+      request_type_validation!(args)
+      additional_validation!(args)
+    end
+
+    def request_type_validation!(args)
+      method = "#{@request_type.downcase}_validation".to_sym
+      send(method, args) if respond_to? method
+    end
+
+    # Intended to be overridden by subclasses, allowing extra validation logic to be provided
+    def additional_validation!(args)
+    end
+
+    def digitization_normalization(args)
+      if args[:target_destination].is_a? String
+        args[:target_destination] = { value: args[:target_destination] }
+      end
+    end
+
+    def digitization_validation(args)
+      args.fetch(:target_destination) do
+        raise ArgumentError.new(
+          ":target_destination option must be specified when request_type is DIGITIZATION"
+        )
+      end
+      pd = args.fetch(:partial_digitization) do
+        raise ArgumentError.new(
+          ":partial_digitization option must be specified when request_type is DIGITIZATION"
+        )
+      end
+      if pd == true
+        args.fetch(:comment) do
+          raise ArgumentError.new(
+            ":comment option must be specified when :request_type is DIGITIZATION and :partial_digitization is true"
+          )
+        end
+      end
+    end
+
+    def booking_normalization(args)
+      if args[:material_type].is_a? String
+        args[:material_type] = { value: args[:material_type] }
+      end
+    end
+
+    def booking_validation(args)
+      args.fetch(:booking_start_date) do
+        raise ArgumentError.new(
+          ":booking_start_date option must be specified when request_type is BOOKING"
+        )
+      end
+      args.fetch(:booking_end_date) do
+        raise ArgumentError.new(
+          ":booking_end_date option must be specified when request_type is BOOKING"
+        )
+      end
+      args.fetch(:pickup_location_type) do
+        raise ArgumentError.new(
+          ":pickup_location_type option must be specified when request_type is BOOKING"
+        )
+      end
+      args.fetch(:pickup_location_library) do
+        raise ArgumentError.new(
+          ":pickup_location_library option must be specified when request_type is BOOKING"
+        )
+      end
+    end
+
+    def hold_normalization(args)
+      # if args[:material_type].is_a? String
+      #   args[:material_type] = { value: args[:material_type] }
+      # end
+    end
+
+    def hold_validation(args)
+      args.fetch(:pickup_location_type) do
+        raise ArgumentError.new(
+          ":pickup_location_type option must be specified when request_type is HOLD"
+        )
+      end
+      args.fetch(:pickup_location_library) do
+        raise ArgumentError.new(
+          ":pickup_location_library option must be specified when request_type is HOLD"
+        )
+      end
+    end
+  end
+
+  class ItemRequest < BibRequest
+    def self.submit(args)
+      request = new(args)
+      response = HTTParty.post(
+        "#{bibs_base_path}/#{request.mms_id}/holdings/#{request.holding_id}/items/#{request.item_pid}/requests",
+        query: { user_id: request.user_id },
+        headers: headers,
+        body: request.body.to_json
+        )
+      Alma::Response.new(response)
+    end
+
+    attr_reader :holding_id, :item_pid
+    def initialize(args)
+      super(args)
+      @holding_id = args.delete(:holding_id) { raise ArgumentError.new(":holding_id option must be specified to create request") }
+      @item_pid = args.delete(:item_pid) { raise ArgumentError.new(":item_pid option must be specified to create request") }
+    end
+
+    def additional_validation!(args)
+      args.fetch(:description) do
+        raise ArgumentError.new(
+          ":description option must be specified when request_type is DIGITIZATION"
+        )
+      end
+    end
+  end
+end

data/lib/alma/request_options.rb

@@ -1,6 +1,12 @@
+# frozen_string_literal: true
+
 module Alma
   class RequestOptions
+    class ResponseError < Alma::StandardError
+    end
+
     extend Forwardable
+    extend Alma::ApiDefaults
 
     attr_accessor :request_options, :raw_response
     def_delegators :raw_response, :response, :request
@@ -9,39 +15,52 @@ module Alma
 
     def initialize(response)
       @raw_response = response
-      @request_options = JSON.parse(response.body)["request_option"]
+      validate(response)
+      @request_options = response.parsed_response["request_option"]
     end
 
-    def self.get(mms_id, options={})
+
+    def self.get(mms_id, options = {})
       url = "#{bibs_base_path}/#{mms_id}/request-options"
-      options.select! {|k,_|  REQUEST_OPTIONS_PERMITTED_ARGS.include? k }
-      response = HTTParty.get(url, headers: headers, query: options)
+      options.select! { |k, _|  REQUEST_OPTIONS_PERMITTED_ARGS.include? k }
+      response = HTTParty.get(url, headers: headers, query: options, timeout: timeout)
       new(response)
     end
 
-    def hold_allowed?
-      !request_options.select {|option| option["type"]["value"] == "HOLD" }.empty?
+    def loggable
+      { uri: @raw_response&.request&.uri.to_s
+      }.select { |k, v| !(v.nil? || v.empty?) }
     end
 
-    private
+    def validate(response)
+      if response.code != 200
+        raise ResponseError.new("Could not get request options.", loggable.merge(response.parsed_response))
+      end
+    end
 
-    def self.region
-      Alma.configuration.region
+    def hold_allowed?
+      !request_options.nil? &&
+        !request_options.select { |option| option["type"]["value"] == "HOLD" }.empty?
     end
 
-    def self.bibs_base_path
-      "#{region}/almaws/v1/bibs"
+    def digitization_allowed?
+      !request_options.nil? &&
+        !request_options.select { |option| option["type"]["value"] == "DIGITIZATION" }.empty?
     end
 
-    def self.headers
-      { "Authorization": "apikey #{apikey}",
-       "Accept": "application/json",
-       "Content-Type": "application/json" }
+    def booking_allowed?
+      !request_options.nil? &&
+        !request_options.select { |option| option["type"]["value"] == "BOOKING" }.empty?
     end
 
-    def self.apikey
-      Alma.configuration.apikey
+    def resource_sharing_broker_allowed?
+      !request_options.nil? &&
+        !request_options.select { |option| option["type"]["value"] == "RS_BROKER" }.empty?
     end
 
+    def ez_borrow_link
+      broker = request_options.select { |option| option["type"]["value"] == "RS_BROKER" }
+      broker.collect { |opt| opt["request_url"] }.first
+    end
   end
 end

data/lib/alma/request_set.rb

@@ -1,29 +1,78 @@
+# frozen_string_literal: true
+
 module Alma
-  class RequestSet
-    extend Forwardable
-    include Enumerable
-    #include Alma::Error
+  class RequestSet < ResultSet
+    class ResponseError < Alma::StandardError
+    end
+
+    alias :total_records :total_record_count
 
-    attr_reader :response
-    def_delegators :list, :each, :size
-    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 list
-      fetch(key, [])
+    def loggable
+      { uri: @raw_response&.request&.uri.to_s
+      }.select { |k, v| !(v.nil? || v.empty?) }
     end
 
-    def total_record_count
-      fetch('total_record_count', 0)
+    def validate(response)
+      if response.code != 200
+        error = "Could not find requests."
+        log = loggable.merge(response.parsed_response)
+        raise ResponseError.new(error, log)
+      end
+    end
+
+    def all
+      Enumerator.new do |yielder|
+        offset = 0
+        loop do
+          r = (offset == 0) ? self : single_record_class.where_user(user_id, { limit: 100, offset: offset })
+          unless r.empty?
+            r.map { |item| yielder << item }
+            offset += 100
+          else
+            raise StopIteration
+          end
+        end
+      end
+    end
+
+    def each(&block)
+      @results.each(&block)
+    end
+
+    def success?
+      raw_response.response.code.to_s == "200"
     end
-    alias :total_records :total_record_count
 
     def key
-      'user_request'
+      "user_request"
     end
 
+    def single_record_class
+      Alma::UserRequest
+    end
+
+    private
+      def user_id
+        @user_id ||= get_user_id_from_path(raw_response.request.uri.path)
+      end
+
+      def get_user_id_from_path(path)
+        # Path in user api calls starts with "/almaws/v1/users/123/maybe_something/else"
+        split_path = path.split("/")
+        # the part immediately following the "users" is going to be the user_id
+        user_id_index = split_path.index("users") + 1
+        split_path[user_id_index]
+      end
   end
 end

data/lib/alma/response.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Alma
+  class Response
+    class StandardError < Alma::StandardError
+    end
+
+    extend ::Forwardable
+
+    attr_reader :raw_response
+    def_delegators :raw_response, :body, :success?, :response, :request
+
+    def initialize(response)
+      @raw_response = response
+      # We could validate and throw an error here but currently a
+      validate(response)
+    end
+
+    def loggable
+      { uri: @raw_response&.request&.uri.to_s
+      }.select { |k, v| !(v.nil? || v.empty?) }
+    end
+
+    def validate(response)
+      if errors.first&.dig("errorCode") == "401136"
+        message = "The requested item already exists."
+        log = loggable.merge(response.parsed_response)
+
+        raise Alma::BibRequest::ItemAlreadyExists.new(message, log)
+      end
+
+      if response.code != 200
+        log = loggable.merge(response.parsed_response)
+        raise StandardError.new("Invalid Response.", log)
+      end
+    end
+
+    # Returns an array of errors
+    def errors
+      @raw_response.parsed_response&.dig("errorList", "error") || []
+    end
+  end
+end

data/lib/alma/result_set.rb

@@ -1,50 +1,42 @@
-module Alma
-  class ResultSet
-    extend Forwardable
+# frozen_string_literal: true
 
-		include Enumerable
-    include Alma::Error
+require "forwardable"
 
-    def_delegators :list, :each, :size
+class Alma::ResultSet
+  extend ::Forwardable
+  include Enumerable
+  include Alma::Error
 
-    def initialize(ws_response)
-      @response = ws_response
-    end
+  attr_reader :response
 
-    def total_record_count
-      @response[top_level_key].fetch('total_record_count', 0).to_i
-    end
+  def_delegators :response, :[], :fetch
+  def_delegators :each, :each_with_index, :size
 
-    def list
-      @list ||= list_results
-    end
+  def initialize(response_body_hash)
+    @response = response_body_hash
+  end
 
+  def loggable
+    { uri: @response&.request&.uri&.to_s }
+      .select { |k, v| !(v.nil? || v.empty?) }
+  end
 
-    def top_level_key
-      raise NotImplementedError 'Subclasses of ResultSet Need to define the top level key'
-    end
+  def each
+    @results ||= @response.fetch(key, [])
+      .map { |item| single_record_class.new(item) }
+  end
 
-    def response_records_key
-      raise NotImplementedError 'Subclasses of ResultSet Need to define the key for response records'
-    end
+  def total_record_count
+    fetch("total_record_count", 0).to_i
+  end
+  alias :total_records :total_record_count
 
-    private
-    def response_records
-      @response[top_level_key].fetch(response_records_key,[])
+  protected
+    def key
+      raise NotImplementedError "Subclasses of ResultSet need to define a response key"
     end
 
-    # Subclasses Can override this to use a Custom Class for single record objects.
     def single_record_class
       Alma::AlmaRecord
     end
-
-    def list_results
-      #If there is only one record in the response, HTTParty returns as a hash, not
-      # an array of hashes, so wrap in array to normalize.
-      response_array = (response_records.is_a? Array) ? response_records : [response_records]
-      response_array.map do |record|
-        single_record_class.new(record)
-      end
-    end
-  end
 end