def _register_user(request, facebook, profile_callback=None,
remove_old_connections=False):
'''
Creates a new user and authenticates
The registration form handles the registration and validation
Other data on the user profile is updates afterwards
if remove_old_connections = True we will disconnect old
profiles from their facebook flow
'''
if not facebook.is_authenticated():
raise ValueError(
'Facebook needs to be authenticated for connect flows')
# get the backend on new registration systems, or none
# if we are on an older version
backend = get_registration_backend()
logger.info('running backend %s for registration', backend)
# gets the form class specified in FACEBOOK_REGISTRATION_FORM
form_class = get_form_class(backend, request)
facebook_data = facebook.facebook_registration_data()
data = request.POST.copy()
for k, v in facebook_data.items():
if not data.get(k):
data[k] = v
if remove_old_connections:
_remove_old_connections(facebook_data['facebook_id'])
if request.REQUEST.get('force_registration_hard'):
data['email'] = data['email'].replace(
'@', '+test%s@' % randint(0, 1000000000))
form = form_class(data=data, files=request.FILES,
initial={'ip': request.META['REMOTE_ADDR']})
if not form.is_valid():
# show errors in sentry
form_errors = form.errors
error = facebook_exceptions.IncompleteProfileError(
'Facebook signup incomplete')
error.form = form
raise error
try:
# for new registration systems use the backends methods of saving
new_user = None
if backend:
new_user = backend.register(request,
form=form, **form.cleaned_data)
# fall back to the form approach
if new_user is None:
raise ValueError(
'new_user is None, note that backward compatability for the older versions of django registration has been dropped.')
except IntegrityError, e:
# this happens when users click multiple times, the first request registers
# the second one raises an error
raise facebook_exceptions.AlreadyRegistered(e)
def _register_user(request, facebook, profile_callback=None):
'''
Creates a new user and authenticates
The registration form handles the registration and validation
Other data on the user profile is updates afterwards
'''
if not facebook.is_authenticated():
raise ValueError(
'Facebook needs to be authenticated for connect flows')
#get the backend on new registration systems, or none if we are on an older version
backend = get_registration_backend()
#gets the form class specified in FACEBOOK_REGISTRATION_FORM
form_class = get_form_class(backend, request)
facebook_data = facebook.facebook_registration_data()
data = request.POST.copy()
for k, v in facebook_data.items():
if not data.get(k):
data[k] = v
if request.REQUEST.get('force_registration_hard'):
data['email'] = data['email'].replace('@', '+%s@' % randint(0, 100000))
form = form_class(data=data,
files=request.FILES,
initial={'ip': request.META['REMOTE_ADDR']})
if not form.is_valid():
error = facebook_exceptions.IncompleteProfileError(
'Facebook data %s '
'gave error %s' % (facebook_data, form.errors))
error.form = form
raise error
#for new registration systems use the backends methods of saving
if backend:
new_user = backend.register(request, **form.cleaned_data)
else:
# For backward compatibility, if django-registration form is used
try:
new_user = form.save(profile_callback=profile_callback)
except TypeError:
new_user = form.save()
signals.facebook_user_registered.send(sender=get_profile_class(),
user=new_user,
facebook_data=facebook_data)
#update some extra data not yet done by the form
new_user = _update_user(new_user, facebook)
# IS this the correct way for django 1.3? seems to require the backend
# attribute for some reason
new_user.backend = 'django_facebook.auth_backends.FacebookBackend'
auth.login(request, new_user)
return new_user
def _register_user(self, facebook, profile_callback=None):
'''
Creates a new user and authenticates
The registration form handles the registration and validation
Other data on the user profile is updates afterwards
'''
if not facebook.is_authenticated():
raise ValueError, 'Facebook needs to be authenticated for connect flows'
facebook_user_converter = FacebookUserConverter(facebook)
from registration.forms import RegistrationFormUniqueEmail
#get the backend on new registration systems, or none if we are on an older version
backend = get_registration_backend()
#get the form used for registration and fall back to uniqueemail version
form_class = RegistrationFormUniqueEmail
if backend:
form_class = backend.get_form_class(request)
facebook_data = facebook_user_converter.facebook_registration_data()
data = self.request.POST.copy()
for k, v in facebook_data.items():
if not data.get(k):
data[k] = v
if self.request.REQUEST.get('force_registration_hard'):
data['email'] = data['email'].replace('@',
'+%s@' % randint(0, 100000))
form = form_class(data=data,
files=self.request.FILES,
initial={'ip': self.request.META['REMOTE_ADDR']})
if not form.is_valid():
error = facebook_exceptions.IncompleteProfileError(
'Facebook data %s gave error %s' %
(facebook_data, form.errors))
error.form = form
raise error
#for new registration systems use the backends methods of saving
if backend:
new_user = backend.register(request, **form.cleaned_data)
else:
new_user = form.save(profile_callback=profile_callback)
#update some extra data not yet done by the form
new_user = self._update_user(new_user, facebook)
#IS this the correct way for django 1.3? seems to require the backend attribute for some reason
new_user.backend = 'django_facebook.auth_backends.FacebookBackend'
auth.login(self.request, new_user)
return new_user
def _register_user(request, facebook, profile_callback=None):
if not facebook.is_authenticated():
raise ValueError, 'Facebook needs to be authenticated for connect flows'
from registration.forms import RegistrationFormUniqueEmail
import registration
new_reg_module = hasattr(registration, 'backends')
if new_reg_module:
from registration.backends import get_backend
form_class = RegistrationFormUniqueEmail
facebook_data = facebook.facebook_registration_data()
data = request.POST.copy()
for k, v in facebook_data.items():
if not data.get(k):
data[k] = v
if request.REQUEST.get('force_registration_hard'):
data['email'] = data['email'].replace('@', '+%s@' % randint(0, 100000))
form = form_class(data=data,
files=request.FILES,
initial={'ip': request.META['REMOTE_ADDR']})
if not form.is_valid():
error = facebook_exceptions.IncompleteProfileError(
'Facebook data %s gave error %s' % (facebook_data, form.errors))
error.form = form
raise error
if new_reg_module:
#support for the newer implementation
try:
from django.conf import settings
backend = get_backend(settings.REGISTRATION_BACKEND)
except:
raise ValueError, 'Cannot get django-registration backend from settings.REGISTRATION_BACKEND'
new_user = backend.register(request, **form.cleaned_data)
else:
new_user = form.save(profile_callback=profile_callback)
profile = new_user.get_profile()
profile.date_of_birth = facebook_data.get('date_of_birth')
if hasattr(profile, 'raw_data'):
serialized_fb_data = json.dumps(facebook.facebook_profile_data())
profile.raw_data = serialized_fb_data
profile.save()
auth.login(request, new_user)
return new_user
def test_connect(self):
'''
Test if we can do logins
django_facebook.connect.connect_user
'''
user = get_user_model().objects.all()[:1][0]
url = self.url
example_url = reverse('facebook_example')
# test registration flow
with patch('django_facebook.views.connect_user',
return_value=(CONNECT_ACTIONS.REGISTER,
user)) as wrapped_connect:
post_data = dict(
access_token='short_username',
next='%s?register=1' % example_url,
)
response = self.client.post(url, post_data, follow=True)
self.assertEqual(wrapped_connect.call_count, 1)
self.assertIn('register', response.redirect_chain[0][0])
self.assertEqual(response.status_code, 200)
# user register next instead of next
with patch('django_facebook.views.connect_user',
return_value=(CONNECT_ACTIONS.REGISTER,
user)) as wrapped_connect:
post_data = dict(access_token='short_username',
register_next='%s?register=1' % example_url)
response = self.client.post(url, post_data, follow=True)
self.assertEqual(wrapped_connect.call_count, 1)
self.assertIn('register', response.redirect_chain[0][0])
self.assertEqual(response.status_code, 200)
# test login
with patch('django_facebook.views.connect_user',
return_value=(CONNECT_ACTIONS.LOGIN,
user)) as wrapped_connect:
post_data = dict(
access_token='short_username',
next='%s?loggggg=1' % example_url,
)
response = self.client.post(url, post_data, follow=True)
self.assertEqual(wrapped_connect.call_count, 1)
self.assertIn('?loggggg=1', response.redirect_chain[0][0])
self.assertEqual(response.status_code, 200)
# test connect
with patch('django_facebook.views.connect_user',
return_value=(CONNECT_ACTIONS.CONNECT,
user)) as wrapped_connect:
post_data = dict(access_token='short_username',
next='%s?loggggg=1' % example_url)
response = self.client.post(url, post_data, follow=True)
self.assertEqual(wrapped_connect.call_count, 1)
assert '?loggggg=1' in response.redirect_chain[0][0]
self.assertEqual(response.status_code, 200)
# test connect
from django_facebook import exceptions as facebook_exceptions
profile_error = facebook_exceptions.IncompleteProfileError()
profile_error.form = None
with patch('django_facebook.views.connect_user',
return_value=(CONNECT_ACTIONS.REGISTER, user),
side_effect=profile_error) as wrapped_connect:
post_data = dict(access_token='short_username',
next='%s?loggggg=1' % example_url)
response = self.client.post(url, post_data, follow=True)
self.assertEqual(wrapped_connect.call_count, 1)
self.assertEqual(response.status_code, 200)
self.assertTrue(response.context)
template = self.get_response_template(response)
backend = get_registration_backend()
assert template.name in backend.get_registration_template()
def _register_user(request, facebook, profile_callback=None,
remove_old_connections=False):
'''
Creates a new user and authenticates
The registration form handles the registration and validation
Other data on the user profile is updates afterwards
if remove_old_connections = True we will disconnect old
profiles from their facebook flow
'''
if not facebook.is_authenticated():
raise ValueError(
'Facebook needs to be authenticated for connect flows')
# get the backend on new registration systems, or none
# if we are on an older version
backend = get_registration_backend()
logger.info('running backend %s for registration', backend)
# gets the form class specified in FACEBOOK_REGISTRATION_FORM
form_class = get_form_class(backend, request)
print("0")
facebook_data = facebook.facebook_registration_data()
print("1")
data = request.POST.copy()
print("2")
for k, v in facebook_data.items():
if not data.get(k):
data[k] = v
print("3")
if remove_old_connections:
_remove_old_connections(facebook_data['facebook_id'])
print("4")
if request.REQUEST.get('force_registration_hard'):
data['email'] = data['email'].replace(
'@', '+test%s@' % randint(0, 1000000000))
print("debug facebook data ", facebook_data, " data ", data)
try:
form = form_class(data=data, files=request.FILES,
initial={'ip': request.META['REMOTE_ADDR']})
if not form.is_valid():
# show errors in sentry
form_errors = form.errors
error = facebook_exceptions.IncompleteProfileError(
'Facebook signup incomplete')
error.form = form
raise error
except facebook_exceptions.AlreadyRegistered:
print("re raised!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!") # TODO
raise facebook_exceptions.AlreadyRegistered(_("This email address is already in use. Please supply a different email address."))
print("debug33", data["facebook_id"])
print("debug34", form.cleaned_data)
try:
# for new registration systems use the backends methods of saving
new_user = None
if backend:
new_user = backend.register(request,
form=form, **form.cleaned_data)
# fall back to the form approach
if new_user is None:
raise ValueError(
'new_user is None, note that backward compatability for the older versions of django registration has been dropped.')
except IntegrityError as e:
# this happens when users click multiple times, the first request registers
# the second one raises an error
raise facebook_exceptions.AlreadyRegistered(e)
# update some extra data not yet done by the form
print("debu4", new_user.facebook_id)
new_user = _update_user(new_user, facebook)
print("debu5", new_user.facebook_id)
new_user.facebook_id = data["facebook_id"]
new_user.raw_data = data
new_user.save()
signals.facebook_user_registered.send(sender=get_user_model(),
user=new_user, facebook_data=facebook_data, request=request, converter=facebook)
# IS this the correct way for django 1.3? seems to require the backend
# attribute for some reason
new_user.backend = 'django_facebook.auth_backends.FacebookBackend'
auth.login(request, new_user)
return new_user
def test_connect(self):
'''
Test if we can do logins
django_facebook.connect.connect_user
'''
user = User.objects.all()[:1][0]
url = reverse('facebook_connect')
#see if the basics don't give errors
response = self.client.get('%s?facebook_login=a' % url)
self.assertEqual(response.status_code, 200)
response = self.client.get('%s?facebook_login=0' % url)
self.assertEqual(response.status_code, 200)
response = self.client.get('%s?facebook_login='******'django_facebook.views.connect_user', return_value=(CONNECT_ACTIONS.REGISTER, user)) as wrapped_connect:
post_data = dict(access_token='short_username',
next='%s?register=1' % url, facebook_login=1)
response = self.client.post(url, post_data, follow=True)
self.assertEqual(wrapped_connect.call_count, 1)
self.assertIn('register', response.redirect_chain[0][0])
self.assertEqual(response.status_code, 200)
#user register next instead of next
with patch('django_facebook.views.connect_user', return_value=(CONNECT_ACTIONS.REGISTER, user)) as wrapped_connect:
post_data = dict(access_token='short_username', register_next='%s?register=1' % url, facebook_login=1)
response = self.client.post(url, post_data, follow=True)
self.assertEqual(wrapped_connect.call_count, 1)
self.assertIn('register', response.redirect_chain[0][0])
self.assertEqual(response.status_code, 200)
#test login
with patch('django_facebook.views.connect_user', return_value=(CONNECT_ACTIONS.LOGIN, user)) as wrapped_connect:
post_data = dict(access_token='short_username',
next='%s?loggggg=1' % url, facebook_login=1)
response = self.client.post(url, post_data, follow=True)
self.assertEqual(wrapped_connect.call_count, 1)
self.assertIn('?loggggg=1', response.redirect_chain[0][0])
self.assertEqual(response.status_code, 200)
#test connect
with patch('django_facebook.views.connect_user', return_value=(CONNECT_ACTIONS.CONNECT, user)) as wrapped_connect:
post_data = dict(access_token='short_username',
next='%s?loggggg=1' % url, facebook_login=1)
response = self.client.post(url, post_data, follow=True)
self.assertEqual(wrapped_connect.call_count, 1)
assert '?loggggg=1' in response.redirect_chain[0][0]
self.assertEqual(response.status_code, 200)
#test connect
from django_facebook import exceptions as facebook_exceptions
profile_error = facebook_exceptions.IncompleteProfileError()
profile_error.form = None
with patch('django_facebook.views.connect_user', return_value=(CONNECT_ACTIONS.REGISTER, user), side_effect=profile_error) as wrapped_connect:
post_data = dict(access_token='short_username',
next='%s?loggggg=1' % url, facebook_login=1)
response = self.client.post(url, post_data, follow=True)
self.assertEqual(wrapped_connect.call_count, 1)
self.assertEqual(response.status_code, 200)
self.assertTrue(response.context)
assert response.template.name in facebook_settings.FACEBOOK_REGISTRATION_TEMPLATE or response.template.name == facebook_settings.FACEBOOK_REGISTRATION_TEMPLATE
facebook_data = facebook.facebook_registration_data()
data = request.POST.copy()
for k, v in facebook_data.items():
if not data.get(k):
data[k] = v
if request.REQUEST.get('force_registration_hard'):
data['email'] = data['email'].replace('@', '+%s@' % randint(0, 100000))
form = form_class(data=data,
files=request.FILES,
initial={'ip': request.META['REMOTE_ADDR']})
if not form.is_valid():
error = facebook_exceptions.IncompleteProfileError(
'Facebook data %s gave error %s' % (facebook_data, form.errors))
error.form = form
raise error
if new_reg_module:
#support for the newer implementation
try:
from django.conf import settings
backend = get_backend(settings.REGISTRATION_BACKEND)
except:
raise ValueError, 'Cannot get django-registration backend from settings.REGISTRATION_BACKEND'
new_user = backend.register(request, **form.cleaned_data)
else:
new_user = form.save(profile_callback=profile_callback)
#update some extra data not yet done by the form
