def _add_association(self, request, access_token):
"""
Adds an association for `access_token` to `request.user`.
Returns an HttpResponse.
"""
success_url = get_success_url(request=request)
if success_url is None:
success_url = login_redirect_url()
try:
self._associate(request, access_token)
except UserAlreadyLinked:
return HttpResponseRedirect(
update_qs(success_url, {
'error': 'user_already_linked',
'user': request.user.username
}))
except TwitterAlreadyLinked:
userinfo = cached_user_info(request, access_token)
return HttpResponseRedirect(
update_qs(
success_url, {
'error': 'twitter_already_linked',
'user': userinfo.screen_name
}))
return HttpResponseRedirect(success_url)
def _add_association(self, request, access_token):
"""
Adds an association for `access_token` to `request.user`.
Returns an HttpResponse.
"""
success_url = get_success_url(request=request)
if success_url is None:
success_url = login_redirect_url()
try:
self._associate(request, access_token)
except UserAlreadyLinked:
return HttpResponseRedirect(
update_qs(success_url,
{'error': 'user_already_linked',
'user': request.user.username})
)
except TwitterAlreadyLinked:
userinfo = cached_user_info(request, access_token)
return HttpResponseRedirect(
update_qs(success_url,
{'error': 'twitter_already_linked',
'user': userinfo.screen_name})
)
return HttpResponseRedirect(success_url)
def _associate(self, request, access_token):
"""Returns the TwitterUser just associated with `request.user`."""
twitter_user = TwitterUser.objects.create_twitter_user(
user=request.user,
access_token=access_token,
userinfo=cached_user_info(request, access_token))
twitter_user_associated.send(sender=self.__class__,
twitter_user=twitter_user)
return twitter_user
def _associate(self, request, access_token):
"""Returns the TwitterUser just associated with `request.user`."""
twitter_user = TwitterUser.objects.create_twitter_user(
user=request.user,
access_token=access_token,
userinfo=cached_user_info(request, access_token)
)
twitter_user_associated.send(sender=self.__class__,
twitter_user=twitter_user)
return twitter_user
class OAuthTwitter(object):
"""Views for django-oauth-twitter."""
def __init__(self,
auto_create_user=False,
registration_form=RegistrationForm,
association_url=None,
registration_url=None):
"""
If `auto_create_user` is True, attempt to create a user automatically
without signing up.
`registration_form` is the form to use to create a new user.
If `association_url` is a reverse()able string or view function,
redirect to that view when associating a TwitterUser to a User.
If `registration_url` is a reverse()able string or view function,
redirect to that view in order to let a user register for a new
User account.
"""
self.auto_create_user = auto_create_user
self._association_url_default = association_url is None
if self._association_url_default:
self.association_url = LazyReverse(self.associate)
else:
self.association_url = LazyReverse(association_url)
if registration_url is None:
self.registration_url = LazyReverse(self.register)
else:
self.registration_url = LazyReverse(registration_url)
self.RegistrationForm = registration_form
def get_urls(self):
"""
Returns urlpatterns for urls.py.
Include it like so::
oauthtwitter = OAuthTwitter()
urlpatterns += patterns('',
url(r'^twitter/', include(oauthtwitter.urls)),
)
"""
urlpatterns = patterns(
'',
url(r'^callback/', self.callback, name='twitter_callback'),
url(r'^signin/', self.signin, name='twitter_signin'),
)
if self._association_url_default:
# Add ^associate/ location if we're meant to handle association.
urlpatterns += patterns(
'',
url(r'^associate/signin/',
self.signin,
kwargs={'success_url': 'twitter_associate'},
name='twitter_signin_associate'),
url(r'^associate/', self.associate, name='twitter_associate'),
)
if self.registration_url.location == self.register:
# Add ^register/ location if we're meant to handle registration.
urlpatterns += patterns(
'',
url(r'^register/',
self.registration_url.location,
name='twitter_register'))
return urlpatterns
urls = property(get_urls)
@login_required_m
def associate(self,
request,
template="django_oauth_twitter/associate.html",
dictionary=None):
"""
View to manage the association between a User and Twitter.
`template` is the template to render for this webpage.
If `dictionary` is provided, it provides extra context for
rendering `template`.
"""
if not request.user.is_authenticated():
return self._redirect_to_login(request)
if request.method == 'POST':
if request.POST.get('action') == 'remove':
twitter_id = request.POST.get('twitter_id')
response = self._remove_association(request, twitter_id)
if response:
return response
self._check_for_revocation(request)
if dictionary is None:
dictionary = {}
dictionary.update({
'error': request.GET.get('error'),
'error_user': request.GET.get('user')
})
return render_to_response(template,
dictionary=dictionary,
context_instance=RequestContext(request))
def callback(self, request):
"""
View that gets the oauth_token from Twitter and signs in a User.
Note: You must set this callback URL in Twitter's Application
Details page. Twitter ignores OAuth's oauth_callback option.
"""
# Ensure that the user came in through signin().
request_token = request.twitter_request_token
if request_token is None:
return self._redirect_to_login(request=request)
# Ensure that the session's token matches Twitter's token.
if request_token.key != request.GET.get('oauth_token'):
remove_tokens(request)
return self._redirect_to_login(request=request)
# Save the access token in the session.
api = TwitterApi(request_token)
try:
access_token = fail_whale(api.getAccessToken)()
except HTTPError, e:
if e.code == 401:
# Restart the authentication process, as Twitter thinks
# we're unauthorized.
return HttpResponseRedirect(reverse('twitter_signin'))
raise
set_access_token(request, access_token)
# Funnel the user into the site.
userinfo = cached_user_info(request, access_token)
if request.user.is_anonymous():
# Find the User by the access token.
user = self._authenticate(userinfo=userinfo)
if user is None:
# New user
return self._on_new_user(request=request)
return self._login_and_redirect(request=request, user=user)
return self._add_association(request, access_token)
