captured sparks

Welcome to captured sparks

Robin Fisher — 2008-02-07T22:38:27+00:00

This inaugural post comes after several days of arguing with Ubuntu, Apache and Mongrel.

This site is hosted on a 256 slice from Slicehost and I’ve learnt a lot about Apache configuration, working with Linux and am now intimately familiar with the command line.

During the process, I’ve been helped by a significant number of resources that are out there and I intend to run a series of posts on how I got this site up and running in the hope that I may stand on the shoulders of giants and provide some insight of my own.

As a side note, you might have seen that this site is running on “sparky”. This is a custom built CMS coded in Rails that is very much in version 0.1. I’ll be doing some posts on its development as well as walking through some features as I add them.

Heroku

Robin Fisher — 2008-02-08T08:36:42+00:00

Would I have swapped the struggles of the last few days in terms of getting this up and running for the simplicity of Heroku?

I’m not sure that I would.

attachment_fu - where are the images?

Robin Fisher — 2008-02-08T22:12:23+00:00

It occurred to me late last night that due to my use of Capistrano to deploy sparky, any images that were uploaded were getting lost every time I deployed.

Thanks to a great article at almost effortless, I thought I had the problem solved.

Unfortunately, attachment_fu seems insistent on adding leading slashes, leading directories and all manner of things to the public_filename path. As such, all my images have disappeared until such time as I can fix this.

attachment_fu problem fixed

Robin Fisher — 2008-02-09T08:18:48+00:00

Just as I shut the laptop last night to go to bed, I came up with a solution to my leading slash problem.

attachment_fu’s default behaviour is to partition the directories into which it stores files based on id. In my case, my images were being placed into the folder public/images/0000/#{id}.

As such, I amended my deploy.rb file to read:

<p>task :after_update_code, :roles =&gt; :app do<br />
  %w{0000}.each do |share|<br />
    run &#8220;rm -rf #{release_path}/public/images/#{share}&#8221;<br />
    run &#8220;mkdir -p #{shared_path}/system/images/#{share}&#8221;<br />
    run &#8220;ln -s #{shared_path}/system/images/#{share} #{release_path}/public/images/#{share}&#8221;<br />
  end<br />
end<br />

This symlinked the 0000 directory to an identically named directory in the shared part of the system.

I’ve deployed a couple of times since then and my images are still accessible.

Integrating Google Shared Items with Rails

Robin Fisher — 2008-02-10T14:33:07+00:00

As part of the home page on captured sparks, I wanted to have a “Recent Reads” section where I could list the articles that have caught my attention recently. I do most of my reading in Google Reader and thought that the Shared Items feature in Reader would be perfect for this. Thanks to the FeedTools gem, adding this was straightforward.

Firstly, grab the FeedTools gem, using sudo if necessary:

gem install feedtools

The way I added this function was to use a helper method inside my home_helper.rb call shared_items. Firstly require the gem in the head of the helper:

12	<p>gem ‘feedtools’<br />require ‘feed_tools’<br />

Next, set up some variables that we will use throughout the method:

content: will be used to contain our shared items
days: used to calculate how old the oldest shared item will be
time: used to make sure each entry is not too old
share_url: the RSS feed for the shared items

Setting up the method now looks like:

<p>content = &#8216;&#8217;<br />
days = 15<br />
time = Time.now.utc &#8211; (86400 * days.to_i)<br />
share_url = &#8217;http://www.google.com/reader/public/atom/user/13411963057092720812/state/com.google/broadcast&#8217;<br />

To create the shared item list:

<p>feed = FeedTools::Feed.open(share_url)<br />
  feed.entries.each do |entry|<br />
    if entry.published &gt; time<br />
      content &lt;&lt; &quot; <li>\n&quot;<br />
      content &lt;&lt; &quot; <a href='#{entry.link}'>#{entry.title}</a>\n&quot;<br />
      content &lt;&lt; &quot; <p />#{entry.find_node(&#8220;source/title/text()&#8221;).to_s}\n&quot;<br />
      content &lt;&lt; &quot; </li>\n&quot;<br />
    end<br />
  end<br />

