def post(self, request):
print "posting data"
data = JSONParser().parse(request)
access_token = data.get('access_token', '')
try:
print request
app = SocialApp.objects.get(provider="facebook")
token = SocialToken(app=app, token=access_token)
login = fb_complete_login(app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
print login
ret = complete_social_login(request, login)
return Response(status=200,
data={
'success': True,
'username': request.user.username,
'user_id': request.user.pk,
})
except:
return Response(status=401,
data={
'success': False,
'reason': "Bad Access Token",
})
def post(self, request, provider=None, params=None, **kwargs):
from requests import RequestException
from allauth.socialaccount import providers
from allauth.socialaccount.helpers import complete_social_login
from allauth.socialaccount.models import SocialLogin, SocialToken
from allauth.socialaccount.providers.facebook.provider import FacebookProvider
if provider == 'facebook':
try:
app = providers.registry.by_id(
FacebookProvider.id).get_app(request)
token = SocialToken(app=app, token=params.access_token)
login = fb_complete_login(request, app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
ret = complete_social_login(request, login)
except RequestException:
return http.HttpBadRequest(
'Error accessing FB user profile')
else:
# If user does not exist
if login.account.user.id is None:
return http.HttpBadRequest('Not registered')
return self._construct_login_response(login.account.user)
return http.HttpBadRequest('Invalid provider')
def persona_login(request):
assertion = request.POST.get('assertion', '')
audience = request.build_absolute_uri('/')
resp = requests.post('https://verifier.login.persona.org/verify',
{'assertion': assertion,
'audience': audience})
if resp.json()['status'] != 'okay':
return render_authentication_error(request)
email = resp.json()['email']
user = get_adapter() \
.populate_new_user(email=email)
extra_data = resp.json()
account = SocialAccount(uid=email,
provider=PersonaProvider.id,
extra_data=extra_data,
user=user)
# TBD: Persona e-mail addresses are verified, so we could check if
# a matching local user account already exists with an identical
# verified e-mail address and short-circuit the social login. Then
# again, this holds for all social providers that guarantee
# verified e-mail addresses, so if at all, short-circuiting should
# probably not be handled here...
login = SocialLogin(account)
login.state = SocialLogin.state_from_request(request)
return complete_social_login(request, login)
def post(self, request, provider=None, params=None, **kwargs):
from requests import RequestException
from allauth.socialaccount import providers
from allauth.socialaccount.helpers import complete_social_login
from allauth.socialaccount.models import SocialLogin, SocialToken
from allauth.socialaccount.providers.facebook.provider import FacebookProvider
if provider == 'facebook':
try:
app = providers.registry.by_id(FacebookProvider.id).get_app(request)
token = SocialToken(app=app, token=params.access_token)
login = fb_complete_login(request, app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
ret = complete_social_login(request, login)
except RequestException:
return http.HttpBadRequest('Error accessing FB user profile')
else:
# If user does not exist
if login.account.user.id is None:
return http.HttpBadRequest('Not registered')
return self._construct_login_response(login.account.user)
return http.HttpBadRequest('Invalid provider')
def api_facebook_connect_by_token(request):
ret = None
if request.method == 'POST':
form = FacebookConnectForm(request.POST)
if form.is_valid():
try:
app = providers.registry.by_id(FacebookProvider.id)\
.get_app(request)
access_token = form.cleaned_data['access_token']
token = SocialToken(app=app,
token=access_token)
login = fb_complete_login(app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
ret = complete_social_login(request, login)
except:
# FIXME: Catch only what is needed
pass
if not ret:
raise Http404
profile = Profile.objects.get_or_create(user=request.user)[0]
profile.avatar_url = login.account.get_avatar_url()
profile.save()
user_source = UserResource()
bundle = user_source.build_bundle(obj=request.user, request=request)
bundle = user_source.full_dehydrate(bundle)
bundle = user_source.alter_detail_data_to_serialize(request, bundle)
return user_source.create_response(request, bundle)
def join_game(request):
if request.method=="POST":
id=str(request.POST['uuid'])
access_token =str(request.POST['access_token'])
type=str(request.POST['type'])
#email=str(request.POST['email'])
try:
app=SocialApp.objects.get(provider="facebook")
token=SocialToken(app=app,token=access_token)
# Check token against facebook
login = fb_complete_login(request, app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
# Add or update the user into users table
ret = complete_social_login(request, login)
a=SocialToken.objects.get(token=access_token)
try:
account=a.account
user=account.user
game=Game.objects.create(id=id)
game.participants.add(user)
return HttpResponse(serializers.serialize("json",[game]))
except User.DoesNotExist:
return HttpResponse("User Dosent Exist")
return HttpResponse("wuhoo")
except Exception as e:
# If we get here we've failed
return HttpResponse("ASdsa "+str(e))
def mobile_facebook_login(request):
if request.method=="POST":
response=HttpResponse
access_token =str(request.POST['access_token'])
#email=str(request.POST['email'])
try:
app=SocialApp.objects.get(provider="facebook")
token=SocialToken(app=app,token=access_token)
# Check token against facebook
login = fb_complete_login(request, app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
# Add or update the user into users table
ret = complete_social_login(request, login)
a=SocialToken.objects.get(token=access_token)
try:
account=a.account
user=account.user
user.backend = 'django.contrib.auth.backends.ModelBackend'
profile=UserProfile.objects.get_or_create(user=user,dp=account.get_avatar_url(),fullName=user.get_full_name())[0]
return HttpResponse(serializers.serialize("json",[profile]))
except User.DoesNotExist:
return HttpResponse("User Dosent Exist")
return HttpResponse("wuhoo")
except Exception as e:
# If we get here we've failed
return HttpResponse("ASdsa "+str(e))
def post(self, request):
data = JSONParser().parse(request)
access_token = data.get('access_token', '')
try:
app = SocialApp.objects.get(provider="facebook")
token = SocialToken(app=app, token=access_token)
# check token against facebook
login = fb_complete_login(app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
# add or update the user into users table
ret = complete_social_login(request, login)
# if we get here we've succeeded
return Response(status=200, data={
'success': True,
'username': request.user.username,
'user_id': request.user.pk,
})
except:
return Response(status=401 ,data={
'success': False,
'reason': "Bad Access Token",
})
def persona_login(request):
assertion = request.POST.get('assertion', '')
settings = app_settings.PROVIDERS.get(PersonaProvider.id, {})
audience = settings.get('AUDIENCE', None)
if audience is None:
raise ImproperlyConfigured("No Persona audience configured. Please "
"add an AUDIENCE item to the "
"SOCIALACCOUNT_PROVIDERS['persona'] setting.")
resp = requests.post('https://verifier.login.persona.org/verify',
{'assertion': assertion,
'audience': audience})
try:
resp.raise_for_status()
extra_data = resp.json()
if extra_data['status'] != 'okay':
return render_authentication_error(
request,
provider_id=PersonaProvider.id,
extra_context={'response': extra_data})
except (ValueError, requests.RequestException) as e:
return render_authentication_error(
request,
provider_id=PersonaProvider.id,
exception=e)
login = providers.registry \
.by_id(PersonaProvider.id) \
.sociallogin_from_response(request, extra_data)
login.state = SocialLogin.state_from_request(request)
return complete_social_login(request, login)
def persona_login(request):
assertion = request.POST.get('assertion', '')
settings = app_settings.PROVIDERS.get(PersonaProvider.id, {})
audience = settings.get('AUDIENCE', None)
if audience is None:
raise ImproperlyConfigured(
"No Persona audience configured. Please "
"add an AUDIENCE item to the "
"SOCIALACCOUNT_PROVIDERS['persona'] setting.")
resp = requests.post('https://verifier.login.persona.org/verify', {
'assertion': assertion,
'audience': audience
})
try:
resp.raise_for_status()
extra_data = resp.json()
if extra_data['status'] != 'okay':
return render_authentication_error(
request,
provider_id=PersonaProvider.id,
extra_context={'response': extra_data})
except (ValueError, requests.RequestException) as e:
return render_authentication_error(request,
provider_id=PersonaProvider.id,
exception=e)
login = providers.registry \
.by_id(PersonaProvider.id) \
.sociallogin_from_response(request, extra_data)
login.state = SocialLogin.state_from_request(request)
return complete_social_login(request, login)
def login_by_token(request):
ret = None
if (request.method == 'POST'):
form = TwitterConnectForm(request.POST)
if form.is_valid():
try:
app = providers.registry.by_id(
TwitterProvider.id).get_app(request)
oauth_token = form.cleaned_data['oauth_token']
oauth_token_secret = form.cleaned_data['oauth_token_secret']
token = SocialToken(app=app,
token=oauth_token,
token_secret=oauth_token_secret)
auth = OAuth1(app.client_id, app.secret, token.token,
token.token_secret)
resp = requests.get(VERIFY_CREDENTIALS_URL, auth=auth)
resp.raise_for_status()
extra_data = resp.json()
login = twitter_complete_login(extra_data)
login.token = token
login.state = SocialLogin.state_from_request(request)
ret = complete_social_login(request, login)
except requests.RequestException:
logger.exception('Error accessing Twitter user profile')
if not ret:
ret = render_authentication_error(request)
return ret
def post (self,request):
original_request = request._request
data = JSONParser().parse(request)
access_token = data.get('access_token', '')
try:
app = SocialApp.objects.get(provider='facebook')
fb_auth_token = SocialToken(app=app, token=access_token)
login = fb_complete_login(original_request, app, fb_auth_token)
login.token = fb_auth_token
login.state = SocialLogin.state_from_request(original_request)
complete_social_login(original_request, login)
token, _ = Token.objects.get_or_create(user=original_request.user)
data_response ={
'username': original_request.user.username,
'objectId': original_request.user.pk,
'firstName': original_request.user.first_name,
'lastName': original_request.user.last_name,
'email': original_request.user.email,
'sessionToken': token.key,
}
return Response(status=status.HTTP_200_OK, data=data_response)
except:
return Response(status=status.HTTP_401_UNAUTHORIZED,data={
'detail': 'Bad Access Token',
})
def create_game(request):
if request.method=="POST":
lon=str(request.POST['longitude'])
lat=str(request.POST['latitude'])
access_token =str(request.POST['access_token'])
type=str(request.POST['type'])
#email=str(request.POST['email'])
try:
app=SocialApp.objects.get(provider="facebook")
token=SocialToken(app=app,token=access_token)
# Check token against facebook
login = fb_complete_login(request, app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
# Add or update the user into users table
ret = complete_social_login(request, login)
a=SocialToken.objects.get(token=access_token)
try:
account=a.account
user=account.user
location = Point(lon, lat)
game=Game.objects.create(host=user,location=location,type=type)
return HttpResponse("done")
except User.DoesNotExist:
return HttpResponse("User Dosent Exist")
return HttpResponse("wuhoo")
except Exception as e:
# If we get here we've failed
return HttpResponse("ASdsa "+str(e))
def post(self, Request):
serializer = UserLoginSerializer(data=Request.data)
if serializer.is_valid():
request_data = serializer.data
userId = request_data.get('fbuserId','')
access_token = Request.data.get('access_token','')
try:
app = SocialApp.objects.get(provider="facebook")
token = SocialToken(app=app,token=access_token)
login = fb_complete_login(Request, app, token)
login.token = token
login.state = SocialLogin.state_from_request(Request)
user = UserLogin.objects.all().filter(fbuserId = userId)
# ret = complete_social_login(Request, login)
if len(user) == 0:
serializer.save()
return Response(status=200 ,data={
'success': True,
'reason': "User created",
'data':user.values()
})
else:
return Response(status=200 ,data={
'success': False,
'reason': "User already exist",
'data':user.values()
})
except Exception,e:
return Response(status=400 ,data={
'success': False,
'reason':e,
})
def persona_login(request):
assertion = request.POST.get('assertion', '')
audience = request.build_absolute_uri('/')
resp = requests.post('https://verifier.login.persona.org/verify', {
'assertion': assertion,
'audience': audience
})
if resp.json['status'] != 'okay':
return render_authentication_error(request)
email = resp.json['email']
user = User(email=email)
extra_data = resp.json
account = SocialAccount(uid=email,
provider=PersonaProvider.id,
extra_data=extra_data,
user=user)
# TBD: Persona e-mail addresses are verified, so we could check if
# a matching local user account already exists with an identical
# verified e-mail address and short-circuit the social login. Then
# again, this holds for all social providers that guarantee
# verified e-mail addresses, so if at all, short-circuiting should
# probably not be handled here...
login = SocialLogin(account)
login.state = SocialLogin.state_from_request(request)
return complete_social_login(request, login)
def get_sociallogin(self, request, data):
app = SocialApp.objects.get(provider='facebook')
fb_auth_token = SocialToken(app=app, token=data['token']['token'])
login = fb_complete_login(request, app, fb_auth_token)
login.token = fb_auth_token
login.state = SocialLogin.state_from_request(request)
return login
def post(self, request):
print "posting data"
data = JSONParser().parse(request)
access_token = data.get('access_token', '')
try:
print request
app = SocialApp.objects.get(provider="facebook")
token = SocialToken(app=app, token=access_token)
login = fb_complete_login(app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
print login
ret = complete_social_login(request, login)
return Response(status=200, data={
'success': True,
'username': request.user.username,
'user_id': request.user.pk,
})
except:
return Response(status=401 ,data={
'success': False,
'reason': "Bad Access Token",
})
def login_by_token(request):
log.debug("login_by_token")
ret = None
if request.method == 'POST':
form = FacebookConnectForm(request.POST)
if form.is_valid():
log.debug("Form is valid")
try:
app = providers.registry.by_id(FacebookProvider.id) \
.get_app(request)
log.debug("App exists")
access_token = form.cleaned_data['access_token']
log.debug("access token exists")
token = SocialToken(app=app,
token=access_token)
log.debug("social token created")
login = fb_complete_login(app, token)
log.debug("fb login complete")
login.token = token
login.state = SocialLogin.state_from_request(request)
ret = complete_social_login(request, login)
except:
# FIXME: Catch only what is needed
pass
if not ret:
log.debug("authentication error")
ret = render_authentication_error(request)
return ret
def login_by_token(request):
ret = None
auth_exception = None
if request.method == 'POST':
form = KakaoConnectForm(request.POST)
if form.is_valid():
try:
provider = providers.registry.by_id(KakaoProvider.id)
app = providers.registry.by_id(
KakaoProvider.id).get_app(request)
access_token = form.cleaned_data['access_token']
token = SocialToken(app=app, token=access_token)
login = kakao_complete_login(request, app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
ret = complete_social_login(request, login)
except requests.RequestException as e:
logger.exception('Error accessing KAKAO user profile')
auth_exception = e
if not ret:
ret = render_authentication_error(request, KakaoProvider.id,
exception + auth_exception)
return ret
def login_by_token(request):
ret = None
if request.method == 'POST':
form = FacebookConnectForm(request.POST)
if form.is_valid():
# try:
print 'trying'
app = providers.registry.by_id(FacebookProvider.id) \
.get_app(request)
access_token = form.cleaned_data['access_token']
token = SocialToken(app=app,
token=access_token)
login = fb_complete_login(app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
print access_token, token, login.token
ret = complete_social_login(request, login)
print ret
# except:
# print 'error'
# FIXME: Catch only what is needed
# pass
if not ret:
ret = render_authentication_error(request)
return ret
def post(self, request):
data = JSONParser().parse(request)
access_token = data.get('access_token', '')
try:
app = SocialApp.objects.get(provider="facebook")
token = SocialToken(app=app, token=access_token)
# return SocialLogin(account)
login = fb_complete_login(app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
# add or update the user
ret = complete_social_login(request, login)
# if we get here we've succeeded
return Response(status=200, data={
'success': True,
'username': request.user.username,
'user_id': request.user.pk,
'csrf_token': unicode(csrf(request)['csrf_token'])
})
except:
# FIXME: Catch only what is needed
#, HttpForbidden
return Response(status=401 ,data={
'success': False,
'reason': "Bad Access Token",
})
def api_twitter_connect_by_token(request):
ret = None
if request.method == 'POST':
try:
adapter = TwitterOAuthAdapter()
app = adapter.get_provider().get_app(request)
access_token = request.POST.get('access_token')
access_token_secret = request.POST.get('access_token_secret')
token = SocialToken(app=app, token=access_token)
login = twitter_complete_login(request, app, access_token, access_token_secret)
login.token = token
login.state = SocialLogin.state_from_request(request)
ret = complete_social_login(request, login)
except Exception as e:
# FIXME: Catch only what is needed
pass
if not ret:
raise Http404
profile = Profile.objects.get_or_create(user=request.user)[0]
profile.avatar_url = login.account.get_avatar_url()
profile.save()
user_source = UserResource()
bundle = user_source.build_bundle(obj=request.user, request=request)
bundle = user_source.full_dehydrate(bundle)
bundle = user_source.alter_detail_data_to_serialize(request, bundle)
return user_source.create_response(request, bundle)
def login_by_token(request):
ret = None
if request.method == 'POST':
form = FacebookConnectForm(request.POST)
if form.is_valid():
try:
provider = providers.registry.by_id(FacebookProvider.id)
app = providers.registry.by_id(FacebookProvider.id) \
.get_app(request)
access_token = form.cleaned_data['access_token']
info = requests.get(
'https://graph.facebook.com/oauth/access_token_info',
params={'client_id': app.client_id,
'access_token': access_token})
nonce = provider.get_nonce(request, pop=True)
if nonce and nonce == info.json().get('auth_nonce'):
token = SocialToken(app=app,
token=access_token)
login = fb_complete_login(request, app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
ret = complete_social_login(request, login)
except requests.RequestException:
logger.exception('Error accessing FB user profile')
if not ret:
ret = render_authentication_error(request)
return ret
def login_by_token(request):
ret = None
if request.method == 'POST':
form = FacebookConnectForm(request.POST)
if form.is_valid():
try:
provider = providers.registry.by_id(FacebookProvider.id)
app = providers.registry.by_id(FacebookProvider.id) \
.get_app(request)
access_token = form.cleaned_data['access_token']
info = requests.get(
'https://graph.facebook.com/oauth/access_token_info',
params={
'client_id': app.client_id,
'access_token': access_token
})
nonce = provider.get_nonce(request, pop=True)
if nonce and nonce == info.json().get('auth_nonce'):
token = SocialToken(app=app, token=access_token)
login = fb_complete_login(request, app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
ret = complete_social_login(request, login)
except requests.RequestException:
logger.exception('Error accessing FB user profile')
if not ret:
ret = render_authentication_error(request)
return ret
def login_by_token(request):
ret = None
auth_exception = None
if request.method == 'POST':
form = KakaoConnectForm(request.POST)
if form.is_valid():
try:
provider = providers.registry.by_id(KakaoProvider.id)
app = providers.registry.by_id(KakaoProvider.id).get_app(request)
access_token = form.cleaned_data['access_token']
token = SocialToken(app=app, token=access_token)
login = kakao_complete_login(request, app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
ret = complete_social_login(request, login)
except requests.RequestException as e:
logger.exception('Error accessing KAKAO user profile')
auth_exception = e
if not ret:
ret = render_authentication_error(request, KakaoProvider.id, exception+auth_exception)
return ret
def facebook_signup(self, request, access_token):
try:
app = SocialApp.objects.get(provider="facebook")
token = SocialToken(app=app, token=access_token)
fb_login = fb_complete_login(request, app, token)
fb_login.token = token
fb_login.state = SocialLogin.state_from_request(request)
ret = complete_social_login(request, fb_login)
response_data = {}
if request.user.is_authenticated():
if request.user.username == "":
request.user.username = request.data['email']
request.user.email = request.data['email']
request.user.first_name = request.data['fname']
request.user.last_name = request.data['lname']
request.user.save()
data = UserProfileSerializer(request.user).data
return data
else:
return {'error': "User with this email already exists."}
except Exception as e:
return {'error': str(e)}
def save(self, request):
user = self.validated_data['user']
if user:
return user
else:
app = SocialApp.objects.get(provider='facebook')
social_token = SocialToken(app=app,
token=self.validated_data['fcb_token'])
try:
# Check token against Facebook
original_request = request._request
login = fb_complete_login(original_request, app, social_token)
login.token = social_token
login.state = SocialLogin.state_from_request(original_request)
complete_social_login(original_request, login)
except HTTPError:
# 400 Client Error
raise exceptions.AuthenticationFailed(
_('Facebook authentication failed.'))
else:
self.cleaned_data = self.validated_data # Needed by save_user()
return get_socialaccount_adapter().save_user(
request, login, self)
def post(self, request):
data = JSONParser().parse(request)
access_token = data.get('access_token', '')
try:
app = SocialApp.objects.get(provider="facebook")
token = SocialToken(app=app, token=access_token)
# check token against facebook
login = fb_complete_login(app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
# add or update the user into users table
ret = complete_social_login(request, login)
# if we get here we've succeeded
return Response(status=200,
data={
'success': True,
'username': request.user.username,
'user_id': request.user.pk,
})
except:
return Response(status=401,
data={
'success': False,
'reason': "Bad Access Token",
})
def social(self, request, access_token):
app = SocialApp.objects.get(provider="facebook")
token = SocialToken(app=app, token=access_token)
login = fb_complete_login(request, app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
complete_social_login(request, login)
return (request, login.user)
def login_by_token(request):
ret = None
auth_exception = None
if request.method == "POST":
form = FacebookConnectForm(request.POST)
if form.is_valid():
try:
provider = providers.registry.by_id(FacebookProvider.id,
request)
login_options = provider.get_fb_login_options(request)
app = provider.get_app(request)
access_token = form.cleaned_data["access_token"]
expires_at = None
if login_options.get("auth_type") == "reauthenticate":
info = requests.get(
GRAPH_API_URL + "/oauth/access_token_info",
params={
"client_id": app.client_id,
"access_token": access_token,
},
).json()
nonce = provider.get_nonce(request, pop=True)
ok = nonce and nonce == info.get("auth_nonce")
else:
ok = True
if ok and provider.get_settings().get("EXCHANGE_TOKEN"):
resp = requests.get(
GRAPH_API_URL + "/oauth/access_token",
params={
"grant_type": "fb_exchange_token",
"client_id": app.client_id,
"client_secret": app.secret,
"fb_exchange_token": access_token,
},
).json()
access_token = resp["access_token"]
expires_in = resp.get("expires_in")
if expires_in:
expires_at = timezone.now() + timedelta(
seconds=int(expires_in))
if ok:
token = SocialToken(app=app,
token=access_token,
expires_at=expires_at)
login = fb_complete_login(request, app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
ret = complete_social_login(request, login)
except requests.RequestException as e:
logger.exception("Error accessing FB user profile")
auth_exception = e
if not ret:
ret = render_authentication_error(request,
FacebookProvider.id,
exception=auth_exception)
return ret
def _session_state(client, data):
rf = RequestFactory()
redirect_url = reverse('servicekonto_login_redirect')
request = rf.get(redirect_url, data)
session = client.session
state = SocialLogin.state_from_request(request)
verifier = 0
session['socialaccount_state'] = (state, verifier)
session.save()
def facebook_login(self, request, **kwargs):
"""Facebook sign up using django allauth tastypie."""
data = self.deserialize(
request,
request.body,
format=request.META.get('CONTENT_TYPE', 'application/json'))
if 'access_token' not in data:
raise CustomBadRequest(
code='missing_key',
message='Must provide {missing_key} when login with facebook.'.format(missing_key='access_token'))
# Assign the access_token
access_token = data.get('access_token', '')
# Import some modules necessary
# from allauth.socialaccount import providers
from allauth.socialaccount.models import (SocialLogin, SocialToken, SocialApp)
from allauth.socialaccount.providers.facebook.views import fb_complete_login
from allauth.socialaccount.helpers import complete_social_login, complete_social_signup
from allauth.socialaccount import providers
from allauth.socialaccount.providers.facebook.provider import FacebookProvider, GRAPH_API_URL
try:
app = SocialApp.objects.get(provider='facebook')
token = SocialToken(app=app, token=access_token)
provider = providers.registry.by_id(FacebookProvider.id)
print(provider.get_fields())
print(GRAPH_API_URL)
login = fb_complete_login(request, app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
ret = complete_social_signup(request, login)
print(ret)
# If we get here we've succeeded
return self.create_response(
request,
{
'success': True,
'user_id': request.user.pk,
'username': request.user.username,
})
except Exception as ex:
print(ex)
raise CustomBadRequest(
code="missing_key",
message="Can't login.")
def login_by_token(request):
ret = None
auth_exception = None
if request.method == 'POST':
form = FacebookConnectForm(request.POST)
if form.is_valid():
try:
provider = providers.registry.by_id(
FacebookProvider.id, request)
login_options = provider.get_fb_login_options(request)
app = provider.get_app(request)
access_token = form.cleaned_data['access_token']
expires_at = None
if login_options.get('auth_type') == 'reauthenticate':
info = requests.get(
GRAPH_API_URL + '/oauth/access_token_info',
params={'client_id': app.client_id,
'access_token': access_token}).json()
nonce = provider.get_nonce(request, pop=True)
ok = nonce and nonce == info.get('auth_nonce')
else:
ok = True
if ok and provider.get_settings().get('EXCHANGE_TOKEN'):
resp = requests.get(
GRAPH_API_URL + '/oauth/access_token',
params={'grant_type': 'fb_exchange_token',
'client_id': app.client_id,
'client_secret': app.secret,
'fb_exchange_token': access_token}).json()
access_token = resp['access_token']
expires_in = resp.get('expires_in')
if expires_in:
expires_at = timezone.now() + timedelta(
seconds=int(expires_in))
if ok:
token = SocialToken(app=app,
token=access_token,
expires_at=expires_at)
login = fb_complete_login(request, app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
ret = complete_social_login(request, login)
except requests.RequestException as e:
logger.exception('Error accessing FB user profile')
auth_exception = e
if not ret:
ret = render_authentication_error(request,
FacebookProvider.id,
exception=auth_exception)
return ret
def persona_login(request):
assertion = request.POST.get('assertion', '')
audience = request.build_absolute_uri('/')
resp = requests.post('https://verifier.login.persona.org/verify',
{'assertion': assertion,
'audience': audience})
if resp.json()['status'] != 'okay':
return render_authentication_error(request)
extra_data = resp.json()
login = providers.registry \
.by_id(PersonaProvider.id) \
.sociallogin_from_response(request, extra_data)
login.state = SocialLogin.state_from_request(request)
return complete_social_login(request, login)
def persona_login(request):
assertion = request.POST.get('assertion', '')
audience = request.build_absolute_uri('/')
resp = requests.post('https://verifier.login.persona.org/verify', {
'assertion': assertion,
'audience': audience
})
if resp.json()['status'] != 'okay':
return render_authentication_error(request)
extra_data = resp.json()
login = providers.registry \
.by_id(PersonaProvider.id) \
.sociallogin_from_response(request, extra_data)
login.state = SocialLogin.state_from_request(request)
return complete_social_login(request, login)
def login_by_token(request):
ret = None
auth_exception = None
if request.method == 'POST':
form = FacebookConnectForm(request.POST)
if form.is_valid():
try:
provider = providers.registry.by_id(FacebookProvider.id,
request)
login_options = provider.get_fb_login_options(request)
app = provider.get_app(request)
access_token = form.cleaned_data['access_token']
if login_options.get('auth_type') == 'reauthenticate':
info = requests.get(GRAPH_API_URL +
'/oauth/access_token_info',
params={
'client_id': app.client_id,
'access_token': access_token
}).json()
nonce = provider.get_nonce(request, pop=True)
ok = nonce and nonce == info.get('auth_nonce')
else:
ok = True
if ok and provider.get_settings().get('EXCHANGE_TOKEN'):
resp = requests.get(GRAPH_API_URL + '/oauth/access_token',
params={
'grant_type': 'fb_exchange_token',
'client_id': app.client_id,
'client_secret': app.secret,
'fb_exchange_token': access_token
}).json()
access_token = resp['access_token']
if ok:
token = SocialToken(app=app, token=access_token)
login = fb_complete_login(request, app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
ret = complete_social_login(request, login)
except requests.RequestException as e:
logger.exception('Error accessing FB user profile')
auth_exception = e
if not ret:
ret = render_authentication_error(request,
FacebookProvider.id,
exception=auth_exception)
return ret
def get(self, request, *args, **kwargs):
try:
original_request = request._request
auth_token = crypt.Cipher.decrypt(self.request.query_params.get('auth_token').replace(' ', '+').encode())
#request.GET.get('auth_token', '')
# Find the token matching the passed Auth token
app = SocialApp.objects.get(provider='vk')
vk_auth_token = SocialToken(app=app, token=auth_token)
#account = SocialToken.objects.get(token=vk_auth_token).account
# check token against facebook
adapter = VKOAuth2Adapter(request)
login = adapter.complete_login(original_request, app, vk_auth_token,
**{'response':{'user_id': None}})
#login = fb_complete_login(original_request, app, vk_auth_token)
login.token = vk_auth_token
login.state = SocialLogin.state_from_request(original_request)
# add or update the user into users table
complete_social_login(original_request, login)
# Create or fetch the session id for this user
token, _ = Token.objects.get_or_create(user=original_request.user)
# if we get here we've succeeded
social_account = SocialAccount.objects.filter(user=original_request.user)[0]
jenc = bytes(crypt.Cipher.pad(str(token.key).replace(' ', '+')), 'utf-8')
enc = crypt.Cipher.encrypt(jenc)
data = {
'username': original_request.user.username,
'objectId': original_request.user.pk,
'firstName': original_request.user.first_name,
'lastName': original_request.user.last_name,
'sessionToken': enc.decode(),
'avatar': str(social_account.extra_data['photo_big']).split('?')[0],
'email': original_request.user.email,
}
return Response(
status=200,
data=data
)
except:
return Response(status=401, data={
'detail': 'Bad Access Token',
})
def _wrapped_view(request, *args, **kwargs):
if request.user.is_authenticated():
return view_func(request, *args, **kwargs)
access_token = request.REQUEST.get('access_token', '')
try:
app = SocialApp.objects.get(provider='facebook')
token = SocialToken(app=app, token=access_token)
login = fb_complete_login(request, app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
complete_social_login(request, login)
return view_func(request, *args, **kwargs)
# TODO: what to except here?
except:
context = {'error': 'Unable to get or create facebook user.'}
return render_response(request, 'assassin/login.html', context)
def _wrapped_view(request, *args, **kwargs):
if request.user.is_authenticated():
return view_func(request, *args, **kwargs)
access_token = request.REQUEST.get('access_token', '')
try:
app = SocialApp.objects.get(provider='facebook')
token = SocialToken(app=app, token=access_token)
login = fb_complete_login(request, app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
complete_social_login(request, login)
return view_func(request, *args, **kwargs)
# TODO: what to except here?
except:
context = {'error': 'Unable to get or create facebook user.'}
return render_response(request, 'assassin/login.html', context)
def test_handle_facebook_without_email_cancel():
request = RequestFactory().get('/accounts/login/callback/')
request.user = AnonymousUser()
account = SocialAccount(provider='facebook')
sociallogin = SocialLogin(user=User(), account=account)
sociallogin.state = SocialLogin.state_from_request(request)
response = complete_social_login(request, sociallogin)
assert response.status_code == 302
assert response['location'].startswith(reverse('email_needed'))
sociallogin.state['auth_params'] = 'auth_type=rerequest'
response = complete_social_login(request, sociallogin)
assert response.status_code == 302
assert response['location'] == reverse('socialaccount_login_cancelled')
def persona_complete(request):
assertion = request.session.pop("sociallogin_assertion", "")
settings = app_settings.PROVIDERS.get(PersonaProvider.id, {})
audience = settings.get("AUDIENCE", None)
if audience is None:
raise ImproperlyConfigured(
"No Persona audience configured. Please "
"add an AUDIENCE item to the "
"SOCIALACCOUNT_PROVIDERS['persona'] setting."
)
resp = requests.post("https://verifier.login.persona.org/verify", {"assertion": assertion, "audience": audience})
if resp.json()["status"] != "okay":
return render_authentication_error(request)
extra_data = resp.json()
login = providers.registry.by_id(PersonaProvider.id).sociallogin_from_response(request, extra_data)
login.state = SocialLogin.state_from_request(request)
return complete_social_login(request, login)
def persona_complete(request):
assertion = request.session.pop('sociallogin_assertion', '')
provider_settings = app_settings.PROVIDERS.get(PersonaProvider.id, {})
audience = provider_settings.get('AUDIENCE', None)
if audience is None:
raise ImproperlyConfigured("No Persona audience configured. Please "
"add an AUDIENCE item to the "
"SOCIALACCOUNT_PROVIDERS['persona'] setting.")
resp = requests.post(settings.PERSONA_VERIFIER_URL,
{'assertion': assertion, 'audience': audience})
if resp.json()['status'] != 'okay':
return render_authentication_error(request)
extra_data = resp.json()
login = providers.registry \
.by_id(PersonaProvider.id) \
.sociallogin_from_response(request, extra_data)
login.state = SocialLogin.state_from_request(request)
return complete_social_login(request, login)
def login_by_token(request):
ret = None
auth_exception = None
if request.method == "POST":
form = FacebookConnectForm(request.POST)
if form.is_valid():
try:
provider = providers.registry.by_id(FacebookProvider.id)
login_options = provider.get_fb_login_options(request)
app = providers.registry.by_id(FacebookProvider.id).get_app(request)
access_token = form.cleaned_data["access_token"]
if login_options.get("auth_type") == "reauthenticate":
info = requests.get(
GRAPH_API_URL + "/oauth/access_token_info",
params={"client_id": app.client_id, "access_token": access_token},
).json()
nonce = provider.get_nonce(request, pop=True)
ok = nonce and nonce == info.get("auth_nonce")
else:
ok = True
if ok and provider.get_settings().get("EXCHANGE_TOKEN"):
resp = requests.get(
GRAPH_API_URL + "/oauth/access_token",
params={
"grant_type": "fb_exchange_token",
"client_id": app.client_id,
"client_secret": app.secret,
"fb_exchange_token": access_token,
},
).json()
access_token = resp["access_token"]
if ok:
token = SocialToken(app=app, token=access_token)
login = fb_complete_login(request, app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
ret = complete_social_login(request, login)
except requests.RequestException as e:
logger.exception("Error accessing FB user profile")
auth_exception = e
if not ret:
ret = render_authentication_error(request, FacebookProvider.id, exception=auth_exception)
return ret
def login_by_token(request):
ret = None
if request.method == 'POST':
form = FacebookConnectForm(request.POST)
if form.is_valid():
try:
app = providers.registry.by_id(FacebookProvider.id) \
.get_app(request)
access_token = form.cleaned_data['access_token']
token = SocialToken(app=app, token=access_token)
login = fb_complete_login(app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
ret = complete_social_login(request, login)
except requests.RequestException:
logger.exception('Error accessing FB user profile')
if not ret:
ret = render_authentication_error(request)
return ret
def login_by_token(request, access_token):
ret = None
if request.method == 'POST':
try:
app = providers.registry.by_id(FacebookProvider.id) \
.get_app(request)
access_token = access_token
token = SocialToken(app=app,
token=access_token)
login = fb_complete_login(app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
ret = complete_social_login(request, login)
except:
# FIXME: Catch only what is needed
pass
if not ret:
ret = render_authentication_error(request)
return ret
def get(self, request, *args, **kwargs):
request.encoding = "utf-8"
try:
original_request = request._request
auth_token = request.GET.get('auth_token', '')
# Find the token matching the passed Auth token
app = SocialApp.objects.get(provider='facebook')
fb_auth_token = SocialToken(app=app, token=auth_token)
# check token against facebook
login = fb_complete_login(original_request, app, fb_auth_token)
login.token = fb_auth_token
login.state = SocialLogin.state_from_request(original_request)
# add or update the user into users table
complete_social_login(original_request, login)
# Create or fetch the session id for this user
token, _ = Token.objects.get_or_create(user=original_request.user)
# if we get here we've succeeded
data = {
'username': original_request.user.username,
'objectId': original_request.user.pk,
'firstName': original_request.user.first_name,
'lastName': original_request.user.last_name,
'sessionToken': token.key,
'email': original_request.user.email,
}
print(data)
return Response(
status=200,
data=data
)
except:
traceback.print_exc(file=sys.stdout)
return Response(status=401, data={
'detail': 'Bad Access Token',
})
def login_by_token(request):
ret = None
if request.method == 'POST':
form = FacebookConnectForm(request.POST)
if form.is_valid():
try:
app = providers.registry.by_id(FacebookProvider.id) \
.get_app(request)
access_token = form.cleaned_data['access_token']
token = SocialToken(app=app,
token=access_token)
login = fb_complete_login(request, app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
ret = complete_social_login(request, login)
except requests.RequestException:
logger.exception('Error accessing FB user profile')
if not ret:
ret = render_authentication_error(request)
return ret
def wykop_login_by_token(request):
ret = None
if request.method == 'GET':
form = WykopConnectForm(request.GET)
if form.is_valid():
try:
app = providers.registry.by_id(WykopProvider.id).get_app(request)
connectData = form.cleaned_data['connectData']
connectData = ast.literal_eval(base64.b64decode(connectData))
token = SocialToken(app=app, token=connectData['token'])
login = wykop_complete_login(app, connectData)
login.token = token
login.state = SocialLogin.state_from_request(request)
ret = complete_social_login(request, login)
except AttributeError:
# FIXME: Catch only what is needed
pass
if not ret:
ret = render_authentication_error(request)
return ret
def login_by_token(request):
ret = None
if request.method == 'POST':
form = FacebookConnectForm(request.POST)
if form.is_valid():
try:
app = providers.registry.by_id(FacebookProvider.id) \
.get_app(request)
access_token = form.cleaned_data['access_token']
token = SocialToken(app=app,
token=access_token)
login = fb_complete_login(request, app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
ret = complete_social_login(request, login)
except requests.RequestException:
logger.exception('Error accessing FB user profile')
if not ret:
request.session['is_show_request_message'] = True
return HttpResponseRedirect(reverse('account_login') + "?action=social_login&result=error")
return ret
def persona_complete(request):
assertion = request.session.pop('sociallogin_assertion', '')
provider_settings = app_settings.PROVIDERS.get(PersonaProvider.id, {})
audience = provider_settings.get('AUDIENCE', None)
if audience is None:
raise ImproperlyConfigured(
"No Persona audience configured. Please "
"add an AUDIENCE item to the "
"SOCIALACCOUNT_PROVIDERS['persona'] setting.")
resp = requests.post(settings.PERSONA_VERIFIER_URL, {
'assertion': assertion,
'audience': audience
})
if resp.json()['status'] != 'okay':
return render_authentication_error(request)
extra_data = resp.json()
login = providers.registry \
.by_id(PersonaProvider.id) \
.sociallogin_from_response(request, extra_data)
login.state = SocialLogin.state_from_request(request)
return complete_social_login(request, login)
def login(self, request):
try:
original_request = request._request
token = request.POST.get(self.token_key, '')
google_auth_adapter = GoogleOAuth2Adapter(request=original_request)
app = SocialApp.objects.get(provider=self.provider)
social_auth_token = SocialToken(app=app, token=token)
login = google_auth_adapter.complete_login(request=original_request, app=app, token=social_auth_token) \
if self.provider is 'google' else fb_complete_login(request=request, app=app, token=social_auth_token)
extra_data = login.account.extra_data
json_error_response = None
if 'email' not in extra_data:
json_error_response = JsonResponse(
dict(message='email is not provided'), status=400)
if json_error_response is not None:
return json_error_response
user = User.objects.filter(email=extra_data['email']).first()
if user is not None:
token, is_created = Token.objects.get_or_create(user=user)
return JsonResponse(dict(key=token.key))
login.token = social_auth_token
login.state = SocialLogin.state_from_request(original_request)
complete_social_login(original_request, login)
token, is_created = Token.objects.get_or_create(
user=original_request.user)
return JsonResponse(dict(key=token.key))
except HTTPError as e:
return JsonResponse(dict(message=str(e)), status=400)
def login_by_token(request):
ret = None
if (request.method == 'POST'):
form = TwitterConnectForm(request.POST)
if form.is_valid():
try:
app = providers.registry.by_id(TwitterProvider.id).get_app(request)
oauth_token = form.cleaned_data['oauth_token']
oauth_token_secret = form.cleaned_data['oauth_token_secret']
token = SocialToken(app=app, token=oauth_token, token_secret=oauth_token_secret)
auth = OAuth1(app.client_id, app.secret, token.token, token.token_secret)
resp = requests.get(VERIFY_CREDENTIALS_URL, auth=auth)
resp.raise_for_status()
extra_data = resp.json()
login = twitter_complete_login(extra_data)
login.token = token
login.state = SocialLogin.state_from_request(request)
ret = complete_social_login(request, login)
except requests.RequestException:
logger.exception('Error accessing Twitter user profile')
if not ret:
ret = render_authentication_error(request)
return ret
def mobile_facebook_login(request):
response = HttpResponse() ## Create an HTTP Response Object
if request.method == "POST": # The method better be a POST
access_token = request.POST.get('access_token') # Get token
email = request.POST.get('email') # Get email
try:
app = SocialApp.objects.get(provider="facebook")
token = SocialToken(app=app, token=access_token)
# Check token against facebook
login = fb_complete_login(request, app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
# Add or update the user into users table
ret = complete_social_login(request, login)
# Try to get username from email
try:
user = User.objects.get(email=email) # Get User
# Login the user from Django's perspective
user.backend = 'django_tours.auth_backend.PasswordlessAuthBackend'
user = authenticate(email=user.email)
auth_login(request,user)
#request.session.cycle_key()
# If we get here we've failed
except:
response['Auth-Response'] = 'failure: %s'%(e)
response.status_code = 401 # Set status
return response
# If we get here we've succeeded
response['Auth-Response'] = 'success'
response['User-Is-Authenticated'] = '%s'%(request.user.is_authenticated())
response.status_code = 200 # Set status
return response
except Exception,e:
# If we get here we've failed
response['Auth-Response'] = 'failure: %s'%(e)
response.status_code = 401 # Set status
return response
def interoves_telegram_login(request):
# resp = requests.post('https://verifier.login.persona.org/verify',
# {'assertion': assertion,
# 'audience': audience})
settings = app_settings.PROVIDERS.get(InterovesTelegramProvider.id, {})
resp = requests.post(
'https://oauth.telegram.org/embed/interoves_bot', {
'origin': settings['domain'],
'size': settings['size'],
'request_access': settings['request_access'],
})
print(resp)
try:
resp.raise_for_status()
except (ValueError, requests.RequestException) as e:
return render_authentication_error(
request, provider_id=InterovesTelegramProvider.id, exception=e)
login = providers.registry \
.by_id(InterovesTelegramProvider.id, request) \
.sociallogin_from_response(request, {})
login.state = SocialLogin.state_from_request(request)
return complete_social_login(request, login)
def login_by_token(request):
ret = None
auth_exception = None
if request.method == 'POST':
form = FacebookConnectForm(request.POST)
if form.is_valid():
try:
provider = providers.registry.by_id(FacebookProvider.id)
login_options = provider.get_fb_login_options(request)
app = providers.registry.by_id(FacebookProvider.id) \
.get_app(request)
access_token = form.cleaned_data['access_token']
if login_options.get('auth_type') == 'reauthenticate':
info = requests.get(
GRAPH_API_URL + '/oauth/access_token_info',
params={'client_id': app.client_id,
'access_token': access_token}).json()
nonce = provider.get_nonce(request, pop=True)
ok = nonce and nonce == info.get('auth_nonce')
else:
ok = True
if ok:
token = SocialToken(app=app,
token=access_token)
login = fb_complete_login(request, app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
ret = complete_social_login(request, login)
except requests.RequestException as e:
logger.exception('Error accessing FB user profile')
auth_exception = e
if not ret:
ret = render_authentication_error(request,
FacebookProvider.id,
exception=auth_exception)
return ret
def mobile_facebook_login(request):
if request.method == "POST":
response = HttpResponse
access_token = str(request.POST['access_token'])
#email=str(request.POST['email'])
try:
app = SocialApp.objects.get(provider="facebook")
token = SocialToken(app=app, token=access_token)
# Check token against facebook
login = fb_complete_login(request, app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
# Add or update the user into users table
ret = complete_social_login(request, login)
a = SocialToken.objects.get(token=access_token)
try:
account = a.account
user = account.user
tuple = UserProfile.objects.get_or_create(
user=user,
dp=account.get_avatar_url(),
fullName=user.get_full_name())
if tuple[1] == True:
Token.objects.create(user=user)
UserProfile.objects.update(user=user, isNew=False)
else:
UserProfile.objects.update(user=user, isNew=False)
x = UserProfile.objects.filter(user=user).values('isNew')
return JsonResponse({'results': list(x)})
except User.DoesNotExist:
return HttpResponse("User Dosent Exist")
return HttpResponse("wuhoo")
except Exception as e:
# If we get here we've failed
return HttpResponse(str(e) + "")
def facebook_login(self, request, **kwargs):
self.method_check(request, allowed=['post'])
data = self.deserialize(request,
request.raw_post_data,
format=request.META.get(
'CONTENT_TYPE', 'application/json'))
access_token = data.get('access_token', '')
from allauth.socialaccount import providers
from allauth.socialaccount.models import SocialLogin, SocialToken, SocialApp
from allauth.socialaccount.providers.facebook.views import fb_complete_login
from allauth.socialaccount.helpers import complete_social_login
try:
app = SocialApp.objects.get(provider="facebook")
token = SocialToken(app=app, token=access_token)
login = fb_complete_login(app, token)
login.token = token
login.state = SocialLogin.state_from_request(request)
ret = complete_social_login(request, login)
#if we get here we've succeeded
return self.create_response(
request, {
'success': True,
'username': request.user.username,
'user_id': request.user.pk,
'api_key': request.user.api_key.key,
})
except:
# FIXME: Catch only what is needed
return self.create_response(request, {
'success': False,
'reason': "Bad Access Token",
}, HttpForbidden)
