Cody Fauser - Show all

Payment Processing with ActiveMerchant

2008-11-19T12:55:00Z

Today I gave my presentation on Payment Processing with ActiveMerchant at the Voices that Matter Professional Ruby Conference. The conference has a wonderful intimate atmosphere, similar to RubyFringe, and follows the same single track format. Download the slides.

Presenting at Voices that Matter: Professional Ruby Conference

2008-10-03T00:25:00Z

I will be doing a presentation on payment processing with Active Merchant at the Voices that Matter: Professional Ruby Conference a.k.a. ObieConf. The conference is running from November 17-20, 2008 in Boston, MA. The list of speakers looks very impressive.

If you're interested in attending the conference you can use the discount code PRDPKRL to get a $200 discount on registration. Hope to see you there!

Ruby Presentation for Open Source Bootcamp

2008-08-29T14:42:00Z

Last night I gave a presentation on Ruby for Open Source Bootcamp #8. The event was held at The Code Factory, a very impressive co-working space in downtown Ottawa. I went on last after Yanick Champoux, who presented on Perl, and Michael P. Soulier, who presented on Python. Both presentations were excellent.

I had forgotten how eerily similar Perl’s syntax is to Ruby. I was speaking with Michael after the talks and he mentioned that this actually causes quite a lot of trouble for people fluent in Perl when moving to Ruby. He mentioned that quite a few times he would write out a Perlism in Ruby, but that the code just wouldn’t behave as expected. For example, the fact that 0 is true in Ruby causes a lot of grief when writing idiomatic Perl.

The other thing I noticed was that although Ruby and Python people are always having huge flame wars about which language is better, both groups have similar goals: to rapidly develop applications, and to enjoy themselves while doing it. Although at this point I favour the syntax of Ruby over Python, I am definitely interested in doing a full project with Python in the future.

You can download the slides and you can get the videos, once available, from the page for the event

Excellent Git Presentation at OGRE

2008-07-15T14:07:00Z

Bart Trojanowski was kind enough to come to our Ottawa Ruby meeting OGRE and do a presentation Git.

I had seen Bart present a few years ago at an OCLUG meeting here in Ottawa and he was very knowledgeable and a great presenter. Therefore, I was was very excited to see him do a presentation on Git. The presentation was fantastic and my level of Git knowledge was increased significantly, especially my understanding of how Git works internally.

The entire presentation was recorded as a screencast and there is also a PDF version of the slides. I would definitely recommend checking them out.

Rails HTTP Status Code to Symbol Mapping

2008-07-04T09:43:00Z

Recently I had been wondering what the complete list of HTTP status code symbols was in Rails. Searching through Rails didn't yield any results for a symbol like :unprocessable_entity. Digging around in the Rails source code I found the file actionpack/lib/action_controller/status_codes.rb, which has the mapping of the status code to the status message. Then Rails defines the symbol to status code mapping dynamically from the status message.

The symbol used is an underscored version of the status message with no spaces. A quick Ruby script yields the following mapping:

Status Code	Status Message	Symbol
1xx Informational
100	Continue	:continue
101	Switching Protocols	:switching_protocols
102	Processing	:processing

2xx Success
200	OK	:ok
201	Created	:created
202	Accepted	:accepted
203	Non-Authoritative Information	:non_authoritative_information
204	No Content	:no_content
205	Reset Content	:reset_content
206	Partial Content	:partial_content
207	Multi-Status	:multi_status
226	IM Used	:im_used

3xx Redirection
300	Multiple Choices	:multiple_choices
301	Moved Permanently	:moved_permanently
302	Found	:found
303	See Other	:see_other
304	Not Modified	:not_modified
305	Use Proxy	:use_proxy
307	Temporary Redirect	:temporary_redirect

