amazon-mws-plus 0.1.3

data/lib/amazon/mws/connection/management.rb

@@ -0,0 +1,95 @@
+class Amazon::MWS::Connection
+
+  module Management #:nodoc:
+=begin
+    def self.included(base)
+      base.cattr_accessor :connections
+      base.connections = {}
+      base.extend ClassMethods
+    end
+
+    # Manage the creation and destruction of connections for Amazon::MWS::Base and its subclasses. Connections are
+    # created with establish_connection!.
+    module ClassMethods
+      # Creates a new connection with which to make requests to the S3 servers for the calling class.
+      #
+      #   Amazon::MWS::Base.establish_connection!(
+      #     :access_key_id     => '...',
+      #     :secret_access_key => '...',
+      #     :merchant_id       => '...',
+      #     :marketplace_id    => '...'
+      #   )
+      #
+      # == Required arguments
+      #
+      # * <tt>:access_key_id</tt> - The access key id for your S3 account. Provided by Amazon.
+      # * <tt>:secret_access_key</tt> - The secret access key for your S3 account. Provided by Amazon.
+      # * <tt>:merchant_id</tt>
+      # * <tt>:marketplace_id</tt>
+      #
+      # If any of these required arguments is missing, a MissingAccessKey exception will be raised.
+      #
+      # == Optional arguments
+      #
+      # * <tt>:server</tt> - The server to make requests to. You can use this to specify your bucket in the subdomain,
+      # or your own domain's cname if you are using virtual hosted buckets. Defaults to <tt>mws.amazonaws.com</tt>.
+      # will be implicitly set to 443, unless specified otherwise. Defaults to false.
+      # * <tt>:persistent</tt> - Whether to use a persistent connection to the server. Having this on provides around a two fold
+      # performance increase but for long running processes some firewalls may find the long lived connection suspicious and close the connection.
+      # If you run into connection errors, try setting <tt>:persistent</tt> to false. Defaults to false.
+      #
+      def establish_connection!(options = {})
+        # After you've already established the default connection, just specify
+        # the difference for subsequent connections
+        #options = default_connection.options.merge(options) if connected?
+        connections[connection_name] = Amazon::MWS::Connection.connect(options)
+      end
+
+      # Returns the connection for the current class, or Base's default connection if the current class does not
+      # have its own connection.
+      #
+      # If not connection has been established yet, NoConnectionEstablished will be raised.
+      def connection
+        if connected?
+          connections[connection_name] || default_connection
+        else
+          raise Amazon::MWS::NoConnectionEstablished.new
+        end
+      end
+
+      # Returns true if a connection has been made yet.
+      def connected?
+        !connections.empty?
+      end
+
+      # Removes the connection for the current class. If there is no connection for the current class, the default
+      # connection will be removed.
+      def disconnect(name = connection_name)
+        name       = default_connection unless connections.has_key?(name)
+        connection = connections[name]
+        connection.http.finish if connection.persistent?
+        connections.delete(name)
+      end
+
+      # Clears *all* connections, from all classes, with prejudice.
+      def disconnect!
+        connections.each_key {|connection| disconnect(connection)}
+      end
+
+    private
+      def connection_name
+        name
+      end
+
+      def default_connection_name
+        'Amazon::MWS::Base'
+      end
+
+      def default_connection
+        connections[default_connection_name]
+      end
+    end
+  end
+
+end
+=end

data/lib/amazon/mws/connection/request_builder.rb

