Set Django to 4.0.1, add DB migrations

Now that we're somewhat Django4 compatible it's time to advertise our
newfound skill! Not all functionality has been tested, but it is
starting again.

api/admin.py

@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.

api/apps.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class ApiConfig(AppConfig):
+    name = 'api'

api/models.py

@@ -0,0 +1,3 @@
+from django.db import models
+
+# Create your models here.

api/serializers.py

@@ -0,0 +1,98 @@
+from django import forms
+from django.utils import timezone
+from rest_framework import serializers
+
+from contest.models import Contest, Band, Frequency, QSO, EntryCategory, User, ShadowCall, Reference
+from contest.validators import CallLogValidator
+
+
+class ContestSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Contest
+        # FIXME: add callQrg
+        fields = ('id', 'shortName', 'deadline', 'qsoStartTime', 'qsoEndTime', 'callQrg')
+
+
+class BandSerializer(serializers.ModelSerializer):
+    # contest = ContestSerializer()
+
+    class Meta:
+        model = Band
+        fields = ('id', 'name', 'contest')
+
+
+class FrequencySerializer(serializers.ModelSerializer):
+    # band = BandSerializer()
+
+    class Meta:
+        model = Frequency
+        fields = ('id', 'channel', 'qrg', 'band', 'note')
+
+
+class EntryCategorySerializer(serializers.ModelSerializer):
+    class Meta:
+        model = EntryCategory
+        fields = ('id', 'name', 'description')
+
+
+class ReferenceSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Reference
+        fields = ('id', 'name', 'description')
+
+
+class UserSerializer(serializers.ModelSerializer):
+    # ref = ReferenceSerializer()
+    # cat = EntryCategorySerializer()
+
+    class Meta:
+        model = User
+        fields = ('id', 'ref', 'cat', 'location', 'opName', 'regTime', 'dncall', 'qrv2m', 'qrv70cm', 'extra2m70cm')
+        read_only_fields = ('ref', 'location', 'regTime')
+
+    def validate(self, attrs):
+        contest = Contest.get_current_contest()
+        if contest.deadline < timezone.now():
+            raise serializers.ValidationError("The deadline for changing the entry category has passed")
+
+        return attrs
+
+
+class QSOSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = QSO
+        fields = ('id', 'owner', 'time', 'ownNo', 'band', 'call', 'reportTX', 'reportRX', 'refStr', 'remarks')
+        read_only_fields = ('owner',)
+
+    def validate_call(self, value):
+        val = value.strip().upper()
+        try:
+            CallLogValidator()(val)
+        except forms.ValidationError as e:
+            raise serializers.ValidationError({'errors': e.error_list})
+
+        return val
+
+    def validate(self, attrs):
+        ownNo = attrs['ownNo']
+        try:
+            o = QSO.objects.get(owner=self.context['request'].user, ownNo=ownNo)
+            if not (self.instance and self.instance.id and self.instance.id == o.id):
+                raise serializers.ValidationError("You already logged a QSO with the number %s" % ownNo)
+        except QSO.DoesNotExist:
+            pass
+
+        band = attrs.get('band')
+        if band:
+            if band.contest.deadline < timezone.now():
+                raise serializers.ValidationError("The deadline for logging and editing QSOs has passed")
+
+        return attrs
+
+
+class ShadowCallSerializer(serializers.ModelSerializer):
+    ref = ReferenceSerializer()
+
+    class Meta:
+        model = ShadowCall
+        fields = ('id', 'username', 'ref', 'location', 'opName', 'regTime')

api/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

api/urls.py

@@ -0,0 +1,20 @@
+from django.urls import include, path
+from rest_framework import routers
+
+from .views import ContestViewSet, BandViewSet, FrequencyViewSet, EntryCategoryViewSet, ReferenceViewSet, QSOViewSet, \
+    ShadowCallViewSet, UserProfileViewSet
+
+router = routers.DefaultRouter()
+router.register('contests', ContestViewSet)
+router.register('bands', BandViewSet)
+router.register('frequencies', FrequencyViewSet)
+router.register('entrycategories', EntryCategoryViewSet)
+router.register('references', ReferenceViewSet)
+router.register('qsos', QSOViewSet, basename='qso')
+router.register('shadowcalls', ShadowCallViewSet)
+router.register('profile', UserProfileViewSet, basename='profile')
+
+urlpatterns = [
+    path('', include(router.urls)),
+    path('api-auth/', include('rest_framework.urls', namespace='rest_framework')),
+]

api/views.py

@@ -0,0 +1,91 @@
+from rest_framework.permissions import IsAuthenticated, IsAdminUser
+from rest_framework import viewsets
+
+from .serializers import ContestSerializer, BandSerializer, FrequencySerializer, EntryCategorySerializer, \
+    ReferenceSerializer, QSOSerializer, ShadowCallSerializer, UserSerializer
+from contest.models import Contest, Band, Frequency, EntryCategory, Reference, QSO, ShadowCall, User
+
+
+class ContestViewSet(viewsets.ReadOnlyModelViewSet):
+    """
+    Resource to list and view all available contests. Use `current/` to get the current Contest.
+    """
+    queryset = Contest.objects.all()
+    serializer_class = ContestSerializer
+    filterset_fields = ['shortName']
+
+    def get_object(self):
+        lookup_url_kwarg = self.lookup_url_kwarg or self.lookup_field
+        if self.kwargs.get(lookup_url_kwarg) == "current":
+            obj = Contest.get_current_contest()
+            self.check_object_permissions(self.request, obj)
+        else:
+            obj = super(ContestViewSet, self).get_object()
+
+        return obj
+
+
+class BandViewSet(viewsets.ReadOnlyModelViewSet):
+    queryset = Band.objects.all()
+    serializer_class = BandSerializer
+    filterset_fields = ['name', 'contest']
+
+
+class FrequencyViewSet(viewsets.ReadOnlyModelViewSet):
+    queryset = Frequency.objects.all()
+    serializer_class = FrequencySerializer
+    filterset_fields = ['band', 'channel']
+
+
+class EntryCategoryViewSet(viewsets.ReadOnlyModelViewSet):
+    queryset = EntryCategory.objects.all()
+    serializer_class = EntryCategorySerializer
+    filterset_fields = ['name']
+
+
+class ReferenceViewSet(viewsets.ReadOnlyModelViewSet):
+    permission_classes = [IsAdminUser]
+    queryset = Reference.objects.all()
+    serializer_class = ReferenceSerializer
+    filterset_fields = ['name']
+
+
+class QSOViewSet(viewsets.ModelViewSet):
+    permission_classes = [IsAuthenticated]
+    serializer_class = QSOSerializer
+    filterset_fields = ['time', 'ownNo', 'band', 'call', 'refStr']
+
+    def get_queryset(self):
+        return QSO.objects.filter(owner=self.request.user)
+
+    def perform_create(self, serializer):
+        return serializer.save(owner=self.request.user)
+
+
+class UserProfileViewSet(viewsets.ModelViewSet):
+    """
+    Resource to view user-profiles, currently restricted to the current user's profile.
+    Use `me/` to get the profile of the currently logged in user.
+    """
+    permission_classes = [IsAuthenticated]
+    serializer_class = UserSerializer
+
+    def get_queryset(self):
+        return User.objects.filter(id=self.request.user.id)
+
+    def get_object(self):
+        lookup_url_kwarg = self.lookup_url_kwarg or self.lookup_field
+        if self.kwargs.get(lookup_url_kwarg) == "me":
+            obj = self.request.user
+            self.check_object_permissions(self.request, obj)
+        else:
+            obj = super(ContestViewSet, self).get_object()
+
+        return obj
+
+
+class ShadowCallViewSet(viewsets.ReadOnlyModelViewSet):
+    permission_classes = [IsAdminUser]
+    queryset = ShadowCall.objects.all()
+    serializer_class = ShadowCallSerializer
+    filterset_fields = ['username', 'ref']

clear_contest.py

@@ -1,8 +1,4 @@
 #!/usr/bin/env python
-from __future__ import print_function
-
-import datetime
-
 # prepare environment
 import sys
 sys.path.append("..")
@@ -11,12 +7,15 @@ os.environ.setdefault("DJANGO_SETTINGS_MODULE", "cqtu.settings")
 import django
 django.setup()
 
-confirm = raw_input("Do are you sure you want to clear all contest data? Answer with uppercase YES: ")
+confirm_msg = "Do are you sure you want to clear all contest data? Answer with uppercase YES: "
+try:
+    confirm = raw_input(confirm_msg)
+except NameError:
+    confirm = input(confirm_msg)
 
 if confirm != "YES":
-	print("Aborting")
+    print("Aborting")
-	sys.exit(1)
+    sys.exit(1)
-
 
 from contest.models import QSO, ShadowCall, Reference, User
 

contest/admin.py

@@ -1,9 +1,12 @@
 from django.contrib import admin
+
 from .models import Frequency, Band, Reference, QSO, User, Contest, ShadowCall, EntryCategory
 
 
 class UserAdmin(admin.ModelAdmin):
     list_display = ('username', 'dncall', 'qrv2m', 'qrv70cm', 'extra2m70cm')
+
+
 admin.site.register(User, UserAdmin)
 admin.site.register(QSO)
 admin.site.register(Band)

contest/apps.py

@@ -1,5 +1,3 @@
-from __future__ import unicode_literals
-
 from django.apps import AppConfig
 
 

contest/cbrparser.py

@@ -1,160 +1,171 @@
+import re
+
 from django.shortcuts import render
 from django.contrib.auth.decorators import login_required
-from .models import Contest, Band
 from django.utils import timezone
 from django.contrib import messages
 from django import forms
 from django.urls import reverse
 from django.http import HttpResponseRedirect
 
-
 from .forms import QSOFormWithTime
+from .models import Contest, Band
 
-import re
 
 def parseCBR(raw):
-	""" Parse a CBR file for the CQTU
+    """ Parse a CBR file for the CQTU
 
