ieplus/ie-admin/src/main/java/com/ruoyi/web/service/ExamService.java

package com.ruoyi.web.service;

import com.alibaba.fastjson2.JSONObject;
import com.alibaba.fastjson2.util.DateUtils;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.ruoyi.common.annotation.Excel;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.enums.ExamType;
import com.ruoyi.common.enums.UserRegStatus;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.dz.service.IDzSubjectService;
import com.ruoyi.dz.service.impl.DzSubjectServiceImpl;
import com.ruoyi.enums.ExamineeStatus;
import com.ruoyi.enums.PaperStatus;
import com.ruoyi.enums.PaperType;
import com.ruoyi.enums.UserTypeEnum;
import com.ruoyi.ie.domain.AMarjorPlan;
import com.ruoyi.ie.service.IAMarjorPlanService;
import com.ruoyi.learn.domain.*;
import com.ruoyi.learn.mapper.*;
import com.ruoyi.learn.service.ILearnPaperService;
import com.ruoyi.learn.service.ILearnPlanService;
import com.ruoyi.mxjb.domain.MxjbContants;
import com.ruoyi.system.service.ISysUserService;
import io.swagger.annotations.ApiModelProperty;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.validation.ValidationException;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 考试服务
 */
@Service
public class ExamService {
    private final LearnAnswerMapper learnAnswerMapper;
    private final LearnExamineeMapper learnExamineeMapper;
    private final LearnStudentMapper learnStudentMapper;
    private final ILearnPlanService learnPlanService;
    private final LearnQuestionsMapper learnQuestionsMapper;
    private final IDzSubjectService dzSubjectService;
    private Set<PaperType> paperTypeSet = Sets.newHashSet(PaperType.Real, PaperType.Custom, PaperType.Test);
    private final LearnPaperMapper paperMapper;
    private final LearnKnowledgeTreeMapper knowledgeTreeMapper;
    private final LearnExamineeMapper examineeMapper;
    private final LearnWrongBookMapper wrongBookMapper;
    private final LearnWrongDetailMapper wrongDetailMapper;
    private final ILearnPaperService learnPaperService;
    private final PaperService paperService;
    private final IAMarjorPlanService marjorPlanService;
    private final ISysUserService sysUserService;

    public ExamService(LearnPaperMapper paperMapper, LearnKnowledgeTreeMapper knowledgeTreeMapper, LearnExamineeMapper examineeMapper, ILearnPaperService learnPaperService, PaperService paperService, IAMarjorPlanService marjorPlanService, LearnAnswerMapper learnAnswerMapper, LearnExamineeMapper learnExamineeMapper, ISysUserService sysUserService, LearnStudentMapper learnStudentMapper, ILearnPlanService learnPlanService, LearnQuestionsMapper learnQuestionsMapper, IDzSubjectService dzSubjectService, LearnWrongBookMapper wrongBookMapper, LearnWrongDetailMapper wrongDetailMapper) {
        this.paperMapper = paperMapper;
        this.knowledgeTreeMapper = knowledgeTreeMapper;
        this.examineeMapper = examineeMapper;
        this.learnPaperService = learnPaperService;
        this.paperService = paperService;
        this.marjorPlanService = marjorPlanService;
        this.learnAnswerMapper = learnAnswerMapper;
        this.learnExamineeMapper = learnExamineeMapper;
        this.sysUserService = sysUserService;
        this.learnStudentMapper = learnStudentMapper;
        this.learnPlanService = learnPlanService;
        this.learnQuestionsMapper = learnQuestionsMapper;
        this.dzSubjectService = dzSubjectService;
        this.wrongBookMapper = wrongBookMapper;
        this.wrongDetailMapper = wrongDetailMapper;
    }

