umlaut 3.0.0alpha1

data/db/seeds.rb

@@ -0,0 +1,7 @@
+# This file should contain all the record creation needed to seed the database with its default values.
+# The data can then be loaded with the rake db:seed (or created alongside the db with db:setup).
+#
+# Examples:
+#
+#   cities = City.create([{ :name => 'Chicago' }, { :name => 'Copenhagen' }])
+#   Mayor.create(:name => 'Daley', :city => cities.first)

data/lib/CronTab.rb

@@ -0,0 +1,192 @@
+# Extracted from dpklib, Ruby library released under same license as Ruby.
+
+
+class CronTab 
+    attr_accessor :min, :hour, :mday, :mon, :wday, :command
+  
+    WDAY = %w(sun mon tue wed thu fri sat)
+    FormatError = Class.new(StandardError)
+
+    def initialize(str)
+      super()
+
+      self.min, self.hour, self.mday, self.mon, self.wday =
+        CronTab.parse_timedate(str)
+
+      self.command = str.scan( /(?:\S+\s+){5}(.*)/ ).shift
+    end
+
+    def ===(rhs)
+      judge_date = proc {
+        b = true
+        b = b && (mday === rhs.mday)
+        b = b && (mon === rhs.mon)
+        b = b && (wday === rhs.wday)
+      }
+      judge_hour = proc {
+        b = true
+        b = b && (min === rhs.min)
+        b = b && (hour === rhs.hour)
+      }
+
+      case rhs
+      when Time
+        judge_hour.call && judge_date.call
+      when Dpklib::Hour
+        judge_hour.call
+      when Date
+        judge_date.call
+      else
+        super
+      end
+    end
+    alias include? ===;
+
+    class NextSeeker 
+      attr_accessor :scalar, :field, :lower_seeker
+      
+      def initialize(s, f, l)
+        self.scalar = s
+        self.field = f
+        self.lower_seeker = l
+      end
+      
+      def succ
+        if lower_seeker.nil? || lower_seeker.succ then
+          self.scalar = field.nextof(scalar)
+          scalar
+        else
+          lower_seeker.recursive_zero
+          self.scalar += 1
+          succ
+        end
+      end
+
+      def recursive_zero
+        self.scalar = 0
+        lower_seeker && lower_seeker.recursive_zero
+      end
+    end #/NextSeeker
+
+    class YearField
+      def nextof(nowyear)
+        nowyear
+      end
+    end #/YearField
+
+    def nexttime(nowtime = Time.now)
+      nowmin = nowtime.min + 1
+
+      seeker_min = NextSeeker.new(nowmin, min, nil)
+      seeker_hour = NextSeeker.new(nowtime.hour, hour, seeker_min)
+      seeker_mday = NextSeeker.new(nowtime.mday, mday, seeker_hour)
+      seeker_mon = NextSeeker.new(nowtime.mon, mon, seeker_mday)
+      seeker_year = NextSeeker.new(nowtime.year, YearField.new, seeker_mon)
+      seeker_year.succ
+
+      Time.local(seeker_year.scalar,
+                 seeker_mon.scalar,
+                 seeker_mday.scalar,
+                 seeker_hour.scalar,
+                 seeker_min.scalar, 0)
+    end
+
+    def waitsec(nowtime = Time.now)
+      nexttime(nowtime).to_i - nowtime.to_i
+    end
+
+    def self.parse_timedate(str)
+      minute, hour, day_of_month, month, day_of_week =
+        str.scan(/^(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)/).shift
+
+      day_of_week = day_of_week.downcase.gsub(/#{WDAY.join("|")}/){
+        WDAY.index($&)
+      }
+
+      [
+        parse_field(minute,       0, 59),
+        parse_field(hour,         0, 23),
+        parse_field(day_of_month, 1, 31),
+        parse_field(month,        1, 12),
+        parse_field(day_of_week,  0, 6),
+      ]
+    end
+
+    class Field 
+      attr_accessor :range, :every
+      
+      def initialize(r, e)
+        self.range = r
+        self.every = e
+      end
+      
+      def ===(rhs)
+        b = true
+        b = b && ( (rhs - range.first) % every == 0 )
+        b = b && ( range === rhs )
+      end
+
+      def nextof(now)
+        if now < range.first then
+          nextof(range.first)
+        elsif range.last < now || (range.exclude_end? && range.last <= now) then
+          nil
+        else
+          now + ( (now - range.first) % every )
+        end
+      end
+    end
+
+    class FieldSet 
+      attr_accessor :fields
+      
+      def initialize(f)
+        self.fields = f
+      end
+      
+      def ===(rhs)
+        b = false
+        fields.each { |field|
+          b ||= (field === rhs)
+        }
+        b
+      end
+
+      def nextof(now)
+        ret = nil
+        fields.each { |field|
+          field_nextof = field.nextof(now)
+          ret = field_nextof if ret.nil? || (field_nextof && field_nextof < ret)
+        }
+        ret
+      end
+    end
+
+    def self.parse_field(str, first, last)
+      list = str.split(",")
+      list.map!{|r|
+        r, every = r.split("/")
+        every = every ? every.to_i : 1
+        f,l = r.split("-")
+        range = if f == "*"
+                  first..last
+                elsif l.nil?
+                  f.to_i .. f.to_i
+                elsif f.to_i < first
+                  raise FormatError.new("out of range (#{f} for #{first})")
+                elsif last < l.to_i
+                  raise FormatError.new("out of range (#{l} for #{last})")
+                else
+                  f.to_i .. l.to_i
+                end
+        Field.new(range, every)
+      }
+      FieldSet.new(list)
+    end
+
+    #alias parse new
+    #alias [] new
+    
+  end #/CronTab
+
+