Finally, check to see if anything is shared and add the appropriate HTML container (or witty comment if nothing is shared), then return the content.

<p>if content.length &gt; 0<br />
  content = &#8220;<ul>&#8221; + content<br />
  content &lt;&lt; &#8220;</ul>\n&#8221;<br />
else<br />
  content = &#8220;<p />Not read anything of interest recently.&#8221;<br />
end<br />
return content<br />

The helper method is then called in the view by simply adding:

&lt;%= shared_items %&gt;

You can read more about FeedTools in the FeedTools API.

Of We and I

Robin Fisher — 2008-02-10T19:31:41+00:00

Having worked in a multi-national corporate for the last 6 years, it is common practice for me to refer to a company as “we”. You may have noticed that I use “we” when talking about captured sparks on this site. The headline on the homepage is “We can make your website sparkle”.

We, in the case of captured sparks, is me. It is I. One person.

Should it ever get to the stage where other people come on board, I’ll let you know. Until then, it’s just me. Even when I say “we”.

Using self in Ruby

Robin Fisher — 2008-02-12T10:45:11+00:00

One of the things that had me confused early on when programming in Ruby was when to use “self” for a method and when not to.

The easiest way to summarise, I think, is to say that

self.method

should be used when referring to a method that operates on the class itself.

method

should be used when referring to a method that operates on an instance of the class.

The most common place this is seen in Rails application is in authentication systems. The method for logging a user into an application is usually written as:

<p>Class User &lt; ActiveRecord::Base</p>
def self.authenticate(user, password)
&#8230;
end
<p>end<br />

This is then called in the controller as:

<p>Class SessionsController &lt; ActionController::Base</p>
def new
@user = User.authenticate(params[:session])
end
<p>end<br />

In contrast, methods can then be called on the @user object once the user has logged in. For example, to check if the user is an administrator, the following method could be used in our User class:

123	<p>def is_admin?<br /> …<br />end<br />

This could then be called within the view, perhaps to display certain restricted information:

<p>&lt;%= if @user.is_admin? %&gt;<br />

As a complete aside, I love how the above code demonstrates the readability of Ruby. There is no doubt as to what that statement means.

UK to ban filesharers from the net?

Robin Fisher — 2008-02-12T11:38:05+00:00

A report in the Times this morning is getting a lot of coverage. It states that the UK government intends to legislate to require ISPs to take action against individuals using their networks for file-sharing activities.

Quite how the government expects ISPs to monitor every bit of traffic that passes through their network is anyone’s guess. It is again indicative of the music industry’s insistence on spending their money on lobbying for legislation to protect a failing business model, rather than adapting to the changing face of music.

Becky Hogge of the Open Rights Group (an organisation for which I volunteer) is appearing opposite the BPI on Radio 4’s World at One to discuss the story. ORG will no doubt be responding to any future consultation.

For further reading on the story, I recommend Techcrunch UK, Techcrunch, the always excellent Techdirt and BBC News’ Darren Waters.

UPDATE: ORG have a post about this story.

Custom spam prevention

Robin Fisher — 2008-02-13T12:52:46+00:00

Inspired by Jonathan, I spent some time last night working on spam prevention for the comments here at captured sparks. I had seen a good article on integrating Akismet with Rails but as this is a home-baked CMS, and having read Jonathan’s approach to the issue decided to have a go myself.

I adopted a similar approach to Jonathan of assigning a score to a comment and then either automatically posting the comment or holding it back for approval . The validation is handled by a before_create callback in the comment model. Here’s an extract of the validation method:

<p>body = self.body<br />
&#8230;<br />
score -= body.scan(/viagra/).size<br />
&#8230;<br />
case score<br />
when 1..999<br />
 write_attribute(:approved, true)<br />
&#8230;<br />

At the moment, the validation is very basic and leans towards a cautious approach to automatic posting. Having said that, all comments are saved to the database for review. I’m not content enough to start automatically rejecting the comments yet.

Thank to Jonathan for the inspiration.

Blogging the building of your app

Robin Fisher — 2008-02-15T08:51:17+00:00

