Consider the form below:

Here's a real quick tip which fixes a problem I've come across time and time again.

Consider the form below:

Here's a snippet of what the code looks like to create 3 of those fields:

	<%= f.label(:vintage) %>
	<%= f.text_field :vintage, :size => 5 %> Optional - e.g. 1990


	<%= f.label(:alcohol) %>
	<%= f.text_field :alcohol, :size => 5 %>% e.g. 5.6 or 10.25 


	<%= f.label(:residual_sugar) %>
	<%= f.text_field :residual_sugar, :size => 5 %> g/L e.g. 45 

You can see I've added a few little side notes next to each field using the small tag. The problem with adding a note inline next to a field in Rails is when the form is submitted and the data isn't valid. The form returned looks like this:

As you can see, the little notes get pushed over onto the next line. That's because Rails puts a div around the fields that are invalid. These divs are assigned a "fieldWithErrors" class. Now this can be useful for highlighting fields that have errors. For example, I like to highlight the label for the field with an error in red text. So I add this to my CSS:

div.fieldWithErrors label {
	color: #933; /* mid to dark red */
}

And that works great, but we still have this problem with the field notes jumping down. The reason for that is because the element Rails uses to put around the invalid field is a div and by default a div is displayed as a block element. We can fix this problem by forcing the browser to render it as an inline element by using the following CSS:

div.fieldWithErrors {
	display: inline;
}

Now it looks like this:

So there you have it. A simple little tip some of you out there might find useful.

Acts_as_attachment really kicks arse when it comes to handling files and images in your Rails application but one thing the file_column plugin has over acts_as_attachment is cropping support. Time and time again at work we have a space in the design for an image which has to be a certain size. By that I mean it must have a set width and height. But the client needs to be able to put any image they want into that space. But what if they upload a bigger image? Or, what if it's different aspect ratio?

Example

Imagine you've got a client that trains dogs. They're revising their home page and the designer has come up with a design that has space for 3 images that are exactly the same size. The designer thinks this looks great, but now you're stuck with the problem of how can you let the client upload any image of any size or aspect ratio and have them perfectly fit into those 3 boxes.

Acts_as_attachment allows you to resize images which is useful when you can have a fixed width or height, but the other is variable. But in this case the designer wants 3 images which are all the same size, both in height and width. This is what would happen if we used acts_as_attachment to resize the images using a fixed width, but variable height.

Out of the box, this is actually your best option. But I've taken acts_as_attachment one step further and added cropping support. This will allow us to resize, then crop the image so that it's scaled down, and then the left over bits are cropped off so that we can fit any image in these 3 boxes of fixed height and width. This is the results of using resizing and cropping:

Now the client can be confident they can upload any image they like and it's going to look nice on the site.

Patching Acts_as_Attachment to Support Cropping

Once you've installed the acts_as_attachment plugin, find the thumbnail_for_image method which is in /vendor/plugins/acts_as_attachment/lib/technoweenie/acts_as_attachment.rb

For me the thumbnail_for_image method begins on line 242. This might be different for you. The method should look like this:

def thumbnail_for_image(img, size)
  size = size.first if size.is_a?(Array) && size.length == 1 && !size.first.is_a?(Fixnum)
  if size.is_a?(Fixnum) || (size.is_a?(Array) && size.first.is_a?(Fixnum))
    size = [size, size] if size.is_a?(Fixnum)
    img.thumbnail(size.first, size[1])
  else
    img.change_geometry(size.to_s) { |cols, rows, image| image.resize(cols, rows) }
  end
end

def thumbnail_for_image(img, size)
  size = size.first if size.is_a?(Array) && size.length == 1 && !size.first.is_a?(Fixnum)
  if size.is_a?(Fixnum) || (size.is_a?(Array) && size.first.is_a?(Fixnum))
    size = [size, size] if size.is_a?(Fixnum)
    img.thumbnail(size.first, size[1])
  elsif size.is_a?(String) && size =~ /^c.*$/ # Patch to enable cropping
    dimensions = size[1..size.size].split("x")
    img.crop_resized!(dimensions[0].to_i, dimensions[1].to_i)
  else
    img.change_geometry(size.to_s) { |cols, rows, image| image.resize(cols, rows) }
  end
