def test_follow_og_share_error(self): user_url = 'http://www.fashiolista.com/style/neni/' kwargs = dict(item=user_url) user = get_user_model().objects.all()[:1][0] profile = try_get_profile(user) user_or_profile = get_instance_for_attribute( user, profile, 'facebook_open_graph') user_or_profile.facebook_open_graph = True user_or_profile.save() some_content_type = ContentType.objects.all()[:1][0] share = OpenGraphShare.objects.create( user_id=user.id, facebook_user_id=13123123, action_domain='fashiolista:follow', content_type=some_content_type, object_id=user.id, ) share.set_share_dict(kwargs) share.save() update_user_attributes(user, profile, dict(new_token_required=False)) from open_facebook.exceptions import FacebookUnreachable, OAuthException with mock.patch('open_facebook.api.OpenFacebook') as mocked: instance = mocked.return_value instance.set = Mock(side_effect=FacebookUnreachable('broken')) share.send(graph=instance) self.assertEqual(share.error_message, 'broken') self.assertFalse(share.completed_at) user = get_user_model().objects.get(id=user.id) if profile: profile = get_profile_model().objects.get(id=profile.id) new_token_required = get_user_attribute( user, profile, 'new_token_required') self.assertEqual(new_token_required, False) # now try with an oauth exception return # Can't figure out how to test this with mock.patch('open_facebook.api.OpenFacebook') as mocked: instance = mocked.return_value instance.set = Mock(side_effect=OAuthException('permissions')) share.send(graph=instance) self.assertEqual(share.error_message, 'permissions') self.assertFalse(share.completed_at) user = get_user_model().objects.get(id=user.id) if profile: profile = get_profile_model().objects.get(id=profile.id) new_token_required = get_user_attribute( user, profile, 'new_token_required') self.assertEqual(new_token_required, True)
def create_profile(sender, instance, created, **kwargs): """Create a matching profile whenever a user object is created.""" if sender == get_user_model(): user = instance profile_model = get_profile_model() if profile_model == MyCustomProfile and created: profile, new = MyCustomProfile.objects.get_or_create(user=instance)`
def random_facebook_friends(self, user, gender=None, limit=3): ''' Returns a random sample of your FB friends Limit = Number of friends Gender = None, M or F ''' assert gender in (None, 'M', 'F'), 'Gender %s wasnt recognized' % gender from django_facebook.utils import get_profile_model facebook_cache_key = 'facebook_users_%s' % user.id non_members = cache.get(facebook_cache_key) profile_class = get_profile_model() if not non_members: facebook_users = list( self.filter(user_id=user.id, gender=gender)[:50]) facebook_ids = [u.facebook_id for u in facebook_users] members = list( profile_class.objects.filter( facebook_id__in=facebook_ids).select_related('user')) member_ids = [p.facebook_id for p in members] non_members = [ u for u in facebook_users if u.facebook_id not in member_ids ] cache.set(facebook_cache_key, non_members, 60 * 60) random_limit = min(len(non_members), 3) random_facebook_users = [] if random_limit: random_facebook_users = random.sample(non_members, random_limit) return random_facebook_users
def _store_friends(self, user, friends): from django_facebook.models import FacebookUser current_friends = inserted_friends = None # store the users for later retrieval if friends: # see which ids this user already stored base_queryset = FacebookUser.objects.filter(user_id=user.id) global_defaults = dict(user_id=user.id) default_dict = {} for f in friends: name = f.get('name') default_dict[str(f['id'])] = dict(name=name) id_field = 'facebook_id' current_friends, inserted_friends = mass_get_or_create( FacebookUser, base_queryset, id_field, default_dict, global_defaults) logger.debug('found %s friends and inserted %s new ones', len(current_friends), len(inserted_friends)) # fire an event, so u can do things like personalizing suggested users # to follow signals.facebook_post_store_friends.send(sender=get_profile_model(), user=user, friends=friends, current_friends=current_friends, inserted_friends=inserted_friends, ) return friends
def _store_likes(self, user, likes): current_likes = inserted_likes = None if likes: from django_facebook.models import FacebookLike base_queryset = FacebookLike.objects.filter(user_id=user.id) global_defaults = dict(user_id=user.id) id_field = 'facebook_id' default_dict = {} for like in likes: name = like.get('name') created_time_string = like.get('created_time') created_time = None if created_time_string: created_time = parse_date(like['created_time']) default_dict[like['id']] = dict(created_time=created_time, category=like.get('category'), name=name) current_likes, inserted_likes = mass_get_or_create( FacebookLike, base_queryset, id_field, default_dict, global_defaults) logger.debug('found %s likes and inserted %s new likes', len(current_likes), len(inserted_likes)) # fire an event, so u can do things like personalizing the users' account # based on the likes signals.facebook_post_store_likes.send( sender=get_profile_model(), user=user, likes=likes, current_likes=current_likes, inserted_likes=inserted_likes, ) return likes
def create_profile(sender, instance, created, **kwargs): """Create a matching profile whenever a user object is created.""" if sender == get_user_model(): user = instance profile_model = get_profile_model() if profile_model == UserProfile and created: profile, new = UserProfile.objects.get_or_create(user=instance)
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_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 random_facebook_friends(self, user, gender=None, limit=3): ''' Returns a random sample of your FB friends Limit = Number of friends Gender = None, M or F ''' assert gender in ( None, 'M', 'F'), 'Gender %s wasnt recognized' % gender from django_facebook.utils import get_profile_model facebook_cache_key = 'facebook_users_%s' % user.id non_members = cache.get(facebook_cache_key) profile_class = get_profile_model() if not non_members: facebook_users = list( self.filter(user_id=user.id, gender=gender)[:50]) facebook_ids = [u.facebook_id for u in facebook_users] members = list(profile_class.objects.filter( facebook_id__in=facebook_ids).select_related('user')) member_ids = [p.facebook_id for p in members] non_members = [ u for u in facebook_users if u.facebook_id not in member_ids] cache.set(facebook_cache_key, non_members, 60 * 60) random_limit = min(len(non_members), 3) random_facebook_users = [] if random_limit: random_facebook_users = random.sample(non_members, random_limit) return random_facebook_users
def _store_likes(self, user, likes): current_likes = inserted_likes = None if likes: from django_facebook.models import FacebookLike base_queryset = FacebookLike.objects.filter(user_id=user.id) global_defaults = dict(user_id=user.id) id_field = 'facebook_id' default_dict = {} for like in likes: name = like.get('name') created_time_string = like.get('created_time') created_time = None if created_time_string: created_time = parse_date(like['created_time']) default_dict[like['id']] = dict( created_time=created_time, category=like.get('category'), name=name ) current_likes, inserted_likes = mass_get_or_create( FacebookLike, base_queryset, id_field, default_dict, global_defaults) logger.debug('found %s likes and inserted %s new likes', len(current_likes), len(inserted_likes)) # fire an event, so u can do things like personalizing the users' account # based on the likes signals.facebook_post_store_likes.send(sender=get_profile_model(), user=user, likes=likes, current_likes=current_likes, inserted_likes=inserted_likes, ) return likes
def profile_authenticate(self, facebook_id=None, facebook_email=None): ''' Authenticate the facebook user by id OR facebook_email We filter using an OR to allow existing members to connect with their facebook ID using email. :param facebook_id: Optional string representing the facebook id :param facebook_email: Optional string with the facebook email :return: The signed in :class:`User`. ''' logger.info("PA01 Inside profile authentication") if facebook_id or facebook_email: profile_class = get_profile_model() logger.info("PA02 Profile class %s" % profile_class) profile_query = profile_class.objects.all().order_by('user') profile_query = profile_query.select_related('user') logger.info("PA03 Profile query %s" % profile_query) profile = None # filter on email or facebook id, two queries for better # queryplan with large data sets if facebook_id: profiles = profile_query.filter(facebook_id=facebook_id)[:1] logger.info("PA04 Profiles from facebook_id %s" % profiles) profile = profiles[0] if profiles else None logger.info("PA05 Profile %s" % profile) if profile is None and facebook_email: try: profiles = profile_query.filter( user__email__iexact=facebook_email)[:1] logger.info("PA06 Profiles from email %s" % profiles) profile = profiles[0] if profiles else None logger.info("PA07 Profile %s" % profile) except DatabaseError: logger.info("PA08 Database error") try: user = get_user_model( ).objects.get(email=facebook_email) logger.info("PA09 User from model %s" % user) except get_user_model().DoesNotExist: logger.info("PA10 No model") user = None profile = try_get_profile(user) if user else None logger.info("PA11 Profile %s" % profile) if profile: # populate the profile cache while we're getting it anyway user = profile.user logger.info("PA07 User from profile %s" % user) user._profile = profile if facebook_settings.FACEBOOK_FORCE_PROFILE_UPDATE_ON_LOGIN: logger.info("UA10 Require user update") user.fb_update_required = True return user
def create_profile(sender, instance, created, **kwargs): ''' Create a matching profile whenever a user object is created. ''' print '=======', sender,instance,created if sender == get_user_model(): user = instance profile_model = get_profile_model() if profile_model == STUserProfile and created: profile, new = STUserProfile.objects.get_or_create(user=instance)
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_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 profile_authenticate(self, facebook_id=None, facebook_email=None): ''' Authenticate the facebook user by id OR facebook_email We filter using an OR to allow existing members to connect with their facebook ID using email. :param facebook_id: Optional string representing the facebook id :param facebook_email: Optional string with the facebook email :return: The signed in :class:`User`. ''' if facebook_id or facebook_email: profile_class = get_profile_model() profile_query = profile_class.objects.all().order_by('user') profile_query = profile_query.select_related('user') profile = None # filter on email or facebook id, two queries for better # queryplan with large data sets if facebook_id: profiles = profile_query.filter(facebook_id=facebook_id)[:1] profile = profiles[0] if profiles else None if profile is None and facebook_email: try: profiles = profile_query.filter( user__email__iexact=facebook_email)[:1] profile = profiles[0] if profiles else None except DatabaseError: try: user = get_user_model( ).objects.get(email=facebook_email) except get_user_model().DoesNotExist: user = None profile = user.get_profile() if user else None if profile: # populate the profile cache while we're getting it anyway user = profile.user user._profile = profile if facebook_settings.FACEBOOK_FORCE_PROFILE_UPDATE_ON_LOGIN: user.fb_update_required = True return user
def profile_authenticate(self, facebook_id=None, facebook_email=None): ''' Authenticate the facebook user by id OR facebook_email We filter using an OR to allow existing members to connect with their facebook ID using email. :param facebook_id: Optional string representing the facebook id :param facebook_email: Optional string with the facebook email :return: The signed in :class:`User`. ''' if facebook_id or facebook_email: profile_class = get_profile_model() profile_query = profile_class.objects.all().order_by('user') profile_query = profile_query.select_related('user') profile = None # filter on email or facebook id, two queries for better # queryplan with large data sets if facebook_id: profiles = profile_query.filter(facebook_id=facebook_id)[:1] profile = profiles[0] if profiles else None if profile is None and facebook_email: try: profiles = profile_query.filter( user__email__iexact=facebook_email)[:1] profile = profiles[0] if profiles else None except DatabaseError: try: user = get_user_model().objects.get( email=facebook_email) except get_user_model().DoesNotExist: user = None profile = user.get_profile() if user else None if profile: # populate the profile cache while we're getting it anyway user = profile.user user._profile = profile if facebook_settings.FACEBOOK_FORCE_PROFILE_UPDATE_ON_LOGIN: user.fb_update_required = True return user
def _store_friends(self, user, friends): from django_facebook.models import FacebookUser current_friends = inserted_friends = None # store the users for later retrieval if friends: # see which ids this user already stored base_queryset = FacebookUser.objects.filter(user_id=user.id) # if none if your friend have a gender clean the old data genders = FacebookUser.objects.filter(user_id=user.id, gender__in=('M', 'F')).count() if not genders: FacebookUser.objects.filter(user_id=user.id).delete() global_defaults = dict(user_id=user.id) default_dict = {} gender_map = dict(female='F', male='M') gender_map['male (hidden)'] = 'M' gender_map['female (hidden)'] = 'F' for f in friends: name = f.get('name') gender = None if f.get('sex'): gender = gender_map[f.get('sex')] default_dict[str(f['id'])] = dict(name=name, gender=gender) id_field = 'facebook_id' current_friends, inserted_friends = mass_get_or_create( FacebookUser, base_queryset, id_field, default_dict, global_defaults) logger.debug('found %s friends and inserted %s new ones', len(current_friends), len(inserted_friends)) # fire an event, so u can do things like personalizing suggested users # to follow signals.facebook_post_store_friends.send( sender=get_profile_model(), user=user, friends=friends, current_friends=current_friends, inserted_friends=inserted_friends, ) return friends
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 registered_friends(self, user): """ Returns all profile models which are already registered on your site and a list of friends which are not on your site """ profile_class = get_profile_model() friends = self.get_friends(limit=1000) if friends: friend_ids = [f["id"] for f in friends] friend_objects = profile_class.objects.filter(facebook_id__in=friend_ids).select_related("user") registered_ids = [f.facebook_id for f in friend_objects] new_friends = [f for f in friends if f["id"] not in registered_ids] else: new_friends = [] friend_objects = profile_class.objects.none() return friend_objects, new_friends
def _store_friends(self, user, friends): from django_facebook.models import FacebookUser current_friends = inserted_friends = None # store the users for later retrieval if friends: # see which ids this user already stored base_queryset = FacebookUser.objects.filter(user_id=user.id) # if none if your friend have a gender clean the old data genders = FacebookUser.objects.filter(user_id=user.id, gender__in=("M", "F")).count() if not genders: FacebookUser.objects.filter(user_id=user.id).delete() global_defaults = dict(user_id=user.id) default_dict = {} gender_map = dict(female="F", male="M") gender_map["male (hidden)"] = "M" gender_map["female (hidden)"] = "F" for f in friends: name = f.get("name") gender = None if f.get("sex"): gender = gender_map[f.get("sex")] default_dict[str(f["id"])] = dict(name=name, gender=gender) id_field = "facebook_id" current_friends, inserted_friends = mass_get_or_create( FacebookUser, base_queryset, id_field, default_dict, global_defaults ) logger.debug("found %s friends and inserted %s new ones", len(current_friends), len(inserted_friends)) # fire an event, so u can do things like personalizing suggested users # to follow signals.facebook_post_store_friends.send( sender=get_profile_model(), user=user, friends=friends, current_friends=current_friends, inserted_friends=inserted_friends, ) return friends
def test_send(error, expected_error_message, expected_new_token, has_permissions=False): user, profile, share = self.share_details update_user_attributes( user, profile, dict(new_token_required=False), save=True) with mock.patch('open_facebook.api.OpenFacebook') as mocked: instance = mocked.return_value instance.set = Mock(side_effect=error) instance.has_permissions = Mock(return_value=has_permissions) instance.access_token = get_user_attribute( user, profile, 'access_token') share.send(graph=instance) self.assertEqual(share.error_message, expected_error_message) self.assertFalse(share.completed_at) user = get_user_model().objects.get(id=user.id) if profile: profile = get_profile_model().objects.get(id=profile.id) new_token_required = get_user_attribute( user, profile, 'new_token_required') self.assertEqual(new_token_required, expected_new_token)
def registered_friends(self, user): ''' Returns all profile models which are already registered on your site and a list of friends which are not on your site ''' profile_class = get_profile_model() friends = self.get_friends(limit=1000) if friends: friend_ids = [f['id'] for f in friends] friend_objects = profile_class.objects.filter( facebook_id__in=friend_ids).select_related('user') registered_ids = [f.facebook_id for f in friend_objects] new_friends = [f for f in friends if f['id'] not in registered_ids] else: new_friends = [] friend_objects = profile_class.objects.none() return friend_objects, new_friends
def _store_friends(self, user, friends): from django_facebook.models import FacebookUser current_friends = inserted_friends = None # store the users for later retrieval if friends: # see which ids this user already stored base_queryset = FacebookUser.objects.filter(user_id=user.id) # if none if your friend have a gender clean the old data genders = FacebookUser.objects.filter( user_id=user.id, gender__in=('M', 'F')).count() if not genders: FacebookUser.objects.filter(user_id=user.id).delete() global_defaults = dict(user_id=user.id) default_dict = {} gender_map = dict(female='F', male='M') for f in friends: name = f.get('name') gender = None if f.get('sex'): try: gender = gender_map[f.get('sex')] except KeyError: # we could get results like 'male (hidden)' pass default_dict[str(f['id'])] = dict(name=name, gender=gender) id_field = 'facebook_id' current_friends, inserted_friends = mass_get_or_create( FacebookUser, base_queryset, id_field, default_dict, global_defaults) logger.debug('found %s friends and inserted %s new ones', len(current_friends), len(inserted_friends)) # fire an event, so u can do things like personalizing suggested users # to follow signals.facebook_post_store_friends.send(sender=get_profile_model(), user=user, friends=friends, current_friends=current_friends, inserted_friends=inserted_friends, ) return friends
def create_profile(sender, instance, created, **kwargs): if sender == get_user_model(): Fbuser = instance profile_model = get_profile_model() if profile_model == FacebookProfile and created: profile, new = FacebookProfile.objects.get_or_create(user=instance)
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} # social-auth support # trying to find social user with given email social_user = User.objects.filter(email=email) social_user = social_user[0] if social_user else None if social_user and UserSocialAuth.objects.filter( user__id=social_user.id).exists(): try: current_user_profile = try_get_profile(social_user) except: profile_model = get_profile_model() profile_model.objects.create(user=social_user) 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) if not auth_user: # We don't have a valid user so raise raise e action = CONNECT_ACTIONS.LOGIN user = _login_user(request, converter, auth_user, update=False)
def connect_user(request, access_token=None, facebook_graph=None, connect_facebook=False): ''' Given a request either - (if authenticated) connect the user - login - register ''' logger.info('CU01: Start data access_token %s' % access_token) logger.info('CU02: Start data facebook_graph %s' % facebook_graph) logger.info('CU03: Connect facebook %s' % connect_facebook) 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.info('CU04: Force registration %s' % force_registration) if connect_facebook and request.user.is_authenticated() and not force_registration: logger.info('CU05: User is authenticated %s' % request.user.is_authenticated()) # 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 logger.info('CU06: Action %s' % action) # default behaviour is not to overwrite old data user = _connect_user(request, converter, overwrite=True) else: logger.info('CU07: Bad day') email = facebook_data.get('email', False) logger.info('CU08: Email %s' % email) email_verified = facebook_data.get('verified', False) kwargs = {} if email and email_verified: logger.info('CU09: Facebook email added to kwargs') kwargs = {'facebook_email': email} # social-auth support # trying to find social user with given email logger.info('CU10: Social auth support') social_user = get_user_model().objects.filter(email=email) logger.info('CU11: Social users found %s' % social_user) social_user = social_user[0] if social_user else None logger.info('CU12: Social user %s' % social_user) if social_user and UserSocialAuth.objects.filter(user__id=social_user.id).exists(): logger.info('CU13: Social user exists') try: current_user_profile = try_get_profile(social_user) logger.info('CU14: Got profile for social user %s' % current_user_profile) except: logger.info('CU15: No profile') profile_model = get_profile_model() logger.info('CU16: Profile model %s' % profile_model) profile_model.objects.create(user=social_user) logger.info('CU17: Profile object created') auth_user = authenticate(facebook_id=facebook_data['id'], **kwargs) logger.info('CU19: Aunthenticated user %s ' % auth_user) if auth_user and not force_registration: referer_url = request.META.get('HTTP_REFERER', None) if referer_url: urlparsed = urlparse(referer_url) is_facebook = urlparsed.netloc.endswith('facebook.com') else: is_facebook = False logger.info('CU32 is_facebook: %s, referer_url: %s'%(is_facebook, referer_url)) if auth_user.is_client() or auth_user.is_subclient() and not is_facebook: action = CONNECT_ACTIONS.CLIENT_REDIRECT logger.info('CU31: Client or subclient detected. Action: CLIENT_REDIRECT') return action, auth_user action = CONNECT_ACTIONS.LOGIN logger.info('CU20: Action %s' % action) # 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) logger.info('CU21: Update %s' % update) profile = try_get_profile(auth_user) logger.info('CU22: Got profile %s' % profile) current_facebook_id = get_user_attribute( auth_user, profile, 'facebook_id') logger.info('CU23: Current facebook_id %s' % current_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 logger.info('CU24: Action %s' % action) # when force registration is active we should remove the old # profile try: user = _register_user(request, converter, remove_old_connections=force_registration) logger.info('CU25: User registered %s' % user) except facebook_exceptions.AlreadyRegistered, e: # in Multithreaded environments it's possible someone beats us to # the punch, in that case just login logger.info( 'CU26: parallel register encountered, slower thread is doing a login') auth_user = authenticate( facebook_id=facebook_data['id'], **kwargs) logger.info('CU27: Auth user %s' % auth_user) if not auth_user: logger.info('CU28: No auth user') # We don't have a valid user so raise raise e logger.info('CU29: Login user') action = CONNECT_ACTIONS.LOGIN user = _login_user(request, converter, auth_user, update=False)