Django Question Models System, see also: http://stackoverflow.com/q/40784376/6396981

admin.py

from django.contrib import admin
from app_name.models import *


class AnswerAdmin(admin.ModelAdmin):
    list_display = ['question', 'answer', 'score']
    list_filter = ['question__type', 'score']
    search_fields = ['question__title', 'answer', 'score']
    raw_id_fields = ['question']


class AnswerAdminInline(admin.TabularInline):
    model = Answer
    extra = 1


class QuestionAdmin(admin.ModelAdmin):
    inlines = [AnswerAdminInline]
    list_display = ['title', 'type', 'created', 'publish']
    search_fields = ['title', 'type']
    list_filter = ['type', 'publish', 'created']


class BaseAnswerUserAdmin(admin.ModelAdmin):
    list_display = ['user', 'key', 'created']
    list_filter = ['created']
    search_fields = ['user', 'key']
    raw_id_fields = ['user']


class AnswerUserAdmin(admin.ModelAdmin):
    list_display = ['base_answer', 'question', 'score']
    list_filter = [
        'created', 'question__type'
    ]
    search_fields = [
        'base_answer__user__username',
        'question__title', 'score', 'text_answer'
    ]
    raw_id_fields = ('base_answer', 'question')


admin.site.register(Question, QuestionAdmin)
admin.site.register(Answer, AnswerAdmin)  # handled with `TabularInline`
admin.site.register(BaseAnswerUser, BaseAnswerUserAdmin)
admin.site.register(AnswerUser, AnswerUserAdmin)

models.py

from django.db import models
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
from django.db.models import (Q, Count, Sum)
from django.utils.translation import ugettext, ugettext_lazy as _
from django.utils.encoding import python_2_unicode_compatible


class TimeStampedModel(models.Model):
    created = models.DateTimeField(auto_now_add=True)
    modified = models.DateTimeField(auto_now=True)

    class Meta:
        abstract = True


class QuestionQuerySet(models.QuerySet):

    def published(self):
        return self.filter(publish=True)


@python_2_unicode_compatible
class Question(TimeStampedModel):
    title = models.CharField(max_length=200)
    TYPE_CHOICES = (
        ('short', _('Sort')),
        ('medium', _('Medium')),
        ('complete', _('Complete'))
    )
    type = models.CharField(
        max_length=200,
        choices=TYPE_CHOICES,
        default='short'
    )
    weight = models.PositiveIntegerField()
    publish = models.BooleanField(default=True)
    objects = QuestionQuerySet.as_manager()

    def __str__(self):
        return self.title

    @property
    def total_score(self):
        answer = Answer.objects.filter(
            question__pk=self.pk
        ).annotate(Sum('score'))
        return answer  # .count()

    def get_answers(self):
        return Answer.objects.filter(
            question__pk=self.pk
        )
    get_answers.allow_tags = True

    class Meta:
        verbose_name = _('Detail Question')
        verbose_name_plural = _('Questions')
        ordering = ['-created']


@python_2_unicode_compatible
class Answer(models.Model):
    question = models.ForeignKey(
        Question, related_name='question_answer'
    )
    answer = models.CharField(max_length=200)
    score = models.PositiveIntegerField()


def key_generator():
    import uuid
    key = uuid.uuid4().hex
    if BaseAnswerUser.objects.filter(key=key).exists():
        return "{0}-{1}".format(key, uuid.uuid4().hex)
    return key


@python_2_unicode_compatible
class BaseAnswerUser(TimeStampedModel):
    """
    Untuk menyimpan jawaban yang terjawab oleh user.
    """
    user = models.ForeignKey(
        User, related_name='user_answer'
    )
    key = models.CharField(
        max_length=200,
        unique=True,
        default=key_generator
    )

    def get_absolute_url(self):
        return reverse('result', kwargs={'key': self.key})

    def get_answers(self):
        return AnswerUser.objects.filter(
            base_answer__key=self.key
        )

    def __str__(self):
        return _('Result analyze for %(user)s') % {
            'user': self.user.username,
        }

    class Meta:
        verbose_name = _('Base Answer User')
        verbose_name_plural = _('Base Answer Users')
        ordering = ['-created']


@python_2_unicode_compatible
class AnswerUser(TimeStampedModel):
    question = models.ForeignKey(
        Question, related_name='question_answer_user'
    )
    base_answer = models.ForeignKey(
        BaseAnswerUser, related_name='base_answer_user'
    )
    score = models.PositiveIntegerField(
        null=True, blank=True
    )
    text_answer = models.TextField(
        null=True, blank=True
    )

    @property
    def weight(self):
        return self.question.weight

    def __str__(self):
        return _('Result for %(question)s') % {
            'question': self.question
        }

    class Meta:
        verbose_name = _('Detail User Answer')
        verbose_name_plural = _('User Answers')
        ordering = ['-created']