end

Save and restart your web app and you should be up and running with cropping support!

How to Indicate you Want Cropping

In your model all you need to do is put a "c" infront of the dimensions on the thumbnail you want to resize and crop. The "c" indicates to acts_as_attachment that cropping should occur.

acts_as_attachment :storage => :file_system,
                   :file_system_path => 'public/system', # Using Capistrano conventions
                   :max_size => 4.megabytes,
                   :content_type => :image, # only allow png, gif and jpg
                   :resize_to => "1000x1000",
                   :thumbnails => {:home => "c100x80",
                                            :something_else => "500>"}

Extending this Idea Further

If you take a look at the modifcations to acts_as_attachment to support cropping, you could easily modify it to support anything you like. Perhaps on a certain thumbnail you want a drop shadow to appear. You could make acts_as_attachment recognise "s" (for 'shadow') infront of the deminsions.

If you do anything cool like that please comment below and let us know!

Images used in example taken from here, here and here.

If you need to test something that changes, then assert_differnce() is perfect. Below is a typical example of something changing. We have a user class and we want to test the destroy method to make sure the user really does get destroyed.

The Rails core team have really been kicking out some cool stuff recently. One addition I've been taking full advantage of is the assert_differnce() method (changeset here). This method is only available to those of you who are using Edge Rails.

If you need to test something that changes, then assert_differnce() is perfect. Below is a typical example of something changing. We have a user class and we want to test the destroy method to make sure the user really does get destroyed.

Let's take a step back for a moment. What changes when this user is deleted? User.count does, because there is now one less user to count. So we need to ensure that there is a difference in the count of users after deleting a user.

Before

class UserTest < Test::Unit::TestCase

  fixtures :users

  def test_should_delete_first_user
    # Record current user count
    old_count = User.count  

    # Delete the first user we find
    User.find(:first).destroy

    # Make sure the count is now 1 less than it was before
    assert_equal old_count -1, User.count  
  end

end

After (using assert_difference)

class UserTest < Test::Unit::TestCase

  fixtures :users

  def test_should_delete_first_user
    assert_difference('User.count', -1) do
      User.find(:first).destroy
    end
  end

end

Ah yes, much nicer.

Here are some guidelines I follow...

It's important to keep a consistant style when writing CSS. When you have a team of developers you might want to consider writing a guideline that everyone follows.

Here are some guidelines I follow...

1. Always combine statements that can be combined. One line is shorter and sweeter. It groups all statements of the same type together which is useful and easier to access. For example:

   /* Better */
   background: url(background.png) #00FF00 no-repeat;
   
   /* Bad */
   background-image: url(background.png);
   background-color: #00FF00;
   background-repeat: no-repeat;
   

2. Always use words for colours where possible. If you're dealing with a basic developer they're far more likely to recognise the word of the colour than the hex value.

   /* Better */
   color: white;
   
   /* Bad */
   color: #FFFFFF;
   

3. Shorten hex colours where possible. Short and sweet.

   /* Better */
   color: #F0F;
   
   /* Bad */
   color: #FF00FF;
   

4. Hex values are easier to spot and read when in capitals.

   /* Better */
   color: #F0F;
   
   /* Bad */
   color: #f0f;
   

5. All hacks should be linked to documentation in a comment. Hacks can be pretty confusing looking to many CSS developers, so why not do them a favour and link them to some relevant documentation so they can go read up about it!

   /* Clearfix hack, see http://www.positioniseverything.net/easyclearing.html */
   .clearfix:after {
       content: "."; 
       display: block; 
       height: 0; 
       clear: both; 
       visibility: hidden;
   }
   /* ... snip ... */
   