    /**
     * 开卷 (卷, 实时组卷)
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public AnswerSheet openExaminee(boolean directed, PaperType paperType, Long relatedId, Long subjectId) {
        SysUser user = SecurityUtils.getLoginUser().getUser();
        if(paperTypeSet.contains(paperType)) {
            if(UserTypeEnum.isCard(user.getUserType()) && !UserRegStatus.Student.equals(user.getRegStatus())) {
                throw new RuntimeException("VIP功能不可用");
            }
            return openExaminee(paperType, relatedId, SecurityUtils.getUserId());
        } else if(PaperType.Practice.equals(paperType)) {
            if(UserTypeEnum.isCard(user.getUserType()) && !UserRegStatus.Student.equals(user.getRegStatus())) {
                throw new RuntimeException("VIP功能不可用");
            }
            return openExaminee(relatedId, SecurityUtils.getUserId(), directed);
        } else if(PaperType.Simulated.equals(paperType)) {
            SysUser exist = sysUserService.selectUserById(SecurityUtils.getUserId());
            LearnStudent ls = learnStudentMapper.selectLearnStudentByStudentId(exist.getUserId());
            if(null == ls) {
                throw new RuntimeException("请先定设置定向学习" + exist.getUserId());
            }
            return openExaminee(ls, subjectId, exist);
        }
        throw new RuntimeException("错误类型: " + paperType);
    }

    public AnswerSheet loadExaminee(Long examineeId, Boolean examContinue) {
        LearnExaminee examinee = examineeMapper.selectLearnExamineeByExamineeId(examineeId);
        if(examContinue) {
            if(ExamineeStatus.Sign.getVal().equals(examinee.getState())) {
                LearnExaminee upExaminee = new LearnExaminee();
                upExaminee.setExamineeId(examineeId);
                upExaminee.setBeginTime(new Date());
                upExaminee.setState(ExamineeStatus.Exam.getVal());
                examineeMapper.updateLearnExaminee(upExaminee);
            } else if(!ExamineeStatus.Exam.getVal().equals(examinee.getState())) {
                throw new RuntimeException("已考完的卷不能继续做");
            }
        } else if(ExamineeStatus.Exam.getVal().equals(examinee.getState())) {
            throw new RuntimeException("考试中，不能提取答案");
        }
        LearnAnswer aCond = new LearnAnswer();
        aCond.setExamineeId(examineeId);
        Map<Long, LearnAnswer> answerMap = learnAnswerMapper.selectLearnAnswerList(aCond).stream().collect(Collectors.toMap(LearnAnswer::getQuestionId, t -> t));
        LearnPaper learnPaper = learnPaperService.selectLearnPaperById(examinee.getPaperId());
        List<PaperVO.QuestionAnswer> questionList = paperService.loadPaperQuestionAnswers(SecurityUtils.getUserId(), examinee.getPaperId(), answerMap, !examContinue);
        AnswerSheet answerSheet = buildAnswerSheet(learnPaper, examinee);
        answerSheet.setTotalCount(learnPaper.getNumber());
        answerSheet.setWrongCount(examinee.getWrongCount());
        answerSheet.setQuestions(questionList);

        if(null != examinee.getPaperInfo()) {
            JSONObject info = JSONObject.parseObject(examinee.getPaperInfo());
            answerSheet.setCollegeId(info.getLong("universityId"));
            answerSheet.setCollegeName(info.getString("universityName"));
            answerSheet.setMajorId(info.getLong("planId"));
            answerSheet.setMajorName(info.getString("majorName"));
            answerSheet.setSubjectId(learnPaper.getSubjectId());
            answerSheet.setSubjectName(dzSubjectService.selectDzSubjectBySubjectId(learnPaper.getSubjectId()).getSubjectName());
        }
        if(null != examinee.getStats()) {
            answerSheet.setStats(JSONObject.parseObject(examinee.getStats()));
        }
        return answerSheet;
    }

    /**
     * 交卷
     * @param answerSheet
     */
    @Transactional(rollbackFor = Exception.class)
    public void commitAnswerSheet(AnswerSheet answerSheet) {
        LearnExaminee exitExaminee = learnExamineeMapper.selectLearnExamineeByExamineeId(answerSheet.getExamineeId());
        if(null == exitExaminee) {
            throw new RuntimeException("无此答卷" + answerSheet.getExamineeId());
        }
        LearnAnswer aCond = new LearnAnswer();
        aCond.setExamineeId(answerSheet.getExamineeId());
        Map<Long, LearnAnswer> answerMap = learnAnswerMapper.selectLearnAnswerList(aCond).stream().collect(Collectors.toMap(LearnAnswer::getQuestionId, t -> t));
        List<PaperVO.QuestionAnswer> qaList = paperService.loadPaperQuestionAnswers(null, exitExaminee.getPaperId(), answerMap, true);
        Map<Long, PaperVO.QuestionAnswer> questionMap = Maps.newHashMap();
        for(PaperVO.QuestionAnswer qa : qaList) {
            if(CollectionUtils.isNotEmpty(qa.getSubQuestions())) {
                for(PaperVO.QuestionAnswer sqa : qa.getSubQuestions()) {
                    questionMap.put(sqa.getId(), sqa);
                }
            } else {
                questionMap.put(qa.getId(), qa);
            }
        }

        List<LearnAnswer> answersList = Lists.newArrayList();
        Integer wrongCount = 0;
        Integer totalScore = 0;
        Integer score = 0;
        for(PaperVO.QuestionAnswer question : answerSheet.getQuestions()) {
            if(CollectionUtils.isNotEmpty(question.getSubQuestions())) {
                for(PaperVO.QuestionAnswer sq : question.getSubQuestions()) {
                    PaperVO.QuestionAnswer stdAnswer = questionMap.get(sq.getId());
                    LearnAnswer answer = buildAnswer(answerSheet, questionMap, sq, answersList);
                    if(answerSheet.getIsDone()) {
                        totalScore += stdAnswer.getTotalScore();
                        score += answer.getScore();
                        if(!answer.getState().equals(1)) {
                            wrongCount++;
                        }
                    }
                }
            } else {
                PaperVO.QuestionAnswer stdAnswer = questionMap.get(question.getId());
                LearnAnswer answer = buildAnswer(answerSheet, questionMap, question, answersList);
                if(answerSheet.getIsDone()) {
                    totalScore += stdAnswer.getTotalScore();
                    score += answer.getScore();
                    if(!answer.getState().equals(1)) {
                        wrongCount++;
                    }
                }
            }
        }
        if(answersList.size() > 0) {
            answersList.stream().forEach(t -> {
                if(null == t.getAnswerId()) {
                    learnAnswerMapper.insertLearnAnswer(t);
                } else {
                    learnAnswerMapper.updateLearnAnswer(t);
                }
            });
        }
        LearnExaminee upExaminee = new LearnExaminee();
        upExaminee.setExamineeId(answerSheet.getExamineeId());
        upExaminee.setDuration(answerSheet.getDuration());
        if(answerSheet.getIsDone()) {
            upExaminee.setEndTime(new Date());
            upExaminee.setState(ExamineeStatus.Commit.getVal());
            upExaminee.setScore(score);
            upExaminee.setScoreRate(score * 100 / totalScore);
            upExaminee.setWrongCount(wrongCount);
            learnExamineeMapper.updateLearnExaminee(upExaminee);
            if(PaperType.Simulated.getVal().equals(exitExaminee.getPaperType())) {
                List<JSONObject> paperStatList = learnExamineeMapper.selectExamRankingStats(upExaminee.getScore(), Lists.newArrayList(exitExaminee.getPaperId()));
                JSONObject o = paperStatList.get(0);
                Integer totalCount = o.getInteger("totalCount");
                Integer maxScore = o.getInteger("maxScore");
                Integer avgScore = o.getInteger("avgScore");
                Integer lowCount = o.getInteger("lowCount");
                JSONObject stats = new JSONObject();
                stats.put("score", upExaminee.getScore());
                stats.put("rate", upExaminee.getScoreRate());
                stats.put("maxScore", maxScore);
                stats.put("averageScore", avgScore);
                stats.put("hitRate", lowCount * 100 / totalCount);
                upExaminee.setStats(JSONObject.toJSONString(stats));
                learnExamineeMapper.updateLearnExaminee(upExaminee);
            }
        } else {
            learnExamineeMapper.updateLearnExaminee(upExaminee);
        }

        if(answerSheet.getIsDone()) {
            // 关闭试卷
            LearnPaper up = new LearnPaper();
            up.setId(exitExaminee.getPaperId());
            up.setStatus(PaperStatus.Valid.getVal());
            paperMapper.updateLearnPaper(up);

            if(PaperType.Practice.getVal().equals(exitExaminee.getPaperType())) {
                learnPlanService.updateLearnPlan(exitExaminee.getStudentId());
                calculateWrongAnswers(exitExaminee, questionMap, answersList, PaperType.Practice.name());
            } else if(PaperType.Simulated.getVal().equals(exitExaminee.getPaperType())) {
                calculateWrongAnswers(exitExaminee, questionMap, answersList, PaperType.Simulated.name());
            }
        }
    }

