django-cats/cats/models.py

from django.conf import settings
from django.conf.global_settings import AUTH_USER_MODEL
from django.contrib.auth.models import AbstractUser
from django.db import models

from django.utils.translation import gettext_lazy as _


class TopicType(models.Model):
    text = models.CharField(max_length=255)

    class Meta:
        verbose_name = _("topic type")

    def __str__(self):
        return self.text


class Topic(models.Model):
    topic = models.CharField(unique=True, max_length=50)
    active = models.IntegerField()
    number_of_questions = models.IntegerField()
    percentage = models.IntegerField()
    lang = models.CharField(max_length=42, blank=True, null=True)
    topic_type = models.ForeignKey(TopicType, on_delete=models.CASCADE)

    class Meta:
        verbose_name = _("topic")

    def __str__(self):
        return f"{self.topic} ({self.topic_type}, {self.lang})"


class QuestionType(models.Model):
    class Meta:
        verbose_name = _("question type")

    def get_name(self, language: str) -> str:
        if self.questiontypename_set.filter(lang=language).exists():
            return self.questiontypename_set.get(lang=language).name
        return self.questiontypename_set.get(lang="en").name


class QuestionTypeName(models.Model):
    question_type = models.ForeignKey(QuestionType, on_delete=models.CASCADE)
    lang = models.CharField(max_length=5)
    name = models.CharField(max_length=25)

    class Meta:
        verbose_name = _("question type name")
        unique_together = (("question_type", "lang"),)

    def __str__(self):
        return f"{self.name} ({self.lang})"


class Question(models.Model):
    question_type = models.ForeignKey(QuestionType, on_delete=models.CASCADE)
    topic = models.ForeignKey(Topic, on_delete=models.CASCADE)
    question = models.TextField(help_text=_("question"))
    active = models.CharField(max_length=1)
    description = models.CharField(max_length=1)
    reference_question = models.ForeignKey(
        "Question",
        related_name="referenced",
        on_delete=models.CASCADE,
        null=True,
        blank=True,
        help_text=_("referenced question in original topic")
    )
    translation_status = models.IntegerField(blank=True, null=True)
    explanation = models.TextField(blank=True)

    class Meta:
        verbose_name = _("question")

    def __str__(self):
        return f'"{self.question}" ({self.question_type.get_name(self.topic.lang)})'


class Answer(models.Model):
    question = models.ForeignKey(Question, on_delete=models.CASCADE)
    answer = models.TextField()
    correct = models.BooleanField(default=False)
    reference_answer = models.ForeignKey(
        "Answer",
        related_name="referenced",
        on_delete=models.CASCADE,
        null=True,
        blank=True,
        help_text=_("referenced answer in original topic"),
    )

    def __str__(self):
        return f"\"{self.answer}\" ({'correct' if self.correct else 'incorrect'})"


class UserCertificate(models.Model):
    user = models.ForeignKey(AUTH_USER_MODEL, on_delete=models.CASCADE, null=True)
    serial_number = models.CharField(
        max_length=20,
        help_text=_("RFC-5280 4.1.2.2. Serial Number hexadecimal without prefix"),
    )
    issuer_name = models.CharField(
        max_length=100, help_text=_("Common Name of the Issuer DN field")
    )
    common_name = models.CharField(
        max_length=100, help_text=_("Common Name of the Subject DN field")
    )

    class Meta:
        unique_together = (("serial_number", "issuer_name"),)


class UserProfile(models.Model):
    user = models.OneToOneField(AUTH_USER_MODEL, on_delete=models.CASCADE)
    language = models.CharField(
        max_length=2,
        help_text=_("preferred language of the user ISO 639 2 letter code"),
    )
    send_certificate = models.CharField(
        max_length=13,
        choices=(
            ("no", _("no")),
            ("email", _("via email")),
            ("post", _("via postal mail")),
        ),
    )


class LearnProgress(models.Model):
    user = models.ForeignKey(
        settings.AUTH_USER_MODEL, on_delete=models.CASCADE, null=True
    )
    user_certificate = models.ForeignKey(
        UserCertificate, on_delete=models.CASCADE,
    )
    date = models.DateTimeField(help_text=_("time and date"))
    topic = models.ForeignKey(Topic, on_delete=models.CASCADE)
    number = models.IntegerField(help_text=_("number of questions"))
    correct = models.IntegerField(help_text=_("questions with correct answer"))
    wrong = models.IntegerField(help_text=_("questions with wrong answer"))
    percentage = models.DecimalField(
        max_digits=5, decimal_places=0, blank=True, null=True,
        help_text=_("percentage of questions that have been answered correctly"),
    )
    uploaded = models.BooleanField(
        help_text=_("indicates whether the learn progress has been uploaded to the main CAcert web application"),
        default=False,
    )
    passed = models.SmallIntegerField(
        help_text=_("-1 means not finished, 0 means not passed, 1 means passed"),
        choices=((-1, _("not finished")), (0, _("not passed")), (1, _("passed"))),
        default=-1,
    )


class IncorrectAnswer(models.Model):
    learn_progress = models.ForeignKey(LearnProgress, on_delete=models.CASCADE)
    question = models.ForeignKey(Question, on_delete=models.CASCADE)

    class Meta:
        unique_together = (("learn_progress", "question"),)


class Statistics(models.Model):
    question = models.ForeignKey(Question, on_delete=models.CASCADE, help_text=_("question"))
    count = models.IntegerField(help_text=_("count of answers"))