alexandria-book-collection-manager 0.6.9.pre1

data/lib/alexandria/book_providers/amazon_ecs_util.rb

@@ -0,0 +1,405 @@
+#--
+# Copyright (c) 2006 Herryanto Siatono, Pluit Solutions
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+# Modified by Cathal Mc Ginley 2008-02-18
+# added Amazon::Ecs.transport - to enable Alexandria's proxy support
+# Modified by Cathal Mc Ginley 2008-08-26
+# Amazon::Element.get now uses inner_text, not inner_html, fixing #21659
+# Modified by Cathal Mc Ginley 2009-08-13
+# Added sign_request and hmac_sha256 methods for Authentication support
+
+require 'net/http'
+require 'hpricot'
+require 'cgi'
+
+require 'digest/sha2'
+
+module Amazon
+  class RequestError < StandardError; end
+
+  class Ecs
+    include Alexandria::Logging
+
+    SERVICE_URLS = { us: 'http://webservices.amazon.com/onca/xml?Service=AWSECommerceService',
+                     uk: 'http://webservices.amazon.co.uk/onca/xml?Service=AWSECommerceService',
+                     ca: 'http://webservices.amazon.ca/onca/xml?Service=AWSECommerceService',
+                     de: 'http://webservices.amazon.de/onca/xml?Service=AWSECommerceService',
+                     jp: 'http://webservices.amazon.co.jp/onca/xml?Service=AWSECommerceService',
+                     fr: 'http://webservices.amazon.fr/onca/xml?Service=AWSECommerceService'
+    }
+
+    @@options = {}
+    @@debug = false
+
+    @@secret_access_key = ''
+
+    # Default search options
+    def self.options
+      @@options
+    end
+
+    def self.secret_access_key=(key)
+      @@secret_access_key = key
+    end
+
+    # Set default search options
+    def self.options=(opts)
+      @@options = opts
+    end
+
+    # Get debug flag.
+    def self.debug
+      @@debug
+    end
+
+    # Set debug flag to true or false.
+    def self.debug=(dbg)
+      @@debug = dbg
+    end
+
+    def self.configure(&_proc)
+      raise ArgumentError, 'Block is required.' unless block_given?
+      yield @@options
+    end
+
+    # Search amazon items with search terms. Default search index option is 'Books'.
+    # For other search type other than keywords, please specify :type => [search type param name].
+    def self.item_search(terms, opts = {})
+      opts[:operation] = 'ItemSearch'
+      opts[:search_index] = opts[:search_index] || 'Books'
+
+      type = opts.delete(:type)
+      if type
+        opts[type.to_sym] = terms
+      else
+        opts[:keywords] = terms
+      end
+
+      send_request(opts)
+    end
+
+    # Search an item by ASIN no.
+    def self.item_lookup(item_id, opts = {})
+      opts[:operation] = 'ItemLookup'
+      opts[:item_id] = item_id
+
+      send_request(opts)
+    end
+
+    # HACK : copied from book_providers.rb
+    def self.transport
+      config = Alexandria::Preferences.instance.http_proxy_config
+      config ? Net::HTTP.Proxy(*config) : Net::HTTP
+    end
+
+    # Generic send request to ECS REST service. You have to specify the :operation parameter.
+    def self.send_request(opts)
+      opts = options.merge(opts) if options
+      request_url = prepare_url(opts)
+      log.debug { "Request URL: #{request_url}" }
+
+      res = transport.get_response(URI.parse(request_url))
+      unless res.is_a? Net::HTTPSuccess
+        raise Amazon::RequestError, "HTTP Response: #{res.code} #{res.message}"
+      end
+      Response.new(res.body)
+    end
+
+    # Response object returned after a REST call to Amazon service.
+    class Response
+      # XML input is in string format
+      def initialize(xml)
+        @doc = Hpricot(xml)
+      end
+
+      # Return Hpricot object.
+      attr_reader :doc
+
+      # Return true if request is valid.
+      def is_valid_request?
+        (@doc / 'isvalid').inner_html == 'True'
+      end
+
+      # Return true if response has an error.
+      def has_error?
+        !(error.nil? || error.empty?)
+      end
+
+      # Return error message.
+      def error
+        Element.get(@doc, 'error/message')
+      end
+
+      # Return an array of Amazon::Element item objects.
+      def items
+        unless @items
+          @items = (@doc / 'item').map { |item| Element.new(item) }
+        end
+        @items
+      end
+
+      # Return the first item (Amazon::Element)
+      def first_item
+        items.first
+      end
+
+      # Return current page no if :item_page option is when initiating the request.
+      def item_page
+        unless @item_page
+          @item_page = (@doc / 'itemsearchrequest/itempage').inner_html.to_i
+        end
+        @item_page
+      end
+
+      # Return total results.
+      def total_results
+        unless @total_results
+          @total_results = (@doc / 'totalresults').inner_html.to_i
+        end
+        @total_results
+      end
+
+      # Return total pages.
+      def total_pages
+        unless @total_pages
+          @total_pages = (@doc / 'totalpages').inner_html.to_i
+        end
+        @total_pages
+      end
+    end
+
+    # protected
+    #  def self.log(s)
+    #    return unless self.debug
+    #    if defined? RAILS_DEFAULT_LOGGER
+    #      RAILS_DEFAULT_LOGGER.error(s)
+    #    elsif defined? LOGGER
+    #      LOGGER.error(s)
+    #    else
+    #      puts s
+    #    end
+    #  end
+
+    def self.prepare_url(opts)
+      country = opts.delete(:country)
+      country = (country.nil?) ? 'us' : country
+      request_url = SERVICE_URLS[country.to_sym]
+      raise Amazon::RequestError, "Invalid country '#{country}'" unless request_url
+
+      qs = ''
+      opts.each {|k, v|
+        next unless v
+        v = v.join(',') if v.is_a? Array
+        qs << "&#{camelize(k.to_s)}=#{URI.encode(v.to_s)}"
+      }
+      url = "#{request_url}#{qs}"
+      # puts ">>> base url >> #{url}"
+      signed_url = sign_request(url)
+      # puts ">>> SIGNED >> #{signed_url}"
+      signed_url
+    end
+
+    def self.camelize(s)
+      s.to_s.gsub(/\/(.?)/) { '::' + Regexp.last_match[1].upcase }.gsub(/(^|_)(.)/) { Regexp.last_match[2].upcase }
+    end
+
+    def self.hmac_sha256(message, key)
+      block_size = 64
+      ipad = "\x36" * block_size
+      opad = "\x5c" * block_size
+      if key.size > block_size
+        d = Digest::SHA256.new
+        key = d.digest(key)
+      end
+
+      ipad_bytes = ipad.bytes.map { |b| b }
+      opad_bytes = opad.bytes.map { |b| b }
+      key_bytes = key.bytes.map { |b| b }
+      ipad_xor = ''
+      opad_xor = ''
+      for i in 0..key.size - 1
+        ipad_xor << (ipad_bytes[i] ^ key_bytes[i])
+        opad_xor << (opad_bytes[i] ^ key_bytes[i])
+      end
+
+      ipad = ipad_xor + ipad[key.size..-1]
+      opad = opad_xor + opad[key.size..-1]
+
+      # inner hash
+      d1 = Digest::SHA256.new
+      d1.update(ipad)
+      d1.update(message)
+      msg_hash = d1.digest
+
+      # outer hash
+      d2 = Digest::SHA256.new
+      d2.update(opad)
+      d2.update(msg_hash)
+      d2.digest
+    end
+
+    def self.sign_request(request)
+      raise AmazonNotConfiguredError unless @@secret_access_key
+      # Step 0 : Split apart request string
+      url_pattern = /http:\/\/([^\/]+)(\/[^\?]+)\?(.*$)/
+      url_pattern =~ request
+      host = Regexp.last_match[1]
+      path = Regexp.last_match[2]
+      param_string = Regexp.last_match[3]
+
+      # Step 1: enter the timestamp
+      t = Time.now.getutc # MUST be in UTC
+      stamp = t.strftime('%Y-%m-%dT%H:%M:%SZ')
+      param_string += "&Timestamp=#{stamp}"
+
+      # Step 2 : URL-encode
+      param_string = param_string.gsub(',', '%2C').gsub(':', '%3A')
+      #   NOTE : take care not to double-encode
+
+      # Step 3 : Split the parameter/value pairs
+      params = param_string.split('&')
+
+      # Step 4 : Sort params
+      params.sort!
+
+      # Step 5 : Rejoin the param string
+      canonical_param_string = params.join('&')
+
+      # Steps 6 & 7: Prepend HTTP request info
+      string_to_sign = "GET\n#{host}\n#{path}\n#{canonical_param_string}"
+
+      # puts string_to_sign
+
+      # Step 8 : Calculate RFC 2104-compliant HMAC with SHA256 hash algorithm
+      sig = hmac_sha256(string_to_sign, @@secret_access_key)
+      base64_sig = [sig].pack('m').strip
+
+      # Step 9 : URL-encode + and = in sig
+      base64_sig = CGI.escape(base64_sig)
+
+      # Step 10 : Add the URL encoded signature to your request
+      "http://#{host}#{path}?#{param_string}&Signature=#{base64_sig}"
+    end
+  end
+
+  # Internal wrapper class to provide convenient method to access Hpricot element value.
+  class Element
+    # Pass Hpricot::Elements object
+    def initialize(element)
+      @element = element
+    end
+
+    # Returns Hpricot::Elments object
+    def elem
+      @element
+    end
+
+    # Find Hpricot::Elements matching the given path. Example: element/"author".
+    def /(path)
+      elements = @element / path
+      return nil if elements.size == 0
+      elements
+    end
+
+    # Find Hpricot::Elements matching the given path, and convert to Amazon::Element.
+    # Returns an array Amazon::Elements if more than Hpricot::Elements size is greater than 1.
+    def search_and_convert(path)
+      elements = self./(path)
+      return unless elements
+      elements = elements.map { |element| Element.new(element) }
+      return elements.first if elements.size == 1
+      elements
+    end
+
+    # Get the text value of the given path, leave empty to retrieve current element value.
+    def get(path = '')
+      Element.get(@element, path)
+    end
+
+    # Get the unescaped HTML text of the given path.
+    def get_unescaped(path = '')
+      Element.get_unescaped(@element, path)
+    end
+
+    # Get the array values of the given path.
+    def get_array(path = '')
+      Element.get_array(@element, path)
+    end
+
+    # Get the children element text values in hash format with the element names as the hash keys.
+    def get_hash(path = '')
+      Element.get_hash(@element, path)
+    end
+
+    # Similar to #get, except an element object must be passed-in.
+    def self.get(element, path = '')
+      return unless element
+      result = element.at(path)
+      ## inner_html doesn't decode entities, hence bug #21659
+      # result = result.inner_html if result
+      result = result.inner_text if result
+      result
+    end
+
+    # Similar to #get_unescaped, except an element object must be passed-in.
+    def self.get_unescaped(element, path = '')
+      result = get(element, path)
+      CGI.unescapeHTML(result) if result
+    end
+
+    # Similar to #get_array, except an element object must be passed-in.
+    def self.get_array(element, path = '')
+      return unless element
+
+      result = element / path
+      if (result.is_a? Hpricot::Elements) || (result.is_a? Array)
+        parsed_result = []
+        result.each {|item|
+          parsed_result << Element.get(item)
+        }
+        parsed_result
+      else
+        [Element.get(result)]
+      end
+    end
+
+    # Similar to #get_hash, except an element object must be passed-in.
+    def self.get_hash(element, path = '')
+      return unless element
+
+      result = element.at(path)
+      if result
+        hash = {}
+        result = result.children
+        result.each do |item|
+          hash[item.name.to_sym] = item.inner_html
+        end
+        hash
+      end
+    end
+
+    def to_s
+      elem.to_s if elem
+    end
+  end
+end

