If you will have a look at OAuth examples on twitter apiwiki there are already examples available to use Sign in with Twitter with Django, so why this new howto and example code. Because being a perfectionist I like things to be the standard way, so for authentication django allows you to specify your own customized authentication backends. I thought why should not that be utilized to authenticate the Django User object with twitter.

There are few pre-requisites listed below in the order they are needed:

• simplejson
• oauth
• python-twitter
• oauth-python-twitter
• TwitterBackend from djangosnippets.org

This guide assumes that simplejson, oauth, python-twitter and oauth-python-twitter are already on your python path.

1. Now create a new Django project: twitterapp

django-admin startproject

2. Change to the project directory.

3. Now start a new app inside the project

python manage.py startapp twitterauth

4. Create a new directory: backends

mkdir backends

5. Change to the backends directory and create 2 new empty files.

cd backends
touch __init__.py
touch twitteroauth.py

6. Copy the code from TwitterBackend into the empty file: twitteroauth.py

7. Now configure your settings.py and add/edit following configuration variables

CONSUMER_KEY = "Your consumer key from twitter"

CONSUMER_SECRET = "You consumer secret from twitter"

AUTHENTICATION_BACKENDS = (
    'backends.twitteroauth.TwitterBackend',
    'django.contrib.auth.backends.ModelBackend',
)

AUTH_PROFILE_MODULE = "twitterauth.UserProfile"

8. Now goto the twitterauth app directory and create a UserProfile module and post save signal processor as follows:

from django.db import models
from django.db.models.signals import post_save
from django.contrib.auth.models import User
class UserProfile(models.Model):
	user = models.ForeignKey(User)
	access_token = models.CharField(max_length=255, blank=True, null=True, editable=False)
	profile_image_url = models.URLField(blank=True, null=True)
	location = models.CharField(max_length=100, blank=True, null=True)
	url = models.URLField(blank=True, null=True)
	description = models.CharField(max_length=160, blank=True, null=True)

	def __str__(self):
		return "%s's profile" % self.user

def create_user_profile(sender, instance, created, **kwargs):
	if created:
		profile, created = UserProfile.objects.get_or_create(user=instance)

post_save.connect(create_user_profile, sender=User)

9. Now modify your views.py in twitterauth app directory as following:

from django.conf import settings
from django.http import HttpResponseRedirect, HttpResponse
from django.contrib.auth import login, authenticate

from oauthtwitter import OAuthApi
import oauth

CONSUMER_KEY = getattr(settings, 'CONSUMER_KEY', 'YOUR_KEY')
CONSUMER_SECRET = getattr(settings, 'CONSUMER_SECRET', 'YOUR_SECRET')

def twitter_signin(request):
	twitter = OAuthApi(CONSUMER_KEY, CONSUMER_SECRET)
	request_token = twitter.getRequestToken()
	request.session['request_token'] = request_token.to_string()
	signin_url = twitter.getSigninURL(request_token)
	return HttpResponseRedirect(signin_url)

def twitter_return(request):
	request_token = request.session.get('request_token', None)

	# If there is no request_token for session,
	#    means we didn't redirect user to twitter
	if not request_token:
		# Redirect the user to the login page,
		# So the user can click on the sign-in with twitter button
		return HttpResponse("We didn't redirect you to twitter...")

	token = oauth.OAuthToken.from_string(request_token)

	# If the token from session and token from twitter does not match
	#   means something bad happened to tokens
	if token.key != request.GET.get('oauth_token', 'no-token'):
		del request.session['request_token']
		# Redirect the user to the login page
		return HttpResponse("Something wrong! Tokens do not match...")

	twitter = OAuthApi(CONSUMER_KEY, CONSUMER_SECRET, token)
	access_token = twitter.getAccessToken()

	request.session['access_token'] = access_token.to_string()
	auth_user = authenticate(access_token=access_token)

	# if user is authenticated then login user
	if auth_user:
		login(request, auth_user)
	else:
		# We were not able to authenticate user
		# Redirect to login page
		del request.session['access_token']
		del request.session['request_token']
		return HttpResponse("Unable to authenticate you!")

	# authentication was successful, use is now logged in
	return HttpResponse("You are logged in")