One to watch over at Next Update, where they are blogging the building of their issue and bug tracking app.

Everyone should have a web app

Robin Fisher — 2008-02-16T08:55:12+00:00

I’ve come up with a little idea for a web app.

It’s going to be for a niche market where the current solutions to the issue are enterprise level with a huge server licence and slightly-less-huge user licences. There is a lot of competition for the traditional solution but none for a simple, hosted solution.

The market I am targeting is historically very traditional and this may present a small barrier to adoption but this is for the sector in which I currently work and I know that I would want something like this.

It’s not going to come as a shock to say that I admire 37 Signals (who doesn’t?). Part of their ethos though is to build what you know and what you use. That way, there is less chance of featuritis. And I know exactly what this app should do.

The cool stuff has to wait

Robin Fisher — 2008-02-18T12:26:33+00:00

As I sit here, all sorts of ideas are popping into my head that would be awesome to implement for my upcoming app. Unfortunately, they need to go on the back-burner.

I started work on the app yesterday afternoon and am still in the process of creating my models and controllers to give a basic functionality. Whilst I do enjoy working in Rails, this is the boring bit. I can’t wait until I can really get into creating my own methods and putting some of these ideas into practice.

The need to know Ruby

Robin Fisher — 2008-02-22T10:53:10+00:00

As part of the development of my app, I had a need to display various different categories of to-do items – complete, overdue and “normal”.

I was using a method in the Todo class similar to the following to create these categories:

<p>def self.find_overdue<br />
  overdue = Array.new<br />
  items = find(:all)<br />
  for item in items<br />
    if item.overdue?<br />
      overdue &lt;&lt; item<br />
    else<br />
    end<br />
  end<br />
  overdue<br />
end<br />

I was reading through the online Ruby documentation on another issue and came across a nice method in the Hash class: reject. This acts as a “delete if” method and can substantially reduce the code above:

1234	<p>def self.find_overdue<br /> items = find(:all)<br /> items.reject { \|i\| i.not_overdue? }<br />end<br />

The “not_overdue” method is defined separately in the Todo class. I think this definitely shows the importance of knowing the Ruby language and equally demonstrates its power.

Dynamically generating a sitemap for Google

Robin Fisher — 2008-02-25T21:59:30+00:00

One of the issues I encountered with my previous Rails application was adding a sitemap to the root directory so that I could use Google’s Webmaster Tools. As I was not under a deadline for sparky, I was able to dedicate some time to the issue.

I figured the easiest way to create the sitemap was to use Rails’ built-in XML builder to dynamically generate the sitemap when requested by Google. This has the advantage of picking up every new blog entry.

First was the controller. In order to keep everything segregated and RESTful, I created a sitemaps controller with one action:

<p>class SitemapController &lt; ApplicationController<br />
  <br />
  def sitemap<br />
    @entries = Entry.find(:all)<br />
    @jobs = Job.find(:all)<br />
    <br />
    respond_to do |format|<br />
      format.xml { render :layout =&gt; false }<br />
    end<br />
  end<br />
  <br />
end<br />

I retrieve all the dynamic information in the controller, which is then passed to the view file. Creating the view was a lot of trial and error, particularly in terms of getting it to match the sitemap specification. Here though is the final view file split into chunks for commentary purposes.

123	<p>base_url = “http://www.capturedsparks.com”<br />xml.instruct! :xml, :version=>"1.0"<br />xml.tag! ‘urlset’, “xmlns” => “http://www.sitemaps.org/schemas/sitemap/0.9” do<br />

This sets the header information in the resulting xml file as required by the sitemap specification.

<p>for entry in @entries do<br />
  xml.tag! &#8216;url&#8217; do<br />
    xml.tag! &#8216;loc&#8217;, &#8220;#{base_url}#{generate_url(entry)}&#8221;<br />
    xml.tag! &#8216;lastmod&#8217;, entry.updated_at.strftime(&#8220;%Y-%m-%d&#8221;)<br />
    xml.tag! &#8216;changefreq&#8217;, &#8216;monthly&#8217;<br />
    xml.tag! &#8216;priority&#8217;, &#8216;0.8&#8217;<br />
  end<br />