    public Set<Integer> invalidStatusSet = Sets.newHashSet(2, 3);
    public void  calculateWrongAnswers(LearnExaminee examinee, Map<Long, PaperVO.QuestionAnswer> questionMap, List<LearnAnswer> answersList, String source) {
        if (CollectionUtils.isEmpty(answersList)){
            return;
        }
        LearnPaper learnPaper = paperMapper.selectLearnPaperById(examinee.getPaperId());
        answersList.forEach(t -> {
            if (invalidStatusSet.contains(t.getState())) {
                LearnWrongBook wrongBookCond = new LearnWrongBook();
                wrongBookCond.setStudentId(examinee.getStudentId());
                wrongBookCond.setQuestionId(t.getQuestionId());
                PaperVO.QuestionAnswer stdAnswer = questionMap.get(t.getQuestionId());
                wrongBookCond.setKnownledgeId(stdAnswer.getKnowledgeId());
                List<LearnWrongBook> wrongBookList = wrongBookMapper.selectLearnWrongBookList(wrongBookCond);
                if (CollectionUtils.isNotEmpty(wrongBookList)) {
                    LearnWrongBook wrongBook = wrongBookList.get(0);
                    if (null == wrongBook.getWrongCount()) {
                        wrongBook.setWrongCount(0L);
                    }
                    if (null == wrongBook.getTotalCount()) {
                        wrongBook.setTotalCount(0L);
                    }
                    wrongBookCond.setWrongId(wrongBook.getWrongId());
                    wrongBookCond.setStudentId(null);
                    wrongBookCond.setQuestionId(null);
                    wrongBookCond.setWrongCount(wrongBook.getWrongCount() + 1);
                    wrongBookCond.setTotalCount(wrongBook.getTotalCount() + 1);
                } else {
                    wrongBookCond.setAnswer1(stdAnswer.getAnswer1());
                    wrongBookCond.setAnswer2(stdAnswer.getAnswer2());
                    wrongBookCond.setSubjectId(learnPaper.getSubjectId());
                    wrongBookCond.setRightCount(0L);
                    wrongBookCond.setWrongCount(1L);
                    wrongBookCond.setTotalCount(1L);
                    // wrongBookCond.setScoreTotal(standard.getScoreTotal());
                }
                // wrongBookCond.setKnownledgeId(standard.getKnowledgeId());
                wrongBookCond.setPaperId(examinee.getPaperId());
                wrongBookCond.setScore(t.getScore());
                wrongBookCond.setSource(source);
                wrongBookCond.setAnswer(t.getAnswer());
                wrongBookCond.setState(MxjbContants.QuestionScoreWrong);
                if(null == wrongBookCond.getWrongId()) {
                    wrongBookMapper.insertLearnWrongBook(wrongBookCond);
                } else {
                    wrongBookMapper.updateLearnWrongBook(wrongBookCond);
                }
                LearnWrongDetail wrongDetail = new LearnWrongDetail();
                wrongDetail.setWrongId(wrongBookCond.getWrongId());
                wrongDetail.setCreatedTime(new Date());
                wrongDetail.setKnownledgeId(stdAnswer.getKnowledgeId());
                wrongDetail.setSource(wrongBookCond.getSource());
                wrongDetail.setExamineeId(examinee.getExamineeId());
                wrongDetail.setStudentId(examinee.getStudentId());
                wrongDetail.setPaperId(examinee.getPaperId());
                wrongDetailMapper.insertLearnWrongDetail(wrongDetail);
            }
        });
    }

