Phil and I just finished working on a new site for good friend, Chris Heinz. Phil put together the design, and I made it happen with Expression Engine. Take a look at csheinz.com.
A newly released site, known as Smatchy (www.smatchy.com), presents an interesting take on recommendations and could become more of the standard than the exception.
Smatchy’s premise revolves around users answering questions and then calculating ‘People Like Me’ for users in fourteen different categories. This ‘People Like Me’ statistic drives almost every feature on the site, linking people together based on how similar they are and not any user-defined criteria. While the math behind this seems to be fairly in-depth, the site has produced a slick interface to navigate all of the options, making everything from figuring out your ‘Smatches’ to querying the dataset fun.
So how do the recommendations fare? Well, pretty well, to be honest. Especially when you consider a lot of the questions are addictive and fun (unlike a strict ranking system). My favorites ones to answer included:
For recommendations, you get the choice of either ‘Normal’ or ‘Obscure’ methodology. While the Normal are good, the real gems are in the Obscure, where unique books, movies, and music are pulled from user’s profiles based upon your matching. Finally, the Forum makes good use of the system with how well individual authors match up to you being displayed alongside the post.
Ruby on Rails is the power behind Smatchy, and does a good job on handling the extensive database while keeping the navigation fun and easy. Rails development being what it is made it fairly quick and painless to put Smatchy on Rails!
As more and more people latch on to this concept, you could just see a better way to get recommendations and interact with other searchers.
[Note: I was personally involved with the site’s Rails development.]
The controller for this exercise includes two methods. One for displaying the main page, and a second for generating the select box. Let’s start with the page. We’ll call it order_list:
def order_list
end
That was easy. Nothing here. You’ll see why in the view.
Now for the second method to populate the second select box:
def fill_orders_box
results = Order.find_all_by_customer_id(@params[:customer_id])
render :partial => ‘options’
end
There’s a few things here that I wanted to comment on. The first is the find command on the Order model. ActiveRecord does this very slick translation when you use the findallby_ or findby followed by the column to search on. When ActiveRecord sees this, it automagically translates it to the equivalent search string. For instance the above example translates to:
@results = Order.find(:all,
:conditions => [“customer_id = ?”, @params[:customer_id])
Now let’s be honest… that’s pretty cool.
The second thing is the use of the partial. In this example I’m using a partial to fill in the select box option tags. This command makes that happen.
Enjoy the View
The view is where I create the form and put in the first select box, the placeholder for the second select box and the AJAX commands to tie them all together. Here’s the code:
<%= javascript_include_tag “prototype” %>
<select id=“order[customer_id] name=“order[customer_id]”>
<%= options_from_collection_for_select(
Customer.find_all_by_customername, “id”, “customername”) %>
</select>
<span id=“order_id_list”>
<select id=“order_id” name=“order[id]”></select>
</span>
<%= observe_field(“order[customer_id]”,
:frequency => 0.25,
:update => “order_id_list”,
:url => {:action => :get_orders},
:with => “‘customer_id=’+value”)
%>
So theres a few things to discuss here. At the top is the javascript_include tag. This is telling the view to use the prototype javascript file in the rails package to handle the AJAX calls. Don’t forget this, it’s what you call ‘important’.
The first select box is straight-forward, but it’s filled with another slick rails deal. Optionsfromcollectionforselect takes the first parameter (note the findallby thing again) to get the recordset to fill it with (hence nothing in the controller for this), the id field is next, and lastly the text for the option statement. Very slick indeed!
Next we have the placeholder for the second select box. In this case I used a span, but div will work too. Then I put an empty select box so that it’s there from the start, you can leave this out if you want it to appear when you click a customer in the first box. Also worth mentioning here is something Rory said on his site, you can’t change the innerHTML of a select box in IE, so that’s the reason for the span, we’ll change what’s in there with the partial.
Now for the AJAX. The last part is the listener. This makes it so the page is always looking for the first select box to change. It looks at the frequency of once ever .25 seconds. When it senses a change, it calls the URL with the included with value as a key and updates the orderidlist span. There’s a bunch of magic that happens in the background, but let’s face it, that’s the best part about rails!
Partial Credit
The last part is the partial. This file is called _options.rhtml. Note the underscore…this is what makes a partial a partial. Because DHH said so.
<select id=“order_id” name=“order[id]”>
<% for order in @results do -%>
<option value=”<%=order.id %>” >
<%= order.order_number %>
</option>
<% end -%>
</select>
That’s it. Here we generate the select box, loop through the records that are sent from the controller and create a slew of option tags.
So there you have it. As I said before, I’m fairly new to rails and ruby, so if you find flaws in my code (which shouldn’t surprise you) please leave a comment and let me know. I hope this helps someone!