6. Be careful not to duplicate CSS or forget to remove redudant CSS. We've all done this, written some CSS and then removed the HTML it was styling but never removed the CSS. CSS redundancy checker to the rescue! This Ruby script will run through your CSS and find and remove redundant CSS for you.

These are just 6 guidlines I follow. Comment if you have one of your own to add...

Roelofs is right, however, full alpha transparency support didn't exist in Internet Explorer until version 7. With this new support for transparency, the advantages of using PNG only become more and more obvious.

However, the plot thickens when you save a PNG file from Adobe Photoshop. Photoshop does a poor job of compressing PNG images properly.

CrushPNG to the rescue! CrushPNG is a lossless PNG optimiser that will reduce the size of your PNG images in a flash.

To install with Ports simple run:

sudo port install crushpng

Otherwise, download it from here.

According to Roelofs, it's a popular misconception that few browsers support PNG. In fact, Microsoft Internet Explorer, Netscape Communicator, and Opera have supported it since 1997.

Roelofs is right, however, full alpha transparency support didn't exist in Internet Explorer until version 7. With this new support for transparency, the advantages of using PNG only become more and more obvious.

However, the plot thickens when you save a PNG file from Adobe Photoshop. Photoshop does a poor job of compressing PNG images properly.

CrushPNG to the rescue! CrushPNG is a lossless PNG optimiser that will reduce the size of your PNG images in a flash.

First you will need to install CrushPNG with Ports. Simply run:

sudo port install crushpng

Otherwise, download it from here.

Here is the basic syntax to optimise a PNG image:

crushpng before.png after.png

If you're like me, you'll have an images directory for your website. So typically I would want to make sure all my PNG images are optimised. You could manually optimise each file but that could be a little tedious and time consuming. So I've written up a command that will recursively go through your files looking for PNG images, optimise them and then finally save them.

The command looks like this:

find . -name "*.png" -exec pngcrush -brute -force -q {} temp.png \;  -exec rm {} \;  -exec mv temp.png {} \; -print

This is quite a long command and I'm hoping you're not crazy enough to remember that. So we can set it as an alias instead. Do the following to setup this command as an alias:

cd ~
mate .profile # I use TextMate, you could use nano .profile here if you wanted to

Now add this line into your .profile file and save it.

alias crushpngs="find . -name \"*.png\" -exec pngcrush -brute -force -q {} temp.png \;  -exec rm {} \;  -exec mv temp.png {} \; -print"

Reopen terminal and now you can just use the "crushpngs" command anywhere you like. The particular use I have for this is in my latest project MyLetterBox. Here is an example of the command running on a Ruby on Rails application:

~/Code/MyLetterBox/trunk/public/images$ crushpngs
./application/bottom-gradient.png
./application/myletterbox-logo.png
./application/top-gradient.png
./buttons/notify-me.png
~/Code/MyLetterBox/trunk/public/images$ 

At some point soon I will write up an article on how to add this to your Capistrano deploy.rb file. That way you can just deploy your application and it will automatically optimise all your PNG images for you.

In the meantime, use the script below to emulate a browser logging in and request the products.xml file.

As part of some on the side work I'm doing for Hanafins, I needed to syncronise products added in Shopify with Telecom's Ferrit ecommerce system. To do this, you need to be able to export all the products out of Shopify. This isn't easy as the Shopify API isn't ready yet.

In the meantime, use the script below to emulate a browser logging in and request the products.xml file.

The Code

Firstly you'll want to install the 'mechanize' gem.

sudo gem install mechanize --include-dependencies

Is this example we're using a Shopify model and a download_xml method.

require 'mechanize' # Required to login and download the products feed
  
