snl-peddler 0.1.0

data/lib/peddler/handlers.rb

@@ -0,0 +1,58 @@
+module Peddler
+  module Handlers
+    class XMLHandler
+      # Decodes an XML response.
+      def self.decode_response(res)
+        XmlSimple.xml_in(res)
+      end
+      # Parses responses to uploads and status queries for feeds in Section 7 of the docs. Walks
+      # through lists and returns an array of hashes.
+      def self.parse(name, xml)
+        name = name.to_s.capitalize
+        list = xml["#{name}sStatusList"] || xml["#{name}sList"]
+        if list
+          list.collect { |s| parse_status(name, s) }
+        else
+          [ parse_status(name, xml) ]
+        end
+      end
+      
+      # Parses legacy responses to queries on statuses of generated reports and inventory uploads.
+      def self.parse_legacy(xml)
+        if xml["Batch"]
+          xml["Batch"].collect  { |input| Peddler::LegacyReports::UploadStatus.new(input) }
+        elsif xml["Report"]
+          xml["Report"].collect { |input| Peddler::LegacyReports::ReportStatus.new(input) }
+        end
+      end
+    protected
+      def self.parse_status(name, xml)
+        if xml[name]
+          xml[name][0].inject({}) do |memo, pair|
+            key, value = pair
+            value[0] = Time.parse(value[0]) if key =~ /Date$/
+            memo.merge!({ key => value[0] })
+          end
+        end
+      end
+    end
+    
+    class TabDelimitedHandler
+      # Parses tab-delimited content, returning an array of OpenStruct objects corresponding to the rows in the former.
+      def self.decode_response(res)
+        lines = res.split("\n")
+        if lines.size > 1
+          params = lines[0].split("\t").collect{ |value| value.gsub(/-/, "_") }
+          params_size = params.size
+          (1..(lines.size - 1)).collect do |line_key|
+            values = lines[line_key].split("\t")
+            data = (0..(params_size - 1)).inject({}) { |memo, key| memo.merge( { params[key] => values[key] } ) }
+            OpenStruct.new(data)
+          end
+        else
+          res
+        end
+      end
+    end
+  end
+end

data/lib/peddler/inventory.rb

