#706: ModerateAvatarForm and ModerateSignatureForm moved to serializers

misago/users/api/userendpoints/avatar.py

@@ -9,8 +9,8 @@ from django.utils.translation import ugettext as _
 from misago.conf import settings
 from misago.core.utils import format_plaintext_for_html
 from misago.users import avatars
-from misago.users.forms.moderation import ModerateAvatarForm
 from misago.users.models import AvatarGallery
+from misago.users.serializers import ModerateAvatarSerializer
 
 
 def avatar_endpoint(request, pk=None):
@@ -203,11 +203,11 @@ AVATAR_TYPES = {
 def moderate_avatar_endpoint(request, profile):
     if request.method == "POST":
         is_avatar_locked = profile.is_avatar_locked
-        form = ModerateAvatarForm(request.data, instance=profile)
-        if form.is_valid():
-            if form.cleaned_data['is_avatar_locked'] and not is_avatar_locked:
+        serializer = ModerateAvatarSerializer(profile, data=request.data)
+        if serializer.is_valid():
+            if serializer.validated_data['is_avatar_locked'] and not is_avatar_locked:
                 avatars.dynamic.set_avatar(profile)
-            form.save()
+            serializer.save()
 
             return Response({
                 'avatars': profile.avatars,
@@ -216,7 +216,7 @@ def moderate_avatar_endpoint(request, profile):
                 'avatar_lock_staff_message': profile.avatar_lock_staff_message,
             })
         else:
-            return Response(form.errors, status=status.HTTP_400_BAD_REQUEST)
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
     else:
         return Response({
             'is_avatar_locked': int(profile.is_avatar_locked),

misago/users/api/userendpoints/signature.py

@@ -6,8 +6,8 @@ from django.utils.translation import ugettext as _
 
 from misago.conf import settings
 from misago.core.utils import format_plaintext_for_html
-from misago.users.forms.options import EditSignatureForm
 from misago.users.signatures import is_user_signature_valid, set_user_signature
+from misago.users.serializers import EditSignatureSerializer
 
 
 def signature_endpoint(request):
@@ -55,14 +55,15 @@ def get_signature_options(user):
 
 
 def edit_signature(request, user):
-    form = EditSignatureForm(request.data, instance=user)
-    if form.is_valid():
+    serializer = EditSignatureSerializer(user, data=request.data)
+    if serializer.is_valid():
         set_user_signature(
-                request, user, form.cleaned_data['signature'])
+                request, user, serializer.validated_data['signature'])
         user.save(update_fields=[
             'signature', 'signature_parsed', 'signature_checksum'
         ])
         return get_signature_options(user)
     else:
-        return Response({'detail': form.non_field_errors()[0]},
-                        status=status.HTTP_400_BAD_REQUEST)
+        return Response({
+            'detail': serializer.errors['non_field_errors'][0]
+        }, status=status.HTTP_400_BAD_REQUEST)

misago/users/forms/moderation.py

@@ -1,69 +0,0 @@
-from datetime import timedelta
-
-from django import forms
-from django.contrib.auth import get_user_model
-from django.utils import timezone
-from django.utils.translation import ugettext_lazy as _
-from django.utils.translation import ungettext
-
-from misago.conf import settings
-from misago.core.forms import YesNoSwitch
-from misago.users.bans import ban_user
-
-
-class ModerateAvatarForm(forms.ModelForm):
-    is_avatar_locked = YesNoSwitch()
-    avatar_lock_user_message = forms.CharField(required=False)
-    avatar_lock_staff_message = forms.CharField(required=False)
-
-    class Meta:
-        model = get_user_model()
-        fields = [
-            'is_avatar_locked',
-            'avatar_lock_user_message',
-            'avatar_lock_staff_message',
-        ]
-
-
-class ModerateSignatureForm(forms.ModelForm):
-    signature = forms.CharField(
-        label=_("Signature contents"),
-        widget=forms.Textarea(attrs={'rows': 3}),
-        required=False)
-    is_signature_locked = YesNoSwitch(
-        label=_("Lock signature"),
-        help_text=_("Setting this to yes will stop user from "
-                    "making changes to his/her signature."))
-    signature_lock_user_message = forms.CharField(
-        label=_("User message"),
-        help_text=_("Optional message to user explaining "
-                    "why his/hers signature is locked."),
-        widget=forms.Textarea(attrs={'rows': 3}),
-        required=False)
-    signature_lock_staff_message = forms.CharField(
-        label=_("Staff message"),
-        help_text=_("Optional message to team members explaining "
-                    "why user signature is locked."),
-        widget=forms.Textarea(attrs={'rows': 3}),
-        required=False)
-
-    class Meta:
-        model = get_user_model()
-        fields = [
-            'signature',
-            'is_signature_locked',
-            'signature_lock_user_message',
-            'signature_lock_staff_message'
-        ]
-
-    def clean_signature(self):
-        data = self.cleaned_data['signature']
-
-        length_limit = settings.signature_length_max
-        if len(data) > length_limit:
-            raise forms.ValidationError(ungettext(
-                "Signature can't be longer than %(limit)s character.",
-                "Signature can't be longer than %(limit)s characters.",
-                length_limit) % {'limit': length_limit})
-
-        return data

misago/users/serializers/__init__.py

@@ -1,4 +1,5 @@
 from .ban import *
+from .moderation import *
 from .options import *
 from .rank import *
 from .user import *

misago/users/serializers/moderation.py

@@ -0,0 +1,44 @@
+from rest_framework import serializers
+
+from django.contrib.auth import get_user_model
+from django.utils.translation import ungettext
+
+from misago.conf import settings
+
+
+UserModel = get_user_model()
+
+__all__ = [
+    'ModerateAvatarSerializer',
+    'ModerateSignatureSerializer',
+]
+
+class ModerateAvatarSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = UserModel
+        fields = [
+            'is_avatar_locked',
+            'avatar_lock_user_message',
+            'avatar_lock_staff_message',
+        ]
+
+
+class ModerateSignatureSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = UserModel
+        fields = [
+            'signature',
+            'is_signature_locked',
+            'signature_lock_user_message',
+            'signature_lock_staff_message'
+        ]
+
+    def validate_signature(self, value):
+        length_limit = settings.signature_length_max
+        if len(value) > length_limit:
+            raise forms.ValidationError(ungettext(
+                "Signature can't be longer than %(limit)s character.",
+                "Signature can't be longer than %(limit)s characters.",
+                length_limit) % {'limit': length_limit})
+
+        return value

misago/users/tests/test_user_avatar_api.py

@@ -291,13 +291,6 @@ class UserAvatarModerationTests(AuthenticatedUserTestCase):
         response = self.client.get(self.link)
         self.assertContains(response, "can't moderate avatars", status_code=403)
 
-        override_acl(self.user, {
-            'can_moderate_avatars': 0,
-        })
-
-        response = self.client.post(self.link)
-        self.assertContains(response, "can't moderate avatars", status_code=403)
-
     def test_moderate_avatar(self):
         """moderate avatar"""
         override_acl(self.user, {
@@ -358,6 +351,61 @@ class UserAvatarModerationTests(AuthenticatedUserTestCase):
         self.assertEqual(response.status_code, 200)
 
         other_user = UserModel.objects.get(pk=self.other_user.pk)
+        self.assertFalse(other_user.is_avatar_locked)
+        self.assertIsNone(other_user.avatar_lock_user_message)
+        self.assertIsNone(other_user.avatar_lock_staff_message)
+
+        options = response.json()
+        self.assertEqual(
+            options['avatars'], other_user.avatars)
+        self.assertEqual(
+            options['is_avatar_locked'], other_user.is_avatar_locked)
+        self.assertEqual(
+            options['avatar_lock_user_message'], other_user.avatar_lock_user_message)
+        self.assertEqual(
+            options['avatar_lock_staff_message'], other_user.avatar_lock_staff_message)
+
+        override_acl(self.user, {
+            'can_moderate_avatars': 1,
+        })
+
+        response = self.client.post(self.link, json.dumps({
+            'is_avatar_locked': True,
+            'avatar_lock_user_message': '',
+            'avatar_lock_staff_message': '',
+        }),
+        content_type="application/json")
+        self.assertEqual(response.status_code, 200)
+
+        other_user = UserModel.objects.get(pk=self.other_user.pk)
+        self.assertTrue(other_user.is_avatar_locked)
+        self.assertEqual(other_user.avatar_lock_user_message, '')
+        self.assertEqual(other_user.avatar_lock_staff_message, '')
+
+        options = response.json()
+        self.assertEqual(
+            options['avatars'], other_user.avatars)
+        self.assertEqual(
+            options['is_avatar_locked'], other_user.is_avatar_locked)
+        self.assertEqual(
+            options['avatar_lock_user_message'], other_user.avatar_lock_user_message)
+        self.assertEqual(
+            options['avatar_lock_staff_message'], other_user.avatar_lock_staff_message)
+
+        override_acl(self.user, {
+            'can_moderate_avatars': 1,
+        })
+
+        response = self.client.post(self.link, json.dumps({
+            'is_avatar_locked': False,
+        }),
+        content_type="application/json")
+        self.assertEqual(response.status_code, 200)
+
+        other_user = UserModel.objects.get(pk=self.other_user.pk)
+        self.assertFalse(other_user.is_avatar_locked)
+        self.assertEqual(other_user.avatar_lock_user_message, '')
+        self.assertEqual(other_user.avatar_lock_staff_message, '')
 
         options = response.json()
         self.assertEqual(