Coding With Ruby on Rails

AJAX with Ruby on Rails! Connecting to the Database!

justinbgood — Thu, 16 Jul 2009 02:16:41 +0000

IF you are looking for good tips on how to make proper AJAX calls in Ruby on Rails, this post is for YOU! I had to look around for the longest time to find good RoR examples of using AJAX, and yet, there really wasn’t a lot out there. However, once I finally figured out I realized how EASY Ruby on Rails makes using Javascript and AJAX calls. So now, I have come here to show YOU what took me soo long to figure out.

First off lets jump to our end goal. What are we trying to achieve? Let’s say we are creating an application and on one of our pages we want to gather information from our database without having to make the user redirect to another page or refresh the current one. This is exactly what AJAX was built for. Asynchronous calls between the server and the database.

In this example, we are going to implement a “building” search bar that will search our database for Building objects by building name. I have found this useful if you are trying to use google maps API and create a map with your own database stored buildings.

First things first… newer versions of Ruby on Rails such as 2.0 and above already have an awesome Javascript/AJAX library included: Prototype! This library is going to make our lives a LOT easier, however, I will also show you how to do these AJAX calls WITHOUT using Prototype so you see REALLY whats going on.

Open up your layout/application.html.erb or site.html.erb (yours could be named otherwise, but basically whatever layout you are using). Mine looks something like this:


<!DOCTYPE HTML PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html>
<head>
<title><%= @title %></title>
</head>
<body>
<div id="container">
<div id="site_content">
<%= yield %>
</div>
</div>
</body>
</html>

We need to first allow our application to use the Prototype library by adding this to our section:


<head>
<title><%= @title %></title>
<%= javascript_include_tag :defaults %>
</head>

This will allow us to use all of the Prototype library calls. Next we need to create our Javascript function that will be called when the user hits our search button. (note: We could also use Prototype to have an AJAX called be sent on a time interval without having the user to click anything. This is similar to what facebook uses for notifying users of new notifications and messages.) I am going to call my function ajaxSearch(). You are going to also want to put your script in the layout header as well, so it is accessible on all pages.


<head>
<title><%= @title %></title>
<%= javascript_include_tag :defaults %>

<script>

function ajaxSearch() {
//this is where our search code will go

}; // end ajaxSearch function

</script> // end script
</head>

Now lets make our search bar and button so that we can call our ajaxSearch function, even though it is not filled with code yet. This code can be placed anywhere on the app. If you want it on every page you need to put it in the layout page, but if you want it on a single page, just put it on that one. Either decision you choose your code is going to look like something like this.


<div id="search_box">
<form action="#" onsubmit="ajaxSearch(); return false;"> // this sets ajaxSearch() to be called form submit
<input style="width: 300px;" type="text" name="q" value="" id="q" />
<input id="search" type="submit" value="Search" />
</form>
</div>

Okay. So now we have a text bar that we can write into and calls the ajaxSearch() function. Now we need to handle the call and do our AJAX search. Change your ajaxSearch to look like this.


function ajaxSearch() {
var query = document.getElementById('q').value;
if( query == '' ) { return; }

document.getElementById("search").value = 'Searching...';
document.getElementById("search").disabled = true;

// AJAX call will go here
}; // end ajaxSearch function

What we have done is saved the text in the box to query, returning if it is null, and changed our search bar to be unaccessible while the AJAX search will be working. Next we need to create our AJAX request. This is where Prototype is going to become our best buddy! Usually when you make a AJAX XMLHttpRequest you need to check for browser compatibility and do lots of other LONG code-y stuff that is good to know but quite annoying. Prototype library AJAX request handles all of this for you behind the scenes, and it comes with Rails! Now lets enter our AJAX request where the // AJAX call will go here – was:

req = new Ajax.Request('/buildings/ajax_buildings', {
method: 'get',
parameters: { q: query },
onComplete: function(transport) {
processReqChange(transport);
}
});

beautiful, isn’t it? What this does is sends an AJAX request to our Buildings controller and calls the ‘ajax_buildings’ action as a GET-er, while also sending the parameters params[:q], which is our query object, and on request completion will run processReqChange(), another function we must write. Lets take a look at our controller code, which in this example is for returning and array of Building objects. This part looks really sweet too.

 // buildings/ajax_buildings <-- in buildings_controller.rb

def ajax_buildings
if params[:q]
@buildings = Building.find( :all,
:conditions => [ 'name LIKE ?', '%' + params[:q].downcase + '%'],
:limit => 20)

render :json => @buildings
end
end

This action searches our application database for all Building objects that have their name property containing the suggested word entered in the search bar – params[:q], and I just threw a limit of 20 on their to stop possible over-flooding of objects. We then return a rendered text, an array of buildings, in a json format. That is JavaScript Object Notation. Although JavaScript can not directly use this string, we can change it into its proper format in a second.

Now for the final piece of our puzzle, we need to create our processReqChange() function that is called once the AJAX search is finished.

 // inside of our <script>

