Pep8 fixes

Reformat codebase a bit so it is easier to work with.
Make profile a modelviewset + add /me/ for current profile
2022-01-22 16:43:48 +01:00 · 2020-03-17 20:25:39 +01:00 · 2020-03-17 20:24:16 +01:00 · 2020-02-08 22:49:14 +01:00 · 2020-02-08 22:49:14 +01:00 · 2020-02-08 22:42:26 +01:00
22 changed files with 928 additions and 663 deletions
--- a/api/init.py
+++ b/api/init.py
--- a/api/admin.py
+++ b/api/admin.py
@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.
--- a/api/apps.py
+++ b/api/apps.py
@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class ApiConfig(AppConfig):
+    name = 'api'
--- a/api/migrations/init.py
+++ b/api/migrations/init.py
--- a/api/models.py
+++ b/api/models.py
@ -0,0 +1,3 @@
+from django.db import models
+
+# Create your models here.
--- a/api/serializers.py
+++ b/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')
--- a/api/tests.py
+++ b/api/tests.py
@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.
--- a/api/urls.py
+++ b/api/urls.py
@ -0,0 +1,20 @@
+from django.conf.urls import include, url
+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 = [
+    url(r'^', include(router.urls)),
+    url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework')),
+]
--- a/api/views.py
+++ b/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']
--- a/clear_contest.py
+++ b/clear_contest.py
@ -1,8 +1,6 @@
 #!/usr/bin/env python
 from __future__ import print_function

-import datetime
-
 # prepare environment
 import sys
 sys.path.append("..")
@ -11,12 +9,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")
-	sys.exit(1)
-
+    print("Aborting")
+    sys.exit(1)

 from contest.models import QSO, ShadowCall, Reference, User

--- a/contest/admin.py
+++ b/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)
--- a/contest/cbrparser.py
+++ b/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
-	look at the regex and parsingfoo, as there is some cqtu specific foo
-	inside them.
-	"""
-	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$")
+    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
+    inside them.
+    """
+    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}) "
+                       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
-	info = {
-		"call": None,
-		"location": None,
-		"qsos": [],
-	}
+    for n, line in enumerate(raw.split("\n"), 1):
+        line = line.strip()
+        # ignore empty lines
+        if line == "":
+            continue

-	for n, line in enumerate(raw.split("\n"), 1):
-		line = line.strip()
-		# ignore empty lines
-		if line == "":
-			continue
+        m = kvlinere.match(line)
+        if m:
+            k = m.group("key")
+            if k == "CALLSIGN":
+                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 m:
-			k = m.group("key")
-			if k == "CALLSIGN":
-				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
+                    if qsoData["band"] == "144":
+                        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")

-					if qsoData["band"] == "144":
-						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)

-					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"]:
-						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)
+                qsoNo += 1
+            elif k == "X-QSO":
+                qsoNo += 1

-				qsoNo += 1
-			elif k == "X-QSO":
-				qsoNo += 1
+        else:
+            raise forms.ValidationError("Error in line %d: could not parse \"KEY: value\" pair" % n)

-		else:
-			raise forms.ValidationError("Error in line %d: could not parse \"KEY: value\" pair" % n)
+    return info

-	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):
-		rawData = self.cleaned_data["data"]
-		parsedData = parseCBR(rawData)
+    def clean_data(self):
+        rawData = self.cleaned_data["data"]
+        parsedData = parseCBR(rawData)
+
+        return parsedData

-		return parsedData

 def checkCBRConsistency(contest, user, info):