    private LearnAnswer buildAnswer(AnswerSheet answerSheet, Map<Long, PaperVO.QuestionAnswer> questionMap, PaperVO.QuestionAnswer question,
                             List<LearnAnswer> answerList) {
        LearnAnswer answer = new LearnAnswer();
        PaperVO.QuestionAnswer stdAnswer = questionMap.get(question.getId());
        if(null == stdAnswer.getAnswerId()) {
            answer.setExamineeId(answerSheet.getExamineeId());
            answer.setStudentId(SecurityUtils.getUserId());
            answer.setSeq(question.getSeq());
        } else {
            answer.setAnswerId(stdAnswer.getAnswerId());
        }
        answerList.add(answer);
        answer.setQuestionId(question.getId()); // 错题计算要使用
        answer.setKnowledgeId(stdAnswer.getKnowledgeId());
        answer.setAnswer(StringUtils.join(question.getAnswers(), ","));
        answer.setMark(null != question.getIsMark() && question.getIsMark());
        answer.setNotKnow(null != question.getIsNotKnow() && question.getIsNotKnow());
        answer.setState(question.calcState(stdAnswer, answerSheet.getIsDone()));
        if (answerSheet.getIsDone()) {
            answer.setScore(answer.getState() == 1 ? stdAnswer.getTotalScore() : 0);
            answer.setScoreRate(answer.getScore() * 100 / stdAnswer.getTotalScore());
        }
        return answer;
    }

