def get_context_data(self, **kwargs):
context = super(UserCollectionsBase, self).get_context_data(**kwargs)
try:
user = UserProfile.objects.get(
user__username=self.kwargs['username']).user
except UserProfile.DoesNotExist:
raise Http404
image_ct = ContentType.objects.get_for_model(Image)
context['requested_user'] = user
context['public_images_no'] = Image.objects.filter(user=user).count()
context['wip_images_no'] = Image.wip.filter(user=user).count()
try:
context['mobile_header_background'] = \
UserService(user).get_public_images().first().thumbnail('regular', None, sync=True) \
if UserService(user).get_public_images().exists() \
else None
except IOError:
context['mobile_header_background'] = None
# TODO: stats
return context
def test_get_case_insensitive_one(self):
user = Generators.user(username="******")
self.assertEqual(user.username,
UserService.get_case_insensitive("one").username)
self.assertEqual(user.username,
UserService.get_case_insensitive("onE").username)
def test_get_wip_images(self):
user = Generators.user()
image = Generators.image(user=user)
wip = Generators.image(user=user, is_wip=True)
self.assertFalse(image in UserService(user).get_wip_images())
self.assertTrue(wip in UserService(user).get_wip_images())
def test_get_corrupted_images(self):
user = Generators.user()
non_corrupted = Generators.image(user=user)
corrupted = Generators.image(user=user, corrupted=True)
self.assertFalse(non_corrupted in UserService(user).get_corrupted_images())
self.assertTrue(corrupted in UserService(user).get_corrupted_images())
def test_get_deleted_images(self):
user = Generators.user()
image = Generators.image(user=user)
deleted = Generators.image(user=user)
deleted.delete()
self.assertFalse(image in UserService(user).get_deleted_images())
self.assertTrue(deleted in UserService(user).get_deleted_images())
def test_can_unlike_anon(self, is_authenticated):
image = Generators.image()
like = Generators.like(image)
is_authenticated.return_value = False
self.assertFalse(UserService(like.user).can_unlike(image))
self.assertEqual("ANONYMOUS",
UserService(like.user).can_unlike_reason(image))
def test_get_public_images(self):
user = Generators.user()
image = Generators.image(user=user)
wip = Generators.image(user=user, is_wip=True)
corrupted = Generators.image(user=user, corrupted=True)
self.assertTrue(image in UserService(user).get_public_images())
self.assertFalse(wip in UserService(user).get_public_images())
self.assertTrue(corrupted in UserService(user).get_public_images())
def test_can_unlike_never_liked(self, is_authenticated):
is_authenticated.return_value = True
image = Generators.image()
user = Generators.user()
self.assertFalse(UserService(user).can_unlike(image))
self.assertEqual("NEVER_LIKED",
UserService(user).can_unlike_reason(image))
def test_get_users_in_group_sample_one_user(self):
group = Group.objects.create(name='test_group')
user = Generators.user()
user.groups.add(group)
self.assertEqual(
1, len(UserService.get_users_in_group_sample(group.name, 10)))
self.assertEqual(
1, len(UserService.get_users_in_group_sample(group.name, 50)))
self.assertEqual(
1, len(UserService.get_users_in_group_sample(group.name, 100)))
def test_shadow_bans(self):
a = Generators.user()
b = Generators.user()
self.assertFalse(UserService(a).shadow_bans(b))
self.assertFalse(UserService(b).shadow_bans(a))
a.userprofile.shadow_bans.add(b.userprofile)
self.assertTrue(UserService(a).shadow_bans(b))
self.assertFalse(UserService(b).shadow_bans(a))
def image_post_save(sender, instance, created, **kwargs):
# type: (object, Image, bool, object) -> None
if created:
instance.user.userprofile.premium_counter += 1
instance.user.userprofile.save(keep_deleted=True)
if not instance.user.userprofile.exclude_from_competitions:
instance.designated_iotd_submitters.add(
*UserService.get_users_in_group_sample(
'iotd_submitters', settings.
IOTD_DESIGNATED_SUBMITTERS_PERCENTAGE, instance.user))
instance.designated_iotd_reviewers.add(
*UserService.get_users_in_group_sample(
'iotd_reviewers', settings.
IOTD_DESIGNATED_REVIEWERS_PERCENTAGE, instance.user))
if not instance.is_wip:
if not instance.skip_notifications:
push_notification_for_new_image.apply_async(args=(
instance.user.pk,
instance.pk,
))
if instance.moderator_decision == 1:
add_story(instance.user,
verb='VERB_UPLOADED_IMAGE',
action_object=instance)
if Image.all_objects.filter(user=instance.user).count() == 1:
push_notification(
[instance.user], None, 'congratulations_for_your_first_image',
{
'BASE_URL': settings.BASE_URL,
'PREMIUM_MAX_IMAGES_FREE':
settings.PREMIUM_MAX_IMAGES_FREE,
'url': reverse_url('image_detail',
args=(instance.get_id(), ))
})
if not instance.uploader_in_progress:
groups = instance.user.joined_group_set.filter(autosubmission=True)
for group in groups:
if instance.is_wip:
group.images.remove(instance)
else:
group.images.add(instance)
if instance.user.userprofile.updated < datetime.datetime.now(
) - datetime.timedelta(minutes=5):
instance.user.save()
try:
instance.user.userprofile.save(keep_deleted=True)
except UserProfile.DoesNotExist:
pass
def test_can_unlike_too_late(self, is_authenticated):
is_authenticated.return_value = True
image = Generators.image()
like = Generators.like(image)
like.created_on = timezone.now() - timedelta(hours=2)
like.save()
self.assertFalse(UserService(like.user).can_unlike(image))
self.assertEqual("TOO_LATE",
UserService(like.user).can_unlike_reason(image))
def test_get_users_in_group_sample_many_users(self):
group = Group.objects.create(name='test_group')
for i in range(100):
user = Generators.user()
user.groups.add(group)
self.assertEqual(
10, len(UserService.get_users_in_group_sample(group.name, 10)))
self.assertEqual(
50, len(UserService.get_users_in_group_sample(group.name, 50)))
self.assertEqual(
100, len(UserService.get_users_in_group_sample(group.name, 100)))
def test_get_case_insensitive_two(self):
user1 = Generators.user(username="******")
user2 = Generators.user(username="******")
self.assertEqual(
user1.username,
UserService.get_case_insensitive(user1.username).username)
self.assertEqual(
user2.username,
UserService.get_case_insensitive(user2.username).username)
with self.assertRaises(User.DoesNotExist):
UserService.get_case_insensitive("One")
def test_can_like_post_same_user(self, get_scores, is_free):
user = Generators.user()
post = Generators.forum_post(user=user)
is_free.return_value = False
self.assertFalse(UserService(user).can_like(post))
def test_can_like_image_anon(self, is_authenticated):
user = Generators.user()
image = Generators.image()
is_authenticated.return_value = False
self.assertFalse(UserService(user).can_like(image))
def test_can_like_image_superuser(self):
user = Generators.user()
image = Generators.image()
user.is_superuser = True
user.save()
self.assertTrue(UserService(user).can_like(image))
def post(self, request, *args, **kwargs):
count = UserService(request.user).empty_trash()
messages.success(
request,
_("%(number)s image(s) deleted from your trash." %
{"number": count}))
return self.render_json_response({"status": "OK"})
def test_get_corrupted_images_when_non_final_revision_is_corrupted(self):
user = Generators.user()
image = Generators.image(user=user, is_final=False)
Generators.imageRevision(image=image, is_final=False, corrupted=True)
Generators.imageRevision(image=image, is_final=True, label='C')
self.assertFalse(image in UserService(user).get_corrupted_images())
def image_post_delete(sender, instance, **kwargs):
def decrease_counter(user):
user.userprofile.premium_counter -= 1
with transaction.atomic():
user.userprofile.save(keep_deleted=True)
ImageIndex().remove_object(instance)
UserService(instance.user).clear_gallery_image_list_cache()
try:
if instance.uploaded > datetime.datetime.now() - relativedelta(
hours=24):
decrease_counter(instance.user)
elif is_lite(instance.user):
usersub = premium_get_valid_usersubscription(instance.user)
usersub_created = usersub.expires - relativedelta(years=1)
dt = instance.uploaded.date() - usersub_created
if dt.days >= 0:
decrease_counter(instance.user)
elif is_lite_2020(instance.user) or \
is_premium(instance.user) or \
is_premium_2020(instance.user) or \
is_any_ultimate(instance.user):
decrease_counter(instance.user)
except IntegrityError:
# Possibly the user is being deleted
pass
def test_can_like_image_ok(self, get_scores, is_free):
user = Generators.user()
image = Generators.image()
is_free.return_value = False
self.assertTrue(UserService(user).can_like(image))
def test_can_like_comment_same_user(self, get_scores, is_free):
user = Generators.user()
comment = NestedCommentsGenerators.comment(author=user)
is_free.return_value = False
self.assertFalse(UserService(user).can_like(comment))
def test_can_like_image_index_zero(self, get_scores, is_free):
get_scores.return_value = {'user_scores_index': 0}
is_free.return_value = True
user = Generators.user()
image = Generators.image()
self.assertTrue(UserService(user).can_like(image))
def test_get_corrupted_images_when_corrupted_revision_is_deleted(self):
user = Generators.user()
image = Generators.image(user=user)
revision = Generators.imageRevision(image=image, is_final=False, corrupted=True)
revision.delete()
self.assertFalse(image in UserService(user).get_corrupted_images())
def test_can_like_image_index_too_low(self, get_scores, is_free):
user = Generators.user()
image = Generators.image()
is_free.return_value = True
get_scores.return_value = {'user_scores_index': .5}
self.assertFalse(UserService(user).can_like(image))
def test_get_users_in_group_sample_with_exclude(self):
group = Group.objects.create(name='test_group')
user = Generators.user()
user.groups.add(group)
self.assertEqual(
0, len(UserService.get_users_in_group_sample(group.name, 10,
user)))
def test_can_like_image_same_user(self, get_scores, is_free):
get_scores.return_value = {'user_scores_index': 0}
is_free.return_value = False
user = Generators.user()
image = Generators.image(user=user)
self.assertFalse(UserService(user).can_like(image))
def test_can_like_comment_ok(self, get_scores, is_free):
get_scores.return_value = {'user_scores_index': 0}
is_free.return_value = False
user = Generators.user()
comment = NestedCommentsGenerators.comment()
self.assertTrue(UserService(user).can_like(comment))
def test_can_like_post_ok(self, get_scores, is_free):
get_scores.return_value = {'user_scores_index': 0}
is_free.return_value = False
user = Generators.user()
post = Generators.forum_post()
self.assertTrue(UserService(user).can_like(post))
def shadow_ban_applies(notice_type, recipient, context):
from astrobin_apps_users.services import UserService
if notice_type.label == 'received_email':
message_sender = context.get('message').sender
if UserService(recipient).shadow_bans(message_sender):
return True
return False