-	errors = []
-	qsos = []
-	if user.username != info["call"]:
-		errors.append("You are not the owner of this logfile! (%s != %s)" % (user.username, info["call"]))
+    errors = []
+    qsos = []
+    if 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"]:
-		errors.append("Location of logfile and registered exchange do not match! (%s != %s)" % (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"]))

-	for n, qsoData in enumerate(info["qsos"], 1):
-		qsoFormData = {
-			#"owner": user,
-			"time": qsoData["datetime"],
-			"call": qsoData["call_r"],
-			"band": Band.objects.get(contest=contest, name=qsoData["band"]).id,
-			"reportTX": qsoData["rst_s"],
-			"reportRX": qsoData["rst_r"],
-			"ownNo": qsoData["no_s"],
-			"otherNo": None,
-			"refStr": qsoData["exc_r"],
-			"remarks": "",
-		}
+    for n, qsoData in enumerate(info["qsos"], 1):
+        qsoFormData = {
+            "time": qsoData["datetime"],
+            "call": qsoData["call_r"],
+            "band": Band.objects.get(contest=contest, name=qsoData["band"]).id,
+            "reportTX": qsoData["rst_s"],
+            "reportRX": qsoData["rst_r"],
+            "ownNo": qsoData["no_s"],
+            "otherNo": None,
+            "refStr": qsoData["exc_r"],
+            "remarks": "",
+        }

-		qsoForm = QSOFormWithTime(user, data=qsoFormData)
-		qsoForm.is_valid()
-		qsoForm.instance.owner = user
-		print(qsoForm.errors)
-		qsos.append((qsoForm.instance, qsoForm))
+        qsoForm = QSOFormWithTime(user, data=qsoFormData)
+        qsoForm.is_valid()
+        qsoForm.instance.owner = user
+        print(qsoForm.errors)
+        qsos.append((qsoForm.instance, qsoForm))
+
+    return qsos, errors

-	return qsos, errors

@login_required
 def uploadCBR(request):
-	if not request.user.ref:
-		return HttpResponseRedirect(reverse("contest:index"))
+    if not request.user.ref:
+        return HttpResponseRedirect(reverse("contest:index"))

-	contest = Contest.objects.get(id=1)
-	deadline = False
-	form = None
-	verifyData = []
-	verifyErrors = []
-	save = saved = False
+    contest = Contest.objects.get(id=1)
+    deadline = False
+    form = None
+    verifyData = []
+    verifyErrors = []
+    save = saved = False

-	if timezone.now() < contest.deadline:
-		if request.method == "POST":
-			form = CBRForm(data=request.POST)
-			if form.is_valid():
-				verifyData, verifyErrors = checkCBRConsistency(contest, request.user, form.cleaned_data["data"])
+    if timezone.now() < contest.deadline:
+        if request.method == "POST":
+            form = CBRForm(data=request.POST)
+            if form.is_valid():
+                verifyData, verifyErrors = checkCBRConsistency(contest, request.user, form.cleaned_data["data"])

-				if request.POST.get("action") == "save":
-					save = True
-					if not verifyErrors:
-						cnt = 0
-						for qso, qsoForm in verifyData:
-							if qsoForm.is_valid():
-								qso.save()
-								cnt += 1
+                if request.POST.get("action") == "save":
+                    save = True
+                    if not verifyErrors:
+                        cnt = 0
+                        for qso, qsoForm in verifyData:
+                            if qsoForm.is_valid():
+                                qso.save()
+                                cnt += 1

-						if cnt > 0:
-							messages.success(request, "%d QSOs have been saved from the cbr file" % cnt)
-						else:
-							messages.warnnig(request, "CBR file was parsed, but no QSOs could be saved, as all cointained errors.")
+                        if cnt > 0:
+                            messages.success(request, "%d QSOs have been saved from the cbr file" % cnt)
+                        else:
+                            messages.warnnig(request, "CBR file was parsed, but no QSOs could be saved, "
+                                                      "as all cointained errors.")

-						return HttpResponseRedirect(reverse("contest:uploadCBR"))
-		else:
-			form = CBRForm()
-	else:
-		deadline = True
+                        return HttpResponseRedirect(reverse("contest:uploadCBR"))
+        else:
+            form = CBRForm()
+    else:
+        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})
--- a/contest/forms.py
+++ b/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()])
-	email = forms.EmailField(required=True)
+class CustomUserCreationForm(UserCreationForm):
+    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)
-	newRefName = forms.CharField(max_length=50, label="New Exchange", help_text="Enter name of new exchange, if we should create a new", required=False)
+    existingRef = forms.ModelChoiceField(label="Existing Exchange", queryset=Reference.objects.all(),
+                                         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)
-	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")
+    location = forms.CharField(max_length=128, label='Exact Location',
+                               help_text="E.g. MAR bei den Fahrstuehlen, TEL 15. OG", required=False)
+    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):
-		data = self.cleaned_data["newRefName"].strip().upper()
+    def clean_newRefName(self):
+        data = self.cleaned_data["newRefName"].strip().upper()

-		return data
+        return data

-	def clean(self):
-		cleaned_data = super(UpdateRefForm, self).clean()
+    def clean(self):
+        cleaned_data = super(UpdateRefForm, self).clean()

-		existingRef = cleaned_data.get("existingRef")
-		newRefName = cleaned_data.get("newRefName")
+        existingRef = cleaned_data.get("existingRef")
+        newRefName = cleaned_data.get("newRefName")

-		if newRefName:
-			try:
-				ref = Reference.objects.get(name=newRefName)
-				self.cleaned_data['newRefName'] = None
-				self.cleaned_data['existingRef'] = ref
-			except Reference.DoesNotExist:
-				pass
+        if newRefName:
+            try:
+                ref = Reference.objects.get(name=newRefName)
+                self.cleaned_data['newRefName'] = None
+                self.cleaned_data['existingRef'] = ref
+            except Reference.DoesNotExist:
+                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())
-	def __init__(self, *args, **kwargs):
-		super(UpdateCategoryForm, self).__init__(*args, **kwargs)
+    entry = forms.ModelChoiceField(label="Entry category", queryset=EntryCategory.objects.all())

-		self.helper = FormHelper()
-		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 __init__(self, *args, **kwargs):
+        super(UpdateCategoryForm, self).__init__(*args, **kwargs)

-	def clean(self):
-		contest = Contest.objects.get(id=1)
+        self.helper = FormHelper()
+        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:
-		model = QSO
-		#fields = ["ownNo", "band", "call", "reportTX", "reportRX", "refStr", "otherNo", "remarks"]
-		fields = ["ownNo", "band", "call", "reportTX", "reportRX", "refStr", "remarks"]
+    class Meta:
+        model = QSO
+        # fields = ["ownNo", "band", "call", "reportTX", "reportRX", "refStr", "otherNo", "remarks"]
+        fields = ["ownNo", "band", "call", "reportTX", "reportRX", "refStr", "remarks"]

-	def __init__(self, user, *args, **kwargs):
-		super(QSOForm, self).__init__(*args, **kwargs)
-		self.user = user
+    def __init__(self, user, *args, **kwargs):
+        super(QSOForm, self).__init__(*args, **kwargs)
+        self.user = user

-		self.helper = FormHelper()
-		self.helper.form_id = "qso-log-form"
-		#self.helper.form_class = "form-inline "
-		#self.helper.form_class = "form-horizontal"
-		#self.helper.form_style = 'inline'
-		#self.helper.field_template = "bootstrap3/layout/inline_field.html"
-		self.helper.action = reverse("contest:log")
-		self.helper.add_input(Submit('submit', 'Log'))
-		#self.helper.layout = Layout(
-		#	#*(QSOForm.Meta.fields +  [ButtonHolder(Submit('submit', 'Submit', css_class='button white'))]))
-		#	*(QSOForm.Meta.fields +  [FormActions(Submit('submit', 'Log!'))]))
+        self.helper = FormHelper()
+        self.helper.form_id = "qso-log-form"
+        # self.helper.form_class = "form-inline "
+        # self.helper.form_class = "form-horizontal"
+        # self.helper.form_style = 'inline'
+        # self.helper.field_template = "bootstrap3/layout/inline_field.html"
+        self.helper.action = reverse("contest:log")
+        self.helper.add_input(Submit('submit', 'Log'))
+        # self.helper.layout = Layout(
+        #     #*(QSOForm.Meta.fields +  [ButtonHolder(Submit('submit', 'Submit', css_class='button white'))]))
+        #     *(QSOForm.Meta.fields +  [FormActions(Submit('submit', 'Log!'))]))

