mws-connect 0.0.1

data/lib/mws/apis/feeds/submission_info.rb

@@ -0,0 +1,45 @@
+module Mws::Apis::Feeds
+
+  class SubmissionInfo
+    
+    private :initialize
+
+    private_class_method :new
+
+    Status = Mws::Enum.for(
+      done: '_DONE_', 
+      submitted: '_SUBMITTED_', 
+      in_progress: '_IN_PROGRESS_', 
+      cancelled: '_CANCELLED_'
+    )
+
+    attr_accessor :id, :submitted, :started, :completed
+
+    Mws::Enum.sym_reader self, :type, :status
+
+    def initialize(node)
+      @id = node.xpath('FeedSubmissionId').first.text.to_s
+      @type = Feed::Type.for(node.xpath('FeedType').first.text)
+      @status = Status.for(node.xpath('FeedProcessingStatus').first.text)
+      @submitted = Time.parse(node.xpath('SubmittedDate').first.text.to_s)
+      node.xpath('StartedProcessingDate').each do | node |
+        @started = Time.parse(node.text.to_s)  
+      end
+      node.xpath('CompletedProcessingDate').each do | node |
+        @completed = Time.parse(node.text.to_s)
+      end
+    end
+
+    def self.from_xml(node)
+      new node
+    end 
+
+    def ==(other)
+      return true if equal? other
+      return false unless other.class == self.class
+      id == other.id
+    end
+
+  end
+
+end

data/lib/mws/apis/feeds/submission_result.rb

@@ -0,0 +1,87 @@
+module Mws::Apis::Feeds
+
+  class SubmissionResult
+
+    private :initialize
+
+    private_class_method :new
+
+    Status = Mws::Enum.for(
+      complete: 'Complete', 
+      processing: 'Processing', 
+      rejected: 'Rejected'
+    )
+
+    attr_reader :transaction_id, :messages_processed
+
+    Mws::Enum.sym_reader self, :status
+    
+    def initialize(node)
+      @transaction_id = node.xpath('ProcessingReport/DocumentTransactionID').first.text.to_s
+      @status = Status.for(node.xpath('ProcessingReport/StatusCode').first.text)
+      @messages_processed = node.xpath('ProcessingReport/ProcessingSummary/MessagesProcessed').first.text.to_i
+      
+      @counts = {}
+      [ Response::Type.SUCCESS, Response::Type.ERROR, Response::Type.WARNING ].each do | type |
+        @counts[type.sym] = node.xpath("ProcessingReport/ProcessingSummary/#{type.val.first}").first.text.to_i
+      end
+      @responses = {}
+      node.xpath('ProcessingReport/Result').each do | result_node |
+        response = Response.from_xml(result_node)
+        @responses[response.id.to_sym] = response 
+      end
+    end
+
+    def self.from_xml(node)
+      new node
+    end
+
+    def ==(other)
+      return true if equal? other
+      return false unless other.class == self.class
+      transaction_id == other.transaction_id
+    end
+
+    def count_for(type)
+      @counts[Response::Type.for(type).sym]
+    end
+
+    def response_for(message_id)
+      @responses[message_id.to_s.to_sym]
+    end
+
+    class Response
+
+      Type = Mws::Enum.for(
+        success: [ 'MessagesSuccessful' ],
+        error: [ 'MessagesWithError', 'Error' ], 
+        warning: [ 'MessagesWithWarning', 'Warning' ]
+      )
+
+      private :initialize
+
+      private_class_method :new
+
+      attr_reader :id, :code, :description, :additional_info
+
+      Mws::Enum.sym_reader self, :type
+
+      def initialize(node)
+        @id = node.xpath('MessageID').first.text.to_s
+        @type = Type.for(node.xpath('ResultCode').first.text.to_s)
+        @code = node.xpath('ResultMessageCode').first.text.to_i
+        @description = node.xpath('ResultDescription').first.text.to_s
+        node.xpath('AdditionalInfo').each do | info |
+          @additional_info = Mws::Serializer.new.hash_for(info, 'additional_info') 
+        end
+      end
+
+      def self.from_xml(node)
+        new node
+      end
+
+    end
+
+  end
+
+end

data/lib/mws/apis/feeds/transaction.rb

