mws-connect 0.0.1

data/lib/mws/serializer.rb

@@ -0,0 +1,81 @@
+require 'nokogiri'
+
+module Mws
+
+  class Serializer
+
+    def self.tree(name, parent, &block)
+      if parent
+        parent.send(name, &block)
+        parent.doc.root.to_xml
+      else
+        Nokogiri::XML::Builder.new do | xml |
+          xml.send(name, &block)
+        end.doc.root.to_xml
+      end
+    end
+
+    def self.leaf(name, parent, value, attributes)
+      if parent
+        parent.send(name, value, attributes)
+        parent.doc.root.to_xml
+      else
+        Nokogiri::XML::Builder.new do | xml |
+          xml.send(name, value, attributes)
+        end.doc.root.to_xml
+      end
+    end
+
+    def initialize(exceptions={})
+      @xml_exceptions = exceptions
+      @hash_exceptions = {}
+      exceptions.each do | key, value |
+        @hash_exceptions[value.to_sym] = key
+      end
+    end
+
+    def xml_for(name, data, builder, context=nil)
+      element = @xml_exceptions[name.to_sym] || Utils.camelize(name)
+      path = path_for name, context
+      if data.respond_to? :keys
+        builder.send(element) do | b |
+          data.each do | key, value |
+            xml_for(key, value, builder, path)
+          end
+        end
+      elsif data.respond_to? :each
+        data.each { |value| xml_for(name, value, builder, path) }
+      elsif data.respond_to? :to_xml
+        data.to_xml element, builder
+      else
+        builder.send element, data
+      end
+    end
+
+    def hash_for(node, context)
+      elements = node.elements()
+      return node.text unless elements.size > 0
+      res = {}
+      elements.each do | element |
+        name = @hash_exceptions[element.name.to_sym] || Utils.underscore(element.name).to_sym
+        path = path_for name, context 
+        content = instance_exec element, path, &method(:hash_for)
+        if res.include? name
+          res[name] = [ res[name] ] unless res[name].instance_of? Array
+          res[name] << content
+        else
+          res[name] = content
+        end
+      end
+      res
+    end
+
+    private
+
+    def path_for(name, context=nil)
+      [ context, name ].compact.join '.'
+    end
+
+  end
+
+end

data/lib/mws/signer.rb

@@ -0,0 +1,20 @@
+class Mws::Signer
+
+  def initialize(options={})
+    @verb = (options[:method] || options[:verb] || 'POST').to_s.upcase
+    @host = (options[:host] || 'mws.amazonservices.com').to_s.downcase
+    @path = options[:path] || '/'
+    @secret = options[:secret]
+  end
+
+  def signature(query, secret=@secret)
+    digest = OpenSSL::Digest::Digest.new 'sha256'
+    message = [ @verb, @host, @path, query ].join "\n"
+    Base64::encode64(OpenSSL::HMAC.digest(digest, secret, message)).chomp
+  end
+
+  def sign(query, secret=@secret)
+    "#{query}&Signature=#{Mws::Utils.uri_escape signature(query, secret)}"
+  end
+
+end

data/lib/mws/utils.rb

@@ -0,0 +1,50 @@
+# This module contains a collection of generally useful methods that (currently) have no better place to live. They can 
+# either be referenced directly as module methods or be mixed in. 
+module Mws::Utils
+  extend self
+
+  # This method will derive a camelized name from the provided underscored name.
+  # 
+  # @param [#to_s] name The underscored name to be camelized.
+  # @param [Boolean] uc_first True if and only if the first letter of the resulting camelized name should be 
+  #  capitalized.
+  #
+  # @return [String] The camelized name corresponding to the provided underscored name.
+  def camelize(name, uc_first=true)
+    return nil if name.nil?
+    name = name.to_s.strip
+    return name if name.empty?
+    parts = name.split '_'
+    assemble = lambda { |head, tail| head + tail.capitalize }
+    parts[0] = uc_first ? parts[0].capitalize : parts[0].downcase
+    parts.inject(&assemble)
+  end
+
+  def underscore(name)
+    return nil if name.nil?
+    name = name.to_s.strip
+    return name if name.empty?
+    name.gsub(/::/, '/')
+      .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+      .gsub(/([a-z\d])([A-Z])/,'\1_\2')
+      .tr("-", "_")
+      .downcase
+  end
+
+  def uri_escape(value)
+    value.gsub /([^a-zA-Z0-9_.~-]+)/ do
+      '%' + $1.unpack('H2' * $1.bytesize).join('%').upcase
+    end
+  end
+
+  def alias(to, from, *constants)
+    constants.each do | name |
+      constant = from.const_get(name)
+      to.singleton_class.send(:define_method, name) do | *args, &block |
+        constant.new *args, &block
+      end
+      to.const_set(name, constant)
+    end
+  end
+
+end