+    def clean_call(self):
+        data = self.cleaned_data["call"].upper().strip()

-	def clean_call(self):
-		data = self.cleaned_data["call"].upper().strip()
-		if Reference.objects.filter(name=data).count() > 0:
-			raise forms.ValidationError("Reference already exists")
+        try:
+            CallLogValidator()(data)
+        except forms.ValidationError:
+            raise forms.ValidationError("Enter a valid callsign (1-2 chars, a number, 1-4 chars, maybe a /[A-Z])")

-		try:
-			CallLogValidator()(data)
-		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:
+            raise forms.ValidationError("You cannot log QSOs with yourself")

-		if data == self.user.username:
-			raise forms.ValidationError("You cannot log QSOs with yourself")
+        return data

-		return data
+    def clean_ownNo(self):
+        data = self.cleaned_data["ownNo"]

-	def clean_ownNo(self):
-		data = self.cleaned_data["ownNo"]
+        if data < 1 or data > 100000:
+            raise forms.ValidationError("Number has to be in range of [1, 1000000]")

-		if data < 1 or data > 100000:
-			raise forms.ValidationError("Number has to be in range of [1, 1000000]")
+        try:
+            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:
-                    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

-                return data
+    def clean_otherNo(self):
+        data = self.cleaned_data["otherNo"]

-	def clean_otherNo(self):
-		data = self.cleaned_data["otherNo"]
+        if not data:
+            # empty value
+            return None

-		if not data:
-			# empty value
-			return None
+        if data < 1 or data > 100000:
+            raise forms.ValidationError("Number has to be in range of [1, 1000000]")

-		if data < 1 or data > 100000:
-			raise forms.ValidationError("Number has to be in range of [1, 1000000]")
+        return data

-		return data
+    def clean_refStr(self):
+        return self.cleaned_data["refStr"].upper()

-	def clean_refStr(self):
-		return self.cleaned_data["refStr"].upper()
+    def clean(self):
+        cleaned_data = super(QSOForm, self).clean()
+        band = cleaned_data.get("band")

-	def clean(self):
-		cleaned_data = super(QSOForm, self).clean()
-		band = cleaned_data.get("band")
+        if band.contest.deadline < timezone.now():
+            raise forms.ValidationError("The deadline for logging and editing QSOs has passed")

-		if band.contest.deadline < timezone.now():
-			raise forms.ValidationError("The deadline for logging and editing QSOs has passed")

 class QSOFormWithTime(QSOForm):
-	class Meta:
-		model = QSO
-		#fields = ["time", "ownNo", "band", "call", "reportTX", "reportRX", "otherNo", "refStr", "remarks"]
-		fields = ["time", "ownNo", "band", "call", "reportTX", "reportRX", "refStr", "remarks"]
+    class Meta:
+        model = QSO
+        # fields = ["time", "ownNo", "band", "call", "reportTX", "reportRX", "otherNo", "refStr", "remarks"]
+        fields = ["time", "ownNo", "band", "call", "reportTX", "reportRX", "refStr", "remarks"]
+

 class ShadowCallAddForm(forms.ModelForm):

-	class Meta:
-		model = ShadowCall
-		fields = ['username']
+    class Meta:
+        model = ShadowCall
+        fields = ['username']

-	def __init__(self, *args, **kwargs):
-		super(ShadowCallAddForm, self).__init__(*args, **kwargs)
+    def __init__(self, *args, **kwargs):
+        super(ShadowCallAddForm, self).__init__(*args, **kwargs)

-		self.helper = FormHelper()
-		self.helper.form_class = "form-inline "
-		self.helper.form_style = 'inline'
-		self.helper.field_template = "bootstrap3/layout/inline_field.html"
-		self.helper.action = reverse("contest:registerRefs")
-		self.helper.add_input(Submit('submit', 'Add shadow'))
-		self.helper.layout = Layout('username')
+        self.helper = FormHelper()
+        self.helper.form_class = "form-inline "
+        self.helper.form_style = 'inline'
+        self.helper.field_template = "bootstrap3/layout/inline_field.html"
+        self.helper.action = reverse("contest:registerRefs")
+        self.helper.add_input(Submit('submit', 'Add shadow'))
+        self.helper.layout = Layout('username')

-	def clean_username(self):
-		data = self.cleaned_data["username"]
-		if User.objects.filter(username=data).count() > 0:
-			raise forms.ValidationError("A user with this call already exists, this is not a shadow!")
+    def clean_username(self):
+        data = self.cleaned_data["username"]
+        if User.objects.filter(username=data).count() > 0:
+            raise forms.ValidationError("A user with this call already exists, this is not a shadow!")

-		return data
+        return data
--- a/contest/models.py
+++ b/contest/models.py
@ -2,245 +2,265 @@ 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)
-	shortName = models.CharField(max_length=20, unique=True)
-	callQrg = models.ForeignKey("Frequency", models.SET_NULL, null=True, blank=True)
-	deadline = models.DateTimeField()
+    name = models.CharField(max_length=20)
+    shortName = models.CharField(max_length=20, unique=True)
+    callQrg = models.ForeignKey("Frequency", models.SET_NULL, null=True, blank=True)
+    deadline = models.DateTimeField()

-	qsoStartTime = models.DateTimeField()
-	qsoEndTime = models.DateTimeField()
+    qsoStartTime = 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)
-	description = models.TextField()
+    name = models.CharField(max_length=20, unique=True, db_index=True)
+    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)
-	description = models.TextField(blank=True)
+    name = models.CharField(max_length=64, unique=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()])
-	ref = models.ForeignKey(Reference, models.SET_NULL,null=True, blank=True)
+    username = models.CharField(max_length=20, unique=True, db_index=True, validators=[CallUsernameValidator()])
+    ref = models.ForeignKey(Reference, models.SET_NULL, null=True, blank=True)