-	Yes, this could be used for other tools, BUT you'd have to take
+    Yes, this could be used for other tools, BUT you'd have to take
-	look at the regex and parsingfoo, as there is some cqtu specific foo
+    look at the regex and parsingfoo, as there is some cqtu specific foo
-	inside them.
+    inside them.
-	"""
+    """
-	kvlinere = re.compile(r"^(?P<key>[A-Z-]+):(?: (?P<value>.*))?$")
+    kvlinere = re.compile(r"^(?P<key>[A-Z-]+):(?: (?P<value>.*))?$")
-	qsore = re.compile(r"^(?P<band>144|432)\s+(?P<mode>[A-Z]{2})\s+(?P<datetime>\d{4}-\d{2}-\d{2} \d{4}) (?P<call_s>[A-Z0-9/-]+)\s+(?P<rst_s>\d{2,3})\s+(?P<exc_s>[A-Z0-9-]+)\s+(?P<call_r>[A-Z0-9/-]+)\s+(?P<rst_r>\d{2,3})\s+(?P<exc_r>[A-Z0-9-]+)\s+0$")
+    qsore = re.compile(r"^(?P<band>144|432)\s+(?P<mode>[A-Z]{2})\s+(?P<datetime>\d{4}-\d{2}-\d{2} \d{4}) "
+                       r"(?P<call_s>[A-Z0-9/-]+)\s+(?P<rst_s>\d{2,3})\s+(?P<exc_s>[A-Z0-9-]+)\s+"
+                       r"(?P<call_r>[A-Z0-9/-]+)\s+(?P<rst_r>\d{2,3})\s+(?P<exc_r>[A-Z0-9-]+)\s+0$")
 
+    qsoNo = 1
+    info = {
+        "call": None,
+        "location": None,
+        "qsos": [],
+    }
 
-	qsoNo = 1
+    for n, line in enumerate(raw.split("\n"), 1):
-	info = {
+        line = line.strip()
-		"call": None,
+        # ignore empty lines
-		"location": None,
+        if line == "":
-		"qsos": [],
+            continue
-	}
 
-	for n, line in enumerate(raw.split("\n"), 1):
+        m = kvlinere.match(line)
-		line = line.strip()
+        if m:
-		# ignore empty lines
+            k = m.group("key")
-		if line == "":
+            if k == "CALLSIGN":
-			continue
+                info["call"] = m.group("value").strip().upper()
+            elif k == "LOCATION":
+                info["location"] = m.group("value").strip().upper()
+            elif k == "QSO":
+                q = m.group("value").strip()
+                # no-s FM date UTC-HHMM call rst-s exch-s call-r rst-r exch-r
+                # no-s / date UTC-HH-MM call rst-s
+                qm = qsore.search(q)
+                if qm:
+                    qsoData = qm.groupdict()
+                    qsoTime = timezone.datetime.strptime(qsoData["datetime"], "%Y-%m-%d %H%M")
+                    qsoData["datetime"] = timezone.get_current_timezone().localize(qsoTime)
+                    qsoData["no_s"] = qsoNo
 
-		m = kvlinere.match(line)
+                    if qsoData["band"] == "144":
-		if m:
+                        qsoData["band"] = "2m"
-			k = m.group("key")
+                    elif qsoData["band"] == "432":
-			if k == "CALLSIGN":
+                        qsoData["band"] = "70cm"
-				info["call"] = m.group("value").strip().upper()
+                    else:
-			elif k == "LOCATION":
+                        raise forms.ValidationError("Error parsing band, needs to be either 144 or 432 "
-				info["location"] = m.group("value").strip().upper()
+                                                    "(as we only support 2m and 70cm in this contest")
-			elif k == "QSO":
-				q = m.group("value").strip()
-				# no-s FM date UTC-HHMM call rst-s exch-s call-r rst-r exch-r
-				# no-s / date UTC-HH-MM call rst-s
-				qm = qsore.search(q)
-				if qm:
-					qsoData = qm.groupdict()
-					qsoTime = timezone.datetime.strptime(qsoData["datetime"], "%Y-%m-%d %H%M")
-					qsoData["datetime"] = timezone.get_current_timezone().localize(qsoTime)
-					qsoData["no_s"] = qsoNo
 
-					if qsoData["band"] == "144":
+                    info["qsos"].append(qsoData)
-						qsoData["band"] = "2m"
-					elif qsoData["band"] == "432":
-						qsoData["band"] = "70cm"
-					else:
-						raise forms.ValidationError("Error parsing band, needs to be either 144 or 432 (as we only support 2m and 70cm in this contest")
 
-					info["qsos"].append(qsoData)
+                    if info["call"] != qsoData["call_s"]:
+                        raise forms.ValidationError("Error in line %d: qso was not made by you? "
+                                                    "(callsigns do not match)" % n)
+                    if info["location"] != qsoData["exc_s"]:
+                        raise forms.ValidationError("Error in line %d: exchange does not match your location? "
+                                                    "(callsigns do not match)" % n)
+                else:
+                    raise forms.ValidationError("Error in line %d: qso was broken, regex did not match" % n)
 
-					if info["call"] != qsoData["call_s"]:
+                qsoNo += 1
-						raise forms.ValidationError("Error in line %d: qso was not made by you? (callsigns do not match)" % n)
+            elif k == "X-QSO":
-					if info["location"] != qsoData["exc_s"]:
+                qsoNo += 1
-						raise forms.ValidationError("Error in line %d: exchange does not match your location? (callsigns do not match)" % n)
-				else:
-					raise forms.ValidationError("Error in line %d: qso was broken, regex did not match" % n)
 
-				qsoNo += 1
+        else:
-			elif k == "X-QSO":
+            raise forms.ValidationError("Error in line %d: could not parse \"KEY: value\" pair" % n)
-				qsoNo += 1
 
-		else:
+    return info
-			raise forms.ValidationError("Error in line %d: could not parse \"KEY: value\" pair" % n)
 
-	return info
 
 class CBRForm(forms.Form):
-	data = forms.CharField(widget=forms.Textarea, label="Cabrillo data", help_text="Paste your cabrillo file contents here")
+    data = forms.CharField(widget=forms.Textarea, label="Cabrillo data",
+                           help_text="Paste your cabrillo file contents here")
 
-	def clean_data(self):
+    def clean_data(self):
-		rawData = self.cleaned_data["data"]
+        rawData = self.cleaned_data["data"]
-		parsedData = parseCBR(rawData)
+        parsedData = parseCBR(rawData)
+
+        return parsedData
 
-		return parsedData
 
 def checkCBRConsistency(contest, user, info):
-	errors = []
+    errors = []
-	qsos = []
+    qsos = []
-	if user.username != info["call"]:
+    if user.username != info["call"]:
-		errors.append("You are not the owner of this logfile! (%s != %s)" % (user.username, info["call"]))
+        errors.append("You are not the owner of this logfile! (%s != %s)" % (user.username, info["call"]))
 
-	if user.ref.name != info["location"]:
+    if user.ref.name != info["location"]:
-		errors.append("Location of logfile and registered exchange do not match! (%s != %s)" % (user.ref.name, info["location"]))
+        errors.append("Location of logfile and registered exchange do not match! (%s != %s)" % (user.ref.name,
+                                                                                                info["location"]))
 
-	for n, qsoData in enumerate(info["qsos"], 1):
+    for n, qsoData in enumerate(info["qsos"], 1):
-		qsoFormData = {
+        qsoFormData = {
-			#"owner": user,
+            "time": qsoData["datetime"],
-			"time": qsoData["datetime"],
+            "call": qsoData["call_r"],
-			"call": qsoData["call_r"],
+            "band": Band.objects.get(contest=contest, name=qsoData["band"]).id,
-			"band": Band.objects.get(contest=contest, name=qsoData["band"]).id,
+            "reportTX": qsoData["rst_s"],
-			"reportTX": qsoData["rst_s"],
+            "reportRX": qsoData["rst_r"],
-			"reportRX": qsoData["rst_r"],
+            "ownNo": qsoData["no_s"],
-			"ownNo": qsoData["no_s"],
+            "otherNo": None,
-			"otherNo": None,
+            "refStr": qsoData["exc_r"],
-			"refStr": qsoData["exc_r"],
+            "remarks": "",
-			"remarks": "",
+        }
-		}
 
-		qsoForm = QSOFormWithTime(user, data=qsoFormData)
+        qsoForm = QSOFormWithTime(user, data=qsoFormData)
-		qsoForm.is_valid()
+        qsoForm.is_valid()
-		qsoForm.instance.owner = user
+        qsoForm.instance.owner = user
-		print(qsoForm.errors)
+        print(qsoForm.errors)
-		qsos.append((qsoForm.instance, qsoForm))
+        qsos.append((qsoForm.instance, qsoForm))
+
+    return qsos, errors
 
-	return qsos, errors
 
 @login_required
 def uploadCBR(request):
-	if not request.user.ref:
+    if not request.user.ref:
-		return HttpResponseRedirect(reverse("contest:index"))
+        return HttpResponseRedirect(reverse("contest:index"))
 
-	contest = Contest.objects.get(id=1)
+    contest = Contest.objects.get(id=1)
-	deadline = False
+    deadline = False
-	form = None
+    form = None
-	verifyData = []
+    verifyData = []
-	verifyErrors = []
+    verifyErrors = []
-	save = saved = False
+    save = saved = False
 
-	if timezone.now() < contest.deadline:
+    if timezone.now() < contest.deadline:
-		if request.method == "POST":
+        if request.method == "POST":
-			form = CBRForm(data=request.POST)
+            form = CBRForm(data=request.POST)
-			if form.is_valid():
+            if form.is_valid():
-				verifyData, verifyErrors = checkCBRConsistency(contest, request.user, form.cleaned_data["data"])
+                verifyData, verifyErrors = checkCBRConsistency(contest, request.user, form.cleaned_data["data"])
 
-				if request.POST.get("action") == "save":
+                if request.POST.get("action") == "save":
-					save = True
+                    save = True
-					if not verifyErrors:
+                    if not verifyErrors:
-						cnt = 0
+                        cnt = 0
-						for qso, qsoForm in verifyData:
+                        for qso, qsoForm in verifyData:
-							if qsoForm.is_valid():
+                            if qsoForm.is_valid():
-								qso.save()
+                                qso.save()
-								cnt += 1
+                                cnt += 1
 
-						if cnt > 0:
+                        if cnt > 0:
-							messages.success(request, "%d QSOs have been saved from the cbr file" % cnt)
+                            messages.success(request, "%d QSOs have been saved from the cbr file" % cnt)
-						else:
+                        else:
-							messages.warnnig(request, "CBR file was parsed, but no QSOs could be saved, as all cointained errors.")
+                            messages.warnnig(request, "CBR file was parsed, but no QSOs could be saved, "
+                                                      "as all cointained errors.")
 
-						return HttpResponseRedirect(reverse("contest:uploadCBR"))
+                        return HttpResponseRedirect(reverse("contest:uploadCBR"))
-		else:
+        else:
-			form = CBRForm()
+            form = CBRForm()
-	else:
+    else:
-		deadline = True
+        deadline = True
 
