amazon-mws 0.1.0

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

@@ -0,0 +1,94 @@
+class Amazon::MWS::Connection
+
+  module Management #:nodoc:
+    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
+

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/#{Amazon::MWS::Version} (Language=Ruby)"
+      return self
+    end
+    
+    def add_content_type
+      # nothing happening yet
+      return self
+    end
+    
+    def add_content_md5(body = "")
+      @request['Content-MD5'] = Base64.encode64(create_md5(body))
+      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.hexdigest
+    end
+  end
+end

data/lib/amazon/mws/exceptions.rb

@@ -0,0 +1,80 @@
+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
+    
+    # All responses with a code between 300 and 599 that contain an <Error></Error> body are wrapped in an
+    # ErrorResponse which contains an Error object. This Error class generates a custom exception with the name
+    # of the xml Error and its message. All such runtime generated exception classes descend from ResponseError
+    # and contain the ErrorResponse object so that all code that makes a request can rescue ResponseError and get
+    # access to the ErrorResponse.
+    # class ResponseError < MWSException
+    #   def initialize(formatted_response)
+    #     instance_eval(<<-EVAL, __FILE__, __LINE__)
+    #       def request_id
+    #         '#{formatted_response["RequestID"]}'
+    #       end
+    #     EVAL
+    #     
+    #     formatted_response["Error"].each do |key, value|
+    #       instance_eval(<<-EVAL, __FILE__, __LINE__)
+    #         def #{key.underscore}
+    #           '#{value}'
+    #         end
+    #       EVAL
+    #     end
+    #   end
+    # end
+    
+    class RequestTimeout < ResponseError
+    end
+    
+    # Most ResponseError's are created just time on a need to have basis, but we explicitly define the
+    # InternalError exception because we want to explicitly rescue InternalError in some cases.
+    class InternalError < ResponseError
+    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
+        
+  end
+end

data/lib/amazon/mws/feed.rb

@@ -0,0 +1,223 @@
+module Amazon
+  module MWS
+    
+    module Feed
+      include Enumerations
+      # class << self
+      # 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_feed(feed_type, message_type, message = {})
+        message_type= message_type.to_s.camelize
+        raise InvalidMessageType if !MESSAGE_TYPES.include?(message_type)
+  
+        body = Amazon::MWS::FeedBuilder.new(message_type, message)
+        
+        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)
+        response = 
+        get("/", {
+          "Action"           => "GetFeedSubmissionResult", 
+          "FeedSubmissionId" => feed_submission_id
+        }.merge(params))
+
+        GetFeedSubmissionResultResponse.format(response)
+      end
+
+      alias_method :feed_submission_result, :get_feed_submission_result
+    end
+    
+    # end
+    # Feed
+    
+  end
+end