#99 use classed base registration view instead of method

core/account_urls.py

@@ -4,9 +4,11 @@
 import core.views.settings_views
 import core.views.trigger_parsing_views
 
+from core.views.account_views import OFMUserCreate
+
 app_name = 'account'
 urlpatterns = [
-    url(r'^register/?$', core.views.account_views.register_view, name='register'),
+    url(r'^register/?$', OFMUserCreate.as_view(), name='register'),
     url(r'^login/?$', core.views.account_views.login_view, name='login'),
     url(r'^$', core.views.account_views.account_view, name='home'),
     url(r'^logout/?$', core.views.account_views.logout_view, name='logout'),

core/forms/registration_form.py

@@ -0,0 +1,9 @@
+from django.forms import ModelForm
+
+from users.models import OFMUser
+
+
+class RegistrationForm(ModelForm):
+    class Meta:
+        model = OFMUser
+        fields = ['username', 'password', 'email', 'ofm_username', 'ofm_password']

core/tests/unit/views/test_registration_views.py

@@ -1,5 +1,6 @@
 from django.core.urlresolvers import reverse
 from django.test import TestCase
+from django.urls import reverse_lazy
 
 from users.models import OFMUser
 
@@ -28,44 +29,44 @@ def test_register_with_existing_username(self):
                                     {'username': 'temporary', 'password': '1234', 'password2': '1234',
                                      'email': '[email protected]',
                                      'ofm_username': 'abc', 'ofm_password': 'def', 'ofm_password2': 'def'})
