peddler 0.1.3

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

data/lib/peddler.rb

@@ -0,0 +1,25 @@
+# Peddler is a Ruby wrapper to the Amazon Inventory management API.
+module Peddler
+  VERSION = "0.1"  
+end
+
+class String #:nodoc: all
+  def camelize
+    self.gsub(/(^|_)(.)/) { $2.upcase }
+  end
+end
+
+require "net/https"
+require "ostruct"
+require "tempfile"
+require "time"
+require "xmlsimple"
+
+require File.dirname(__FILE__) + "/peddler/client"
+require File.dirname(__FILE__) + "/peddler/handlers"
+require File.dirname(__FILE__) + "/peddler/feeds"
+require File.dirname(__FILE__) + "/peddler/inventory"
+require File.dirname(__FILE__) + "/peddler/legacy_reports"
+require File.dirname(__FILE__) + "/peddler/refunds"
+require File.dirname(__FILE__) + "/peddler/reports"
+require File.dirname(__FILE__) + "/peddler/transport"

data/peddler.gemspec

@@ -0,0 +1,80 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{peddler}
+  s.version = "0.1.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Hakan Senol Ensari"]
+  s.date = %q{2009-11-06}
+  s.description = %q{Peddler is a Ruby wrapper to the Amazon Inventory Management API.}
+  s.email = %q{hakan.ensari@papercavalier.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "History.txt",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION.yml",
+     "init.rb",
+     "lib/peddler.rb",
+     "lib/peddler/client.rb",
+     "lib/peddler/feeds.rb",
+     "lib/peddler/handlers.rb",
+     "lib/peddler/inventory.rb",
+     "lib/peddler/legacy_reports.rb",
+     "lib/peddler/refunds.rb",
+     "lib/peddler/reports.rb",
+     "lib/peddler/transport.rb",
+     "peddler.gemspec",
+     "spec/peddler/client_spec.rb",
+     "spec/peddler/feeds_spec.rb",
+     "spec/peddler/handlers_spec.rb",
+     "spec/peddler/inventory_spec.rb",
+     "spec/peddler/legacy_reports_spec.rb",
+     "spec/peddler/refunds_spec.rb",
+     "spec/peddler/reports_spec.rb",
+     "spec/peddler/transport_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://snl.github.com/peddler}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{A Ruby wrapper to the Amazon Inventory Management API}
+  s.test_files = [
+    "spec/peddler/client_spec.rb",
+     "spec/peddler/feeds_spec.rb",
+     "spec/peddler/handlers_spec.rb",
+     "spec/peddler/inventory_spec.rb",
+     "spec/peddler/legacy_reports_spec.rb",
+     "spec/peddler/refunds_spec.rb",
+     "spec/peddler/reports_spec.rb",
+     "spec/peddler/transport_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<xml-simple>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+    else
+      s.add_dependency(%q<xml-simple>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<xml-simple>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+  end
+end
+

data/spec/peddler/client_spec.rb

@@ -0,0 +1,47 @@
+require File.join(File.dirname(__FILE__), "/../spec_helper") 
+
+module Peddler
+  
+  describe Client do 
+    
+    before(:each) do
+      @client = Peddler::Client.new :username => "seller@example.com",
+                                    :password => "secret",
+                                    :region   => "us"
+    end
+      
+    it "should return a new inventory batch" do
+      @client.new_inventory_batch.should be_an_instance_of(Peddler::Inventory::Batch)
+    end
+    
+    it "should return a new inventory item" do
+      @client.new_inventory_item.should be_an_instance_of(Peddler::Inventory::Item)
+    end
+    
+    it "should return a new order fulfillment feed" do
+      @client.new_order_fulfillment_feed.should be_an_instance_of(Peddler::Feeds::OrderFulfillment::Batch)
+    end
+    
+    it "should return a new fulfilled order" do
+      @client.new_fulfilled_order.should be_an_instance_of(Peddler::Feeds::OrderFulfillment::Item)
+    end
+    
+    it "should return a new order cancellation feed" do
+      @client.new_order_cancellation_feed.should be_an_instance_of(Peddler::Feeds::OrderCancellation::Batch)
+    end
+    
+    it "should return a new cancelled order" do
+      @client.new_cancelled_order.should be_an_instance_of(Peddler::Feeds::OrderCancellation::Item)
+    end
+    
+    it "should return a new refund batch" do
+      @client.new_refund_batch.should be_an_instance_of(Peddler::Refunds::Batch)
+    end
+    
+    it "should return a new report" do
+      @client.new_report(:foo).should be_an_instance_of(Peddler::LegacyReports::Report)
+    end
+    
+  end
+  
+end