4xx Client Error
400	Bad Request	:bad_request
401	Unauthorized	:unauthorized
402	Payment Required	:payment_required
403	Forbidden	:forbidden
404	Not Found	:not_found
405	Method Not Allowed	:method_not_allowed
406	Not Acceptable	:not_acceptable
407	Proxy Authentication Required	:proxy_authentication_required
408	Request Timeout	:request_timeout
409	Conflict	:conflict
410	Gone	:gone
411	Length Required	:length_required
412	Precondition Failed	:precondition_failed
413	Request Entity Too Large	:request_entity_too_large
414	Request-URI Too Long	:request_uri_too_long
415	Unsupported Media Type	:unsupported_media_type
416	Requested Range Not Satisfiable	:requested_range_not_satisfiable
417	Expectation Failed	:expectation_failed
422	Unprocessable Entity	:unprocessable_entity
423	Locked	:locked
424	Failed Dependency	:failed_dependency
426	Upgrade Required	:upgrade_required

5xx Server Error
500	Internal Server Error	:internal_server_error
501	Not Implemented	:not_implemented
502	Bad Gateway	:bad_gateway
503	Service Unavailable	:service_unavailable
504	Gateway Timeout	:gateway_timeout
505	HTTP Version Not Supported	:http_version_not_supported
507	Insufficient Storage	:insufficient_storage
510	Not Extended	:not_extended

Update

The cheat gem contains a cheat sheet for the status codes. You can get the gem and view the status codes as follows:


sudo gem install cheat
cheat status_codes

Thanks for the info Josh.

ActiveMerchant on GitHub

2008-05-20T19:12:00Z

The ActiveMerchant source repository has made the move over to GitHub. I think the social development GitHub provides will be a perfect fit for ActiveMerchant. We’ve also moved the ActiveMerchant bug tracker over to Lighthouse.

If you’re looking to get up to speed on payment processing and payment processing with ActiveMerchant then be sure to check out my PeepCode ActiveMerchant PDF which was given a very favorable review at RubyInside.

Shopify.info Redesigned

2008-01-25T21:16:00Z

Daniel, our designer, has just finished the redesign of the Shopify brochure page and it looks fantastic. The page features a beautiful redesign, fantastic video overview of some of Shopify's features, as well as profiles and interviews with some of Shopify's highest profile clients. If you're in the market for an e-commerce store or if you're into eye candy then you'll definitely want to go and check it out.

PayPal Express Payments with ActiveMerchant

2008-01-17T13:00:00Z

There is a lot of confusion over the myriad of services that PayPal offers for accepting PayPal payments. In reality there are two ways of accepting PayPal payments.

PayPal Website Payments Standard

Website Payments Standard is the basic service PayPal offers for accepting PayPal payments. Website Payments Standard requires the creation of an HTML form that is posted to PayPal. The user is redirected to the PayPal website where they complete their payment. They are then redirected back to the seller's website at the end of the process where it is possible to display an order confirmation, or other information. Very basic, easy to setup, but also quite limited.

PayPal Express

PayPal Express is a much more powerful alternative to PayPal Website Payments Standard. The downside is that it is slightly more complicated. However, I am going to show how easy it is to get PayPal Express working with ActiveMerchant. PayPal Express has several benefits including support for Authorization and Capture. Website Payments Standard also has support for Authorization and Capture, but the seller has to actually login to their PayPal account to capture the funds. PayPal Express also keeps control of the payment flow on your page, instead of PayPal's. The user is only redirected to PayPal briefly to confirm payment, and then they are sent back to the seller's page to complete the payment. There are several advantages to this, but I think the biggest is that you can rely on PayPal to provide address information for the buyer and then determine additional shipping or other charges to add to the total of the order.

Now that I've provided a bit of background on PayPal Express I'm going to show how simple it is to integrate into Rails application. The code is based on the integration of PayPal Express into Shopify. The applicable integration points from the PayPal Express Checkout Integration Guide will be noted throughout the example. If you like you can download the completed Sprockets application sprockets.tar.gz. You will need at least Rails 2.0.2 Gems to run the Sprockets application. You will only need to add your API credentials into the application, which is described in the example text.

First, in order to use the sandbox, you'll need a PayPal Sandbox buyer and seller to work with. See Sandbox Testing for more information on getting these accounts setup. The seller account must be either a Premier Account or Business Account in order to work with PayPal Express. Don't forget to activate the account using the Test Email link in Developer Central. Email isn't really sent in the sandbox. It just accumulates in the Developer Central inbox. Then you'll have to confirm your bank account using the Get Verified link while logged in as the test user.

Create a new Rails application. I am going to name my project Sprockets, which is what I'll be selling on my site:


$ rails sprockets

Now you can enter the project and install ActiveMerchant as a plugin:


$ cd sprockets
$ ./script/plugin install http://activemerchant.googlecode.com/svn/trunk/active_merchant

The first thing to do is to configure ActiveMerchant. By default ActiveMerchant uses the production environment of a payment gateway, so we have to force ActiveMerchant into test mode while we're running in the Rails development environment. This is easily accomplished by opening up config/environments/development.rb and adding the following code to the bottom of the file:

123	config.after_initialize do ActiveMerchant::Billing::Base.mode = :testend

The preceding code ensures that the PayPal Sandbox will be used for the test payments, and waits until the entire application is loaded before doing the configuration.

The next thing to do is to login to the PayPal Sandbox and launch the sandbox for the seller account you previously created. Click the My Account link followed by the Profile _ link. Then click _API Access underneath Account Information. Select Request API signature and then click Agree and Submit. Record the API username, API Password, and Signature. We'll be using them shortly.

Now that all of the configuration has been completed we can move onto actually accepting payments. Let's generate a controller PaymentsController that will be used to accept the payments from PayPal.


$ ./script/generate controller payments index confirm complete

We created the controller with the action index, confirm, complete actions in the controller along with their associated views. Let's open up the index.html.erb template and add the PayPal Express logo that the customer will click to make payment.

The first thing we need to do is include the ActiveMerchant::Billing namespace into the controller so that we can access the classes from ActiveMerchant with less typing:

123	class PaymentsController < ApplicationController include ActiveMerchant::Billingend

I'm assuming that you have created a common layout, such as application.html.erb to provide the required HTML structure for the page. The index action represents Integration Point 1a from the Integration Guide. index.html.erb looks as follows:

<h1>Purchase Sprockets</h1>
<p>Thank you for your decision to purchase our sprockets.</p>
<p>Your order total is $50.00</p>
<p>
  <%= link_to image_tag('https://www.paypal.com/en_US/i/btn/btn_xpressCheckout.gif'), :action => 'checkout' %>
</p>

Clicking the PayPal Express button do a GET request on the checkout action. The checkout action is where we setup the purchase with PayPal and get the token identifying the purchase from PayPal. We didn't generate the checkout action initially because it doesn't require a view. The checkout action represents Integration Point 1b from the Integration Guide. Define the checkout action as follows:

def checkout
  setup_response = gateway.setup_purchase(5000,
    :ip                => request.remote_ip,
    :return_url        => url_for(:action => 'confirm', :only_path => false),
    :cancel_return_url => url_for(:action => 'index', :only_path => false)
  )
  redirect_to gateway.redirect_url_for(setup_response.token)
end

gateway is actually a method which constructs the PaypalExpressGateway if it hasn't been already:

private
def gateway
  @gateway ||= PaypalExpressGateway.new(
    :login => 'API Login',
    :password => 'API Password',
    :signature => 'API Signature'
  )
end

As you can see, we're constructing the gateway using the credentials provided to us earlier in the PayPal Sandbox and returning the new instance of the gateway.

The setup_purchase() method informs PayPal of the details of the purchase we're going to make and returns a token. 5000 is the amount in cents of the purchase, which is $50.00. ActiveMerchant only accepts amounts in cents. The customer's IP address, passed in using the :ip option, is a required option, and helps PayPal reduce fraud. The :return_url option is the absolute URL that the customer will be redirected to after their purchase, and :cancel_return_url is the URL the customer will return to if they cancel the purchase.

Finally, we redirect the customer to PayPal. The URL is constructed by passing the token returned in the setup_purchase() call to the redirect_url_for() method provided by the gateway.

Now if you load http://localhost:3000/payments in your browser and click the PayPal Express button you should be redirected to PayPal. You will need to be logged into the PayPal Developer Central at the time you click the button in order for the sandbox to load correctly. You can now log in to PayPal using the Sandbox buyer account that you created earlier. Once logged in you will see the details of the purchase. You'll also see the link to cancel the transaction below the Continue button. The time spent on PayPal's site represents Integration Point 2a and Integration Point 2b from the Integration Guide. Clicking the Continue button will redirect your browser back to the Sprockets application confirm action. The redirection back to our application represents Integration Point 2c from the Integration guide. We already have a confirm action, but it just displays the default message put in the template by the Rails generator.