10. Add the following 2 lines to urls.py at correct location.

    url('^login/$', twitter_signin, name='login'),
    url('^return/$', twitter_return, name='return'),

11. Now start the django devevelopment server

python manage.py runserver


12. Goto http://localhost:8000/login and you will be redirected to user for authentication, and if everything wents well you will see the message that your are logged in.

If you like this post:
:: :: :: :: :: :: :: :: :: :: ::

Using OAuth for authentication is quite different then using Basic Auth in many ways, first major difference is that one don’t know the username until it is requested from twitter after completing the authentication process.

Details

You will need following information to start.

• Consumer Key
• Consumer Secret

If you do not have above, you can request them from here: http://twitter.com/oauth_clients

The following are the steps that should be performed to authenticate user and get user information from twitter, the rest is same as using python-twitter.

• Get the Request Token from twitter
• Get Authorization URL
• Get the Access Token from twitter
• Get user information

Get the Request Token from twitter


twitter = OAuthApi(CONSUMER_KEY, CONSUMER_SECRET)

request_token = twitter.getRequestToken()


Get Authorization URL

using same request_token from previous step

authorization_url = twitter.getAuthorizationURL(request_token)

Now send the user to authorization URL, for allowing access to the application.

Get the Access Token from twitter

Once the user return from twitter, we need to request the access_token from twitter for futher aunthenticated api calls on behalf of user.

NOTE: Need to create the new instance of OAuthApi using request_token from first step.

twitter = OAuthApi(CONSUMER_KEY, CONSUMER_SECRET, request_token)

access_token = twitter.getAccessToken()

Get user information

This api call was not present in python-twitter and the user info call expected that there we know the username before making call, but this is not the case with OAuth, so we have to request User Information so we can use it in our application.

NOTE: Need to create the new instance of OAuthApi using access_token from last step.

twitter = OAuthApi(CONSUMER_KEY, CONSUMER_SECRET, access_token)

user = twitter.GetUserInfo()

Now use the rest of python-twitter api calls as you used to use them with basic authentication, for more information see the wiki at:http://code.google.com/p/python-twitter

If you like this post, share it with others:
:: :: :: :: :: :: :: :: :: :: ::

If you are a python developer and you tried to develop some application for twitter, you must have came acrossed python-twitter. Which provides you a pythonic interface to twitter, by allowing you to access almost all twitter objects as python objects. python-twitter is still in devleopment, and hence still does not have the OAuth compatibility. I am being a oauth pro, deicided to write a derived class from python-twitter, to allow OAuth to be used as the authentication mechnism for python-twitter.

python-twitter is being developed by our beloved google’s employee: DeWitt Clinton

You can get the python-twitter at: python-twitter

You can get the oauth extension to python-twitter at: oauth-python-twitter

In the next following posts I will posting about how I am using it with Django specifically and how I have writter my TwitterAuthBackend for Django. The whole purpose of publishing the code is to get improvements and reviews on the code, so I have allowed non-members to review the above project on code.google.com, you are more then welcome to post your coments here or review the code on the project. Let me know if you don’t understand anything by asking questions in comments.

P.S I have used the same license as was used for python-twitter.

Happy twittering and developing

As you all might have noticed that I was not posting for a while now, actually had been taken overy by few projects. But today I thought to post about the updates from Google App Engine. Google App Engine have released the Cookbook where you can submit your recipies or can benefit from other people’s snippets of code.

One more thing that Google App Engine team has done which is really useful, they have included the documentation with SDK, so if you are offline you will still have access to SDK. This will not let your engine stops even if you are not connected to internet.

If you haven’t been following Google App Engine Blog, according to latest post the Google App Engine is getting popularity and many programmers are learning python just to play with App Engine. According to Marzia Niccolai on Google App Engine Blog:

I’ve returned from the App Engine hack-a-thon in Chicago a Superfan of the App Engine community. We had lots of fun meeting App Engine developers, but why let me tell you about it? A couple of attendees wrote great summaries of the day: A Ruby on Rails developer giving Python a whirl, and a developer who worked on testing with App Engine. We saw people working on iPhone apps, OpenSocial and App Engine, and even a chat application!

So, if you want to host your application on reliable Google platform then you gotta learn Python to make your next app in Google App Engine. Google App Engine is going to be the next big thing if they started supporting rest of the languages like PHP, Ruby and Perl which they have already promised. So stay tuned.