-        self.assertEqual(response.status_code, 302)
-        self.assertRedirects(response, reverse('core:account:register'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTemplateUsed(response, 'core/account/register.html')
         self.assertFalse(response.wsgi_request.user.is_authenticated())
 
     def test_register_with_unmatching_passwords(self):
         response = self.client.post(reverse('core:account:register'),
                                     {'username': 'new', 'password': '1234', 'password2': '12345',
                                      'email': '[email protected]',
                                      'ofm_username': 'abc', 'ofm_password': 'def', 'ofm_password2': 'def'})
-        self.assertEqual(response.status_code, 302)
-        self.assertRedirects(response, reverse('core:account:register'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTemplateUsed(response, 'core/account/register.html')
         self.assertFalse(response.wsgi_request.user.is_authenticated())
 
     def test_register_with_unmatching_ofm_passwords(self):
         response = self.client.post(reverse('core:account:register'),
                                     {'username': 'new', 'password': '1234', 'password2': '1234',
                                      'email': '[email protected]',
                                      'ofm_username': 'abc', 'ofm_password': 'def', 'ofm_password2': 'ghj'})
-        self.assertEqual(response.status_code, 302)
-        self.assertRedirects(response, reverse('core:account:register'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTemplateUsed(response, 'core/account/register.html')
         self.assertFalse(response.wsgi_request.user.is_authenticated())
 
     def test_register_with_already_registered_ofm_username(self):
         response = self.client.post(reverse('core:account:register'),
                                     {'username': 'new', 'password': '1234', 'password2': '1234',
                                      'email': '[email protected]',
                                      'ofm_username': 'ofm', 'ofm_password': 'def', 'ofm_password2': 'def'})
-        self.assertEqual(response.status_code, 302)
-        self.assertRedirects(response, reverse('core:account:register'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTemplateUsed(response, 'core/account/register.html')
         self.assertFalse(response.wsgi_request.user.is_authenticated())
 
     def test_register_with_already_registered_email(self):
         response = self.client.post(reverse('core:account:register'),
                                     {'username': 'new', 'password': '1234', 'password2': '1234',
                                      'email': '[email protected]',
                                      'ofm_username': 'new', 'ofm_password': 'def', 'ofm_password2': 'def'})
-        self.assertEqual(response.status_code, 302)
-        self.assertRedirects(response, reverse('core:account:register'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTemplateUsed(response, 'core/account/register.html')
         self.assertFalse(response.wsgi_request.user.is_authenticated())
 
     def test_register_when_already_logged_in(self):

core/views/account_views.py

@@ -1,60 +1,51 @@
 from django.contrib import messages
 from django.contrib.auth import authenticate, login, logout
 from django.shortcuts import render, redirect
+from django.urls import reverse_lazy
+from django.views.generic import CreateView
 
+from core.forms.registration_form import RegistrationForm
 from core.localization.messages import PASSWORDS_UNEQUAL, OFM_PASSWORDS_UNEQUAL, NOT_LOGGED_IN, \
     OFM_USERNAME_ALREADY_EXISTS, USERNAME_ALREADY_EXISTS, EMAIL_ALREADY_EXISTS, ALREADY_LOGGED_IN, \
     ACCOUNT_CREATED, LOGGED_OUT, USERNAME_OR_PASSWORD_INVALID, LOGIN_IMPOSSIBLE_ACCOUNT_IS_DEACTIVATED, \
     LOGIN_SUCCESSFUL
 from users.models import OFMUser
 
 
-def register_view(request):
-    if request.user.is_authenticated():
-        messages.error(request, ALREADY_LOGGED_IN)
-        return render(request, 'core/account/home.html')
-    if request.POST:
-        username = request.POST.get('username')
-        email = request.POST.get('email')
-        password = request.POST.get('password')
-        password2 = request.POST.get('password2')
-        ofm_username = request.POST.get('ofm_username')
-        ofm_password = request.POST.get('ofm_password')
-        ofm_password2 = request.POST.get('ofm_password2')
-
-        if OFMUser.objects.filter(email=email).exists():
-            messages.error(request, EMAIL_ALREADY_EXISTS)
-            return redirect('core:account:register')
-
-        if OFMUser.objects.filter(username=username).exists():
-            messages.error(request, USERNAME_ALREADY_EXISTS)
-            return redirect('core:account:register')
-
-        if password != password2:
-            messages.error(request, PASSWORDS_UNEQUAL)
-            return redirect('core:account:register')
-
-        if OFMUser.objects.filter(ofm_username=ofm_username).exists():
-            messages.error(request, OFM_USERNAME_ALREADY_EXISTS)
-            return redirect('core:account:register')
-
-        if ofm_password != ofm_password2:
-            messages.error(request, OFM_PASSWORDS_UNEQUAL)
-            return redirect('core:account:register')
-
-        OFMUser.objects.create_user(
-            username=username,
-            email=email,
-            password=password,
-            ofm_username=ofm_username,
-            ofm_password=ofm_password,
-        )
-
-        messages.success(request, ACCOUNT_CREATED)
-        return redirect('core:account:login')
-
-    else:
-        return render(request, 'core/account/register.html')
+class OFMUserCreate(CreateView):
+    form_class = RegistrationForm
+    success_url = reverse_lazy('core:account:login')
+    template_name = 'core/account/register.html'
+
+    def form_valid(self, form):
+        if self.request.user.is_authenticated():
+            messages.error(self.request, ALREADY_LOGGED_IN)
+            return render(self.request, 'core/account/home.html')
+
+        if self.is_registration_form_invalid(form):
+            return super(OFMUserCreate, self).form_invalid(form)
+
+        messages.success(self.request, ACCOUNT_CREATED)
+        return super(OFMUserCreate, self).form_valid(form)
+
+    def is_registration_form_invalid(self, form):
+        form_invalid = False
+        if OFMUser.objects.filter(username=form.data['username']).exists():
+            messages.error(self.request, USERNAME_ALREADY_EXISTS)
+            form_invalid = True
+        if OFMUser.objects.filter(email=form.data['email']).exists():
+            messages.error(self.request, EMAIL_ALREADY_EXISTS)
+            form_invalid = True
+        if form.data['password'] != form.data['password2']:
+            messages.error(self.request, PASSWORDS_UNEQUAL)
+            form_invalid = True
+        if OFMUser.objects.filter(ofm_username=form.data['ofm_username']).exists():
+            messages.error(self.request, OFM_USERNAME_ALREADY_EXISTS)
+            form_invalid = True
+        if form.data['ofm_password'] != form.data['ofm_password2']:
+            messages.error(self.request, OFM_PASSWORDS_UNEQUAL)
+            form_invalid = True
+        return form_invalid
 
 
 def login_view(request):