@@ -0,0 +1,108 @@
+module Peddler
+  module Inventory
+    module Queue
+      # Returns number of inventory uploads queued at Amazon
+      def self.count(transport)
+        transport.legacize_request
+        transport.path << "manual-reports/get-pending-uploads-count"
+        res = transport.execute_request
+        Peddler::Handlers::XMLHandler.decode_response(res).to_i
+      end
+    end
+    
+    # This is an inventory batch.
+    class Batch
+      attr_reader :id
+      attr_accessor :batch
+      
+      def initialize(transport)
+        @transport = transport
+        @batch = []
+      end
+      
+      # Uploads batch to Amazon.
+      def upload(params={})
+        raise PeddlerError.new("Batch already uploaded") unless @id.nil?
+        @transport.legacize_request
+        @transport.path << "catalog-upload/"
+        case params[:method].to_s
+        when "modify"
+          @transport.path << "modify-only"
+          @transport.body = file_content(:short)
+        when "purge"
+          @transport.path << "purge-replace"
+          @transport.body = file_content
+        else
+          @transport.path << "add-modify-delete"
+          @transport.body = file_content
+        end
+        params.delete(:method)
+        params = defaultize(params)
+        @transport.headers.merge!(params)
+        res = @transport.execute_request
+        if res =~ /^<BatchID>(.*)<\/BatchID>$/
+          @id = $1
+        else
+          @id = 0
+        end
+        true
+      end
+      
+      # Reformats parameters and mixes in some defaults.
+      def defaultize(params)
+        { :upload_for         => "Marketplace",
+          :file_format        =>"TabDelimited",
+          :asin_match_create  => "Y",
+          :asinate            => "Y",
+          :batch_id           => "Y",
+          :email              => "Y"}.each_pair{ |key, value| params[key] = value unless params[key] }
+        # Some Amazon dimwit figured he'd spell this differently
+        if params[:enable_expedited_shipping]
+          params["enable-expedited-shipping"] = params[:enable_expedited_shipping]
+          params.delete(:enable_expedited_shipping)
+        else
+          params["enable-expedited-shipping"] = "Y"
+        end
+        params
+      end
+    
+      def file_content(type=:long)
+        return @file_content if @file_content 
+        case type
+        when :long
+          out = "product-id\tproduct-id-type\titem-condition\tprice\tsku\tquantity\tadd-delete\twill-ship-internationally\texpedited-shipping\titem-note\titem-is-marketplace\tfulfillment-center-id\titem-name\titem-description\tcategory1\timage-url\tshipping-fee\tbrowse-path\tstorefront-feature\tboldface\tasin1\tasin2\tasin3\r\n"
+          @batch.each{ |item| out << item.to_s }
+        when :short
+          out = "sku\tprice\tquantity\r\n"
+          @batch.each{ |item| out << item.to_s(:short) }
+        end
+        @file_content = out
+      end
+    
+      def file_content=(file_content)
+        @file_content = file_content
+      end
+    
+      def <<(item)
+        @batch << item
+      end
+    end
+    
+    class Item
+      attr_accessor :product_id, :product_id_type, :item_condition, :price, :sku, :quantity, :add_delete, :will_ship_internationally, :expedited_shipping, :item_note, :item_is_marketplace, :fulfillment_center_id, :item_name, :item_description, :category1, :image_url, :shipping_fee, :browse_path, :storefront_feature, :boldface, :asin1, :asin2, :asin3
+      
+      def initialize(params={})
+        params.each_pair{ |key, value| send("#{key.to_s}=", value) }
+      end
+      
+      def to_s(type=:long)
+        case type
+        when :long
+          "#{self.product_id}\t#{self.product_id_type}\t#{self.item_condition}\t#{self.price}\t#{self.sku}\t#{self.quantity}\t#{self.add_delete}\t#{self.will_ship_internationally}\t#{self.expedited_shipping}\t#{self.item_note}\t#{self.item_is_marketplace}\t#{self.fulfillment_center_id}\t#{self.item_name}\t#{self.item_description}\t#{self.category1}\t#{self.image_url}\t#{self.shipping_fee}\t#{self.browse_path}\t#{self.storefront_feature}\t#{self.boldface}\t#{self.asin1}\t#{self.asin2}\t#{self.asin3}\r\n"
+        when :short
+          "#{self.sku}\t#{self.price}\t#{self.quantity}\r\n"
+        end
+      end
+    end
+  end
+end

data/lib/peddler/legacy_reports.rb

