Class: Peddler::Client

Inherits:
Object
  • Object
show all
Defined in:
lib/peddler/client.rb

Overview

This is the public interface of the Peddler library.

Instance Method Summary collapse

Constructor Details

#initialize(params = {}) ⇒ Client

Creates a client instance.

client = Peddler::Client.new(
  :username => '[email protected]',
  :password => 'secret',
  :region   => 'us'
)



16
17
18
 
# File 'lib/peddler/client.rb', line 16

def initialize(params={})
  params.each_pair { |key, value| self.send("#{key}=", value.to_s) }
end

Instance Method Details

#detab(msg) ⇒ Object

Decodes tab-delimited content into an array of OpenStruct objects.



227
228
229
 
# File 'lib/peddler/client.rb', line 227

def detab(msg)
  Peddler::Handlers::TabDelimitedHandler.decode_response(msg)
end

#generate_report(name, params = {}) ⇒ Object

Requests a report. Returns true when successful.

Possible report names: [:order, :open_listings, :open_listings_lite, :open_listings_liter]

client.generate_report :order, :number_of_days => 15

A word of caution. Open listings may crap up with larger inventories.



197
198
199
 
# File 'lib/peddler/client.rb', line 197

def generate_report(name,params={})
  Peddler::LegacyReports.generate(self.transport, name, params)
end

#inventory_queue ⇒ Object

Returns count of pending inventory uploads queued at Amazon.



76
77
78
 
# File 'lib/peddler/client.rb', line 76

def inventory_queue
  Peddler::Inventory::Queue.count(self.transport)
end

#latest_reports(name, params = {}) ⇒ Object

Returns status of most recent reports. Optional “count” defaults to 10. Name can be [ :upload, :order, :batch_refund, :open_listings, :open_listings_lite, :open_listings_liter ].

reports = client.latest_reports :order, :count => 1
reports[0]
=> #<Peddler::LegacyReports::ReportStatus starts_at="07-29-2009:10-00-06" ...



222
223
224
 
# File 'lib/peddler/client.rb', line 222

def latest_reports(name,params={})
  Peddler::LegacyReports.latest(self.transport, name, params)
end

#new_cancelled_order(params = {}) ⇒ Object

Creates an item that can then be added to an order cancellation feed. Keys are lowercased and underscored but otherwise the same as Amazon’s headers. See section 7.4 in the API docs.



127
128
129
 
# File 'lib/peddler/client.rb', line 127

def new_cancelled_order(params={})
  Peddler::Feeds::OrderCancellation::Item.new(params)
end

#new_fulfilled_order(params = {}) ⇒ Object

Creates an item that can then be added to an order fulfillment feed. Keys are lowercased and underscored but otherwise the same as Amazon’s headers. See section 7.1 in the API docs.



101
102
103
 
# File 'lib/peddler/client.rb', line 101

def new_fulfilled_order(params={})
  Peddler::Feeds::OrderFulfillment::Item.new(params)
end

#new_inventory_batch ⇒ Object

Creates an inventory batch.

batch = client.new_inventory_batch
book = new_inventory_item(

  :product_id => “1234567890”,

  :sku        => "SKU-001",
  :price      => 10.00,
  :quantity   => 1)
batch << book
batch.upload

Once the batch is processed, you may view the report:

report = client.new_report :upload, :id => batch.id
p report.body
=> "Feed Processing Summary:\n\tNumber of records processed\t\t1\n\tNumber of records successful\t\t1\n\n"



55
56
57
 
# File 'lib/peddler/client.rb', line 55

def new_inventory_batch
  Peddler::Inventory::Batch.new(self.transport.dup)
end

#new_inventory_item(params = {}) ⇒ Object

Creates an inventory item. Parameter keys are lowercased and underscored but otherwise the same as the colum titles in the tab-delimited upload templates provided by Amazon.



71
72
73
 
# File 'lib/peddler/client.rb', line 71

def new_inventory_item(params={})
  Peddler::Inventory::Item.new(params)
end

#new_order_cancellation_feed ⇒ Object

feed << cancelled_order

feed.upload
feed.status
=> "_SUBMITTED_"
sleep(60)
feed.status!
=> "_DONE_"
p feed.download.to_s



121
122
123
 
# File 'lib/peddler/client.rb', line 121

def new_order_cancellation_feed
  Peddler::Feeds::OrderCancellation::Batch.new(self.transport.dup)