-	return render(request, "contest/uploadCBR.html", {"deadline": deadline, 'form': form, 'verifyData': verifyData, 'verifyErrors': verifyErrors, 'save': save, 'saved': saved})
+    return render(request, "contest/uploadCBR.html",
+                  {"deadline": deadline, 'form': form, 'verifyData': verifyData, 'verifyErrors': verifyErrors,
+                   'save': save, 'saved': saved})

contest/forms.py

@@ -1,174 +1,180 @@
-from django import forms
-from django.contrib.auth.forms import UserCreationForm
-from django.utils import timezone
-
 from crispy_forms.helper import FormHelper
 from crispy_forms.layout import Submit, Layout
+from django import forms
+from django.contrib.auth.forms import UserCreationForm
 from django.urls import reverse
+from django.utils import timezone
 
 from .models import User, Reference, QSO, ShadowCall, EntryCategory, Contest
 from .validators import CallUsernameValidator, CallLogValidator
 
-class CustomUserCreationForm(UserCreationForm):
-	class Meta:
-		model = User
-		fields = ("username", "email", "dncall", "qrv2m", "qrv70cm", "extra2m70cm")
 
-	username = forms.CharField(max_length=50, validators=[CallUsernameValidator()])
+class CustomUserCreationForm(UserCreationForm):
-	email = forms.EmailField(required=True)
+    class Meta:
+        model = User
+        fields = ("username", "email", "dncall", "qrv2m", "qrv70cm", "extra2m70cm")
+
+    username = forms.CharField(max_length=50, validators=[CallUsernameValidator()])
+    email = forms.EmailField(required=True)
+
 
 class UpdateRefForm(forms.Form):
-	existingRef = forms.ModelChoiceField(label="Existing Exchange", queryset=Reference.objects.all(), help_text="If exchange already exists, select it here.", required=False)
+    existingRef = forms.ModelChoiceField(label="Existing Exchange", queryset=Reference.objects.all(),
-	newRefName = forms.CharField(max_length=50, label="New Exchange", help_text="Enter name of new exchange, if we should create a new", required=False)
+                                         help_text="If exchange already exists, select it here.", required=False)
+    newRefName = forms.CharField(max_length=50, label="New Exchange",
+                                 help_text="Enter name of new exchange, if we should create a new", required=False)
 
-	location = forms.CharField(max_length=128, label='Exact Location', help_text="E.g. MAR bei den Fahrstuehlen, TEL 15. OG", required=False)
+    location = forms.CharField(max_length=128, label='Exact Location',
-	opName = forms.CharField(max_length=128, label='Operators', help_text="Name of operator(s)", required=False)
+                               help_text="E.g. MAR bei den Fahrstuehlen, TEL 15. OG", required=False)
-	regTime = forms.DateTimeField(label="Registration time", help_text="Time of Registration")
+    opName = forms.CharField(max_length=128, label='Operators', help_text="Name of operator(s)", required=False)
+    regTime = forms.DateTimeField(label="Registration time", help_text="Time of Registration")
 
-	def clean_newRefName(self):
+    def clean_newRefName(self):
-		data = self.cleaned_data["newRefName"].strip().upper()
+        data = self.cleaned_data["newRefName"].strip().upper()
 
-		return data
+        return data
 
-	def clean(self):
+    def clean(self):
-		cleaned_data = super(UpdateRefForm, self).clean()
+        cleaned_data = super(UpdateRefForm, self).clean()
 
-		existingRef = cleaned_data.get("existingRef")
+        existingRef = cleaned_data.get("existingRef")
-		newRefName = cleaned_data.get("newRefName")
+        newRefName = cleaned_data.get("newRefName")
 
-		if newRefName:
+        if newRefName:
-			try:
+            try:
-				ref = Reference.objects.get(name=newRefName)
+                ref = Reference.objects.get(name=newRefName)
-				self.cleaned_data['newRefName'] = None
+                self.cleaned_data['newRefName'] = None
-				self.cleaned_data['existingRef'] = ref
+                self.cleaned_data['existingRef'] = ref
-			except Reference.DoesNotExist:
+            except Reference.DoesNotExist:
-				pass
+                pass
+
+        if existingRef and newRefName:
+            raise forms.ValidationError("Select an existing exchange or create a new one, not both!")
+        if not existingRef and not newRefName:
+            raise forms.ValidationError("Select either an existing exchange or create a new one!")
 
-		if existingRef and newRefName:
-			raise forms.ValidationError("Select an existing exchange or create a new one, not both!")
-		if not existingRef and not newRefName:
-			raise forms.ValidationError("Select either an existing exchange or create a new one!")
 
 class UpdateCategoryForm(forms.Form):
-	entry = forms.ModelChoiceField(label="Entry category", queryset=EntryCategory.objects.all())
+    entry = forms.ModelChoiceField(label="Entry category", queryset=EntryCategory.objects.all())
-	def __init__(self, *args, **kwargs):
-		super(UpdateCategoryForm, self).__init__(*args, **kwargs)
 
-		self.helper = FormHelper()
+    def __init__(self, *args, **kwargs):
-		self.helper.form_class = "form-inline "
+        super(UpdateCategoryForm, self).__init__(*args, **kwargs)
-		self.helper.form_style = 'inline'
-		self.helper.field_template = "bootstrap3/layout/inline_field.html"
-		self.helper.action = reverse("profile")
-		self.helper.add_input(Submit('submit', 'Set category'))
-		self.helper.layout = Layout('entry')
 
-	def clean(self):
+        self.helper = FormHelper()
-		contest = Contest.objects.get(id=1)
+        self.helper.form_class = "form-inline "
+        self.helper.form_style = 'inline'
+        self.helper.field_template = "bootstrap3/layout/inline_field.html"
+        self.helper.action = reverse("profile")
+        self.helper.add_input(Submit('submit', 'Set category'))
+        self.helper.layout = Layout('entry')
+
+    def clean(self):
+        contest = Contest.objects.get(id=1)
+
+        if contest.deadline < timezone.now():
+            raise forms.ValidationError("The deadline for setting your contest category has passed")
 
-		if contest.deadline < timezone.now():
-			raise forms.ValidationError("The deadline for setting your contest category has passed")
 
 class QSOForm(forms.ModelForm):
-	class Meta:
+    class Meta:
-		model = QSO
+        model = QSO
-		#fields = ["ownNo", "band", "call", "reportTX", "reportRX", "refStr", "otherNo", "remarks"]
+        # fields = ["ownNo", "band", "call", "reportTX", "reportRX", "refStr", "otherNo", "remarks"]
-		fields = ["ownNo", "band", "call", "reportTX", "reportRX", "refStr", "remarks"]
+        fields = ["ownNo", "band", "call", "reportTX", "reportRX", "refStr", "remarks"]
 
-	def __init__(self, user, *args, **kwargs):
+    def __init__(self, user, *args, **kwargs):
-		super(QSOForm, self).__init__(*args, **kwargs)
+        super(QSOForm, self).__init__(*args, **kwargs)
-		self.user = user
+        self.user = user
 
-		self.helper = FormHelper()
+        self.helper = FormHelper()
-		self.helper.form_id = "qso-log-form"
+        self.helper.form_id = "qso-log-form"
-		#self.helper.form_class = "form-inline "
+        # self.helper.form_class = "form-inline "
-		#self.helper.form_class = "form-horizontal"
+        # self.helper.form_class = "form-horizontal"
-		#self.helper.form_style = 'inline'
+        # self.helper.form_style = 'inline'
-		#self.helper.field_template = "bootstrap3/layout/inline_field.html"
+        # self.helper.field_template = "bootstrap3/layout/inline_field.html"
-		self.helper.action = reverse("contest:log")
+        self.helper.action = reverse("contest:log")
-		self.helper.add_input(Submit('submit', 'Log'))
+        self.helper.add_input(Submit('submit', 'Log'))
-		#self.helper.layout = Layout(
+        # self.helper.layout = Layout(
-		#	#*(QSOForm.Meta.fields +  [ButtonHolder(Submit('submit', 'Submit', css_class='button white'))]))
+        #     #*(QSOForm.Meta.fields +  [ButtonHolder(Submit('submit', 'Submit', css_class='button white'))]))
-		#	*(QSOForm.Meta.fields +  [FormActions(Submit('submit', 'Log!'))]))
+        #     *(QSOForm.Meta.fields +  [FormActions(Submit('submit', 'Log!'))]))
 
+    def clean_call(self):
+        data = self.cleaned_data["call"].upper().strip()
 
-	def clean_call(self):
+        try:
-		data = self.cleaned_data["call"].upper().strip()
+            CallLogValidator()(data)
-		if Reference.objects.filter(name=data).count() > 0:
+        except forms.ValidationError:
-			raise forms.ValidationError("Reference already exists")
+            raise forms.ValidationError("Enter a valid callsign (1-2 chars, a number, 1-4 chars, maybe a /[A-Z])")
 
-		try:
+        if data == self.user.username:
-			CallLogValidator()(data)
+            raise forms.ValidationError("You cannot log QSOs with yourself")
-		except forms.ValidationError:
-			raise forms.ValidationError("Enter a valid callsign (1-2 chars, a number, 1-4 chars, maybe a /[A-Z])")
 
-		if data == self.user.username:
+        return data
-			raise forms.ValidationError("You cannot log QSOs with yourself")
 
-		return data
+    def clean_ownNo(self):
+        data = self.cleaned_data["ownNo"]
 
-	def clean_ownNo(self):
+        if data < 1 or data > 100000:
-		data = self.cleaned_data["ownNo"]
+            raise forms.ValidationError("Number has to be in range of [1, 1000000]")
 
-		if data < 1 or data > 100000:
+        try:
-			raise forms.ValidationError("Number has to be in range of [1, 1000000]")
+            o = QSO.objects.get(owner=self.user.id, ownNo=data)
+            if not (self.instance and self.instance.id and self.instance.id == o.id):
+                raise forms.ValidationError("You already logged a QSO with the number %s" % data)
+        except QSO.DoesNotExist:
+            pass
 
-		try:
+        return data
-                    o = QSO.objects.get(owner=self.user.id, ownNo=data)
-                    if not (self.instance and self.instance.id and self.instance.id == o.id):
-                        raise forms.ValidationError("You already logged a QSO with the number %s" % data)
-		except QSO.DoesNotExist:
-                    pass
 
-                return data
+    def clean_otherNo(self):
+        data = self.cleaned_data["otherNo"]
 
-	def clean_otherNo(self):
+        if not data:
-		data = self.cleaned_data["otherNo"]
+            # empty value
+            return None
 
