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 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 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)