# This model handles the downloading of the Shopify XML feed
class Shopify < ActiveRecord::Base

  URL = "http://yourstore.myshopify.com"
  LOGIN = "you@youremail.com"
  PASSWORD = "yourpassword"

  # Download the XML feed from Shopify
  def download_xml
    # Request the login page
    agent = WWW::Mechanize.new
    page = agent.get("#{URL}/admin/auth/login")

    # Input the login creditionals into the form
    form = page.forms.first
    form.login = LOGIN
    form.password = PASSWORD
    page = agent.submit(form, form.buttons.first)
    
    # Request all the products in the store. Stops at 10,000 products.
    page = agent.get("#{URL}/admin/products.xml?limit=10000")
    page.body
  end

end

And that's it! So now in your controller you could go:

  products_xml = Shopify.new.download_xml
  render :text => products_xml

And you would get all the products outputted in XML from your Shopify store.

Related Documentation

Mechanize RDoc's

If you give a client the tools to update a website themselves you'd like to hope they will actually take advantage of your hard work.

This is where I have found RSS handy in my latest project.

Sometimes when I have completed a website for a client, I wonder if they are really using it correctly. With some clients, you can build them the coolest backend but they don't use it to its fullest extent. It's not that they are stupid, but perhaps something was overlooked which is making it difficult for the client.

If you give a client the tools to update a website themselves you'd like to hope they will actually take advantage of your hard work.

This is where I have found RSS handy in my latest project.

Use RSS to Spy on your Clients

Okay, so it's not really spying... but the client I was dealing with is very new to computers. I had to make it as simple as possible for her use. I also wanted to make sure she was able to use it.

When I built the backend, I always had to keep in mind the ability of the client. But once you show the client your beautiful polished work, you can never really be sure what problems they will have when you're not around.

By placing RSS feeds around the site I was able to track when the client was updating the website as they did it. I could check right away if they had made any mistakes.

Correcting Mistakes Early & Quickly Makes Happier Clients

I was able to ring my client up, correct a few things and educate the client from what I could see they needed improving on.

Because of RSS I knew right away she was updating the website so when I called her of course, she was right in front of the computer with the backend open ready to hear what I had to say.

That day I had also been making alterations to the code which caused a problem. It was only until the site was altered by the client that this problem occurred. Because I could check the site as she was updating it, I found the problem as soon as she made the changes and fixed it promptly before anyone could see.

A website project is an ongoing thing

Most website projects I've been involved in have been an on-going pieces of work. You can never say a website is "complete" and never touch it again. You have to update and maintain it and RSS is a great way to keep up to date with how the client is going.

"If your site has dynamic content or pages that aren't easily discovered by following links, you can use a Sitemap file to provide information about the pages on your site. This helps the spiders know what URLs are available on your site and about how often they change."

I thought it would be a good thing to have Google Sitemaps integrated into some of my Ruby on Rails projects. Because Ruby on Rails has excellent XML support, I went ahead and implemented Google Sitemaps into one of my latest projects.

From Google's website

"If your site has dynamic content or pages that aren't easily discovered by following links, you can use a Sitemap file to provide information about the pages on your site. This helps the spiders know what URLs are available on your site and about how often they change."

I thought it would be a good thing to have Google Sitemaps integrated into some of my Ruby on Rails projects. Because Ruby on Rails has excellent XML support, I went ahead and implemented Google Sitemaps into one of my latest projects.

The Controller

Nearly every site I've made so far in Rails has a page controller. So in this example I will use a page controller with a sitemap method inside it.

	
class PageController < ApplicationController

  def sitemap
    @pages = Page.find(:all)
    render_without_layout
  end

end
	

As you can see in my example controller, the Rails application has a page model. You can replace this with as many models as you wish. For example, if you also had news on your application, you might want to add @news= News.find(:all) to the controller and change the view as required.

The View (sitemap.rxml)

	
xml.instruct!
xml.urlset(:xmlns=>'http://www.google.com/schemas/sitemap/0.84') {
  for page in @pages
    xml.url {
      xml.loc(url_for :controller=>'page',
                      :action => 'show',
                      :id => page.id,
                      :trailing_slash => true,
                      :only_path => false)
      xml.lastmod(page.updated_on.strftime('%Y-%m-%d'))
    }
  end
}
	