end<br />

This iterates through the blog entries, which are contained in the @entries variable set in the controller. This is then followed with identical code for the @jobs variable.

For each of the static pages (including the blog and job indexes), I use the following code assigning them higher priorities than the individual blog and job entries.

<p>xml.tag! &#8216;url&#8217; do<br />
    xml.tag! &#8216;loc&#8217;, &#8220;http://www.capturedsparks.com/about/&#8221;<br />
    xml.tag! &#8216;changefreq&#8217;, &#8216;monthly&#8217;<br />
    xml.tag! &#8216;priority&#8217;, &#8216;1&#8217;<br />
end<br />

The resulting xml file can be seen here.

About the sidebar

Robin Fisher — 2008-02-25T22:35:11+00:00

I’ve add a sidebar to the individual blog entry pages so that I can let visitors know that we do some web design.

Just to confirm that I haven’t left off my ruby output tags. The idea of using variable names was inspired by Wil Wheaton and the auto-responder he used to have.

Creating monthly archives in Rails

Robin Fisher — 2008-02-28T21:34:08+00:00

Whilst creating my own blog software has made me realise how little I needed compared to the vast functionality of readily-available software, one of the things I did want was a monthly archive view.

The first thing I did was create a method in the Entry model that would assign each entry an “archive link” consisting of the month and year in which the entry was created:

<p>class Entry &lt; ActiveRecord::Base</p>
<p>after_create :create_archive_link<br />
&#8230;<br />
def create_archive_link<br />
  month = self.created_at.strftime(&#8220;%B %Y&#8221;)<br />
  month = month.downcase.sub(/[ ]/, &quot;&quot;)<br />
  self.month_year = month<br />
  self.save<br />
end<br />

I have to confess at this point that I broke from the RESTful conventions that I try to employ and created a monthly_index method in the entries controller:

<p>def monthly_index<br />
  @entries = Entry.find_all_by_month_year(params[:month])<br />
  @entry = @entries<sup class="footnote"><a href="#fn1">1</a></sup><br />
  @all_entries = Entry.find(:all)<br />
end<br />

For the blog index, I then list the monthly archives using the following code:

<ul>
&lt;% @all_entries.group_by(&amp;:month_year).each do |month, entries| %&gt;
    <li>&lt;%= link_to &#8220;#{month} (#{entries.size})&#8221;, monthly_archive_url(month.downcase.sub(/[ ]/, &quot;&quot;)) %&gt;</li>
&lt;% end %&gt;
</ul>
<p>

This code does several things in a short space of time:

1) Groups each entry by a defined month_year method resulting in a hash keyed on the month_year method

2) Prepares to iterate through the hash based on the month_year key

3) Lists the month name and the number of posts in that month with a link to a monthly_archive_url route that is defined in routes.rb

In routes.rb, the following route is defined:

<p>ActionController::Routing::Routes.draw do |map|<br />
&#8230;<br />
  map.monthly_archive &#8216;entries/archive/:month&#8217;, :controller =&gt; &#8216;entries&#8217;, :action =&gt; &#8216;monthly_index&#8217;<br />
&#8230;<br />
end<br />

I think the code could be cleaned up a little bit by defining more methods in the model. Just writing this has made me think that I should define a method to convert the archive link of february2008 back into February 2008.

What I have found is that writing a lot of the code needed to run an effective blogging platform is not particularly complicated when the function needed is broken down into a series of steps.

A little bit on growl and Autotest

Robin Fisher — 2008-03-02T19:08:40+00:00

There’s not a lot that I can say that hasn’t been said already on this subject. I’ve managed to get this working tonight via a combination of John Nunemaker and Aisle Ten.

John’s blog entry is a great high level overview of how to get it to work and Aisle Ten’s post will come in very useful if you run into any problems.

dConstruct 2008

Robin Fisher — 2008-03-03T15:06:50+00:00

I absolutely love this design for dConstruct 2008.

Intaeco goes live

Robin Fisher — 2008-03-09T20:39:25+00:00

Due to pressing issues at work, I haven’t had the chance to say that Intaeco has gone live.