function processReqChange(req) {
// request is complete
if (req.readyState == 4) {
var results = req.responseText;
var buildings = eval("("+results+")");
var size = buildings.length;

if(buildings.length == 0) {
alert("No matches were found!");
return;
}

// do all the work you want with your data

// CODE

// CODE

//  CODE

} // end if req == 4

}; // end function

Notice that what we sent in as ‘transport’ is now called ‘req’. First we double check to make sure the readyState is equal to 4, which means the AJAX request is completely finished and we may now do our work with the data. We then store the response text into ‘results’ (this is our array of buildings string in json format). The next line of code: var buildings = eval(“(“+results+”)”); – is a special command that I was told by my mentor is usually never used except for special circumstances, such as this! This essentially turns that string of a bulding array into an ACTUAL array that we can use! That’s right, we can USE it nowlike ANY other JavaScript array. buildings[0] will yield the first building in the array and you can use call ALL of the parameters of the building as such. Ex: buildings[0].name – will yield the first building’s name in the array.

Now that you have an array of the data you wanted, you can fill in the rest by manipulating and using that data however you want to. AWESOME! So, in conclusion, what we have done is easily and code-efficiently created a search bar that could potentially search and return any information, array of data or object from our database without having the user load or refresh to another page! It’s THAT easy!

Below is what your html.erb (or .rhtml) file would look liek put all together…


<!DOCTYPE HTML PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html>
<head>
<title><%= @title %></title>

<%= javascript_include_tag :defaults %>

<script>

function ajaxSearch() {
var query = document.getElementById('q').value;
if( query == '' ) { return; }

document.getElementById("search").value = 'Searching...';
document.getElementById("search").disabled = true;

req = new Ajax.Request('/buildings/ajax_buildings', {
method: 'get',
parameters: { q: query },
onComplete: function(transport) {
processReqChange(transport);
}

}); // end ajax req
}; // end ajaxSearch function

function processReqChange(req) {
// request is complete
if (req.readyState == 4) {
var results = req.responseText;
var buildings = eval("("+results+")");
var size = buildings.length;

if(buildings.length == 0) {
alert("No matches were found!");
return;
}

// do all the work you want with your data

// CODE

// CODE

//  CODE

} // end if req == 4

}; // end function

</script>

</head>
<body>
<div id="container">
<div id="site_content">

<div id="search_box">
<form action="#" onsubmit="ajaxSearch(); return false;"> // this sets ajaxSearch() to be called form submit
<input style="width: 300px;" type="text" name="q" value="" id="q" />
<input id="search" type="submit" value="Search" />
</form>
</div>
</div>
</div>
</body>
</html>

That, and putting in the correct Controller Action – ajax_buildings (or w/e your desired object is) and your set! This can be used for a lot of different things, such as calling objects, having a text search engine for your own site, uploading notifications instantly, basically anything you can imagine. It’s good to know that something as difficult as AJAX calls and JS functions can be so simple and straight forward! Thank you so much for reading my article on AJAX on Ruby on Rails. If you like it please feel free to leave a comment. You can also e-mail me if you have any questions at jbryant@inigral.com.

More information on the Prototype library can be found at their website: http://www.prototypejs.org/learn

If you liked this article, please link it on yours or any other site! Thanks a bunch guys! Good coding to all!

Ruby on Rails – YouTube on Facebook

justinbgood — Wed, 17 Sep 2008 00:58:48 +0000

So for one of my websites, I wanted to allow users the ability to post youtube videos of themselves for there skateboarding. Now after thinking it over I thought of a pretty primitive yet effective way to quickly, and efficiently do it without taking up lots of space or memory.

Its as easy as this. Create a column you want int the correct table called “video”. Example: If you want each User to have their own video you would add a column, you would use a migration file to add a text column to the User table. That way you could now do User.video and it would point to a text object.

Now, for Facebook to properly use a you tbe video you must call the FBML function:

Now, the link to the video must be a certain format, and it is NOT the default hyperlink to the actual video. Say you were to search for a video it would look something like this.

http://www.youtube.com/watch?v=cbYrXR87cvE

However, if you put this in as the hyperlink it will NOT work. The correct link that it requires looks a little different. Instead of /watch?v=[video ID] it looks for a /v/[video ID]. Thus the link would have to be http://www.youtube.com/v/cbYrXR87cvE. So, I figure the easiest way to make this for the user is, allow them to use the INCORRECT link to store into your databse. But, inside your Model Helper create this helper function. Call it youtube_embed.

module CrewsHelper def youtube_embed(video_id) return video_id.gsub('watch?v=', 'v/') end end

What this does is recieves a String video_id (coul dbe named anything) and uses the usefule ruby gsub method to simply replace the “watch?v” with “v/”. This will turn it into the correct hyperlink format to work. Now to actually you the method you would do something like this.

# if the video param for User is not null (i.e. has a link) do this

Now, every time that page is loaded, if the user has a youtube video that he put into his video param, it will show up on that page! Pretty straight forward I hope. Enjoy!

-Justin Bryant

AB Email Testing

justinbgood — Mon, 18 Aug 2008 23:54:45 +0000

