alma 0.2.8 → 0.3.1

data/lib/alma/loan_set.rb

@@ -1,34 +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 :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, 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 each
-      @response.fetch(key, []).map{|item| Alma::Loan.new(item)}
+    def loggable
+      { search_args: @search_args,
+        uri: @raw_response&.request&.uri.to_s
+      }.select { |k, v| !(v.nil? || v.empty?) }
     end
-    alias list each
 
-    def size
-      each.count
+    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 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 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/renewal_response.rb

@@ -1,13 +1,17 @@
 module Alma
   class RenewalResponse
 
-
-
     def initialize(response)
-      @response = response
+      @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

data/lib/alma/request.rb

@@ -0,0 +1,165 @@
+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,10 @@
 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,43 +13,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={})
       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)
+      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
 
-    def digitization_allowed?
-      !request_options.select {|option| option["type"]["value"] == "DIGITIZATION" }.empty?
+    def validate(response)
+      if response.code != 200
+        raise ResponseError.new("Could not get request options.", loggable.merge(response.parsed_response))
+      end
     end
 
-    private
-
-    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,33 +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 :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 each
-      @response.fetch(key, []).map{|item| Alma::AlmaRecord.new(item)}
+    def loggable
+      { uri: @raw_response&.request&.uri.to_s
+      }.select { |k, v| !(v.nil? || v.empty?) }
     end
-    alias list each
 
-    def size
-      each.count
+    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 total_record_count
-      fetch('total_record_count', 0)
+    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