-		if not data:
+        if data < 1 or data > 100000:
-			# empty value
+            raise forms.ValidationError("Number has to be in range of [1, 1000000]")
-			return None
 
-		if data < 1 or data > 100000:
+        return data
-			raise forms.ValidationError("Number has to be in range of [1, 1000000]")
 
-		return data
+    def clean_refStr(self):
+        return self.cleaned_data["refStr"].upper()
 
-	def clean_refStr(self):
+    def clean(self):
-		return self.cleaned_data["refStr"].upper()
+        cleaned_data = super(QSOForm, self).clean()
+        band = cleaned_data.get("band")
 
-	def clean(self):
+        if band.contest.deadline < timezone.now():
-		cleaned_data = super(QSOForm, self).clean()
+            raise forms.ValidationError("The deadline for logging and editing QSOs has passed")
-		band = cleaned_data.get("band")
 
-		if band.contest.deadline < timezone.now():
-			raise forms.ValidationError("The deadline for logging and editing QSOs has passed")
 
 class QSOFormWithTime(QSOForm):
-	class Meta:
+    class Meta:
-		model = QSO
+        model = QSO
-		#fields = ["time", "ownNo", "band", "call", "reportTX", "reportRX", "otherNo", "refStr", "remarks"]
+        # fields = ["time", "ownNo", "band", "call", "reportTX", "reportRX", "otherNo", "refStr", "remarks"]
-		fields = ["time", "ownNo", "band", "call", "reportTX", "reportRX", "refStr", "remarks"]
+        fields = ["time", "ownNo", "band", "call", "reportTX", "reportRX", "refStr", "remarks"]
+
 
 class ShadowCallAddForm(forms.ModelForm):
 
-	class Meta:
+    class Meta:
-		model = ShadowCall
+        model = ShadowCall
-		fields = ['username']
+        fields = ['username']
 
-	def __init__(self, *args, **kwargs):
+    def __init__(self, *args, **kwargs):
-		super(ShadowCallAddForm, self).__init__(*args, **kwargs)
+        super(ShadowCallAddForm, self).__init__(*args, **kwargs)
 
-		self.helper = FormHelper()
+        self.helper = FormHelper()
-		self.helper.form_class = "form-inline "
+        self.helper.form_class = "form-inline "
-		self.helper.form_style = 'inline'
+        self.helper.form_style = 'inline'
-		self.helper.field_template = "bootstrap3/layout/inline_field.html"
+        self.helper.field_template = "bootstrap3/layout/inline_field.html"
-		self.helper.action = reverse("contest:registerRefs")
+        self.helper.action = reverse("contest:registerRefs")
-		self.helper.add_input(Submit('submit', 'Add shadow'))
+        self.helper.add_input(Submit('submit', 'Add shadow'))
-		self.helper.layout = Layout('username')
+        self.helper.layout = Layout('username')
 
-	def clean_username(self):
+    def clean_username(self):
-		data = self.cleaned_data["username"]
+        data = self.cleaned_data["username"]
-		if User.objects.filter(username=data).count() > 0:
+        if User.objects.filter(username=data).count() > 0:
-			raise forms.ValidationError("A user with this call already exists, this is not a shadow!")
+            raise forms.ValidationError("A user with this call already exists, this is not a shadow!")
 
-		return data
+        return data

contest/migrations/0021_alter_qso_otherno_alter_qso_ownno_alter_user_dncall_and_more.py

@@ -0,0 +1,65 @@
+# Generated by Django 4.0.1 on 2022-01-22 16:18
+
+import django.contrib.auth.validators
+import django.core.validators
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('contest', '0020_auto_20190122_2348'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='qso',
+            name='otherNo',
+            field=models.IntegerField(blank=True, null=True, validators=[django.core.validators.MinValueValidator(1), django.core.validators.MaxValueValidator(1000000)], verbose_name='No-R'),
+        ),
+        migrations.AlterField(
+            model_name='qso',
+            name='ownNo',
+            field=models.IntegerField(validators=[django.core.validators.MinValueValidator(1), django.core.validators.MaxValueValidator(1000000)], verbose_name='No'),
+        ),
+        migrations.AlterField(
+            model_name='user',
+            name='dncall',
+            field=models.CharField(blank=True, default='', help_text='If you have a DN call that you will offer to SWLs please enter it here', max_length=16, verbose_name='DN-Call'),
+        ),
+        migrations.AlterField(
+            model_name='user',
+            name='extra2m70cm',
+            field=models.BooleanField(default=False, help_text='Will you bring an additional 2m/70cm TRX to lend to other participants?', verbose_name='Additional 2m/70cm TRX'),
+        ),
+        migrations.AlterField(
+            model_name='user',
+            name='first_name',
+            field=models.CharField(blank=True, max_length=150, verbose_name='first name'),
+        ),
+        migrations.AlterField(
+            model_name='user',
+            name='last_name',
+            field=models.CharField(blank=True, max_length=150, verbose_name='last name'),
+        ),
+        migrations.AlterField(
+            model_name='user',
+            name='qrv2m',
+            field=models.BooleanField(default=False, help_text='Will you be QRV on 2m during the contest?', verbose_name='QRV on 2m'),
+        ),
+        migrations.AlterField(
+            model_name='user',
+            name='qrv70cm',
+            field=models.BooleanField(default=False, help_text='Will you be QRV on 70cm during the contest?', verbose_name='QRV on 70cm'),
+        ),
+        migrations.AlterField(
+            model_name='user',
+            name='regTime',
+            field=models.DateTimeField(blank=True, default=None, null=True),
+        ),
+        migrations.AlterField(
+            model_name='user',
+            name='username',
+            field=models.CharField(error_messages={'unique': 'A user with that username already exists.'}, help_text='Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only.', max_length=150, unique=True, validators=[django.contrib.auth.validators.UnicodeUsernameValidator()], verbose_name='username'),
+        ),
+    ]

contest/models.py

@@ -1,246 +1,264 @@
-from __future__ import unicode_literals
-
 import datetime
 
-from django.db import models
 from django.contrib.auth.models import AbstractUser
-from django.core.validators import RegexValidator
+from django.core.validators import RegexValidator, MinValueValidator, MaxValueValidator
+from django.db import models
 from django.db.models import Q, signals
 
-from .validators import CallUsernameValidator
 from .signals import checkForShadowCall
+from .validators import CallUsernameValidator
+
 
 class Contest(models.Model):
-	name = models.CharField(max_length=20)
+    name = models.CharField(max_length=20)
-	shortName = models.CharField(max_length=20, unique=True)
+    shortName = models.CharField(max_length=20, unique=True)
-	callQrg = models.ForeignKey("Frequency", models.SET_NULL, null=True, blank=True)
+    callQrg = models.ForeignKey("Frequency", on_delete=models.SET_NULL, null=True, blank=True)
-	deadline = models.DateTimeField()
+    deadline = models.DateTimeField()
 
-	qsoStartTime = models.DateTimeField()
+    qsoStartTime = models.DateTimeField()
-	qsoEndTime = models.DateTimeField()
+    qsoEndTime = models.DateTimeField()
+
+    def __str__(self):
+        return self.name
+
+    @classmethod
+    def get_current_contest(cls):
+        return cls.objects.get(id=1)
 
-	def __str__(self):
-		return self.name
 
 class Reference(models.Model):
-	name = models.CharField(max_length=20, unique=True, db_index=True)
+    name = models.CharField(max_length=20, unique=True, db_index=True)
-	description = models.TextField()
+    description = models.TextField()
+
+    def __str__(self):
+        return self.name
 
-	def __str__(self):
-		return self.name
 
 class EntryCategory(models.Model):
-	name = models.CharField(max_length=64, unique=True)
+    name = models.CharField(max_length=64, unique=True)
-	description = models.TextField(blank=True)
+    description = models.TextField(blank=True)
+
+    def __str__(self):
+        return self.name
 
-	def __str__(self):
-		return self.name
 
 class ShadowCall(models.Model):
-	username = models.CharField(max_length=20, unique=True, db_index=True, validators=[CallUsernameValidator()])
+    username = models.CharField(max_length=20, unique=True, db_index=True, validators=[CallUsernameValidator()])
-	ref = models.ForeignKey(Reference, models.SET_NULL,null=True, blank=True)
+    ref = models.ForeignKey(Reference, models.SET_NULL, null=True, blank=True)
 
-	location = models.CharField(max_length=128, default="", blank=True)
+    location = models.CharField(max_length=128, default="", blank=True)
-	opName = models.CharField(max_length=128, default="", blank=True)
+    opName = models.CharField(max_length=128, default="", blank=True)
-	regTime = models.DateTimeField(null=True, default=None)
+    regTime = models.DateTimeField(null=True, default=None)
+
+    def __str__(self):
+        return self.username
 
-	def __str__(self):
-		return self.username
 
 class User(AbstractUser):
-	ref = models.ForeignKey(Reference, models.SET_NULL, null=True, blank=True)
+    ref = models.ForeignKey(Reference, models.SET_NULL, null=True, blank=True)
-	cat = models.ForeignKey(EntryCategory, models.SET_NULL, null=True, blank=True)
+    cat = models.ForeignKey(EntryCategory, models.SET_NULL, null=True, blank=True)
 
-	location = models.CharField(max_length=128, default="", blank=True)
+    location = models.CharField(max_length=128, default="", blank=True)
-	opName = models.CharField(max_length=128, default="", blank=True)
+    opName = models.CharField(max_length=128, default="", blank=True)
-	regTime = models.DateTimeField(null=True, default=None)
+    regTime = models.DateTimeField(null=True, default=None, blank=True)
 
-	# because of cbr parsing bug, we sometimes have users who only have 70cm qsos
+    # because of cbr parsing bug, we sometimes have users who only have 70cm qsos
-	# we ignore the band for them when checking QSOs
+    # we ignore the band for them when checking QSOs
-	ignoreBand = models.BooleanField(default=False)
+    ignoreBand = models.BooleanField(default=False)
 