Okay, after settig up rails 2.1 we are now ready to start our rails journey. So lets begin with a simple blog application. If you are thinking why are we not following the tradition of “Hello World” project here,  the answer is simple, because you can find it all over the internet. For the sake of simplicity of this beginner introduction we assume we just want to create posts and add comments to our blog. No categories and no other bells and whistles, because the main point is to learn rails 2.1 neither to learn how to create a blog.

 

Creating the project

First thing is to create rails project and for this purpose we use rails command. But there is one thing you need to remember by default rails setup the project’s database to sqlite, so you need to change it to mysql by using the -d option with rails command, so lets create our project.

Command:

rails -d mysql bloggy

You will see bunch of lines passing by on your screen, these are all messages from rails about creating the directory structure that is required to build our web app in rails. If you will view your directory listing now you will find a new directory bloggy there, this directory contains subdirectories and files that are being created by the above command. Now change your directory to the bloggy directory.

NOTE: This is important because from now on we will assume that we are in bloggy directory.

Directory Structure

There are 2 directories that are of our interest for now and those are app and config. First talk about config directory, it contains configuration files which you never need to change if you follow purely rails way of developing your web application. But the important files there are database.yml, environment.rb and routes.rb. We will see later what these files are for but for now just remember that they are in the config sub directory under our main project directory.

Role of the Controllers

The other sub-direcotry app contains 4 other sub directories, controllers, models, helpers and views. As rails uses MVC approach for development the code is separated in those sub directories. Controllers have all the decision powers and they are called controller because as soon as rails gets a request the first thing it do is matches the url against routes.rb file in config directory and then give the control to the respective controller and from there controller decides what model to call and what view to use. Now you must be asking what are models?

What are Rails Models?

Models are interface to your database, so instead of writing SQL in your app you use model objects. You create class which represents table in your database, you instantiate class in your code and that represents a row in the table, and attributes of that object represents columns of that row. So you don’t write SQL at all just use Models to talk with your database. Now lets get to know what are views so we can gets our hand wet with some rails in practical.

What are Rails Views?

Views contain the code that will create your site’s interface, that is actually viewable by user and hence view sub directory contains further sub directories which contain html + some ruby code for that controller.

Convention over Configuration

Although Rails prefers convention over configuration, so if you just place everything in its place you just have to worry about coding your app rather then to change any configuration files. But there is one configuration file that needs to be changed, that is your database configuration file database.yml which is located in config directory. By default database.yml contains following:

# MySQL.  Versions 4.1 and 5.0 are recommended.
#
# Install the MySQL driver:
#   gem install mysql
# On Mac OS X:
#   sudo gem install mysql -- --with-mysql-dir=/usr/local/mysql
# On Mac OS X Leopard:
#   sudo env ARCHFLAGS="-arch i386" gem install mysql -- --with-mysql-config=/usr/local/mysql/bin/mysql_config
#       This sets the ARCHFLAGS environment variable to your native architecture
# On Windows:
#   gem install mysql
#       Choose the win32 build.
#       Install MySQL and put its /bin directory on your path.
#
# And be sure to use new-style password hashing:
#   http://dev.mysql.com/doc/refman/5.0/en/old-client.html
development:
adapter: mysql
encoding: utf8
database: bloggy_development
username: root
password:
socket: /var/run/mysqld/mysqld.sock
…rest of the file skipped…

The lines starting with ‘#’ are comments and followed by the first comment block is the development database clause and that is what we are interested for now. The other databases are production and test, the name suggests what they are used for. So our main concerned now is development db as we are still in the development stage. So now we should provide valid credentials for development database, the file is self explanatory and hopefully you know how to edit text files and save them. So update your database.yml with correct credentials and save the file.

Creating the databae

Now run the following rake command to create the database for your application.

rake db:create

Don’t worry about rake its just a “make” like utility which allows you to perform common rails tasks without worrying much about them. So now we have our rails project and database ready. Now we will generate some scaffolds.

Generating Scaffolds

Now there is one more directory that I want to introduce to you, the script sub directory under your project main directory. The script directory contains scripts to allow you to interact with your rails framework. The few main scripts are server (a development web server that allows you to quickly test your app via browser), console (load your rails environment and then gives you ruby prompt) and generate (this is your friend who writes code for you ). So we know that generate script is our friend so how do we use it?