-	location = models.CharField(max_length=128, default="", blank=True)
-	opName = models.CharField(max_length=128, default="", blank=True)
-	regTime = models.DateTimeField(null=True, default=None)
+    location = models.CharField(max_length=128, default="", blank=True)
+    opName = models.CharField(max_length=128, default="", blank=True)
+    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)
-	cat = models.ForeignKey(EntryCategory, 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)

-	location = models.CharField(max_length=128, default="", blank=True)
-	opName = models.CharField(max_length=128, default="", blank=True)
-	regTime = models.DateTimeField(null=True, default=None)
+    location = models.CharField(max_length=128, default="", blank=True)
+    opName = models.CharField(max_length=128, default="", blank=True)
+    regTime = models.DateTimeField(null=True, default=None, blank=True)

-	# because of cbr parsing bug, we sometimes have users who only have 70cm qsos
-	# we ignore the band for them when checking QSOs
-	ignoreBand = models.BooleanField(default=False)
+    # because of cbr parsing bug, we sometimes have users who only have 70cm qsos
+    # we ignore the band for them when checking QSOs
+    ignoreBand = models.BooleanField(default=False)

-	# extra profile stuff so DL7BST can sleep well without his doodles
-	editedProfile = models.BooleanField(default=False)
-	dncall = models.CharField(max_length=16, default='', blank=True,
-								verbose_name="DN-Call",
-								help_text="If you have a DN call that you will offer to SWLs please enter it here")
-	qrv2m = models.BooleanField(default=False,
-								verbose_name="QRV on 2m",
-								help_text="Will you be QRV on 2m during the contest?")
-	qrv70cm = models.BooleanField(default=False,
-									verbose_name="QRV on 70cm",
-									help_text="Will you be QRV on 70cm during the contest?")
-	extra2m70cm = models.BooleanField(default=False,
-                                        verbose_name="Additional 2m/70cm TRX",
-                                        help_text="Will you bring an additional 2m/70cm TRX to lend to other participants?")
+    # extra profile stuff so DL7BST can sleep well without his doodles
+    editedProfile = models.BooleanField(default=False)
+    dncall = models.CharField(max_length=16, default='', blank=True,
+                              verbose_name="DN-Call",
+                              help_text="If you have a DN call that you will offer to SWLs please enter it here")
+    qrv2m = models.BooleanField(default=False,
+                                verbose_name="QRV on 2m",
+                                help_text="Will you be QRV on 2m during the contest?")
+    qrv70cm = models.BooleanField(default=False,
+                                  verbose_name="QRV on 70cm",
+                                  help_text="Will you be QRV on 70cm during the contest?")
+    extra2m70cm = models.BooleanField(default=False,
+                                      verbose_name="Additional 2m/70cm TRX",
+                                      help_text="Will you bring an additional 2m/70cm TRX to lend to "
+                                                "other participants?")

-	def __init__(self, *args, **kwargs):
-		super(User, self).__init__(*args, **kwargs)
-		self._meta.get_field("username").validators = [CallUsernameValidator()]
+    def __init__(self, *args, **kwargs):
+        super(User, self).__init__(*args, **kwargs)
+        self._meta.get_field("username").validators = [CallUsernameValidator()]

-	def getQSOCount(self):
-		return self.qso_set.count()
+    def getQSOCount(self):
+        return self.qso_set.count()

-	def getCfmdQSOCount(self):
-		return self.qso_set.filter(~Q(cfmdQSO=None)).count()
+    def getCfmdQSOCount(self):
+        return self.qso_set.filter(~Q(cfmdQSO=None)).count()

-	def getCfmdRefCount(self):
-		return len(set(map(lambda _x: _x["refStr"], self.qso_set.filter(ref__isnull=False).values("ref", "refStr"))))
+    def getCfmdRefCount(self):
+        return len(set(map(lambda _x: _x["refStr"], self.qso_set.filter(ref__isnull=False).values("ref", "refStr"))))

-	def calcClaimedPoints(self):
-		return self.calcPoints(cfmd=False)
+    def calcClaimedPoints(self):
+        return self.calcPoints(cfmd=False)

-	def calcCfmdPoints(self):
-		return self.calcPoints(cfmd=True)
+    def calcCfmdPoints(self):
+        return self.calcPoints(cfmd=True)

-	def calcPoints(self, cfmd):
-		contest = Contest.objects.get(id=1)
+    def calcPoints(self, cfmd):
+        contest = Contest.objects.get(id=1)

-		result = {"refCount": 0, "qsoCount": 0}
-		for band in contest.band_set.all():
-			result[band.name] = self.calcBandPoints(band, cfmd)
-			result["refCount"] += result[band.name]["refCount"]
-			result["qsoCount"] += result[band.name]["qsoCount"]
+        result = {"refCount": 0, "qsoCount": 0}
+        for band in contest.band_set.all():
+            result[band.name] = self.calcBandPoints(band, cfmd)
+            result["refCount"] += result[band.name]["refCount"]
+            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):
-		return self.name
+class Band(models.Model):
+    name = models.CharField(max_length=10)
+    contest = models.ForeignKey(Contest)
+
+    def __str__(self):
+        return self.name
+

 class Frequency(models.Model):
-	# qrg
-	# band
-	channel = models.CharField(max_length=3)
-	qrg = models.DecimalField(max_digits=7, decimal_places=3)
-	band = models.ForeignKey(Band)
+    # qrg
+    # band
+    channel = models.CharField(max_length=3)
+    qrg = models.DecimalField(max_digits=7, decimal_places=3)
+    band = models.ForeignKey(Band)

-	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:
-		index_together = [
-			["owner", "call"],
-		]
+    class Meta:
+        index_together = [
+            ["owner", "call"],
+        ]