-	# extra profile stuff so DL7BST can sleep well without his doodles
+    # extra profile stuff so DL7BST can sleep well without his doodles
-	editedProfile = models.BooleanField(default=False)
+    editedProfile = models.BooleanField(default=False)
-	dncall = models.CharField(max_length=16, default='', blank=True,
+    dncall = models.CharField(max_length=16, default='', blank=True,
-								verbose_name="DN-Call",
+                              verbose_name="DN-Call",
-								help_text="If you have a DN call that you will offer to SWLs please enter it here")
+                              help_text="If you have a DN call that you will offer to SWLs please enter it here")
-	qrv2m = models.BooleanField(default=False,
+    qrv2m = models.BooleanField(default=False,
-								verbose_name="QRV on 2m",
+                                verbose_name="QRV on 2m",
-								help_text="Will you be QRV on 2m during the contest?")
+                                help_text="Will you be QRV on 2m during the contest?")
-	qrv70cm = models.BooleanField(default=False,
+    qrv70cm = models.BooleanField(default=False,
-									verbose_name="QRV on 70cm",
+                                  verbose_name="QRV on 70cm",
-									help_text="Will you be QRV on 70cm during the contest?")
+                                  help_text="Will you be QRV on 70cm during the contest?")
-	extra2m70cm = models.BooleanField(default=False,
+    extra2m70cm = models.BooleanField(default=False,
-                                        verbose_name="Additional 2m/70cm TRX",
+                                      verbose_name="Additional 2m/70cm TRX",
-                                        help_text="Will you bring an additional 2m/70cm TRX to lend to other participants?")
+                                      help_text="Will you bring an additional 2m/70cm TRX to lend to "
+                                                "other participants?")
 
-	def __init__(self, *args, **kwargs):
+    def __init__(self, *args, **kwargs):
-		super(User, self).__init__(*args, **kwargs)
+        super(User, self).__init__(*args, **kwargs)
-		self._meta.get_field("username").validators = [CallUsernameValidator()]
+        self._meta.get_field("username").validators = [CallUsernameValidator()]
 
-	def getQSOCount(self):
+    def getQSOCount(self):
-		return self.qso_set.count()
+        return self.qso_set.count()
 
-	def getCfmdQSOCount(self):
+    def getCfmdQSOCount(self):
-		return self.qso_set.filter(~Q(cfmdQSO=None)).count()
+        return self.qso_set.filter(~Q(cfmdQSO=None)).count()
 
-	def getCfmdRefCount(self):
+    def getCfmdRefCount(self):
-		return len(set(map(lambda _x: _x["refStr"], self.qso_set.filter(ref__isnull=False).values("ref", "refStr"))))
+        return len(set(map(lambda _x: _x["refStr"], self.qso_set.filter(ref__isnull=False).values("ref", "refStr"))))
 
-	def calcClaimedPoints(self):
+    def calcClaimedPoints(self):
-		return self.calcPoints(cfmd=False)
+        return self.calcPoints(cfmd=False)
 
-	def calcCfmdPoints(self):
+    def calcCfmdPoints(self):
-		return self.calcPoints(cfmd=True)
+        return self.calcPoints(cfmd=True)
 
-	def calcPoints(self, cfmd):
+    def calcPoints(self, cfmd):
-		contest = Contest.objects.get(id=1)
+        contest = Contest.objects.get(id=1)
 
-		result = {"refCount": 0, "qsoCount": 0}
+        result = {"refCount": 0, "qsoCount": 0}
-		for band in contest.band_set.all():
+        for band in contest.band_set.all():
-			result[band.name] = self.calcBandPoints(band, cfmd)
+            result[band.name] = self.calcBandPoints(band, cfmd)
-			result["refCount"] += result[band.name]["refCount"]
+            result["refCount"] += result[band.name]["refCount"]
-			result["qsoCount"] += result[band.name]["qsoCount"]
+            result["qsoCount"] += result[band.name]["qsoCount"]
 
-		result["points"] = result["qsoCount"] * result["refCount"]
+        result["points"] = result["qsoCount"] * result["refCount"]
 
-		return result
+        return result
+
+    def calcBandPoints(self, band, cfmd=False):
+        contest = band.contest
+        qsos = self.qso_set.filter(band=band, time__gte=contest.qsoStartTime, time__lte=contest.qsoEndTime)
+        if cfmd:
+            qsos = qsos.filter(cfmdQSO__isnull=False)
+        refs = set(map(lambda _x: _x["refStr"], qsos.values("refStr")))
+
+        return {
+            "band": band,
+            "refs": refs,
+            "qsoCount": qsos.count(),
+            "refCount": len(refs)
+        }
 
-	def calcBandPoints(self, band, cfmd=False):
-		contest = band.contest
-		qsos = self.qso_set.filter(band=band, time__gte=contest.qsoStartTime, time__lte=contest.qsoEndTime)
-		if cfmd:
-			qsos = qsos.filter(cfmdQSO__isnull=False)
-		refs = set(map(lambda _x: _x["refStr"], qsos.values("refStr")))
 
-		return {
-			"band": band,
-			"refs": refs,
-			"qsoCount": qsos.count(),
-			"refCount": len(refs)
-		}
 signals.post_save.connect(checkForShadowCall, sender=User)
 
-class Band(models.Model):
-	name = models.CharField(max_length=10)
-	contest = models.ForeignKey(Contest)
 
-	def __str__(self):
+class Band(models.Model):
-		return self.name
+    name = models.CharField(max_length=10)
+    contest = models.ForeignKey(Contest, on_delete=models.CASCADE)
+
+    def __str__(self):
+        return self.name
+
 
 class Frequency(models.Model):
-	# qrg
+    # qrg
-	# band
+    # band
-	channel = models.CharField(max_length=3)
+    channel = models.CharField(max_length=3)
-	qrg = models.DecimalField(max_digits=7, decimal_places=3)
+    qrg = models.DecimalField(max_digits=7, decimal_places=3)
-	band = models.ForeignKey(Band)
+    band = models.ForeignKey(Band, on_delete=models.CASCADE)
 
-	note = models.CharField(max_length=50, blank=True)
+    note = models.CharField(max_length=50, blank=True)
+
+    def __str__(self):
+        return "Channel %s: %s MHz" % (self.channel, self.qrg)
 
-	def __str__(self):
-		return "Channel %s: %s MHz" % (self.channel, self.qrg)
 
 class QSO(models.Model):
-	reportValidator = RegexValidator("[1-5][1-9]")
+    MAX_NO_VALUE = 1000000
+    reportValidator = RegexValidator("[1-5][1-9]")
 
-	class Meta:
+    class Meta:
-		index_together = [
+        index_together = [
-			["owner", "call"],
+            ["owner", "call"],
-		]
+        ]
 
-	owner = models.ForeignKey(User, db_index=True)
+    owner = models.ForeignKey(User, on_delete=models.CASCADE, db_index=True)
-	time = models.DateTimeField(blank=True)
+    time = models.DateTimeField(blank=True)
-	call = models.CharField(max_length=20, db_index=True)
+    call = models.CharField(max_length=20, db_index=True)
-	callRef = models.ForeignKey(User, models.SET_NULL, related_name='qsoref', null=True, blank=True, default=None)
+    callRef = models.ForeignKey(User, on_delete=models.SET_NULL, related_name='qsoref', null=True, blank=True, default=None)
-	band = models.ForeignKey(Band)
+    band = models.ForeignKey(Band, on_delete=models.CASCADE)
 
-	reportTX = models.CharField(max_length=7, default=59, verbose_name='RS-S', validators=[reportValidator])
+    reportTX = models.CharField(max_length=7, default=59, verbose_name='RS-S', validators=[reportValidator])
-	reportRX = models.CharField(max_length=7, default=59, verbose_name='RS-R', validators=[reportValidator])
+    reportRX = models.CharField(max_length=7, default=59, verbose_name='RS-R', validators=[reportValidator])
 
-	ownNo = models.IntegerField(verbose_name='No')
+    ownNo = models.IntegerField(verbose_name='No', validators=[MinValueValidator(1), MaxValueValidator(MAX_NO_VALUE)])
-	otherNo = models.IntegerField(verbose_name='No-R', null=True, blank=True)
+    otherNo = models.IntegerField(verbose_name='No-R', null=True, blank=True,
+                                  validators=[MinValueValidator(1), MaxValueValidator(MAX_NO_VALUE)])
 
-	refStr = models.CharField(max_length=20, verbose_name="EXC")
+    refStr = models.CharField(max_length=20, verbose_name="EXC")
-	ref = models.ForeignKey(Reference, models.SET_NULL, null=True, blank=True)
+    ref = models.ForeignKey(Reference, on_delete=models.SET_NULL, null=True, blank=True)
 
-	remarks = models.CharField(max_length=50, blank=True, default=None)
+    remarks = models.CharField(max_length=50, blank=True, default=None)
 
-	cfmdQSO = models.ForeignKey("QSO", models.SET_NULL, null=True, blank=True, default=None)
+    cfmdQSO = models.ForeignKey("QSO", on_delete=models.SET_NULL, null=True, blank=True, default=None)
 
-	CFMD_SEC = 5*60
+    CFMD_SEC = 5 * 60
 
-	def checkQSOData(self):
+    def checkQSOData(self):
-		""" Match strdata to log rows. Only call, if you intent to save this object if we return True! """
+        """ Match strdata to log rows. Only call, if you intent to save this object if we return True! """
-		# find reference
+        # find reference
-		changed = False
+        changed = False
-		if self.refStr:
+        if self.refStr:
-			refName = self.refStr.replace("-", "")
+            refName = self.refStr.replace("-", "")
-			if refName == "GX":
+            if refName == "GX":
-				refName = "DX"
+                refName = "DX"
 
-			# Old reference exists?
+            # Old reference exists?
-			if self.ref and self.ref.name != refName:
+            if self.ref and self.ref.name != refName:
-				self.ref = None
+                self.ref = None
-				changed = True
+                changed = True
 
-			if not self.ref:
+            if not self.ref:
-				# find matching ref
+                # find matching ref
-				try:
+                try:
-					self.ref = Reference.objects.get(name=refName)
+                    self.ref = Reference.objects.get(name=refName)
-					changed = True
+                    changed = True
-				except Reference.DoesNotExist:
+                except Reference.DoesNotExist:
-					pass
+                    pass
 
-		# find call
+        # find call
-		if not self.callRef or self.callRef.username != self.call:
+        if not self.callRef or self.callRef.username != self.call:
-			try:
+            try:
-				self.callRef = User.objects.get(username=self.call)
+                self.callRef = User.objects.get(username=self.call)
-				changed = True
+                changed = True
-			except User.DoesNotExist:
+            except User.DoesNotExist:
-				if self.callRef:
+                if self.callRef:
-					changed = True
+                    changed = True
-				self.callRef = None
+                self.callRef = None
 