@@ -0,0 +1,67 @@
+class Amazon::MWS::Connection
+  class RequestBuilder
+    attr_accessor :request
+
+    def initialize(verb, path, body = nil)
+      # Create the request object
+      @request = request_method(verb).new(path)
+      process_body(body)
+    end
+
+    def request_method(verb)
+      Net::HTTP.const_get(verb.to_s.capitalize)
+    end
+
+    def process_body(body)
+      @request.content_length = 0 and return self if body.nil?
+
+      if body.respond_to?(:read)
+        @request.body_stream = body
+      else
+        @request.body = body
+      end
+
+      @request.content_length = body.respond_to?(:lstat) ? body.stat.size : body.size
+      return self
+    end
+
+    # For the SubmitFeed (p. 41) function, we require that you pass the Content-MD5 HTTP header,
+    # which contains the MD5 hash of the HTTP entity body (see Section 14.15 of RFC 2616, the HTTP/1.1
+    # specification), so we can check if the feed we stored for processing is bit for bit identical with what you
+    # sent, protecting you from corrupted descriptive or pricing product data appearing on Amazon.com.
+    #
+    #def add_host
+    #  @request['Host'] = Amazon::MWS::DEFAULT_HOST
+    #  return self
+    #end
+
+    def add_user_agent
+      @request['User-Agent'] = "Amazon::MWS (Language=Ruby)"
+      return self
+    end
+
+    def add_content_type
+      @request.content_type = "text/html; charset=iso-8859-1"
+      return self
+    end
+
+    def add_content_md5(body = "")
+      @request['Content-MD5'] = Base64.encode64(create_md5(body)).chomp
+      return self # chainable
+    end
+
+    # think about chaining this with process_body
+    def create_md5(body)
+      md5 = Digest::MD5.new
+
+      # stream from file or in memory?
+      if body.respond_to?(:read)
+        digest = body.each { |line| md5.update(line) }
+      else
+        digest = md5.update(body)
+      end
+
+      return digest.digest
+    end
+  end
+end

data/lib/amazon/mws/exceptions.rb

@@ -0,0 +1,55 @@
+module Amazon
+  module MWS
+
+    # Abstract super class of all Amazon::MWS exceptions
+    class MWSException < StandardError
+    end
+
+    # Abstract super class for all invalid options.
+    class InvalidOption < MWSException
+    end
+
+    class InvalidMessageType < MWSException
+    end
+
+    class InvalidReportType < MWSException
+    end
+
+    class InvalidSchedule < MWSException
+    end
+
+    class MissingConnectionOptions < MWSException
+    end
+
+    # Raised if an unrecognized option is passed when establishing a connection.
+    class InvalidConnectionOption < InvalidOption
+      def initialize(invalid_options)
+        message = "The following connection options are invalid: #{invalid_options.join(', ')}. "    +
+        "The valid connection options are: #{Connection::Options::VALID_OPTIONS.join(', ')}."
+        super(message)
+      end
+    end
+
+    # Raised if either the access key id or secret access key arguments are missing when establishing a connection.
+    class MissingAccessKey < InvalidOption
+      def initialize(missing_keys)
+        key_list = missing_keys.map {|key| key.to_s}.join(' and the ')
+        super("You did not provide both required access keys. Please provide the #{key_list}.")
+      end
+    end
+
+    # Raised if a request is attempted before any connections have been established.
+    class NoConnectionEstablished < MWSException
+      def initialize
+        super("\nPlease use Amazon::MWS::Base.establish_connection! before making API calls.")
+      end
+    end
+
+    class InvalidParams < MWSException
+      def initialize(params)
+        super("\nInvalid Params For The Request! Please Pass Correct Params #{params.inspect} to Build The Request.")
+      end
+    end 
+
+  end
+end

data/lib/amazon/mws/lib/extensions.rb