    private AnswerSheet openExaminee(PaperType paperType, Long paperId, Long studentId) {
        LearnPaper paper = paperMapper.selectLearnPaperById(paperId);

        LearnExaminee learnExaminee = new LearnExaminee();
        learnExaminee.setStudentId(studentId);
        learnExaminee.setPaperId(paperId);
        learnExaminee.setPaperType(paperType.getVal());
        learnExaminee.setState(ExamineeStatus.Exam.getVal());
        List<LearnExaminee> examineeList = examineeMapper.selectLearnExamineeList(learnExaminee);
        if (CollectionUtils.isNotEmpty(examineeList)) {
            learnExaminee = examineeList.get(0);
        } else {
            learnExaminee.setState(ExamineeStatus.Exam.getVal());
            learnExaminee.setBeginTime(new Date());
            learnExaminee.setDuration(0L);
            examineeMapper.insertLearnExaminee(learnExaminee);
        }
        return buildAnswerSheet(paper, learnExaminee);
    }

    private AnswerSheet openExaminee(LearnStudent ls, Long subjectId, SysUser sysUser) {
        AMarjorPlan plan = marjorPlanService.selectAMarjorPlanById(ls.getMajorPlanId());
        if(null == plan) {
            throw new ValidationException("专业id无效");
        }
        LearnExaminee examinee = new LearnExaminee();
        examinee.setStudentId(SecurityUtils.getLoginUser().getUser().getUserId());
        examinee.setPaperType(PaperType.Simulated.getVal());
        examinee.setPaperKey(subjectId.toString());
        List<LearnExaminee> examineeList = examineeMapper.selectLearnExamineeList(examinee);
        Set<Long> existPaperIdSet = Sets.newHashSet();
        for(LearnExaminee e : examineeList) {
            if(ExamineeStatus.Sign.getVal().equals(e.getState())) {
                LearnPaper learnPaper = paperMapper.selectLearnPaperById(e.getPaperId());
                AnswerSheet answerSheet = buildAnswerSheet(learnPaper, e);
                if(null != e.getPaperInfo()) {
                    JSONObject info = JSONObject.parseObject(e.getPaperInfo());
                    answerSheet.setCollegeId(info.getLong("universityId"));
                    answerSheet.setCollegeName(info.getString("universityName"));
                    answerSheet.setMajorId(info.getLong("planId"));
                    answerSheet.setMajorName(info.getString("majorName"));
                    answerSheet.setSubjectId(learnPaper.getSubjectId());
                    answerSheet.setSubjectName(dzSubjectService.selectDzSubjectBySubjectId(learnPaper.getSubjectId()).getSubjectName());
                }
                return answerSheet;
            }
            existPaperIdSet.add(e.getPaperId());
        }
        LearnPaper paper = getBestPaper(sysUser.getExamType(), plan, subjectId, existPaperIdSet);
        examinee.setPaperId(paper.getId());
        examinee.setState(ExamineeStatus.Sign.getVal());
        examinee.setDuration(0L);

        JSONObject evalCountObj = JSONObject.parseObject(sysUser.getEvalCounts());
        Integer evalCount = evalCountObj.getInteger(subjectId.toString());
        if(null == evalCount || evalCount <= 0) {
            throw new ValidationException("超过最大次数限制" + evalCount );
        }
        SysUser upUser = new SysUser();
        upUser.setUserId(sysUser.getUserId());
        evalCountObj.put(subjectId.toString(), evalCount - 1);
        upUser.setEvalCounts(evalCountObj.toJSONString());
        sysUserService.updateUserProfile(upUser);

        JSONObject info = new JSONObject();
        info.put("universityId", ls.getUniversityId());
        info.put("universityName", plan.getUniversityName());
        info.put("planId", ls.getMajorPlanId());
        info.put("majorName", plan.getMajorName());
        examinee.setPaperInfo(info.toJSONString());
        examineeMapper.insertLearnExaminee(examinee);
        AnswerSheet answerSheet = buildAnswerSheet(paper, examinee);

        answerSheet.setCollegeId(ls.getUniversityId());
        answerSheet.setCollegeName(plan.getUniversityName());
        answerSheet.setMajorId(ls.getMajorPlanId());
        answerSheet.setMajorName(plan.getMajorName());
        answerSheet.setSubjectId(paper.getSubjectId());
        answerSheet.setSubjectName(dzSubjectService.selectDzSubjectBySubjectId(paper.getSubjectId()).getSubjectName());
        return answerSheet;

    }