data/lib/aws_product_sign.rb

@@ -0,0 +1,146 @@
+  require 'rubygems'
+  require 'cgi'
+  require 'time'
+  require 'openssl'
+  require 'base64'  
+  
+# Code to sign a request to Amazon Product Advertising API (formerly known as
+# the AWS ECommerce Service), as per the specs at:
+# http://docs.amazonwebservices.com/AWSECommerceService/latest/DG/index.html?RequestAuthenticationArticle.html
+#
+# This code based heavily on that at: http://chrisroos.co.uk/blog/2009-01-31-implementing-version-2-of-the-amazon-aws-http-request-signature-in-ruby
+# Thanks Chris!
+#
+#  Example:
+#
+#  aws_signer = AwsProductSign(:access_key => "00000000000000000000", :secret_key => "1234567890")
+#  params =  {
+#      "Service" => "AWSECommerceService",      
+#      "Operation"=>"ItemLookup",
+#      "ItemId"=>"0679722769",
+#      "ResponseGroup"=>"ItemAttributes,Offers,Images,Reviews"
+#    }
+#  query_string = aws_signer.query_with_signature(  params   )
+#
+#  params will have a Timestamp AWSAccessKeyId added to it, unless input
+#  already had it.
+#
+#  Or you can get back a params hash instead of an encoded query string.
+#  Beware that the Signature parameter must be URL-encoded precisely, and
+#  not over-encoded: "the final signature you send in the request must be URL
+#  encoded as specified in RFC 3986
+
+#  Then you can go on to use those new params in rails url_for or the URI
+#  builder of your choice. Values are not URI-escaped yet. Or mutate the
+#  params passsed in with #add_signature! instead. 
+#
+#  Returning a new params hash, leaving your input untouched:
+#
+#  query_string_component = aws_signer.add_signature( params )
+#
+#  Or mutate your input:
+#  aws_signer.add_signature!(params)
+#
+#
+# At the moment this class can't handle a query string where you need the same
+# key twice. I don't think the AWS service ever uses that though?
+#
+# This class also assumes a GET request. 
+class AwsProductSign  
+  
+  def initialize(options = {})
+    @secret_key = options[:secret_key]
+    raise Exception.new("You must supply a :secret_key") unless @secret_key
+    @access_key = options[:access_key]
+  end
+
+  def query_with_signature(hash)
+    return hash_to_query( add_signature(hash)  )
+  end
+  
+  # Pass in a hash representing params for a query string.  
+  # param keys should be strings, not symbols please.
+  # Will return a param with the "Signature" key/value added, without
+  # modifying original. 
+  def add_signature(params)
+    # Make a copy to not modify original  
+    add_signature!( Hash[params]  )
+  end
+  
+  # Like #add_signature, but will mutate the hash passed in, 
+  # adding a "Signature" key/value to hash passed in, and return
+  # hash too.  
+  def add_signature!(params)
+    
+    # supply timestamp and access key if not already provided
+    params["Timestamp"] ||= Time.now.iso8601
+    params["AWSAccessKeyId"] ||= access_key
+    # Existing "Signature"? That's gotta go before we generate a new
+    # signature and add it. 
+    params.delete("Signature")
+
+    query_string = canonical_querystring(params)
+
+    string_to_sign = string_to_sign(query_string)
+    
+    # chomp is important!  the base64 encoded version will have a newline at the end
+    # which amazon does not want. 
+    digest  = OpenSSL::Digest::Digest.new('sha256')
+    signature = Base64.encode64(OpenSSL::HMAC.digest(digest, secret_key, string_to_sign)).chomp
+    
+    params["Signature"] = signature
+
+    #order doesn't matter for the actual request, we return the hash
+    #and let client turn it into a url.
+    return params
+  end
+
+  # Insist on specific method of URL encoding, RFC3986. 
+  def url_encode(string)
+    # It's kinda like CGI.escape, except CGI.escape is encoding a tilde when
+    # it ought not to be, so we turn it back. Also space NEEDS to be %20 not +.
+    return CGI.escape(string).gsub("%7E", "~").gsub("+", "%20")
+  end
+
+  # param keys should be strings, not symbols please. return a string joined
+  # by & in canonical order. 
+  def canonical_querystring(params)
+    # I hope this built-in sort sorts by byte order, that's what's required. 
+    values = params.keys.sort.collect {|key|  [url_encode(key), url_encode(params[key].to_s)].join("=") }
+    
+    return values.join("&")
+  end
+
+  def string_to_sign(query_string, options = {})
+    options[:verb] = "GET"
+    options[:request_uri] = "/onca/xml"
+    options[:host] = "webservices.amazon.com"
+
+    
+    return options[:verb] + "\n" + 
+        options[:host].downcase + "\n" +
+        options[:request_uri] + "\n" +
+        query_string
+  end
+
+  # Turns a hash into a query string, returns the query string.
+  # url-encodes everything to Amazon's specifications. 
+  def hash_to_query(hash)
+    hash.collect do |key, value|
+      
+      url_encode(key) + "=" + url_encode(value)
+    
+    end.join("&")
+  end
+
+  def secret_key
+    return @secret_key
+  end
+  def access_key
+    return @access_key
+  end
+  def access_key=(a)
+    @access_key = a
+  end
+  
+end

