def test_get_test_login(self):
user_count = User.objects.count()
socialuser_count = len(list(SocialUser.all()))
response = self.client.get(reverse('sociallogin:test_login'),
{'vendorId': '1234'})
self.assertEqual(response.status_code, 200)
response_content = response.content
if six.PY3:
response_content = str(response_content, encoding='utf8')
json_content = json.loads(response_content)
self.assertIn('authenticated', json_content)
self.assertEqual(json_content['authenticated'], True)
self.assertEqual(User.objects.count(), user_count + 1)
self.assertEqual(len(list(SocialUser.all())), socialuser_count + 1)
self.assertIn('preferencesInitialized', json_content)
self.assertIn('token', json_content)
token = json_content['token']
# login again
response = self.client.get(reverse('sociallogin:test_login'),
{'vendorId': '1234'})
self.assertEqual(response.status_code, 200)
response_content = response.content
if six.PY3:
response_content = str(response_content, encoding='utf8')
json_content = json.loads(response_content)
self.assertIn('authenticated', json_content)
self.assertEqual(json_content['authenticated'], True)
self.assertEqual(User.objects.count(), user_count + 1)
self.assertEqual(len(list(SocialUser.all())), socialuser_count + 1)
self.assertIn('token', json_content)
self.assertEqual(json_content['token'], token)
def test_get_combine(self):
user = User.objects.get(pk=3)
test_user = User.objects.get(pk=4)
socialuser = SocialUser.get(1)
test_socialuser = SocialUser.get(2)
self.assertEqual(test_user.username, 'abcd')
self.assertEqual(socialuser.user_id, 3)
self.assertEqual(test_socialuser.user_id, 4)
videos_user, context_user = SocialUser.next_videos(user.id)
videos_test_user, context_test_user = SocialUser.next_videos(
test_user.id)
self.assertEqual(sorted([video.name for video in videos_user]), [u'B'])
self.assertEqual(sorted([video.name for video in videos_test_user]),
[u'A'])
# combine
response = self.client.get(reverse('sociallogin:combine_accounts'),
{'vendorId': 'abcd'})
self.assertEqual(response.status_code, 201)
self.assertTrue(test_user.username.endswith('abcd'))
self.assertEqual(socialuser.user_id, 3)
self.assertEqual(test_socialuser.user_id, 3)
videos_user, context_user = SocialUser.next_videos(user.id)
self.assertEqual(sorted([video.name for video in videos_user]), [u'C'])
# do it again
response = self.client.get(reverse('sociallogin:combine_accounts'),
{'vendorId': 'abcd'})
self.assertEqual(response.status_code, 204)
def create_neo_socialuser(user_id):
user = SocialUser()
with NeoGraph() as graph:
tx = graph.begin()
user.id = tx.run('MATCH (n:{}) RETURN COUNT(n)+1'.format(
SocialUser.__primarylabel__)).evaluate()
user.user_id = user_id
tx.create(user)
tx.commit()
def registration(request):
print "registration"
if request.POST:
form = RegistrationForm(data=request.POST)
if form.is_valid():
user = form.save()
user.set_password(user.password)
user.save()
social_user = SocialUser(user=user)
social_user.save()
return render(request, 'common/login.html', {'form': form})
else:
print "request was not POST"
form = RegistrationForm()
return render(request, 'registration/registration.html', {'form': form})
def landingpage(request):
user_ids = [s.user_id for s in SocialUser.all()]
return render(
request, 'landingpage.html', {
'video_count':
len(list(Video.all())),
'group_count':
len(list(Group.all())),
'socialuser_count':
len(set(user_ids)),
'socialuser_all_count':
len(user_ids),
'overall_suggestions_count':
statistics.overall_suggestions_count(),
'overall_suggestions_user_count':
statistics.overall_suggestions_user_count(),
'suggestions_user_count':
statistics.suggestions_user_count(),
'overall_watch_count':
statistics.overall_watch_count(),
'overall_watch_user_count':
statistics.overall_watch_user_count(),
'watch_user_count':
statistics.watch_user_count(),
'overall_dismiss_count':
statistics.overall_dismiss_count(),
'overall_dismiss_user_count':
statistics.overall_dismiss_user_count(),
'dismiss_user_count':
statistics.dismiss_user_count(),
'user_watches':
statistics.user_watches(),
})
def get(self, request):
vendor_id = request.GET.get('vendorId')
if vendor_id is None:
return HttpResponse(status=status.HTTP_400_BAD_REQUEST,
reason='No vendor id')
try:
vendor_user = User.objects.get(username=vendor_id)
except User.DoesNotExist:
return HttpResponse(status=status.HTTP_400_BAD_REQUEST,
reason='Invalid vendor id')
if vendor_user == request.user:
# you can't combine with yourself
return HttpResponse(status=status.HTTP_204_NO_CONTENT,
reason='Unable to combine')
socialuser = SocialUser.user_for_django_user(vendor_user.id)
socialuser.user_id = request.user.id
socialuser.save()
vendor_user.username = '******' % (
datetime.now().strftime('%Y%M%d-%H%m%S-%s'), vendor_user.username)
vendor_user.save()
request.user.username = vendor_id
request.user.save()
return Response(status=status.HTTP_201_CREATED)
def get(self, request):
rest_request = Request(request)
try:
user_token = TokenAuthentication().authenticate(rest_request)
if user_token is None:
raise AuthenticationFailed
user, token = user_token
except AuthenticationFailed:
try:
user_session = SessionAuthentication().authenticate(
rest_request)
if user_session is None:
raise AuthenticationFailed
user, _ = user_session
if not user.has_perm('base.consume_curriculum'):
raise AuthenticationFailed
token, _ = Token.objects.get_or_create(user=user)
except AuthenticationFailed:
return JsonResponse({
'authenticated': False,
})
socialuser = SocialUser.user_for_django_user(user.id)
return JsonResponse({
'authenticated': True,
'preferencesInitialized': socialuser.has_initialized_preferences,
'token': token.key,
})
def get_context_data(self, **kwargs):
context = super(SocialUserUpdateView, self).get_context_data(**kwargs)
with NeoGraph() as graph:
pk = int(self.kwargs.get(self.pk_url_kwarg))
obj = SocialUser.select(graph, pk).first()
context['user_id'] = obj.user_id
return context
def test_get_detail_view(self):
user = SocialUser.get(1)
response = self.client.get(
reverse('socialusers:detail', kwargs={'pk': user.id}))
self.assertEqual(response.status_code, 200)
self.assertIn('socialuser', response.context)
self.assertEqual(response.context['socialuser'], user)
def test_get_list_view(self):
response = self.client.get(reverse('socialusers:list'))
self.assertEqual(response.status_code, 200)
self.assertIn('socialusers', response.context)
socialusers = list(response.context['socialusers'])
all_socialusers = SocialUser.all()
self.assertTrue(all(user in all_socialusers for user in socialusers))
def user_watches():
with NeoGraph() as graph:
cursor = graph.run('''
MATCH (u:SocialUser)
OPTIONAL MATCH (u)-[ww:WATCHED]->(vw:Video)
WHERE ww.progress > 0
WITH u, COUNT(DISTINCT vw) as watch_count
OPTIONAL MATCH (u)-[wd:WATCHED]->(vd:Video)
RETURN u, watch_count, COUNT(DISTINCT vd) as dismiss_count
ORDER BY watch_count DESC, dismiss_count DESC
''')
stats = [
{
'socialuser': SocialUser.wrap(d['u']),
'watch_count': d['watch_count'],
'dismiss_count': d['dismiss_count'],
# 'completed_surveys': Survey.objects.filter(completed_by=SocialUser.wrap(d['u']).user_id).count(),
} for d in cursor.data()
]
user_ids = set([stat['socialuser'].user_id for stat in stats])
completed_surveys_per_user = {
user.id: user.survey_count
for user in User.objects.filter(id__in=user_ids).annotate(
survey_count=Count('completed_surveys'))
}
for stat in stats:
stat['completed_surveys'] = completed_surveys_per_user.get(
stat['socialuser'].user_id, 0)
return stats
def get(self, request):
vendor_id = request.GET.get('vendorId')
if vendor_id is None:
return HttpResponse(status=status.HTTP_400_BAD_REQUEST,
reason='No vendor id')
try:
user = User.objects.get(username=vendor_id)
except User.DoesNotExist:
user = User.objects.create_user(vendor_id)
group = Group.objects.get(name='Social users')
user.groups.add(group)
user.save()
create_neo_socialuser(user.id)
token, _ = Token.objects.get_or_create(user=user)
socialuser = SocialUser.user_for_django_user(user.id)
return JsonResponse({
'authenticated': True,
'preferencesInitialized': socialuser.has_initialized_preferences,
'token': token.key,
})
def test_creation(self):
pre_socialuser_count = len(list(SocialUser.all()))
UserSocialAuth.objects.create(user_id=2)
post_socialuser_count = len(list(SocialUser.all()))
self.assertEqual(pre_socialuser_count+1, post_socialuser_count)