Today I learned some nifty tricks for AB email testing for ruby on rails applications. What is AB Email Testing you ask? Thats a good place to start at. When you own an application that has many users you are going to want to email them information. Whether its to tell them of a new offer, or update them on something, your ultimate goal is to get that reader engaged in your email and follow the links you offer them. AB testing is a simple test of sending out multiple versions on an email to all your users and seeing which version gets the highest amount of users following the link you supplied them. This is a very important test for marketing your emails. You want to use the email with the greatest success rate. So now we have a few things we need to do to get the to work. 1) we need a easy way to send emails to all your users. 2) we need a system of sending different versions of that email to each user. 3) we need a way to store and keep track of how many users clicked each link and figure out which one has the higest success rate.

Hopefully after this blog entry you will be able to create your own AB test system. There are many programs and companies that will sell you this service, which would probably be much easier, but sometimes the easiest route isn’t the smartest. By following this blog you will be able to fully create and control your own AB email tesing system, making it as specific and customized for your app as possible.

For this blog I am going to assume that you have an ActionMailer set up and working for your application. The ActionMailer I will be referring to in my blog is called SignupMailer. Yours may be called anything as long as it inherits the ActionMailer class. Now lets begin…

The first thing we are going to want to do is create a table in our database that will store all the information we desire. Lets create a model for our tracking system… I called my model “Click”. Everytime a user hits the link button a Click will be created and added to the database, and that will hold all the information we will find useful. Lets start this now shall we?

go ahead and -> ruby script/generate model Click

now go into your newly created migration file called. ####_create_clicks. Lets add some useful information that it shoul dbe holding. For mine I woul dlike to keep track of a few things. 1) The User who clicked the link. 2) The name of the email being sent. 3) what version of the email it is. 4) the location you want to send the user too after they click the link. Here is my migration file
class CreateClicks < ActiveRecord::Migration def self.up create_table :clicks do |t| t.column :user_id, :integer # user id t.column :email_name, :string #email name t.column :variation, :integer #version number t.column :link, :string # link we want to send our users to t.column :created_at, :timestamp # information on when the link was pressed end end

def self.down drop_table :clicks end end

