alma 0.2.4 → 0.3.2

data/lib/alma/request_set.rb

@@ -1,14 +1,78 @@
+# frozen_string_literal: true
+
 module Alma
   class RequestSet < 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)
+      @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 loggable
+      { 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 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
 
-    def top_level_key
-      'user_requests'
+    def key
+      "user_request"
     end
 
-    def response_records_key
-      'user_request'
+    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
+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

data/lib/alma/user.rb

@@ -1,34 +1,114 @@
+# frozen_string_literal: true
+
 module Alma
-  class  User < AlmaRecord
-    extend Alma::Api
+  class  User
+    class ResponseError < Alma::StandardError
+    end
+    extend Forwardable
+    extend Alma::ApiDefaults
 
-    attr_accessor :id
+    def self.find(user_id, args = {})
+      args[:expand] ||= "fees,requests,loans"
+      response = HTTParty.get("#{self.users_base_path}/#{user_id}", query: args, headers: headers, timeout: timeout)
 
-    def post_initialize
-      @id = response['primary_id'].to_s
-      @recheck_loans = true
+      Alma::User.new response
     end
 
-    def fines
-      self.class.get_fines({user_id: self.id})
+    # Authenticates a Alma user with their Alma Password
+    # @param [Hash] args
+    # @option args [String] :user_id The unique id of the user
+    # @option args [String] :password The users local alma password
+    # @return [Boolean] Whether or not the user Successfully authenticated
+    def self.authenticate(args)
+      user_id = args.delete(:user_id) { raise ArgumentError }
+      args.merge!({ op: "auth" })
+      response = HTTParty.post("#{users_base_path}/#{user_id}", query: args, headers: headers, timeout: timeout)
+      response.code == 204
+    end
+
+
+    # The User object can respond directly to Hash like access of attributes
+    def_delegators :response, :[], :[]=, :has_key?, :keys, :to_json
+
+    def initialize(response)
+      @raw_response = response
+      @response = response.parsed_response
+      validate(response)
     end
 
-    def loans
-      unless @loans && !recheck_loans?
-        @loans = self.class.get_loans({user_id: self.id})
-        @recheck_loans = false
+    def loggable
+      { 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)
+        error = "The user was not found."
+        raise ResponseError.new(error, log)
       end
-      @loans
+    end
+
+    def response
+      @response
+    end
+
+    def id
+      self["primary_id"]
+    end
+
+    def total_fines
+      response.dig("fees", "value") || "0"
+    end
+
+    def total_requests
+      response.dig("requests", "value") || "0"
+    end
+
+    def total_loans
+      response.dig("loans", "value") || "0"
+    end
+
+
+    # Access the top level JSON attributes as object methods
+    def method_missing(name)
+      return response[name.to_s] if has_key?(name.to_s)
+      super.method_missing name
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      has_key?(name.to_s) || super
+    end
+
+
+    # Persist the user in it's current state back to Alma
+    def save!
+      response = HTTParty.put("#{users_base_path}/#{id}", timeout: timeout, headers: headers, body: to_json)
+      get_body_from(response)
+    end
+
+
+    def fines
+      Alma::Fine.where_user(id)
+    end
+
+    def requests
+      Alma::UserRequest.where_user(id)
+    end
+
+
+    def loans(args = {})
+      @loans ||= Alma::Loan.where_user(id, args)
     end
 
     def renew_loan(loan_id)
-      response = self.class.renew_loan({user_id: self.id, loan_id: loan_id})
+      response = self.class.send_loan_renewal_request({ user_id: id, loan_id: loan_id })
       if response.renewed?
         @recheck_loans ||= true
       end
-      response
     end
 
+
     def renew_multiple_loans(loan_ids)
       loan_ids.map { |id| renew_loan(id) }
     end
@@ -37,68 +117,40 @@ module Alma
       renew_multiple_loans(loans.map(&:loan_id))
     end
 
-    def recheck_loans?
-      @recheck_loans
+    def preferred_email
+      self["contact_info"]["email"].select { |k, v| k["preferred"] }.first["email_address"]
     end
 
-    def requests
-      self.class.get_requests({user_id:self.id})
+    def email
+      self["contact_info"]["email"].map { |e| e["email_address"] }
     end
 
-    class << self
-      # Static methods that do the actual querying
+    def preferred_first_name
+      pref_first = self["pref_first_name"] unless self["pref_first_name"] == ""
+      pref_first || self["first_name"] || ""
+    end
 
-      def find(args = {})
-        #TODO Handle Search Queries
-        #TODO Handle Pagination
-        #TODO Handle looping through all results
+    def preferred_middle_name
+      pref_middle = self["pref_middle_name"] unless self["pref_middle_name"] == ""
+      pref_middle || self["middle_name"] || ""
+    end
 
-        return find_by_id(user_id: args[:user_id]) if args.fetch(:user_id, nil)
-        params = query_merge args
-        response = resources.almaws_v1_users.get(params)
-        Alma::UserSet.new(response)
-      end
+    def preferred_last_name
+      pref_last = self["pref_last_name"] unless self["pref_last_name"] == ""
+      pref_last || self["last_name"]
+    end
 
-      def find_by_id(user_id_hash)
-        params = query_merge user_id_hash
-        response = resources.almaws_v1_users.user_id.get(params)
-        User.new(response['user'])
-      end
+    def preferred_suffix
+      self["pref_name_suffix"] || ""
+    end
 
-      def get_fines(args)
-        #TODO Handle Additional Parameters
-        #TODO Handle Pagination
-        #TODO Handle looping through all results
-        params = query_merge args
-        response = resources.almaws_v1_users.user_id_fees.get(params)
-        Alma::FineSet.new(response)
-      end
+    def preferred_name
+      "#{preferred_first_name} #{preferred_middle_name} #{preferred_last_name} #{preferred_suffix}"
+    end
 
-      def get_loans(args)
-        #TODO Handle Additional Parameters
-        #TODO Handle Pagination
-        #TODO Handle looping through all results
-        params = query_merge args
-        response = resources.almaws_v1_users.user_id_loans.get(params)
-        Alma::LoanSet.new(response)
-      end
 
-      def get_requests(args)
-        #TODO Handle Additional Parameters
-        #TODO Handle Pagination
-        #TODO Handle looping through all results
-        params = query_merge args
-        response = resources.almaws_v1_users.user_id_requests.get(params)
-        Alma::RequestSet.new(response)
-      end
 
-      def authenticate(args)
-        # Authenticates a Alma user with their Alma Password
-        args.merge!({op: 'auth'})
-        params = query_merge args
-        response = resources.almaws_v1_users.user_id.post(params)
-        response.code == 204
-      end
+    private
 
       # Attempts to renew a single item for a user
       # @param [Hash] args
@@ -106,36 +158,40 @@ module Alma
       # @option args [String] :loan_id The unique id of the loan
       # @option args [String] :user_id_type Type of identifier being used to search. OPTIONAL
       # @return [RenewalResponse] Object indicating the renewal message
-      def renew_loan(args)
-        args.merge!({op: 'renew'})
-        params = query_merge args
-        response = resources.almaws_v1_users.user_id_loans_loan_id.post(params)
+      def self.send_loan_renewal_request(args)
+        loan_id = args.delete(:loan_id) { raise ArgumentError }
+        user_id = args.delete(:user_id) { raise ArgumentError }
+        params = { op: "renew" }
+        response = HTTParty.post("#{users_base_path}/#{user_id}/loans/#{loan_id}", query: params, headers: headers)
         RenewalResponse.new(response)
       end
 
-      # Attempts to renew a multiple items for a user
+      # Attempts to renew multiple items for a user
       # @param [Hash] args
       # @option args [String] :user_id The unique id of the user
-      # @option args [Array<String>] :loan_ids Array of loan ids
+      # @option args [Array<String>] :loan_ids The unique ids of the loans
       # @option args [String] :user_id_type Type of identifier being used to search. OPTIONAL
-      # @return [Array<RenewalResponse>] Object indicating the renewal message
-      def renew_multiple_loans(args)
-
-        if args.fetch(:loans_ids, nil).respond_to? :map
-          args.delete(:loan_ids).map do |loan_id|
-            renew_loan(args.merge(loan_id: loan_id))
-          end
-        else
-          []
-        end
+      # @return [Array<RenewalResponse>] Array of Objects indicating the renewal messages
+      def self.send_multiple_loan_renewal_requests(args)
+        loan_ids = args.delete(:loan_ids) { raise ArgumentError }
+        loan_ids.map { |id| Alma::User.send_loan_renewal_request(args.merge(loan_id: id)) }
+      end
+
+      def get_body_from(response)
+        JSON.parse(response.body)
       end
 
 
+      def self.users_base_path
+        "https://api-na.hosted.exlibrisgroup.com/almaws/v1/users"
+      end
 
+      def users_base_path
+        self.class.users_base_path
+      end
 
-      def set_wadl_filename
-        'user.wadl'
+      def headers
+        self.class.headers
       end
-    end
   end
-end
+end