270 lines
9.1 KiB
Python
270 lines
9.1 KiB
Python
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
|
|
from django.urls import reverse
|
|
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
|
|
|
|
def index(request):
|
|
if request.user.is_authenticated():
|
|
return HttpResponseRedirect(reverse("contest:index"))
|
|
|
|
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")
|
|
|
|
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"))
|
|
|
|
form = None
|
|
|
|
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()
|
|
|
|
l.owner = request.user
|
|
l.save()
|
|
|
|
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
|
|
|
|
form = QSOForm(request.user, initial=data)
|
|
form.helper.form_tag = False
|
|
|
|
|
|
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"))
|
|
|
|
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()
|
|
|
|
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})
|
|
|
|
def logDelete(request, qsoid):
|
|
if not request.user.ref:
|
|
return HttpResponseRedirect(reverse("contest:index"))
|
|
|
|
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})
|
|
|
|
|
|
|
|
@staff_member_required
|
|
def registerRefs(request):
|
|
allUser = User.objects.all()
|
|
shadows = ShadowCall.objects.all()
|
|
|
|
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()
|
|
|
|
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)
|
|
|
|
|
|
@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
|
|
|
|
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", {})
|
|
|
|
@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'))
|
|
|
|
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})
|
|
|
|
@staff_member_required
|
|
def updateRef(request, shadow, uid):
|
|
user = None
|
|
form = None
|
|
|
|
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)
|
|
|
|
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
|
|
|
|
form = UpdateRefForm(initial=data)
|
|
|
|
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'))
|
|
|
|
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})
|
|
|
|
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)
|
|
|
|
return HttpResponseRedirect(reverse("contest:index"))
|
|
else:
|
|
form = CustomUserCreationForm()
|
|
|
|
return render(request, 'registration/register.html', {"form": form})
|
|
|
|
@login_required
|
|
def profile(request):
|
|
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")
|
|
|
|
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"))
|
|
|
|
if not pwForm:
|
|
pwForm = PasswordChangeForm(user=request.user)
|
|
|
|
if not catForm:
|
|
catForm = UpdateCategoryForm(initial={'entry': request.user.cat})
|
|
|
|
return render(request, 'registration/profile.html', {"pwForm": pwForm, "catForm": catForm})
|