now you can rake db:migrate the newly made migration. So now we got our table which we can create Clicks and add them to the database. How and when do we create these clicks? and how do we send the emails? There are many different ways to go about doing this, but I will do what works well for me. I am going to create a rake file that by simply executing from the command line will send all of your users emails of different versions with the ability to track whether or not they have been clicked.
The next thing we need to do is create a controller for our Clicks. Go ahead and
ruby script/generate controller Clicks
inside make a function link.
def link end
we will fill that in later. Now lets begin with our rake file. Move into your lib/tasks folder and create our rakefile. If you do not have this directory simply create one. Now lets assume we have a new promotional email we want to send out and we want to find out which of the 3 versions we have is most efficient at drawing users. We will want to create a rakefill called promo1 (assuming you may have other promos later we will want to start with 1 and work our way up after that. so create your promo1.rake file inside lib/tasks and open it up. inside of it put this.
# Provide tasks to load and delete user data require 'active_record' require 'active_record/fixtures'


namespace :db do

  namespace :promo1 do 
    desc "Send The Emails!"

    task :load => :environment do |t|

      send_emails

    end

  end

end

def send_emails end
when you run this rake file it will load and run the send_email functions which we will now create.

def send_emails users = User.find :all # gets all users in database


  users.each { |user| # goes through each user
    variation = rand(2)+1 # picks a random number from 1 - 3

    email_name = "promo_" + variation.to_s # our promo name with the variation at the end

    redirect_control = "login" # the controller we want to call

    redirect_action = "login" # the action we want to call from that controller
# now we will check which of the 3 versions we will send to the user

    if variation == 1

#we must send a bunch of these params to the ActionMailer so it can use it later

      SignupMailer::deliver_promo_1(user, email_name, variation, redirect_control, redirect_action)
    elsif variation == 2

      SignupMailer::deliver_promo_2(user, email_name, variation, redirect_control, redirect_action)
    elsif variation == 3

      SignupMailer::deliver_promo_3(user, email_name, variation, redirect_control, redirect_action)
    end

  }

end
and thats it. the rakefile is done. But we are not quite done yet. Lets now go back to our clicks controller. Now lets fill in what we want in the link function.

def link # all of these params we will specify in our link we create for our emails user_id = params[:id] email_name = params[:email] variation = params[:variation] control = params[:redirect_control] action = params[:redirect_action]


    link = "http://www.yoururl.com/#{control}/#{action}"
    click = Click.new(:user_id => user_id,

                      :email_name => email_name,

                      :variation => variation,

                      :link => link,

                      :created_at => DateTime.now)
    click.save

redirect_to :controller => control, :action => action end

pretty straight forward huh? we just send it all the info we desire from the email. Save it into a new click object. and voila! its stored in our database. Now lets create our promo_(1-3) emails. Lets open our ActionMailer model and create the proper function calls.

SignupMailer.rb (model file)
def promo_1(user, email_name, variation, redirect_control, redirect_action) from "admin@standardissimo.com" recipients user.email subject email_name content_type "text/html" body( :recipient => user, :email_name => email_name, :variation => variation, :redirect_control => redirect_control, :redirect_action => redirect_action) end


  def promo_2(user, email_name, variation, redirect_control, redirect_action)

    from "admin@standardissimo.com"

    recipients user.email

    subject email_name

    content_type "text/html"

    body( :recipient => user,

          :email_name => email_name,

          :variation => variation,

          :redirect_control => redirect_control,

          :redirect_action => redirect_action)

  end

def promo_3(user, email_name, variation, redirect_control, redirect_action) from "admin@standardissimo.com" recipients user.email subject email_name content_type "text/html" body( :recipient => user, :email_name => email_name, :variation => variation, :redirect_control => redirect_control, :redirect_action => redirect_action) end
so here we are sending all of our given params to the BODY which is very important. The body is what gets sent to the email .rhtml file to be used as a local variable. Now lets create our new SignupMailer .rhtml email files. Move into your views/SignupMailer folder and create promo_1 – promo_3. Now lets add the actual code to this .rhtml file.

views/signup_mailer/promo_1.rhtml


 Promo 1 
<%="" %>Click here four our promo!

now here is the true beauty of all this. we are actually sending our users who click on this link directly to our click controllers link action while sending with it the necessary parms such as user_id, email, variation, control and action. Once you copy this for your other 2 promos, changing the wording and varying the way it feels you are DONE. thats right. ready to test now? all you have to do for this to work is go to your console, move into your application and runrake db:promo1:loadand shabam! you should have a bunch of emails all of different random variations being sent out, with the capability of tracking which emails were clicked with detailed information about them including when exactly it was clicked. Thanks for reading my tutorial and I hoped this helped some AB email testers out there. I do realize that there are probably other ways to go about doing this. I have found that this is the simplest and efficient way to create your own working AB email testing system. Thanks all!



Rake Files To Upload Test Users!!!
justinbgood — Mon, 04 Aug 2008 23:22:41 +0000
Today I learned a few tips and trick about uploading data into a database for testing purposes. Lets say you are creating a large social network application that will have many users and many associations between those users. When you are in the development stage you may want to see exactly how your code will work when you have many users. A great way to do this is upload a large amounts of test data or users to “test” the functionality of your site.
Although there are many ways to do this, I have found that a good way to accomplish this is by using rake files.  You can call a rake task when you are in your console and it creates information quickly and efficiently. I need to state that the source code for this was taken from the Insoshi open source code and then modified. In my example I will create many users, give them jobs and then put them all into one organization. This way, when I start the site I can check and see if everything is working ok.
The first thing you will need to do is create a tasks folder inside your lib folder (if it is not already created). Inside your tasks folder you will need to make a test_data.rake file, a install.rake file, and a test_data folder. Move into your test_data folder. Now create a female_names.txt and a male_names.txt. Inside these files type in the names of the example users you will want to create. example:
male_names.txt



Jimmy Dangle

Fredrick Yammington

Robert Coolridge

Michael Monty

William Wanker

David Devreux

Richard Rottingham

Charles Day

Joseph Myles

Thomas Keaton

Christopher Wallace

Daniel Duckard



do something similar for your females. Now. Move back into the tasks folder and open up install.rake. Input this into the file.
install.rake



# Provide tasks to load and delete test user data.

require 'active_record'

require 'active_record/fixtures'

desc "Install AppName" # change Appname with your Application Name

task :install => :environment do |t|

  Rake::Task["db:migrate"].invoke

end


Now open test_data.rake. you will want to start your file by giving it the proper ActiveRecord inputs like so.
test_data.rake



# Provide tasks to load and delete test user data.

require 'active_record'

require 'active_record/fixtures'

DATA_DIRECTORY = File.join(RAILS_ROOT, "lib", "tasks", "test_data")


Now we will create the code that will run when it is called.


namespace :db do

  namespace :test_data do 

    desc "Load test data"

    task :load => :environment do |t|

      # this will call a method to create people. We will make this in a second.

      create_people

      # you may call any other function you desire here

    end
    # destroy the databse

    desc "Remove test data"

    task :remove => :environment do |t|

      Rake::Task["db:migrate:reset"].invoke

      # get rid of anything you may not want to accumulate

      # Blow away the Ferret index.

      # system("rm -rf index/")

      # Remove images to avoid accumulation.

      # system("rm -rf public/photos")

    end
    # reloads the test data

    desc "Reload test data"

    task :reload => :environment do |t|

      Rake::Task["db:test_data:remove"].invoke

      Rake::Task["install"].invoke

      Rake::Task["db:test_data:load"].invoke

    end

  end

end


Okay. Now we move to the next step. Creating the Create People function. Below the code you just make above put in this.
test_data.rak



...

end

def create_people

  %w[male female].each do |gender| # goes through both male and female users

    filename = File.join(DATA_DIRECTORY, "#{gender}_names.txt")

    names = File.open(filename).readlines

    password = "foobar"
    names.each_with_index do |name, i| # reads through each name in the .txt file

      name.strip! # strips the name of any trailing spaces. 
      # Now here's the trick. I want to make Users because my app uses User Models.

      # You will have to change user to w/e ur app uses.

      # example. person = Person.create! (if you uses Person)

      user = User.create!(    :email => "#{name.split[0].downcase}@example.com",

                              :password => password,

                              :name => name,

                              :user_type => "Instructor") # my users have a user type. Yours may not
      # so now I've created a bunch of users. Voila. They are in the database

      # however I also want to test some other things I have for my users

      # this code will NOT apply to your application but will give you some

      # insight into how to create your own user associations....
      # create the jobs for each person

      # for the purpose of testing

      job = Job.create!(  :title => "Teacher",

                          :user_id => user.id,

                          :school_id => 8,

                          :district_id => 3,

                          :state_id => 44,

                          :is_primary => true  )
      user.jobs < "Fight For Better Wages",

                            :public => true,

                            :group_type => "Protest",

                            :district_id => 3,

                            :author_id => user.id,

                            :state_id => 44,

                            :school_id => 8 )

        user.groups << g # gives the author user the group as well

      # add all others to group

      else

        # find the group just created and put them into it

        g = Group.find_by_name "Fight For Better Wages"

        user.groups << g

      end
    end

  end