    /**
     * 根据知识点生成一次性练习卷并开始做题
     * @return
     */
    private AnswerSheet openExaminee(Long knowledgeId, Long studentId, Boolean directed) {
        String directKey;
        AMarjorPlan plan = null;
        LearnStudent ls = null;
        if(!directed) {
            directKey = "";
        } else {
            ls = learnStudentMapper.selectLearnStudentByStudentId(SecurityUtils.getUserId());
            if(null == (plan = marjorPlanService.selectAMarjorPlanById(ls.getMajorPlanId()))) {
                throw new ValidationException("专业id无效");
            }
            directKey = StringUtils.trimToEmpty(ls.getDirectKey());
        }
        LearnKnowledgeTree knowledgeTree = knowledgeTreeMapper.selectLearnKnowledgeTreeById(knowledgeId);
        LearnPaper paper = new LearnPaper();
        paper.setPaperType(PaperType.Practice.name());
        paper.setRelateId(knowledgeId);
        paper.setYear(Calendar.getInstance().get(Calendar.YEAR));
        paper.setStatus(PaperStatus.TmpValid.getVal());
        paper.setDirectKey(studentId + "_" + directKey);
        List<LearnPaper> paperList = paperMapper.selectLearnPaperList(paper);
        if (CollectionUtils.isNotEmpty(paperList)) { // 有未做完的
            LearnPaper existPaper = paperList.get(0);
            LearnExaminee learnExaminee = new LearnExaminee();
            learnExaminee.setStudentId(studentId);
            learnExaminee.setPaperId(existPaper.getId());
            learnExaminee.setPaperType(PaperType.Practice.getVal());
            learnExaminee.setState(ExamineeStatus.Exam.getVal());
            List<LearnExaminee> examineeList = examineeMapper.selectLearnExamineeList(learnExaminee);
            if (CollectionUtils.isNotEmpty(examineeList) && ExamineeStatus.Exam.getVal().equals(examineeList.get(0).getState())) {
                LearnExaminee examinee = examineeList.get(0);
                LearnAnswer aCond = new LearnAnswer();
                aCond.setExamineeId(examinee.getExamineeId());
                Map<Long, LearnAnswer> answerMap = learnAnswerMapper.selectLearnAnswerList(aCond).stream().collect(Collectors.toMap(LearnAnswer::getQuestionId, t -> t));
                List<PaperVO.QuestionAnswer> questionList = paperService.loadPaperQuestionAnswers(SecurityUtils.getUserId(), examinee.getPaperId(), answerMap, true);
                AnswerSheet answerSheet = buildAnswerSheet(existPaper, examinee);
                answerSheet.setQuestions(questionList);
                answerSheet.setKnowledgeId(existPaper.getRelateId());
                return answerSheet;
            }
            // 关闭试卷
            LearnPaper up = new LearnPaper();
            up.setId(learnExaminee.getPaperId());
            up.setStatus(PaperStatus.Valid.getVal());
            paperMapper.updateLearnPaper(up);
        }

        TestPaperVO.PaperDef paperDef = new TestPaperVO.PaperDef();
        paperDef.setTotal(15L);
        paperDef.setFillExclude(true);
        paperDef.setKnowIds(Lists.newArrayList(knowledgeId));
        List<TestPaperVO.TypeDef> typeDefList= Lists.newArrayList();
        typeDefList.add(new TestPaperVO.TypeDef("单选题", "单选题", 9, 1));
        typeDefList.add(new TestPaperVO.TypeDef("判断题", "判断题", 4, 1));
        typeDefList.add(new TestPaperVO.TypeDef("主观题", "主观题", 2, 1));
        paperDef.setTypes(typeDefList);
        List<LearnPaperQuestion> pqList = paperService.getQuestions(studentId,  paperDef);
        paper.setPaperSource(0);
        paper.setFenshu(0);
        paper.setSubjectId(knowledgeTree.getSubjectId());
        paper.setPaperName(studentId + "-" + knowledgeTree.getName() + "-" + DateUtils.format(new Date(), "yyyyMMddHHmmss"));
        paper.setRelateId(knowledgeId);
        paperService.savePaper(paper, pqList);

        LearnExaminee learnExaminee = new LearnExaminee();
        learnExaminee.setStudentId(studentId);
        learnExaminee.setPaperType(PaperType.Practice.getVal());
        learnExaminee.setPaperId(paper.getId());
        learnExaminee.setPaperKey(String.valueOf(knowledgeId));
        learnExaminee.setState(ExamineeStatus.Exam.getVal());
        learnExaminee.setBeginTime(new Date());
        learnExaminee.setDuration(0L);
        if(directed && null != ls.getMajorPlanId()) {
            JSONObject info = new JSONObject();
            info.put("universityId", ls.getUniversityId());
            info.put("universityName", plan.getUniversityName());
            info.put("planId", ls.getMajorPlanId());
            info.put("majorName", plan.getMajorName());
            learnExaminee.setPaperInfo(info.toJSONString());
        }
        examineeMapper.insertLearnExaminee(learnExaminee);

        AnswerSheet answerSheet = buildAnswerSheet(paper, learnExaminee);
        List<PaperVO.QuestionAnswer> questionList = paperService.loadPaperQuestionAnswers(SecurityUtils.getUserId(), paper.getId(), null, true);
        answerSheet.setQuestions(questionList);
        answerSheet.setKnowledgeId(paper.getRelateId());
        return answerSheet;
    }

