def test_double_username(self):
'''
This used to give an error with duplicate usernames
with different capitalization
'''
facebook = get_facebook_graph(access_token='short_username')
action, user = connect_user(self.request, facebook_graph=facebook)
user.username = '******'
user.save()
self.request.user = AnonymousUser()
facebook = get_facebook_graph(access_token='same_username')
action, new_user = connect_user(self.request, facebook_graph=facebook)
self.assertNotEqual(user.username, new_user.username)
self.assertNotEqual(user.id, new_user.id)
def friendslist(request):
#try:
graph = get_facebook_graph(request)
facebook = FacebookUserConverter(graph)
#groups = facebook.get_groups()
items = facebook.get_free_for_sale()
#print json.dumps(items, sort_keys=True, indent=4, separators=(',', ': '))
for item in items:
thumbnail_url = item.get('picture')
if thumbnail_url:
link = item.get('link')
fb_id = parse_qs(urlparse(link).query)['fbid'][0]
# print(fb_id)
picture = facebook.get_facebook_url(fb_id)
# print(picture)
picture_url = picture.get('source')
# print(picture_url)
#print items
#friends = facebook.get_friends()
#likes = facebook.get_likes()
#store_likes = facebook.get_and_store_likes(request.user)
#print(groups)
#print(store_likes)
#print(queryset)
#context_object_name = 'my_friends_list'
#template_name = "friendslist.html"
#except OpenFacebookException as e:
# print(e)
#except:
# raise Http404
update_index.Command().handle(using='default', remove=True)
return render_to_response('friendslist.html', {'items': items},
context_instance=RequestContext(request))
def test_parallel_register(self):
'''
Adding some testing for the case when one person tries to register
multiple times in the same second
'''
graph = get_facebook_graph(access_token='short_username')
FacebookUserConverter(graph)
action, user = connect_user(self.request, facebook_graph=graph)
self.assertEqual(action, CONNECT_ACTIONS.REGISTER)
self.request.user.is_authenticated = lambda: False
with patch('django_facebook.connect.authenticate') as patched:
return_sequence = [user, None]
def side(*args, **kwargs):
value = return_sequence.pop()
return value
patched.side_effect = side
with patch('django_facebook.connect._register_user'
) as patched_register:
patched_register.side_effect = facebook_exceptions.AlreadyRegistered(
'testing parallel registers')
action, user = connect_user(self.request, facebook_graph=graph)
self.assertEqual(action, CONNECT_ACTIONS.LOGIN)
def test_user_registered_signal(self):
# Ensure user registered, pre update and post update signals fire
def user_registered(sender, user, facebook_data, **kwargs):
user.registered_signal = True
def pre_update(sender, user, profile, facebook_data, **kwargs):
user.pre_update_signal = True
def post_update(sender, user, profile, facebook_data, **kwargs):
user.post_update_signal = True
Profile = get_profile_model()
user_model = get_user_model()
signals.facebook_user_registered.connect(user_registered,
sender=user_model)
signals.facebook_pre_update.connect(pre_update, sender=user_model)
signals.facebook_post_update.connect(post_update, sender=user_model)
graph = get_facebook_graph(access_token='short_username')
facebook = FacebookUserConverter(graph)
user = _register_user(self.request, facebook)
self.assertEqual(hasattr(user, 'registered_signal'), True)
self.assertEqual(hasattr(user, 'pre_update_signal'), True)
self.assertEqual(hasattr(user, 'post_update_signal'), True)
def test_persistent_graph(self):
request = RequestMock().get('/')
request.session = {}
request.user = AnonymousUser()
graph = get_facebook_graph(access_token='short_username')
FacebookUserConverter(graph)
action, user = connect_user(self.request, facebook_graph=graph)
self.assertEqual(action, CONNECT_ACTIONS.REGISTER)
def test_registration_form(self):
'''
Django_facebook should use user supplied registration form if given
'''
from django.conf import settings
if settings.MODE == 'userena':
return
test_form = 'django_facebook.test_utils.forms.SignupForm'
old_setting = facebook_settings.FACEBOOK_REGISTRATION_FORM
facebook_settings.FACEBOOK_REGISTRATION_FORM = test_form
try:
facebook = get_facebook_graph(access_token='short_username')
action, user = connect_user(self.request, facebook_graph=facebook)
# The test form always sets username to test form
self.assertEqual(user.username, 'Test form')
finally:
facebook_settings.FACEBOOK_REGISTRATION_FORM = old_setting
def test_fb_update_required(self):
def pre_update(sender, user, profile, facebook_data, **kwargs):
user.pre_update_signal = True
Profile = get_profile_model()
user_model = get_user_model()
signals.facebook_pre_update.connect(pre_update, sender=user_model)
facebook = get_facebook_graph(access_token='tschellenbach')
facebook_settings.FACEBOOK_FORCE_PROFILE_UPDATE_ON_LOGIN = True
action, user = connect_user(self.request, facebook_graph=facebook)
self.assertEqual(action, CONNECT_ACTIONS.LOGIN)
self.assertTrue(hasattr(user, 'pre_update_signal'))
facebook_settings.FACEBOOK_FORCE_PROFILE_UPDATE_ON_LOGIN = False
action, user = connect_user(self.request, facebook_graph=facebook)
self.assertEqual(action, CONNECT_ACTIONS.LOGIN)
self.assertFalse(hasattr(user, 'pre_update_signal'))
def test_full_connect(self):
# going for a register, connect and login
graph = get_facebook_graph(access_token='short_username')
FacebookUserConverter(graph)
action, user = connect_user(self.request, facebook_graph=graph)
self.assertEqual(action, CONNECT_ACTIONS.REGISTER)
# and now we do a login, not a connect
action, user = connect_user(self.request, facebook_graph=graph)
self.assertEqual(action, CONNECT_ACTIONS.LOGIN)
self.request.GET._mutable = True
self.request.GET['connect_facebook'] = 1
action, user = connect_user(self.request,
facebook_graph=graph,
connect_facebook=True)
self.assertEqual(action, CONNECT_ACTIONS.CONNECT)
self.request.user = AnonymousUser()
action, user = connect_user(self.request,
facebook_graph=graph,
connect_facebook=True)
self.assertEqual(action, CONNECT_ACTIONS.LOGIN)
def test_update_access_token(self):
request = RequestMock().get('/')
request.session = {}
request.user = AnonymousUser()
graph = get_persistent_graph(request, access_token='paul')
action, user = connect_user(self.request, facebook_graph=graph)
first_user_id = user.id
# new token required should start out as False
profile = try_get_profile(user)
new_token_required = get_user_attribute(user, profile,
'new_token_required')
self.assertEqual(new_token_required, False)
# we manually set it to true
update_user_attributes(user,
profile,
dict(new_token_required=True),
save=True)
if profile:
profile = get_profile_model().objects.get(id=profile.id)
user = get_user_model().objects.get(id=user.id)
new_token_required = get_user_attribute(user, profile,
'new_token_required')
self.assertEqual(new_token_required, True)
# another update should however set it back to False
request.facebook = None
graph = get_facebook_graph(request, access_token='paul2')
logger.info('and the token is %s', graph.access_token)
action, user = connect_user(self.request, facebook_graph=graph)
user = get_user_model().objects.get(id=user.id)
self.assertEqual(user.id, first_user_id)
if profile:
profile = get_profile_model().objects.get(id=profile.id)
user = get_user_model().objects.get(id=user.id)
new_token_required = get_user_attribute(user, profile,
'new_token_required')
self.assertEqual(new_token_required, False)
def test_auth_backend(self):
# the auth backend
backend = FacebookBackend()
facebook = get_facebook_graph(access_token='new_user')
action, user = connect_user(self.request, facebook_graph=facebook)
facebook_email = user.email
profile = try_get_profile(user)
user_or_profile = get_instance_for_attribute(user, profile,
'facebook_id')
facebook_id = user_or_profile.facebook_id
auth_user = backend.authenticate(facebook_email=facebook_email)
logger.info('%s %s %s', auth_user.email, user.email, facebook_email)
self.assertEqual(auth_user, user)
auth_user = backend.authenticate(facebook_id=facebook_id)
self.assertEqual(auth_user, user)
auth_user = backend.authenticate(facebook_id=facebook_id,
facebook_email=facebook_email)
self.assertEqual(auth_user, user)
auth_user = backend.authenticate()
self.assertIsNone(auth_user)
def test_gender(self):
graph = get_facebook_graph(access_token='new_user')
facebook = FacebookUserConverter(graph)
data = facebook.facebook_registration_data()
self.assertEqual(data['gender'], 'm')
def test_short_username(self):
facebook = get_facebook_graph(access_token='short_username')
action, user = connect_user(self.request, facebook_graph=facebook)
self.assertTrue(len(user.username) > 4)
self.assertEqual(action, CONNECT_ACTIONS.REGISTER)
def test_new_user(self):
facebook = get_facebook_graph(access_token='new_user')
action, user = connect_user(self.request, facebook_graph=facebook)
def test_utf8(self):
graph = get_facebook_graph(access_token='unicode_string')
facebook = FacebookUserConverter(graph)
action, user = connect_user(self.request, facebook_graph=graph)
def connect_user(request,
access_token=None,
facebook_graph=None,
connect_facebook=False):
'''
Given a request either
- (if authenticated) connect the user
- login
- register
'''
user = None
graph = facebook_graph or get_facebook_graph(request, access_token)
converter = get_instance_for('user_conversion', graph)
assert converter.is_authenticated()
facebook_data = converter.facebook_profile_data()
force_registration = request.REQUEST.get('force_registration') or\
request.REQUEST.get('force_registration_hard')
logger.debug('force registration is set to %s', force_registration)
if connect_facebook and request.user.is_authenticated(
) and not force_registration:
# we should only allow connect if users indicate they really want to connect
# only when the request.CONNECT_FACEBOOK = 1
# if this isn't present we just do a login
action = CONNECT_ACTIONS.CONNECT
# default behaviour is not to overwrite old data
user = _connect_user(request, converter, overwrite=True)
else:
email = facebook_data.get('email', False)
email_verified = facebook_data.get('verified', False)
kwargs = {}
if email and email_verified:
kwargs = {'facebook_email': email}
auth_user = authenticate(facebook_id=facebook_data['id'], **kwargs)
if auth_user and not force_registration:
action = CONNECT_ACTIONS.LOGIN
# Has the user registered without Facebook, using the verified FB
# email address?
# It is after all quite common to use email addresses for usernames
update = getattr(auth_user, 'fb_update_required', False)
profile = try_get_profile(auth_user)
current_facebook_id = get_user_attribute(auth_user, profile,
'facebook_id')
if not current_facebook_id:
update = True
# login the user
user = _login_user(request, converter, auth_user, update=update)
else:
action = CONNECT_ACTIONS.REGISTER
# when force registration is active we should remove the old
# profile
try:
user = _register_user(
request,
converter,
remove_old_connections=force_registration)
except facebook_exceptions.AlreadyRegistered, e:
# in Multithreaded environments it's possible someone beats us to
# the punch, in that case just login
logger.info(
'parallel register encountered, slower thread is doing a login'
)
auth_user = authenticate(facebook_id=facebook_data['id'],
**kwargs)
action = CONNECT_ACTIONS.LOGIN
user = _login_user(request, converter, auth_user, update=False)
def fb_import(request):
if request.method == 'GET':
existing_groups = []
new_groups = []
data = {}
if request.user.is_authenticated():
user_profile = request.user.get_profile()
my_circles = user_profile.my_circles.all()
my_circles_id = [o.id for o in my_circles]
try:
graph = get_facebook_graph(request)
facebook = FacebookUserConverter(graph)
groups = facebook.get_groups()
#friends = facebook.get_friends()
groups = sorted(groups,
key=lambda group: group['bookmark_order'])
for group in groups:
try:
existing = Circle.objects.get(fb_id=group['id'])
if existing not in my_circles:
existing_groups.append(existing)
except:
new_groups.append(group)
except:
existing_groups = Circle.objects.filter(
is_public=True).exclude(
id__in=my_circles_id).order_by('?')[:5]
if not existing_groups:
existing_groups = Circle.objects.filter(
is_public=True).exclude(
id__in=my_circles_id).order_by('?')[:5]
data['existing_groups'] = existing_groups
data['new_groups'] = new_groups
user_profile.first_time = False
user_profile.save()
return render_to_response('fb_import.html',
data,
context_instance=RequestContext(request))
else:
user_profile = request.user.get_profile()
create_groups = request.POST.getlist("createFbId")
create_groups = map(int, create_groups)
join_groups = request.POST.getlist("joinGroupId")
graph = get_facebook_graph(request)
facebook = FacebookUserConverter(graph)
groups = facebook.get_groups()
for group in groups:
#print(group['id'])
if not Circle.objects.filter(fb_id=group['id']) and int(
group['id']) in create_groups:
name = group[
'name'][:
100] #this 100 comes from the circle name model max length
circle = Circle.objects.create(name=group['name'],
creator=request.user,
fb_id=group['id'],
url_key=Circle.make_key(),
is_public=True)
user_profile.my_circles.add(circle)
for group_id in join_groups:
group = Circle.objects.get(id=group_id)
user_profile.my_circles.add(group)
return redirect(
'/accounts/profile/groups/?msg=Groups have been successfully updated!'
)
def test_current_user(self):
facebook = get_facebook_graph(access_token='tschellenbach')
action, user = connect_user(self.request, facebook_graph=facebook)
self.assertEqual(action, CONNECT_ACTIONS.LOGIN)
def fb_to_excel(request):
data = {}
ffs_items = txtbook_items = clothes_items = []
choices = ''
limit = 1000
existing = ''
new_items = []
import time
until = datetime.datetime.utcnow()
until = time.mktime(until.timetuple())
since = 0
if 'choices' in request.GET:
choices = request.GET['choices']
if 'limit' in request.GET:
limit = int(request.GET['limit'])
if 'existing' in request.GET:
existing = request.GET['existing']
if 'until' in request.GET:
until = request.GET['until']
if 'since' in request.GET:
since = request.GET['since']
if not existing:
try:
graph = get_facebook_graph(request)
facebook = FacebookUserConverter(graph)
if not choices or 'ffs' in choices:
ffs_items = facebook.get_free_for_sale(limit=limit)
if not choices or 'txt' in choices:
txtbook_items = facebook.get_textbook_exchange(limit=limit)
if not choices or 'cls' in choices:
clothes_items = facebook.get_facebook_data(
'429395210488691/feed', limit=limit)
except:
data['title'] = 'Relogin to Facebook'
data['message'] = 'Your login has expired. Relogin ya doof.'
return render_to_response('message.html',
data,
context_instance=RequestContext(request))
items = ffs_items + txtbook_items + clothes_items
new_items = save_fb_items_to_model(facebook, items)
existing_items = FacebookPostForExcel.objects.all()
response = HttpResponse(content_type='text/csv')
response['Content-Disposition'] = 'attachment; filename="FB-items.csv"'
import cc.unicodecsv as csv
writer = csv.writer(response)
'''
message=message,
user_id=user_id,
facebook_id=item_id,
seller_name=seller_name,
post_url=post_url,
thumbnail_url=thumbnail_url,
picture_url=picture_url,
price=price,
created_time=created_time
'''
writer.writerow([
'Created_Time', 'Message', 'Post Url', 'Seller Name', 'Picture Url',
'Price', 'Comments', 'Likes'
])
db_items = new_items
if existing:
db_items = existing_items
for item in db_items:
try:
updated_time = item.updated_time.isoformat()
except:
updated_time = "None"
writer.writerow([
updated_time, item.message, item.post_url, item.seller_name,
item.picture_url,
str(item.price), item.num_comments, item.num_likes
])
return response