The RXML is extremely straight-foward as you can see.

With the above setup the output looks like this...

	
<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.google.com/schemas/sitemap/0.84">
  <url>
    <loc>http://localhost:3000/browse/welcome/</loc>
    <lastmod>2005-08-23</lastmod>
  </url>
  <url>
    <loc>http://localhost:3000/browse/contact/</loc>

    <lastmod>2005-08-23</lastmod>
  </url>
  <url>
    <loc>http://localhost:3000/browse/links/</loc>
    <lastmod>2005-08-23</lastmod>
  </url>
  <url>

    <loc>http://localhost:3000/browse/about/</loc>
    <lastmod>2005-08-23</lastmod>
  </url>
</urlset>
	

Setting up the Route

Google "strongly recommends" that you place the sitemap in the root directory. Eg: http://www.example.com/sitemap.xml

To do this we need to setup a route. Open up config/routes.rb and add...

	
map.connect 'sitemap.xml', :controller => 'page', :action => 'sitemap' 
	

...near the top of the file. Now when we request http://localhost:3000/sitemap.xml the sitemap will appear.

Submit your Sitemap to Google

Now you have setup the sitemap you will need to submit it to Google.

Update

Mark extends this example by implementing automatic submissions to Google when your sitemap changes.

More Information

For more information about Google's Sitemaps take a look at the BETA website:
http://www.google.com/webmasters/sitemaps/docs/en/overview.html

For information about Rails and XML have a look at:
http://api.rubyonrails.com/classes/Builder/XmlMarkup.html

Introduction

To find out how blogging (short for web-logging) can be used as a method of CRM (Customer Relationship Management) we first need to define the two keywords.

Blogging:

"A blog is a user-generated website where entries are made in journal style and displayed in a reverse chronological order." - Wikipedia (2007)

CRM:

"Acronym for customer relationship management. CRM entails all aspects of interaction a company has with its customer, whether it be sales or service related. CRM an information industry term for methodologies, software, and usually Internet capabilities that help an enterprise manage customer relationships in an organised way." Creotec (2005)

As the definition suggests, blogging is a series of web-based publications and the definition for CRM mentions "CRM entails all aspects of interaction a company has with its customer”. We can see there is a clear overlap here which makes me ask one further question:

How would a business use blogging as a customer relationship management tool?

How and where do they overlap? In what way can regular online posts form and be some sort of interaction between the customer and a company. This question I endeavour to answer in my findings and summarise in my conclusion.

Findings

Are Blogs Useful?

I found out that yes they certainly are. Like most things on the Internet, there’s great information but there is also worthless information; Weblogs follow this trend.

"You care about blogs if your organization wants to develop real relationships with customers and wants to do so better than its competitors.
Blogs aren’t just a media or PR tool. Business blogs are being used by a variety of industries and companies to circumvent the media and the competition to connect directly with customers." - F. Christopher (2005)

It’s made clear that blogs can not only make a connection with your customers but actually help you do better than you competition. They’re a very cheap, simple and fast way to give your customers updates on just about anything. They can also create communities and allow value feedback to occur. This feedback is free too because anyone can post an opinion on a blog (in most cases). It is now becoming clear that blogs are useful for these reasons.

Types of Blogs

According to F. Christopher (2005) there are six types of business blogs which you can categorise nearly any blog under. When I say business blog, I mean a blog that is related to a company or is the company itself; a blog that has some sort of commercial nature. These types of blogs directly relate to the question this report attempts to answer:

How Would a Business use Blogging as a Customer Relationship Management Tool?

A business could use any of the following types of blogs as a CRM tool:

• The Tour Guide
• The Recommender
• The Maven
• The Customer Advocate
• The Do-er
• The CEO Blog

The Tour Guide