The company sells environmentally friendly plumbing and heating products such as solar heating systems. The site is static in nature aside from some PHP for the contact form and jQuery is used for the javascript effects.

ActiveMerchant, Paypal and Rails

Robin Fisher — 2008-03-25T21:35:22+00:00

EDIT: I have followed this up with a further post, More on ActiveMerchant and Paypal.

I’ve spent most of the past week playing with ActiveMerchant and Paypal in order to implement recurring billing for my app.

After a false start with Datacash and some fumbling in the Paypal Sandbox, I got started with a test account for Website Payments Pro (UK). This has the benefit of using Paypal as your gateway service and also as your merchant account. The fees for processing are slightly higher than other gateways but I find the all in one solution worth it so far.

I should mention at this point that Cody Fauser’s ActiveMerchant PDF from PeepCode was invaluable in giving me a start to integration. Although the book is geared towards a straightforward purchase (rather than recurring billing), the code was a great starting point. Thankfully, the ActiveMerchant library is very well commented and easily understandable.

In brief, to setup the recurring billing (implemented through Subscription model), an account is created using the subdomain as account key model. If the account is a paying account, the user is redirected to a secure page to enter their credit card details and create the subscription. The credit card information, amount to be billed and frequency are passed to Paypal in the following form:

<p>Subscription.recurring(amount, credit_card, options = {:ip =&gt; request.remote_ip})<br />

This calls a method on the Subscription class which sends the data to Paypal. If a successful response is received, the response and other information is stored in the database.

In terms of updating the subscription, this is easily done with the AM library by sending the profile id (which is returned by Paypal when recurring billing is set up) along with the recurring billing request. Using this method, credit card details, payment amount and frequency can be simply changed.

I’m more than happy to share the code I’m using if you want to leave a comment.

Busy times

Robin Fisher — 2008-05-10T13:26:19+00:00

I haven’t had much opportunity to post here recently due to some travel and a mix of work on my own projects and work for clients. Aside from my development work, I also maintain a few websites and the updates and maintenance for these have been coming thick and fast.

One of my own projects is approaching fruition. It’s a small application that allows people to review coffee shops that are local to them or that they visit. The idea came following a trip to Hull where I had about 5 hours to kill and there was no way to find details of a good coffee shop where I could spend a few hours. I suppose I hope it may help unearth some gems and stop people heading for the nearest Starbucks or Costa.

The application uses the Google Maps API and the GeoKit plugin to geocode the location of coffee houses. I think this is the type of application that really suits having a mobile version and once the web version is sufficiently complete, I’ll work on producing a mobile friendly version. There is quite a bit to do, but I’m going to push it live in the next month and hopefully get some feedback that will drive continued development.

I also hope to write up a bit more detail on ActiveMerchant and PayPal as I note from the logs that the entry on that topic has received quite a bit of traffic and I think it is definitely a topic that could do with more documentation.

A new look

Robin Fisher — 2008-05-18T18:38:23+00:00

I’ve spent the past few weeks working a redesign for captured sparks and this weekend, as you can see, I have put it live.

I have also taken the opportunity to implement some functionality that has been missing. As you might know, captured sparks is published on my own system coded in Rails and even though I have had the basics running for a few months, there were some key things that I needed but never found the time to implement.

During the course of the redesign, I’ve added the following functionality:

Post Status

I can now classify a post as either a draft or published.

Comment Administration

Up until now, I have had to manage any comments by logging into the server and directly editing the database through the Rails console. I’ve now added the ability to approve or reject comments in the admin area.

I’ve also made the decision to effectively ignore IE6. The site uses PNGs for titles and I’ve not taken any steps to address IE6’s failure in this regard. Nor have I checked to see how the site looks in IE6 generally. I’m using IE conditional comments to present a friendly warning to those users with IE6 that the site may not look great and suggesting an upgrade.

More on ActiveMerchant and Paypal

Robin Fisher — 2008-05-18T19:02:09+00:00

I’ve had a few comments asking for some more information setting up AM with Paypal. I won’t profess to be an expert and there may be better ways of doing this.

