facebook_js contrib

socialregistration/contrib/facebook/views.py

@@ -10,14 +10,14 @@ class FacebookRedirect(OAuthRedirect):
 class FacebookCallback(OAuthCallback):
     client = Facebook
     template_name = 'socialregistration/facebook/facebook.html'
-    
+
     def get_redirect(self):
         return reverse('socialregistration:facebook:setup')
 
 class FacebookSetup(SetupCallback):
     client = Facebook
     profile = FacebookProfile
     template_name = 'socialregistration/facebook/facebook.html'
-    
+
     def get_lookup_kwargs(self, request, client):
         return {'uid': client.get_user_info()['id']}

socialregistration/contrib/facebook_js/admin.py

@@ -0,0 +1,4 @@
+from django.contrib import admin
+from socialregistration.contrib.facebook_js.models import FacebookProfile
+
+admin.site.register(FacebookProfile)

socialregistration/contrib/facebook_js/auth.py

@@ -0,0 +1,16 @@
+from django.contrib.auth.backends import ModelBackend
+from django.contrib.sites.models import Site
+from socialregistration.contrib.facebook_js.models import FacebookProfile
+
+
+class FacebookAuth(ModelBackend):
+    supports_object_permissions = False
+    supports_anonymous_user = False
+
+    def authenticate(self, uid = None):
+        try:
+            return FacebookProfile.objects.get(
+                uid = uid,
+                site = Site.objects.get_current()).user
+        except FacebookProfile.DoesNotExist:
+            return None

socialregistration/contrib/facebook_js/client.py

@@ -0,0 +1,36 @@
+from django.conf import settings
+from django.contrib.sites.models import Site
+from django.core.urlresolvers import reverse
+from socialregistration.clients.oauth import OAuth2
+from socialregistration.settings import SESSION_KEY
+import json
+import facebook
+
+class Facebook(OAuth2):
+    client_id = getattr(settings, 'FACEBOOK_APP_ID', '')
+    secret = getattr(settings, 'FACEBOOK_SECRET_KEY', '')
+    scope = getattr(settings, 'FACEBOOK_REQUEST_PERMISSIONS', '')
+
+    auth_url = 'https://www.facebook.com/dialog/oauth'
+    access_token_url = 'https://graph.facebook.com/oauth/access_token'
+
+    graph = None
+    _user_info = None
+
+
+    def get_callback_url(self):
+        if self.is_https():
+            return 'https://%s%s' % (Site.objects.get_current().domain,
+                reverse('socialregistration:facebook:callback'))
+        return 'http://%s%s' % (Site.objects.get_current().domain,
+            reverse('socialregistration:facebook:callback'))
+
+    def get_user_info(self):
+        if self._user_info is None:
+            self.graph = facebook.GraphAPI(self._access_token)
+            self._user_info = self.graph.request('me')
+        return self._user_info
+
+    @staticmethod
+    def get_session_key():
+        return '%sfacebook' % SESSION_KEY

socialregistration/contrib/facebook_js/context_processors.py

@@ -0,0 +1,21 @@
+from django.conf import settings
+
+FACEBOOK_API_KEY = getattr(settings, 'FACEBOOK_API_KEY', None)
+FACEBOOK_SECRET_KEY = getattr(settings, 'FACEBOOK_SECRET_KEY', None)
+FACEBOOK_REQUEST_PERMISSIONS = getattr(settings, 'FACEBOOK_REQUEST_PERMISSIONS', None)
+FACEBOOK_AUTO_LOGIN_IF_HAS_ACCOUNT = getattr(settings, 'FACEBOOK_AUTO_LOGIN_IF_HAS_ACCOUNT', False)
+
+def FacebookTemplateVars(request):
+    """
+    Provides the facebook variables
+    FACEBOOK_API_KEY
+    FACEBOOK_SECRET_KEY
+    FACEBOOK_REQUEST_PERMISSIONS
+    FACEBOOK_AUTO_LOGIN_IF_HAS_ACCOUNT
+    """
+    return {
+    'FACEBOOK_API_KEY': FACEBOOK_API_KEY,
+    'FACEBOOK_SECRET_KEY': FACEBOOK_SECRET_KEY,
+    'FACEBOOK_REQUEST_PERMISSIONS': FACEBOOK_REQUEST_PERMISSIONS,
+    'FACEBOOK_AUTO_LOGIN_IF_HAS_ACCOUNT': FACEBOOK_AUTO_LOGIN_IF_HAS_ACCOUNT
+    }