Let's enhance the confirm action as follows:

def confirm
  redirect_to :action => 'index' unless params[:token]
  
  details_response = gateway.details_for(params[:token])
  
  if !details_response.success?
    @message = details_response.message
    render :action => 'error'
    return
  end
    
  @address = details_response.address
end

First, we request the details of the purchase from PayPal using the details_for() method, which takes the token param as its first argument. If we successful get the details for the purchase then we display the confirm.html.erb template. Otherwise, we render the the error.html.erb template. error.html.erb looks as follows:

12	<h1>Error</h1><p>Unfortunately an error occurred: <%= @message %></p>

The confirm.html.erb templates displays the customer's PayPal address and asks them if they want to complete the payment. Displaying the review page represents Integration Point 3a from the Integration guide. This is the customer's opportunity to review the details of their order, change shipping methods, etc. It looks like this:

<h1>Please Confirm Your Payment Details</h1>

<table>
  <tr><td>Name</td><td><%= @address['name'] %></td></tr>
  <tr><td>Company</td><td><%= @address['company'] %></td></tr>
  <tr><td>Address 1</td><td><%= @address['address1'] %></td></tr>
  <tr><td>Address 2</td><td><%= @address['address2'] %></td></tr>
  <tr><td>City</td><td><%= @address['city'] %></td></tr>
  <tr><td>State</td><td><%= @address['state'] %></td></tr>
  <tr><td>Country</td><td><%= @address['country'] %></td></tr>
  <tr><td>Zip</td><td><%= @address['zip'] %></td></tr>
</table>

<% form_tag :action => 'complete', :token => params[:token], :payer_id => params[:PayerID] do %>
  <%= submit_tag 'Complete Payment' %>
<% end %>

When the customer clicks the Complete Payment button they will post their token, and PayerID, which were returned from PayPal, back to the complete action where we'll inform PayPal to complete the purchase. Completing the purchase represents Integration Point 3b from the Integration Guide. It looks as follows:

def complete
  purchase = gateway.purchase(5000,
    :ip       => request.remote_ip,
    :payer_id => params[:payer_id],
    :token    => params[:token]
  )
  
  if !purchase.success?
    @message = purchase.message
    render :action => 'error'
    return
  end
end

This looks similar to when we initially setup the purchase, but we're calling purchase() instead of setup_purchase(). If the purchase is successful then we render the complete.html.erb template. Displaying the final success message represents Integration Point 4 from the Integration Guide, which is the final step. It looks like:

<p>Thank you for your purchase</p>

The entire flow of the purchase is very flexible. The initial amount of the setup_purchase() method doesn't even need to match the final amount sent in purchase(). This allows for the buyer to change their mind about their order details during the checkout flow in your site. This is useful for situations where the customer may want to add high priority shipping, a discount code, or gift wrapping while reviewing their order. There is a lot of data that can be provided to PayPal throughout the integration. Take a look at the Integration Guide for a complete overview of all that is possible.

Scrivener, the best writing tool since sliced bread

2007-10-20T16:17:00Z

Have you ever wanted to write something, but felt so bogged down by the tools that you gave up? Even worse is if you don't even have the option of giving up. When I was writing RJS Templates for Rails using the O'Reilly Word template there were many moments when I thought that I may end it all. Thankfully, that didn't happen.

I have a profound hatred for Microsoft Word. I feel like its entire codebase exists solely to make my writing experience miserable. Capitalizing everything I need lowercase, formatting my paragraphs in ways that I don't want, just messing with my document to ruin my weekend. I'm sure it is possible to make Word do what I want, but I just don't feel like it is worth the effort. I don't want to waste my time figuring out how to make Word work for me, when what I want to do is really simple. I just want to write text. Is this a lot to ask for?

Thankfully, Tobias Lütke let me know about Scrivener. What can I say? Scrivener is fantastic. Scrivener not only gets out of my way when I'm writing, it actually has features that help with the process of writing. Scrivener helps in all the areas where it counts when it comes to writing. Organization, taking notes, keeping lists of reference material, storing research documents right in the project. Scrivener feels like a combination of a simple text editor with the power of an organizational tool like Omni Outliner built right in. You can create an outline in minutes, reorganize by dragging sections around, look at high level views of a section in a cork board view, and then turn off the entire UI when you're ready to get down to writing by entering the full screen typewriter mode.