end

#new_order_fulfillment_feed ⇒ Object

Creates an order fulfillment batch.

feed = client.new_order_fulfillment_feed
fulfilled_order = client.new_fulfilled_order(
  :order_id    => "123-1234567-1234567",
  :order_date  => "2009-08-01")
feed << fulfilled_order
feed.upload
feed.status
=> "_SUBMITTED_"
sleep(60)
feed.status!
=> "_DONE_"
p feed.download.to_s



95
96
97
 
# File 'lib/peddler/client.rb', line 95

def new_order_fulfillment_feed
  Peddler::Feeds::OrderFulfillment::Batch.new(self.transport.dup)
end

#new_refund(params = {}) ⇒ Object

Creates a refund item that can then be added to a refund batch.

Possible reasons: [“GeneralAdjustment”, “CouldNotShip”, “DifferentItem”, “MerchandiseNotReceived”, “MerchandiseNotAsDescribed”]



157
158
159
 
# File 'lib/peddler/client.rb', line 157

def new_refund(params={})
  Peddler::Refunds::Item.new(params)
end

#new_refund_batch ⇒ Object

Creates a refund batch.

batch = client.new_refund_batch
refund = client.new_refund(
  :order_id                 => "123-1234567-1234567",
  :payments_transaction_id  => "12341234567890",
  :refund_amount            => 10.00,
  :reason                   => "CouldNotShip",
  :message                  => "With our apologies.")
batch << refund
batch.upload
sleep(60)
status = client.latest_reports :batch_refund, :count => 1
report = client.new_report(
  :batch_refund,
  :id => status[0].id)
p report.body
=> "123-1234567-1234567order-item-id: 12341234567890\tSUCCESS 10.00 is Refunded.\r\n"



150
151
152
 
# File 'lib/peddler/client.rb', line 150

def new_refund_batch
  Peddler::Refunds::Batch.new(self.transport.dup)
end

#new_report(name, params = {}) ⇒ Object

Creates an instance for an already-generated report. Works only with legacy reports, meaning anything that comes before section 7 in the API docs.

Possible report names: [:upload, :order, :preorder, :batch_refund, :open_listings, :open_listings_lite, :open_listings_liter]

You can download a specific report by using its ID. Otherwise, the instance will fetch the latest available report. One oddball exception: Upload reports do require an ID and will return nil if you don’t provide one.

orders_report = client.new_report :order
orders = client.detab(orders_report.body)
orders[0].buyer_name
=> "John Doe"

preorders_report = client.new_report(

  :preorder,

  :product_line  => "Books",
  :frequency     => 2)
preorders = client.detab(preorders_report.body)
preorders[0].average_asking_price
=> "100"



186
187
188
 
# File 'lib/peddler/client.rb', line 186

def new_report(name,params={})
  Peddler::LegacyReports::Report.new(self.transport.dup, name, params)
end

#new_unshipped_orders_report(params = {}) ⇒ Object

Creates an unshipped order report. Takes on some optional parameters, such as :id, :starts_at, :ends_at. By default, it will request a new unshipped order report for the past seven days.

report = client.new_unshipped_orders_report
report.status
=> "_SUBMITTED_"
sleep(60)
report.status!
=> "_DONE_"
p report.unshipped_orders



212
213
214
 
# File 'lib/peddler/client.rb', line 212

def new_unshipped_orders_report(params={})
  Peddler::Reports::UnshippedOrdersReport.new(self.transport.dup, params)
end

#password=(password) ⇒ Object

Sets password.



26
27
28
 
# File 'lib/peddler/client.rb', line 26

def password=(password)
  self.transport.password = password
end

#purge_inventory ⇒ Object

A short-hand method to purge inventory.

client.purge_inventory



63
64
65
66
67
 
# File 'lib/peddler/client.rb', line 63

def purge_inventory
  empty_batch = Peddler::Inventory::Batch.new(self.transport.dup)
  empty_batch.upload(:method => 'purge')
  
end

#region=(region) ⇒ Object

Sets Amazon region.

client.region = :jp



34
35
36
 
# File 'lib/peddler/client.rb', line 34

def region=(region)
  self.transport.region = region.to_s
end

#username=(username) ⇒ Object

Sets username.



21
22
23
 
# File 'lib/peddler/client.rb', line 21

def username=(username)
  self.transport.username = username
end