alma 0.2.4 → 0.3.2

data/lib/alma/loan.rb

@@ -1,9 +1,38 @@
+# frozen_string_literal: true
+
 module Alma
   class Loan < AlmaRecord
+    extend Alma::ApiDefaults
+
+
+    def renewable?
+      !!renewable
+    end
+
+    def renewable
+      response.fetch("renewable", false)
+    end
+
+    def overdue?
+      loan_status == "Overdue"
+    end
 
     def renew
-      Alma::User.renew_loan({user_id: user_id, loan_id: loan_id})
+      Alma::User.renew_loan({ user_id: user_id, loan_id: loan_id })
     end
 
+    def self.where_user(user_id, args = {})
+      # Always expand renewable unless you really don't want to
+      args[:expand] ||= "renewable"
+      # Default to upper limit
+      args[:limit] ||= 100
+      response = HTTParty.get(
+        "#{users_base_path}/#{user_id}/loans",
+        query: args,
+        headers: headers,
+        timeout: timeout
+        )
+      Alma::LoanSet.new(response, args)
+    end
   end
-end
+end

data/lib/alma/loan_set.rb

@@ -1,18 +1,76 @@
+# frozen_string_literal: true
+
 module Alma
   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
+
+    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 top_level_key
-      'item_loans'
+    def success?
+      raw_response.response.code.to_s == "200"
     end
 
-    def response_records_key
-      'item_loan'
+    def key
+      "item_loan"
     end
 
     def single_record_class
       Alma::Loan
     end
 
+    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,42 +1,53 @@
+# frozen_string_literal: true
+
 module Alma
   class RenewalResponse
-
-    include Alma::Error
-
     def initialize(response)
-      @response = response
-      @success  = response.fetch('item_loan', {})
-      @renewed  = error.empty?
+      @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?
-      @renewed
+      @success
+    end
+
+    def has_error?
+      !renewed?
     end
 
     def due_date
-      @success.fetch('due_date', '')
+      @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 @success
-        @success['title']
+      if renewed?
+        @response["title"]
       else
-        'This Item'
+        "This Item"
       end
     end
 
     def message
-      if @success
+      if renewed?
         "#{item_title} is now due #{due_date}"
       else
         "#{item_title} could not be renewed."
       end
     end
 
+    def error_message
+      @response unless renewed?
+    end
   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

@@ -0,0 +1,66 @@
+# 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
+
+    REQUEST_OPTIONS_PERMITTED_ARGS = [:user_id]
+
+    def initialize(response)
+      @raw_response = response
+      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, timeout: timeout)
+      new(response)
+    end
+
+    def loggable
+      { uri: @raw_response&.request&.uri.to_s
+      }.select { |k, v| !(v.nil? || v.empty?) }
+    end
+
+    def validate(response)
+      if response.code != 200
+        raise ResponseError.new("Could not get request options.", loggable.merge(response.parsed_response))
+      end
+    end
+
+    def hold_allowed?
+      !request_options.nil? &&
+        !request_options.select { |option| option["type"]["value"] == "HOLD" }.empty?
+    end
+
+    def digitization_allowed?
+      !request_options.nil? &&
+        !request_options.select { |option| option["type"]["value"] == "DIGITIZATION" }.empty?
+    end
+
+    def booking_allowed?
+      !request_options.nil? &&
+        !request_options.select { |option| option["type"]["value"] == "BOOKING" }.empty?
+    end
+
+    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