@@ -0,0 +1,37 @@
+module Mws::Apis::Feeds
+	
+	class Transaction
+
+    attr_reader :id, :type, :status, :submitted, :items
+
+    def initialize(submission_info, items=[], &item_builder)
+      @id = submission_info.id
+      @type = submission_info.type
+      @status = submission_info.status
+      @submitted = submission_info.submitted
+      @items = items
+      instance_eval &item_builder unless item_builder.nil?
+    end
+
+    private
+
+    def item(id, sku, operation, qualifier=nil)
+      @items << Item.new(id, sku, operation, qualifier)
+    end
+
+    class Item
+
+      attr_reader :id, :sku, :operation, :qualifier
+
+      def initialize(id, sku, operation, qualifier)
+        @id = id
+        @sku  = sku
+        @operation = operation
+        @qualifier = qualifier
+      end
+
+    end
+
+  end
+
+end

data/lib/mws/apis/feeds/weight.rb

@@ -0,0 +1,19 @@
+module Mws::Apis::Feeds
+
+  class Weight < Measurement
+
+    Unit = Mws::Enum.for(
+      grams: 'GR',
+      kilograms: 'KG',
+      ounces: 'OZ',
+      pounds: 'LB',
+      miligrams: 'MG'
+    )
+
+    def initialize(amount, unit=nil)
+      super amount, unit || :pounds
+    end
+
+  end
+
+end

data/lib/mws/apis/orders.rb

@@ -0,0 +1,23 @@
+class Mws::Apis::Orders
+
+  def initialize(connection, overrides={})
+    @connection = connection
+    @param_defaults = {
+      market: 'ATVPDKIKX0DER'
+    }.merge overrides
+    @option_defaults = {
+      version: '2011-01-01',
+      list_pattern: '%{key}.%{ext}.%<index>d'
+    }
+  end
+
+  def list(params={})
+    params[:markets] ||= [ params.delete(:markets) || params.delete(:market) || @param_defaults[:market] ].flatten.compact
+    options = @option_defaults.merge action: 'ListOrders'
+    doc = @connection.get "/Orders/#{options[:version]}", params, options
+    doc.xpath('Orders/Order').map do | node |
+      'Someday this will be an Order'
+    end
+  end
+
+end

data/lib/mws/connection.rb

@@ -0,0 +1,84 @@
+require 'uri'
+require 'net/http'
+require 'digest/md5'
+require 'logging'
+require 'nokogiri'
+
+module Mws
+
+  class Connection
+
+    attr_reader :merchant, :orders, :feeds
+
+    def initialize(overrides)
+      @log = Logging.logger[self]
+      @scheme = overrides[:scheme] || 'https'
+      @host = overrides[:host] || 'mws.amazonservices.com'
+      @merchant = overrides[:merchant]
+      raise Mws::Errors::ValidationError, 'A merchant identifier must be specified.' if @merchant.nil?
+      @access = overrides[:access]
+      raise Mws::Errors::ValidationError, 'An access key must be specified.' if @access.nil?
+      @secret = overrides[:secret]
+      raise Mws::Errors::ValidationError, 'A secret key must be specified.' if @secret.nil?
+      @orders = Apis::Orders.new self
+      @feeds = Apis::Feeds::Api.new self
+    end
+
+    def get(path, params, overrides)
+      request(:get, path, params, nil, overrides)
+    end
+
+    def post(path, params, body, overrides)
+      request(:post, path, params, body, overrides)
+    end
+
+    private
+
+    def request(method, path, params, body, overrides)
+      query = Query.new({
+        action: overrides[:action],
+        version: overrides[:version],
+        merchant: @merchant,
+        access: @access,
+        list_pattern: overrides.delete(:list_pattern)
+      }.merge(params))
+      signer = Signer.new method: method, host: @host, path: path, secret: @secret
+      parse response_for(method, path, signer.sign(query), body), overrides
+    end
+
+    def response_for(method, path, query, body)
+      uri = URI("#{@scheme}://#{@host}#{path}?#{query}")
+      @log.debug "Request URI:\n#{uri}\n"
+      req = Net::HTTP.const_get(method.to_s.capitalize).new (uri.request_uri)
+      req['User-Agent'] = 'MWS Connect/0.0.1 (Language=Ruby)'
+      req['Accept-Encoding'] = 'text/xml'
+      if req.request_body_permitted? and body
+        @log.debug "Body:\n#{body}"
+        req.content_type = 'text/xml'
+        req['Content-MD5'] = Digest::MD5.base64digest(body).strip
+        @log.debug "Hash:\n#{req['Content-MD5']}\n"
+        req.body = body
+      end
+      res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do | http |
+        http.request req
+      end
+      raise Errors::ServerError.new(code: res.code, message: res.msg) if res.body.nil?
+      @log.debug "Response Body:\n#{res.body}\n"
+      res.body
+    end
+
+    def parse(body, overrides)
+      doc = Nokogiri::XML(body)
+      doc.remove_namespaces!
+      doc.xpath('/ErrorResponse/Error').each do | error |
+        options = {}
+        error.element_children.each { |node| options[node.name.downcase.to_sym] = node.text }
+        raise Errors::ServerError.new(options)
+      end
+      result = doc.xpath((overrides[:xpath] || '/%{action}Response/%{action}Result') % overrides ).first
+      result
+    end
+
+  end
+
+end