data/mws.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mws'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'mws-connect'
+  gem.version       = Mws::VERSION
+  gem.authors       = ['Sean M. Duncan', 'John E. Bailey']
+  gem.email         = ['info@devmode.com']
+  gem.description   = %q{The missing ruby client library for Amazon MWS}
+  gem.summary       = %q{The missing ruby client library for Amazon MWS}
+  gem.homepage      = 'http://github.com/devmode/mws'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|specs?|feat(ures?)?)/})
+  gem.require_paths = ['lib']
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'simplecov'
+  gem.add_development_dependency 'cucumber'
+  gem.add_development_dependency 'activesupport'
+  gem.add_dependency 'logging', '~> 1.8.0'
+  gem.add_dependency 'nokogiri', '~> 1.5.5'
+end

data/scripts/catalog-workflow

@@ -0,0 +1,136 @@
+#!/usr/bin/env ruby
+
+if ARGV.size < 3
+  puts "Usage: 'catalog-workflow merchant access secret'"
+  exit 1
+end
+
+require 'mws'
+require 'logging'
+require 'active_support/core_ext'
+
+Logging.logger.root.appenders = Logging.appenders.stdout
+Logging.logger.root.level = :debug
+
+mws = Mws.connect(
+  merchant: ARGV[0], 
+  access: ARGV[1], 
+  secret: ARGV[2]
+)
+
+class Workflow
+
+  def initialize(queue)
+    @queue = queue
+    @handlers = []
+  end
+  
+  def register(*deps, &handler)
+    @handlers << [ handler, deps ]
+  end
+
+  def complete(feed)
+    @handlers.each do | handler |
+      handler.last.delete feed
+    end
+    proceed
+  end
+
+  def proceed
+    @handlers.each_with_index do | handler, index |
+      if handler.last.empty?
+        @handlers[index] = nil
+        [ handler.first.call ].compact.flatten.each do | feed |
+          @queue << feed
+        end
+      end
+    end
+    @handlers.compact!
+  end
+
+end
+
+in_process_q = []
+terminated_q = []
+
+workflow = Workflow.new(in_process_q)
+
+workflow.register do
+  product_feed = mws.feeds.products.add(
+    Mws::Product('2634897') do
+      tax_code 'A_GEN_TAX'
+      name "Rocketfish\u2122 6' In-Wall HDMI Cable"
+      brand "Rocketfish\u2122"
+      description "This 6' HDMI cable supports signals up to 1080p and most screen refresh rates to ensure stunning image clarity with reduced motion blur in fast-action scenes."
+      bullet_point 'Compatible with HDMI components'
+      bullet_point'Connects an HDMI source to an HDTV or projector with an HDMI input'
+      bullet_point 'Up to 15 Gbps bandwidth'
+      bullet_point'In-wall rated' 
+      msrp 49.99, :usd
+      category :ce
+      details {
+        cable_or_adapter {
+          cable_length as_distance 6, :feet
+        }
+      }
+    end
+  )
+  workflow.register product_feed.id do
+    price_feed = mws.feeds.prices.add(
+      Mws::PriceListing('2634897', 49.99).on_sale(29.99, Time.now, 3.months.from_now)
+    )
+    image_feed = mws.feeds.images.add(
+      Mws::ImageListing('2634897', 'http://images.bestbuy.com/BestBuy_US/images/products/2634/2634897_sa.jpg', 'Main'),
+      Mws::ImageListing('2634897', 'http://images.bestbuy.com/BestBuy_US/images/products/2634/2634897cv1a.jpg', 'PT1')
+    )
+    shipping_feed = mws.feeds.shipping.add(
+      Mws::Shipping('2634897') {
+        restricted :alaska_hawaii, :standard, :po_box
+        adjust 4.99, :usd, :continental_us, :standard
+        replace 11.99, :usd, :continental_us, :expedited, :street
+      } 
+    )
+    workflow.register price_feed.id, image_feed.id, shipping_feed.id do
+      inventory_feed = mws.feeds.inventory.add(
+        Mws::Inventory('2634897', quantity: 10, fulfillment_type: :mfn)
+      )
+      workflow.register inventory_feed.id do
+        puts 'The workflow is complete!'
+      end
+      inventory_feed.id
+    end
+    [ price_feed.id, image_feed.id, shipping_feed.id ]
+  end
+  product_feed.id
+end
+
+workflow.proceed
+
+50.times do
+  puts "In Process: #{in_process_q}"
+  mws.feeds.list(ids: in_process_q).each do | info |
+    puts "SubmissionId: #{info.id} Status: #{info.status}"
+    terminated_q << in_process_q.delete(info.id) if [:cancelled, :done].include? info.status
+  end unless in_process_q.empty?
+
+  puts "Terminated: #{terminated_q}"
+  unless terminated_q.empty?
+    id = terminated_q.shift
+    result = mws.feeds.get id
+    puts result.inspect
+    if result.messages_processed == result.count_for(:success)
+      workflow.complete result.transaction_id
+    end
+  end
+  puts  "|                        Waiting                           |"
+  print '------------------------------------------------------------'
+  60.times do |it|
+    sleep 1
+    print "\r"
+    prg = it + 1
+    rem = 60 - prg
+    prg.times { print '=' }
+    rem.times { print '-' }
+  end
+  print "\n"
+end