    private LearnPaper getBestPaper(ExamType examType, AMarjorPlan plan, Long subjectId, Set<Long> existPaperIdSet) {
        String groupName = StringUtils.trimToEmpty(plan.getMajorGroup());
        LearnPaper paperCond = new LearnPaper();
        paperCond.setSubjectId(subjectId);
        paperCond.setPaperType(PaperType.Simulated.name());
        String baseKey = plan.getUniversityId() + "_" + examType.name();
        for(int i = 3; i>0; i--) {
            if(i == 3) {
                paperCond.setDirectKey(baseKey + "_" + groupName + "_" + plan.getMajorName());
            } else if(i == 2) {
                paperCond.setDirectKey(baseKey + "_" + groupName);
            } else if(StringUtils.isBlank(groupName)) {
                break;
            } else {
                paperCond.setDirectKey(baseKey);
            }
            List<LearnPaper> paperList = learnPaperService.selectLearnPaperList(paperCond);
            for(LearnPaper paper : paperList) {
                if(existPaperIdSet.add(paper.getId())) {
                    return paper;
                }
            }
        }
        throw new ValidationException("未初始化院校定向模拟题库: " + subjectId + ":" + plan.getId());
    }

    private AnswerSheet buildAnswerSheet(LearnPaper paper, LearnExaminee examinee) {
        AnswerSheet answerSheet = new AnswerSheet();
        answerSheet.setExamineeId(examinee.getExamineeId());
        answerSheet.setPaperId(examinee.getPaperId());
        answerSheet.setName(paper.getPaperName());
        answerSheet.setBeginTime(examinee.getBeginTime());
        answerSheet.setDuration(examinee.getDuration());
        if(StringUtils.isNotBlank(paper.getPaperInfo())) {
            answerSheet.setPaperInfo(JSONObject.parseObject(paper.getPaperInfo(), AnswerSheet.PaperCond.class));
        }
        if(PaperType.Practice.name().equals(paper.getPaperType())) {
            answerSheet.setKnowledgeId(paper.getRelateId());
        }
        answerSheet.setScoringType("1");
        answerSheet.setMode(0L);
        answerSheet.setState(examinee.getState());
        answerSheet.setAllowAnswer(true);
        answerSheet.setAllowScore(false);
        return answerSheet;
    }
}