data/lib/mws/enum.rb

@@ -0,0 +1,81 @@
+module  Mws
+
+  class Enum
+
+    private :initialize
+
+    private_class_method :new
+
+    def initialize(entries)
+      @reverse = {}
+      @entries = []
+      entries.each do | key, values |
+        entry = EnumEntry.new(key, values)
+        @entries << entry
+        @reverse[key] = entry
+        values = [ values ] unless values.respond_to? :each
+        values.each do | value |
+          @reverse[value] = entry
+        end
+      end
+    end
+
+    def syms
+      @entries.map { |it| it.sym }
+    end
+
+    def vals
+      @entries.map { |it| it.val }.flatten
+    end
+
+    def for(it)
+      return it if it.instance_of? EnumEntry 
+      @reverse[it]
+    end
+
+    def sym(str)
+      entry = self.for(str)
+      entry && entry.sym
+    end
+
+    def val(sym)
+      entry = self.for(sym)
+      entry && entry.val
+    end
+
+    def self.for(h)
+      it = new(h)
+      eigenclass = class << it
+        self
+      end
+      h.each do | key, value |
+        eigenclass.send(:define_method, key.to_s.upcase.to_sym) do
+          it.for key
+        end 
+      end
+      it
+    end
+
+    def self.sym_reader(target, *attributes)
+      attributes.each do | attribute |
+        target.send(:define_method, attribute) do
+          entry = send(:instance_variable_get, "@#{attribute}")
+          entry && entry.sym
+        end
+      end
+    end
+
+  end
+
+  class EnumEntry
+
+    attr_reader :sym, :val
+
+    def initialize(sym, val)
+      @sym = sym
+      @val = val
+    end
+
+  end
+
+end

data/lib/mws/errors.rb

@@ -0,0 +1,32 @@
+module Mws::Errors
+
+  class Error < RuntimeError
+
+  end
+
+  class ServerError < Error
+
+    attr_reader :type, :code, :message, :details
+
+    def initialize(options)
+      @type = options[:type] || 'HTTP'
+      @code = options[:code]
+      @message = options[:message]
+      @details = options[:details] || options[:detail] 
+      if @details.nil? or @details.empty?
+        @details = 'None'
+      end
+      super "Type: #{@type}, Code: #{@code}, Message: #{@message}, Details: #{@details}"
+    end
+
+  end
+
+  class ClientError < Error
+
+  end
+
+  class ValidationError < ClientError
+
+  end
+
+end

data/lib/mws/query.rb

@@ -0,0 +1,45 @@
+require 'time'
+
+class Mws::Query
+
+  def initialize(overrides)
+    options = {
+      signature_method: 'HmacSHA256',
+      signature_version: '2',
+      timestamp: Time.now.iso8601
+    }.merge overrides
+
+    options[:aws_access_key_id] ||= options.delete :access
+    options[:seller_id] ||= options.delete(:merchant) || options.delete(:seller)
+    options[:marketplace_id] ||= options.delete(:markets) || []
+    list_pattern = options.delete(:list_pattern) || '%{key}List.%{ext}.%<index>d'
+    
+    @params = Hash[options.inject({}) do | params, entry |
+      key = normalize_key entry.first
+      if entry.last.respond_to? :each_with_index
+        entry.last.each_with_index do | value, index |
+          param_key = list_pattern % { key: key, ext: entry.first.to_s.split('_').last.capitalize, index: index + 1 }
+          params[param_key] = normalize_val value
+        end
+      else
+        params[key] = normalize_val entry.last
+      end
+      params
+    end.sort]
+  end
+
+  def to_s
+    @params.map { |it| it.join '=' }.join '&'
+  end
+
+  private
+
+  def normalize_key(key)
+    Mws::Utils.camelize(key).sub /^Aws/, 'AWS'
+  end
+
+  def normalize_val(value)
+    Mws::Utils.uri_escape(value.respond_to?(:iso8601) ? value.iso8601 : value.to_s)
+  end
+
+end