end


There you go. Now lets RUN it. Go to your console and change to your application folder. In my example it would be ( cd dev/standardissimo). Now run the rake file. 
rake db:test_data:reload
After this runs all the users and appropriate associations should have been created. Now for all the troubles I ran into. The program i made to use this was running of rails 1.2.4 and it gave me an error in my test_data.rake file with Rake::Task["db:migrate:reset"].invoke so I had to comment it out. This means that after I was done looking at the test users and wanted to get rid of them I had to either A) drop the database and start fresh or B) drop the Users, tables and all other associated tables. I decided to go with route B just because my rake db:migrate takes a LONG time. While I was doing this I noticed that when I tried to drop my Users tables (in MySQL -> delete from users;) it came up with an error.

Cannot delete or update a parent row: a foreign key constraint fails (`standardissimo/groups`, CONSTRAINT `fk_groups_author_id` FOREIGN KEY (`author_id`) REFERENCES `users` (`id`))

What this mean was that there was an association still linked that needed to be deleted. To fix this i had to delete jobs first (MySQL -> delete from jobs;) and then delete the users. Now when I made the groups I had the same problem. Except i got that error when i tried to even delete the groups table. I was quite confused about this until I realized that i had a groups_users table that existed and worked as an association link between the user and groups tables. So I had to delete the groups_users table first, then delete the groups and finally users table. Now this is a pain in the ass so I reccommend upgrading to rails 2.1. That way your rake db:migrate:reset will do that all for you. Anyways… i think that about wraps it up. Hope this helps a little bit!
-Justin Brant
Below is my entire test_data.rake file



# Provide tasks to load and delete sample user data.

require 'active_record'

require 'active_record/fixtures'

DATA_DIRECTORY = File.join(RAILS_ROOT, "lib", "tasks", "test_data")
namespace :db do

  namespace :test_data do 
    desc "Load sample data"

    task :load => :environment do |t|

      @lipsum = File.open(File.join(DATA_DIRECTORY, "lipsum.txt")).read

      create_people

      #make_connections

      #make_messages(@lipsum)

      #make_forum_posts

      #make_blog_posts

      #make_feed

    end
    desc "Remove sample data"

    task :remove => :environment do |t|

      #Rake::Task["db:migrate:reset"].invoke

      # Blow away the Ferret index.

      system("rm -rf index/")

      # Remove images to avoid accumulation.

      system("rm -rf public/photos")

    end
    desc "Reload sample data"

    task :reload => :environment do |t|

      Rake::Task["db:test_data:remove"].invoke

      Rake::Task["install"].invoke

      Rake::Task["db:test_data:load"].invoke

    end

  end

end
def create_people

  %w[male female].each do |gender|

    filename = File.join(DATA_DIRECTORY, "#{gender}_names.txt")

    names = File.open(filename).readlines

    password = "foobar"

    photos = Dir.glob("lib/tasks/sample_data/#{gender}_photos/*.jpg").sort_by { rand }

    last_names = @lipsum.split

    names.each_with_index do |name, i|

      name.strip!

      #full_name = "#{name} #{last_names.pick.capitalize}"

      user = User.create!(    :email => "#{name.split[0].downcase}@example.com",

                              :password => password,

                              #:password_confirmation => password,

                              :name => name,

                              :user_type => "Instructor")
      # Photo.create!(:uploaded_data => uploaded_file(photos[i], 'image/jpg'),

      #             :person => person, :primary => true)
      # create the jobs for each person

      job = Job.create!(  :title => "Teacher",

                          :user_id => user.id,

                          :school_id => 8,

                          :district_id => 3,

                          :state_id => 44,

                          :is_primary => true  )
      user.jobs < "Fight For Better Wages",

                            :public => true,

                            :group_type => "Protest",

                            :district_id => 3,

                            :author_id => user.id,

                            :state_id => 44,

                            :school_id => 8 )

        user.groups << g

      # add all others to group

      else

        g = Group.find_by_name "Fight For Better Wages"

        user.groups << g

      end
    end

  end