@@ -0,0 +1,107 @@
+module Peddler
+  # This module contains methods to manage legacy reports -- anything that comes before section 7 in the API docs.
+  module LegacyReports
+    # Returns statuses of most recent reports in an array of OpenStructs.
+    def self.latest(transport,name,params={})
+      transport.legacize_request
+      if name == :upload
+        transport.path << "catalog-upload/get-batches"
+        transport.headers[:number_of_batches] = params[:count] if params[:count]
+      else
+        transport.path << "manual-reports/get-report-status"
+        transport.headers[:report_name] = name.to_s.camelize
+        transport.headers[:number_of_reports] = params[:count] if params[:count]
+      end
+      res = transport.execute_request
+      xml = Peddler::Handlers::XMLHandler.decode_response(res)
+      Peddler::Handlers::XMLHandler.parse_legacy(xml)
+    end
+    
+    # Requests a report to be generated and returns the report instance if request is successful.
+    def self.generate(transport,name,params={})
+      transport.legacize_request
+      transport.path << "manual-reports/generate-report-now"
+      transport.headers[:report_name] = name.to_s.camelize
+      transport.headers.merge!(params)
+      res = transport.execute_request
+      res =~ /SUCCESS/ ? Peddler::LegacyReports::Report.new(transport, name) : false
+    end
+    
+    # A legacy report
+    class Report
+      attr_accessor :name, :id, :product_line, :frequency
+      
+      def initialize(transport, name=nil, params={})
+        @transport, @name = transport, name
+        params.each_pair{ |key, value| self.send "#{key}=", value }
+      end
+      
+      def body
+        return nil if @name == :upload && @id.nil?
+        @body ||= download
+      end
+    
+    private
+      def download
+        return false if @name.nil? && @id.nil?
+        case @name.to_s
+        when "upload"
+          @transport.legacize_request
+          @transport.path << "download/errorlog"
+          @transport.headers["BatchID"] = @id
+          @transport.execute_request
+        else
+          @transport.legacize_request
+          @transport.path << "download/report"
+          if @id.nil?
+            @transport.headers[:report_name] = @name.to_s.camelize
+            if @name == :preorder
+              @transport.headers["productline"] = @product_line if @product_line
+              @transport.headers["frequency"] = @frequency if @frequency
+            end
+          else
+            @transport.headers["ReportID"] = @id
+          end
+          @transport.execute_request
+        end
+      end
+    end
+    
+    class Status < OpenStruct
+      def initialize(input)
+        if input.kind_of? String
+          hash = input.scan(/([a-z]+)=([^=]+)($| )/).inject({}){ |memo, value| memo.merge( { @keymap[value[0]] => value[1].strip }) }
+        end
+        super(hash)
+      end
+    
+      def id
+        @table[:id] || self.object_id
+      end
+    end
+  
+    class ReportStatus < Status
+      def initialize(input)
+        @keymap = {
+          "reportstarttime" => "starts_at",
+          "reportendtime"   => "ends_at",
+          "reportid"        => "id"}
+        super(input)
+      end
+    end
+  
+    class UploadStatus < Status
+      def initialize(input)
+        @keymap = {
+          "status"            => "status",
+          "batchid"           => "id",
+          "numberofwarnings"  => "number_of_warnings",
+          "activateditems"    => "activated_items",
+          "itemsnotacivated"  => "items_not_activated",
+          "itemsnotactivated" => "items_not_activated",
+          "dateandtime"       => "datetime"}
+        super(input)
+      end
+    end
+  end
+end

data/lib/peddler/refunds.rb

@@ -0,0 +1,54 @@
+module Peddler
+  module Refunds
+    # This is a refund batch.
+    class Batch
+      attr_accessor :batch
+      
+      def initialize(transport)
+        @transport = transport
+        @batch = []
+      end
+      
+      def file_content
+        out = "order-id\tpayments-transaction-id\trefund-amount\treason\tmessage\r\n"
+        @file_content = @batch.inject(out){ |memo, item| memo << item.to_s }
+      end
+      
+      def <<(item)
+        @batch << item
+      end
+      
+      def upload
+        raise PeddlerError.new("Batch already uploaded") if @completed
+        @transport.legacize_request
+        @transport.path << "catalog-upload/batch-refund"
+        @transport.body = file_content
+        res = @transport.execute_request
+        @completed = true if res == "<Success>SUCCESS</Success>"
+      end
+      
+    end
+    
+    # This is a refund.
+    class Item
+      REFUND_REASONS = %w{ GeneralAdjustment CouldNotShip DifferentItem MerchandiseNotReceived MerchandiseNotAsDescribed }
+      
+      attr_accessor :order_id, :payments_transaction_id, :refund_amount, :message
+      attr_reader   :reason
+      
+      def initialize(options={})
+        options.each_pair{ |key, value| send("#{key.to_s}=", value) }
+      end
+      
+      def reason=(reason)
+        @reason = reason if REFUND_REASONS.include?(reason)
+      end
+      
+      def to_s
+        "#{self.order_id}\t#{self.payments_transaction_id}\t#{self.refund_amount}\t#{self.reason}\t#{self.message}\r\n"
+      end
+    end
+    
+  end
+  
+end

data/lib/peddler/reports.rb

