cqtu/contest/models.py

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.db.models import Q, signals

from .validators import CallUsernameValidator
from .signals import checkForShadowCall

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()

    qsoStartTime = models.DateTimeField()
    qsoEndTime = models.DateTimeField()

    def __str__(self):
        return self.name

class Reference(models.Model):
    name = models.CharField(max_length=20, unique=True, db_index=True)
    description = models.TextField()

    def __str__(self):
        return self.name

class EntryCategory(models.Model):
    name = models.CharField(max_length=64, unique=True)
    description = models.TextField(blank=True)

    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)

    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

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)

    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)

    # 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 getQSOCount(self):
        return self.qso_set.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 calcClaimedPoints(self):
        return self.calcPoints(cfmd=False)

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

    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["points"] = result["qsoCount"] * result["refCount"]

        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)
        }
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 Frequency(models.Model):
    # 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)

    def __str__(self):
        return "Channel %s: %s MHz" % (self.channel, self.qrg)

class QSO(models.Model):
    reportValidator = RegexValidator("[1-5][1-9]")

    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)

    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)

    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)

    cfmdQSO = models.ForeignKey("QSO", models.SET_NULL, null=True, blank=True, default=None)

    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"

            # 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

        # 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

        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]

        return changed

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

        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)