As the name suggests, this type of blog gives you a guided tour of a company. It gives you a behind the scenes look at what’s going on in the company and perhaps who is behind it all.

From a business perspective this is useful to draw customers in and create good customer relationships because a customer might be very impressed with some of the things they see happening inside the company. They may also feel special being able to see behind the scenes. It makes the customer feel more confident as nothing is being hidden from them.

The Recommender

This sort of blog is an intermediary for a customer trying to find information about something. The blog must maintain and build up a reputation for having good recommendations to survive.

This sort of blog is quite different from the others and is also more difficult to create good customer relationships from it. One example could Apple’s iPod. There’re lots of third party products which complement iPods. If Apple created a blog which recommended these third party products to the customers, the customer might become happier with the iPod itself because one of the third party products was something the customer was looking for but Apple didn’t offer it. Just by letting a customer know about another product, indirectly they have become more satisfied with your product as a result of that.

The Maven

“The Maven” type of business blog contains posts from experts in a company. Rather than being orientated around the company it’s more about the experts and what they have to say. The blog normally covers a very broad topic rather than something very specific and narrow focused.

Even though the readers of the blog are after expert advice from the writer, it gives the company an appearance of expertise. The user might say to themselves "this expert works for this company, so this company must be really good". If the users can see this expertise, the company might get customers which choose that company over their competition as a result of this.

The Customer Advocate

This type of blog is one of the most effective in business. The Customer Advocate blog directly engages with the customer. It allows the customer to write feedback and ask or even answer others questions.

This blog allows a high level of communication which can often be of great help to the company and the customer. One way it could be helpful to the company is if a new product is in development and perhaps a sneak preview is posted online. Readers could post feedback on what they think is good or bad about the product. The company could use these good ideas and adjust the product before the final release. The feedback is free so effectively the product is made better at nearly no cost.

It can also be helpful for the customer if they have a question about something and they post it. The question will then be answered and the customer will be happy. But because it’s on a blog and online the question stays online. If another customer has the same question they might find their question has already been answered.

The Do-er

The Do-er is a more focused version of the Maven blog type. Rather than covering a broad range of issues The Do-er blog type is more focused on specific topics and issues. The information is written by experts in a company.

This type of blog really shows that the company is up with the play to the users who read it. The posts might also be very cutting edge. The blog will demonstrate to the readers that the employees in the company are doing great things. This also gives the employees a boost of confidence because company has allowed them and often encourages them to post interesting things that they know about to the public. This gives the employees a sense of importance and in some ways it might be rewarding.

The CEO Blog

The CEO Blog is a blog where the CEO posts information about the company and relating issues. He or she might release new products or get feedback on various things but the key point is that the head of the company is directly talking to the customers. It removes the barriers and allows customers to interact directly with the head of the company.

The customers benefit by have a direct line of communication with the CEO and the CEO benefits by receiving feedback from the customers directly and not having it filtered through several managers before reaching him or her.

Conclusion

We have learnt that blogs can be a very powerful tool in business. It’s cheap, simple and can be very effective. A blog can be a great way to form excellent relationships with your customers but there are also great company benefits too. You can keep employees happy by showing them that they are intelligent enough to post information under the company name and the public. You can gain better feedback on products by allowing comments and discussions to happen.

The six types of blogs outlined, show six different ways and focuses a blog can have, each with different benefits. To make a business blog the most successful you need to decide which blog type best fits your business situation. Which one in your specific case will suit your company’s vision and the customer’s expectations?

To finally answer the question:

How would a business use blogging as a customer relationship management tool?

A business would have to carefully look at the pros and cons of each type of blog and come to a decision on which one is best. Then setup the blog and make sure regular postings occur. This is how a business can successfully use blogging as a CRM tool.

References

Christopher, C. F. (2005). The Business Blogging Field Guide.
Retrieved November 4, 2005, from
http://www.cerado.com/download/CeradoBusinessBloggingFieldGuide.pdf