end



         


Ajax AutoComplete Help
justinbgood — Tue, 29 Jul 2008 22:36:20 +0000
Okay! So now you have a working database, and you want some way to have an autocomplete complete search bar for those database objects. How are we ever going to get this to work? Luckily for us both, there is the INTERNET! My blog will closely follow the code of another post, because it is the code that I used as well. My job will be to clarify how it is used and some errors and troubles I ran into during my testing period of it.

First, you will want to use the code from this website. AJAX Auto Complete
This example works for facebook and can similarly be used for any other application or production. Firstly, the key to this is that the Options code AND the JavaScript code MUST be placed in SCRIPT braces inside the .html or .fbml file you want to have the search bar in. If you want it on every page you will want this code inside of your LAYOUT page, wherever you want it. I have my code in layout/_header.fbml.erb file, since I have mine at the top of the page in the header. ex:

layout/_header.fbml.erb 


options = {

	preMsgTxt: "search for topic...", // text to display when nothing has been typed

	menuOpacity: 94, // opacity of the menu

	ajaxUrl: _hostname+"/topics/auto_complete_for_table_thing", // url to your data source

	focus: false, // whether or not to auto-focus the textbox upon creation

	onEnter: function(value) { // handler for hitting the 'enter' key

		 console.log(value);

		 document.setLocation("http://apps.facebook.com/researchr/topics/search?topic_search="+value);

	},

	delayTime: 100, // amount of idle time after a keypress before making the ajax call

	clearOnEnter: false // whether or not to clear the text after they hit enter

}; 

function ajaxSuggestFbml(obj, options) {

	this.obj = obj; // Setup the events we're listening to

	this.obj.addEventListener('focus', this.onfocus.bind(this))

		.addEventListener('blur', this.onblur.bind(this))

		.addEventListener('keyup', this.onkeyup.bind(this))

		.addEventListener('keydown', this.onkeydown.bind(this))

		.addEventListener('keypress', this.onkeypress.bind(this));

}

. . . . . . . . . blah blah blah ALLLL that code . . . . .


Okay now… phew. Here is the IMPORTANT facts! notice in your options the AjaxURL line. This will have to be changed to the directory of your auto_complete_for_table_thing function. Now, you will want your auto_complete_for_table_thing in the CONTROLLER of whatever it is your searching in your database. In my case, I want to search through my database for Research Topics that have title’s and body’s. So, I want to put my auto_complete_for_table_thing function inside my topics controller. here is my example:



def auto_complete_for_table_thing # this is for the auto complete function in header.fbml.erb

    topics = Topic.find(:all,

                        :conditions => [ 'page_title LIKE ?', params[:suggest_typed].downcase + '%'],

                        :limit => 30,

                        :order => 'page_title ASC').map { |n| n.page_title }

    topics = topics.uniq

    topics = topics[0...10]

    render :text => "{fortext:#{params[:suggest_typed].to_json},results:#{topics.to_json}}"

  end



notice the differences in my table to the suggested one. I made some changes (which you will have to make to) to make it work correctly for my usage. First I am searching through all of my topics objects in the database. I am using the :conditions => hash to tell it im looking for all instances where the topics “page_title” is LIKE ? (a MySQL command) the suggested type (what was entered inside the search bar). I chose page_title because that is intuitively what a user would be looking for. Example: if the user wanted to know something about Philosophy, most of my topics with have in its page_title Philosophy of …. Philosophy of … etc etc etc. That way, it will now be picked up during the AJAX call. I also had to uniq my topics because I had many topics with the same page_title as another one, this got rid of the ugly duplicates in the suggested topic results. This is not necessary unless you are getting multiple of the same objects you are looking for. 
Okay, now so you created your auto_complete_for_table_thing function in your controller. You must make sure your AjaxUrl in your options is linked to it correctly like mine is.

ajaxUrl: _hostname+"/topics/auto_complete_for_table_thing", // url to your data source

you may have to play with the link to get it pointed to your specific controller which contains the auto_complete function in it. Once its pointed correctly and you have inserted the neccessary JavaScript code given in the example, you will have to now create the actual search bar. There are many ways to create a search bar but I will show you my example. This also is in my layouts/_header.fbml.erb file. (this should be in the same file as the JavaScript and options.

example:



input id="search_box_topics" autocomplete="off" maxlength="20" type="text"/>

input type="button" value="search" onClick="suggestr.options.onEnter(suggestr.obj.getValue());"/>

var suggestr = new ajaxSuggestFbml(document.getElementById('search_box_topics'),options);



this creates the search box and starts up your ajaxSuggestFbml java script function. Once this is put in KABLAM, it should work. If it doesn’t work you should check main things:

1) your options and javascript is in the desired file

2) your search box is in the same file as the java script

3) your auto complete is in your controller and is set correctly