-		# find matching qso
+        # find matching qso
-		if self.cfmdQSO:
+        if self.cfmdQSO:
-			# check if this still checks out
+            # check if this still checks out
-			q = self.cfmdQSO
+            q = self.cfmdQSO
-			if abs((self.time - q.time).total_seconds()) <= self.CFMD_SEC and \
+            if abs((self.time - q.time).total_seconds()) <= self.CFMD_SEC and \
-				self.ref and self.owner.ref and self.callRef and q.callRef and \
+                    self.ref and self.owner.ref and self.callRef and q.callRef and \
-				q.owner == self.callRef and q.callRef == self.owner and \
+                    q.owner == self.callRef and q.callRef == self.owner and \
-				self.ref == q.owner.ref and self.owner.ref == q.ref and \
+                    self.ref == q.owner.ref and self.owner.ref == q.ref and \
-				self.band == q.band:
+                    self.band == q.band:
-				# checks out
+                # checks out
-				pass
+                pass
-			else:
+            else:
-				changed = True
+                changed = True
-				self.cfmdQSO.cfmdQSO = None
+                self.cfmdQSO.cfmdQSO = None
-				self.cfmdQSO.save(checkQSO=False)
+                self.cfmdQSO.save(checkQSO=False)
-				self.cfmdQSO = None
+                self.cfmdQSO = None
 
-		if self.ref and self.callRef and self.callRef.ref and not self.cfmdQSO:
+        if self.ref and self.callRef and self.callRef.ref and not self.cfmdQSO:
-			# look for a matching line
+            # look for a matching line
-			q = QSO.objects.filter(
+            q = QSO.objects.filter(
-				(Q(time__lte=self.time + datetime.timedelta(seconds=self.CFMD_SEC)) & Q(time__gte=self.time - datetime.timedelta(seconds=self.CFMD_SEC))),
+                (Q(time__lte=self.time + datetime.timedelta(seconds=self.CFMD_SEC)) &
-				owner=self.callRef,
+                 Q(time__gte=self.time - datetime.timedelta(seconds=self.CFMD_SEC))),
-				callRef=self.owner,
+                owner=self.callRef,
-				owner__ref=self.ref,
+                callRef=self.owner,
-				ref=self.owner.ref,
+                owner__ref=self.ref,
-				band=self.band)
+                ref=self.owner.ref,
+                band=self.band)
 
-			if q.count() == 1:
+            if q.count() == 1:
-				changed = True
+                changed = True
-				q[0].cfmdQSO = self
+                q[0].cfmdQSO = self
-				q[0].save(checkQSO=False)
+                q[0].save(checkQSO=False)
-				self.cfmdQSO = q[0]
+                self.cfmdQSO = q[0]
 
-		return changed
+        return changed
 
-	def save(self, checkQSO=True, *args, **kwargs):
+    def save(self, checkQSO=True, *args, **kwargs):
-		if checkQSO:
+        if checkQSO:
-			self.checkQSOData()
+            self.checkQSOData()
 
-		super(QSO, self).save(*args, **kwargs)
+        super(QSO, self).save(*args, **kwargs)
 
-	def __str__(self):
+    def __str__(self):
-		return "QSO no %s at %s on band %s from %s with %s@%s %s/%s" % (self.ownNo, self.time.strftime("%H:%M"), self.band, self.owner.username, self.call, self.refStr, self.reportTX, self.reportRX)
+        return "QSO no %s at %s on band %s from %s with %s@%s %s/%s" % (self.ownNo, self.time.strftime("%H:%M"),
+                                                                        self.band, self.owner.username, self.call,
+                                                                        self.refStr, self.reportTX, self.reportRX)

contest/signals.py

@@ -1,18 +1,18 @@
 
 def checkForShadowCall(sender, instance, created, raw, **kwargs):
-	""" Check for existing shadow call. If present copy it's data and delete it. """
+    """ Check for existing shadow call. If present copy it's data and delete it. """
-	if created:
+    if created:
-		# to prevent circular imports we import ShadowCall here
+        # to prevent circular imports we import ShadowCall here
-		from .models import ShadowCall
+        from .models import ShadowCall
 
-		try:
+        try:
-			shadow = ShadowCall.objects.get(username=instance.username)
+            shadow = ShadowCall.objects.get(username=instance.username)
-			instance.ref = shadow.ref
+            instance.ref = shadow.ref
-			instance.location = shadow.location
+            instance.location = shadow.location
-			instance.opName = shadow.opName
+            instance.opName = shadow.opName
-			instance.regTime = shadow.regTime
+            instance.regTime = shadow.regTime
 
-			instance.save()
+            instance.save()
-			shadow.delete()
+            shadow.delete()
-		except ShadowCall.DoesNotExist:
+        except ShadowCall.DoesNotExist:
-			pass
+            pass

contest/urls.py

@@ -1,35 +1,22 @@
-"""cqtu URL Configuration
+from django.urls import re_path
-
-The `urlpatterns` list routes URLs to views. For more information please see:
-    https://docs.djangoproject.com/en/1.10/topics/http/urls/
-Examples:
-Function views
-    1. Add an import:  from my_app import views
-    2. Add a URL to urlpatterns:  url(r'^$', views.home, name='home')
-Class-based views
-    1. Add an import:  from other_app.views import Home
-    2. Add a URL to urlpatterns:  url(r'^$', Home.as_view(), name='home')
-Including another URLconf
-    1. Import the include() function: from django.conf.urls import url, include
-    2. Add a URL to urlpatterns:  url(r'^blog/', include('blog.urls'))
-"""
-from django.conf.urls import url
 
 
 import contest.views as contest_views
 from contest.cbrparser import uploadCBR
 
+app_name = 'context'
+
 urlpatterns = [
-	url(r'^$', contest_views.contestIndex, name='index'),
+    re_path(r'^$', contest_views.contestIndex, name='index'),
-	url(r'^regref/$', contest_views.registerRefs, name='registerRefs'),
+    re_path(r'^regref/$', contest_views.registerRefs, name='registerRefs'),
-	url(r'^regref/edit/(?P<uid>\d+)/$', contest_views.updateRef, {"shadow": False}, name='updateRef'),
+    re_path(r'^regref/edit/(?P<uid>\d+)/$', contest_views.updateRef, {"shadow": False}, name='updateRef'),
-	url(r'^regref/shadow/edit/(?P<uid>\d+)/$', contest_views.updateRef, {"shadow": True}, name='updateShadowRef'),
+    re_path(r'^regref/shadow/edit/(?P<uid>\d+)/$', contest_views.updateRef, {"shadow": True}, name='updateShadowRef'),
-	url(r'^regref/qsos/all/$', contest_views.viewAllQSOs, name='viewAllQSOs'),
+    re_path(r'^regref/qsos/all/$', contest_views.viewAllQSOs, name='viewAllQSOs'),
-	url(r'^regref/qsos/user/(?P<uid>\d+)/$', contest_views.viewUserQSOs, name='viewUserQSOs'),
+    re_path(r'^regref/qsos/user/(?P<uid>\d+)/$', contest_views.viewUserQSOs, name='viewUserQSOs'),
-	url(r'^overview/$', contest_views.overview, name='overview'),
+    re_path(r'^overview/$', contest_views.overview, name='overview'),
-	url(r'^log/$', contest_views.log, name='log'),
+    re_path(r'^log/$', contest_views.log, name='log'),
-	url(r'^log/edit/(?P<qsoid>\d+)/$', contest_views.logEdit, name='logEdit'),
+    re_path(r'^log/edit/(?P<qsoid>\d+)/$', contest_views.logEdit, name='logEdit'),
-	url(r'^log/delete/(?P<qsoid>\d+)/$', contest_views.logDelete, name='logDelete'),
+    re_path(r'^log/delete/(?P<qsoid>\d+)/$', contest_views.logDelete, name='logDelete'),
-	url(r'^uploadcbr/$', uploadCBR, name='uploadCBR'),
+    re_path(r'^uploadcbr/$', uploadCBR, name='uploadCBR'),
-	url(r'^regref/recheckqsos/$', contest_views.recheckAllQSOs, name='recheckAllQSOs'),
+    re_path(r'^regref/recheckqsos/$', contest_views.recheckAllQSOs, name='recheckAllQSOs'),
 ]

contest/validators.py

@@ -1,28 +1,25 @@
 from django.core import validators
-from django.utils import six
 from django.utils.deconstruct import deconstructible
-from django.utils.translation import ugettext_lazy as _
+from django.utils.translation import gettext_lazy as _
 
 import re
 
 
 @deconstructible
 class CallUsernameValidator(validators.RegexValidator):
-    #regex = r'^[\w.@+-]+$'
     regex = r'^(?:[A-Z]+/)?[A-Z]{1,2}[0-9][A-Z]{1,4}(?:-[0-9])??$'
     message = _(
         'Enter a valid Callsign as Username, ALL UPPERCASE, if needed with -1 / -2,'
         'e.g. DL7BST, DN1BER-1, DL/OE1FOO.'
     )
-    flags = re.ASCII if six.PY3 else 0
+    flags = re.ASCII
+
 
 @deconstructible
 class CallLogValidator(validators.RegexValidator):
-    #regex = r'^[\w.@+-]+$'
     regex = r'^(?:[A-Z]+/)?[A-Z]{1,2}[0-9][A-Z]{1,4}(?:-[0-9])?(?:/[A-Z]{1,3})?$'
     message = _(
         'Enter a valid callsign, ALL UPPERCASE, if needed with -1 / -2,'
         'e.g. DL7BST, DN1BER-1, DL/OE1FOO, DN1FTW-1/p'
     )
-    flags = re.ASCII if six.PY3 else 0
+    flags = re.ASCII
-

contest/views.py

@@ -1,8 +1,8 @@
-from django.shortcuts import render, get_object_or_404
+import datetime
 
+from django.shortcuts import render, get_object_or_404
 from django.contrib.auth.decorators import login_required
 from django.contrib.admin.views.decorators import staff_member_required
-#from django.db.models import Q
 from django.contrib.auth.forms import AuthenticationForm, PasswordChangeForm
 from django.http import HttpResponseRedirect
 from django.contrib import messages
@@ -11,259 +11,268 @@ from django.contrib.auth import login as auth_login
 from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
 from django.utils import timezone
 
-
-
-import datetime
-
 from .models import User, Contest, Frequency, Reference, QSO, ShadowCall
-from .forms import UpdateRefForm, QSOForm, QSOFormWithTime, CustomUserCreationForm, ShadowCallAddForm, UpdateCategoryForm
+from .forms import UpdateRefForm, QSOForm, QSOFormWithTime, CustomUserCreationForm, ShadowCallAddForm, \
+    UpdateCategoryForm
+
 
 def index(request):
-	if request.user.is_authenticated():
+    if request.user.is_authenticated:
-		return HttpResponseRedirect(reverse("contest:index"))
+        return HttpResponseRedirect(reverse("contest:index"))
+
+    return render(request, "index.html", {"loginForm": AuthenticationForm()})
 