@@ -0,0 +1,94 @@
+module Peddler
+  # This module generates and downloads unshipped order reports.
+  # I decided to keep this out of Peddler::LegacyReports because the API is quite different.
+  module Reports
+    # This is an unshipped orders report. It's very similar to the feed objects so I'm just porting over the class.
+    # It will have a few stray attributes, but whatever.
+    class UnshippedOrdersReport < Peddler::Feeds::Feed
+      alias         :unshipped_orders :batch
+      attr_accessor :starts_at, :ends_at, :scheduled
+      
+      # Creates new unshipped order report. It literally sends a request to Amazon to generate the
+      # report if the report ID is not already set.
+      def initialize(transport, params={})
+        super(transport)
+        @mapped_params = {
+          "ReportID"                  => "id",
+          "StartDate"                 => "starts_at",
+          "EndDate"                   => "ends_at",
+          "DownloadType"              => "type",
+          "Scheduled"                 => "scheduled",
+          "ReportStatus"              => "status",
+          "SubmittedDate"             => "submitted_at",
+          "StartedProcessingDate"     => "started_processing_at",
+          "CompletedProcessingDate"   => "completed_processing_at",
+          "CompletedProcesssingDate"  => "completed_processing_at"}
+        params.each_pair{ |key, value| self.send "#{key}=", value }
+        @starts_at ||= (Date.today - 7).strftime("%Y-%m-%dT00:00:00-00:00")
+        @ends_at ||= (Date.today + 1).strftime("%Y-%m-%dT00:00:00-00:00")
+        #@type ||= "_GET_CONVERGED_FLAT_FILE_ACTIONABLE_ORDER_DATA_"
+        @type ||= "_GET_FLAT_FILE_ACTIONABLE_ORDER_DATA_"
+        if @id.nil?
+          generate_report
+        end
+        self
+      end
+    private
+      def refresh_status
+        @transport.modernize_request
+        @transport.query_params.merge!({
+          "Action"   => "reportStatus",
+          "reportId" => @id})
+        res = @transport.execute_request
+        process_response(res)
+      end
+      
+      def generate_report
+        @transport.modernize_request
+        @transport.query_params.merge!({
+          "Action"       => "generateReport",
+          "startDate"    => @starts_at,
+          "endDate"      => @ends_at,
+          "downloadType" => @type})
+        res = @transport.execute_request
+        process_response(res)
+      end
+      
+      def process_response(res)
+        xml = Peddler::Handlers::XMLHandler.decode_response(res)
+        params = Peddler::Handlers::XMLHandler.parse(:report, xml)
+        if params[0]
+          params[0].each_pair do |key, value|
+            if key == "ListOfDownloads"
+              params = Peddler::Handlers::XMLHandler.parse(:download, value)
+              @download = Peddler::Feeds::Download.new(@transport, params[0])
+              @batch = Peddler::Handlers::TabDelimitedHandler.decode_response(@download.to_s)
+            else
+              self.send "#{@mapped_params[key]}=", value
+            end
+          end
+        end
+      end
+    end
+    
+    # This is an unshipped order.
+    class Item
+      attr_accessor :order_id, :order_item_id, :quantity, :ship_date, :carrier_name, :tracking_number, :ship_method
+      attr_reader   :carrier_code
+
+      def initialize(params={})
+        params.each_pair{ |key, value| send("#{key}=", value) }
+      end
+      
+      # Validates when setting carrier code.
+      def carrier_code=(carrier_code)
+        @carrier_code = carrier_code if %w{USPS UPS FedEx other}.include?(carrier_code)
+      end
+      
+      # Outputs a formatted line for the tab-delimited upload file.
+      def to_s
+        "#{@order_id}\t#{@order_item_id}\t#{@quantity}\t#{@ship_date}\t#{@carrier_code}\t#{@carrier_name}\t#{@tracking_number}\t#{@ship_method}\r\n"
+      end
+    end
+  end
+end

data/lib/peddler/transport.rb