4) your AjaxUrl is pointing correctly to the /controller/auto_complete_for_table_thing
with all of that correctly set up you should have a working auto complete search box connected to objects in your database!
Hope everything works out and that this was helpful!
P.S. Whatever you are searching for (be it first names, last names, titles) should be INDEXED in your migration. This will allow for faster database searching and will shave off a lot of seconds of “would be wait time” for users to get the search results. Google on indexing a column for MySQL databses, because that is what I used for mine.

         


ActionMailer
justinbgood — Thu, 24 Jul 2008 20:29:59 +0000
The ability to control and use e-mail is a crucial part for most modern web applications. Whether you need to send an e-mail to retrieve a lost password or verify the authenticity of a users identity, Rails offers great support for sending and receiving e-mails with its ActionMailer and by allowing the ability to create mailer models. Rails by default tries to send e-mails via SMTP of localhost. If you have an SMTP daemon running and it accepts SMTP e-mails locally don’t have to do anything else to send e-mails. Otherwise you will need to decide another means for your system to send e-mails.



Mailer Models:

The way to create a mail model is like this -> $ ruby script/generate mailer [mail name] ex: script/generate mailer LateNotice

You work with ActionMailer classes by defining public mailer methods that correspond to the types of e-mails that you want to send.
And example of a mailer method:

def late_timeshee(user, week_of)

  recipients user.email

  subject "[Time and Expenses] Late timesheet notice"

  from "system@timeandexpenses.com"

  body :recipient => user.name, :week => week_of

end
Here is a list of all the mail-related options that you can set inside of mailer methods

attachment: Specifies a file attachment. Can be called multiple times for multiple files

bcc: Specifies blind recipient

body: Defines body of the email. Can take a hash or a string. ActionMailer automatically normalizes lines

cc: Specifies carbon copy recipients

charset: The character set to use for message

content_type: Specifies content type of the message. The default is text/plain

from: Specifies the from address for the message

headers: Additional headers to be added to the message hash

implicit_parts_order: Array specifying the order in which the parts of a multipart email should be sorted base on their MIME content-type.

mailer_name: Overrides the mailer name

mime_version: Defaults to “1.0″, but may be explicitly given if needed

part: Enables sending of multipart email messages by letting you define contenttype, template, and body variables.

recipients: The address you are sending the message to. This requires a string, not the user object itself.

sent_on: An explicit sent date

subject: The subject for the message

template: Specify the template name to use for the message.
To make HTML e-mail messages you must make sure your view template generates HTML and set the content type to html in your mailer method. Example:



class MyMailer  "text/html", :body => render_message("signup_as_plain", :account => recipient)

    part  "text_plain" do |p|

      p.body = render_message("signup_as_plain", :account => recipient)

      p.transfer_encoding = "base64"

    end

  end

end
Adding Attachments to an Email

attachment :content_type => "image/jpeg", :body => File.read("example.jpg")

attachment "application/pdf" do |a|

 a.body = generate_your_pdf_here()

end
Sending an E-mail

You should never try to call the instance of the methods directly. You need to call one of the two class methods generated for you based on the instance methods defined in your mailer class. Those two cass methods are deliver_ and create_. Let’s say you wrote a signup_notification instance method on a class named ApplicationMailer, you would want to use the code:



ApplicationMailer.create_signup_notification("exampe@whatever.com")

ApplicationMailer.deliver_signup_notification("example@whatever.com")



ApplicationMailer.new.signup_notification(“example@whatever.com”) # WRONG!



Recieving E-mails
To receive e-mails we will want to use the TMail::Mail class which is a ruby library for email processing. We will want to write a public method named “receive” on one of your application’s ActionMailer::Base subclass. It will make a TMail object instance as its single parameter. When there is an incoming e-mail to handle, you can call a class method named receive on your Mailer class. 
Example:

class MessageArchiver  email.subject, :body => email.body)

   end

end
The receiver class method can be the target for a Postfix recipe or any other mail handler process that can pipe the contents of the email to another process. The Rails runner script makes it easy to handle incoming mail:

./script/runner ‘MessageArchiver,receive(STDIN.read)’

This way, when the message is received, the receive class method would be fed the raw string content of the incoming email via STDIN.
Configuration

Usually you will not have to configure anything special to get mail sending to work. Your production server will have sendmail installed and ActionMailer works fine with it. If you dont have sendmail installed you can try setting up rails to send email directly via SMTP. The ActionMailer::Base class has a hash named smtp_settings (server_settings prior to Rails 2.0) that holds configuration information for SMTP servers. You will want to make some changes, like the ones below, to your config/environment.rb fies:

AcrionMailer::Base.smtp_settings = {

:address => 'smtp.yourserver.com',

:port => '25',

:domain => 'yourserver.com',

localhost.localdomain

:user_name => 'user',

:password => 'password',

:authentification => :plain

}

         


Ruby Forms!
justinbgood — Thu, 24 Jul 2008 18:36:11 +0000
Ruby on Rails has a very comprehensive method of dealing with site interactions and the changes they make to database models by using Forms. All FormHelpers will help make HTML forms and inputs for either an ActiveRecord base or for other explicit variables and instances. The four Rails methods used to create forms are:
form_for