data/lib/exlibris/aleph/patron.rb

@@ -0,0 +1,64 @@
+module Exlibris::Aleph
+  class Patron < RestAPI
+    attr_accessor :patron_id
+
+    def initialize(patron_id, uri)
+      @patron_id = patron_id
+      raise "Initialization error in #{self.class}. Missing patron id." if @patron_id.nil?
+      super(uri)
+      @uri = @uri+ "/patron/#{patron_id}"
+    end
+
+    # Place a hold on the specificed item.
+    # Raises errors if 
+    def place_hold(adm_library, bib_library, bib_id, item_id, params)
+      pickup_location = params[:pickup_location]
+      raise "Error in place hold.  Missing pickup location." if pickup_location.nil?
+      last_interest_date = params.fetch(:last_interest_date, "")
+      start_interest_date = params.fetch(:start_interest_date, "")
+      sub_author = params.fetch(:sub_author, "")
+      sub_title = params.fetch(:sub_title, "")
+      pages = params.fetch(:pages, "")
+      note_1 = params.fetch(:note_1, "")
+      note_2 = params.fetch(:note_2, "")
+      rush = params.fetch(:rush, "N")
+      body_str = "<hold-request-parameters>"
+      body_str << "<pickup-location>#{pickup_location}</pickup-location>"
+      body_str << "<last-interest-date>#{last_interest_date}</last-interest-date>"
+      body_str << "<start-interest-date>#{start_interest_date}</start-interest-date>"
+      body_str << "<sub-author>#{sub_author}</sub-author>"
+      body_str << "<sub-title>#{sub_title}</sub-title>"
+      body_str << "<pages>#{pages}</pages>"
+      body_str << "<note-1>#{note_1}</note-1>"
+      body_str << "<note-2>#{note_2}</note-2>"
+      body_str << "<rush>#{rush}</rush>"
+      body_str << "</hold-request-parameters>"
+      options = { :body => "post_xml=#{body_str}"}
+      @response = self.class.put(@uri+ "/record/#{bib_library}#{bib_id}/items/#{item_id}/hold", options)
+      raise "Error placing hold through Aleph REST APIs. #{error}" unless error.nil?
+      return @response
+    end
+
+    def loans()
+      @response = self.class.get(@uri+ "/circulationActions/loans?view=full")
+      raise "Error getting loans through Aleph REST APIs. #{error}" unless error.nil?
+      return @response
+    end
+
+    def renew_loans(item_id="")
+      # Will renew all if specific item not specified
+      @response = self.class.post(@uri+ "/circulationActions/loans/#{item_id}")
+      raise "Error renewing loan(s) through Aleph REST APIs. #{error}" unless error.nil?
+      return @response
+    end
+
+    def note
+      return (not @response.first.last.kind_of?(Hash) or @response.first.last["create_hold"].nil?) ? "" : ": #{@response.first.last["create_hold"]["note"]}" if @response.instance_of?(Hash)
+    end
+
+    def error
+      return nil if reply_code == "0000"
+      return "#{reply_text}#{note}"
+    end
+  end
+end

