def authenticate(self, openid_key, request, provider, email=None):
try:
assoc = UserAssociation.objects.get(openid_key=openid_key)
user = User.objects.get(pk=assoc.user.pk)
if user.is_active:
return user
else:
return
except (UserAssociation.DoesNotExist, User.DoesNotExist):
#fetch if openid provider provides any simple registration fields
nickname = None
if request.openid and request.openid.sreg:
if email is None:
email = request.openid.sreg.get('email')
nickname = request.openid.sreg.get('nickname')
elif request.openid and request.openid.ax:
if email is None:
email = request.openid.ax.get('email')
nickname = request.openid.ax.get('nickname')
if nickname is None:
nickname = ''.join([
random.choice('abcdefghijklmnopqrstuvwxyz')
for i in xrange(10)
])
if email is None:
valid_username = False
email = '%s@%s.%s.com' % (nickname, provider,
settings.SITE_NAME)
else:
valid_username = True
existing_users = User.objects.filter(username=nickname).count()
if existing_users > 0:
index = 0
username = '******' % (nickname, index)
while existing_users > 0:
username = '******' % (nickname, index)
existing_users = User.objects.filter(
username=username).count()
index += 1
user = User.objects.create_user(username, email)
else:
user = User.objects.create_user(nickname, email)
user.save()
#create openid association
assoc = UserAssociation()
assoc.openid_key = openid_key
assoc.user = user
if email:
assoc.email = email
if nickname:
assoc.nickname = nickname
if valid_username:
assoc.is_username_valid = True
assoc.save()
#Create AuthMeta
auth_meta = AuthMeta(user=user, provider=provider)
auth_meta.save()
return user
def authenticate(self, openid_key, request, provider):
try:
assoc = UserAssociation.objects.get(openid_key=openid_key)
if assoc.user.is_active:
return assoc.user
else:
return
except UserAssociation.DoesNotExist:
#fetch if openid provider provides any simple registration fields
nickname = None
email = None
if request.openid and request.openid.sreg:
email = request.openid.sreg.get('email')
nickname = request.openid.sreg.get('nickname')
elif request.openid and request.openid.ax:
if provider in ('Google', 'Yahoo'):
email = request.openid.ax.get('http://axschema.org/contact/email')
email = email.pop()
else:
email = request.openid.ax.get('email')
nickname = request.openid.ax.get('nickname')
if nickname is None :
if email:
nickname = email.split('@')[0]
else:
nickname = ''.join([random.choice('abcdefghijklmnopqrstuvwxyz') for i in xrange(10)])
if email is None :
valid_username = False
email = None #'*****@*****.**'%(nickname)
else:
valid_username = True
name_count = User.objects.filter(username__startswith = nickname).count()
if name_count:
username = '******'%(nickname, name_count + 1)
user = User.objects.create_user(username,email or '')
else:
user = User.objects.create_user(nickname,email or '')
user.save()
#create openid association
assoc = UserAssociation()
assoc.openid_key = openid_key
assoc.user = user#AuthUser.objects.get(pk=user.pk)
if email:
assoc.email = email
if nickname:
assoc.nickname = nickname
if valid_username:
assoc.is_username_valid = True
assoc.save()
#Create AuthMeta
auth_meta = AuthMeta(user = user, provider = provider)
auth_meta.save()
return user
def authenticate(self, openid_key, request, provider):
try:
assoc = UserAssociation.objects.get(openid_key=openid_key)
return assoc.user
except UserAssociation.DoesNotExist:
#fetch if openid provider provides any simple registration fields
nickname = None
email = None
print "dfsdfsdfsdfsfsdfsdf"
if request.openid and request.openid.sreg:
email = request.openid.sreg.get('email')
nickname = request.openid.sreg.get('nickname')
elif request.openid and request.openid.ax:
email = request.openid.ax.__dict__.get('data').values()[0][0]
nickname = email.split('@')[
0] #request.openid.ax.get('nickname')
if nickname is None:
nickname = ''.join([
random.choice('abcdefghijklmnopqrstuvwxyz')
for i in xrange(10)
])
if email is None:
valid_username = False
email = '%s@%s.%s.com' % (nickname, provider,
settings.SITE_NAME)
else:
valid_username = True
name_count = User.objects.filter(
username__startswith=nickname).count()
if name_count:
username = '******' % (nickname, name_count + 1)
user = User.objects.create_user(username, email)
else:
user = User.objects.create_user(nickname, email)
user.save()
#create openid association
assoc = UserAssociation()
assoc.openid_key = openid_key
assoc.user = user
if email:
assoc.email = email
if nickname:
assoc.nickname = nickname
if valid_username:
assoc.is_username_valid = True
assoc.save()
#Create AuthMeta
auth_meta = AuthMeta(user=user, provider=provider)
auth_meta.save()
return user
def authenticate(self, openid_key, request, provider, user=None):
try:
assoc = UserAssociation.objects.get(openid_key = openid_key)
return assoc.user
except UserAssociation.DoesNotExist:
#fetch if openid provider provides any simple registration fields
nickname = None
email = None
if request.openid and request.openid.sreg:
email = request.openid.sreg.get('email')
nickname = request.openid.sreg.get('nickname')
elif request.openid and request.openid.ax:
email = request.openid.ax.get('http://axschema.org/contact/email')[0]
try:
nickname = request.openid.ax.get('nickname')#should be replaced by correct schema
except:
pass
if nickname is None :
nickname = ''.join([random.choice('abcdefghijklmnopqrstuvwxyz') for i in xrange(10)])
name_count = User.objects.filter(username__startswith = nickname).count()
if name_count:
username = '******'.format(nickname, name_count + 1)
else:
username = '******'.format(nickname)
if email is None :
valid_username = False
email = "{0}@socialauth".format(username)
else:
valid_username = True
if not user:
user = User.objects.create_user(username, email or '')
user.save()
#create openid association
assoc = UserAssociation()
assoc.openid_key = openid_key
assoc.user = user
if email:
assoc.email = email
if nickname:
assoc.nickname = nickname
if valid_username:
assoc.is_username_valid = True
assoc.save()
#Create AuthMeta
auth_meta = AuthMeta(user=user, provider=provider, provider_model='OpenidProfile', provider_id=assoc.pk)
auth_meta.save()
return user
def authenticate(self, openid_key, request, provider):
try:
assoc = UserAssociation.objects.get(openid_key=openid_key)
return assoc.user
except UserAssociation.DoesNotExist:
# fetch if openid provider provides any simple registration fields
nickname = None
email = None
if request.openid and request.openid.sreg:
email = request.openid.sreg.get("email")
nickname = request.openid.sreg.get("nickname")
elif request.openid and request.openid.ax:
email = request.openid.ax.get("http://axschema.org/contact/email")[0]
try:
nickname = request.openid.ax.get("nickname") # should be replaced by correct schema
except:
pass
if nickname is None:
nickname = "".join([random.choice("abcdefghijklmnopqrstuvwxyz") for i in xrange(10)])
if email is None:
valid_username = False
email = None #'*****@*****.**'%(nickname)
else:
valid_username = True
name_count = User.objects.filter(username__startswith=nickname).count()
if name_count:
username = "******" % (nickname, name_count + 1)
try:
user = User.objects.get(email=email)
except:
user = User.objects.create_user(nickname, email or "")
user.save()
# create openid association
assoc = UserAssociation()
assoc.openid_key = openid_key
assoc.user = user
if email:
assoc.email = email
if nickname:
assoc.nickname = nickname
if valid_username:
assoc.is_username_valid = True
assoc.save()
# Create AuthMeta
auth_meta = AuthMeta(user=user, provider=provider)
auth_meta.save()
return user
def authenticate(self, twitter_access_token, user=None):
'''authenticates the token by requesting user information from twitter'''
# twitter = oauthtwitter.OAuthApi(TWITTER_CONSUMER_KEY, TWITTER_CONSUMER_SECRET, twitter_access_token)
twitter = oauthtwitter.TwitterOAuthClient(
settings.TWITTER_CONSUMER_KEY, settings.TWITTER_CONSUMER_SECRET)
try:
userinfo = twitter.get_user_info(twitter_access_token)
except:
# If we cannot get the user information, user cannot be authenticated
raise
screen_name = userinfo.screen_name
twitter_id = userinfo.id
try:
user_profile = TwitterUserProfile.objects.get(
screen_name=screen_name)
# Update Twitter Profile
user_profile.url = userinfo.url
user_profile.location = userinfo.location
user_profile.description = userinfo.description
user_profile.profile_image_url = userinfo.profile_image_url
user_profile.save()
user = user_profile.user
return user
except TwitterUserProfile.DoesNotExist:
# Create new user
if not user:
same_name_count = User.objects.filter(
username__startswith=screen_name).count()
if same_name_count:
username = '******' % (screen_name, same_name_count + 1)
else:
username = screen_name
user = User(username=username)
name_data = userinfo.name.split()
try:
first_name, last_name = name_data[0], ' '.join(
name_data[1:])
except:
first_name, last_name = screen_name, ''
user.first_name, user.last_name = first_name, last_name
#user.email = screen_name + "@socialauth"
#user.email = '*****@*****.**'%(userinfo.screen_name)
user.save()
user_profile = TwitterUserProfile(user=user,
screen_name=screen_name)
user_profile.access_token = twitter_access_token
user_profile.url = userinfo.url
user_profile.location = userinfo.location
user_profile.description = userinfo.description
user_profile.profile_image_url = userinfo.profile_image_url
user_profile.save()
auth_meta = AuthMeta(user=user, provider='Twitter').save()
return user
def authenticate(self, linkedin_access_token, user=None):
linkedin = LinkedIn(LINKEDIN_CONSUMER_KEY, LINKEDIN_CONSUMER_SECRET)
# get their profile
profile = (ProfileApi(linkedin).getMyProfile(
access_token=linkedin_access_token))
try:
user_profile = (LinkedInUserProfile.objects.get(
linkedin_uid=profile.id))
user = user_profile.user
return user
except LinkedInUserProfile.DoesNotExist:
# Create a new user
username = '******' % profile.id
if not user:
user = User(username=username)
user.first_name, user.last_name = (profile.firstname,
profile.lastname)
user.email = '%s@socialauth' % (username)
user.save()
userprofile = LinkedInUserProfile(user=user,
linkedin_uid=profile.id)
userprofile.save()
auth_meta = AuthMeta(user=user, provider='LinkedIn').save()
return user
def authenticate(self, request, user=None):
cookie = facebook.get_user_from_cookie(request.COOKIES,
FACEBOOK_APP_ID,
FACEBOOK_SECRET_KEY)
if cookie:
uid = cookie['uid']
access_token = cookie['access_token']
else:
# if cookie does not exist
# assume logging in normal way
params = {}
params["client_id"] = FACEBOOK_APP_ID
params["client_secret"] = FACEBOOK_SECRET_KEY
params["redirect_uri"] = '%s://%s%s' % (
'https' if request.is_secure() else 'http',
Site.objects.get_current().domain,
reverse("socialauth_facebook_login_done"))
params["code"] = request.GET.get('code', '')
url = ("https://graph.facebook.com/oauth/access_token?" +
urllib.urlencode(params))
from cgi import parse_qs
userdata = urllib.urlopen(url).read()
res_parse_qs = parse_qs(userdata)
# Could be a bot query
if not res_parse_qs.has_key('access_token'):
return None
access_token = res_parse_qs['access_token'][-1]
graph = facebook.GraphAPI(access_token)
uid = graph.get_object('me')['id']
try:
fb_user = FacebookUserProfile.objects.get(facebook_uid=uid)
return fb_user.user
except FacebookUserProfile.DoesNotExist:
# create new FacebookUserProfile
graph = facebook.GraphAPI(access_token)
fb_data = graph.get_object("me")
if not fb_data:
return None
username = uid
if not user:
user = User.objects.create(username=username)
user.first_name = fb_data['first_name']
user.last_name = fb_data['last_name']
user.email = username + '@socialauth+facebook'
user.save()
fb_profile = FacebookUserProfile(facebook_uid=uid, user=user)
fb_profile.save()
auth_meta = AuthMeta(user=user, provider='Facebook').save()
return user
def authenticate(self, openid_key, request, provider):
try:
assoc = UserAssociation.objects.get(openid_key = openid_key)
return assoc.user
except UserAssociation.DoesNotExist:
#fetch if openid provider provides any simple registration fields
nickname = None
email = None
print "dfsdfsdfsdfsfsdfsdf"
if request.openid and request.openid.sreg:
email = request.openid.sreg.get('email')
nickname = request.openid.sreg.get('nickname')
elif request.openid and request.openid.ax:
email = request.openid.ax.__dict__.get('data').values()[0][0]
nickname = email.split('@')[0] #request.openid.ax.get('nickname')
if nickname is None :
nickname = ''.join([random.choice('abcdefghijklmnopqrstuvwxyz') for i in xrange(10)])
if email is None :
valid_username = False
email = '%s@%s.%s.com'%(nickname, provider, settings.SITE_NAME)
else:
valid_username = True
name_count = User.objects.filter(username__startswith = nickname).count()
if name_count:
username = '******'%(nickname, name_count + 1)
user = User.objects.create_user(username,email)
else:
user = User.objects.create_user(nickname,email)
user.save()
#create openid association
assoc = UserAssociation()
assoc.openid_key = openid_key
assoc.user = user
if email:
assoc.email = email
if nickname:
assoc.nickname = nickname
if valid_username:
assoc.is_username_valid = True
assoc.save()
#Create AuthMeta
auth_meta = AuthMeta(user = user, provider = provider)
auth_meta.save()
return user
def authenticate(self, access_token):
'''authenticates the token by requesting user information from twitter
'''
twitter = oauthtwitter.OAuthApi(TWITTER_CONSUMER_KEY, TWITTER_CONSUMER_SECRET, access_token)
try:
userinfo = twitter.GetUserInfo()
except:
# If we cannot get the user information, user cannot be authenticated
raise
screen_name = userinfo.screen_name
img_url = userinfo.profile_image_url
try:
user_profile = TwitterUserProfile.objects.get(screen_name = screen_name)
if user_profile.user.is_active:
return user_profile.user
else:
return
except TwitterUserProfile.DoesNotExist:
#Create new user
same_name_count = User.objects.filter(username__startswith = screen_name).count()
if same_name_count:
username = '******' % (screen_name, same_name_count + 1)
else:
username = screen_name
username = '******'+username
name_count = AuthUser.objects.filter(username__startswith = username).count()
if name_count:
username = '******'%(username, name_count + 1)
user = User(username = username)
temp_password = User.objects.make_random_password(length=12)
user.set_password(temp_password)
name_data = userinfo.name.split()
try:
first_name, last_name = name_data[0], ' '.join(name_data[1:])
except:
first_name, last_name = screen_name, ''
user.first_name, user.last_name = first_name, last_name
if img_url:
img = ContentFile(urlopen(img_url).read())
name = img_url.split('/')[-1]
user.picture.save(name, img, False)
#user.email = '%s@twitteruser.%s.com'%(userinfo.screen_name, settings.SITE_NAME)
user.save()
userprofile = TwitterUserProfile(user = user, screen_name = screen_name)
userprofile.access_token = access_token.key
userprofile.url = userinfo.url
userprofile.location = userinfo.location
userprofile.description = userinfo.description
userprofile.profile_image_url = userinfo.profile_image_url
userprofile.save()
AuthMeta(user=user, provider='Twitter').save()
return user
def authenticate(self, openid_key, request, provider):
try:
assoc = UserAssociation.objects.get(openid_key = openid_key)
return assoc.user
except UserAssociation.DoesNotExist:
#fetch if openid provider provides any simple registration fields
nickname = None
email = None
# print 'request.openid: %s' % request.openid
# print 'request.openid.sreg: %s' % request.openid.sreg
if request.openid and request.openid.sreg:
email = request.openid.sreg.get('email')
nickname = request.openid.sreg.get('nickname')
if nickname is None :
nickname = ''.join([random.choice('abcdefghijklmnopqrstuvwxyz') for i in xrange(10)])
if email is None :
email = '%s@%s.%s.com'%(nickname, provider, settings.SITE_NAME)
name_count = User.objects.filter(username__startswith = nickname).count()
# print 'nickname: %s, email: %s, name_count: %s' % (nickname, email, name_count)
if name_count:
username = '******'%(nickname, name_count + 1)
user = User.objects.create_user(username,email)
else:
user = User.objects.create_user(nickname,email)
user.save()
#create openid association
assoc = UserAssociation()
assoc.openid_key = openid_key
assoc.user = user
if email:
assoc.email = email
if nickname:
assoc.nickname = nickname
assoc.save()
#Create AuthMeta
auth_meta = AuthMeta(user = user, provider = provider)
auth_meta.save()
return user
def authenticate(self, foursquare_access_token):
try:
foursquare_profile = FoursquareUserProfile.objects.get(
access_token=foursquare_access_token)
return foursquare_profile.user
except FoursquareUserProfile.DoesNotExist:
foursquare_user_count = FoursquareUserProfile.objects.all().count()
username = "******" + str(foursquare_user_count + 1)
user = User(username=username)
user.save()
foursquare_user = FoursquareUserProfile(
user=user, access_token=foursquare_access_token)
foursquare_user.save()
AuthMeta(user=user, provider='Foursquare').save()
return foursquare_user.user
def authenticate(self, cookies):
API_KEY = FACEBOOK_API_KEY
API_SECRET = FACEBOOK_API_SECRET
REST_SERVER = FACEBOOK_REST_SERVER
if API_KEY in cookies:
signature_hash = get_facebook_signature(API_KEY, API_SECRET,
cookies, True)
if (signature_hash == cookies[API_KEY]) and (
datetime.fromtimestamp(float(
cookies[API_KEY + '_expires'])) > datetime.now()):
user_info_response = get_user_info(API_KEY, API_SECRET,
cookies)
username = user_info_response[0]['first_name']
try:
user_profile = FacebookUserProfile.objects.get(
user__is_active=True,
facebook_uid=user_info_response[0]['uid'])
if user_profile.user.is_active:
return user_profile.user
else:
return
except FacebookUserProfile.DoesNotExist:
fb_data = user_info_response[0]
name_count = AuthUser.objects.filter(
username__istartswith=username).count()
if name_count:
username = '******' % (username, name_count + 1)
#user_email = '%s@facebookuser.%s.com'%(user_info_response[0]['first_name'], settings.SITE_NAME)
user = User.objects.create(username=username)
user.first_name = fb_data['first_name']
user.last_name = fb_data['last_name']
user.save()
location = str(fb_data['current_location'])
fb_profile = FacebookUserProfile(
facebook_uid=fb_data['uid'],
user=user,
profile_image_url=fb_data['pic_small'],
location=location)
fb_profile.save()
AuthMeta(user=user, provider='Facebook').save()
return user
else:
return None
else:
return None
def authenticate(self, github_access_token, user=None):
response_qs = parse_qs(github_access_token)
github_access_token = response_qs['access_token'][0]
try:
github_user = GithubUserProfile.objects.get(
access_token=github_access_token)
return github_user.user
except GithubUserProfile.DoesNotExist:
github_user_count = GithubUserProfile.objects.all().count()
username = "******" + str(github_user_count + 1)
user = User(username=username)
user.save()
github_user = GithubUserProfile(user=user,
access_token=github_access_token)
github_user.save()
AuthMeta(user=user, provider='Github').save()
return github_user.user
def authenticate(self, access_token):
""" authenticates the token by requesting user information from twitter """
try:
api = oauthtwitter.OAuthApi(TWITTER_CONSUMER_KEY,
TWITTER_CONSUMER_SECRET, access_token)
userinfo = api.GetUserInfo()
except:
# If we cannot get the user information, user cannot be authenticated
raise
try:
user_profile = TwitterUserProfile.objects.get(
screen_name=userinfo.screen_name)
if user_profile.user.is_active:
return user_profile.user
else:
return
except TwitterUserProfile.DoesNotExist:
#Create new user
username = userinfo.screen_name
user = new_user(username=username, provider='Twitter')
name_data = userinfo.name.split()
try:
first_name, last_name = name_data[0], ' '.join(name_data[1:])
except:
first_name, last_name = userinfo.screen_name, ''
user.first_name, user.last_name = first_name, last_name
user.save()
img_url = userinfo.profile_image_url
userprofile = TwitterUserProfile(user=user,
screen_name=userinfo.screen_name)
userprofile.access_token = access_token.key
userprofile.url = userinfo.url
userprofile.location = userinfo.location
userprofile.description = userinfo.description
userprofile.profile_image_url = userinfo.profile_image_url
#user.email = '%s@Twitteruser.%s.com'%(userinfo.screen_name, settings.SITE_NAME)
if img_url:
img = ContentFile(urlopen(img_url).read())
name = img_url.split('/')[-1]
user.picture.save(name, img, False)
userprofile.save()
AuthMeta(user=user, provider='Twitter').save()
return user
def authenticate(self, fb_access_token):
""" authenticates the token by requesting user information from facebook """
try:
api = facebook.GraphAPI(fb_access_token)
userinfo = api.get_object("me")
except:
# If we cannot get the user information, user cannot be authenticated
raise
# variables not initialise here
try:
user_profile = FacebookUserProfile.objects.get(
fb_uid=userinfo['id'])
if user_profile.user.is_active:
return user_profile.user
else:
return
except FacebookUserProfile.DoesNotExist:
#Create new user
try:
username = userinfo['username']
except KeyError:
# if username not set on facebook
username = userinfo['first_name']
user = new_user(username=username, provider='Facebook')
user.first_name, user.last_name = userinfo['first_name'], userinfo[
'last_name']
#img_url = 'http://graph.facebook.com/me/picture?type=large'+'&fb_access_token='+ access_token
user.save()
userprofile = FacebookUserProfile(user=user,
fb_uid=userinfo['id'],
fb_username=username,
location=userinfo['location'])
userprofile.access_token = fb_access_token
"""if img_url:
img = ContentFile(urlopen(img_url).read())
name = img_url.split('/')[-1]
user.picture.save(name, img, False)"""
userprofile.save()
AuthMeta(user=user, provider='Facebook').save()
return user
def authenticate(self, request):
if not settings.FACEBOOK_API_KEY in request.COOKIES:
return None
facebook = Facebook(settings.FACEBOOK_API_KEY,
settings.FACEBOOK_SECRET_KEY)
check = facebook.check_session(request)
fb_user = facebook.users.getLoggedInUser()
try:
profile = FacebookUserProfile.objects.get(facebook_uid=fb_user)
return profile.user
except FacebookUserProfile.DoesNotExist:
fb_data = facebook.users.getInfo([fb_user], [
'uid', 'first_name', 'last_name', 'pic_small',
'current_location'
])
if not fb_data:
return None
fb_data = fb_data[0]
username = '******' % fb_data['uid']
user_email = '%s@facebookuser.%s.com' % (fb_data['first_name'],
settings.SITE_NAME)
user = User.objects.create(username=username, email=user_email)
user.first_name = fb_data['first_name']
user.last_name = fb_data['last_name']
user.save()
location = str(fb_data['current_location'])
fb_profile = FacebookUserProfile(
facebook_uid=fb_data['uid'],
user=user,
profile_image_url=fb_data['pic_small'],
location=location)
fb_profile.save()
auth_meta = AuthMeta(user=user, provider='Facebook').save()
return user
except Exception, e:
print str(e)
def authenticate(self, facebook, request):
facebook.oauth2_check_session(request)
facebook.uid = facebook.users.getLoggedInUser()
user_info = facebook.users.getInfo([facebook.uid], ['first_name', 'last_name', 'pic_square'])[0]
username = user_info['first_name']
try:
user_profile = FacebookUserProfile.objects.get(user__is_active=True, facebook_uid=user_info['uid'])
if user_profile.user.is_active:
return user_profile.user
else:
return None
except FacebookUserProfile.DoesNotExist:
name_count = AuthUser.objects.filter(username__istartswith=username).count()
if name_count:
username = '******' % (username, name_count + 1)
user = User.objects.create(username=username)
user.first_name = user_info['first_name']
user.last_name = user_info['last_name']
img_url = user_info.get('pic_square')
if img_url:
img = ContentFile(urlopen(img_url).read())
name = img_url.split('/')[-1]
user.picture.save(name, img, False)
user.save()
location = '' # TODO: Figure out how to get this from Facebook. Maybe.
fb_profile = FacebookUserProfile(facebook_uid=user_info['uid'], user=user,
profile_image_url=img_url, location=location)
fb_profile.save()
AuthMeta(user=user, provider='Facebook').save()
return user
def authenticate(self, openid_key, request, provider, user=None):
try:
assoc = UserAssociation.objects.get(openid_key=openid_key)
return assoc.user
except UserAssociation.DoesNotExist:
#fetch if openid provider provides any simple registration fields
nickname = None
email = None
firstname = None
lastname = None
if request.openid and request.openid.sreg:
email = request.openid.sreg.get('email')
nickname = request.openid.sreg.get('nickname')
firstname, lastname = (request.openid.sreg.get(
'fullname', ' ').split(' ', 1))
elif request.openid and request.openid.ax:
email = \
(request.openid.ax
.getSingle('http://axschema.org/contact/email'))
if 'google' in provider:
ax_schema = OPENID_AX_PROVIDER_MAP['Google']
firstname = (request.openid.ax.getSingle(
ax_schema['firstname']))
lastname = (request.openid.ax.getSingle(
ax_schema['lastname']))
nickname = email.split('@')[0]
else:
ax_schema = OPENID_AX_PROVIDER_MAP['Default']
try:
#should be replaced by correct schema
nickname = (request.openid.ax.getSingle(
ax_schema['nickname']))
(firstname, lastname) = (request.openid.ax.getSingle(
ax_schema['fullname']).split(' ', 1))
except:
pass
if nickname is None:
nickname = ''.join([
random.choice('abcdefghijklmnopqrstuvwxyz')
for i in xrange(10)
])
name_count = (User.objects.filter(
username__startswith=nickname).count())
if name_count:
username = '******' % (nickname, name_count + 1)
else:
username = '******' % (nickname)
if email is None:
valid_username = False
email = "%s@socialauth" % (username)
else:
valid_username = True
if not user:
user = User.objects.create_user(username, email)
user.first_name = firstname
user.last_name = lastname
user.save()
#create openid association
assoc = UserAssociation()
assoc.openid_key = openid_key
assoc.user = user
if email:
assoc.email = email
if nickname:
assoc.nickname = nickname
if valid_username:
assoc.is_username_valid = True
assoc.save()
#Create AuthMeta
# auth_meta =
# AuthMeta(user=user,
# provider=provider,
# provider_model='OpenidProfile',
# provider_id=assoc.pk)
auth_meta = AuthMeta(user=user, provider=provider)
auth_meta.save()
return user
def authenticate(self, request, user=None):
cookie = facebook.get_user_from_cookie(request.COOKIES,
FACEBOOK_APP_ID,
FACEBOOK_SECRET_KEY)
if cookie:
uid = cookie['uid']
access_token = cookie['access_token']
else:
# if cookie does not exist
# assume logging in normal way
params = {}
params["client_id"] = FACEBOOK_APP_ID
params["client_secret"] = FACEBOOK_SECRET_KEY
params["redirect_uri"] = reverse(
"socialauth_facebook_login_done")[1:]
params["code"] = request.GET.get('code', '')
url = ("https://graph.facebook.com/oauth/access_token?" +
urllib.urlencode(params))
from cgi import parse_qs
userdata = urllib.urlopen(url).read()
res_parse_qs = parse_qs(userdata)
# Could be a bot query
if not res_parse_qs.has_key('access_token'):
return None
parse_data = res_parse_qs['access_token']
uid = parse_data['uid'][-1]
access_token = parse_data['access_token'][-1]
try:
fb_user = FacebookUserProfile.objects.get(facebook_uid=uid)
return fb_user.user
except FacebookUserProfile.DoesNotExist:
# create new FacebookUserProfile
graph = facebook.GraphAPI(access_token)
fb_data = graph.get_object("me")
if not fb_data:
return None
username = uid
if not user:
user = User.objects.create(username=username)
user.first_name = fb_data['first_name']
user.last_name = fb_data['last_name']
user.email = fb_data.get('email')
user.save()
picture_url = 'http://graph.facebook.com/%s/picture' % uid
fb_profile = FacebookUserProfile(
facebook_uid=uid,
user=user,
profile_image_url=picture_url,
profile_image_url_small=picture_url + '?type=small',
profile_image_url_big=picture_url + '?type=large',
about_me=fb_data.get('about'),
url=fb_data.get('website'),
)
if 'location' in fb_data:
fb_profile.location = fb_data['location']['name']
fb_profile.save()
auth_meta = AuthMeta(user=user, provider='Facebook').save()
return user
def authenticate(self, openid_key, request, provider):
try:
assoc = UserAssociation.objects.get(openid_key=openid_key)
if assoc.user.is_active:
return assoc.user
else:
return
except UserAssociation.DoesNotExist:
#fetch if openid provider provides any simple registration fields
nickname = None
email = None
if request.openid and request.openid.sreg:
email = request.openid.sreg.get('email')
nickname = request.openid.sreg.get('nickname')
elif request.openid and request.openid.ax:
if provider in ('Google', 'Yahoo'):
email = request.openid.ax.get(
'http://axschema.org/contact/email')
email = email.pop()
else:
try:
email = request.openid.ax.get('email')
except KeyError:
pass
try:
nickname = request.openid.ax.get('nickname')
except KeyError:
pass
if nickname is None:
if email:
nickname = email.split('@')[0]
else:
nickname = ''.join([
random.choice('abcdefghijklmnopqrstuvwxyz')
for i in xrange(10)
])
if email is None:
valid_username = False
email = None #'*****@*****.**'%(nickname)
else:
valid_username = True
name_count = AuthUser.objects.filter(
username__startswith=nickname).count()
if name_count:
username = '******' % (nickname, name_count + 1)
user = User.objects.create_user(username, email or '')
else:
user = User.objects.create_user(nickname, email or '')
user.save()
#create openid association
assoc = UserAssociation()
assoc.openid_key = openid_key
assoc.user = user #AuthUser.objects.get(pk=user.pk)
if email:
assoc.email = email
if nickname:
assoc.nickname = nickname
if valid_username:
assoc.is_username_valid = True
assoc.save()
#Create AuthMeta
auth_meta = AuthMeta(user=user, provider=provider)
auth_meta.save()
return user
def authenticate(self, openid_key, request, provider, user=None):
logger.info("request.GET: %s", request.GET)
logger.info("request.POST: %s", request.POST)
logger.info("------------------------------------------ Authenticating against OpenID")
logger.info("openid_key: %s", openid_key)
logger.info("provider: %s", provider)
try:
assoc = OpenidProfile.objects.get(openid_key=openid_key)
logger.info("Found a OpenidProfile")
logger.info("assoc.openid_key: %s", assoc.openid_key)
logger.info("assoc.user.username: %s", assoc.user.username)
logger.info("assoc.nickname: %s", assoc.nickname)
logger.info("assoc.is_username_valid: %s", assoc.is_username_valid)
logger.info("assoc.email: %s", assoc.email)
if assoc.email.endswith("@socialauth") and request.openid.ax is not None:
assoc.email = request.openid.ax.getSingle("http://axschema.org/contact/email", None)
logger.info("Updating existing OpenidProfile with correct openid email")
assoc.save()
return assoc.user
except OpenidProfile.DoesNotExist:
# fetch if openid provider provides any simple registration fields
logger.info("Creating a OpenidProfile")
nickname = None
email = None
if request.openid and request.openid.sreg:
email = request.openid.sreg.get("email")
nickname = request.openid.sreg.get("nickname")
elif request.openid and request.openid.ax:
email = request.openid.ax.getSingle("http://axschema.org/contact/email", None)
if nickname is None:
nickname = "".join([random.choice("abcdefghijklmnopqrstuvwxyz") for i in xrange(10)])
name_count = User.objects.filter(username__startswith=nickname).count()
if name_count:
username = "******".format(nickname, name_count + 1)
else:
username = "******".format(nickname)
if email is None:
valid_username = False
email = "{0}@socialauth".format(username)
else:
valid_username = True
if not user:
user = User.objects.create_user(username, email or "")
user.set_unusable_password()
user.save()
# create openid association
assoc = OpenidProfile()
assoc.openid_key = openid_key
assoc.user = user
if provider == "Google":
assoc.needs_google_crossdomain_merge = True
if email:
assoc.email = email
if nickname:
assoc.nickname = nickname
if valid_username:
assoc.is_username_valid = True
assoc.save()
logger.info("assoc.openid_key: %s", assoc.openid_key)
logger.info("assoc.user.username: %s", assoc.user.username)
logger.info("assoc.nickname: %s", assoc.nickname)
logger.info("assoc.is_username_valid: %s", assoc.is_username_valid)
logger.info("assoc.email: %s", assoc.email)
# Create AuthMeta
auth_meta = AuthMeta(user=user, provider=provider, provider_model="OpenidProfile", provider_id=assoc.pk)
auth_meta.save()
return user
def authenticate(self, openid_key, request, provider, user=None):
try:
assoc = UserAssociation.objects.get(openid_key=openid_key)
return assoc.user
except UserAssociation.DoesNotExist:
#fetch if openid provider provides any simple registration fields
nickname = None
email = None
firstname = None
lastname = None
if request.openid and request.openid.sreg:
email = request.openid.sreg.get('email')
nickname = request.openid.sreg.get('nickname')
firstname, lastname = (request.openid.sreg
.get('fullname', ' ')
.split(' ', 1))
elif request.openid and request.openid.ax:
email = \
(request.openid.ax
.getSingle('http://axschema.org/contact/email'))
if 'google' in provider:
ax_schema = OPENID_AX_PROVIDER_MAP['Google']
firstname = (request.openid.ax
.getSingle(ax_schema['firstname']))
lastname = (request.openid.ax
.getSingle(ax_schema['lastname']))
nickname = email.split('@')[0]
else:
ax_schema = OPENID_AX_PROVIDER_MAP['Default']
try:
#should be replaced by correct schema
nickname = (request.openid.ax
.getSingle(ax_schema['nickname']))
(firstname,
lastname) = (request.openid.ax
.getSingle(ax_schema['fullname'])
.split(' ', 1))
except:
pass
if nickname is None :
nickname = ''.join(
[random
.choice('abcdefghijklmnopqrstuvwxyz')
for i in xrange(10)])
name_count = (User.objects
.filter(username__startswith=nickname)
.count())
if name_count:
username = '******' % (nickname, name_count + 1)
else:
username = '******' % (nickname)
if email is None :
valid_username = False
email = "%s@socialauth" % (username)
else:
valid_username = True
if not user:
user = User.objects.create_user(username, email)
user.first_name = firstname
user.last_name = lastname
user.save()
#create openid association
assoc = UserAssociation()
assoc.openid_key = openid_key
assoc.user = user
if email:
assoc.email = email
if nickname:
assoc.nickname = nickname
if valid_username:
assoc.is_username_valid = True
assoc.save()
#Create AuthMeta
# auth_meta =
# AuthMeta(user=user,
# provider=provider,
# provider_model='OpenidProfile',
# provider_id=assoc.pk)
auth_meta = AuthMeta(user=user, provider=provider)
auth_meta.save()
return user
def authenticate(self, openid_key, request, provider, user=None):
try:
assoc = UserAssociation.objects.get(openid_key=openid_key)
return assoc.user
except UserAssociation.DoesNotExist:
# fetch if openid provider provides any simple registration fields
nickname = None
email = None
first_name = None
last_name = None
if request.openid and request.openid.sreg:
email = request.openid.sreg.get("email")
nickname = request.openid.sreg.get("nickname")
first_name, last_name = request.openid.sreg.get("fullname", "").split(" ", 1)
elif request.openid and request.openid.ax:
email = request.openid.ax.get("http://axschema.org/contact/email")[0]
try:
nickname = request.openid.ax.get("nickname") # should be replaced by correct schema
except:
pass
try:
first_name = request.openid.ax.get("http://axschema.org/namePerson/first").pop()
except:
pass
try:
last_name = request.openid.ax.get("http://axschema.org/namePerson/last").pop()
except:
pass
if nickname is None:
nickname = "".join([random.choice("abcdefghijklmnopqrstuvwxyz") for i in xrange(10)])
name_count = User.objects.filter(username__startswith=nickname).count()
if name_count:
username = "******" % (nickname, name_count + 1)
else:
username = "******" % (nickname)
if email is None:
valid_username = False
email = "%s@socialauth" % (username)
else:
valid_username = True
if not user:
user = User.objects.create_user(username, email or "")
if first_name is not None:
user.first_name = first_name
if last_name is not None:
user.last_name = last_name
user.save()
# create openid association
assoc = UserAssociation()
assoc.openid_key = openid_key
assoc.user = user
if email:
assoc.email = email
if nickname:
assoc.nickname = nickname
if valid_username:
assoc.is_username_valid = True
assoc.save()
# Create AuthMeta
# auth_meta =
# AuthMeta(user=user,
# provider=provider,
# provider_model='OpenidProfile',
# provider_id=assoc.pk)
auth_meta = AuthMeta(user=user, provider=provider)
auth_meta.save()
return user
def openid_done(request, provider=None):
"""
When the request reaches here, the user has completed the Openid
authentication flow. He has authorised us to login via Openid, so
request.openid is populated.
After coming here, we want to check if we are seeing this openid first time.
If we are, we will create a new Django user for this Openid, else login the
existing openid.
"""
if not provider:
provider = request.session.get("openid_provider", "")
if request.openid:
email = None
nickname = None
password = None
# fetch if openid provider provides any simple registration fields
if request.openid.sreg:
if request.openid.sreg.has_key("email"):
email = request.openid.sreg["email"]
if request.openid.sreg.has_key("nickname"):
nickname = request.openid.sreg["nickname"]
# check for already existing associations
openid_key = escape(str(request.openid))
userassociation = UserAssociation.objects.filter(openid_key=openid_key)
if userassociation:
user = userassociation[0].user
nickname = user.username
email = user.email
else:
if nickname is None:
nickname = "".join([random.choice("abcdefghijklmnopqrstuvwxyz") for i in xrange(10)])
if email is None:
from django.conf import settings
email = "%s@%s.%s.com" % (nickname, settings.SITE_NAME, provider)
user = User.objects.create_user(nickname, email)
user.save()
# create openid association
assoc = UserAssociation()
assoc.openid_key = openid_key
assoc.user = user
assoc.save()
# Create AuthMeta
auth_meta = AuthMeta(user=user, provider=provider)
auth_meta.save()
# authenticate and login
user = authenticate(openid_key=openid_key)
if user:
login(request, user)
if "openid_next" in request.session:
openid_next = request.session.get("openid_next")
if len(openid_next.strip()) > 0:
return HttpResponseRedirect(openid_next)
redirect_url = reverse("socialauth_signin_complete")
return HttpResponseRedirect(redirect_url)
