amazon-mws 0.1.0

data/lib/amazon/mws/feed_builder.rb

@@ -0,0 +1,67 @@
+require 'set'
+
+module Amazon
+  module MWS
+    
+    class FeedBuilder
+      attr_accessor :xml
+  
+      OPERATION_TYPES = Set.new([
+        "Update", 
+        "Delete"  
+      ])
+  
+      def initialize(message_type, message = {}, params = {})
+        @xml = Builder::XmlMarkup.new 
+        @message_type = message_type
+        @message = message
+        @params = params
+      end
+      
+      def render  
+        @xml.instruct!
+        @xml.AmazonEnvelope("xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance", "xsi:noNamespaceSchemaLocation"=>"amzn-envelope.xsd") do 
+          render_envelope(:message_type => @message_type)
+          # header
+          render_header(@params)
+          # message      
+          render_message(@message, @params)
+        end
+      end
+  
+      def render_header(params = {})
+        @xml.Header do
+          @xml.MerchantIdentifier "merchant_id"
+        end
+      end
+  
+      def render_envelope(params = {})      
+        @xml.EffectiveDate Time.now
+        @xml.MessageID
+        @xml.MessageType(params[:message_type])
+        @xml.OperationType(params[:operation_type]) if params[:operation_type]
+        @xml.PurgeAndReplace(params[:purge] || false)
+      end
+  
+      def render_message(message, params = {})
+        raise unless message.is_a? Hash
+        
+        @xml.Message do |xml|
+          build_xml(message, xml)
+        end
+      end
+      
+      def build_xml(hash, xml)
+        hash.each {|key, value|
+          case value
+            when Hash  then xml.tag!(key) {|xml| build_xml(value, xml) }
+            when Array then xml.tag!(key) {|xml| value.each {|v| build_xml(v, xml) } }
+            else xml.tag!(key, value)
+          end
+        }
+      end
+    end
+    # Feed
+    
+  end
+end

data/lib/amazon/mws/feed_enumerations.rb

@@ -0,0 +1,46 @@
+module Amazon
+  module MWS
+    module Feed
+
+    module Enumerations
+      
+      # 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_',
+        # :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",
+        "OrderAcknowledgment",
+        "OrderAdjustment",
+        "OrderFulfillment",
+        "OrderReport",
+        "Override",
+        "Price",
+        "ProcessingReport",
+        "Product",
+        "ProductImage",
+        "Relationship",
+        "SettlementReport"
+      ]
+
+    end
+    
+    end
+  end
+end

data/lib/amazon/mws/feed_submission.rb

@@ -0,0 +1,14 @@
+module Amazon
+  module MWS
+    
+    class FeedSubmission < Response
+      xml_name "FeedSubmissionInfo"
+      
+      xml_reader :id, :from => "FeedSubmissionId", :as => Integer
+      xml_reader :feed_type
+      xml_reader :submitted_date, :as => Time
+      xml_reader :feed_processing_status
+    end
+    
+  end
+end

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

@@ -0,0 +1,162 @@
+class String
+  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
+  
+  def to_boolean
+    (self == "true") ? true : false
+  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
+  
+  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
+
+class Hash
+  def self.from_query_string(string)
+    query = string.split(/\?/)[-1]
+    parts = query.split(/&|=/)
+    Hash[*parts]
+  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
+
+class Hash
+  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
+
+class Object
+  def returning(value)
+    yield(value)
+    value
+  end
+end
+
+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
+
+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?

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/orders.rb

@@ -0,0 +1,9 @@
+module Amazon
+  module MWS
+    
+    class Orders
+      
+    end
+    
+  end
+end

data/lib/amazon/mws/report.rb

