alexandria-book-collection-manager 0.7.5 → 0.7.9

data/lib/alexandria/book_providers/amazon_aws.rb

@@ -1,252 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright (C) 2004-2006 Laurent Sansonetti
-# Copyright (C) 2008 Cathal Mc Ginley
-# Copyright (C) 2014, 2016 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/Amazon
-
-require "hpricot"
-require "alexandria/book_providers/amazon_ecs_util"
-
-module Alexandria
-  class BookProviders
-    class AmazonProvider < GenericProvider
-      include Logging
-      include GetText
-      GetText.bindtextdomain(Alexandria::TEXTDOMAIN, charset: "UTF-8")
-
-      # CACHE_DIR = File.join(Alexandria::Library::DIR, '.amazon_cache')
-
-      LOCALES = ["ca", "de", "fr", "jp", "uk", "us"].freeze
-
-      def initialize
-        super("Amazon", "Amazon")
-        # prefs.add("enabled", _("Enabled"), true, [true,false])
-        prefs.add("locale", _("Locale"), "us", AmazonProvider::LOCALES)
-        prefs.add("dev_token", _("Access key ID"), "")
-        prefs.add("secret_key", _("Secret access key"), "")
-        prefs.add("associate_tag", _("Associate Tag"), "")
-
-        prefs.read
-        token = prefs.variable_named("dev_token")
-        # kill old (shorter) tokens, or previously distributed Access Key Id (see #26250)
-
-        if token
-          token.new_value = token.value.strip if token.value != token.value.strip
-        end
-        if token && ((token.value.size != 20) || (token.value == "0J356Z09CN88KB743582"))
-          token.new_value = ""
-        end
-
-        secret = prefs.variable_named("secret_key")
-        if secret
-          secret.new_value = secret.value.strip if secret.value != secret.value.strip
-        end
-
-        associate = prefs.variable_named("associate_tag")
-        if associate
-          associate.new_value = "rubyalexa-20" if associate.value.strip.empty?
-          if associate.value != associate.value.strip
-            associate.new_value = associate.value.strip
-          end
-        end
-      end
-
-      def search(criterion, type)
-        prefs.read
-
-        if prefs["secret_key"].empty?
-          raise(Amazon::RequestError,
-                "Secret Access Key required for Authentication:" \
-                " you must sign up for your own Amazon AWS account")
-        end
-
-        if (config = Alexandria::Preferences.instance.http_proxy_config)
-          host, port, user, pass = config
-          url = "http://"
-          url += user + ":" + pass + "@" if user && pass
-          url += host + ":" + port.to_s
-          ENV["http_proxy"] = url
-        end
-
-        access_key_id = prefs["dev_token"]
-
-        Amazon::Ecs.options = { aWS_access_key_id: access_key_id,
-                                associateTag: prefs["associate_tag"] }
-        Amazon::Ecs.secret_access_key = prefs["secret_key"]
-        # #req.cache = Amazon::Search::Cache.new(CACHE_DIR)
-        locales = AmazonProvider::LOCALES.dup
-        locales.delete prefs["locale"]
-        locales.unshift prefs["locale"]
-        locales.reverse!
-
-        begin
-          request_locale = locales.pop.intern
-          products = []
-          case type
-          when SEARCH_BY_ISBN
-            criterion = Library.canonicalise_isbn(criterion)
-            # This isn't ideal : I'd like to do an ISBN/EAN-specific search
-            res = Amazon::Ecs.item_search(criterion,
-                                          response_group: "ItemAttributes,Images",
-                                          country: request_locale)
-            res.items.each do |item|
-              products << item
-            end
-            # #req.asin_search(criterion) do |product|
-
-            # Shouldn't happen.
-            # raise TooManyResultsError if products.length > 1
-
-            # I had assumed that publishers were bogusly publishing
-            # multiple editions of a book with the same ISBN, and
-            # Amazon was distinguishing between them.  So we'll log
-            # this case, and arbitrarily return the FIRST item
-
-            # Actually, this may be due to Amazon recommending a
-            # preferred later edition of a book, in spite of our
-            # searching on a single ISBN it can return more than one
-            # result with different ISBNs
-
-            if products.length > 1
-              log.warn do
-                "ISBN search at Amazon[#{request_locale}] got #{products.length} results;" \
-                " returning the first result only"
-              end
-            end
-
-          when SEARCH_BY_TITLE
-            res = Amazon::Ecs.item_search(criterion,
-                                          response_group: "ItemAttributes,Images",
-                                          country: request_locale)
-
-            res.items.each do |item|
-              products << item if /#{criterion}/i.match?(item.get("itemattributes/title"))
-            end
-            # #req.keyword_search(criterion) do |product|
-
-          when SEARCH_BY_AUTHORS
-            criterion = "author:#{criterion}"
-            res = Amazon::Ecs.item_search(criterion,
-                                          response_group: "ItemAttributes,Images",
-                                          country: request_locale, type: "Power")
-            res.items.each do |item|
-              products << item
-            end
-            # #req.author_search(criterion) do |product|
-
-          when SEARCH_BY_KEYWORD
-            res = Amazon::Ecs.item_search(criterion,
-                                          response_group: "ItemAttributes,Images",
-                                          country: request_locale)
-
-            res.items.each do |item|
-              products << item
-            end
-
-          else
-            raise InvalidSearchTypeError
-          end
-          raise Amazon::RequestError, "No products" if products.empty?
-          # raise NoResultsError if products.empty?
-        rescue Amazon::RequestError => ex
-          log.debug { "Got Amazon::RequestError at #{request_locale}: #{ex}" }
-          retry unless locales.empty?
-          raise NoResultsError
-        end
-
-        results = []
-        products.each do |item|
-          next unless item.get("itemattributes/productgroup") == "Book"
-
-          atts = item.search_and_convert("itemattributes")
-          title = normalize(atts.get("title"))
-
-          media = normalize(atts.get("binding"))
-          media = nil if media == "Unknown Binding"
-
-          isbn = normalize(atts.get("isbn"))
-          isbn = (Library.canonicalise_ean(isbn) if isbn && Library.valid_isbn?(isbn))
-          # hack, extract year by regexp (not Y10K compatible :-)
-          /([1-9][0-9]{3})/ =~ atts.get("publicationdate")
-          publishing_year = Regexp.last_match[1] ? Regexp.last_match[1].to_i : nil
-          book = Book.new(title,
-                          atts.get_array("author").map { |x| normalize(x) },
-                          isbn,
-                          normalize(atts.get("manufacturer")),
-                          publishing_year,
-                          media)
-
-          image_url = item.get("mediumimage/url")
-          log.info { "Found at Amazon[#{request_locale}]: #{book.title}" }
-          results << [book, image_url]
-        end
-        if type == SEARCH_BY_ISBN
-          if results.size == 1
-            results.first
-          else
-            log.info { "Found multiple results for lookup: checking each" }
-            query_isbn_canon = Library.canonicalise_ean(criterion)
-            results.each do |rslt|
-              book = rslt[0]
-              book_isbn_canon = Library.canonicalise_ean(book.isbn)
-              return rslt if query_isbn_canon == book_isbn_canon
-
-              log.debug { "rejected possible result #{book}" }
-            end
-            # gone through all and no ISBN match, so just return first result
-            log.info do
-              "no more results to check. Returning first result, just an approximation"
-            end
-            results.first
-          end
-        else
-          results
-        end
-      end
-
-      def url(book)
-        isbn = Library.canonicalise_isbn(book.isbn)
-        url = case prefs["locale"]
-              when "fr"
-                "http://www.amazon.fr/exec/obidos/ASIN/%s"
-              when "uk"
-                "http://www.amazon.co.uk/exec/obidos/ASIN/%s"
-              when "de"
-                "http://www.amazon.de/exec/obidos/ASIN/%s"
-              when "ca"
-                "http://www.amazon.ca/exec/obidos/ASIN/%s"
-              when "jp"
-                "http://www.amazon.jp/exec/obidos/ASIN/%s"
-              when "us"
-                "http://www.amazon.com/exec/obidos/ASIN/%s"
-              end
-        url % isbn
-      rescue StandardError => ex
-        log.warn { "Cannot create url for book #{book}; #{ex.message}" }
-        nil
-      end
-
-      def normalize(str)
-        str = str.squeeze(" ").strip unless str.nil?
-        str
-      end
-    end
-  end
-end

data/lib/alexandria/book_providers/amazon_ecs_util.rb

@@ -1,388 +0,0 @@
-# frozen_string_literal: true
-
-# This file is part of Alexandria.
-#
-# See the file README.md for authorship and licensing information.
-
-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"
-    }.freeze
-
-    @@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
-        @items ||= (@doc / "item").map { |item| Element.new(item) }
-        @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
-        @item_page ||= (@doc / "itemsearchrequest/itempage").inner_html.to_i
-        @item_page
-      end
-
-      # Return total results.
-      def total_results
-        @total_results ||= (@doc / "totalresults").inner_html.to_i
-        @total_results
-      end
-
-      # Return total pages.
-      def total_pages
-        @total_pages ||= (@doc / "totalpages").inner_html.to_i
-        @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 do |k, v|
-        next unless v
-
-        v = v.join(",") if v.is_a? Array
-        qs << "&#{camelize(k.to_s)}=#{URI.encode(v.to_s)}"
-      end
-      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(%r{/(.?)}) { "::" + 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 = ""
-      (0..key.size - 1).each do |i|
-        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 = %r{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.empty?
-
-      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 do |item|
-          parsed_result << Element.get(item)
-        end
-        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
-    end
-  end
-end