I am using Paypal UK Website Payments Pro and for this have set up an account that gives me access to Paypal Manager.

As per my previous post, an account is created using the account key as subdomain model:

<p>def create<br />
    <code>account = Account.new(params[:account])
    @account.initial_plan = params[:plan_id]
    if @account.save
      @account.set_admin
      if @account.initial_plan == "2"
        redirect_to :host =&gt; account_host(

account.name), :controller => ‘sessions’, :action => ‘new’
else
redirect_to :host => account_host(@account.name), :controller => ‘subscriptions’, :action => ‘new’
end
else
flash[:error] = “Could not create account. Please try again.”
redirect_to :controller => ‘accounts’, :action => ‘new’
end
end

If the customer has selected anything other than a free account, they are redirect to the new action of the subscriptions controller. I am using the subscription model to act as a join between an account and a particular plan.

The template for the new action is a simple form with space for credit card information. Creating a subscription calls the following create action in the controller:

12	<p>def create<br /> <code>plan = Plan.find_by_id(

account.initial_plan)
first_name = params[:cc_name].split(’ ‘)⁰
surname = params[:cc_name].split(’ ’)¹
name = params[:cc_name]
number = params[:cc_number]
amount = @plan.price*100
credit_card = {
:number => “#{number}”,
:first_name => “#{first_name}”,
:last_name => “#{surname}”,
:name => “#{name}”,
:month => “#{params[:cc_month]}”,
:year => “#{params[:cc_year]}”,
:verification_value => “#{params[:cc_cvv]}”,
:type => “#{params[:cc_type]}”
}
subscription = Subscription.recurring(amount, credit_card, options = {:ip => request.remote_ip})
if subscription
subscription.plan_id = @plan.id
subscription.account_id = @account.id
subscription.save
flash[:notice] = “Your account has been setup. You can now login!”
redirect_to matters_url
else
flash[:error] = “YIKES!”
redirect_to new_subscription_url
end
end

I have no doubt that a lot of this could be refactored into the model. At the moment, I am focussing on getting the app running, not tidying up the code. You will note the class method “recurring”, which is in the subscription.rb file. The code for this is taken straight from the AM pdf mentioned in my earlier post so I cannot repost that here. This method creates a connection through AM to Paypal and creates a recurring subscription. Information that is returned includes a profile id that can be used to uniquely identify a particular subscription in both the app and Paypal manager.

Updating the subscription is fairly similar to creating a new subscription except you pass the profile id through so that Paypal knows which account to change.

One thing to note is that it is important to ensure consistency between Paypal and the subscriptions table in your app. It is very easy to update a subscription in Paypal so that a customer is billed the correct amount but fail to update the internal record in your app. This will result in revenues being either significantly higher or lower than you expect.

One of the questions in the comments to the original post is how much information in the pdf was relevant to Paypal US. I can’t directly answer that but I can say that the code works as a great starting point but some re-coding will necessary to make it work for your app.

The final 10%

Robin Fisher — 2008-05-27T11:53:34+00:00

The final 10% is always the hardest bit to do. Unfortunately, it’s generally that bit that makes something really work. It stops something being OK and makes it great. It makes you go “Wow”.

On my coffee application (I still don’t have a name apart from wanna coffee?, which I don’t like), the majority of the functionality is there. In its most basic form, the app works. It just doesn’t have that polish and that is what I’m talking about. That is the final 10% and I wouldn’t be happy launching it without that polish. I’m happy if some areas of functionality are not present at launch, provided they are not core to the purpose.

What I don’t want to do is launch at 90% of what I want, and would expect, version 1 to be like. It’s that 10% that I’m working on now.

Want Beans

Robin Fisher — 2008-06-08T12:52:20+00:00

I’m happy to announce the launch of Want Beans!

Want Beans is a social network for reviewing and rating coffee shops and finding great places to grab a coffee when you’re out and about.

As I mentioned in an earlier post, the idea was inspired when I had about 5 hours to kill in Hull and just wanted to find somewhere to hang out with my MacBook.

I hope that you’ll register and add your favourite cafe to help other people discover great places to grab a latte. To get started, please visit Want Beans.