data/lib/alexandria/book_providers/barnes_and_noble.rb

@@ -0,0 +1,229 @@
+# -*- ruby -*-
+#
+# Copyright (C) 2009 Cathal Mc Ginley
+# Modifications Copyright (C) 2011, 2014 Matijs van Zuijlen
+#
+# Alexandria is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License as
+# published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+#
+# Alexandria is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public
+# License along with Alexandria; see the file COPYING.  If not,
+# write to the Free Software Foundation, Inc., 51 Franklin Street,
+# Fifth Floor, Boston, MA 02110-1301 USA.
+
+# http://en.wikipedia.org/wiki/Barnes_&_Noble
+
+# New BarnesAndNoble provider, taken from the Palatina MetaDataSource
+# and modified to fit the structure of Alexandria book providers.
+# Completely rewritten by Cathal Mc Ginley (18 Dec 2009)
+
+# NOTE: this modified version is based on the Alexandria WorldCat provider.
+
+require 'cgi'
+require 'alexandria/net'
+require 'alexandria/book_providers/web'
+
+module Alexandria
+  class BookProviders
+    class BarnesAndNobleProvider < WebsiteBasedProvider
+      include Alexandria::Logging
+
+      SITE = 'http://www.barnesandnoble.com'
+
+      BASE_ISBN_SEARCH_URL = 'http://search.barnesandnoble.com/books' \
+        '/product.aspx?ISBSRC=Y&ISBN=%s'
+
+      BASE_SEARCH_URL = 'http://search.barnesandnoble.com/booksearch' \
+        '/results.asp?%s=%s' # type, term
+
+      def initialize
+        super('BarnesAndNoble', 'BarnesAndNoble')
+        @agent = nil
+        prefs.read
+      end
+
+      def agent
+        unless @agent
+          @agent = Alexandria::WWWAgent.new
+        end
+        @agent
+      end
+
+      def fetch_redirectly(uri_str, limit = 5)
+        raise NoResultsError, 'HTTP redirect too deep' if limit == 0
+        response = agent.get(uri_str)
+        if limit < 10
+          sleep 0.1
+          puts "Redirectly :: #{uri_str}"
+        else
+          puts "Fetching   :: #{uri_str}"
+        end
+        puts response.inspect
+        case response
+        when Net::HTTPSuccess     then response
+        when Net::HTTPRedirection then fetch_redirectly(response['Location'], (limit - 1))
+        else
+          response.error!
+        end
+      end
+
+      def search(criterion, type)
+        req = create_search_uri(type, criterion)
+        puts "Requesting #{req}" if $DEBUG
+        html_data = fetch_redirectly(req)
+
+        if type == SEARCH_BY_ISBN
+          parse_result_data(html_data.body, criterion)
+        else
+          results = parse_search_result_data(html_data.body)
+          raise NoResultsError if results.empty?
+
+          results.map { |result| get_book_from_search_result(result) }
+        end
+      end
+
+      def url(book)
+        create_search_uri(SEARCH_BY_ISBN, book.isbn)
+      rescue => ex
+        log.warn { "Cannot create url for book #{book}; #{ex.message}" }
+        nil
+      end
+
+      def create_search_uri(search_type, search_term)
+        search_type_code = {
+          SEARCH_BY_AUTHORS => 'ATH',
+          SEARCH_BY_TITLE => 'TTL',
+          SEARCH_BY_KEYWORD => 'WRD'    # SEARCH_BY_PUBLISHER => 'PBL' # not implemented
+        }[search_type] or ''
+        if search_type == SEARCH_BY_ISBN
+          BASE_ISBN_SEARCH_URL % Library.canonicalise_ean(search_term) # isbn-13
+        else
+          search_term_encoded = CGI.escape(search_term)
+          BASE_SEARCH_URL % [search_type_code, search_term_encoded]
+        end
+      end
+
+      def get_book_from_search_result(result)
+        log.debug { "Fetching book from #{result[:url]}" }
+        html_data =  transport.get_response(URI.parse(result[:url]))
+        parse_result_data(html_data.body)
+      end
+
+      def parse_search_result_data(html)
+        doc = html_to_doc(html)
+        book_search_results = []
+        begin
+          result_divs = doc / 'div[@class*="book-container"]'
+          result_divs.each do |div|
+            result = {}
+            # img = div % 'div.book-image/a/img'
+            # result[:image_url] = img['src'] if img
+            title_header = div % 'h2'
+            title_links = title_header / 'a'
+            result[:title] = title_links.first.inner_text
+            result[:url] = title_links.first['href']
+
+            book_search_results << result
+          end
+        rescue => ex
+          trace = ex.backtrace.join("\n> ")
+          log.warn {'Failed parsing search results for Barnes & Noble ' \
+            "#{ex.message} #{trace}" }
+        end
+        book_search_results
+      end
+
+      def parse_result_data(html, _search_isbn = nil, _recursing = false)
+        doc = html_to_doc(html)
+        begin
+          book_data = {}
+          title_header = doc % '//div.wgt-productTitle/h1'
+          if title_header
+            title = ''
+            title_header.children.each do |node|
+              if node.text?
+                title += ' ' + node.to_s
+              end
+            end
+            title.strip!
+            if title.empty?
+              log.warn { 'Unexpectedly found no title in BarnesAndNoble lookup' }
+              raise NoResultsError
+            end
+            book_data[:title] = title.strip.squeeze(' ')
+            subtitle_span = title_header % 'span.subtitle'
+            if subtitle_span
+              book_data[:title] += " #{subtitle_span.inner_text}"
+            end
+          end
+
+          isbn_links = doc / '//a.isbn-a'
+          isbns = isbn_links.map(&:inner_text)
+          book_data[:isbn] =  Library.canonicalise_ean(isbns.first)
+
+          authors = []
+          author_links = title_header / 'a[@href*="ATH"]'
+          author_links.each do |a|
+            authors << a.inner_text
+          end
+          book_data[:authors] = authors
+
+          publisher_item = doc % 'li.publisher'
+          if publisher_item
+            publisher_item.inner_text =~ /Publisher:\s*(.+)/
+            book_data[:publisher] = Regexp.last_match[1]
+          end
+
+          date_item = doc % 'li.pubDate'
+          if date_item
+            date_item.inner_text =~ /Date: ([^\s]*)\s*([\d]{4})/
+            year = Regexp.last_match[2].to_i if Regexp.last_match[2]
+            book_data[:publication_year] = year
+          end
+
+          book_data[:binding] = ''
+          format_list_items = doc / '//div.col-one/ul/li'
+          format_list_items.each do |li|
+            if li.inner_text =~ /Format:\s*(.*),/
+              book_data[:binding] = Regexp.last_match[1]
+            end
+          end
+
+          product_image_div = doc % 'div#product-image'
+          if product_image_div
+            images = product_image_div / 'img'
+            if images.size == 1
+              book_data[:image_url] = images.first['src']
+            else
+              if images.first['src'] =~ /see_inside.gif/
+                # the first image is the "See Inside!" label
+                book_data[:image_url] = images[1]['src']
+              else
+                book_data[:image_url] = images.first['src']
+              end
+            end
+          end
+
+          book = Book.new(book_data[:title], book_data[:authors],
+                          book_data[:isbn], book_data[:publisher],
+                          book_data[:publication_year],
+                          book_data[:binding])
+          return [book, book_data[:image_url]]
+        rescue => ex
+          raise ex if ex.instance_of? NoResultsError
+          trace = ex.backtrace.join("\n> ")
+          log.warn {'Failed parsing search results for BarnesAndNoble ' \
+            "#{ex.message} #{trace}" }
+          raise NoResultsError
+        end
+      end
+    end # class BarnesAndNobleProvider
+  end # class BookProviders
+end # module Alexandria