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