@@ -0,0 +1,310 @@
+module Amazon
+  module MWS
+
+    module Report
+      include Enumerations
+      # class << self
+    
+      # The RequestReport operation requests the generation of a report, which
+      # creates a report request. Reports are retained for 90 days.
+      # Required Request Parameters
+      # ReportType - The type of report to request.
+      #
+      # Optional Request Parameters
+      # StartDate - Start of a date range used for selecting the data to report.
+      # EndDate - End of a date range used for selecting the data to report.
+
+      def request_report(report_type, params ={})
+        raise InvalidReportType if !REPORT_TYPES.include?(report_type)
+        # These may need to be processed
+        start_date = params[:start_date]
+        end_date   = params[:end_date]
+      
+        query_params = {
+          "Action"   => "RequestReport", 
+          "ReportType" => REPORT_TYPES[report_type]
+        }
+      
+        query_params.merge!({"StartDate" => start_date}) if start_date
+        query_params.merge!({"EndDate" => end_date}) if end_date
+            
+        response = get("/", query_params)
+        
+        RequestReportResponse.format(response)
+      end
+
+      # GetReportRequestList
+      # --------------------
+      # The GetReportRequestList operation returns a list of report requests
+      # that match the query parameters.
+      # 
+      # Amazon MWS limits calls to 1,000 total calls per hour per seller
+      # account, including calls to GetReportRequestList.
+      # 
+      # 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
+      # GetReportRequestListByNextToken until HasNext is false.
+      
+      # Optional Request Parameters
+      #
+      # ReportRequestIdList - A structured list of report request IDs. If you
+      # pass in explicit IDs in this call, the other conditions, if specified,
+      # will be ignored.
+      #
+      # ReportTypeList - A structured ReportType list by which to filter
+      # reports.
+      # 
+      # ReportProcessingStatusList -A structured list of report processing
+      # statuses by which to filter report requests.
+      # 
+      # ReportProcessingStatus values:
+      # 
+      # _SUBMITTED_ 
+      # _IN_PROGRESS_
+      # _CANCELLED_
+      # _DONE_
+      # _DONE_NO_DATA_
+      #
+      # MaxCount - Maximum number of reports to return in the list. If you
+      # specify a number greater than 100, the call will be rejected.
+      #
+      # RequestedFromDate - The earliest 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").
+      #
+      # RequestedToDate - The most recent date you are looking for.
+    
+      def get_report_request_list(params = {})
+        response = get("/", {"Action" => "GetReportRequestList"}.merge(params))
+        GetReportRequestListResponse.format(response)
+      end
+      # add a nice method
+      alias_method :report_request_list, :get_report_request_list
+    
+      # GetReportRequestListByNextToken
+      # Description
+      # 
+      # The GetReportRequestListByNextToken operation returns a list of report
+      # requests that match the query parameters, using the NextToken, which
+      # was supplied by a previous call to either
+      # GetReportRequestListByNextToken or a call to GetReportRequestList,
+      # where the value of HasNext was true in that previous call.
+      
+      # NextToken
+      # Token returned in a previous call to either GetReportRequestList or
+      # GetReportRequestListByNextToken when the value of HasNext was true.
+      
+      def get_report_request_list_by_next_token(next_token)
+        response = 
+         post("/", {
+           "Action"   => "GetReportRequestListByNextToken", 
+           "NextToken" => next_token
+         })
+
+         GetReportRequestListByNextTokenResponse.format(response)
+      end
+
+      alias_method :report_request_list_by_next_token, :get_report_request_list_by_next_token      
+    
+      # GetReportRequestCount
+      # The GetReportRequestCount returns a count of report requests.
+    
+      def get_report_request_count(params = {})
+        response = get("/", {"Action" => "GetReportRequestCount"})
+        GetReportRequestCountResponse.format(response)
+      end
+      # add a nice method
+      alias_method :report_request_count, :get_report_request_count
+    
+      # CancelReportRequests
+      # The CancelReportRequests operation cancels one or more report
+      # requests, returning the count of the canceled report requests and the
+      # report request information. You can specify a number to cancel of
+      # greater than one hundred, but information will only be returned about
+      # the first one hundred report requests in the list. To return metadata
+      # about a greater number of canceled report requests, you can call
+      # GetReportRequestList. If report requests have already begun
+      # processing, they cannot be canceled.
+      
+      #  
+      # ReportRequestIdList
+      # A structured list of report request IDs. If you pass in explicit IDs in this call, the other conditions, if specified, will be ignored.
+      # 
+      # ReportTypeList
+      # A structured ReportType list by which to filter reports.
+      # 
+      # ReportProcessingStatusList
+      # A structured list of report processing statuses by which to filter report requests.
+      # 
+      # ReportProcessingStatus
+      # _SUBMITTED_
+      # _IN_PROGRESS_
+      # _CANCELLED_
+      # _DONE_
+      # _DONE_NO_DATA_
+      # 
+      # RequestedFromDate
+      # The earliest 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").
+      # 
+      # RequestedToDate
+      # The most recent date you are looking for.
+      
+      def cancel_report_requests(params = {})
+        response = get("/", {"Action" => "CancelReportRequests"}.merge(params))
+        CancelReportRequestsResponse.format(response)
+      end
+            
+      # GetReportList
+      # The GetReportList operation returns a list of reports within the
+      # previous 90 days that match the query parameters. 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 GetReportListByNextToken
+      # until HasNext is false.
+      # 
+      # Request Parameters
+      
+      def get_report_list(params = {})
+        response = get("/", {"Action" => "GetReportList"}.merge(params))
+        GetReportListResponse.format(response)
+      end
+
+      alias_method :report_list, :get_report_list
+      
+      # GetReportCount
+      # The GetReportCount operation returns a count of reports within the
+      # previous 90 days that are available for the seller to download.
+
+      #  ReportTypeList
+      # A structured ReportType list by which to filter reports.
+      #      
+      # Acknowledged
+      # Set to true to list reports that have been acknowledged with a prior
+      # call to UpdateReportAcknowledgements. Set to false to list reports
+      # that have not been acknowledged.
+      #
+      # AvailableFromDate
+      # The earliest 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").
+      # 
+      # AvailableToDate
+      # The most recent date you are looking for.
+      
+      def get_report_count(params = {})
+        response = get("/", {"Action" => "GetReportCount"})
+        GetReportCountResponse.format(response)
+      end 
+      
+      alias_method :report_count, :get_report_count     
+
+      # GetReport
+      # Description
+      # 
+      # The GetReport operation returns the contents of a report and the
+      # Content-MD5 header for the returned body. Reports are retained for 90
+      # days from the time they have been generated.
+      # 
+      # Amazon MWS limits calls to 1,000 total calls per hour per seller
+      # account, including a limit of 60 calls per hour to GetReport.
+      # 
+      # You should compute the MD5 hash of the HTTP body and compare that with
+      # the returned Content-MD5 header value. 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, see Using the
+      # Content-MD5 Header with SubmitFeed.     
+      #    
+      
+      def get_report(report_id, params = {})
+        response = get("/", {"Action" => "GetReport", "ReportId" => report_id})
+        # TODO format response
+      end
+      alias_method :report, :get_report
+
+      # ManageReportSchedule
+      # The ManageReportSchedule operation creates, updates, or deletes a
+      # report schedule for a particular report type. Currently, only order
+      # reports can be scheduled.
+      # 
+      # Request Parameters  
+      #
+      # ReportType
+      # The type of reports that you want to schedule generation of.
+      # Currently, only order reports can be scheduled.
+      #
+      # Schedule
+      # A string that describes how often a ReportRequest should be created.
+      # The list of enumerated values is found in the enumeration topic,
+      # Schedule.
+      # 
+      # ScheduledDate
+      # The date when the next report is scheduled to run. Limited to no more
+      # than 366 days in the future.
+      
+      def manage_report_schedule(report_type, schedule, params={})
+        raise InvalidReportType if !REPORT_TYPES.include?(report_type)
+        raise InvalidSchedule if !SCHEDULE.include?(schedule)
+        
+        response = 
+        get("/", {
+          "Action" => "ManageReportSchedule", 
+          "Schedule" => schedule,
+          "ReportType" => report_type
+        })
+        
+        ManageReportScheduleResponse.format(reponse)
+      end
+      
+      # GetReportScheduleList
+      # The GetReportScheduleList operation returns a list of report schedules
+      # that match the query parameters. Currently, only order reports can be
+      # scheduled.
+      # 
+      # 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
+      # GetReportScheduleListByNextToken until HasNext is false.
+      # [Note]  Note
+      # 
+      # For this release of Amazon MWS, only order reports can be scheduled,
+      # so HasNext will always be False.
+      
+      
+      def get_report_schedule_list(params = {})
+        response = get("/", {"Action" => "GetReportScheduleList"}.merge(params))
+        GetReportScheduleListResponse.format(response)
+      end
+
+      alias_method :report_schedule_list, :get_report_schedule_list
+      
+      
+      def get_report_schedule_list_by_next_token(next_token)
+        response = 
+         get("/", {
+           "Action"   => "GetReportScheduleListByNextToken", 
+           "NextToken" => next_token
+         })
+
+         GetReportScheduleListByNextTokenResponse.format(response)
+      end
+
+      alias_method :report_schedule_list_by_next_token, :get_report_schedule_list_by_next_token      
+      
+      def get_report_schedule_count(params = {})
+        response = get("/", {"Action" => "GetReportScheduleCount"})
+        GetReportScheduleCountResponse.format(response)
+      end 
+      
+      alias_method :report_schedule_count, :get_report_schedule_count
+      
+    end
+    
+    # end
+  end
+end