-	owner = models.ForeignKey(User, db_index=True)
-	time = models.DateTimeField(blank=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)
-	band = models.ForeignKey(Band)
+    owner = models.ForeignKey(User, db_index=True)
+    time = models.DateTimeField(blank=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)
+    band = models.ForeignKey(Band)

-	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])
+    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])

-	ownNo = models.IntegerField(verbose_name='No')
-	otherNo = models.IntegerField(verbose_name='No-R', null=True, blank=True)
+    ownNo = models.IntegerField(verbose_name='No', validators=[MinValueValidator(1), MaxValueValidator(MAX_NO_VALUE)])
+    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")
-	ref = models.ForeignKey(Reference, models.SET_NULL, null=True, blank=True)
+    refStr = models.CharField(max_length=20, verbose_name="EXC")
+    ref = models.ForeignKey(Reference, 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", models.SET_NULL, null=True, blank=True, default=None)

-	CFMD_SEC = 5*60
+    CFMD_SEC = 5 * 60

-	def checkQSOData(self):
-		""" Match strdata to log rows. Only call, if you intent to save this object if we return True! """
-		# find reference
-		changed = False
-		if self.refStr:
-			refName = self.refStr.replace("-", "")
-			if refName == "GX":
-				refName = "DX"
+    def checkQSOData(self):
+        """ Match strdata to log rows. Only call, if you intent to save this object if we return True! """
+        # find reference
+        changed = False
+        if self.refStr:
+            refName = self.refStr.replace("-", "")
+            if refName == "GX":
+                refName = "DX"

-			# Old reference exists?
-			if self.ref and self.ref.name != refName:
-				self.ref = None
-				changed = True
+            # Old reference exists?
+            if self.ref and self.ref.name != refName:
+                self.ref = None
+                changed = True

-			if not self.ref:
-				# find matching ref
-				try:
-					self.ref = Reference.objects.get(name=refName)
-					changed = True
-				except Reference.DoesNotExist:
-					pass
+            if not self.ref:
+                # find matching ref
+                try:
+                    self.ref = Reference.objects.get(name=refName)
+                    changed = True
+                except Reference.DoesNotExist:
+                    pass

-		# find call
-		if not self.callRef or self.callRef.username != self.call:
-			try:
-				self.callRef = User.objects.get(username=self.call)
-				changed = True
-			except User.DoesNotExist:
-				if self.callRef:
-					changed = True
-				self.callRef = None
+        # find call
+        if not self.callRef or self.callRef.username != self.call:
+            try:
+                self.callRef = User.objects.get(username=self.call)
+                changed = True
+            except User.DoesNotExist:
+                if self.callRef:
+                    changed = True
+                self.callRef = None

-		# find matching qso
-		if self.cfmdQSO:
-			# check if this still checks out
-			q = self.cfmdQSO
-			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 \
-				q.owner == self.callRef and q.callRef == self.owner and \
-				self.ref == q.owner.ref and self.owner.ref == q.ref and \
-				self.band == q.band:
-				# checks out
-				pass
-			else:
-				changed = True
-				self.cfmdQSO.cfmdQSO = None
-				self.cfmdQSO.save(checkQSO=False)
-				self.cfmdQSO = None
+        # find matching qso
+        if self.cfmdQSO:
+            # check if this still checks out
+            q = self.cfmdQSO
+            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 \
+                    q.owner == self.callRef and q.callRef == self.owner and \
+                    self.ref == q.owner.ref and self.owner.ref == q.ref and \
+                    self.band == q.band:
+                # checks out
+                pass
+            else:
+                changed = True
+                self.cfmdQSO.cfmdQSO = None
+                self.cfmdQSO.save(checkQSO=False)
+                self.cfmdQSO = None

-		if self.ref and self.callRef and self.callRef.ref and not self.cfmdQSO:
-			# look for a matching line
-			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))),
-				owner=self.callRef,
-				callRef=self.owner,
-				owner__ref=self.ref,
-				ref=self.owner.ref,
-				band=self.band)
+        if self.ref and self.callRef and self.callRef.ref and not self.cfmdQSO:
+            # look for a matching line
+            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))),
+                owner=self.callRef,
+                callRef=self.owner,
+                owner__ref=self.ref,
+                ref=self.owner.ref,
+                band=self.band)

-			if q.count() == 1:
-				changed = True
-				q[0].cfmdQSO = self
-				q[0].save(checkQSO=False)
-				self.cfmdQSO = q[0]
+            if q.count() == 1:
+                changed = True
+                q[0].cfmdQSO = self
+                q[0].save(checkQSO=False)
+                self.cfmdQSO = q[0]

-		return changed
+        return changed

-	def save(self, checkQSO=True, *args, **kwargs):
-		if checkQSO:
-			self.checkQSOData()
+    def save(self, checkQSO=True, *args, **kwargs):
+        if checkQSO:
+            self.checkQSOData()

-		super(QSO, self).save(*args, **kwargs)
+        super(QSO, self).save(*args, **kwargs)

-	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)
+    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)
--- a/contest/signals.py
+++ b/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. """
-	if created:
-		# to prevent circular imports we import ShadowCall here
-		from .models import ShadowCall
+    """ Check for existing shadow call. If present copy it's data and delete it. """
+    if created:
+        # to prevent circular imports we import ShadowCall here
+        from .models import ShadowCall

-		try:
-			shadow = ShadowCall.objects.get(username=instance.username)
-			instance.ref = shadow.ref
-			instance.location = shadow.location
-			instance.opName = shadow.opName
-			instance.regTime = shadow.regTime
+        try:
+            shadow = ShadowCall.objects.get(username=instance.username)
+            instance.ref = shadow.ref
+            instance.location = shadow.location
+            instance.opName = shadow.opName
+            instance.regTime = shadow.regTime