Receiving emails with Ruby on Rails

Robin Fisher — 2008-06-17T08:29:55+00:00

I spent the weekend getting a little application to play nicely with emails being sent to it. As receiving emails with Rails is something that is not written about as much as sending emails, I thought I would share my solution.

This tutorial will show you how to receive emails into your application, store them in the database and forward the contents to multiple recipients.

The first problem of course is getting the emails into your application. I have root access to my server, so my solution uses Postfix. If you don’t have root access, you can use POP and there are a number of examples out there. On with the instructions…

As I am hosting a number of domains on the same box, I set up my main.cf file as follows:

12	<p>virtual_alias_domains = mydomain.com<br />virtual_alias_maps = hash:/etc/postfix/virtual<br />

I then set up my virtual file (which you may need to create) with a single line:

<p>@mydomain.com rails_mailer<br />

This will intercept any emails sent to mydomain.com and pass them to the rails_mailer alias, which is created in your alias file. Mine is located in /etc/aliases: yours might be in /etc/postfix/aliases. Add to the bottom of your aliases file:

<p>rails_mailer: &#8220;|curl <del>F mail=&#8217;&lt;</del>&#8217; http://mydomain.com/emails&#8221;<br />

This uses curl to post the mail as form data to the given url. The email contents will be stored inside the mail parameter. The pipe character at the start indicates that this is a shell command and not a directory.

To apply all these changes:

123	<p>sudo postmap /etc/postfix/virtual<br />sudo newaliases<br />sudo /etc/init.d/postfix reload<br />

To check that this is working, change into your /var/log directory and use:

<p>tail -f mail.info<br />

Then send an email to any address @mydomain.com and you should see it received in your mail log and passed to your Rails app. If you look in your app’s logs, you should see it spitting out a 500 error as there is no code to handle the email…yet.

On to the Ruby. Create an Emails controller and define a create method:

<p>def create<br />
  if params[:mail]<br />
    Notifier.receive(params[:mail])<br />
  end<br />
end<br />

This receives the contents of params[:mail] and passes it to the receive method of our notifier model.

To deal with Rails’ cross-site scripting protection, you need to add to the top of your controller:

<p>skip_before_filter :verify_authenticity_token<br />

Next, generate a mailer called notifier. In notifier.rb, define a method called receive(email). Using this method name automatically invokes the power of TMail. My receive method is as follows. You will need to change this to make sure you pull the information you need from the email:

<p>def receive(email)<br />
  event_name = email.to<br />
  event_name = event_name.to_s.sub(&#8216;@mydomain.com&#8217;, &#8217;&#8217;)<br />
  event = Event.find_by_tidy_name(event_name)<br />
  body = email.body<br />
  address = Array.new<br />
  event.attendees.each do |attendee|<br />
    address &lt;&lt; attendee.email.to_s<br />
  end<br />
  from = email.from.to_s<br />
  new_email = event.emails.new<br />
  new_email.from = email.friendly_from<br />
  new_email.body = body<br />
  new_email.save<br />
  Notifier.deliver_event_email(event, from, address, body)<br />
end<br />

Before running through this code, I should explain that when people use the app, they receive a dedicated email address in format myeventname@mydomain.com.

This code does two things. Firstly, it extracts the following data from the email: the name of the event, the body of the email and who the email is from. It then constructs a new email that belongs to the event and saves to the database. It then invokes another method in our notifier.rb to forward the email body to the individuals who are attending the event.

<p>def event_email(event, from, address, body)<br />
  setup_email(from)<br />
  @bcc = address<br />
  @subject += &#8220;#{event.name}&#8221;<br />
  @body[:body] = body<br />
end<br />

In terms of the application that I wrote this for, I hope to launch it within the next week. If you’ve got any questions or run into any problems, leave a comment and I’ll try and help.

Eventamatic!

Robin Fisher — 2008-07-06T17:08:36+00:00

I’m pleased to announce the launch of Eventamatic!, a simple way for you to manage your events.

Building Buzz

Robin Fisher — 2008-07-14T21:35:27+00:00

37signals, who are perhaps best known for Basecamp, have just posted an interesting blog post on how they built buzz in their early days. It’s a great look back at the origins of a company that now inspires a lot of other web design and web application companies. Not just in terms of the work they produce, but also in terms of their approach to running a business.

What the post highlights is how it is not always necessary to focus on what you do provided that the things you are doing are related to your primary activity. Ideas like the E-Commerce Search Report and Design Not Found offer an “in” to prospective customers.

I also subscribe to Seth Godin and one of the ideas he promotes is to always offer content. Seth has a new post on his blog every day (or thereabouts).

It takes a concerted effort to build buzz and drive business. The posts here at captured sparks have always been a little sparse, and mainly related to web development. From now, I will be making a concerted effort to post more.

Empowerment

Robin Fisher — 2008-08-07T20:12:59+00:00

I was at a meeting a couple of days ago and somebody raised a question about empowerment for the employees. They seemed to be looking for an indication from our CFO that they would be empowered to, and entitled to, make decisions without having to refer it to a manager.

I found the question extremely strange as I have always considered the company for which I work to delegate a lot of responsibility to the employees. I have never felt constrained or not permitted to make a decision and thought it odd that a colleague did.

One of the things I do find is that people often shirk that responsibility. They ask for it. They want it. They want to feel that the company trusts them to do the right thing. But they don’t actually want to take action. They are too scared of making the wrong decision.

When recruiting people, I’m always interested in finding out how they respond to that kind of empowerment. I ask them for an example of when they took a wrong decision at work and how they coped with the consequences. Did it deter them from making further decisions?

Giving people the power to make decisions is half the battle. Creating a culture where people feel secure in actually making them is the other half. Where they don’t think they will get fired if it goes wrong. Where genuinely acting in the best interests of the company is the important thing.

Want Beans Update

Robin Fisher — 2008-08-07T20:25:25+00:00

You no longer need to create an account to create a cafe on Want Beans. Add your favourite coffee house by visiting the new cafe page.

Equal height columns

Robin Fisher — 2008-08-17T11:46:34+00:00

One of the common issues that has plagued web designers is how to ensure that a sidebar column with a background colour will fill the height of the page when a second column is much longer. One of the most used options is Faux Columns by Dan Cederholm.

I’m going to show you how to quickly achieve identical height columns using jQuery.

We start with a simple layout:

<div id="main">
<div id="sidebar">
Lorem ipsum..
</div>
<div id="content">
Lorem ipsum&#8230;
</div>
</div>
<p>

We can then use the following jQuery code to ensure that the sidebar is always equal to the height of the content column:

<p>var mainHeight = jQuery(&#8216;#main&#8217;).height();<br />
  if (mainHeight &gt; 280) {<br />
    jQuery(&#8216;#sidebar&#8217;).css({<br />
      height: mainHeight<br />
    });<br />
  } else { <br />
  };<br />

This grabs the height of the #main div and if that height is greater than 280px, dynamically adjusts the height of the sidebar to match.

Update!

Robin Fisher — 2009-02-15T18:39:30+00:00

So, my last entry here was 17th August 2008. And that was written just over a month after I said I would post more. Work took over. My full-time job was incredibly busy during the last 3 months of 2008 and the I have been working on a Rails site since October and that is still ongoing. As a result of this combination, I never really had the opportunity to post anything to the blog.

For me, 2008 was a good year. During 2007, my site received 200 visits. In 2008, it received over 1700 visits. This was driven primarily by three articles I wrote on 2 subjects – combining ActiveMerchant and Paypal (something I still receive emails about) and receiving emails with Rails. The visitor numbers have kept up through January 2009 and I hope to post more this year to drive more traffic.

The site I’m working on at the moment is a straight-forward brochure site although I have done a nice implementation with Google Maps to show the nearest stockists for the products sold by the client. This should be finished within the next month, following which I hope to work on a small project of my own. Nothing concrete as yet but have some ideas floating round my head.

Finally, I’ve been spammed massively in the comments. If you left a comment after 16 January, I’m afraid I’ve had to delete it as I couldn’t go through 2000 comments to identify the genuine ones. Sorry again.