data/spec/mws/apis/feeds/api_spec.rb

@@ -0,0 +1,229 @@
+require 'spec_helper'
+
+module Mws::Apis::Feeds
+
+  class Api
+    attr_reader :defaults
+  end
+
+  describe Api do
+
+    let(:connection) do
+      Mws::Connection.new(
+        merchant: 'GSWCJ4UBA31UTJ',
+        access: 'AYQAKIAJSCWMLYXAQ6K3', 
+        secret: 'Ubzq/NskSrW4m5ncq53kddzBej7O7IE5Yx9drGrX'
+      )
+    end
+
+    let(:api) { Api.new(connection) }
+
+    context '.new' do
+
+      it 'should require connection' do
+        expect { Api.new(nil) }.to raise_error Mws::Errors::ValidationError, 'A connection is required.'
+      end
+
+      it 'should default version to 2009-01-01' do
+        api.defaults[:version].should == '2009-01-01'
+      end
+
+      it 'should initialize a products feed' do
+        TargetedApi.as_null_object
+        TargetedApi.should_receive(:new).with(anything, connection.merchant, :product)
+        api = Api.new(connection)
+        api.products.should_not be nil
+      end
+
+      it 'should initialize an images feed' do
+        TargetedApi.as_null_object
+        TargetedApi.should_receive(:new).with(anything, connection.merchant, :image)
+        api = Api.new(connection)
+        api.images.should_not be nil
+      end
+
+      it 'should initialize a prices feed' do
+        TargetedApi.as_null_object
+        TargetedApi.should_receive(:new).with(anything, connection.merchant, :price)
+        api = Api.new(connection)
+        api.prices.should_not be nil
+      end
+
+      it 'should initialize a shipping feed' do
+        TargetedApi.as_null_object
+        TargetedApi.should_receive(:new).with(anything, connection.merchant, :override)
+        api = Api.new(connection)
+        api.shipping.should_not be nil
+      end
+
+      it 'should initialize an inventory feed' do
+        TargetedApi.as_null_object
+        TargetedApi.should_receive(:new).with(anything, connection.merchant, :inventory)
+        api = Api.new(connection)
+        api.inventory.should_not be nil
+      end
+
+    end
+
+    context '#get' do
+
+      it 'should properly delegate to connection' do
+        connection.should_receive(:get).with('/', { feed_submission_id: 1 }, { 
+          version: '2009-01-01',
+          action: 'GetFeedSubmissionResult',
+          xpath: 'AmazonEnvelope/Message'
+        }).and_return('a_node')
+        SubmissionResult.should_receive(:from_xml).with('a_node')
+        api.get(1)
+      end
+
+    end
+
+    context '#submit' do
+
+      it 'should properly delegate to connection' do
+        response = double(:response)
+        response.should_receive(:xpath).with('FeedSubmissionInfo').and_return(['a_result'])
+        connection.should_receive(:post).with('/', { feed_type: '_POST_INVENTORY_AVAILABILITY_DATA_' }, 'a_body', {
+          version: '2009-01-01',
+          action: 'SubmitFeed'
+        }).and_return(response)
+        SubmissionInfo.should_receive(:from_xml).with('a_result')
+        api.submit 'a_body', feed_type: :inventory
+      end
+
+    end
+
+    context '#list' do
+
+      it 'should handle a single submission id' do
+        response = double(:response)
+        response.should_receive(:xpath).with('FeedSubmissionInfo').and_return(['result_one'])
+        connection.should_receive(:get).with('/', { feed_submission_id: [ 1 ] }, {
+          version: '2009-01-01',
+          action: 'GetFeedSubmissionList'
+        }).and_return(response)
+        SubmissionInfo.should_receive(:from_xml) { | node | node }.once
+        api.list(id: 1).should == [ 'result_one' ]
+      end
+
+      it 'should handle a multiple submission ids' do
+        response = double(:response)
+        response.should_receive(:xpath).with('FeedSubmissionInfo').and_return([ 'result_one', 'result_two', 'result_three' ])
+        connection.should_receive(:get).with('/', { feed_submission_id: [ 1, 2, 3 ] }, {
+          version: '2009-01-01',
+          action: 'GetFeedSubmissionList'
+        }).and_return(response)
+        SubmissionInfo.should_receive(:from_xml) { | node | node }.exactly(3).times
+        api.list(ids: [ 1, 2, 3 ]).should == [ 'result_one', 'result_two', 'result_three' ]
+      end
+
+    end
+
+    context '#count' do
+
+      it 'should properly delegate to connection' do
+        count = double(:count)
+        count.should_receive(:text).and_return('5')
+        response = double(:response)
+        response.should_receive(:xpath).with('Count').and_return([ count ])
+        connection.should_receive(:get).with('/', {}, {
+          version: '2009-01-01',
+          action: 'GetFeedSubmissionCount'
+        }).and_return(response)
+        api.count.should == 5
+      end
+
+    end
+
+  end
+
+  describe TargetedApi do
+
+    let(:connection) do
+      Mws::Connection.new(
+        merchant: 'GSWCJ4UBA31UTJ',
+        access: 'AYQAKIAJSCWMLYXAQ6K3', 
+        secret: 'Ubzq/NskSrW4m5ncq53kddzBej7O7IE5Yx9drGrX'
+      )
+    end
+
+    let(:api) { Api.new(connection) }
+
+    context '#add' do
+
+      it 'should properly delegate to #submit' do
+        api.products.should_receive(:submit).with([ 'resource_one', 'resource_two' ], :update, true).and_return('a_result')
+        api.products.add('resource_one', 'resource_two').should == 'a_result'
+      end
+
+    end
+
+    context '#update' do
+
+      it 'should properly delegate to #submit' do
+        api.products.should_receive(:submit).with([ 'resource_one', 'resource_two' ], :update).and_return('a_result')
+        api.products.update('resource_one', 'resource_two').should == 'a_result'
+      end
+
+    end
+
+    context '#patch' do
+
+      it 'should properly delegate to #submit for products' do
+        api.products.should_receive(:submit).with([ 'resource_one', 'resource_two' ], :partial_update).and_return('a_result')
+        api.products.patch('resource_one', 'resource_two').should == 'a_result'
+      end
+
+      it 'should not be supported for feeds other than products' do
+        expect { api.images.patch('resource_one', 'resource_two') }.to raise_error 'Operation Type not supported.'
+      end
+
+    end
+
+    context '#delete' do
+
+      it 'should properly delegate to #submit' do
+        api.products.should_receive(:submit).with([ 'resource_one', 'resource_two' ], :delete).and_return('a_result')
+        api.products.delete('resource_one', 'resource_two').should == 'a_result'
+      end
+
+    end
+
+    context '#submit' do
+
+      it 'should properly construct the feed and delegate to feeds' do
+        resource = double :resource
+        resource.stub(:to_xml)
+        resource.stub(:sku).and_return('a_sku')
+        resource.stub(:operation_type).and_return(:update)
+        feed_xml = Nokogiri::XML::Builder.new do
+          AmazonEnvelope('xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance', 'xsi:noNamespaceSchemaLocation' => 'amznenvelope.xsd') {
+            Header {
+              DocumentVersion '1.01'
+              MerchantIdentifier 'GSWCJ4UBA31UTJ'
+            }
+            MessageType 'Product'
+            PurgeAndReplace false
+            Message {
+              MessageID 1
+              OperationType 'Update'
+            }
+          }
+        end.doc.to_xml
+        submission_info = double(:submission_info).as_null_object
+        api.should_receive(:submit).with(feed_xml, feed_type: Feed::Type.PRODUCT, purge_and_replace: false).and_return(submission_info)
+        tx = api.products.submit [ resource ], :update
+        tx.items.size.should == 1
+        item = tx.items.first
+        item.id.should == 1
+        item.sku.should == 'a_sku'
+        item.operation.should == :update
+        item.qualifier.should be nil
+      end
+
+    end
+
+  end
+
+end