data/lib/exlibris/aleph/record.rb

@@ -0,0 +1,54 @@
+module Exlibris::Aleph
+  class Record < RestAPI
+    def initialize(bib_library, record_id, uri)
+      @record_id = record_id
+      raise "Initialization error in #{self.class}. Missing record id." if @record_id.nil?
+      @bib_library = bib_library
+      raise "Initialization error in #{self.class}. Missing bib library." if @bib_library.nil?
+      super(uri)
+      @uri = @uri+ "/record/#{bib_library}#{record_id}"
+      # Format :xml parses response as a hash.
+      # Eventually I'd like this to be the default since it raises exceptions for invalid XML.
+      # self.class.format :xml
+      # Format :html does no parsing, just passes back raw XML for parsing by client
+      self.class.format :html
+    end
+
+    # Returns an XML string representation of a bib.  
+    # Every method call refreshes the data from the underlying API.
+    # Raises and exception if there are errors.
+    def bib
+      @response = self.class.get(@uri+ "?view=full")
+      raise "Error getting bib from Aleph REST APIs. #{error}" unless error.nil?
+      return @response
+    end
+
+    # Returns an array of items. Each item is represented as an HTTParty hash. 
+    # Every method call refreshes the data from the underlying API.
+    # Raises an exception if the response is not valid XML or there are errors.
+    def items
+      @items = []
+      self.class.format :xml
+      # Since we're parsing xml, this will raise an error
+      # if the response isn't xml.
+      @response = self.class.get(@uri+ "/items?view=full")
+      self.class.format :html
+      raise "Error getting items from Aleph REST APIs. #{error}" if not error.nil? or 
+        @response.nil? or @response["get_item_list"].nil? or @response["get_item_list"]["items"].nil?
+      item_list = @response["get_item_list"]["items"]["item"]
+      @items.push(item_list) if item_list.instance_of?(Hash)
+      item_list.each {|item|@items.push(item)} if item_list.instance_of?(Array)
+      Rails.logger.warn("No items returned from Aleph in #{self.class}.") if @items.empty?
+      return @items
+    end
+
+    # Returns an XML string representation of holdings 
+    # Every method call refreshes the data from the underlying API.
+    # Raises and exception if there are errors.
+    def holdings
+      @response = self.class.get(@uri+ "/holdings?view=full")
+      raise "Error getting holdings from Aleph REST APIs. #{error}" unless error.nil?
+      return @response
+    end
+  end
+end