Back to our blog application what models to we need? As we decided earlier we will only allow posts and comments. So that means 2 models a Post model and a Comment model. So, first we will create the scaffolding for our Post model. Following table lists the attributes we need for our Post model.

Attribute  |   Type    |   MySQL Type
title             string         varchar
body            text            text

Now to the practical part of it, how to create the scaffolding for the above model. The new scaffolding that has been introduced in Rails 2.1 has following syntax

ruby script/generate scaffold ModelName [field:type field:type ...]

We know our fields and types, so we will generate our scaffolding like following:

ruby script/generate scaffold Post title:string body:text

This will again show you bunch of lines on your screen showing what files has been created. We are almost done, just need to create the post table in our database, in rails terminology migrate our db to current version. And to accomplish this we will again use rake, so the following command will migrate our database to the most current version.

rake db:migrate

We are done with our scaffolding, now we can test our bloggy app, as it now supports creating posts. In the next part (coming very very soon) I will write how to add comments to the post, that will be part 2 of this post.

Viewing the outcome

Now to test our app we have to run the rails development web server using the following command:

ruby script/server

Output:

=> Booting WEBrick…
=> Rails 2.1.0 application started on http://0.0.0.0:3000
=> Ctrl-C to shutdown server; call with –help for options
[2008-07-25 11:52:33] INFO  WEBrick 1.3.1
[2008-07-25 11:52:33] INFO  ruby 1.8.6 (2007-09-24) [i486-linux]
[2008-07-25 11:52:33] INFO  WEBrick::HTTPServer#start: pid=4763 port=3000

You should see the above output, from the above output we can see our webserver is running on port 3000 so now we will open our web browser and browse to the URL: http://localhost:3000/, you should see “Welcome aboard” message from rails that means web server is running fine.

Now browse to the http://localhost:3000/posts to test our scaffolding that we have generated yet. You should see something like following:

Command Summary:

1. rails -d mysql bloggy
2. rake db:create
3. ruby script/generate scaffold Post title:string body:text
4. rake db:migrate
5. ruby script/server

Practice

I hope you have been successfully following till here. Now spend sometime getting to know the scaffolding generated, view the code generated for controller, model and views. Get your self familiar with it, ask questions for what you don’t understand. In the next part we will add comments functionality in our blog app. If you like to be updated you can subscribe to the feed.

I thought it would be a good idea to start with actually installation of rails 2.1, as many latest linux distributions don’t come with the latest version of rails which includes Ubuntu 8.04. So in this how to we will cover installation of rails 2.1 on Ubuntu 8.04.

NOTE: This howto is not for you if you want to be keep your system with ubuntu repository. This howto will use gem to install rails and hence will not use the rails version available in ubuntu repository.

This is not actually a Rails 2.1 development tutorial, but it is related to it and hence has been made part of Rails 2.1 tutorials. Once again I would like to clarify that I am not advocating Ubuntu here nor I am saying that you should use Ubuntu for your rails development but that is what I prefer to use for my development and personal use.

NOTE: If you are developing on windows or using any other distribution of Linux then you can still ask in comments if you face any problems and I will try to help you out.

Lets start installing Rails 2.1 on our Ubuntu system. We know that apt-get is our friend which takes care of all the dependencies, fetching them and installing them.

Step 1: First step is to install ruby and other required software packages.

sudo apt-get install ruby rdoc irb ruby1.8-dev rubygems libopenssl-ruby
Step 2: We have installed RubyGems in “Step 1″, now we need to update gem to the latest available version and for this we will use below command:

sudo gem update --system

You will see a lot of messages on the screen, if you have few minutes you can read them but the last 4-5 lines will be a message that you have successfully updated your gem installation.

Output:

RubyGems installed the following executables:
/usr/bin/gem1.8

If `gem` was installed by a previous RubyGems installation, you may need
to remove it by hand.

RubyGems system software updated

Step 3: Now we have two versions of RubyGem on our system one is installed via package manager in Step 1 and the other is via “gem update” in Step 2. Now we will remove the version that was intstalled in Step 1 and will keep the latest version from Step 2.