@@ -0,0 +1,178 @@
+
+class String
+
+=begin
+  if RUBY_VERSION >= '1.9'
+    def valid_utf8?
+      dup.force_encoding('UTF-8').valid_encoding?
+    end
+  else
+    def valid_utf8?
+      scan(Regexp.new('[^\x00-\xa0]', nil, 'u')) { |s| s.unpack('U') }
+      true
+    rescue ArgumentError
+      false
+    end
+  end
+=end
+
+=begin
+  def to_boolean
+    (self == "true") ? true : false
+  end
+=end
+
+  # By default, +camelize+ converts strings to UpperCamelCase. If the argument to +camelize+
+  # is set to <tt>:lower</tt> then +camelize+ produces lowerCamelCase.
+  #
+  # +camelize+ will also convert '/' to '::' which is useful for converting paths to namespaces.
+  #
+  # Examples:
+  #   "active_record".camelize                # => "ActiveRecord"
+  #   "active_record".camelize(:lower)        # => "activeRecord"
+  #   "active_record/errors".camelize         # => "ActiveRecord::Errors"
+  #   "active_record/errors".camelize(:lower) # => "activeRecord::Errors"
+  def camelize(first_letter_in_uppercase = true)
+    if first_letter_in_uppercase
+      self.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    else
+      self.to_s.first.downcase + camelize(lower_case_and_underscored_word)[1..-1]
+    end
+  end
+
+=begin
+  def underscore
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+=end
+end
+
+class Hash
+  
+=begin
+  def self.from_query_string(string)
+    query = string.split(/\?/)[-1]
+    parts = query.split(/&|=/)
+    Hash[*parts]
+  end
+  
+  def to_query_string
+    self.map { |k,v| "%s=%s" % [URI.encode(k.to_s), URI.encode(v.to_s)] }.join('&') unless self.empty?
+  end  
+=end
+
+  #take keys of hash and transform those to a symbols
+  def self.keys_to_s(value)
+    return value if not value.is_a?(Hash)
+    hash = value.inject({}){|memo,(k,v)| memo[k.to_s] = Hash.keys_to_s(v); memo}
+    return hash
+  end
+
+end
+
+class Array
+  def extract_options!
+    last.is_a?(::Hash) ? pop : {}
+  end
+
+  #def to_query_string
+  #  self.map { |k| "%s=%s" % [URI.encode(k[0].to_s), URI.encode(k[1].to_s)] }.join('&') unless self.empty?
+  #end
+end
+
+=begin
+class Object
+  def returning(value)
+    yield(value)
+    value
+  end
+end
+=end
+
+=begin
+module Kernel
+  def __method__(depth = 0)
+    caller[depth][/`([^']+)'/, 1]
+  end if RUBY_VERSION <= '1.8.7'
+
+  def __called_from__
+    caller[1][/`([^']+)'/, 1]
+  end if RUBY_VERSION > '1.8.7'
+
+  def expirable_memoize(reload = false, storage = nil)
+    current_method = RUBY_VERSION > '1.8.7' ? __called_from__ : __method__(1)
+    storage = "@#{storage || current_method}"
+    if reload
+      instance_variable_set(storage, nil)
+    else
+      if cache = instance_variable_get(storage)
+        return cache
+      end
+    end
+    instance_variable_set(storage, yield)
+  end
+
+  def require_library_or_gem(library, gem_name = nil)
+    if RUBY_VERSION >= '1.9'
+      gem(gem_name || library, '>=0')
+    end
+    require library
+  rescue LoadError => library_not_installed
+    begin
+      require 'rubygems'
+      require library
+    rescue LoadError
+      raise library_not_installed
+    end
+  end
+end
+=end
+
+=begin
+class Class # :nodoc:
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+  end
+
+  def cattr_writer(*syms)
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+
+        def #{sym}=(obj)
+          @@#{sym} = obj
+        end
+      EOS
+    end
+  end
+
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+end if Class.instance_methods(false).grep(/^cattr_(?:reader|writer|accessor)$/).empty?
+=end

data/lib/amazon/mws/lib/memoizable.rb

@@ -0,0 +1,10 @@
+module Memoizable
+  def memoize( name, cache = Hash.new )
+    original = "__unmemoized_#{name}__"
+    ([Class, Module].include?(self.class) ? self : self.class).class_eval do
+      alias_method original, name
+      private original
+      define_method(name) { |*args| cache[args] ||= send(original, *args) }
+    end
+  end
+end

data/lib/amazon/mws/request/feed.rb

@@ -0,0 +1,276 @@
+module Amazon
+  module MWS
+    module Feed
+
+      # Note: We do not handle flat file feed types
+      FEED_TYPES = {
+        :product_data              => '_POST_PRODUCT_DATA_',
+        :product_relationship_data => '_POST_PRODUCT_RELATIONSHIP_DATA_',
+        :item_data                 => '_POST_ITEM_DATA_',
+        :product_overrides         => '_POST_PRODUCT_OVERRIDES_DATA_',
+        :product_image_data        => '_POST_PRODUCT_IMAGE_DATA_',
+        :product_pricing           => '_POST_PRODUCT_PRICING_DATA_',
+        :inventory_availability    => '_POST_INVENTORY_AVAILABILITY_DATA_',
+        :order_acknowledgement     => '_POST_ORDER_ACKNOWLEDGEMENT_DATA_',
+        :order_fulfillment         => '_POST_ORDER_FULFILLMENT_DATA_',
+        :payment_adjustment        => '_POST_PAYMENT_ADJUSTMENT_DATA_',
+        :invoice_confirmation      => '_POST_INVOICE_CONFIRMATION_DATA_'
+        # :flat_file_listings              => '_POST_FLAT_FILE_LISTINGS_DATA_',
+        # :flat_file_order_acknowledgement => '_POST_FLAT_FILE_ORDER_ACKNOWLEDGEMENT_DATA_',
+        # :flat_file_fulfillment_data      => '_POST_FLAT_FILE_FULFILLMENT_DATA_',
+        # :flat_file_payment_adjustment    => '_POST_FLAT_FILE_PAYMENT_ADJUSTMENT_DATA_',
+        # :flat_file_invloader             => '_POST_FLAT_FILE_INVLOADER_DATA_'
+      }
+
+      MESSAGE_TYPES = [
+        "FulfillmentCenter",
+        "Inventory",
+        "OrderAcknowledgement",
+        "OrderAdjustment",
+        "OrderFulfillment",
+        "OrderReport",
+        "Override",
+        "Price",
+        "ProcessingReport",
+        "Product",
+        "ProductImage",
+        "Relationship",
+        "SettlementReport",
+        "InvoiceConfirmation"
+      ]
+      
+      PRODUCT_MESSAGE_TYPES = [
+        "Product",
+        "Price",
+        "ProductImage",
+        "Relationship",
+        "Inventory"
+      ]
+      
+      PROCESSING_STATUSES = {
+        :submitted => '_SUBMITTED_',
+        :in_progress => '_IN_PROGRESS_',
+        :done => '_DONE_',
+        :completed => '_COMPLETED_'
+      }
+      # The SubmitFeed operation uploads a file for processing together with
+      # the necessary metadata to process the file.
+
+      # Amazon MWS limits calls to 1,000 total calls per hour per seller
+      # account. For best performance, you should limit your calls to
+      # SubmitFeed to no more than three feeds per hour per seller account,
+      # although you can successfully call SubmitFeed up to 30 times per
+      # hour. Feed size is limited to 2,147,483,647 bytes (2^32 -1) per
+      # feed.
+
+      def submit_flat_file_feed(records, purge_flag = false)
+        header = "sku\tproduct-id\tproduct-id-type\tprice\titem-condition\tquantity\tadd-delete\twill-ship-internationally\texpedited-shipping\titem-note\tfulfillment-center-id"
+        query_params = {"Action" => "SubmitFeed","FeedType" => "_POST_FLAT_FILE_INVLOADER_DATA_"}
+        query_params['PurgeAndReplace'] = 'true' if purge_flag
+        response = post("/", query_params, ([header] + records).join("\r"))
+        result = SubmitFeedResponse.format(response)
+      end
+
+      # params can only contain {:purge => true}
+      def submit_feed(feed_type, message_type, messages = [], params = {})
+        message_type= message_type.to_s.camelize
+        raise InvalidMessageType if !MESSAGE_TYPES.include?(message_type)
+        raise "Missing merchant_id" unless @merchant_id
+        
+        body = Amazon::MWS::FeedBuilder.new(message_type, messages, params.merge({:merchant_id => @merchant_id})).render
+        puts body if Amazon::MWS::Base.debug
+        
+        response =
+          post("/", {
+          "Action"   => "SubmitFeed",
+          "FeedType" => FEED_TYPES[feed_type]
+        }, body)
+
+        result = SubmitFeedResponse.format(response)
+      end
+
+      alias_method :submit, :submit_feed
+
+      # The GetFeedSubmissionList operation returns the total list of feed
+      # submissions within the previous 90 days that match the query
+      # parameters. Amazon MWS limits calls to 1,000 total calls per hour
+      # per seller account, including calls to GetFeedSubmissionList.
+      #
+      # The maximum number of results that will be returned in one call is
+      # one hundred. If there are additional results to return, HasNext will
+      # be returned in the response with a true value. To retrieve all the
+      # results, you can use the value of the NextToken parameter to call
+      # GetFeedSubmissionListByNextToken until HasNext is false.
+
+      # Optional Request Parameters
+      # ------------------
+      # FeedSubmissionIdList
+      # A structured list of feed submission IDs. If you pass in explicit
+      # IDs in this call, the other conditions, if specified, will be
+      # ignored.
+
+      # MaxCount
+      # Maximum number of feed submissions to return in the list. If you
+      # specify a number greater than 100, the call will be rejected.
+
+      # FeedTypeList
+      # A structured list of one or more FeedType constants by which to
+      # filter feed submissions.
+
+      # FeedProcessingStatusList
+      # A structured list of one or more feed processing statuses by which
+      #  to filter feed submissions. Valid values are:
+      #
+      # _SUBMITTED_
+      # _IN_PROGRESS_
+      # _CANCELLED_
+      # _DONE_
+
+      # SubmittedFromDate
+      # The earliest submission date you are looking for, in ISO8601 date
+      #  format (for example, "2008-07-03T18:12:22Z" or
+      #  "2008-07-03T18:12:22.093-07:00").
+
+      # SubmittedToDate
+      # The latest submission date you are looking for, in ISO8601 date
+      # format (for example, "2008-07-03T18:12:22Z" or
+      # "2008-07-03T18:12:22.093-07:00").
+
+      def get_feed_submission_list(params = {})
+       response = get("/", {"Action" => "GetFeedSubmissionList"}.merge(params))
+       result = GetFeedSubmissionListResponse.format(response)
+      end
+
+      alias_method :feed_submission_list, :get_feed_submission_list
+
+      # The GetFeedSubmissionListByNextToken operation returns a list of
+      # feed submissions that match the query parameters, using the
+      # NextToken, which was supplied by a previous call to either
+      # GetFeedSubmissionListByNextToken or a call to GetFeedSubmissionList,
+      # where the value of HasNext was true in that previous call.
+      #
+      # Request Parameters
+      # ------------------
+      # NextToken
+      # Token returned in a previous call to either GetFeedSubmissionList or
+      # GetFeedSubmissionListByNextToken when the value of HasNext was true.
+      def get_feed_submission_list_by_next_token(next_token)
+        response =
+         get("/", {
+           "Action"   => "GetFeedSubmissionListByNextToken",
+           "NextToken" => next_token
+         })
+
+         GetFeedSubmissionListByNextTokenResponse.format(response)
+      end
+
+      alias_method :feed_submission_list_by_next_token, :get_feed_submission_list_by_next_token
+
+      # The GetFeedsubmissionCount operation returns a count of the total
+      # number of feed submissions within the previous 90 days.
+      #
+      # Optional Request Parameters
+      # ------------------
+      # FeedTypeList
+      # A structured list of one or more FeedType constants by which to
+      # filter feed submissions.
+
+      # FeedProcessingStatusList
+      # A structured list of one or more feed processing statuses by which
+      # to filter feed submissions. Valid values are:
+      #
+      # _SUBMITTED_
+      # _IN_PROGRESS_
+      # _CANCELLED_
+      # _DONE_
+
+      #  SubmittedFromDate
+      #  The earliest submission date you are looking for, in ISO8601 date
+      # format (for example, "2008-07-03T18:12:22Z" or
+      # "2008-07-03T18:12:22.093-07:00").
+
+      # SubmittedToDate
+      # The latest submission date you are looking for, in ISO8601 date
+      # format (for example, "2008-07-03T18:12:22Z" or
+      # "2008-07-03T18:12:22.093-07:00").
+
+      def get_feed_submission_count(params = {})
+        response = get("/", {"Action" => "GetFeedSubmissionCount"}.merge(params))
+        GetFeedSubmissionCountResponse.format(response)
+      end
+
+      alias_method :feed_submission_count, :get_feed_submission_count
+
+      # The CancelFeedSubmissions operation cancels one or more feed
+      # submissions, returning the count of the canceled feed submissions
+      # and the feed submission information. You can specify a number to
+      # cancel of greater than one hundred, but information will only be
+      # returned about the first one hundred feed submissions in the list.
+      # To return metadata about a greater number of canceled feed
+      # submissions, you can call GetFeedSubmissionList. If feeds have
+      # already begun processing, they cannot be canceled.
+
+      # Amazon MWS limits calls to 1,000 total calls per hour per seller
+      # account, including calls to CancelFeedSubmissions.
+
+      # Optional Request Parameters
+      # ------------------
+      # FeedSubmissionIdList
+      # A structured list of feed submission IDs. If you pass in explicit
+      # IDs in this call, the other conditions, if specified, will be
+      # ignored.
+
+      # FeedTypeList
+      # A structured list of one or more FeedType constants by which to
+      # filter feed submissions.
+
+      # SubmittedFromDate
+      # The earliest submission date you are looking for, in ISO8601 date
+      # format (for example, "2008-07-03T18:12:22Z" or
+      # "2008-07-03T18:12:22.093-07:00").
+
+      # SubmittedToDate
+      # The latest submission date you are looking for, in ISO8601 date
+      # format (for example, "2008-07-03T18:12:22Z" or
+      # "2008-07-03T18:12:22.093-07:00").
+
+      def cancel_feed_submissions(params = {})
+        response =
+        get("/", {"Action" => "CancelFeedSubmissions"}.merge(params))
+
+        CancelFeedSubmissionsResponse.format(response)
+      end
+
+      # The GetFeedSubmissionResult operation returns the feed processing
+      # report and the Content-MD5 header for the returned body.
+
+      # You should compute the MD5 hash of the HTTP body that we returned to
+      # you, and compare that with the Content-MD5 header value that we
+      # returned. If they do not match, which means the body was corrupted
+      # during transmission, you should discard the result and automatically
+      # retry the call for up to three more times. Please notify us if you
+      # ever see such a corrupted body. You can contact us by using the
+      # contact form at http://mws.amazon.com (http://mws.amazon.com). For
+      # more information on computing the MD5, see Using the Content-MD5
+      # Header with SubmitFeed.
+
+      # FeedSubmissionId
+      # The identifier of the feed submission to get results for. Obtained
+      # by a call to GetFeedSubmissionList.
+
+      def get_feed_submission_result(feed_submission_id, params = {})
+        response = get("/", {
+          "Action"           => "GetFeedSubmissionResult",
+          "FeedSubmissionId" => feed_submission_id
+        }.merge(params))
+
+        GetFeedSubmissionResultResponse.format(response)
+      end
+
+      alias_method :feed_submission_result, :get_feed_submission_result
+    end
+
+    # Feed
+
+  end
+end