-	return render(request, "index.html", {"loginForm": AuthenticationForm()})
 
 @login_required
 def contestIndex(request):
-	qsoform = QSOForm(request.user)
+    qsoform = QSOForm(request.user)
-	contest = Contest.objects.get(id=1)
+    contest = Contest.objects.get(id=1)
-	qrgs = Frequency.objects.filter(band__contest=contest).order_by("channel")
+    qrgs = Frequency.objects.filter(band__contest=contest).order_by("channel")
+
+    return render(request, 'contest/index.html', {"qsoform": qsoform, "contest": contest, "qrgs": qrgs})
 
-	return render(request, 'contest/index.html', {"qsoform": qsoform, "contest": contest, "qrgs": qrgs})
 
 @login_required
 def log(request):
-	if not request.user.ref:
+    if not request.user.ref:
-		return HttpResponseRedirect(reverse("contest:index"))
+        return HttpResponseRedirect(reverse("contest:index"))
 
-	form = None
+    form = None
 
-	qsos = QSO.objects.filter(owner=request.user).order_by("-ownNo")
+    qsos = QSO.objects.filter(owner=request.user).order_by("-ownNo")
 
-	if request.method == 'POST':
+    if request.method == 'POST':
-		form = QSOForm(user=request.user, data=request.POST)
+        form = QSOForm(user=request.user, data=request.POST)
-		form.helper.form_tag = False
+        form.helper.form_tag = False
-		if form.is_valid():
+        if form.is_valid():
-			l = form.instance
+            l = form.instance
-			if not l.time:
+            if not l.time:
-				# set current time
+                # set current time
-				l.time = datetime.datetime.now()
+                l.time = datetime.datetime.now()
 
-			l.owner = request.user
+            l.owner = request.user
-			l.save()
+            l.save()
 
-			messages.success(request, "QSO saved!")
+            messages.success(request, "QSO saved!")
 
-			return HttpResponseRedirect(reverse("contest:log"))
+            return HttpResponseRedirect(reverse("contest:log"))
-	else:
+    else:
-		data = {
+        data = {
-			"ownNo": qsos[0].ownNo + 1 if len(qsos) > 0 else 1,
+            "ownNo": qsos[0].ownNo + 1 if len(qsos) > 0 else 1,
-			"reportRX": "59",
+            "reportRX": "59",
-			"reportTX": "59",
+            "reportTX": "59",
-		}
+        }
-		if qsos.count() > 0:
+        if qsos.count() > 0:
-			data["band"] = qsos[0].band
+            data["band"] = qsos[0].band
 
-		form = QSOForm(request.user, initial=data)
+        form = QSOForm(request.user, initial=data)
-		form.helper.form_tag = False
+        form.helper.form_tag = False
 
+    return render(request, 'contest/log.html', {'form': form, 'qsos': qsos})
 
-	return render(request, 'contest/log.html', {'form': form, 'qsos': qsos})
 
 @login_required
 def logEdit(request, qsoid):
-	if not request.user.ref:
+    if not request.user.ref:
-		return HttpResponseRedirect(reverse("contest:index"))
+        return HttpResponseRedirect(reverse("contest:index"))
 
-	qso = QSO.objects.get(id=qsoid, owner=request.user)
+    qso = QSO.objects.get(id=qsoid, owner=request.user)
-	form = None
+    form = None
 
-	if request.method == 'POST':
+    if request.method == 'POST':
-		form = QSOFormWithTime(user=request.user, instance=qso, data=request.POST)
+        form = QSOFormWithTime(user=request.user, instance=qso, data=request.POST)
-		if form.is_valid():
+        if form.is_valid():
-			form.instance.save()
+            form.instance.save()
 
-			messages.info(request, "QSO has been edited")
+            messages.info(request, "QSO has been edited")
-			return HttpResponseRedirect(reverse("contest:log"))
+            return HttpResponseRedirect(reverse("contest:log"))
-	else:
+    else:
-		form = QSOFormWithTime(user=request.user, instance=qso)
+        form = QSOFormWithTime(user=request.user, instance=qso)
+
+    return render(request, 'contest/logEdit.html', {'form': form, "qso": qso})
 
-	return render(request, 'contest/logEdit.html', {'form': form, "qso": qso})
 
 def logDelete(request, qsoid):
-	if not request.user.ref:
+    if not request.user.ref:
-		return HttpResponseRedirect(reverse("contest:index"))
+        return HttpResponseRedirect(reverse("contest:index"))
 
-	qso = QSO.objects.get(id=qsoid, owner=request.user)
+    qso = QSO.objects.get(id=qsoid, owner=request.user)
 
-	if request.method == 'POST':
+    if request.method == 'POST':
-		if "delete" in request.POST:
+        if "delete" in request.POST:
-			if request.POST["delete"].lower() == "yes":
+            if request.POST["delete"].lower() == "yes":
-				qso.delete()
+                qso.delete()
-				messages.info(request, "QSO has been deleted")
+                messages.info(request, "QSO has been deleted")
-				return HttpResponseRedirect(reverse("contest:log"))
+                return HttpResponseRedirect(reverse("contest:log"))
-			elif request.POST["delete"].lower() == "no":
+            elif request.POST["delete"].lower() == "no":
-				return HttpResponseRedirect(reverse("contest:log"))
+                return HttpResponseRedirect(reverse("contest:log"))
-
-	return render(request, 'contest/logDelete.html', {"qso": qso})
 
+    return render(request, 'contest/logDelete.html', {"qso": qso})
 
 
 @staff_member_required
 def registerRefs(request):
-	allUser = User.objects.all()
+    allUser = User.objects.all()
-	shadows = ShadowCall.objects.all()
+    shadows = ShadowCall.objects.all()
 
-	qsos = QSO.objects.all().order_by("-time")[0:10]
+    qsos = QSO.objects.all().order_by("-time")[0:10]
 
-	shadowForm = None
+    shadowForm = None
-	if request.method == 'POST':
+    if request.method == 'POST':
-		shadowForm = ShadowCallAddForm(data=request.POST)
+        shadowForm = ShadowCallAddForm(data=request.POST)
-		if shadowForm.is_valid():
+        if shadowForm.is_valid():
-			shadowForm.instance.save()
+            shadowForm.instance.save()
-			messages.success(request, "Successfully added shadow user %s" % (shadowForm.instance.username,))
+            messages.success(request, "Successfully added shadow user %s" % (shadowForm.instance.username,))
-			return HttpResponseRedirect(reverse("contest:registerRefs"))
+            return HttpResponseRedirect(reverse("contest:registerRefs"))
-	else:
+    else:
-		shadowForm = ShadowCallAddForm()
+        shadowForm = ShadowCallAddForm()
+
+    return render(request, 'contest/registerRefs.html',
+                  {'alluser': allUser, "qsos": qsos, "shadowForm": shadowForm, "shadows": shadows})
 
-	return render(request, 'contest/registerRefs.html', {'alluser': allUser, "qsos": qsos, "shadowForm": shadowForm, "shadows": shadows})
 
 def getPage(paginator, pageNo):
-	try:
+    try:
-		return paginator.page(pageNo)
+        return paginator.page(pageNo)
-	except PageNotAnInteger:
+    except PageNotAnInteger:
-		return paginator.page(1)
+        return paginator.page(1)
-	except EmptyPage:
+    except EmptyPage:
-		return paginator.page(paginator.num_pages)
+        return paginator.page(paginator.num_pages)
 
 
 @staff_member_required
 def recheckAllQSOs(request):
-	if request.method == "POST":
+    if request.method == "POST":
-		cnt = 0
+        cnt = 0
-		for qso in QSO.objects.all():
+        for qso in QSO.objects.all():
-			if qso.checkQSOData():
+            if qso.checkQSOData():
-				print(qso)
+                print(qso)
-				qso.save()
+                qso.save()
-				cnt += 1
+                cnt += 1
 
-		messages.success(request, "Allo QSO have been checked against each other (%d QSOs modified)" % (cnt,))
+        messages.success(request, "Allo QSO have been checked against each other (%d QSOs modified)" % (cnt,))
-		return HttpResponseRedirect(reverse("contest:registerRefs"))
+        return HttpResponseRedirect(reverse("contest:registerRefs"))
+
+    return render(request, "contest/checkAllQSOs.html", {})
 
-	return render(request, "contest/checkAllQSOs.html", {})
 
 @staff_member_required
 def viewUserQSOs(request, uid, page=1):
-	user = get_object_or_404(User, id=uid)
+    user = get_object_or_404(User, id=uid)
-	qsos = QSO.objects.filter(owner=user).order_by("-time")
+    qsos = QSO.objects.filter(owner=user).order_by("-time")
-	qsoPager = Paginator(qsos, 50)
+    qsoPager = Paginator(qsos, 50)
-	qsoPage = getPage(qsoPager, request.GET.get('page'))
+    qsoPage = getPage(qsoPager, request.GET.get('page'))
 
-	userRefs = set(map(lambda _x: _x["refStr"], user.qso_set.filter(ref__isnull=False).values("ref", "refStr")))
+    userRefs = set(map(lambda _x: _x["refStr"], user.qso_set.filter(ref__isnull=False).values("ref", "refStr")))
+
+    return render(request, "contest/viewUserQSOs.html",
+                  {'owner': user, 'qsos': qsos, 'qsoPage': qsoPage, 'userRefs': userRefs})
 
-	return render(request, "contest/viewUserQSOs.html", {'owner': user, 'qsos': qsos, 'qsoPage': qsoPage, 'userRefs': userRefs})
 
 @staff_member_required
 def updateRef(request, shadow, uid):
-	user = None
+    user = None
-	form = None
+    form = None
 
-	if shadow:
+    if shadow:
-		user = get_object_or_404(ShadowCall, id=uid)
+        user = get_object_or_404(ShadowCall, id=uid)
-	else:
+    else:
-		user = get_object_or_404(User, id=uid)
+        user = get_object_or_404(User, id=uid)
 
-	if request.method == 'POST':
+    if request.method == 'POST':
-		form = UpdateRefForm(data=request.POST)
+        form = UpdateRefForm(data=request.POST)
-		if form.is_valid():
+        if form.is_valid():
-			ref = None
+            ref = None
-			if form.cleaned_data["existingRef"]:
+            if form.cleaned_data["existingRef"]:
-				ref = form.cleaned_data["existingRef"]
+                ref = form.cleaned_data["existingRef"]
-			else:
+            else:
-				ref = Reference(name=form.cleaned_data["newRefName"])
+                ref = Reference(name=form.cleaned_data["newRefName"])
-				ref.save()
+                ref.save()
-				messages.info(request, "New Ref '%s' created" % ref)
+                messages.info(request, "New Ref '%s' created" % ref)
 
