def wrapper(request, backend, *args, **kwargs):
if redirect_name:
redirect = reverse(redirect_name, args=(backend,))
else:
redirect = request.path
backend = get_backend(backend, request, redirect)
if not backend:
return HttpResponseServerError("Incorrect authentication " + "service")
try:
return func(request, backend, *args, **kwargs)
except Exception, e: # some error ocurred
backend_name = backend.AUTH_BACKEND.name
logger.error(unicode(e), exc_info=True, extra=dict(request=request))
# Why!?
msg = str(e)
if "django.contrib.messages" in settings.INSTALLED_APPS:
from django.contrib.messages.api import error
error(request, msg, extra_tags=backend_name)
else:
logger.warn("Messages framework not in place, some " + "errors have not been shown to the user.")
return HttpResponseRedirect(BACKEND_ERROR_REDIRECT)
def wrapper(request, backend, *args, **kwargs):
if redirect_name:
redirect = reverse(redirect_name, args=(backend,))
else:
redirect = request.path
backend = get_backend(backend, request, redirect)
if not backend:
return HttpResponseServerError('Incorrect authentication ' + \
'service')
try:
return func(request, backend, *args, **kwargs)
except Exception, e: # some error ocurred
if setting('DEBUG'):
raise
backend_name = backend.AUTH_BACKEND.name
log('error', unicode(e), exc_info=True,
extra=dict(request=request))
if 'django.contrib.messages' in setting('INSTALLED_APPS'):
from django.contrib.messages.api import error
error(request, unicode(e), extra_tags=backend_name)
else:
log('warn', 'Messages framework not in place, some '+
'errors have not been shown to the user.')
url = setting('SOCIAL_AUTH_BACKEND_ERROR_URL', LOGIN_ERROR_URL)
return HttpResponseRedirect(url)
def wrapper(request, backend, *args, **kwargs):
if redirect_name:
redirect = reverse(redirect_name, args=(backend,))
else:
redirect = request.path
backend = get_backend(backend, request, redirect)
if not backend:
return HttpResponseServerError('Incorrect authentication ' + \
'service')
try:
return func(request, backend, *args, **kwargs)
except Exception, e: # some error ocurred
backend_name = backend.AUTH_BACKEND.name
msg = str(e)
if 'django.contrib.messages' in settings.INSTALLED_APPS:
from django.contrib.messages.api import error
error(request, msg, extra_tags=backend_name)
else:
if ERROR_KEY: # store error in session
request.session[ERROR_KEY] = msg
if NAME_KEY: # store the backend name for convenience
request.session[NAME_KEY] = backend_name
return HttpResponseRedirect(BACKEND_ERROR_REDIRECT)
def wrapper(request, backend, *args, **kwargs):
if redirect_name:
redirect = reverse(redirect_name, args=(backend,))
else:
redirect = request.path
backend = get_backend(backend, request, redirect)
if not backend:
return HttpResponseServerError('Incorrect authentication ' + \
'service')
RAISE_EXCEPTIONS = backend_setting(backend, 'SOCIAL_AUTH_RAISE_EXCEPTIONS', setting('DEBUG'))
try:
return func(request, backend, *args, **kwargs)
except Exception, e: # some error ocurred
if RAISE_EXCEPTIONS:
raise
log('error', unicode(e), exc_info=True, extra={
'request': request
})
mod, func_name = PROCESS_EXCEPTIONS.rsplit('.', 1)
try:
process = getattr(import_module(mod), func_name,
lambda *args: None)
except ImportError:
pass
else:
process(request, backend, e)
url = backend_setting(backend, 'SOCIAL_AUTH_BACKEND_ERROR_URL',
LOGIN_ERROR_URL)
return HttpResponseRedirect(url)
def wrapper(request, backend, *args, **kwargs):
if redirect_name:
redirect = reverse(redirect_name, args=(backend, ))
else:
redirect = request.path
backend = get_backend(backend, request, redirect)
if not backend:
return HttpResponseServerError('Incorrect authentication ' + \
'service')
try:
return func(request, backend, *args, **kwargs)
except Exception, e: # some error ocurred
if RAISE_EXCEPTIONS:
raise
log('error',
unicode(e),
exc_info=True,
extra={'request': request})
mod, func_name = PROCESS_EXCEPTIONS.rsplit('.', 1)
try:
process = getattr(import_module(mod), func_name,
lambda *args: None)
except ImportError:
pass
else:
process(request, backend, e)
url = backend_setting(backend, 'SOCIAL_AUTH_BACKEND_ERROR_URL',
LOGIN_ERROR_URL)
return HttpResponseRedirect(url)
def wrapper(request, backend, *args, **kwargs):
if redirect_name:
redirect = reverse(redirect_name, args=(backend,))
else:
redirect = request.path
backend = get_backend(backend, request, redirect)
if not backend:
return HttpResponseServerError(
"Incorrect authentication " + "service or service API settings not available!"
)
try:
return func(request, backend, *args, **kwargs)
except Exception, e: # some error ocurred
if RAISE_EXCEPTIONS:
raise
backend_name = backend.AUTH_BACKEND.name
log("error", unicode(e), exc_info=True, extra=dict(request=request))
if "django.contrib.messages" in setting("INSTALLED_APPS"):
from django.contrib.messages.api import error
error(request, unicode(e), extra_tags=backend_name)
else:
log("warn", "Messages framework not in place, some " + "errors have not been shown to the user.")
url = backend_setting(backend, "SOCIAL_AUTH_BACKEND_ERROR_URL", LOGIN_ERROR_URL)
return HttpResponseRedirect(url)
def wrapper(request, backend, *args, **kwargs):
if redirect_name:
redirect = reverse(redirect_name, args=(backend, ))
else:
redirect = request.path
backend = get_backend(backend, request, redirect)
if not backend:
return HttpResponseServerError('Incorrect authentication ' + \
'service')
try:
return func(request, backend, *args, **kwargs)
except Exception, e: # some error ocurred
backend_name = backend.AUTH_BACKEND.name
logger.error(unicode(e),
exc_info=True,
extra=dict(request=request))
if 'django.contrib.messages' in settings.INSTALLED_APPS:
from django.contrib.messages.api import error
error(request, unicode(e), extra_tags=backend_name)
else:
logger.warn('Messages framework not in place, some ' +
'errors have not been shown to the user.')
return HttpResponseRedirect(BACKEND_ERROR_REDIRECT)
def disconnect(request, backend):
"""Disconnects given backend from current logged in user."""
backend = get_backend(backend, request, request.path)
if not backend:
return HttpResponseServerError("Incorrect authentication service")
backend.disconnect(request.user)
url = request.REQUEST.get(REDIRECT_FIELD_NAME, "") or DEFAULT_REDIRECT
return HttpResponseRedirect(url)
def associate_complete(request, backend):
"""Authentication complete process"""
backend = get_backend(backend, request, request.path)
if not backend:
return HttpResponseServerError("Incorrect authentication service")
backend.auth_complete(user=request.user)
url = request.session.pop(REDIRECT_FIELD_NAME, "") or getattr(settings, "LOGIN_REDIRECT_URL", "")
return HttpResponseRedirect(url)
def associate_complete(request, backend):
"""Authentication complete process"""
backend = get_backend(backend, request, request.path)
if not backend:
return HttpResponseServerError('Incorrect authentication service')
backend.auth_complete(user=request.user)
url = request.session.pop(REDIRECT_FIELD_NAME, '') or DEFAULT_REDIRECT
return HttpResponseRedirect(url)
def disconnect(request, backend):
"""Disconnects given backend from current logged in user."""
backend = get_backend(backend, request, request.path)
if not backend:
return HttpResponseServerError('Incorrect authentication service')
backend.disconnect(request.user)
url = request.REQUEST.get(REDIRECT_FIELD_NAME, '') or DEFAULT_REDIRECT
return HttpResponseRedirect(url)
def disconnect(request, backend):
"""Disconnects given backend from current logged in user."""
backend = get_backend(backend, request, request.path)
if not backend:
return HttpResponseServerError('Incorrect authentication service')
backend.disconnect(request.user)
url = request.REQUEST.get(REDIRECT_FIELD_NAME, '') or \
getattr(settings, 'LOGIN_REDIRECT_URL', '')
return HttpResponseRedirect(url)
def wrapper(request, backend, *args, **kwargs):
if redirect_name:
redirect = reverse(redirect_name, args=(backend,))
else:
redirect = request.path
request.social_auth_backend = get_backend(backend, request, redirect)
if request.social_auth_backend is None:
raise WrongBackend(backend)
return func(request, request.social_auth_backend, *args, **kwargs)
def wrapper(request, backend, *args, **kwargs):
if redirect_name:
redirect = reverse(redirect_name, args=(backend,))
else:
redirect = request.path
backend = get_backend(backend, request, redirect)
if not backend:
return HttpResponseServerError("Incorrect authentication " + "service")
return func(request, backend, *args, **kwargs)
def wrapper(request, backend, *args, **kwargs):
if redirect_name:
redirect = reverse(redirect_name, args=(backend,))
else:
redirect = request.path
request.social_auth_backend = get_backend(backend, request,
redirect)
if request.social_auth_backend is None:
raise WrongBackend(backend)
return func(request, request.social_auth_backend, *args, **kwargs)
def disconnect(request, backend, association_id=None):
"""Disconnects given backend from current logged in user."""
backend = get_backend(backend, request, request.path)
if not backend:
return HttpResponseServerError('Incorrect authentication service')
backend.disconnect(request.user, association_id)
url = request.REQUEST.get(REDIRECT_FIELD_NAME, '') or \
DISCONNECT_REDIRECT_URL or \
DEFAULT_REDIRECT
return HttpResponseRedirect(url)
def obj_create(self, bundle, request=None, **kwargs):
bundle.obj = Obj()
bundle.obj.id = 1
backend = get_backend('linkedin', bundle.request, bundle.request.path)
backend.name = 'linkedin'
access_token_url = 'https://www.linkedin.com/uas/oauth2/accessToken'
names = getattr(settings, 'LINKEDIN_EXTRA_DATA')
extra = ','.join(dict(names).keys())
people_api_url = 'https://api.linkedin.com/v1/people/' \
'~:({})'.format(extra)
payload = dict(client_id=bundle.data['clientId'],
redirect_uri=bundle.data['redirectUri'],
client_secret=backend.consumer.secret,
code=bundle.data['code'],
grant_type='authorization_code')
# Step 1. Exchange authorization code for access token.
r = requests.post(access_token_url, data=payload)
response = json.loads(r.text)
params = dict(oauth2_access_token=response['access_token'],
format='json')
# Step 2. Retrieve information about the current user.
r = requests.get(people_api_url, params=params)
profile = json.loads(r.text)
data = {}
for key in profile.keys():
value = profile.get(key)
alias = self.convert(key)
data[alias] = value
uid = data.get('id')
social_user = UserSocialAuth.get_social_auth('linkedin', uid)
if social_user is None:
social_user = UserSocialAuth.create_social_auth(
bundle.request.user, uid, 'linkedin')
social_user.extra_data = data
social_user.save()
else:
raise ImmediateHttpResponse(
HttpForbidden("Linkedin already associated"))
extra_data = params
if extra_data and social_user.extra_data != extra_data:
if social_user.extra_data:
social_user.extra_data.update(extra_data)
else:
social_user.extra_data = extra_data
social_user.save()
return bundle
def auth_process(request, backend, complete_url_name, default_final_url):
"""Authenticate using social backend"""
redirect = reverse(complete_url_name, args=(backend,))
backend = get_backend(backend, request, redirect)
if not backend:
return HttpResponseServerError("Incorrect authentication service")
request.session[REDIRECT_FIELD_NAME] = request.GET.get(REDIRECT_FIELD_NAME, default_final_url)
if backend.uses_redirect:
return HttpResponseRedirect(backend.auth_url())
else:
return HttpResponse(backend.auth_html(), content_type="text/html;charset=UTF-8")
def complete(request, backend):
"""Authentication complete process"""
backend = get_backend(backend, request, request.path)
if not backend:
return HttpResponseServerError("Incorrect authentication service")
user = backend.auth_complete()
if user and getattr(user, "is_active", True):
login(request, user)
url = request.session.pop(REDIRECT_FIELD_NAME, "") or getattr(settings, "LOGIN_REDIRECT_URL", "")
else:
url = getattr(settings, "LOGIN_ERROR_URL", settings.LOGIN_URL)
return HttpResponseRedirect(url)
def complete_process(request, backend):
"""Authentication complete process"""
backend = get_backend(backend, request, request.path)
if not backend:
return HttpResponseServerError('Incorrect authentication service')
try:
user = backend.auth_complete(request=request)
except ValueError, e: # some Authentication error ocurred
user = None
error_key = getattr(settings, 'SOCIAL_AUTH_ERROR_KEY', None)
if error_key: # store error in session
request.session[error_key] = str(e)
def complete_process(request, backend):
"""Authentication complete process"""
backend = get_backend(backend, request, request.path)
if not backend:
return HttpResponseServerError("Incorrect authentication service")
try:
user = backend.auth_complete()
except ValueError, e: # some Authentication error ocurred
user = None
error_key = getattr(settings, "SOCIAL_AUTH_ERROR_KEY", None)
if error_key: # store error in session
request.session[error_key] = str(e)
def auth_process(request, backend, complete_url_name):
"""Authenticate using social backend"""
redirect = reverse(complete_url_name, args=(backend,))
backend = get_backend(backend, request, redirect)
if not backend:
return HttpResponseServerError("Incorrect authentication service")
data = request.REQUEST
# Check and sanitize a user-defined GET/POST redirect_to field value.
redirect = sanitize_redirect(request.get_host(), data.get(REDIRECT_FIELD_NAME))
request.session[REDIRECT_FIELD_NAME] = redirect or DEFAULT_REDIRECT
if backend.uses_redirect:
return HttpResponseRedirect(backend.auth_url())
else:
return HttpResponse(backend.auth_html(), content_type="text/html;charset=UTF-8")
def auth_complete(request, backend):
"""Complete auth process. Return authenticated user or None."""
backend = get_backend(backend, request, request.path)
if not backend:
return HttpResponseServerError('Incorrect authentication service')
user = request.user if request.user.is_authenticated() else None
try:
user = backend.auth_complete(user=user)
except ValueError, e: # some Authentication error ocurred
error_key = getattr(settings, 'SOCIAL_AUTH_ERROR_KEY', None)
if error_key: # store error in session
request.session[error_key] = str(e)
def auth_complete(request, backend):
"""Complete auth process. Return authenticated user or None."""
backend = get_backend(backend, request, request.path)
if not backend:
return HttpResponseServerError('Incorrect authentication service')
user = request.user if request.user.is_authenticated() else None
try:
user = backend.auth_complete(user=user)
except ValueError, e: # some Authentication error ocurred
error_key = getattr(settings, 'SOCIAL_AUTH_ERROR_KEY', None)
if error_key: # store error in session
request.session[error_key] = str(e)
def auth_process(request, backend, complete_url_name):
"""Authenticate using social backend"""
redirect = reverse(complete_url_name, args=(backend,))
backend = get_backend(backend, request, redirect)
if not backend:
return HttpResponseServerError('Incorrect authentication service')
# Check and sanitize a user-defined GET/POST redirect_to field value.
redirect = sanitize_redirect(request.get_host(),
request.REQUEST.get(REDIRECT_FIELD_NAME))
request.session[REDIRECT_FIELD_NAME] = redirect or DEFAULT_REDIRECT
if backend.uses_redirect:
return HttpResponseRedirect(backend.auth_url())
else:
return HttpResponse(backend.auth_html(),
content_type='text/html;charset=UTF-8')
def disconnect_identity(request, identity_id):
if request.method != "POST":
raise NotImplementedError
try:
auth = UserSocialAuth.objects.get(id=identity_id)
except UserSocialAuth.DoesNotExist:
return HttpResponseRedirect(
reverse("sentry-account-settings-identities"))
backend = get_backend(auth.provider, request, "/")
if backend is None:
raise Exception(u"Backend was not found for request: {}".format(
auth.provider))
# stop this from bubbling up errors to social-auth's middleware
# XXX(dcramer): IM SO MAD ABOUT THIS
try:
backend.disconnect(request.user, identity_id)
except Exception as exc:
import sys
exc_tb = sys.exc_info()[2]
six.reraise(Exception, exc, exc_tb)
del exc_tb
# XXX(dcramer): we experienced an issue where the identity still existed,
# and given that this is a cheap query, lets error hard in that case
assert not UserSocialAuth.objects.filter(user=request.user,
id=identity_id).exists()
backend_name = backend.AUTH_BACKEND.name
messages.add_message(
request,
messages.SUCCESS,
u"Your {} identity has been disconnected.".format(
settings.AUTH_PROVIDER_LABELS.get(backend_name, backend_name)),
)
logger.info(
"user.identity.disconnect",
extra={
"user_id": request.user.id,
"ip_address": request.META["REMOTE_ADDR"],
"usersocialauth_id": identity_id,
},
)
return HttpResponseRedirect(reverse("sentry-account-settings-identities"))
def delete(self, request, user, identity_id):
"""
Disconnect a Identity from Account
```````````````````````````````````````````````````````
Disconnects a social auth identity from a sentry account
:pparam string identity_id: identity id
:auth: required
"""
try:
auth = UserSocialAuth.objects.get(id=identity_id)
except UserSocialAuth.DoesNotExist:
return Response(status=404)
backend = get_backend(auth.provider, request, '/')
if backend is None:
raise Exception(u'Backend was not found for request: {}'.format(auth.provider))
# stop this from bubbling up errors to social-auth's middleware
# XXX(dcramer): IM SO MAD ABOUT THIS
try:
backend.disconnect(user, identity_id)
except Exception as exc:
import sys
exc_tb = sys.exc_info()[2]
six.reraise(Exception, exc, exc_tb)
del exc_tb
# XXX(dcramer): we experienced an issue where the identity still existed,
# and given that this is a cheap query, lets error hard in that case
assert not UserSocialAuth.objects.filter(
user=user,
id=identity_id,
).exists()
logger.info(
'user.identity.disconnect',
extra={
'user_id': user.id,
'ip_address': request.META['REMOTE_ADDR'],
'usersocialauth_id': identity_id,
}
)
return Response(status=204)
def delete(self, request, user, identity_id):
"""
Disconnect a Identity from Account
```````````````````````````````````````````````````````
Disconnects a social auth identity from a sentry account
:pparam string identity_id: identity id
:auth: required
"""
try:
auth = UserSocialAuth.objects.get(id=identity_id)
except UserSocialAuth.DoesNotExist:
return Response(status=404)
backend = get_backend(auth.provider, request, "/")
if backend is None:
raise Exception("Backend was not found for request: {}".format(
auth.provider))
# stop this from bubbling up errors to social-auth's middleware
# XXX(dcramer): IM SO MAD ABOUT THIS
try:
backend.disconnect(user, identity_id)
except Exception as exc:
import sys
exc_tb = sys.exc_info()[2]
six.reraise(Exception, exc, exc_tb)
del exc_tb
# XXX(dcramer): we experienced an issue where the identity still existed,
# and given that this is a cheap query, lets error hard in that case
assert not UserSocialAuth.objects.filter(user=user,
id=identity_id).exists()
logger.info(
"user.identity.disconnect",
extra={
"user_id": user.id,
"ip_address": request.META["REMOTE_ADDR"],
"usersocialauth_id": identity_id,
},
)
return Response(status=204)
def disconnect_identity(request, identity_id):
if request.method != 'POST':
raise NotImplementedError
try:
auth = UserSocialAuth.objects.get(id=identity_id)
except UserSocialAuth.DoesNotExist:
return HttpResponseRedirect(reverse('sentry-account-settings-identities'))
backend = get_backend(auth.provider, request, '/')
if backend is None:
raise Exception('Backend was not found for request: {}'.format(auth.provider))
# stop this from bubbling up errors to social-auth's middleware
# XXX(dcramer): IM SO MAD ABOUT THIS
try:
backend.disconnect(request.user, identity_id)
except Exception as exc:
import sys
exc_tb = sys.exc_info()[2]
six.reraise(Exception, exc, exc_tb)
del exc_tb
# XXX(dcramer): we experienced an issue where the identity still existed,
# and given that this is a cheap query, lets error hard in that case
assert not UserSocialAuth.objects.filter(
user=request.user,
id=identity_id,
).exists()
backend_name = backend.AUTH_BACKEND.name
messages.add_message(
request, messages.SUCCESS, 'Your {} identity has been disconnected.'.format(
settings.AUTH_PROVIDER_LABELS.get(backend_name, backend_name),
)
)
logger.info(
'user.identity.disconnect',
extra={
'user_id': request.user.id,
'ip_address': request.META['REMOTE_ADDR'],
'usersocialauth_id': identity_id,
}
)
return HttpResponseRedirect(reverse('sentry-account-settings-identities'))
def socialauth_complete(request, backend):
"""
Authentication complete process -- override from the
default in django-social-auth to:
-- collect phone numbers on registration
-- integrate with django-registration in order
to confirm email for new users
"""
backend = get_backend(backend, request, request.path)
if not backend:
return HttpResponseServerError('Incorrect authentication service')
try:
user = backend.auth_complete()
except ValueError, e: # some Authentication error ocurred
user = None
error_key = getattr(settings, 'SOCIAL_AUTH_ERROR_KEY', 'error_msg')
if error_key: # store error in session
request.session[error_key] = str(e)
def new_user_social_auth(request, backend, username, email=None, template="registration/association.html",
form_class_login=AuthenticationForm, form_class_register=RegistrationForm, *args, **kwargs):
"""Complete auth process. Return authenticated user or None."""
new_data = {}
if request.user and request.user.is_authenticated():
new_data['user'] = request.user
if 'register' in request.POST:
form_register = form_class_register(request.POST)
form_login = form_class_login(request)
if form_register.is_valid():
new_data['username'] = form_register.cleaned_data['username']
new_data['user'] = UserSocialAuth.create_user(form_register.cleaned_data['username'],
form_register.cleaned_data['email'],
form_register.cleaned_data['password1'])
else:
initial_data = { 'username': username }
if email:
initial_data.update({ 'email': email })
form_register = form_class_register(initial=initial_data)
form_login = form_class_login(request, request.POST or None)
if form_login.is_valid():
new_data['user'] = form_login.get_user()
if new_data:
if request.session.get(PIPELINE_KEY):
data = request.session.pop(PIPELINE_KEY)
backend = get_backend(backend, request, '/')
idx, xargs, xkwargs = backend.from_session_dict(data, *args, **kwargs)
xkwargs.update(new_data)
data = backend.to_session_dict(idx, *xargs, **xkwargs)
request.session[PIPELINE_KEY] = data
return complete_process(request, backend, *args, **kwargs)
context = {
'form_register': form_register,
'form_login': form_login,
'backend': backend,
}
return TemplateResponse(request, template, context)
def do_twitter_registration(data):
uid = data["twitter"]["id"]
backend = get_backend("twitter")
social_user = UserSocialAuth.get_social_auth(backend.name, uid)
if social_user:
social_user.extra_data = data["twitter"]
social_user.save()
else:
user = UserSocialAuth.create_user(username=get_username(), email="")
Profile.objects.create(user=user)
social_user = UserSocialAuth.objects.create(user=user, provider="twitter", uid=uid, extra_data=data["twitter"])
dd_user_id = social_user.user.id
twitter_service = SocialServiceLocator.get_instane().build_service_by_name("twitter")
twitter_service.pull_user_info(dd_user_id, {"access_token": data["twitter"]["access_token"], "twitter_id": uid})
return dd_user_id
def auth_process(request, backend, complete_url_name):
"""Authenticate using social backend"""
redirect = reverse(complete_url_name, args=(backend,))
backend = get_backend(backend, request, redirect)
if not backend:
return HttpResponseServerError('Incorrect authentication service')
# Save any defined redirect_to value into session
if REDIRECT_FIELD_NAME in request.REQUEST:
data = request.POST if request.method == 'POST' else request.GET
if REDIRECT_FIELD_NAME in data:
# Check and sanitize a user-defined GET/POST redirect_to field value.
redirect = sanitize_redirect(request.get_host(),
data[REDIRECT_FIELD_NAME])
request.session[REDIRECT_FIELD_NAME] = redirect or DEFAULT_REDIRECT
if backend.uses_redirect:
return HttpResponseRedirect(backend.auth_url())
else:
return HttpResponse(backend.auth_html(),
content_type='text/html;charset=UTF-8')
def disconnect_identity(request, identity_id):
if request.method != 'POST':
raise NotImplementedError
try:
auth = UserSocialAuth.objects.get(id=identity_id)
except UserSocialAuth.DoesNotExist:
return HttpResponseRedirect(
reverse('sentry-account-settings-identities'))
backend = get_backend(auth.provider, request, '/')
if backend is None:
raise Exception('Backend was not found for request: {}'.format(
auth.provider))
# stop this from bubbling up errors to social-auth's middleware
# XXX(dcramer): IM SO MAD ABOUT THIS
try:
backend.disconnect(request.user, identity_id)
except Exception as exc:
import sys
exc_tb = sys.exc_info()[2]
six.reraise(Exception, exc, exc_tb)
del exc_tb
# XXX(dcramer): we experienced an issue where the identity still existed,
# and given that this is a cheap query, lets error hard in that case
assert not UserSocialAuth.objects.filter(
user=request.user,
id=identity_id,
).exists()
backend_name = backend.AUTH_BACKEND.name
messages.add_message(
request, messages.SUCCESS,
'Your {} association has been revoked.'.format(
settings.AUTH_PROVIDER_LABELS.get(backend_name, backend_name), ))
return HttpResponseRedirect(reverse('sentry-account-settings-identities'))
def auth_process(request, backend, complete_url_name):
"""Authenticate using social backend"""
redirect = reverse(complete_url_name, args=(backend,))
backend = get_backend(backend, request, redirect)
if not backend:
return HttpResponseServerError('Incorrect authentication service')
data = request.REQUEST
# Check and sanitize a user-defined GET/POST redirect_to field value.
redirect = sanitize_redirect(request.get_host(), data.get(REDIRECT_FIELD_NAME))
try:
request.session[REDIRECT_FIELD_NAME] = redirect or DEFAULT_REDIRECT
if backend.uses_redirect:
return HttpResponseRedirect(backend.auth_url())
else:
return HttpResponse(backend.auth_html(),
content_type='text/html;charset=UTF-8')
except ValueError, e:
error_key = getattr(settings, 'SOCIAL_AUTH_ERROR_KEY', None)
if error_key: # store error in session
request.session[error_key] = str(e)
url = getattr(settings, 'LOGIN_ERROR_URL', settings.LOGIN_URL)
return HttpResponseRedirect(url)
def wrapper(request, backend, *args, **kwargs):
if redirect_name:
redirect = reverse(redirect_name, args=(backend,))
else:
redirect = request.path
backend = get_backend(backend, request, redirect)
if not backend:
return HttpResponseServerError('Incorrect authentication ' + \
'service')
try:
return func(request, backend, *args, **kwargs)
except Exception, e: # some error ocurred
backend_name = backend.AUTH_BACKEND.name
logger.error(unicode(e), exc_info=True,
extra=dict(request=request))
# Why!?
msg = str(e)
if 'django.contrib.messages' in settings.INSTALLED_APPS:
from django.contrib.messages.api import error
error(request, msg, extra_tags=backend_name)
else:
logger.warn('Messages framework not in place, some '+
'errors have not been shown to the user.')
# What's the use in this, having not both the messages
# framework and decent logging in place?
# Also: do we really want to share all and any errors back
# to the user, in a security-wise sensitive application?
#
# else:
# if ERROR_KEY: # store error in session
# request.session[ERROR_KEY] = msg
# if NAME_KEY: # store the backend name for convenience
# request.session[NAME_KEY] = backend_name
return HttpResponseRedirect(BACKEND_ERROR_REDIRECT)
def auth_process(request, backend, complete_url_name):
"""Authenticate using social backend"""
redirect = reverse(complete_url_name, args=(backend,))
backend = get_backend(backend, request, redirect)
if not backend:
return HttpResponseServerError('Incorrect authentication service')
# Check and sanitize a user-defined GET/POST redirect_to field value.
redirect = sanitize_redirect(request.get_host(),
request.REQUEST.get(REDIRECT_FIELD_NAME))
request.session[REDIRECT_FIELD_NAME] = redirect
# Store query parameters (if any). These will be tacked on to the end of
# the login redirect url in complete_process().
all_params = dict(parse_qsl(request.META['QUERY_STRING']))
params = [(k, v) for k, v in all_params.items() if not k == REDIRECT_FIELD_NAME]
request.session[REDIRECT_QUERY_STRING] = urlencode(params)
if backend.uses_redirect:
return HttpResponseRedirect(backend.auth_url())
else:
return HttpResponse(backend.auth_html(),
content_type='text/html;charset=UTF-8')
return {
'action':
'login_or_register',
'result':
'failed',
'value':
'integrity_error',
'msg':
translation.ugettext(
'Erabiltzaile izen hau lehendik ere existitzen da. Mesedez, erabili beste izen bat.'
)
}
access_token = ast.literal_eval(access_token)
try:
backend = get_backend(SOCIAL_ORIGIN[origin], request,
request.path)
user = backend.do_auth(access_token['access_token'])
except Exception as e:
logger.error("ERROR: " + str(e))
return {
'action':
'login_or_register',
'result':
'failed',
'value':
'auth_error',
'msg':
translation.ugettext(
'Sare sozialetako autentikazioak huts egin du: ') +
str(e)
}
def obj_create(self, bundle, request=None, **kwargs):
bundle.obj = Obj()
bundle.obj.id = 1
oauth_token = bundle.data.get('oauth_token')
oauth_verifier = bundle.data.get('oauth_verifier', '')
backend = get_backend('twitter', bundle.request, bundle.request.path)
backend.name = 'twitter'
REQUEST_TOKEN_URL = 'https://api.twitter.com/oauth/request_token'
ACCESS_TOKEN_URL = 'https://api.twitter.com/oauth/access_token'
consumer_key = backend.consumer.key
consumer_secret = backend.consumer.secret
if oauth_token and oauth_verifier:
oauth_client = OAuth1Session(
consumer_key,
client_secret=consumer_secret,
resource_owner_key=oauth_token,
verifier=oauth_verifier
)
response = oauth_client.fetch_access_token(ACCESS_TOKEN_URL)
uid = response.get('user_id')
social_user = UserSocialAuth.get_social_auth('twitter', uid)
if social_user is None:
social_user = UserSocialAuth.create_social_auth(
bundle.request.user, uid, 'twitter')
social_user.extra_data = response
social_user.save()
load_twitter_user_friends(social_user)
else:
raise ImmediateHttpResponse(
HttpForbidden("Twitter already associated")
)
try:
url = 'https://api.twitter.com/1.1/account/' \
'verify_credentials.json'
consumer = oauth.Consumer(key=consumer_key,
secret=consumer_secret)
token = oauth.Token(key=response['oauth_token'],
secret=response['oauth_token_secret'])
client = oauth.Client(consumer, token)
resp, content = client.request(url)
extra_data = json.loads(content)
except Exception as err:
extra_data = None
logger.error(err, err.message)
if extra_data and social_user.extra_data != extra_data:
if social_user.extra_data:
social_user.extra_data.update(extra_data)
else:
social_user.extra_data = extra_data
social_user.save()
else:
oauth_client = OAuth1Session(
consumer_key,
client_secret=consumer_secret,
)
bundle.data['oauth_token'] = oauth_client.fetch_request_token(
REQUEST_TOKEN_URL
).get('oauth_token')
return bundle
if not User.objects.filter(username=username).exists():
try:
user = User()
user.username = username
user.is_active = True
user.save()
usa, created = UserSocialAuth.objects.get_or_create(user=user, provider = SOCIAL_ORIGIN[origin], uid=int(social_id))
usa.extra_data = access_token
usa.save()
except IntegrityError, e:
logger.error("ERROR:"+str(e))
return {'action': 'login_or_register', 'result': 'failed', 'value': 'integrity_error', 'msg': translation.ugettext('Erabiltzaile izen hau lehendik ere existitzen da. Mesedez, erabili beste izen bat.')}
access_token = ast.literal_eval(access_token)
try:
backend = get_backend(SOCIAL_ORIGIN[origin], request, request.path)
user = backend.do_auth(access_token['access_token'])
except Exception as e:
logger.error("ERROR: "+str(e))
return {'action': 'login_or_register', 'result': 'failed', 'value': 'auth_error', 'msg': translation.ugettext('Sare sozialetako autentikazioak huts egin du: ')+str(e)}
if user and user.is_active:
login(request, user)
token = default_token_generator.make_token(user)
# Redirect to a success page.
return {'action': 'login_or_register', 'result': 'success', 'value': token, 'username': user.username}
else:
# Return a 'disabled account' error message
logger.error("ERROR: User is not active!")
return {'action': 'login_or_register', 'result': 'failed', 'value': 'user_not_active', 'msg': translation.ugettext('Erabiltzailea ez dago aktibatuta. Mesedez, begiratu zure epostara bidali dugun mezua eta jarraitu aktibazio pausoak.')}
else:
logger.error("ERROR: Wrong origin!")