Christopher, C. F. (2005). Why blogs?
Retrieved November 4, 2005, from
http://www.cerado.com/download/CeradoBlogDatasheet.pdf

Creotec (2005). electronic business terms and definitions (glossary).
Retrieved November 4, 2005, from
http://www.creotec.com/index.php?page=e-business_terms

Mohammed R.A., Fisher R.J., Jaworski B.J. and Paddison G.J. (2004). Internet
Marketing: Building Advantage in a Networked Economy (2nd Edition)

Wikipedia (2005). Blog. Retrieved November 4, 2005, from
http://en.wikipedia.org/wiki/Blogging

This has opened up New Zealanders to Shopfiy, one of the best web 2.0 applications around.

Up until now, New Zealand based online stores using Ruby on Rails had to use Paypal to process credit cards. Today, I'm releasing support for a new gateway to Active Merchant which uses a local online payment company called Payment Express.

Why Payment Express?

Payment express is local, which means you can hook your online transactions direct into your New Zealand bank accounts.

From Payment Express website:

In NZ we support ANZ, Westpac, National Bank, ASB and BNZ. In Australia we support ANZ, NAB, Westpac, CBA, St George and Bank of South Australia. The Maybank in Malaysia is supported and the Citibank for Singapore.

Payment Express is also very well used in the NZ industry. Here are just some of the companies using Payment Express:

• Trademe
• Sony
• Farmers
• HP
• EziBuy

Active Merchant

Active Merchant is an open source plugin for Rails. It's an "extraction from the e-commerce system Shopify". In short, it makes it super easy for anyone to easily and cleanly make credit card payments from their Rails application.

Show me the code!

Enough talk, here's some example code demonstrating how you might go about using the gateway to process credit cards in your application.

First run this command from the root of your Rails application:

 ruby script/plugin install http://activemerchant.googlecode.com/svn/trunk/active_merchant 

Now add the appropriate files covered below...

app/views/payment/index.html

<% form_tag :action => 'process' do -%>
	<label>Number</label> <%= text_field :credit_card, :number %>
	E.g. 4111111111111111

	<label>First Name</label> <%= text_field :credit_card, :first_name %>
	E.g. David

	<label>Last Name</label> <%= text_field :credit_card, :last_name %>
	E.g. Jones

	<label>Type</label> <%= select :credit_card, :type, ['visa', 'master'] %>

	<%= date_select :credit_card, :expiry, :discard_day => true,
                                                                :start_year => Time.now.year,
                                                                :end_year => Time.now.year + 10 %>
    <%= submit_tag 'Process' %>
<% end -%>

The view is very simple. Just gather the information about the users' credit card...

app/controllers/payment_controller.rb

class PaymentController < ApplicationController
  
  require 'money'

  def process
    creditcard = assemble_credit_card

    if creditcard.valid?
      gateway = ActiveMerchant::Billing::PaymentExpressGateway.new(:username => 'your_username',
                                                                :password => 'your_password')

      response = gateway.authorize(1000, creditcard, {:reference => 'This weeks rent'})

      if response.success?
        result = gateway.capture(1000, response.authorization)
        
        render :text => response.inspect
      else
        raise StandardError, response.message 
      end
    end
  end

private

  def assemble_credit_card
    ActiveMerchant::Billing::CreditCard.new(
      :type       => params[:credit_card][:type],
      :number     => params[:credit_card][:number],
      :month      => params[:credit_card]['expiry(2i)'].to_i,
      :year       => params[:credit_card]['expiry(1i)'].to_i,
      :first_name => params[:credit_card][:first_name],
      :last_name  => params[:credit_card][:last_name]
    )
  end

end

What Now?

During the process of developing this gateway we've been using a Payment Express test account. If you're looking at adding credit card support for your Rails application then I'd suggest you sign up here for a test account so you can get your application under way! Make sure you select "Development Account" on the pricing plan.