socialregistration/contrib/facebook_js/middleware.py

@@ -0,0 +1,40 @@
+from django.utils.functional import SimpleLazyObject
+from socialregistration.contrib.facebook_js.models import FacebookAccessToken, \
+    FacebookProfile
+import facebook
+
+def get_uid(user):
+    try:
+        return FacebookProfile.objects.get(user = user).uid
+    except FacebookProfile.DoesNotExist:
+        return ''
+
+def get_access_token(user):
+    try:
+        return FacebookAccessToken.objects.get(profile__user = user).access_token
+    except FacebookAccessToken.DoesNotExist:
+        return ''
+
+def get_graph(user):
+    def wrapped(self):
+        if not self.access_token:
+            return None
+        return facebook.GraphAPI(self.access_token)
+    return wrapped
+
+def get_facebook_object(user):
+    def wrapped():
+        return type('Facebook', (object,), {'uid': get_uid(user), 
+            'access_token': get_access_token(user), 'get_graph': get_graph(user)})()    
+    return wrapped
+
+class FacebookMiddleware(object):
+    def process_request(self, request):
+        """
+        Enables ``request.facebook`` in your views for authenticated users.
+        It's a lazy object that does database lookups.
+        """
+
+        request.facebook = SimpleLazyObject(get_facebook_object(request.user))
+
+        return None

socialregistration/contrib/facebook_js/models.py

@@ -0,0 +1,45 @@
+from django.conf import settings
+from django.contrib.auth import authenticate
+from django.contrib.auth.models import User
+from django.contrib.sites.models import Site
+from django.db import models
+from socialregistration.signals import connect, login
+
+class FacebookProfile(models.Model):
+    user = models.ForeignKey(User, unique=True)
+    site = models.ForeignKey(Site, default=Site.objects.get_current)
+    uid = models.CharField(max_length=255, blank=False, null=False)
+
+    class Meta:
+        db_table = 'socialregistration_facebookprofile'
+
+    def __unicode__(self):
+        try:
+            return u'%s: %s' % (self.user, self.uid)
+        except User.DoesNotExist:
+            return u'None'
+
+    def authenticate(self):
+        return authenticate(uid=self.uid)
+
+class FacebookAccessToken(models.Model):
+    profile = models.OneToOneField(FacebookProfile, related_name='access_token')
+    access_token = models.CharField(max_length=255)
+
+    class Meta:
+        db_table = 'socialregistration_facebookaccesstoken'
+
+def save_facebook_token(sender, user, profile, client, **kwargs):
+    if hasattr(client, 'access_token'):
+        try:
+            FacebookAccessToken.objects.get(profile=profile).delete()
+        except FacebookAccessToken.DoesNotExist:
+            pass
+
+        FacebookAccessToken.objects.create(profile=profile,
+            access_token=client.access_token)
+
+connect.connect(save_facebook_token, sender=FacebookProfile,
+    dispatch_uid='socialregistration.facebook.connect')
+login.connect(save_facebook_token, sender = FacebookProfile,
+    dispatch_uid = 'socialregistration.facebook.login')

socialregistration/contrib/facebook_js/templates/socialregistration/facebook_js/channel.html

@@ -0,0 +1 @@
+<script src="//connect.facebook.net/en_US/all.js"></script>

socialregistration/contrib/facebook_js/templates/socialregistration/facebook_js/facebook.html