-			user.ref = ref
+            user.ref = ref
-			user.regTime = form.cleaned_data["regTime"]
+            user.regTime = form.cleaned_data["regTime"]
-			user.location = form.cleaned_data["location"]
+            user.location = form.cleaned_data["location"]
-			user.opName = form.cleaned_data["opName"]
+            user.opName = form.cleaned_data["opName"]
-			user.save()
+            user.save()
-			messages.success(request, "%s%s ref set to %s" % ("(shadow) " if shadow else "", user, ref))
+            messages.success(request, "%s%s ref set to %s" % ("(shadow) " if shadow else "", user, ref))
-			return HttpResponseRedirect(reverse("contest:registerRefs"))
+            return HttpResponseRedirect(reverse("contest:registerRefs"))
-	else:
+    else:
-		data = {}
+        data = {}
-		if user.ref:
+        if user.ref:
-			data["existingRef"] = user.ref
+            data["existingRef"] = user.ref
 
-		if user.regTime:
+        if user.regTime:
-			data["regTime"] = user.regTime
+            data["regTime"] = user.regTime
-		else:
+        else:
-			data["regTime"] = timezone.now()
+            data["regTime"] = timezone.now()
-		data["opName"] = user.opName
+        data["opName"] = user.opName
-		data["location"] = user.location
+        data["location"] = user.location
 
-		form = UpdateRefForm(initial=data)
+        form = UpdateRefForm(initial=data)
+
+    return render(request, 'contest/updateRef.html', {'userobj': user, 'form': form, "shadow": shadow})
 
-	return render(request, 'contest/updateRef.html', {'userobj': user, 'form': form, "shadow": shadow})
 
 @staff_member_required
 def viewAllQSOs(request, page=1):
-	qsos = QSO.objects.all().order_by("-time")
+    qsos = QSO.objects.all().order_by("-time")
-	qsoPager = Paginator(qsos, 10)
+    qsoPager = Paginator(qsos, 10)
-	qsoPage = getPage(qsoPager, request.GET.get('page'))
+    qsoPage = getPage(qsoPager, request.GET.get('page'))
+
+    return render(request, 'contest/viewAllQSOs.html', {'qsoPage': qsoPage})
 
-	return render(request, 'contest/viewAllQSOs.html', {'qsoPage': qsoPage})
 
 def overview(request):
-	# FIXME: Hardcoded for cqtu... everywhere
+    # FIXME: Hardcoded for cqtu... everywhere
-	c = Contest.objects.get(id=1)
+    c = Contest.objects.get(id=1)
-	qrgs = Frequency.objects.filter(band__contest=c).order_by("channel")
+    qrgs = Frequency.objects.filter(band__contest=c).order_by("channel")
-	return render(request, 'contest/overview.html', {'contest': c, 'qrgs': qrgs})
+    return render(request, 'contest/overview.html', {'contest': c, 'qrgs': qrgs})
+
 
 def register(request):
-	form = None
+    form = None
-	if request.method == 'POST':
+    if request.method == 'POST':
-		form = CustomUserCreationForm(data=request.POST)
+        form = CustomUserCreationForm(data=request.POST)
-		if form.is_valid():
+        if form.is_valid():
-			form.save()
+            form.save()
-			auth_login(request, form.instance)
+            auth_login(request, form.instance)
-			messages.info(request, "Registration as user %s successfull!" % form.instance.username)
+            messages.info(request, "Registration as user %s successfull!" % form.instance.username)
 
-			return HttpResponseRedirect(reverse("contest:index"))
+            return HttpResponseRedirect(reverse("contest:index"))
-	else:
+    else:
-		form = CustomUserCreationForm()
+        form = CustomUserCreationForm()
+
+    return render(request, 'registration/register.html', {"form": form})
 
-	return render(request, 'registration/register.html', {"form": form})
 
 @login_required
 def profile(request):
-	pwForm = None
+    pwForm = None
-	catForm = None
+    catForm = None
 
-	if request.method == 'POST':
+    if request.method == 'POST':
-		if request.POST.get("submit", None) == "pwchange":
+        if request.POST.get("submit", None) == "pwchange":
-			pwForm = PasswordChangeForm(user=request.user, data=request.POST)
+            pwForm = PasswordChangeForm(user=request.user, data=request.POST)
-			if pwForm.is_valid():
+            if pwForm.is_valid():
-				pwForm.save()
+                pwForm.save()
-				auth_login(request, pwForm.user)
+                auth_login(request, pwForm.user)
-				messages.success(request, "Password changed")
+                messages.success(request, "Password changed")
 
-				return HttpResponseRedirect(reverse("profile"))
+                return HttpResponseRedirect(reverse("profile"))
-		else:
+        else:
-			catForm = UpdateCategoryForm(data=request.POST)
+            catForm = UpdateCategoryForm(data=request.POST)
-			if catForm.is_valid():
+            if catForm.is_valid():
-				request.user.cat = catForm.cleaned_data["entry"]
+                request.user.cat = catForm.cleaned_data["entry"]
-				request.user.save()
+                request.user.save()
-				messages.success(request, "Entry category set")
+                messages.success(request, "Entry category set")
 
-				return HttpResponseRedirect(reverse("profile"))
+                return HttpResponseRedirect(reverse("profile"))
 
-	if not pwForm:
+    if not pwForm:
-		pwForm = PasswordChangeForm(user=request.user)
+        pwForm = PasswordChangeForm(user=request.user)
 
-	if not catForm:
+    if not catForm:
-		catForm = UpdateCategoryForm(initial={'entry': request.user.cat})
+        catForm = UpdateCategoryForm(initial={'entry': request.user.cat})
 
-	return render(request, 'registration/profile.html', {"pwForm": pwForm, "catForm": catForm})
+    return render(request, 'registration/profile.html', {"pwForm": pwForm, "catForm": catForm})

cqtu/settings.py

@@ -33,18 +33,20 @@ ALLOWED_HOSTS = []
 # Application definition
 
 INSTALLED_APPS = [
-	# default
+    # default
     'django.contrib.admin',
     'django.contrib.auth',
     'django.contrib.contenttypes',
     'django.contrib.sessions',
     'django.contrib.messages',
     'django.contrib.staticfiles',
-	
+    'crispy_forms',
-	'crispy_forms',
+    'rest_framework',
+    'django_filters',
 
-	# local
+    # local
-	'contest',
+    'contest',
+    'api',
 ]
 
 MIDDLEWARE = [
@@ -105,12 +107,6 @@ AUTH_PASSWORD_VALIDATORS = [
             'min_length': 4,
         },
     },
-    #{
-    #    'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
-    #},
-    #{
-    #    'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
-    #},
 ]
 
 
@@ -140,6 +136,9 @@ STATICFILES_DIRS = [
 CRISPY_TEMPLATE_PACK = 'bootstrap3'
 
 MESSAGE_TAGS = {
-	messages.ERROR: 'danger',
+    messages.ERROR: 'danger',
 }
 
+REST_FRAMEWORK = {
+    'DEFAULT_FILTER_BACKENDS': ['django_filters.rest_framework.DjangoFilterBackend']
+}

cqtu/urls.py

@@ -1,42 +1,18 @@
-"""cqtu URL Configuration
+from django.urls import include, path
-
-The `urlpatterns` list routes URLs to views. For more information please see:
-    https://docs.djangoproject.com/en/1.10/topics/http/urls/
-Examples:
-Function views
-    1. Add an import:  from my_app import views
-    2. Add a URL to urlpatterns:  url(r'^$', views.home, name='home')
-Class-based views
-    1. Add an import:  from other_app.views import Home
-    2. Add a URL to urlpatterns:  url(r'^$', Home.as_view(), name='home')
-Including another URLconf
-    1. Import the include() function: from django.conf.urls import url, include
-    2. Add a URL to urlpatterns:  url(r'^blog/', include('blog.urls'))
-"""
-from django.conf.urls import url, include
 from django.contrib import admin
-
 from django.contrib.auth import views as auth_views
-#from django.views.generic.edit import CreateView
-#from django.contrib.auth.forms import UserCreationForm
 
-#from contest.forms import CustomUserCreationForm
 from contest.views import index, register, profile
 
 
-
 urlpatterns = [
-	url('^$', index, name="index"),
+    path('', index, name="index"),
-	url('^cqtufm2019/', include('contest.urls', namespace='contest')),
+    path('cqtufm2019/', include('contest.urls', namespace='contest')),
 
-    url(r'^admin/', admin.site.urls),
+    path('admin/', admin.site.urls),
-	url(r'^login/$', auth_views.login, name='login'),
+    path('login/', auth_views.LoginView.as_view(), name='login'),
-	url(r'^logout/$', auth_views.logout, {'next_page': '/'}, name='logout'),
+    path('logout/', auth_views.LogoutView.as_view(), {'next_page': '/'}, name='logout'),
-	url(r'^register/$', register, name='register'),
+    path('register/', register, name='register'),
-	url(r'^profile/$', profile, name='profile'),
+    path('profile/', profile, name='profile'),
-	#url(r'^register/$', CreateView.as_view(
+    path('api/', include('api.urls')),
-	#			template_name='registration/register.html',
-	#			form_class=CustomUserCreationForm,
-	#			success_url='/',
-	#), name='register'),
 ]

requirements.txt

@@ -1,2 +1,4 @@
-Django==1.10
+Django==4.0.1
 django-crispy-forms
+django-rest-framework
+django-filter

templates/base.html

@@ -8,7 +8,7 @@
     <meta name="description" content="">
     <meta name="author" content="">
     <link rel="icon" href="/favicon.ico">
-	{% load staticfiles %}
+	{% load static %}
 
     <title>CQTUFM2019 - CQ TU FM Contest 2019</title>
 

templates/registration/register.html

@@ -10,8 +10,11 @@
 			<div class="panel-body">
 				<p>
 				Please register with your (uppercase) Callsign as Usernames.
-				For DN-Calls, -[0-9] is allowed.
+				For DN-Calls, -[0-9] is allowed (e.g. DN1ABC-2 for the second group).
 				</p>
+                <p>
+                Note: If you are a <strong>Ham/OM/YL</strong> please with your <strong>own</strong> callsign (e.g. DL7DOC). If you are a <strong>SWL</strong>, please use the <strong>DN-Call provided</strong> by your operator.
+                </p>
 				<form method="POST" action="{% url 'register' %}">
 				{% csrf_token %}
 				{{ form|crispy }}