@@ -0,0 +1,135 @@
+module Peddler
+  class PeddlerError < StandardError
+    def initialize(msg)
+      super("#{msg}")
+    end
+  end
+  
+  # Our work horse. Runs on top of Net::HTTP.
+  class Transport
+    API_HOSTS       = {:us => "secure.amazon.com",
+                       :uk => "secure.amazon.co.uk",
+                       :de => "secure.amazon.de",
+                       :ca => "secure.amazon.ca",
+                       :fr => "secure.amazon.fr",
+                       :jp => "vendornet.amazon.co.jp" }
+    BASE_HEADERS    = {"User-Agent"    => "Peddler/#{Peddler::VERSION}",
+                       "Content-Type"  => "text/xml;charset=utf-8",
+                       "Cookie"        => "x-main=YvjPkwfntqDKun0QEmVRPcTTZDMe?Tn?; ubid-main=002-8989859-9917520; ubid-tacbus=019-5423258-4241018;x-tacbus=vtm4d53DvX@Sc9LxTnAnxsFL3DorwxJa; ubid-tcmacb=087-8055947-0795529; ubid-ty2kacbus=161-5477122-2773524; session-id=087-178254-5924832;session-id-time=950660664"}
+    
+    BASE_PARAMS = {
+      "Service" => "MerchantQueryService"
+    }
+    
+    attr_writer   :username, :password
+    attr_accessor :path, :query_params, :headers, :body
+    
+    #Returns request instance
+    def request
+      req = request_method.new("#{self.path.gsub(/\/$/, "")}/#{self.query_string}")
+      self.headers.each do |header, value|
+        if header.kind_of? Symbol
+          req[header.to_s.gsub(/_/, "")] = value
+        else
+          req[header] = value
+        end
+      end
+      req.basic_auth(@username, @password) if @username && @password
+      req.body = self.body unless self.body.empty?
+      req
+    end
+    
+    def execute_request
+      begin
+        self.conn.start do |http|
+          res = http.request(self.request)
+          case res
+          when Net::HTTPSuccess
+            res.body
+          else
+            raise PeddlerError.new(res.body)
+          end
+        end
+      end
+    end
+    
+    def clear_request
+      self.headers = BASE_HEADERS.dup
+      self.body = ""
+    end
+    
+    def legacize_request
+      self.clear_request
+      self.path = "/exec/panama/seller-admin/"
+      self.query_params = {}
+    end
+    
+    def modernize_request
+      self.clear_request
+      self.path = "/query/"
+      self.query_params = BASE_PARAMS.dup
+    end
+    
+    def region=(region)
+      @conn = nil
+      region = region.to_sym
+      if API_HOSTS.has_key?(region)
+        @region = region
+      else
+        raise PeddlerError.new("Region not recognized")
+      end
+    end
+    
+    def url
+      URI.parse("https://#{self.host}#{self.path.gsub(/\/$/, "")}/#{self.query_string}")
+    end
+    
+    def dump_headers(msg)
+      msg.each_header do |key, value|
+        p "#{key}=#{value}"
+      end
+    end
+    
+  protected
+    #Returns the Net::HTTP instance.
+    def conn
+      if @conn
+        @conn
+      else
+        conn = Net::HTTP.new(host, 443)
+        conn.use_ssl = true
+        conn.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        @conn = conn
+      end
+    end
+    
+    def request_method
+      if !self.body.empty? || !self.query_params.empty?
+        Net::HTTP::Post
+      else
+        Net::HTTP::Get
+      end
+    end
+    
+    def host
+      API_HOSTS[@region]
+    end
+    
+    def query_string
+      unless query_params.empty?
+        query_params.inject("?") do |out, pair|
+          key, value = pair
+          key = key.to_s.gsub(/_([a-z])/) { $1.upcase } if key.kind_of? Symbol
+          value = value.httpdate if value.respond_to? :httpdate
+          out += "&" if out.size > 1
+          "#{out}#{url_encode(key)}=#{url_encode(value)}"
+        end
+      end
+    end
+    
+    def url_encode(value)
+      require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
+      CGI.escape(value.to_s)
+    end
+  end
+end