-			instance.save()
-			shadow.delete()
-		except ShadowCall.DoesNotExist:
-			pass
+            instance.save()
+            shadow.delete()
+        except ShadowCall.DoesNotExist:
+            pass
--- a/contest/urls.py
+++ b/contest/urls.py
@ -20,16 +20,16 @@ import contest.views as contest_views
 from contest.cbrparser import uploadCBR

 urlpatterns = [
-	url(r'^$', contest_views.contestIndex, name='index'),
-	url(r'^regref/$', contest_views.registerRefs, name='registerRefs'),
-	url(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'),
-	url(r'^regref/qsos/all/$', contest_views.viewAllQSOs, name='viewAllQSOs'),
-	url(r'^regref/qsos/user/(?P<uid>\d+)/$', contest_views.viewUserQSOs, name='viewUserQSOs'),
-	url(r'^overview/$', contest_views.overview, name='overview'),
-	url(r'^log/$', contest_views.log, name='log'),
-	url(r'^log/edit/(?P<qsoid>\d+)/$', contest_views.logEdit, name='logEdit'),
-	url(r'^log/delete/(?P<qsoid>\d+)/$', contest_views.logDelete, name='logDelete'),
-	url(r'^uploadcbr/$', uploadCBR, name='uploadCBR'),
-	url(r'^regref/recheckqsos/$', contest_views.recheckAllQSOs, name='recheckAllQSOs'),
+    url(r'^$', contest_views.contestIndex, name='index'),
+    url(r'^regref/$', contest_views.registerRefs, name='registerRefs'),
+    url(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'),
+    url(r'^regref/qsos/all/$', contest_views.viewAllQSOs, name='viewAllQSOs'),
+    url(r'^regref/qsos/user/(?P<uid>\d+)/$', contest_views.viewUserQSOs, name='viewUserQSOs'),
+    url(r'^overview/$', contest_views.overview, name='overview'),
+    url(r'^log/$', contest_views.log, name='log'),
+    url(r'^log/edit/(?P<qsoid>\d+)/$', contest_views.logEdit, name='logEdit'),
+    url(r'^log/delete/(?P<qsoid>\d+)/$', contest_views.logDelete, name='logDelete'),
+    url(r'^uploadcbr/$', uploadCBR, name='uploadCBR'),
+    url(r'^regref/recheckqsos/$', contest_views.recheckAllQSOs, name='recheckAllQSOs'),
 ]
--- a/contest/validators.py
+++ b/contest/validators.py
@ -8,7 +8,6 @@ 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,'
@ -18,11 +17,9 @@ class CallUsernameValidator(validators.RegexValidator):

@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
-
--- a/contest/views.py
+++ b/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():
-		return HttpResponseRedirect(reverse("contest:index"))
+    if request.user.is_authenticated():
+        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)
-	contest = Contest.objects.get(id=1)
-	qrgs = Frequency.objects.filter(band__contest=contest).order_by("channel")
+    qsoform = QSOForm(request.user)
+    contest = Contest.objects.get(id=1)
+    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:
-		return HttpResponseRedirect(reverse("contest:index"))
+    if not request.user.ref:
+        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':
-		form = QSOForm(user=request.user, data=request.POST)
-		form.helper.form_tag = False
-		if form.is_valid():
-			l = form.instance
-			if not l.time:
-				# set current time
-				l.time = datetime.datetime.now()
+    if request.method == 'POST':
+        form = QSOForm(user=request.user, data=request.POST)
+        form.helper.form_tag = False
+        if form.is_valid():
+            l = form.instance
+            if not l.time:
+                # set current time
+                l.time = datetime.datetime.now()

-			l.owner = request.user
-			l.save()
+            l.owner = request.user
+            l.save()

-			messages.success(request, "QSO saved!")
+            messages.success(request, "QSO saved!")

-			return HttpResponseRedirect(reverse("contest:log"))
-	else:
-		data = {
-			"ownNo": qsos[0].ownNo + 1 if len(qsos) > 0 else 1,
-			"reportRX": "59",
-			"reportTX": "59",
-		}
-		if qsos.count() > 0:
-			data["band"] = qsos[0].band
+            return HttpResponseRedirect(reverse("contest:log"))
+    else:
+        data = {
+            "ownNo": qsos[0].ownNo + 1 if len(qsos) > 0 else 1,
+            "reportRX": "59",
+            "reportTX": "59",
+        }
+        if qsos.count() > 0:
+            data["band"] = qsos[0].band

-		form = QSOForm(request.user, initial=data)
-		form.helper.form_tag = False
+        form = QSOForm(request.user, initial=data)
+        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:
-		return HttpResponseRedirect(reverse("contest:index"))
+    if not request.user.ref:
+        return HttpResponseRedirect(reverse("contest:index"))

-	qso = QSO.objects.get(id=qsoid, owner=request.user)
-	form = None
+    qso = QSO.objects.get(id=qsoid, owner=request.user)
+    form = None

-	if request.method == 'POST':
-		form = QSOFormWithTime(user=request.user, instance=qso, data=request.POST)
-		if form.is_valid():
-			form.instance.save()
+    if request.method == 'POST':
+        form = QSOFormWithTime(user=request.user, instance=qso, data=request.POST)
+        if form.is_valid():
+            form.instance.save()

-			messages.info(request, "QSO has been edited")
-			return HttpResponseRedirect(reverse("contest:log"))
-	else:
-		form = QSOFormWithTime(user=request.user, instance=qso)
+            messages.info(request, "QSO has been edited")
+            return HttpResponseRedirect(reverse("contest:log"))
+    else:
+        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:
-		return HttpResponseRedirect(reverse("contest:index"))
+    if not request.user.ref:
+        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 "delete" in request.POST:
-			if request.POST["delete"].lower() == "yes":
-				qso.delete()
-				messages.info(request, "QSO has been deleted")
-				return HttpResponseRedirect(reverse("contest:log"))
-			elif request.POST["delete"].lower() == "no":
-				return HttpResponseRedirect(reverse("contest:log"))
-
-	return render(request, 'contest/logDelete.html', {"qso": qso})
+    if request.method == 'POST':
+        if "delete" in request.POST:
+            if request.POST["delete"].lower() == "yes":
+                qso.delete()
+                messages.info(request, "QSO has been deleted")
+                return HttpResponseRedirect(reverse("contest:log"))
+            elif request.POST["delete"].lower() == "no":
+                return HttpResponseRedirect(reverse("contest:log"))

+    return render(request, 'contest/logDelete.html', {"qso": qso})


@staff_member_required
 def registerRefs(request):
-	allUser = User.objects.all()
-	shadows = ShadowCall.objects.all()
+    allUser = User.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
-	if request.method == 'POST':
-		shadowForm = ShadowCallAddForm(data=request.POST)
-		if shadowForm.is_valid():
-			shadowForm.instance.save()
-			messages.success(request, "Successfully added shadow user %s" % (shadowForm.instance.username,))
-			return HttpResponseRedirect(reverse("contest:registerRefs"))
-	else:
-		shadowForm = ShadowCallAddForm()
+    shadowForm = None
+    if request.method == 'POST':
+        shadowForm = ShadowCallAddForm(data=request.POST)
+        if shadowForm.is_valid():
+            shadowForm.instance.save()
+            messages.success(request, "Successfully added shadow user %s" % (shadowForm.instance.username,))
+            return HttpResponseRedirect(reverse("contest:registerRefs"))
+    else:
+        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:
-		return paginator.page(pageNo)
-	except PageNotAnInteger:
-		return paginator.page(1)
-	except EmptyPage:
-		return paginator.page(paginator.num_pages)
+    try:
+        return paginator.page(pageNo)
+    except PageNotAnInteger:
+        return paginator.page(1)
+    except EmptyPage:
+        return paginator.page(paginator.num_pages)


@staff_member_required
 def recheckAllQSOs(request):
-	if request.method == "POST":
-		cnt = 0
-		for qso in QSO.objects.all():
-			if qso.checkQSOData():
-				print(qso)
-				qso.save()
-				cnt += 1
+    if request.method == "POST":
+        cnt = 0
+        for qso in QSO.objects.all():
+            if qso.checkQSOData():
+                print(qso)
+                qso.save()
+                cnt += 1

-		messages.success(request, "Allo QSO have been checked against each other (%d QSOs modified)" % (cnt,))
-		return HttpResponseRedirect(reverse("contest:registerRefs"))
+        messages.success(request, "Allo QSO have been checked against each other (%d QSOs modified)" % (cnt,))
+        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)
-	qsos = QSO.objects.filter(owner=user).order_by("-time")
-	qsoPager = Paginator(qsos, 50)
-	qsoPage = getPage(qsoPager, request.GET.get('page'))
+    user = get_object_or_404(User, id=uid)
+    qsos = QSO.objects.filter(owner=user).order_by("-time")
+    qsoPager = Paginator(qsos, 50)
+    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
-	form = None
+    user = None
+    form = None

