We have used Acts As Amazon Product in production, as have other stellar Ruby on Rails consultancies. We hope that you find it as helpful as we have. And true to the open source nature of the project, if you have any ideas on how we can make AAAP better, by all means, submit a pull request!

For more information on AAAP, check out the project page on Github. Enjoy!

The technology behind it is really quite remarkable. Netphase’s proprietary solution takes into account the available inventory of the seller, who typically will be an average user with products in their possession that they wish to resell. It prevents shopping cart conflicts, yet also considers how long a prospective buyer is allowed to keep an item in his cart before the item is returned back to the active inventory for others to purchase. Bottom line is that it strives to strike the difficult balance of allowing a seller to have inventory tied up by only those wanting to purchase, and also of allowing a buyer with an item in her cart to shop with confidence, knowing that when she checks out, the item is in fact hers.

Other features of WeSell protect both the buyer and seller by way of a built-in transaction escrow system. It is fully secure, deployed in the infinitely scalable Amazon EC2 Cloud, and of course, it runs on Ruby on Rails.

About Homeschool Apple

The Homeschool Apple mission is to be an oasis for homeschoolers on the internet. HSA seeks to provide a one-stop place where homeschoolers can sell their used, new, self-published or downloadable curriculum, connect with others, and share their talents with the world. While far from complete, Homeschool Apple is well on its way, with the most unique homeschool store on the Web and a rock-solid platform on which to build. The site is currently in public Beta, and homeschoolers are encouraged to sign up for their FREE account now. Pass the word to your friends, won’t you?

First, we got some participation from David Eisinger to help improve testing and some other critical features. Thanks, David! Recently though, we added some new functionality we had lying around in an old plugin called acts_as_amazonable.

The new functionality allows you to load Amazon product attributes into a new or existing model object on your system. You can define which fields are loaded, and which attributes in your model they map to. We are using this functionality on a new double-secret project that we are working on, and it is great. In that project, we are letting our users type in an ISBN code, and we pre-populate a form with all of the Amazon data we want for that product, saving the user from a lot of typing. We also pick up the images, so they don’t even have to load an image to sell their item. Pretty cool!

Here’s how you use aaap’s new functionality:

require 'acts_as_amazon_product'
 
 class LocalBook < ActiveRecord::Base
   acts_as_amazon_product(
     :asin => 'isbn', :name => 'title',
     :access_key => '0123456', :associate_tag => 'assoc-20',
     :auto_load_fields => {
         :title => 'title',
         :isbn => 'asin',
         :publisher_name => 'manufacturer',
         :author => 'author'}
   )
 end

The keys in the auto_load_fields hash are the fields in your object, and the values are their Amazon equivalents. In the true Rails convention over configuration spirit, we have included some of the most popular auto load fields as defaults. If your object contains the following attributes, they will automatically be loaded with their Amazon equivalents:

:auto_load_fields => {
     :title => 'title',
     :isbn => 'asin',
     :publisher_name => 'manufacturer',
     :author => 'author',
     :binding => 'binding',
     :list_price => 'listprice/amount',
     :pages => 'numberofpages',
     :description => 'content',
     :small_image_url => 'smallimage/url',
     :medium_image_url => 'mediumimage/url',
     :large_image_url => 'largeimage/url',
     :detail_url => 'detailpageurl'
}

Don’t worry if your object does not have some or most of these fields; Acts as Amazon Product is smart enough to check to see if the method exists before attempting to load up the Amazon value.

Now, if by some coincidence you have some fields in your local object that have the same name as our auto_load defaults, you can choose to specifically ignore those fields using, you guessed it, :ignore_fields. :ignore_fields is a simple array of fields in your object that you do NOT want to be replaced with the Amazon equivalent. You would specify them like this:

acts_as_amazon_product(
    :asin => 'isbn', :name => 'title',
    :access_key => '0123456', :associate_tag => 'assoc-20',
    :ignore_fields => [:small_image_url, :medium_image_url]
  )

In this instance, the object in question would load Amazon info for any of the default fields that the object has, with the exception of the small_image_url and medium_image_url values.

To load the Amazon values into your object for local storage, you may call the following methods:

load_from_amazon(title_or_asin, by_title = false)
load_from_amazon!(title_or_asin, by_title = false)

The two methods do exactly the same thing, except the first simply returns a new, unsaved object with its Amazon-like fields loaded with their appropriate Amazon values. The second version (load_from_amazon!) goes one step further and saves the object for good measure.

You may pass either an isbn (asin) or a title in. If you are passing a title, you need to specify that you are passing a title by also passing true as the second parameter so we will perform an item_search rather than an item_lookup. Note that passing a title is risky business, since currently the code will take the first result returned and load that into your object. So unless your title is unique, I would recommend sticking with the isbn (asin) value.

Since that is the default, all you need to do would be something like this:

@local_book = LocalBook.load_from_amazon('1590598415')

If your object was similar to the LocalBook object in our example, for instance, you would not need to specify the auto_load_fields in the acts_as call at all. The title, isbn, publisher_name and author methods would automatically be called once you call load_from_amazon, and their values populated appropriately.

It is important to note that if you call load_from_amazon with an invalid asin, you will simply get back an empty object.

Now, calling load_from_amazon still allows you to take advantage of the other Acts as Amazon features, like the dynamic loading of Amazon attributes on the fly by using the various amazon.foo methods as it always has.

All that’s necessary to integrate any of your existing models with Amazon is to add a require line to the top of your model file and then an acts_as_amazon_product line just inside your class definition.

require 'acts_as_amazon_product'
 
class Book < ActiveRecord::Base
  acts_as_amazon_product(
      :asin => 'isbn', :name => 'title', 
      :access_key => '0123456', 
      :associate_tag => 'assoc-20')
end

After this, you can access Amazon data in your controllers or views like this:

@book = Book.new(:title => 'Getting Things Done')
@book.amazon.isbn
@book.amazon.title
@book.amazon.author
@book.amazon.small_image_url
 
@book.amazon.get('itemattributes/foobar')

The code does not require changing any current database tables. It only requires adding one migration for a single new table used to cache responses from Amazon:

ActiveRecord::Base.connection.create_table :amazon_products do |t|
  t.column :asin, :string
  t.column :xml, :text
  t.column :created_at, :datetime
  t.column :amazonable_id, :integer
  t.column :amazonable_type, :string
end