title: redirecting url after facebook logs in successfully with django app
body: <p>I created a django application with a user login/registration page. I am trying to implement a facebook login also possible along with my django login. For doing so i was following this link : <a href="http://djangosnippets.org/snippets/1252/" rel="nofollow">enter link description here</a>. As the documentaion says, i have created a file called FaebookConnectMiddleware.py and put in settings.py folder; and changed the db name to my db name. Now the facebook log in works fine, but after it logs in, its redirected to that same page (django registration page,dats where i put FB login button).How can i redirect it to another page in my application. Can somebody help me to solve this. I will paste FacebookConnectMiddleware.py code here. </p>
  
  <pre><code> # FacebookConnectMiddleware.py
  from django.contrib.auth import authenticate, login, logout
  from django.contrib.auth.models import User
  from django.conf import settings
  
  import md5
  import urllib
  import time
  import simplejson
  from datetime import datetime
  
  # These values could be placed in Django's project settings
  # More info here: http://nyquistrate.com/django/facebook-connect/
  FACEBOOK_API_KEY = 'xxxxx'
  FACEBOOK_SECRET_KEY = 'xxxx'
  
  REST_SERVER = 'http://api.facebook.com/restserver.php'
  
  # You can get your User ID here: http://developers.facebook.com/tools.php?api
  MY_FACEBOOK_UID = 'xxx@gmail.com'
  
  NOT_FRIEND_ERROR = 'You must be my Facebook friend to log in.'
  PROBLEM_ERROR = 'There was a problem. Try again later.'
  ACCOUNT_DISABLED_ERROR = 'Your account is not active.'
  ACCOUNT_PROBLEM_ERROR = 'There is a problem with your account.'
  
  class FacebookConnectMiddleware(object):
  
      def process_request(self, request):
          try:
               # Set the facebook message to empty. This message can be used to dispaly info from the middleware on a Web page.
              request.facebook_message = None
  
              # Don't bother trying FB Connect login if the user is already logged in
              if not request.user.is_authenticated():
  
                  # FB Connect will set a cookie with a key == FB App API Key if the user has been authenticated
                  if FACEBOOK_API_KEY in request.COOKIES:
  
                      signature_hash = self.get_facebook_signature(request.COOKIES, True)
  
                      # The hash of the values in the cookie to make sure they're not forged
                      if(signature_hash == request.COOKIES[FACEBOOK_API_KEY]):
  
                          # If session hasn't expired
                          if(datetime.fromtimestamp(float(request.COOKIES[FACEBOOK_API_KEY+'_expires'])) &gt; datetime.now()):
  
                              # Make a request to FB REST(like) API to see if current user is my friend
                              are_friends_params = {
                                  'method':'Friends.areFriends',
                                  'api_key': FACEBOOK_API_KEY,
                                  'session_key': request.COOKIES[FACEBOOK_API_KEY + '_session_key'],
                                  'call_id': time.time(),
                                  'v': '1.0',
                                  'uids1': MY_FACEBOOK_UID,
                                  'uids2': request.COOKIES[FACEBOOK_API_KEY + '_user'],
                                  'format': 'json',
                              }
  
                              are_friends_hash = self.get_facebook_signature(are_friends_params)
  
                              are_friends_params['sig'] = are_friends_hash
  
                              are_friends_params = urllib.urlencode(are_friends_params)
  
                              are_friends_response  = simplejson.load(urllib.urlopen(REST_SERVER, are_friends_params))
  
                              # If we are friends
                              if(are_friends_response[0]['are_friends'] is True):
  
                                  try:
                                      # Try to get Django account corresponding to friend
                                      # Authenticate then login (or display disabled error message)
                                      django_user = UniversityDetails.objects.get(username=request.COOKIES[FACEBOOK_API_KEY + '_user'])
                                      user = authenticate(username=request.COOKIES[FACEBOOK_API_KEY + '_user'], 
                                                          password=md5.new(request.COOKIES[FACEBOOK_API_KEY + '_user'] + settings.FACEBOOK_SECRET_KEY).hexdigest())
                                      if user is not None:
                                          if user.is_active:
                                              login(request, user)
                                              self.facebook_user_is_authenticated = True
                                          else:
                                              request.facebook_message = ACCOUNT_DISABLED_ERROR
                                              self.delete_fb_cookies = True
                                      else:
                                         request.facebook_message = ACCOUNT_PROBLEM_ERROR
                                         self.delete_fb_cookies = True
                                  except User.DoesNotExist:
                                      # There is no Django account for this Facebook user.
                                      # Create one, then log the user in.
  
                                      # Make request to FB API to get user's first and last name
                                      user_info_params = {
                                          'method': 'Users.getInfo',
                                          'api_key': FACEBOOK_API_KEY,
                                          'call_id': time.time(),
                                          'v': '1.0',
                                          'uids': request.COOKIES[FACEBOOK_API_KEY + '_user'],
                                          'fields': 'first_name,last_name',
                                          'format': 'json',
                                      }
  
                                      user_info_hash = self.get_facebook_signature(user_info_params)
  
                                      user_info_params['sig'] = user_info_hash
  
                                      user_info_params = urllib.urlencode(user_info_params)
  
                                      user_info_response  = simplejson.load(urllib.urlopen(REST_SERVER, user_info_params))
  
  
                                      # Create user
                                      user = UniversityDetails.objects.create_user(request.COOKIES[FACEBOOK_API_KEY + '_user'], '', 
                                                                      md5.new(request.COOKIES[FACEBOOK_API_KEY + '_user'] + 
                                                                      settings.SECRET_KEY).hexdigest())
                                      user.first_name = user_info_response[0]['first_name']
                                      user.last_name = user_info_response[0]['last_name']
                                      user.save()
  
                                      # Authenticate and log in (or display disabled error message)
                                      user = authenticate(username=request.COOKIES[FACEBOOK_API_KEY + '_user'], 
                                                          password=md5.new(request.COOKIES[FACEBOOK_API_KEY + '_user'] + settings.FACEBOOK_SECRET_KEY).hexdigest())
                                      if user is not None:
                                          if user.is_active:
                                              login(request, user)
                                              self.facebook_user_is_authenticated = True
                                          else:
                                              request.facebook_message = ACCOUNT_DISABLED_ERROR
                                              self.delete_fb_cookies = True
                                      else:
                                         request.facebook_message = ACCOUNT_PROBLEM_ERROR
                                         self.delete_fb_cookies = True
                              # Not my FB friend
                              else:
                                  request.facebook_message = NOT_FRIEND_ERROR
                                  self.delete_fb_cookies = True
  
                          # Cookie session expired
                          else:
                              logout(request)
                              self.delete_fb_cookies = True
  
                     # Cookie values don't match hash
                      else:
                          logout(request)
                          self.delete_fb_cookies = True
  
              # Logged in
              else:
                  # If FB Connect user
                  if FACEBOOK_API_KEY in request.COOKIES:
                      # IP hash cookie set
                      if 'fb_ip' in request.COOKIES:
  
                          try:
                              real_ip = request.META['HTTP_X_FORWARDED_FOR']
                          except KeyError:
                              real_ip = request.META['REMOTE_ADDR']
  
                          # If IP hash cookie is NOT correct
                          if request.COOKIES['fb_ip'] != md5.new(real_ip + FACEBOOK_SECRET_KEY + settings.FACEBOOK_SECRET_KEY).hexdigest():
                               logout(request)
                               self.delete_fb_cookies = True
                      # FB Connect user without hash cookie set
                      else:
                          logout(request)
                          self.delete_fb_cookies = True
  
          # Something else happened. Make sure user doesn't have site access until problem is fixed.
          except:
              request.facebook_message = PROBLEM_ERROR
              logout(request)
              self.delete_fb_cookies = True
  
      def process_response(self, request, response):        
  
          # Delete FB Connect cookies
          # FB Connect JavaScript may add them back, but this will ensure they're deleted if they should be
          if self.delete_fb_cookies is True:
              response.delete_cookie(FACEBOOK_API_KEY + '_user')
              response.delete_cookie(FACEBOOK_API_KEY + '_session_key')
              response.delete_cookie(FACEBOOK_API_KEY + '_expires')
              response.delete_cookie(FACEBOOK_API_KEY + '_ss')
              response.delete_cookie(FACEBOOK_API_KEY)
              response.delete_cookie('fbsetting_' + FACEBOOK_API_KEY)
  
          self.delete_fb_cookies = False
  
          if self.facebook_user_is_authenticated is True:
              try:
                  real_ip = request.META['HTTP_X_FORWARDED_FOR']
              except KeyError:
                  real_ip = request.META['REMOTE_ADDR']
              response.set_cookie('fb_ip', md5.new(real_ip + FACEBOOK_SECRET_KEY + settings.FACEBOOK_SECRET_KEY).hexdigest())
  
          # process_response() must always return a HttpResponse
          return response
  
      # Generates signatures for FB requests/cookies
      def get_facebook_signature(self, values_dict, is_cookie_check=False):
          signature_keys = []
          for key in sorted(values_dict.keys()):
              if (is_cookie_check and key.startswith(FACEBOOK_API_KEY + '_')):
                  signature_keys.append(key)
              elif (is_cookie_check is False):
                  signature_keys.append(key)
  
          if (is_cookie_check):
              signature_string = ''.join(['%s=%s' % (x.replace(FACEBOOK_API_KEY + '_',''), values_dict[x]) for x in signature_keys])
          else:
              signature_string = ''.join(['%s=%s' % (x, values_dict[x]) for x in signature_keys])
          signature_string = signature_string + FACEBOOK_SECRET_KEY
  
          return md5.new(signature_string).hexdigest()
  </code></pre>
  
  <p><strong>views</strong> These functions does the login/registration for the django application.</p>
  
  <pre><code>def registrationForm(request):
      if request.method == "POST":  
          firstName = request.POST.get("firstName")
          lastName = request.POST.get("lastName")
          email = request.POST.get("email")
          password = request.POST.get("password")
          sex = request.POST.get("sex")
          birthday = request.POST.get("birthday")
          UniversityDetails(firstName=firstName,lastName=lastName,email=email,password=password,sex=sex,birthday=birthday).save()
  
          send_mail('Email Verification', 'You have registered successfully', 'xx@gmail.com',
      ['xx@gmail.com'], fail_silently=False)
  
          return render_to_response('login.html')
  
      return render_to_response("registrationForm.html")
  
  def login(request):
      if request.POST:       
          #sessionObj = request.session['active_token']
         # print sessionObj
          email=request.POST.get("username")
          password = request.POST.get("password")
          user = UniversityDetails.objects.filter(email=email,password=password)
          if(not user):
              return render_to_response("registrationForm.html",{'invalid': True })
          else:
              return render_to_response("login.html")
      return render_to_response("registrationForm.html")
  </code></pre>
  
  <p><strong>registrationForm.html</strong></p>
  
  <pre><code>&lt;div id="fb-root"&gt;&lt;/div&gt;
    &lt;script src="http://connect.facebook.net/en_US/all.js"&gt;&lt;/script&gt;
    &lt;script&gt;
     FB.init({ 
          appId:'114322105313139', cookie:true,
          status:true, xfbml:true 
       });
    &lt;/script&gt;     
    &lt;fb:login-button perms="email,user_checkins"  onlogin=”location.reload(false);"&gt;Login with Facebook&lt;/fb:login-button&gt;
  </code></pre>