-	if shadow:
-		user = get_object_or_404(ShadowCall, id=uid)
-	else:
-		user = get_object_or_404(User, id=uid)
+    if shadow:
+        user = get_object_or_404(ShadowCall, id=uid)
+    else:
+        user = get_object_or_404(User, id=uid)

-	if request.method == 'POST':
-		form = UpdateRefForm(data=request.POST)
-		if form.is_valid():
-			ref = None
-			if form.cleaned_data["existingRef"]:
-				ref = form.cleaned_data["existingRef"]
-			else:
-				ref = Reference(name=form.cleaned_data["newRefName"])
-				ref.save()
-				messages.info(request, "New Ref '%s' created" % ref)
+    if request.method == 'POST':
+        form = UpdateRefForm(data=request.POST)
+        if form.is_valid():
+            ref = None
+            if form.cleaned_data["existingRef"]:
+                ref = form.cleaned_data["existingRef"]
+            else:
+                ref = Reference(name=form.cleaned_data["newRefName"])
+                ref.save()
+                messages.info(request, "New Ref '%s' created" % ref)

-			user.ref = ref
-			user.regTime = form.cleaned_data["regTime"]
-			user.location = form.cleaned_data["location"]
-			user.opName = form.cleaned_data["opName"]
-			user.save()
-			messages.success(request, "%s%s ref set to %s" % ("(shadow) " if shadow else "", user, ref))
-			return HttpResponseRedirect(reverse("contest:registerRefs"))
-	else:
-		data = {}
-		if user.ref:
-			data["existingRef"] = user.ref
+            user.ref = ref
+            user.regTime = form.cleaned_data["regTime"]
+            user.location = form.cleaned_data["location"]
+            user.opName = form.cleaned_data["opName"]
+            user.save()
+            messages.success(request, "%s%s ref set to %s" % ("(shadow) " if shadow else "", user, ref))
+            return HttpResponseRedirect(reverse("contest:registerRefs"))
+    else:
+        data = {}
+        if user.ref:
+            data["existingRef"] = user.ref

-		if user.regTime:
-			data["regTime"] = user.regTime
-		else:
-			data["regTime"] = timezone.now()
-		data["opName"] = user.opName
-		data["location"] = user.location
+        if user.regTime:
+            data["regTime"] = user.regTime
+        else:
+            data["regTime"] = timezone.now()
+        data["opName"] = user.opName
+        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")
-	qsoPager = Paginator(qsos, 10)
-	qsoPage = getPage(qsoPager, request.GET.get('page'))
+    qsos = QSO.objects.all().order_by("-time")
+    qsoPager = Paginator(qsos, 10)
+    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
-	c = Contest.objects.get(id=1)
-	qrgs = Frequency.objects.filter(band__contest=c).order_by("channel")
-	return render(request, 'contest/overview.html', {'contest': c, 'qrgs': qrgs})
+    # FIXME: Hardcoded for cqtu... everywhere
+    c = Contest.objects.get(id=1)
+    qrgs = Frequency.objects.filter(band__contest=c).order_by("channel")
+    return render(request, 'contest/overview.html', {'contest': c, 'qrgs': qrgs})
+

 def register(request):
