amazon-associates 0.6.3

data/lib/amazon-associates/errors.rb

@@ -0,0 +1,23 @@
+module Amazon
+  module Associates
+    class RequestError < StandardError; end
+    class InvalidParameterValue < ArgumentError; end
+    class ParameterOutOfRange < InvalidParameterValue; end
+    class RequiredParameterMissing < ArgumentError; end
+    class ItemNotFound < StandardError; end
+
+    # Map AWS error types to ruby exceptions
+    ERROR = {
+      'AWS.InvalidParameterValue' => InvalidParameterValue,
+      'AWS.MissingParameters' => RequiredParameterMissing,
+      'AWS.MinimumParameterRequirement' => RequiredParameterMissing,
+      'AWS.ECommerceService.NoExactMatches' => ItemNotFound,
+      'AWS.ParameterOutOfRange' => ParameterOutOfRange,
+      'AWS.InvalidOperationParameter'=> InvalidParameterValue,
+      'AWS.InvalidResponseGroup' => InvalidParameterValue,
+      'AWS.RestrictedParameterValueCombination' => InvalidParameterValue
+    }
+
+    IGNORE_ERRORS = ['AWS.ECommerceService.NoSimilarities']
+  end
+end

data/lib/amazon-associates/extensions/core.rb

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'active_support'
+
+class Object # http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
+  def meta_def name, &blk
+    (class << self; self; end).instance_eval { define_method name, &blk }
+  end
+end
+
+class OpenHash < Hash
+  def method_missing_with_attributes_query(meth, *args)
+    fetch(meth) do
+      method_missing_without_attributes_query(meth)
+    end
+  end
+  alias_method_chain :method_missing, :attributes_query  
+end
+
+class Float
+  def whole?
+    (self % 1) < 0.0001
+  end
+end
+
+class Hash
+  def rekey!(keys)
+    keys.each_pair do |old, new|
+      store(new, delete(old)) if has_key?(old)    
+    end
+  end
+end

data/lib/amazon-associates/extensions/hpricot.rb

@@ -0,0 +1,115 @@
+require 'rubygems'
+require 'active_support'
+require 'roxml'
+
+# TODO: Untange this inter-dependency...
+%w{ browse_node measurement image ordinal price }.each do |type|
+  require File.join(File.dirname(__FILE__), '..', 'types', type)
+end
+
+module Hpricot
+  class Element < OpenHash
+    def initialize(value, attributes = {})
+      merge! :value => value,
+             :attributes => attributes
+    end
+  end
+
+  # Extend with some convenience methods
+  module Traverse
+    def self.induce(type, &block)
+      raise ArgumentError, "block missing" unless block_given?
+
+      type_at, to_type, types_at = "#{type}_at", "to_#{type}", "#{type.to_s.pluralize}_at"
+      if [type_at, to_type, types_at].any? {|m| method_defined?(m) }
+        raise ArgumentError, "some methods already defined"
+      end
+
+      define_method type_at do |path|
+        result = at(path) and yield result
+      end
+      define_method to_type do
+        method(type_at).call('')
+      end
+      define_method types_at do |path|
+        results = search(path) and results.collect {|r| yield r }
+      end
+    end
+
+    # Get the text value of the given path, leave empty to retrieve current element value.
+    induce :text do |result|
+      CGI::unescapeHTML(result.inner_html)
+    end
+
+    induce :int do |result|
+      Integer(result.inner_html)
+    end
+
+    induce :bool do |result|
+      case result.inner_html
+      when '0': false
+      when 'False': false
+      when '1': true
+      when 'True': true
+      else
+        raise TypeError, "String #{result.inspect} is not convertible to bool"
+      end
+    end
+
+    induce :element do |result|
+      # TODO: Use to_h here?
+      attrs = result.attributes.inject({}) do |hash, attr|
+        hash[attr[0].to_sym] = attr[1].to_s; hash
+      end
+
+      children = result.children
+      if children.size == 1 and children.first.is_a? Text
+        value = children.first.to_s
+      else
+        result = children.inject({}) do |hash, item|
+          name = item.name.to_sym
+          hash[name] ||= []
+          hash[name] << item.to_hash
+          hash
+        end
+
+        value = result.each_pair {|key, value| result[key] = value[0] if value.size == 1 }
+      end
+
+      (attrs.empty?) ? value : Element.new(value, attrs)
+    end
+
+    # TODO: This probably doesn't belong here...  References to Amazon:: types indicate as much anyway
+    # Get the children element text values in hash format with the element names as the hash keys.
+    induce :hash do |result|
+      # TODO: date?, image? &c
+      # TODO: This is super-ugly... is there a better way to map?
+      if ['width', 'height', 'length', 'weight'].include? result.name
+        Amazon::Measurement.from_xml(result.to_s)
+      elsif ['batteriesincluded', 'iseligibleforsupersavershipping', 'isautographed', 'ismemorabilia', 'isvalid'].include? result.name
+        result.to_bool
+      elsif result.name == 'browsenode'
+        Amazon::BrowseNode.from_xml(result.to_s)
+      elsif result.name == 'edition'
+        begin
+          Amazon::Ordinal.from_xml(result.to_s)
+        rescue TypeError
+          # a few edition types aren't ordinals, but strings (e.g., "First American Edition")
+          result.to_text
+        end
+      elsif result.name.starts_with? 'total' or result.name.starts_with? 'number' or ['quantity'].include? result.name
+        result.to_int
+      elsif result.name.ends_with? 'price' or result.name.ends_with? 'total'
+        Amazon::Price.from_xml(result.to_s)
+      elsif result.name.ends_with? 'image'
+        Amazon::Image.from_xml(result.to_s)
+      else
+        if (result.children.size > 1 or !result.children.first.is_a? Text) and names = result.children.collect {|c| c.name }.uniq and names.size == 1 and names[0].pluralize == result.name
+          result.children.map(&:to_hash)
+        else
+          result.to_element
+        end
+      end
+    end
+  end
+end