There are many, many more killer features that I won't get into here. Do yourself a favour and get the demo. Better yet, just buy it. It only costs $34.99, which is less than you're going to spend next week at Starbucks anyway. You can get up to speed with all the features in less than an hour with the included tutorials.

Loading all Rails test fixtures with fixtures :all

2007-05-27T16:39:00Z

Are you as tired as we were of loading 20+ different fixtures in each of your Rails test classes? We were, and we even added a method all_fixtures() to test_helper.rb to do the loading of all our fixtures for us.

Thankfully though, we don't need our own helper method anymore, as the Rails fixtures() method will now accept a symbol :all, which will instruct the test helper to load all of your fixtures automatically.


require File.dirname(__FILE__) + '/../test_helper'

class ShopTest < Test::Unit::TestCase
  fixtures :all

  # Your tests here
end

As of Rails 1.2.3 this feature has not yet been merged from the trunk. This means that you'll either need to run Edge Rails from Subversion, or install the beta Rails gems as follows:


sudo gem install -s http://gems.rubyonrails.org rails -y

Happy testing!

I'm in a Magazine!

2007-04-02T20:45:00Z

Back in January my wife Maria and I were lucky enough to go on an all expenses paid vacation to Club Med Cancún Yucután. What was the catch? Well, the entire trip was a makeover for a magazine in Toronto called 2 Magazine.

The trip was a blast and we were fortunate enough to be photographed for the magazine by the incredible Toronto based photographer James Pattyn. The entire week was also documented on video by Mark and Evan from Viral Media Group

Special thanks to the entire 2Magazine crew including Diane, Beth, Margo, Jamie, Keri, Mark, and Evan. It was an awesome experience that we will never forget.

Ruby - Power, Simplicity, and Beauty

2007-03-14T03:07:00Z

Tonight while reading through Refactoring by Martin Fowler I was once again amazed by power, beauty, and simplicity of Ruby. Wait, hold on, aren't the code examples in Refactoring in Java? Yes, that is precisely the point. All day I am lucky enough to write Ruby, but sometimes I need to take a look back over the other side of the fence to appreciate where I'm at. Let me tell you that the grass is definitely not green over there.

Consider the simple method being extracted on page 27 of the book:


private double getTotalCharge() {
  double result = 0;
  Enumeration rentals = _rentals.elements();
  while (rentals.hasMoreElements()) {
    Rental each = (Rental) rentals.nextElement();
    result += each.getCharge();
  }
  return result;
}

Basically the code is just iterating over the collection of Rental objects and calculating the total charge. Simple enough. The equivalent using inject with Ruby:

1234	def get_total_charge rentals.inject{ \|sum, rental\| sum + rental.get_charge } end

Then, with the new sum method added to Enumerable in Rails it gets even simpler:

1234	def get_total_charge rentals.sum{ \|r\| r.get_charge } end

This just goes to show the power and expressiveness of Ruby. With so many fewer keystrokes, and lines of code, it is so much easier to focus on the problem at hand.

Switch & Solo Cards with Website Payments Pro UK (Payflow) and XMLPay

2007-03-09T20:00:00Z

While implementing support for PayPal Website Payments Pro UK in ActiveMerchant I ran across a small problem while processing the UK cards Switch & Solo.

Switch & Solo cards are a special case when processing credit cards, as they need some additional information. The additional information is either the card issue number or start date, as printed on the card. The problem is that the XMLPay guide provided by PayPal doesn't exactly specify where to put this information. If you dig around in the schema it appears as though you can place the CardIssue or CardStart element within a Level3Invoice element, however that didn't seem to work, and always returned the error "Field format error: CARDSTART or CARDISSUE must be present"

After some trial and error, and a helping hand in the right direction from Todd Sieber at PayPal, I was finally able to successfully process the Switch & Solo cards using the ExtData elements within the Card element of the XML request:


<Card>
  <CardType>Switch</CardType>
  <CardNum>5641820000000005</CardNum>
  <ExpDate>200801</ExpDate>
  <NameOnCard>Cody Fauser</NameOnCard>
  <CVNum>123</CVNum>
  <ExtData Name='CardIssue' Value='01'/>
  <ExtData Name='CardStart' Value='0299'/>
</Card>

You only need either the CardIssue or CardStart element to be present, but for illustrative purposes I included them both.

One other thing to note is that XMLPay API will no longer be updated by PayPal. So if you are writing new code then you might as well just stick to the Name-Value pair API.

Move to Mephisto

2007-01-08T04:16:00Z

I finally bit the bullet and moved my blog over to Mephisto. So far I am loving it. Thanks to Justin Palmer and Rick Olson for all of their hard work that went into making this an awesome application.

I migrated from Typo and used the great howto Converting Typo to Mephisto on the Octoblog. What an awesome name for a blog! The only thing I did differently, since I'm using the latest code from the Mephisto trunk, was the support for Typo style article URLs. I just opened up config/routes.rb and tweaked it to look as follows:


ActionController::Routing::Routes.draw do |map|
  Mephisto::Routing.connect_with map do
    map.connect 'articles/*path', :controller => 'mephisto', :action => 'dispatch'
  end
end

eBay API Client for Ruby

2006-11-22T04:43:00Z

I recently released my Ruby client for the eBay XML API. The source code can be found on Google Code. Benefits of this implementation include:

Simple and easy to use Ruby implementation.
Ability to return a raw response for calls that return an extremely large response such as GetCategoriesRequest.
Up-to-date with the latest eBay API version 485.
Months of usage in a production environment.
Support for Platform Notifications baked right in.

Enough talking about why you should use this library, let's get started with the eBay equivalent to 'Hello World', which is the GeteBayOfficialTime call.

Firstly you'll need to sign up for an eBay developer account. You can sign up at the eBay Developer Center. Once you have signed up you need to follow the directions in the confirmation email to get your Developer ID, Application ID, and Certificate ID. Record this information, as you'll need it when setting up the eBay client.

Now you need to setup a sandbox user to make API calls on behalf of.

Next you'll need to generate your Authentication Token. Simply enter the information you previously recorded into the form, select the sandbox environment from the dropdown menu and click the "Continue to generate token" link. Then sign in as the sandbox user you just created above and agree to allow your developer account to make API calls on behalf of the sandbox user. Record the Authentication Token that is now displayed.

The Authentication Token is your means of sending requests for different users. All you have to do to send a request for a different eBay user is change the Authentication Token that pass into the API call you are making. Of course, you'll need permission to make API calls on their behalf.

Now that we have all of the information needed for authenticating the API calls we can setup the configuration file that we'll use for the following example.

Start by creating a file config.rb and place the following code into it:


Ebay::Api.configure do |ebay|
  ebay.auth_token = 'YOUR AUTH TOKEN HERE'
  ebay.dev_id = 'YOUR DEVELOPER ID HERE'
  ebay.app_id = 'YOUR APPLICATION ID HERE'
  ebay.cert = 'YOUR CERTIFICATE HERE'

  # The default environment is the production environment
  # Override by setting use_sandbox to true
  ebay.use_sandbox = true
end

Obviously you'll want to place your own IDs and tokens into the configuration.

After you've signed up for the Developer Program and you have the API configuration ready to go you can get started installing the Ruby ebayapi gem. Install this gem as by running:

12	> sudo gem install ebayapi -y

The -y flag tells gems to install all the dependencies that the the gem requires.

Now that you've got the API client installed we can finally go ahead and get the official eBay time from eBay's servers.

Create a file named official_time.rb, in the same directory as the config.rb file we created earlier, and place the following code in it:


#!/usr/bin/env ruby

require 'rubygems'
require 'ebay'

# Include the API configuration
require 'config'

# Create the eBay client
ebay = Ebay::Api.new

# Get the official eBay time
response = ebay.get_ebay_official_time

# Display the time to the user
puts response.timestamp

Now you can run this simple application:


> ruby official_time.rb
# => Wed Nov 22 06:03:35 UTC 2006

That was easy. Once we got all of the IDs and tokens that eBay requires, that is. Next time I'll go into some more depth and background the client.

In the meantime you can checkout the examples I've provided in the source. Happy coding.