-	form = None
-	if request.method == 'POST':
-		form = CustomUserCreationForm(data=request.POST)
-		if form.is_valid():
-			form.save()
-			auth_login(request, form.instance)
-			messages.info(request, "Registration as user %s successfull!" % form.instance.username)
+    form = None
+    if request.method == 'POST':
+        form = CustomUserCreationForm(data=request.POST)
+        if form.is_valid():
+            form.save()
+            auth_login(request, form.instance)
+            messages.info(request, "Registration as user %s successfull!" % form.instance.username)

-			return HttpResponseRedirect(reverse("contest:index"))
-	else:
-		form = CustomUserCreationForm()
+            return HttpResponseRedirect(reverse("contest:index"))
+    else:
+        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
-	catForm = None
+    pwForm = None
+    catForm = None

-	if request.method == 'POST':
-		if request.POST.get("submit", None) == "pwchange":
-			pwForm = PasswordChangeForm(user=request.user, data=request.POST)
-			if pwForm.is_valid():
-				pwForm.save()
-				auth_login(request, pwForm.user)
-				messages.success(request, "Password changed")
+    if request.method == 'POST':
+        if request.POST.get("submit", None) == "pwchange":
+            pwForm = PasswordChangeForm(user=request.user, data=request.POST)
+            if pwForm.is_valid():
+                pwForm.save()
+                auth_login(request, pwForm.user)
+                messages.success(request, "Password changed")

-				return HttpResponseRedirect(reverse("profile"))
-		else:
-			catForm = UpdateCategoryForm(data=request.POST)
-			if catForm.is_valid():
-				request.user.cat = catForm.cleaned_data["entry"]
-				request.user.save()
-				messages.success(request, "Entry category set")
+                return HttpResponseRedirect(reverse("profile"))
+        else:
+            catForm = UpdateCategoryForm(data=request.POST)
+            if catForm.is_valid():
+                request.user.cat = catForm.cleaned_data["entry"]
+                request.user.save()
+                messages.success(request, "Entry category set")

-				return HttpResponseRedirect(reverse("profile"))
+                return HttpResponseRedirect(reverse("profile"))

-	if not pwForm:
-		pwForm = PasswordChangeForm(user=request.user)
+    if not pwForm:
+        pwForm = PasswordChangeForm(user=request.user)

-	if not catForm:
-		catForm = UpdateCategoryForm(initial={'entry': request.user.cat})
+    if not catForm:
+        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})
--- a/cqtu/settings.py
+++ b/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
-	'contest',
+    # local
+    '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']
+}
--- a/cqtu/urls.py
+++ b/cqtu/urls.py
@ -15,28 +15,19 @@ Including another URLconf
 """
 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"),
-	url('^cqtufm2019/', include('contest.urls', namespace='contest')),
+    url('^$', index, name="index"),
+    url('^cqtufm2019/', include('contest.urls', namespace='contest')),

    url(r'^admin/', admin.site.urls),
-	url(r'^login/$', auth_views.login, name='login'),
-	url(r'^logout/$', auth_views.logout, {'next_page': '/'}, name='logout'),
-	url(r'^register/$', register, name='register'),
-	url(r'^profile/$', profile, name='profile'),
-	#url(r'^register/$', CreateView.as_view(
-	#			template_name='registration/register.html',
-	#			form_class=CustomUserCreationForm,
-	#			success_url='/',
-	#), name='register'),
+    url(r'^login/$', auth_views.login, name='login'),
+    url(r'^logout/$', auth_views.logout, {'next_page': '/'}, name='logout'),
+    url(r'^register/$', register, name='register'),
+    url(r'^profile/$', profile, name='profile'),
+    url(r'^api/', include('api.urls')),
 ]
--- a/requirements.txt
+++ b/requirements.txt
@ -1,2 +1,4 @@
-Django==1.10
+Django<1.12
 django-crispy-forms
+django-rest-framework
+django-filter
--- a/templates/registration/register.html
+++ b/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 }}
Author	SHA1	Message	Date
Sebastian Lohff	ff94b62212	Pep8 fixes Reformat codebase a bit so it is easier to work with.	2022-01-22 16:43:48 +01:00
Sebastian Lohff	94d2f5a8d8	Make profile a modelviewset + add /me/ for current profile	2020-03-17 20:25:39 +01:00
Sebastian Lohff	59a4c73bd0	Reorganize imports of api views.py	2020-03-17 20:24:16 +01:00
Sebastian Lohff	c43c5c1e10	Move QSO no validation into model	2020-02-08 22:49:14 +01:00
Sebastian Lohff	e049e45698	Remove broken check from QSO form The check disallowed having a QSO with any callsign that is also a reference. Obviously the user should also be able to log this kind of QSO, even if it might not make sense. We don't judge.	2020-02-08 22:49:14 +01:00
Sebastian Lohff	e825685105	Add REST API to webinterface	2020-02-08 22:42:26 +01:00
Sebastian Lohff	ddb09d148e	Add REST API to webinterface	2020-02-08 22:35:24 +01:00
Sebastian Lohff	782f5cbe32	Allow regTime in user to be blank as well Without regTime being blank a user with regTime NULL cannot be edited via the admin interface	2020-02-08 22:35:24 +01:00
Sebastian Lohff	99ab46272b	Clarify choice of username at registration, again Apparently it was still unclear to people what call they should use on registration. Added extra message to explain this further.	2020-02-08 22:35:24 +01:00
Sebastian Lohff	92007bab02	clear_contest: make python3 ready, remove unused import	2020-02-08 22:35:24 +01:00
Sebastian Lohff	9efdeda3c6	Bump django version to 1.11	2020-02-08 22:35:24 +01:00
Sebastian Lohff	4b8a444f1f	Move to consistent use of spaces instead of tabs Required for python3 transition	2020-01-26 11:36:47 +01:00