remote_form_for

form_tag

form_remote_tag
One of the most important aspects to know about forms are that the “form_for” and “remote_form_for” are both methods used when you want to present model based data. The “form_tag” and “form_remote_tag” are used for input tags based on explicit naming and values, unlike the form_for which requires an association to an ActiveRecord model.
form_for:
The “form_for” allows you to create forms based on models you’ve already created for your Rails application. For example, if you have a model named ‘User’ tied to a database table, you will have many fields in that model you may want to create/change/delete. An example form_for is below:



<% form_for :user, :url => { :action => 'update', :id => @user.id } do |form| %>

User Name: <%= form.text_field :user_name  &>

<%= submit_tag 'Update' %>

<% end %>



The forms first first variable, :user, let’s the form know that we will be changing an object of User model. The :url hash tells us which method on the controller we will use when we submit the button . The :id parameter allows us to send an id to the controller which will be inside the params[:id] variable (inside the controller). You can send anything to the controller that is needed.
example :url => { :action => 'new', :user_id => @user.id, :topic_id => @topic.id }… we have just sent to the ‘new’ function inside the user_controller a user_id ( called by params[:user_id] inside ‘new’ ) and a topic_id ) called by params[:topic_id] )
The form_for’s content is contained inside of a block, which is seen in the “do |form|” Since we are in a block we can make calls against the ‘form’ variable. This allows us to access to methods to change different sorts of form elements. As shown in the example above, we are putting our user_name column value into  text_field which maps into an input control.
Here is the example of our “update” method:



def update

user = User.find(params[:id])

user.update_attributes(params[:user])

redirect_to :action => 'form_form_test'

end



First we are finding the user from the database by grabbing the id from the :id parameter. Next we use Rails special update_attributes method to grab the users parameter representing the changes we made when we submitted our form and applies it to the model while saving the database.
Form helpers are designed to make working with models much easier compared to using just standard HTML elements by providing a set of methods for creating forms based on your models. This helper generates the HTML for forms, providing a method for each sort of input (e.g., text, password, select, and so on). When the form is submitted (i.e., when the user hits the submit button or form.submit is called via JavaScript), the form inputs will be bundled into the params object and passed back to the controller.
remote_form_for
The remote_form_for is based of the PrototypeHelper module. Prototype is a JavaScript library that provides DOM manipulation, Ajax functionality, other traditional JavaScript functions. PrototypeHelper creates helpers to make it more convenient to call functions from Prototype using Rails, including functionality to call remote Rails methods using Ajax. This allows you you to call actions in your controllers without reloading the page and still be able to update parts of it using injections into the DOM. To use the Prototype helpers you must include the Prototype JavaScript framework in your pages.
javascript_include_tag ‘prototype’
The remote_form_for reates a form that will submit using XMLHttpRequest in the background instead of the regular reloading POST arrangement and a scope around a specific resource that is used as a base for questioning about values for the fields. One of the many defenitions of remote_form_for is
remote_form_for(record_or_name_or_array, *args, &proc)
form_tag
form_tag starts a FORM , with its action attribute set to the URL passed at the url_for_options parameter. The :method option defaults to POST. Browsers can handle HTTP GET and POST but if you specify “put”, “delete” or any other HTTP verb,  a hidden input field will be inserted with the name _method and a  value corresponding to the method supplied. The :multipart option allows you to specify that you will be including file upload fields in the form submission and the server should be ready to handle those files accordingly. heres is the definition for a form_tag:
form_tag(url_for_options = {}, options = {}, #parameters_for_url, &block)
example:

form_tag('/posts')

# => 

form_tag('/posts/1', :method => :put)

# => 
form_tag('/upload', :multipart => true)

# => 
<% form_tag '/posts' do -%>

<%= submit_tag 'Save' %>


<% end -%>

# => 




form_remote_tag
the form_remote_tag returns a form tag that will submit using XMLHttpRequest in the background instead of the regular reloading POST. Even though it’s using JavaScript to serialize the form elements, the form submission will still have all the elements available in the params. The options for specifying the target with :url and defining callbacks is the same as link_to_remote. A “fall-through” target for browsers that don’t  execute JavaScript can be specified with the :action/:method options inside :html.
example: form_remote_tag :html => { :action => url_for(:controller => "posts", :action => "edit") }
The Hash passed to the :html key is equivalent to the options 2nd argument in the FormTagHelper.form_tag method.

         


Hello Everyone!
justinbgood — Thu, 24 Jul 2008 17:58:21 +0000
Hello everyone. My name is Justin. I am a computer scientist at UCSB and a professional longboarder for comet skateboards. I am hoping that I will be able to write some blogs that will be able to shed some light on concepts and questions directed towards newer users to Ruby on Rails. As I am still quite new to Ruby on Rails, this will be a learning process for myself as well. If you would like to learn more about me and my skating, please feel free to check me out at www.cometskateboards.com. We have many cool videos and bogs posted. Also if you are looking for some harder, more in depth Ruby on Rails information, check out the company I work for at www.inigral.com. Thanks for stopping by and enjoy!