def setUp(self):
self._urlconf_setup()
self.group = Group.objects.get_or_create(name='CoolGroup')[0]
self.user1 = User.objects.get_or_create(username='******')[0]
self.user1.set_password('admin')
self.user1.is_superuser = self.user1.is_active = self.user1.is_staff = True
self.user1.save()
self.user2 = User.objects.get_or_create(username='******')[0]
# User1 joins group
self.user1.groups.add(self.group)
action.send(self.user1, verb='joined', target=self.group)
# User1 follows User2
follow(self.user1, self.user2)
# User2 joins group
self.user2.groups.add(self.group)
action.send(self.user2, verb='joined', target=self.group)
# User2 follows group
follow(self.user2, self.group)
# User1 comments on group
action.send(self.user1, verb='commented on', target=self.group)
self.comment = Comment.objects.create(user=self.user1,
comment="Sweet Group!")
# Group responds to comment
action.send(self.group, verb='responded to', target=self.comment)
self.client = Client()
def setUp(self):
self.group = Group.objects.get_or_create(name='CoolGroup')[0]
self.user1 = User.objects.get_or_create(username='******')[0]
self.user1.set_password('admin')
self.user1.is_superuser = self.user1.is_active = self.user1.is_staff = True
self.user1.save()
self.user2 = User.objects.get_or_create(username='******')[0]
# User1 joins group
self.user1.groups.add(self.group)
action.send(self.user1, verb='joined', target=self.group)
# User1 follows User2
follow(self.user1, self.user2)
# User2 joins group
self.user2.groups.add(self.group)
action.send(self.user2, verb='joined', target=self.group)
# User2 follows group
follow(self.user2, self.group)
# User1 comments on group
action.send(self.user1, verb='commented on', target=self.group)
comment = Comment.objects.get_or_create(
user=self.user1,
content_type=ContentType.objects.get_for_model(self.group),
object_pk=self.group.pk,
comment='Sweet Group!',
site=Site.objects.get_current())[0]
# Group responds to comment
action.send(self.group, verb='responded to', target=comment)
self.client = Client()
def test_doesnt_generate_duplicate_follow_records(self):
g = Group.objects.get_or_create(name='DupGroup')[0]
s = User.objects.get_or_create(username='******')[0]
f1 = follow(s, g)
self.assertTrue(f1 is not None,
"Should have received a new follow record")
self.assertTrue(isinstance(f1, Follow), "Returns a Follow object")
self.assertEquals(
1,
Follow.objects.filter(
user=s,
object_id=g.pk,
content_type=ContentType.objects.get_for_model(g)).count(),
"Should only have 1 follow record here")
f2 = follow(s, g)
self.assertEquals(
1,
Follow.objects.filter(
user=s,
object_id=g.pk,
content_type=ContentType.objects.get_for_model(g)).count(),
"Should still only have 1 follow record here")
self.assertTrue(f2 is not None, "Should have received a Follow object")
self.assertTrue(isinstance(f2, Follow), "Returns a Follow object")
self.assertEquals(
f1, f2,
"Should have received the same Follow object that I first submitted"
)
def setUp(self):
self._urlconf_setup()
self.group = Group.objects.get_or_create(name="CoolGroup")[0]
self.user1 = User.objects.get_or_create(username="******")[0]
self.user1.set_password("admin")
self.user1.is_superuser = self.user1.is_active = self.user1.is_staff = True
self.user1.save()
self.user2 = User.objects.get_or_create(username="******")[0]
# User1 joins group
self.user1.groups.add(self.group)
action.send(self.user1, verb="joined", target=self.group)
# User1 follows User2
follow(self.user1, self.user2)
# User2 joins group
self.user2.groups.add(self.group)
action.send(self.user2, verb="joined", target=self.group)
# User2 follows group
follow(self.user2, self.group)
# User1 comments on group
action.send(self.user1, verb="commented on", target=self.group)
self.comment = Comment.objects.create(user=self.user1, comment="Sweet Group!")
# Group responds to comment
action.send(self.group, verb="responded to", target=self.comment)
self.client = Client()
def setUp(self):
self.group = Group.objects.get_or_create(name='CoolGroup')[0]
self.user1 = User.objects.get_or_create(username='******')[0]
self.user1.set_password('admin')
self.user1.is_superuser = self.user1.is_active = self.user1.is_staff = True
self.user1.save()
self.user2 = User.objects.get_or_create(username='******')[0]
# User1 joins group
self.user1.groups.add(self.group)
action.send(self.user1,verb='joined',target=self.group)
# User1 follows User2
follow(self.user1, self.user2)
# User2 joins group
self.user2.groups.add(self.group)
action.send(self.user2,verb='joined',target=self.group)
# User2 follows group
follow(self.user2, self.group)
# User1 comments on group
# Use a site object here and predict the "__unicode__ method output"
action.send(self.user1,verb='commented on',target=self.group)
self.comment = Site.objects.create(
domain="admin: Sweet Group!...")
# Group responds to comment
action.send(self.group,verb='responded to',target=self.comment)
self.client = Client()
def follow_unfollow(request, content_type_id, object_id, do_follow=True):
"""
Creates or deletes the follow relationship between ``request.user`` and the actor defined by ``content_type_id``, ``object_id``
"""
ctype = get_object_or_404(ContentType, pk=content_type_id)
actor = get_object_or_404(ctype.model_class(), pk=object_id)
if do_follow:
follow(request.user, actor)
return respond(request, 201) # CREATED
unfollow(request.user, actor)
return respond(request, 204) # NO CONTENT
def follow_unfollow(request, content_type_id, object_id, do_follow=True):
"""
Creates or deletes the follow relationship between ``request.user`` and the actor defined by ``content_type_id``, ``object_id``
"""
ctype = get_object_or_404(ContentType, pk=content_type_id)
actor = get_object_or_404(ctype.model_class(), pk=object_id)
if do_follow:
follow(request.user, actor)
return respond(request, 201) # CREATED
unfollow(request.user, actor)
return respond(request, 204) # NO CONTENT
def test_doesnt_generate_duplicate_follow_records(self):
g = Group.objects.get_or_create(name='DupGroup')[0]
s = User.objects.get_or_create(username='******')[0]
f1 = follow(s, g)
self.assertTrue(f1 is not None, "Should have received a new follow record")
self.assertTrue(isinstance(f1, Follow), "Returns a Follow object")
self.assertEquals( 1, Follow.objects.filter(user = s, object_id = g.pk,
content_type = ContentType.objects.get_for_model(g)).count(), "Should only have 1 follow record here")
f2 = follow(s, g)
self.assertEquals( 1, Follow.objects.filter(user = s, object_id = g.pk,
content_type = ContentType.objects.get_for_model(g)).count(), "Should still only have 1 follow record here")
self.assertTrue( f2 is not None, "Should have received a Follow object")
self.assertTrue(isinstance(f2, Follow), "Returns a Follow object")
self.assertEquals(f1, f2, "Should have received the same Follow object that I first submitted")
def follow_unfollow(request, content_type_id, object_id, do_follow=True):
"""
Creates or deletes the follow relationship between ``request.user`` and the actor defined by ``content_type_id``, ``object_id``
"""
if request.method == 'POST':
ctype = get_object_or_404(ContentType, pk=content_type_id)
actor = get_object_or_404(ctype.model_class(), pk=object_id)
if do_follow:
follow(request.user, actor)
return respond(request, 201) # CREATED
unfollow(request.user, actor)
return respond(request, 204) # NO CONTENT
response = HttpResponse()
response['Allow'] = 'POST'
response.status_code = 405 # Method not allowed
return response
def sync_followers(self, old):
print "Migrating followers ..."
prog = ProgressBar(0, self.count_table(old, 'users_followers'), 77, mode='fixed')
old.execute('select * from users_followers')
for old_follower in old.fetchall():
if not old_follower[0]: continue
if not old_follower[1]: continue
try:
user = self.get_user(old_follower[0])
follower = self.get_user(old_follower[1])
follow(follower, user, False)
except:
continue
prog.increment_amount()
print prog, '\r',
sys.stdout.flush()
def setUp(self):
self.group = Group.objects.get_or_create(name="CoolGroup")[0]
self.user1 = User.objects.get_or_create(username="******")[0]
self.user1.set_password("admin")
self.user1.is_superuser = self.user1.is_active = self.user1.is_staff = True
self.user1.save()
self.user2 = User.objects.get_or_create(username="******")[0]
# User1 joins group
self.user1.groups.add(self.group)
action.send(self.user1, verb="joined", target=self.group)
# User1 follows User2
follow(self.user1, self.user2)
# User2 joins group
self.user2.groups.add(self.group)
action.send(self.user2, verb="joined", target=self.group)
# User2 follows group
follow(self.user2, self.group)
# User1 comments on group
action.send(self.user1, verb="commented on", target=self.group)
comment = Comment.objects.get_or_create(
user=self.user1,
content_type=ContentType.objects.get_for_model(self.group),
object_pk=self.group.pk,
comment="Sweet Group!",
site=Site.objects.get_current(),
)[0]
# Group responds to comment
action.send(self.group, verb="responded to", target=comment)
self.client = Client()
def socialregistration_userdata(request, form_class=UserDataForm,
template_name='socialregistration/userdata.html', extra_context=None):
context = {}
if 'socialregistration_profile' in request.session:
profile = request.session['socialregistration_profile']
user = request.session['socialregistration_user']
elif request.user.is_authenticated():
if request.user.facebookprofile_set.count():
profile = request.user.facebookprofile_set.all()[0]
elif request.user.twitterprofile_set.count():
profile = request.user.twitterprofile_set.all()[0]
if request.user.gfcprofile_set.count():
profile = request.user.gfcprofile_set.all()[0]
user = request.user
else:
return http.HttpResponseRedirect(urlresolvers.reverse(
'acct_signup'))
if request.method == 'POST':
form = form_class(request.POST)
if form.is_valid():
request.session['socialregistration_userdata'] = form.cleaned_data
user = request.session['socialregistration_user']
profile = request.session['socialregistration_profile']
userdata = request.session['socialregistration_userdata']
user.first_name = userdata.get('first_name', '')
user.last_name = userdata.get('last_name', '')
user.email = userdata.get('email', '')
user_slug = defaultfilters.slugify('%s %s' % (
user.first_name,
user.last_name
))
if User.objects.filter(username=user_slug).count() > 0:
i = 1
user_slug_test = user_slug + unicode(i)
while User.objects.filter(username=user_slug_test).count() >0:
i += 1
user_slug_test = user_slug + str(i)
user.username = user_slug_test
else:
user.username = user_slug
user.save()
user.playlistprofile.user_location = userdata.get('location', '')
user.playlistprofile.avatar_url = userdata.get('avatar_url', '')
user.playlistprofile.user = user
user.playlistprofile.save()
profile.user = user
profile.avatar_url = userdata.get('avatar_url', '')
profile.url = userdata.get('url', '')
profile.nick = userdata.get('nick', '')
profile.save()
if 'socialregistration_user' in request.session:
del request.session['socialregistration_user']
if 'socialregistration_profile' in request.session:
del request.session['socialregistration_profile']
if 'socialregistration_userdata' in request.session:
del request.session['socialregistration_userdata']
user = profile.authenticate()
auth.login(request, user)
request.user = user
if not user:
logger.info('NOT USER IN REGISTRATION!')
return shortcuts.render_to_response('socialregistration/fail.html', context,
context_instance=template.RequestContext(request))
friends = []
conditions = []
for facebookprofile in user.facebookprofile_set.all():
print facebookprofile
friendlist = request.facebook.graph.request(request.facebook.user['uid'] + '/friends')
facebook_ids = [x['id'] for x in friendlist['data']]
conditions.append(Q(facebookprofile__uid__in=facebook_ids))
if user.twitterprofile_set.count():
client = OAuthTwitter(
request, settings.TWITTER_CONSUMER_KEY,
settings.TWITTER_CONSUMER_SECRET_KEY,
settings.TWITTER_REQUEST_TOKEN_URL,
)
for twitterprofile in user.twitterprofile_set.all():
res = simplejson.loads(client.query('http://api.twitter.com/1/statuses/friends.json'))
twitter_ids = [x['id'] for x in res]
conditions.append(Q(twitterprofile__twitter_id__in=twitter_ids))
for gfcprofile in user.gfcprofile_set.all():
container = gfc.my_opensocial_container(request)
res = container.fetch_friends()
gfc_ids = [x['id'] for x in res]
conditions.append(Q(gfcprofile__uid__in=gfc_ids))
for u in User.objects.filter(reduce(operator.or_,conditions)):
follow(user, u)
return http.HttpResponseRedirect(urlresolvers.reverse('socialregistration_friends'))
else:
if profile.__class__.__name__ == 'FacebookProfile':
upstream = request.facebook.graph.request(request.facebook.user['uid'])
initial = {
'first_name': upstream.get('first_name', ''),
'last_name': upstream.get('last_name', ''),
'email': upstream.get('email', ''),
'avatar_url': 'http://graph.facebook.com/%s/picture' % request.facebook.user['uid'],
'nick': '%s %s' % (upstream.get('first_name', ''), upstream.get('last_name', '')),
'url': upstream.get('link', ''),
}
if 'location' in upstream:
initial['location'] = upstream['location']['name']
else:
initial['location'] = ''
elif profile.__class__.__name__ == 'TwitterProfile':
client = OAuthTwitter(
request, settings.TWITTER_CONSUMER_KEY,
settings.TWITTER_CONSUMER_SECRET_KEY,
settings.TWITTER_REQUEST_TOKEN_URL,
)
upstream = client.get_user_info()
initial = {
'first_name': '',
'last_name': upstream.get('name', ''),
'location': upstream.get('location', ''),
'email': '',
'avatar_url': upstream['profile_image_url'],
'url': 'http://twitter.com/%s' % upstream['screen_name'],
'nick': upstream['screen_name'],
}
elif profile.__class__.__name__ == 'GfcProfile':
container = gfc.my_opensocial_container(request)
req = opensocial.FetchPersonRequest(profile.uid, ['@all'])
upstream = container.send_request(req)
initial = {
'first_name': upstream.get('displayName', ''),
'last_name': '',
'location': '',
'email': '',
'avatar_url': upstream['thumbnailUrl'],
'url': upstream['urls'][0]['value'],
'nick': upstream['displayName'],
}
form = form_class(initial=initial)
context['form'] = form
context['step'] = 'userdata'
context.update(extra_context or {})
return shortcuts.render_to_response(template_name, context,
context_instance=template.RequestContext(request))