sudo apt-get remove rubygems
Step 4: Now the gem command is removed so we need to create symbolic link to the latest version of gem manager.

sudo ln -s /usr/bin/gem1.8 /usr/bin/gem
Step 5: Now to install rails 2.1 on our system simply use the gem manage to install the rails gem.

sudo gem install rails

You should see the similar output like following:

Successfully installed rake-0.8.1
Successfully installed activesupport-2.1.0
Successfully installed activerecord-2.1.0
Successfully installed actionpack-2.1.0
Successfully installed actionmailer-2.1.0
Successfully installed activeresource-2.1.0
Successfully installed rails-2.1.0
7 gems installed
Installing ri documentation for rake-0.8.1…
Installing ri documentation for activesupport-2.1.0…
Installing ri documentation for activerecord-2.1.0…
Installing ri documentation for actionpack-2.1.0…
Installing ri documentation for actionmailer-2.1.0…
Installing ri documentation for activeresource-2.1.0…
Installing RDoc documentation for rake-0.8.1…
Installing RDoc documentation for activesupport-2.1.0…
Installing RDoc documentation for activerecord-2.1.0…
Installing RDoc documentation for actionpack-2.1.0…
Installing RDoc documentation for actionmailer-2.1.0…
Installing RDoc documentation for activeresource-2.1.0…

Congratulations

If you have successfully followed till here then you have installed the latest available version of rails i.e rails 2.1 on your system. Yay!!! now get your self ready for actual fun.

:: :: :: :: :: :: :: :: :: :: ::

As I mentioned earlier I will start writing some rails tutorials in my Post “Why Django is more attractive then Rails?“. So now I have created this separate rails tutorial section which will serve as a TOC for all my rails tutorial posts. I have decided to start with a simple todo app. One thing to note here is we will be using rails 2.1 (which is the latest version of rails), so I might also write how you can install rails 2.1 on your machine. Sorry for the confusion that I wrote in my earlier article that we will be using rails 2.0. But any how its rails 2.x which is very very different then rails 1.x, so I hope my effort will not be wasted and it will be of some benefit for some newbies converting to rails out there.

One more thing I am not a rails advocate or something, I am just a developer who wants to help newbies. The reason I am writing these rails tutorials is because there is a lot of information for django and other frame works but I think rails lack a simple introduction which can help a newbie understand rails better.

So, I am not sure right now how much articles I will be writing to complete the tutorial but we will go in steps, which means I am not going to write a long article at once.  So stay tuned please I am almost finished with my first post and it will be here soon.

One of my friends was introduced to rails when the version 2.0 was already out. He tried to learn rails for months on his own but couldn’t succeed. Recently he contacted me and asked if I have books, materials or may be links to some good books/tutorials for learning rails 2.0. And to my surprise there is not enough material available for a newbie to learn rails 2.0 which is totally different then the older 1.x version.

The whole internet and even the rails site points to old materials and this is quite confusing for newbies. My that friend has already been turned to Django for professional development but he still wants to learn Ruby on Rails. The books like “Agile Web Development With Rails” is still to come out for Rails 2.0.

So, now to give something back to the community I have decided to write a through more then a “Hello Wolrd” tutorial for rails 2.0 so newbies don’t waste their precious time just looking for the information which is almost now obsolete. I said obsolete because Rails 2.0 has been changed alot, although the old programmers don’t notice it much because of their prior experience of the language. But for new comers its confusing when scaffolds don’t work for them or they get confused when they see the config/routes.rb which has new majic of map.resource covering everything.

So, hopefully I will be able to solve all these mysteries here. Also if you have written something for Rails 2.0 you can post the link in comments and later I will create a separate post that will points to all the external collections.

Google I/O the developer event that happened in SanFransisco, many were able to join it but there are thousands of people who were not able to join it Google has not forgotten them. The videos of almost all the talks has been posted but the best one is “Rapid Development wiht Python, Django and Google App Engine“.

Its a must watch video so I decided to share it here. I hope you will benefit from it. You can get the presentation slides from here.

If you like the above video then there are few other good videos too related to Google App Engine, so if you ware interested in learning Google App Engine and not only that but there are videos for other Google technologies which include Gears, Gadgets, OpenSocial and gData. Have look at Google I/O session videos posted with slides