@@ -0,0 +1,3 @@
+{% if error %}
+	<p>{{ error }}</p>
+{% endif %}

socialregistration/contrib/facebook_js/templates/socialregistration/facebook_js/facebook_button.html

@@ -0,0 +1,9 @@
+{% include 'socialregistration/facebook_js/facebook_js.html' %}
+
+<form class="connect-button" name="login" method="post" action="{% url socialregistration:facebook:redirect %}">
+{% csrf_token %}
+{% if next %}
+    <input type="hidden" name="next" value="{{ next }}" />
+{% endif %}
+<input type="image" onclick="this.form.submit();" src="{% if button %}{{ button }}{% else %}http://static.ak.fbcdn.net/images/fbconnect/login-buttons/connect_light_large_long.gif{% endif %}" />
+</form>

socialregistration/contrib/facebook_js/templates/socialregistration/facebook_js/facebook_js.html

@@ -0,0 +1,172 @@
+<div id="fb-root"></div>
+<script>
+  window.fbAsyncInit = function() {
+    FB.init({
+      appId      : '{{ FACEBOOK_API_KEY }}', // App ID
+      channelUrl : '//{{ request.get_host }}{% url socialregistration:facebook_js:channel %}', // Channel File
+      status     : true, // check login status
+      cookie     : true, // enable cookies to allow the server to access the session
+      xfbml      : true  // parse XFBML
+    });
+    // Additional initialization code here
+
+    SocialUserLoginCallback = function SocialUserLoginCallback(response, uid, accessToken) {
+
+        var csrftoken = $("{% csrf_token %}").find('input[name=csrfmiddlewaretoken]').val();
+        response.csrfmiddlewaretoken = csrftoken;
+
+        if (uid != undefined) {
+            response.uid = uid;
+        }
+
+        response.profile_photo = 'http://graph.facebook.com/' + response.id + '/picture';
+
+        if (accessToken != undefined) {
+            response.accessToken = accessToken;
+        }
+
+        var post_data = $.param(response);
+
+        $.ajax({
+          type: 'POST',
+          url: "{% url socialregistration:facebook_js:callback %}",
+          data: post_data,
+        })
+        .success(function(data, textStatus, jqXHR) {
+            console.log('')
+            document.location.reload();
+        })
+        .error(function(jqXHR, textStatus, errorThrown) { 
+            var data = $.parseJSON(jqXHR.responseText);
+        })
+        .complete(function() {});
+
+    };
+
+    SocialUserCallback = function SocialUserCallback(response) {
+        if (response.error == undefined && response.id != undefined) {
+            if (response.authResponse != undefined) {
+                // is the authorized response, have just logged in and we have the access token
+                //console.log('is the authorized response, have just logged in and we have the access token');
+                var uid = response.authResponse.userID;
+                var accessToken = response.authResponse.accessToken;
+
+                // setup callback
+                SocialUserLoginCallback(response, uid, accessToken);
+            } else {
+                // normal auth response no token
+                //console.log('normal auth response no token')
+                // login callback
+                SocialUserLoginCallback(response);
+            }
+        }
+    };
+
+    SocialFBGetMe = function SocialFBGetMe(response) {
+        FB.api('/me', function(response) {
+            var image = document.getElementById('fb-profile-image');
+            var name = document.getElementById('fb-profile-name');
+
+            if (response && response.error == undefined) {
+                // user is logged into facebook
+                if (image != undefined)
+                  image.src = 'http://graph.facebook.com/' + response.id + '/picture';
+                if (name != undefined)
+                  name.innerHTML = response.name;
+                // see if we have a record of them and log them in if we do
+                {% if not request.user.is_authenticated %}
+                // only call this if the user is NOT loggedin to the local system already
+                SocialFBHasLocalAccount(response);
+                {% endif %}
+            } else {
+                // console.log('There was an error accessing the user profile:' + user.error.message)
+            }
+        });
+    };
+
+    SocialFBHasLocalAccount = function SocialFBHasLocalAccount(fb_user_info) {
+        $.ajax({
+          type: 'GET',
+          url: "{% url client:has_fb_account %}?uid=" + fb_user_info.id,
+          fb_user_info: fb_user_info
+        })
+        .success(function(data, textStatus, jqXHR) {
+            {% if FACEBOOK_AUTO_LOGIN_IF_HAS_ACCOUNT %}
+            data = $.parseJSON(data);
+            if (data[0].is_authenticated == false) {
+                SocialUserLoginCallback(this.fb_user_info);
+            }
+            {% endif %}
+        })
+        .error(function(jqXHR, textStatus, errorThrown) { 
+            console.log(jqXHR +', '+ textStatus +', '+ errorThrown)
+        })
+        .complete(function() {});
+    }
+
+    FB.getLoginStatus(function(response) {
+      if (response.status === 'connected') {
+        // the user is logged in and has authenticated your
+        // app, and response.authResponse supplies
+        // the user's ID, a valid access token, a signed
+        // request, and the time the access token 
+        // and signed request each expire
+        SocialFBGetMe(response);
+
+      } else if (response.status === 'not_authorized') {
+        // the user is logged in to Facebook, 
+        // but has not authenticated your app
+      } else {
+        // the user isn't logged in to Facebook.
+      }
+     });
+
+     SocialFBExtendedAccessAuthenticationToken = function SocialFBExtendedAccessAuthenticationToken(response) {
+
+         $.ajax({
+           type: 'GET',
+           url: "https://graph.facebook.com/oauth/access_token?client_id={{ FACEBOOK_API_KEY }}&client_secret={{ FACEBOOK_SECRET_KEY }}&grant_type=fb_exchange_token&fb_exchange_token=" + response.authResponse.accessToken,
+         })
+         .success(function(data, textStatus, jqXHR) {
+           data = $.parseQuerystring(data);
+           response.authResponse.accessToken = data.access_token;
+           response.authResponse.expires = data.expires;
+           SocialUserCallback(response);
+         })
+         .error(function(jqXHR, textStatus, errorThrown) { 
+             console.log(jqXHR +', '+ textStatus +', '+ errorThrown)
+         })
+         .complete(function() {});
+     }
+
+    SocialFBLogin = function SocialFBLogin(me_response) {
+        FB.api('/me', function(me_response) {
+            me_response.authResponse = FB.getAuthResponse();
+            SocialFBExtendedAccessAuthenticationToken(me_response);
+        });
+     };
+
+  };
+
+  $.extend({
+    parseQuerystring: function(url){
+      var nvpair = {};
+      var qs = (url == undefined) ? window.location.search.replace('?', '') : url ;
+      var pairs = qs.split('&');
+      $.each(pairs, function(i, v){
+        var pair = v.split('=');
+        nvpair[pair[0]] = pair[1];
+      });
+      return nvpair;
+    }
+  });
+
+  // Load the SDK Asynchronously
+  (function(d){
+     var js, id = 'facebook-jssdk', ref = d.getElementsByTagName('script')[0];
+     if (d.getElementById(id)) {return;}
+     js = d.createElement('script'); js.id = id; js.async = true;
+     js.src = "//connect.facebook.net/en_US/all.js";
+     ref.parentNode.insertBefore(js, ref);
+   }(document));
+</script>

socialregistration/contrib/facebook_js/templatetags/facebook.py

@@ -0,0 +1,7 @@
+from django import template
+
+from socialregistration.templatetags import button
+
+register = template.Library()
+
+register.tag('facebook_button', button('socialregistration/facebook_js/facebook_js.html'))

socialregistration/contrib/facebook_js/templatetags/facebook_tags.py

@@ -0,0 +1,5 @@
+import warnings 
+
+warnings.warn("{% load facebook_tags %} will be removed. Use {% load facebook %} instead")
+
+from facebook import *