data/lib/amazon-associates/request.rb

@@ -0,0 +1,143 @@
+%w{errors extensions/core types/api_result
+   types/error types/customer_review types/editorial_review types/ordinal types/listmania_list types/browse_node types/measurement types/image types/image_set types/price types/offer types/item types/requests types/cart
+   responses/response responses/item_search_response responses/item_lookup_response responses/similarity_lookup_response responses/browse_node_lookup_response responses/cart_responses }.each do |file|
+  require File.join(File.dirname(__FILE__), file)
+end
+
+require 'net/http'
+require 'cgi'
+require 'hmac'
+require 'hmac-sha2'
+require 'base64'
+
+module Amazon
+  module Associates
+    def self.request(actions, &block)
+      actions.each_pair do |action, main_arg|
+        meta_def(action) do |*args|
+          opts = args.extract_options!
+          opts[main_arg] = args.first unless args.empty?
+          opts[:operation] = action.to_s.camelize
+
+          opts = yield opts if block_given?
+          send_request(opts)
+        end
+      end
+    end
+
+  private
+    # Generic send request to ECS REST service. You have to specify the :operation parameter.
+    def self.send_request(opts)
+      opts.to_options!
+      opts.reverse_merge! options.except(:caching_options, :caching_strategy)
+      if opts[:aWS_access_key_id].blank?
+        raise ArgumentError, "amazon-associates requires the :aws_access_key_id option"
+      end
+
+      request_url = prepare_url(opts)
+      response = nil
+
+      if cacheable?(opts['Operation'])
+        FilesystemCache.sweep
+
+        response = FilesystemCache.get(request_url)
+      end
+
+      if response.nil?
+        log "Request URL: #{request_url}"
+
+        response = Net::HTTP.get_response(URI::parse(request_url))
+        unless response.kind_of? Net::HTTPSuccess
+          raise RequestError, "HTTP Response: #{response.inspect}"
+        end
+        cache_response(request_url, response) if cacheable?(opts['Operation'])
+      end
+
+      doc = ROXML::XML::Parser.parse(response.body).root
+      eval(doc.name).from_xml(doc, request_url)
+    end
+
+    BASE_ARGS = [:aWS_access_key_id, :operation, :associate_tag, :response_group]
+    CART_ARGS = [:cart_id, :hMAC]
+    ITEM_ARGS = (0..99).inject([:items]) do |all, i|
+      all << :"Item.#{i}.ASIN"
+      all << :"Item.#{i}.OfferListingId"
+      all << :"Item.#{i}.CartItemId"
+      all << :"Item.#{i}.Quantity"
+      all
+    end
+    OTHER_ARGS = [
+      :item_page, :item_id, :country, :type, :item_type,
+      :browse_node_id, :actor, :artist, :audience_rating, :author,
+      :availability, :brand, :browse_node, :city, :composer,
+      :condition, :conductor, :director, :page, :keywords,
+      :manufacturer, :maximum_price, :merchant_id,
+      :minimum_price, :neighborhood, :orchestra,
+      :postal_code, :power, :publisher, :search_index, :sort,
+      :tag_page, :tags_per_page, :tag_sort, :text_stream,
+      :title, :variation_page
+    ]
+    VALID_ARGS = {
+      'CartCreate' => ITEM_ARGS,
+      'CartAdd' => ITEM_ARGS + CART_ARGS,
+      'CartModify' => ITEM_ARGS + CART_ARGS,
+      'CartGet' => CART_ARGS,
+      'CartClear' => CART_ARGS
+    }
+
+    def self.valid_arguments(operation)
+      BASE_ARGS + VALID_ARGS.fetch(operation, OTHER_ARGS)
+    end
+
+    TLDS = HashWithIndifferentAccess.new(
+        'us' => 'com',
+        'uk' => 'co.uk',
+        'ca' => 'ca',
+        'de' => 'de',
+        'jp' => 'co.jp',
+        'fr' => 'fr'
+    )
+    def self.tld(country)
+      TLDS.fetch(country || 'us') do
+        raise RequestError, "Invalid country '#{country}'"
+      end
+    end
+
+    def self.prepare_url(opts)
+      opts = opts.to_hash.to_options!
+      raise opts.inspect if opts.has_key?(:cart)
+      opts.assert_valid_keys(*valid_arguments(opts[:operation]))
+
+      params = opts.each_pair do |k, v|
+        opts.delete(k)
+        v *= ',' if v.is_a? Array
+        opts[k.to_s.camelize] = v.to_s
+        params
+      end
+
+      params.merge!(
+        'Service' => 'AWSECommerceService',
+        'Timestamp' => Time.now.gmtime.iso8601,
+        'SignatureVersion' => '2',
+        'SignatureMethod' => "HmacSHA256"
+      )
+
+      unsigned_uri = URI.parse("http://webservices.amazon.#{tld(opts.delete("Country"))}/onca/xml?#{params.sort { |a, b| a[0] <=> b[0] }.map { |key, val| "#{key}=#{CGI::escape(val).gsub('+', '%20')}" }.join("&")}")
+      hmac = HMAC::SHA256.new(ENV['AMAZON_SECRET_ACCESS_KEY'])
+      hmac.update("GET\n#{unsigned_uri.host}\n#{unsigned_uri.path}\n#{unsigned_uri.query}")
+      "#{unsigned_uri}&Signature=#{CGI::escape(Base64.encode64(hmac.digest).chomp)}"
+    end
+
+    def self.cacheable?(operation)
+      caching_enabled? && !operation.starts_with?('Cart')
+    end
+
+    def self.caching_enabled?
+      !options[:caching_strategy].blank?
+    end
+
+    def self.cache_response(request, response)
+      FilesystemCache.cache(request, response)
+    end
+  end
+end

data/lib/amazon-associates/requests/browse_node.rb

@@ -0,0 +1,10 @@
+require File.join(File.dirname(__FILE__), '../request')
+
+module Amazon
+  module Associates
+		request :browse_node_lookup => :browse_node_id do |opts|
+		  opts[:response_group] ||= 'TopSellers'
+		  opts
+		end
+  end
+end

data/lib/amazon-associates/requests/cart.rb

@@ -0,0 +1,81 @@
+require File.join(File.dirname(__FILE__), '../request')
+
+module Amazon
+  module Associates
+  private
+    def self.unpack_item(opts, index, item, count = 1)
+      case item
+      when CartItem
+        opts[:"Item.#{index}.CartItemId"] = item.cart_item_id
+      when String
+        opts["Item.#{index}.ASIN"] = item
+      when Item
+        opts["Item.#{index}.ASIN"] = item.asin
+      else
+        item = item.to_hash.dup
+        unless [:offer_listing_id, :asin, :list_item_id, :cart_item_id].any?{|id| item.has_key?(id)}
+          raise ArgumentError, "item needs an OfferListingId, ASIN, or ListItemId"
+        end
+
+        if id = item[:cart_item_id]
+          opts[:"Item.#{index}.CartItemId"] = id
+        elsif id = item[:offer_listing_id]
+          opts[:"Item.#{index}.OfferListingId"] = id
+        elsif id = item.delete(:asin)
+          opts["Item.#{index}.ASIN"] = id
+        elsif id = item.delete(:list_item_id)
+          opts["Item.#{index}.ListItemId"] = id
+        end
+      end
+      opts[:"Item.#{index}.Quantity"] = count
+    end
+
+    def self.unpack_items(opts)
+      raise ArgumentError, "items are required" if opts[:items].blank?
+
+      opts.delete(:items).each_with_index do |(item, count), index|
+        unpack_item(opts, index, item, count || item[:quantity] || 1)
+      end
+      opts
+    end
+
+    def self.unpack_cart(opts)
+      opts.merge!(opts.delete(:cart).to_hash) if opts[:cart]
+      opts[:cart_id] ||= opts.delete(:id)
+      opts[:hMAC] ||= opts.delete(:hmac)
+      opts
+    end
+
+  public
+    # Cart operations build the Item tags from the ASIN
+
+    # Creates remote shopping cart containing _asin_
+    request :cart_create => :items do |opts|
+      unpack_items(opts)
+    end
+
+    # Adds item to remote shopping cart
+    request :cart_add => :cart do |opts|
+      opts = unpack_items(opts)
+      unpack_cart(opts)
+    end
+
+    # Adds item to remote shopping cart
+    request :cart_get => :cart do |opts|
+      unpack_cart(opts)
+    end
+
+    # modifies _cart_item_id_ in remote shopping cart
+    # _quantity_ defaults to 0 to remove the given _cart_item_id_
+    # specify _quantity_ to update cart contents
+    request :cart_modify => :cart do |opts|
+      opts = unpack_items(opts)
+      unpack_cart(opts)
+    end
+
+    # clears contents of remote shopping cart
+    request :cart_clear => :cart do |opts|
+      unpack_cart(opts)
+    end
+  end
+end

data/lib/amazon-associates/requests/item.rb

@@ -0,0 +1,13 @@
+require File.join(File.dirname(__FILE__), '../request')
+
+module Amazon
+  module Associates
+    request :item_search => :keywords do |opts|
+      # TODO: Default to blended?  Don't show others except on refined search page?
+      opts[:search_index] ||= 'Books'
+      opts
+    end
+    request :similarity_lookup => :item_id,
+            :item_lookup => :item_id
+  end
+end

data/lib/amazon-associates/responses/browse_node_lookup_response.rb

@@ -0,0 +1,10 @@
+module Amazon
+  module Associates
+    class BrowseNodeLookupResponse < Response
+      xml_name 'BrowseNodeLookupResponse'
+      xml_reader :browse_nodes, :as => [BrowseNode]
+      xml_reader :request, :as => Request, :in => 'xmlns:BrowseNodes'
+      xml_reader :request_query, :as => BrowseNodeLookupRequest, :in => 'xmlns:BrowseNodes/xmlns:Request'
+    end
+  end
+end

data/lib/amazon-associates/responses/cart_responses.rb

@@ -0,0 +1,26 @@
+module Amazon
+  module Associates
+    class CartResponse < Response
+      xml_reader :cart, :as => Cart, :required => true
+      xml_reader :request, :as => Request, :in => 'xmlns:Cart'
+      xml_reader :query_request, :as => CartRequest, :in => 'xmlns:Cart/xmlns:Request'
+    end
+
+    class CartCreateResponse < CartResponse
+      xml_name 'CartCreateResponse'
+    end
+
+    class CartGetResponse < CartResponse
+    end
+
+    class CartAddResponse < CartResponse
+    end
+
+    class CartModifyResponse < CartResponse
+    end
+
+    class CartClearResponse < CartResponse
+      xml_name 'CartClearResponse'
+    end
+  end
+end