ks/apps/examination/exampaper/models.py

# coding=utf-8

import random
from django.db import models
from django.utils import timezone
from django.conf import settings

from utils.exceptions import CustomError

from apps.foundation.models import Subject
from apps.examination.examquestion.models import ExamQuestion

class ExamPaper(models.Model):
    MOCK = 1
    FORMAL = 2
    RANDOM = 3
    TYPE_CHOICES = (
        (MOCK, u'模拟试卷'),
        (FORMAL, u'正式试卷'),
        (RANDOM, u'随机试卷'),
    )
    TYPE_JSON = [{'id': item[0], 'value': item[1]} for item in TYPE_CHOICES]

    name = models.CharField(max_length=200, verbose_name=u"名称")
    subject = models.ForeignKey(Subject, verbose_name=u"科目", on_delete=models.PROTECT)
    type = models.PositiveSmallIntegerField(choices=TYPE_CHOICES, verbose_name=u"类型")
    passline = models.IntegerField(verbose_name=u'及格线')
    desc = models.TextField(verbose_name=u"备注", null=True, blank=True)

    single_simple_count = models.IntegerField(verbose_name=u'简单单选题数量', default=0)
    multiple_simple_count = models.IntegerField(verbose_name=u'简单多选题数量', default=0)
    fill_simple_count = models.IntegerField(verbose_name=u'简单填空题数量', default=0)
    judgment_simple_count = models.IntegerField(verbose_name=u'简单判断题数量', default=0)
    discuss_simple_count = models.IntegerField(verbose_name=u'简单论述题数量', default=0)

    single_mid_count = models.IntegerField(verbose_name=u'中等单选题数量', default=0)
    multiple_mid_count = models.IntegerField(verbose_name=u'中等多选题数量', default=0)
    fill_mid_count = models.IntegerField(verbose_name=u'中等填空题数量', default=0)
    judgment_mid_count = models.IntegerField(verbose_name=u'中等判断题数量', default=0)
    discuss_mid_count = models.IntegerField(verbose_name=u'中等论述题数量', default=0)

    single_hard_count = models.IntegerField(verbose_name=u'困难单选题数量', default=0)
    multiple_hard_count = models.IntegerField(verbose_name=u'困难多选题数量', default=0)
    fill_hard_count = models.IntegerField(verbose_name=u'困难填空题数量', default=0)
    judgment_hard_count = models.IntegerField(verbose_name=u'困难判断题数量', default=0)
    discuss_hard_count = models.IntegerField(verbose_name=u'困难论述题数量', default=0)

    single_scores = models.IntegerField(verbose_name=u'单选题单题分数', default=0)
    multiple_scores = models.IntegerField(verbose_name=u'多选题单题分数', default=0)
    fill_scores = models.IntegerField(verbose_name=u'填空题单题分数', default=0)
    judgment_scores = models.IntegerField(verbose_name=u'判断题单题分数', default=0)
    discuss_scores = models.IntegerField(verbose_name=u'论述题单题分数', default=0)

    single_total_count = models.IntegerField(verbose_name=u'单选题总数量', default=0, editable=False)
    multiple_total_count = models.IntegerField(verbose_name=u'多选题总数量', default=0, editable=False)
    fill_total_count = models.IntegerField(verbose_name=u'填空题总数量', default=0, editable=False)
    judgment_total_count = models.IntegerField(verbose_name=u'判断题总数量', default=0, editable=False)
    discuss_total_count = models.IntegerField(verbose_name=u'论述题总数量', default=0, editable=False)

    single_total_scores = models.IntegerField(verbose_name=u'单选题总分数', default=0, editable=False)
    multiple_total_scores = models.IntegerField(verbose_name=u'多选题总分数', default=0, editable=False)
    fill_total_scores = models.IntegerField(verbose_name=u'填空题总分数', default=0, editable=False)
    judgment_total_scores = models.IntegerField(verbose_name=u'判断题总分数', default=0, editable=False)
    discuss_total_scores = models.IntegerField(verbose_name=u'论述题总分数', default=0, editable=False)

    question_total_count  = models.IntegerField(verbose_name=u'试题总数量', default=0, editable=False)
    question_total_scores = models.IntegerField(verbose_name=u'试题总分数', default=0, editable=False)

    create_user = models.ForeignKey(settings.AUTH_USER_MODEL, verbose_name=u'添加人', editable=False, on_delete=models.PROTECT)
    create_time = models.DateTimeField(verbose_name=u"添加时间", default=timezone.now, editable=False)
    delete = models.BooleanField(verbose_name=u'删除', default=False, editable=False)

    did_count = models.IntegerField(verbose_name=u'做过人数', default=0, editable=False)

    class Meta:
        db_table = "exam_paper"
        ordering = ['-id']
        verbose_name = u"试卷管理"
        default_permissions = ()

    @staticmethod
    def getById(id):
        instance = ExamPaper.objects.filter(pk=id).first()
        if not instance:
            raise CustomError(u'未找到相应的试卷')
        return instance

    def generate_passline(self):
        self.passline = int(self.question_total_scores * 0.6)

    def clear_detail(self):
        ExamPaperDetail.objects.filter(main=self).update(delete=True)

    def generate_detail(self):
        begin_order = 1
        if self.single_simple_count:
            self._generate_detail(self.single_simple_count, ExamQuestion.SINGLE, ExamQuestion.SIMPLE, begin_order)
            begin_order += self.single_simple_count
        if self.single_mid_count:
            self._generate_detail(self.single_mid_count, ExamQuestion.SINGLE, ExamQuestion.MID, begin_order)
            begin_order += self.single_mid_count
        if self.single_hard_count:
            self._generate_detail(self.single_hard_count, ExamQuestion.SINGLE, ExamQuestion.HARD, begin_order)
            begin_order += self.single_hard_count

        if self.multiple_simple_count:
            self._generate_detail(self.multiple_simple_count, ExamQuestion.MULTIPLE, ExamQuestion.SIMPLE, begin_order)
            begin_order += self.multiple_simple_count
        if self.multiple_mid_count:
            self._generate_detail(self.multiple_mid_count, ExamQuestion.MULTIPLE, ExamQuestion.MID, begin_order)
            begin_order += self.multiple_mid_count
        if self.multiple_hard_count:
            self._generate_detail(self.multiple_hard_count, ExamQuestion.MULTIPLE, ExamQuestion.HARD, begin_order)
            begin_order += self.multiple_hard_count

        if self.fill_simple_count:
            self._generate_detail(self.fill_simple_count, ExamQuestion.FILL, ExamQuestion.SIMPLE, begin_order)
            begin_order += self.fill_simple_count
        if self.fill_mid_count:
            self._generate_detail(self.fill_mid_count, ExamQuestion.FILL, ExamQuestion.MID, begin_order)
            begin_order += self.fill_mid_count
        if self.fill_hard_count:
            self._generate_detail(self.fill_hard_count, ExamQuestion.FILL, ExamQuestion.HARD, begin_order)
            begin_order += self.fill_hard_count

        if self.judgment_simple_count:
            self._generate_detail(self.judgment_simple_count, ExamQuestion.JUDGMENT, ExamQuestion.SIMPLE, begin_order)
            begin_order += self.judgment_simple_count
        if self.judgment_mid_count:
            self._generate_detail(self.judgment_mid_count, ExamQuestion.JUDGMENT, ExamQuestion.MID, begin_order)
            begin_order += self.judgment_mid_count
        if self.judgment_hard_count:
            self._generate_detail(self.judgment_hard_count, ExamQuestion.JUDGMENT, ExamQuestion.HARD, begin_order)
            begin_order += self.judgment_hard_count

        if self.discuss_simple_count:
            self._generate_detail(self.discuss_simple_count, ExamQuestion.DISCUSS, ExamQuestion.SIMPLE, begin_order)
            begin_order += self.discuss_simple_count
        if self.discuss_mid_count:
            self._generate_detail(self.discuss_mid_count, ExamQuestion.DISCUSS, ExamQuestion.MID, begin_order)
            begin_order += self.discuss_mid_count
        if self.discuss_hard_count:
            self._generate_detail(self.discuss_hard_count, ExamQuestion.DISCUSS, ExamQuestion.HARD, begin_order)
            begin_order += self.discuss_hard_count

    def update_count(self):
        self.single_total_count = self.single_simple_count + self.single_mid_count + self.single_hard_count
        self.multiple_total_count = self.multiple_simple_count + self.multiple_mid_count + self.multiple_hard_count
        self.fill_total_count = self.fill_simple_count + self.fill_mid_count + self.fill_hard_count
        self.judgment_total_count = self.judgment_simple_count + self.judgment_mid_count + self.judgment_hard_count
        self.discuss_total_count = self.discuss_simple_count + self.discuss_mid_count + self.discuss_hard_count

        self.single_total_scores = self.single_scores * self.single_total_count
        self.multiple_total_scores = self.multiple_scores * self.multiple_total_count
        self.fill_total_scores = self.fill_scores * self.fill_total_count
        self.judgment_total_scores = self.judgment_scores * self.judgment_total_count
        self.discuss_total_scores = self.discuss_scores * self.discuss_total_count

        self.question_total_count = self.single_total_count + self.multiple_total_count + self.fill_total_count + self.judgment_total_count + self.discuss_total_count
        self.question_total_scores = self.single_total_scores + self.multiple_total_scores + self.fill_total_scores + self.judgment_total_scores+ self.discuss_total_scores
        return self

    def _generate_detail(self, count, type, difficulty, begin_order):
        questions = ExamQuestion.objects.filter(
            chapter__subject=self.subject,
            difficulty = difficulty,
            type = type,
            delete=False
        )
        questions_count = questions.count()
        if questions_count < count:
            raise CustomError(u'[%s][%s]数量不足！' % (ExamQuestion.DIFFICULTY_CHOICES[difficulty-1][1], ExamQuestion.TYPE_CHOICES[type-1][1]))
        question_ids = questions.values_list('id', flat=True)
        rows = random.sample(list(question_ids), count)
        random.shuffle(rows)

        data = []
        for row in rows:
            item = ExamPaperDetail(
                main=self,
                question_id=row,
                order=begin_order
            )
            begin_order += 1
            data.append(item)

        ExamPaperDetail.objects.bulk_create(data)

class ExamPaperDetail(models.Model):
    main = models.ForeignKey(ExamPaper, verbose_name=u"试卷", on_delete=models.PROTECT)
    question = models.ForeignKey(ExamQuestion, verbose_name=u"试题", on_delete=models.PROTECT)
    order = models.IntegerField(verbose_name=u'序号', editable=False)
    delete = models.BooleanField(verbose_name=u'删除', default=False, editable=False)

    class Meta:
        db_table = "exam_paper_detail"
        ordering = ['order']
        verbose_name = u"试卷明细"
        default_permissions = ()