You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1339 lines
44 KiB
1339 lines
44 KiB
<template> |
|
<div class="page"> |
|
<Breadcrumb :data="crumbs" /> |
|
<div v-loading="loading"> |
|
<el-form :model="form" :rules="rules" class="input-form model" ref="form" label-width="140px"> |
|
<p class="page-name mb">试卷基础信息</p> |
|
<el-form-item prop="name" label="试卷名称"> |
|
<el-input style="width: 940px" placeholder="请输入试卷名称" v-model="form.name" clearable maxlength="100" /> |
|
</el-form-item> |
|
<div class="item-line"> |
|
<el-form-item prop="particularYear" label="年份"> |
|
<el-date-picker v-model="form.particularYear" type="year" placeholder="请选择年份" format="yyyy" |
|
value-format="yyyy"> |
|
</el-date-picker> |
|
</el-form-item> |
|
<el-form-item prop="classificationId" label="所属试卷分类"> |
|
<el-cascader filterable placeholder="请选择所属试卷分类" :options="types" v-model="form.classificationId" |
|
:props="cascaderProps" style="width: 100%"> |
|
</el-cascader> |
|
</el-form-item> |
|
</div> |
|
<div class="item-line"> |
|
<el-form-item prop="paperType" label="建议用途"> |
|
<el-select v-model="form.paperType" clearable placeholder="请选择建议用途"> |
|
<el-option v-for="(item, i) in paperTypes" :key="i" :label="item.name" :value="item.id"></el-option> |
|
</el-select> |
|
</el-form-item> |
|
<el-form-item prop="suggestTime" label="估计用时"> |
|
<el-input placeholder="请输入估计用时" v-model.number="form.suggestTime"> |
|
<template slot="append">分钟</template> |
|
</el-input> |
|
</el-form-item> |
|
</div> |
|
<div class="item-line"> |
|
<el-form-item prop="professionals" label="所属专业"> |
|
<el-select v-model="form.professionalId" filterable multiple clearable placeholder="请选择所属专业"> |
|
<el-option v-for="(item, i) in professionals" :key="i" :label="item.professionalName" |
|
:value="item.professionalId" filter></el-option> |
|
</el-select> |
|
</el-form-item> |
|
<el-form-item prop="difficult" label="试卷难度"> |
|
<el-select v-model="form.difficult" clearable placeholder="系统自动评估，也可手动选择" |
|
@change="val => difficultSelected = !!val"> |
|
<el-option v-for="(item, i) in difficults" :key="i" :label="item.name" :value="item.id"></el-option> |
|
</el-select> |
|
<el-tooltip placement="top"> |
|
<div class="diff-text" slot="content"> |
|
<p>基础题：难度系数0.2</p> |
|
<p>普通题：难度系数0.4</p> |
|
<p>较难题：难度系数0.6</p> |
|
<p>困难题：难度系数0.8</p> |
|
<p>（1）<span class="em">题型难度系数</span>=对应题型所有试题的难度系数之和/总试题数</p> |
|
<p>（2）<span class="em">试卷总难度系数</span>=所有试题的难度系数之和/总试题数</p> |
|
<p>（3）<span class="em">难度系数评价</span>：</p> |
|
<div class="coe"> |
|
<p>简单：系数 <=0.3</p> |
|
<p>普通：0.3<系数<=0.4</p> |
|
<p>较难：0.4<系数<0.5</p> |
|
<p>困难:系数>=0.5</p> |
|
</div> |
|
</div> |
|
<i class="el-icon-question m-l-10" style="font-size: 16px;color: #8f8f8f;cursor: pointer;"></i> |
|
</el-tooltip> |
|
</el-form-item> |
|
</div> |
|
<el-form-item prop="remarks" label="试卷说明"> |
|
<UeditorPlus ref="remarks" @ready="remarksReady" /> |
|
</el-form-item> |
|
|
|
<div class="line"></div> |
|
|
|
<p class="page-name mb">试卷大纲</p> |
|
<div class="relative text-center m-b-40"> |
|
<p class="fs-16">{{ templateName }}</p> |
|
<el-button class="tem-btn" type="primary" size="small" @click="showTemplate">选择大纲模板</el-button> |
|
</div> |
|
<el-table :data="form.paperOutline" stripe header-align="center" row-key="id"> |
|
<el-table-column type="index" width="60" label="序号" align="center"></el-table-column> |
|
<el-table-column label="大题" align="center" min-width="120"> |
|
<template slot-scope="scope">第{{ arabicToChinese(scope.$index + 1) }}大题</template> |
|
</el-table-column> |
|
<el-table-column prop="name" label="题型" align="center" min-width="120"> |
|
<template slot-scope="scope"> |
|
<el-select v-model="scope.row.questionType" placeholder="请选择题型" @change="questionTypeChange(scope.row)"> |
|
<el-option v-for="(item, i) in questionTypes" :key="i" :label="item.name" :value="item.id"></el-option> |
|
</el-select> |
|
</template> |
|
</el-table-column> |
|
<el-table-column prop="name" label="目标题数" align="center" min-width="120"> |
|
<template slot-scope="scope"> |
|
<el-input placeholder="请输入目标题数" v-model.number="scope.row.questionNum" type="number" /> |
|
</template> |
|
</el-table-column> |
|
<el-table-column prop="name" label="目标分值" align="center" min-width="120"> |
|
<template slot-scope="scope"> |
|
<el-input placeholder="请输入目标分值" v-model="scope.row.targetScore" /> |
|
</template> |
|
</el-table-column> |
|
<el-table-column label="操作" align="center" width="120"> |
|
<template slot-scope="scope"> |
|
<i class="el-icon-circle-plus-outline action-icon m-r-10" @click="addLine(scope.$index)"></i> |
|
<i v-if="form.paperOutline.length > 1" class="el-icon-remove-outline action-icon" |
|
@click="delLine(scope.$index)"></i> |
|
</template> |
|
</el-table-column> |
|
</el-table> |
|
<p class="m-t-10 m-b-20 text-right">目标总题数：{{ overview.questionCount }}；目标总分：{{ overview.totalScore }}</p> |
|
|
|
<div class="line"></div> |
|
|
|
<div class="flex j-between a-center"> |
|
<h6 class="page-name" style="margin-bottom: 0">试卷试题</h6> |
|
<div> |
|
<el-button type="primary" @click="allocationAll">一键分配分值</el-button> |
|
<el-button type="primary" @click="showAuto">自动选题</el-button> |
|
</div> |
|
</div> |
|
|
|
<ul class="ques"> |
|
<li v-for="(item, i) in form.paperOutline" :key="i"> |
|
<div class="top"> |
|
<div> |
|
<span class="serial">第{{ arabicToChinese(i + 1) }}大题</span> |
|
<el-input placeholder="请输入大题名称" v-model="item.outlineName" /> |
|
</div> |
|
<div> |
|
<el-button type="primary" @click="allocation(item)">一键分配分值</el-button> |
|
<el-button type="primary" @click="showManualDia(item)">批量添加</el-button> |
|
<el-button type="danger" @click="batchDelQues(item)">批量移除试题</el-button> |
|
<img :class="['shrink', { active: item.shrink }]" src="@/assets/images/shrink.svg" alt="" |
|
@click="item.shrink = !item.shrink"> |
|
</div> |
|
</div> |
|
<p class="sum">本大题共{{ item.questionNum }}小题，共{{ item.targetScore }}分</p> |
|
<el-checkbox v-if="item.examQuestions && item.examQuestions.length" class="m-l-15" v-model="item.checkAll" |
|
@change="e => item.examQuestions.map(n => n.check = e)">全选</el-checkbox> |
|
|
|
<div :class="['ques-wrap', { hide: item.shrink }]"> |
|
<draggable v-model="item.examQuestions" :group="dragGroup" chosenClass="chosen" animation="1000" |
|
@update="e => updateSort(e, item)"> |
|
<div v-for="(ques, j) in item.examQuestions" :key="j" class="ques-item"> |
|
<el-checkbox v-model="ques.check"></el-checkbox> |
|
<div :class="['ques-info', { disabled: !ques.status, del: ques.isDel, repeat: ques.repeat }]"> |
|
<div class="top-line"> |
|
<div class="stem-info"> |
|
<div class="labels"> |
|
<span class="label">{{ j + 1 }} / {{ item.examQuestions.length }}</span> |
|
<span class="label">{{ questionTypes.find(e => e.id === item.questionType).name }}</span> |
|
<span v-if="ques.givenYear" class="label">{{ ques.givenYear }}</span> |
|
</div> |
|
<el-tag v-if="ques.difficult" :type="ques.difficultTheme">{{ ques.difficult }}</el-tag> |
|
</div> |
|
|
|
<div class="actions"> |
|
<p v-if="item.questionType !== 'fill_blank'" class="m-r-10 input-wrap"> |
|
（<el-input class="l-input" placeholder="请输入分值" v-model="ques.score" />分）</p> |
|
|
|
<el-popover v-else-if="ques.fillScores" placement="bottom" width="350" trigger="click"> |
|
<div class="fill-scores"> |
|
<p class="fill-title">每空分值</p> |
|
<div v-for="(score, k) in ques.fillScores" :key="k" class="input-wrap"> |
|
<el-input class="l-input" placeholder="请输入分值" v-model="score.val" |
|
@change="fillScoreChange(ques)" /> |
|
分 填空项{{ k + 1 }} |
|
<span |
|
v-if="ques.answerData && ques.answerData.length && ques.answerData[k] && ques.answerData[k].scoreProportion != 0"> 建议分值占比：{{ |
|
ques.answerData[k].scoreProportion }}%</span> |
|
</div> |
|
</div> |
|
<div slot="reference" class="input-wrap"> |
|
查看每空分值<el-input class="l-input" placeholder="请输入分值" v-model="ques.score" readonly /> |
|
</div> |
|
</el-popover> |
|
<el-button v-if="!ques.isDel" type="text" @click="toQues(item, j, ques, 2)">编辑试题</el-button> |
|
<el-button type="text" @click="showManualDia(item, j, ques)">更换试题</el-button> |
|
<el-button type="text" @click="showManualDia(item, j)">添加试题</el-button> |
|
<el-button type="text" @click="delQues(item, j)">移除试题</el-button> |
|
<div class="input-wrap"> |
|
<span>排序</span> |
|
<el-input class="l-input sort-input" v-model="ques.serialNumber" |
|
@change="sortChange(item, ques)" /> |
|
</div> |
|
</div> |
|
</div> |
|
<div class="stem html-parse" :id="'stem' + ques.questionVersionId" v-html="ques.stem"></div> |
|
|
|
<!-- 单选、多选、判断的选项 --> |
|
<template |
|
v-if="item.questionType !== 'fill_blank' && item.questionType !== 'essay' && ques.questionAnswerVersionsList"> |
|
<div v-for="(opt, j) in ques.questionAnswerVersionsList" :key="j" class="opt"> |
|
<span>{{ numToLetter(j) }}. </span> |
|
<div class="text html-parse" v-html="opt.optionText"></div> |
|
</div> |
|
</template> |
|
|
|
<div class="bottom-line"> |
|
【{{ item.questionType === 'essay' ? '参考答案' : '正确答案' }}】： |
|
<div v-html="getCorrectAnswer(ques)" class="ans html-parse"></div> |
|
</div> |
|
|
|
<div v-if="ques.knowledgePointList && ques.knowledgePointList.length" class="bottom-line"> |
|
<span>【知识点】</span> |
|
<el-tag v-for="(kp, k) in ques.knowledgePointList" :key="k" class="m-r-5" type="info" |
|
effect="plain">{{ |
|
kp.name }}</el-tag> |
|
</div> |
|
<div v-if="ques.questionBankName" class="bottom-line"> |
|
<span>来自：</span> |
|
<div>{{ ques.questionBankName }}</div> |
|
</div> |
|
</div> |
|
</div> |
|
</draggable> |
|
</div> |
|
</li> |
|
</ul> |
|
</el-form> |
|
<div class="btns"> |
|
<el-button @click="submit(0)">保存草稿</el-button> |
|
<el-button type="primary" @click="submit(1)">发布</el-button> |
|
<el-button v-if="paperId" @click="preview">预览</el-button> |
|
<el-button @click="back">取消</el-button> |
|
</div> |
|
</div> |
|
|
|
<div v-if="form.paperOutline && form.paperOutline.length" class="layer" id="layer"> |
|
<table class="table"> |
|
<thead> |
|
<tr> |
|
<th width="30%">大题</th> |
|
<th width="35%">已添加题数/目标题数</th> |
|
<th width="35%">已分配分值/目标分值</th> |
|
</tr> |
|
</thead> |
|
<tbody> |
|
<tr v-for="(item, i) in form.paperOutline" :key="i"> |
|
<td>第{{ arabicToChinese(i + 1) }}大题</td> |
|
<td>{{ item.examQuestions.length }}/{{ item.questionNum }}</td> |
|
<td>{{ item.examQuestions.reduce((e, j) => (e += +j.score), 0) || 0 }}/{{ item.targetScore }}</td> |
|
</tr> |
|
<tr> |
|
<td>总计</td> |
|
<td>{{ overview.alreadyQuesCount }}/{{ overview.questionCount }}</td> |
|
<td>{{ overview.alreadyScore }}/{{ overview.totalScore }}</td> |
|
</tr> |
|
</tbody> |
|
</table> |
|
</div> |
|
|
|
<Template :visible.sync="templateVisible" /> |
|
<Manual :visible.sync="manualVisible" :questionType.sync="curType.questionType" /> |
|
<Auto :visible.sync="autoVisible" /> |
|
<RepeatQues :visible.sync="repeatVisible" :list.sync="repeatQues" /> |
|
|
|
<el-drawer title="编辑试题" :visible.sync="addQuesVisible" size="1200px" :close-on-click-modal="false" |
|
custom-class="editques-dia"> |
|
<QuesDetail :key="quesKey" :paperType.sync="testPaperType" :curQues.sync="curRow" @closeAdd="closeAdd" |
|
@updateQues="updateQues" /> |
|
</el-drawer> |
|
</div> |
|
</template> |
|
<script> |
|
import Draggable from 'vuedraggable' |
|
import UeditorPlus from '@/components/ueditorPlus' |
|
import Breadcrumb from '@/components/breadcrumb' |
|
import Template from './template' |
|
import Manual from './manual' |
|
import Auto from './auto' |
|
import RepeatQues from './repeatQues' |
|
import QuesDetail from '@/pages/ques/detail' |
|
import Setting from '@/setting' |
|
import Util from '@/libs/util' |
|
import dayjs from 'dayjs' |
|
import QuesConst from '@/const/ques' |
|
import TestPaperConst from '@/const/testPaper' |
|
import Decimal from 'decimal.js' |
|
import _ from 'lodash' |
|
|
|
export default { |
|
components: { UeditorPlus, Breadcrumb, Template, Manual, Auto, RepeatQues, Draggable, QuesDetail }, |
|
data () { |
|
return { |
|
crumbs: [], |
|
questionTypes: QuesConst.questionTypes, |
|
difficults: TestPaperConst.difficults, |
|
paperTypes: TestPaperConst.paperTypes, |
|
arabicToChinese: Util.arabicToChinese, |
|
numToLetter: Util.numToLetter, |
|
paperId: this.$route.query.paperId, |
|
libraryId: this.$route.query.libraryId, |
|
isCopy: this.$route.query.isCopy, |
|
loading: false, |
|
headers: { |
|
token: Util.local.get(Setting.tokenKey) |
|
}, |
|
types: [], |
|
cascaderProps: { |
|
checkStrictly: true, |
|
label: "classificationName", |
|
value: "classificationId" |
|
}, |
|
professionals: [], |
|
|
|
dragGroup: { |
|
pull: false, |
|
}, |
|
form: { |
|
classificationId: +this.$route.query.classificationId || '', |
|
difficult: '', |
|
libraryId: '', |
|
name: '', |
|
paperMethod: '', |
|
paperType: '', |
|
particularYear: new Date(), |
|
professionalId: [], |
|
remarks: '', |
|
score: '', |
|
questionCount: 0, |
|
suggestTime: '', |
|
paperOutline: [ |
|
{ |
|
examQuestions: [], |
|
outlineName: '单选题', |
|
questionNum: '10', |
|
questionType: 'single_choice', |
|
targetScore: '20.0', |
|
shrink: false, |
|
checkAll: false, |
|
}, |
|
{ |
|
examQuestions: [], |
|
outlineName: '多选题', |
|
questionNum: '5', |
|
questionType: 'multiple_choice', |
|
targetScore: '15.0', |
|
shrink: false, |
|
checkAll: false, |
|
}, |
|
{ |
|
examQuestions: [], |
|
outlineName: '判断题', |
|
questionNum: '5', |
|
questionType: 'judgement', |
|
targetScore: '10.0', |
|
shrink: false, |
|
checkAll: false, |
|
}, |
|
{ |
|
examQuestions: [], |
|
outlineName: '填空题', |
|
questionNum: '5', |
|
questionType: 'fill_blank', |
|
targetScore: '15.0', |
|
shrink: false, |
|
checkAll: false, |
|
}, |
|
{ |
|
examQuestions: [], |
|
outlineName: '问答题', |
|
questionNum: '3', |
|
questionType: 'essay', |
|
targetScore: '40.0', |
|
shrink: false, |
|
checkAll: false, |
|
}, |
|
], |
|
}, |
|
rules: { |
|
name: [ |
|
{ required: true, message: '请输入试卷名称', trigger: 'blur' } |
|
], |
|
particularYear: [ |
|
{ required: true, message: '请选择年份', trigger: 'change' } |
|
], |
|
classificationId: [ |
|
{ required: true, message: '请选择所属试卷分类', trigger: 'change' } |
|
], |
|
paperType: [ |
|
{ required: true, message: '请选择建议用途', trigger: 'change' } |
|
], |
|
suggestTime: [ |
|
{ required: true, message: '请输入估计用时', trigger: 'blur' } |
|
], |
|
name: [ |
|
{ required: true, message: '请输入试卷名称', trigger: 'blur' } |
|
], |
|
}, |
|
templateName: '默认模板', |
|
templateVisible: false, |
|
manualVisible: false, |
|
curType: {}, |
|
curQuesIndex: 0, |
|
curQues: null, |
|
|
|
autoVisible: false, |
|
|
|
|
|
quesVisible: false, |
|
curRow: {}, |
|
|
|
difficultSelected: false, |
|
|
|
addQuesVisible: false, |
|
quesKey: 1, |
|
testPaperType: 2, |
|
|
|
repeatVisible: false, |
|
repeatQues: [], |
|
tempForm: {}, |
|
submiting: false, |
|
}; |
|
}, |
|
computed: { |
|
// 试题概览 |
|
overview () { |
|
const paper = this.form.paperOutline |
|
let questionCount = 0 |
|
let alreadyQuesCount = 0 |
|
let totalScore = 0 |
|
let alreadyScore = 0 |
|
paper.forEach(e => { |
|
questionCount += +e.questionNum // 试卷目标总题数 |
|
if (e.examQuestions) { |
|
alreadyQuesCount += e.examQuestions.length // 已添加总题数 |
|
totalScore = Decimal(totalScore).add(+e.targetScore || 0).toNumber() // 试卷目标总分 |
|
e.examQuestions.forEach(n => { |
|
alreadyScore = Decimal(alreadyScore).add(+n.score || 0).toNumber() // 已分配总分值 |
|
}) |
|
} |
|
}) |
|
return { |
|
questionCount, |
|
alreadyQuesCount, |
|
totalScore, |
|
alreadyScore, |
|
} |
|
}, |
|
}, |
|
mounted () { |
|
this.crumbs = [ |
|
{ |
|
name: '试卷管理', |
|
route: 'list', |
|
query: { |
|
id: this.libraryId |
|
} |
|
}, |
|
{ |
|
name: '创建试卷' |
|
}, |
|
] |
|
|
|
this.drag() |
|
this.getDetail() |
|
this.getType() |
|
this.getProfessional() |
|
}, |
|
methods: { |
|
// 获取试卷详情 |
|
async getDetail () { |
|
try { |
|
const { paperId } = this |
|
if (paperId) { |
|
this.loading = true |
|
const res = await this.$get(this.api.examPaperDetails, { |
|
id: paperId |
|
}) |
|
const r = res.examPaper |
|
delete r.createTime |
|
delete r.updateTime |
|
const paper = r.paperOutline |
|
paper.map(e => { |
|
e.shrink = false |
|
e.checkAll = false |
|
e.examQuestions.map((n, j) => { |
|
n.originSort = j + 1 |
|
Object.assign(n, n.question) |
|
this.handleQuesInfo(n) |
|
}) |
|
|
|
}) |
|
if (r.particularYear) r.particularYear = r.particularYear + '' |
|
r.professionalId = r.professionalId ? r.professionalId.split(',').map(e => +e) : [] |
|
this.form = r |
|
this.loading = false |
|
} |
|
} catch (e) { |
|
this.loading = false |
|
} |
|
}, |
|
// 获取试卷分类 |
|
async getType () { |
|
try { |
|
const res = await this.$post(this.api.examClassificationList, { |
|
libraryId: this.libraryId, |
|
}) |
|
const data = res.treeList |
|
this.handleType(data) |
|
this.types = data |
|
} catch (e) { } |
|
}, |
|
// 获取所属专业 |
|
async getProfessional () { |
|
try { |
|
const res = await this.$post(this.api.queryProfessional, { |
|
pageNum: 1, |
|
pageSize: 1000, |
|
}) |
|
this.professionals = res.pageList.records |
|
} catch (e) { } |
|
}, |
|
// 处理树形 |
|
handleType (list) { |
|
list.map(e => { |
|
if (e.children && e.children.length) { |
|
this.handleType(e.children) |
|
} else { |
|
delete e.children |
|
} |
|
}) |
|
}, |
|
// 试卷说明富文本加载完毕回调 |
|
remarksReady (editor) { |
|
this.form.remarks && editor.setContent(this.form.remarks) |
|
}, |
|
// 选择大纲模板 |
|
showTemplate () { |
|
this.templateVisible = true |
|
}, |
|
|
|
// 大纲题型选择回调 |
|
questionTypeChange (row) { |
|
// 如果大题名称为空，或者还是默认的名字（即5个题型的名字），那么修改了题型后需要同步修改大题名称，用户自定义了大题名称，则不修改 |
|
if (!row.outlineName || this.questionTypes.find(e => e.name === row.outlineName)) row.outlineName = this.questionTypes.find(e => e.id === row.questionType).name |
|
}, |
|
// 试卷大纲添加行 |
|
addLine (i) { |
|
this.form.paperOutline.splice(i + 1, 0, { |
|
examQuestions: [], |
|
outlineName: '', |
|
questionNum: '', |
|
questionType: '', |
|
targetScore: '', |
|
shrink: false, |
|
checkAll: false, |
|
}) |
|
}, |
|
// 试卷大纲移除行 |
|
delLine (i) { |
|
this.form.paperOutline.length > 1 && this.form.paperOutline.splice(i, 1) |
|
}, |
|
|
|
// 一键分配所有题目的分值 |
|
async allocationAll () { |
|
const paper = this.form.paperOutline |
|
const { data } = await this.$post(this.api.avgValues, { |
|
avgValueList: paper.map(e => { |
|
return { |
|
questionNum: e.examQuestions.length, |
|
targetScore: e.targetScore, |
|
questionType: e.questionType, |
|
} |
|
}) |
|
}) |
|
if (data && data.avgValueList && data.avgValueList.length) { |
|
const fillBlanks = [] |
|
data.avgValueList.map((e, i) => { |
|
paper[i].questionType === 'fill_blank' && fillBlanks.push(...paper[i].examQuestions) |
|
// scores里有-1则不用循环 |
|
e.scores.includes(-1) || e.scores.map((n, j) => { |
|
this.$set(paper[i].examQuestions[j], 'score', n) |
|
}) |
|
}) |
|
fillBlanks.length && this.fillBlankAllocation(fillBlanks) // 填空题则需要给里面的每个空再分配一次分数 |
|
} |
|
}, |
|
// 大题一键分配分值 |
|
async allocation (item) { |
|
const { data } = await this.$post(this.api.avgValues, { |
|
avgValueList: [{ |
|
questionNum: item.examQuestions.length, |
|
targetScore: +item.targetScore, |
|
questionType: item.questionType, |
|
}] |
|
}) |
|
if (data && data.avgValueList && data.avgValueList.length) { |
|
const { scores } = data.avgValueList[0] |
|
scores.includes(-1) || item.examQuestions.forEach((e, i) => { |
|
this.$set(e, 'score', scores[i]) |
|
}) |
|
} |
|
item.questionType === 'fill_blank' && this.fillBlankAllocation(item.examQuestions) // 填空题则需要给里面的每个空再分配一次分数 |
|
}, |
|
// 填空题一键分配 |
|
async fillBlankAllocation (list) { |
|
const param = list.map(e => { |
|
let { answerData } = e |
|
if (answerData && e.questionAnswerVersionsList) { |
|
return { |
|
questionType: e.questionType, |
|
answerData: e.questionAnswerVersionsList[0].answerData, |
|
questionNum: answerData.length, |
|
targetScore: e.score, |
|
questionId: e.questionVersionId |
|
} |
|
} |
|
}) |
|
|
|
const { data } = await this.$post(this.api.avgValues, { |
|
avgValueList: param |
|
}) |
|
if (data && data.avgValueList && data.avgValueList.length) { |
|
data.avgValueList.map((e, i) => { |
|
// scores里有-1则不用循环 |
|
if (!e.scores.includes(-1)) { |
|
const { fillScores } = list[i] |
|
if (fillScores) { |
|
for (const j in fillScores) { |
|
fillScores[j].val = e.scores[j] |
|
} |
|
} |
|
} |
|
}) |
|
} |
|
}, |
|
// 自动计算试卷难度 |
|
calcDifficult () { |
|
// 如果试卷难度用户已经选择过了，则不用再计算；如果没选择过，则通过公式计算难度：所有试题的难度系数之和/总试题数 |
|
if (this.difficultSelected) return false |
|
let coefficient = 0 // 试题总系数 |
|
let len = 0 // 试题总数 |
|
const diffs = QuesConst.difficults |
|
this.form.paperOutline.map(e => { |
|
len += e.examQuestions.length |
|
coefficient += e.examQuestions.reduce((e, j) => { |
|
const val = diffs.find(n => n.id === j.difficulty) |
|
return e += val ? +val.coefficient : 0 |
|
}, 0) |
|
}) |
|
const result = coefficient / len |
|
this.form.difficult = result <= 0.3 ? |
|
1 : |
|
result > 0.3 && result <= 0.4 ? |
|
2 : |
|
result > 0.4 && result <= 0.5 ? |
|
3 : |
|
4 |
|
}, |
|
// 自动选题 |
|
showAuto () { |
|
this.autoVisible = true |
|
}, |
|
// 处理正确答案的显示 |
|
getCorrectAnswer (e) { |
|
const opts = e.questionAnswerVersionsList |
|
if (e.questionType === 'fill_blank') { // 填空题 |
|
// answerData里存了该填空题所有填空项的正确答案及分值占比，对象转化为字符串存起来了 |
|
let data = e.answerData |
|
if (data) { |
|
let result = '' |
|
data.map((e, i) => { |
|
result += `填空项${i + 1}：${e.fills.map(n => n.val).join('|')}；` |
|
}) |
|
return result |
|
} |
|
return '' |
|
} else if (e.questionType === 'essay') { // 问答题取参考答案 |
|
if (opts) return opts[0].referenceAnswer || '暂无' |
|
} else { |
|
if (opts) { |
|
const correct = opts.filter(e => e.answerIsCorrect) |
|
return correct ? (e.questionType === 'judgement' ? correct[0].optionText : correct.map(e => Util.numToLetter(e.optionNumber - 1)).join('')) : '' // 单选多选显示ABC选项，判断题显示选项内容 |
|
} |
|
} |
|
}, |
|
|
|
// 处理试题的知识点名称、难度等 |
|
handleQuesInfo (ques) { |
|
try { |
|
// 难度名称 |
|
const { difficults } = QuesConst |
|
if (ques.difficulty) { |
|
const curDiff = difficults.find(m => m.id === ques.difficulty) |
|
if (curDiff) { |
|
ques.difficult = curDiff.name |
|
ques.difficultTheme = curDiff.theme |
|
} |
|
} |
|
|
|
const opts = ques.questionAnswerVersionsList |
|
// 填空题的小空分数处理 |
|
if (ques.questionType === 'fill_blank' && opts && opts.length) { |
|
// 填空题小空json |
|
let { answerData } = opts[0] |
|
if (answerData) { |
|
answerData = JSON.parse(answerData) |
|
ques.answerData = answerData |
|
// 正确答案 |
|
let { jsonText } = ques |
|
let scores |
|
if (jsonText) { |
|
jsonText = JSON.parse(jsonText) |
|
scores = jsonText.scores |
|
} |
|
|
|
const fillScores = answerData.map((e, i) => { |
|
return { |
|
val: scores ? scores[i] : '' |
|
} |
|
}) |
|
ques.fillScores = fillScores |
|
} |
|
} |
|
} catch (e) { } |
|
}, |
|
// 填空题分数输入回调 |
|
fillScoreChange (ques) { |
|
let total = 0 |
|
ques.fillScores.map(e => { |
|
if (e.val && !isNaN(e.val)) total = Decimal(total).add(e.val).toNumber() |
|
}) |
|
ques.score = total |
|
}, |
|
|
|
// 编辑试题 |
|
toQues (item, i, ques, type) { |
|
this.testPaperType = type |
|
this.quesKey++ |
|
this.curType = item |
|
this.curQuesIndex = i |
|
this.curRow = ques |
|
this.addQuesVisible = true |
|
}, |
|
// 关闭试题弹框 |
|
closeAdd () { |
|
this.addQuesVisible = false |
|
}, |
|
// 编辑试题完成后把新的试题信息带过来 |
|
updateQues (ques) { |
|
ques.questionAnswerVersionsList = ques.questionAnswerVersions |
|
delete ques.questionAnswerVersions |
|
ques.score = '' |
|
this.curType.examQuestions[this.curQuesIndex] = Object.assign(this.curRow, ques) |
|
this.handleQuesInfo(this.curType.examQuestions[this.curQuesIndex]) |
|
this.calcDifficult() |
|
}, |
|
|
|
// 添加题目 |
|
showManualDia (item, i, ques) { |
|
this.curType = item |
|
this.curQuesIndex = i |
|
this.curQues = ques |
|
this.manualVisible = true |
|
}, |
|
// 批量删除试题 |
|
async batchDelQues (item) { |
|
try { |
|
const checked = item.examQuestions.filter(e => e.check) |
|
if (checked.length) { |
|
await this.$confirm(`确认要移除吗？`, '提示', { |
|
confirmButtonText: '确定', |
|
cancelButtonText: '取消', |
|
type: 'warning', |
|
closeOnClickModal: false, |
|
}) |
|
checked.map(e => { |
|
const cur = item.examQuestions.findIndex(n => n.questionVersionId === e.questionVersionId) |
|
cur >= 0 && item.examQuestions.splice(cur, 1) |
|
}) |
|
item.checkAll = false |
|
this.calcDifficult() |
|
} else { |
|
Util.warningMsg('请选择数据') |
|
} |
|
} catch (e) { } |
|
}, |
|
// 拖拽后回调 |
|
updateSort (e, item) { |
|
e.preventDefault() |
|
item.examQuestions.map((e, i) => { |
|
this.$set(e, 'serialNumber', i + 1) |
|
}) |
|
}, |
|
// 排序输入完回调 |
|
sortChange (item, ques) { |
|
item.examQuestions.sort((a, b) => { |
|
if (a.serialNumber == b.serialNumber && (a.questionVersionId === ques.questionVersionId || b.questionVersionId === ques.questionVersionId)) return b.originSort - a.originSort |
|
return a.serialNumber - b.serialNumber |
|
}) |
|
item.examQuestions.map((e, i) => { |
|
e.originSort = i + 1 |
|
e.serialNumber = i + 1 |
|
}) |
|
}, |
|
// 移除试题 |
|
async delQues (item, i, noConfirm) { |
|
try { |
|
if (!noConfirm) { |
|
await this.$confirm(`确认要移除吗？`, '提示', { |
|
confirmButtonText: '确定', |
|
cancelButtonText: '取消', |
|
type: 'warning', |
|
closeOnClickModal: false, |
|
}) |
|
} |
|
item.examQuestions.splice(i, 1) |
|
item.checkAll = false |
|
this.calcDifficult() |
|
} catch (e) { } |
|
}, |
|
// 检查重复试题 |
|
hasRepeatQues (list) { |
|
const result = [] |
|
list.forEach(e => { |
|
list.forEach(n => { |
|
if (e.questionVersionId !== n.questionVersionId && !e.repeat) { |
|
let diff = 0 |
|
// 选择和判断题则判断题型+题干+选项内容；填空/问答：题干+题型一样即重复 |
|
if (e.questionType !== 'fill_blank' && e.questionType !== 'essay') { |
|
// 判断每个选项的内容是否相同 |
|
const opts = e.questionAnswerVersionsList |
|
if (opts) { |
|
for (const j in opts) { |
|
if (!n.questionAnswerVersionsList || !n.questionAnswerVersionsList[j] || n.questionAnswerVersionsList[j].optionText !== opts[j].optionText) { |
|
diff = 1 |
|
break |
|
} |
|
} |
|
} |
|
} |
|
if (e.questionType === n.questionType && e.stem === n.stem && !diff) { |
|
const i = result.findIndex(m => m.questionVersionId === e.questionVersionId || m.questionVersionId === n.questionVersionId) |
|
if (!e.repeat) { |
|
i === -1 ? result.push(e) : result.splice(i, 0, e) |
|
e.repeat = true |
|
} |
|
if (!n.repeat) { |
|
i === -1 ? result.push(n) : result.splice(i, 0, n) |
|
n.repeat = true |
|
} |
|
} |
|
} |
|
}) |
|
}) |
|
return result |
|
}, |
|
// 提交 |
|
submit (status) { |
|
if (!status) { |
|
// 草稿只需判断名字有没有填 |
|
if (!this.form.name) return Util.warningMsg('请输入试卷名称') |
|
this.validForm(status) |
|
} else { |
|
this.$refs.form.validate(async (valid) => { |
|
const { form } = this |
|
if (form.name === '') return Util.warningMsg('请输入试卷名称') |
|
if (!form.particularYear) return Util.warningMsg('请选择年份') |
|
if (!form.classificationId) return Util.warningMsg('请选择所属试卷分类') |
|
if (form.paperType === '') return Util.warningMsg('请选择建议用途') |
|
if (form.suggestTime === '') return Util.warningMsg('请输入估计用时') |
|
if (valid) { |
|
this.validForm(status) |
|
} |
|
}) |
|
} |
|
}, |
|
// 保存发送请求 |
|
async saveTestPaper () { |
|
try { |
|
await this.$post(this.api.saveExamPaper, this.tempForm) |
|
Util.successMsg('保存成功') |
|
this.back() |
|
} finally { |
|
this.submiting = false |
|
} |
|
}, |
|
// 提交验证及处理数据 |
|
async validForm (status) { |
|
if (this.submiting) return false |
|
const { isCopy, overview } = this // 复制 |
|
const { getUuid } = Util |
|
const form = _.cloneDeep(this.form) |
|
const paper = form.paperOutline |
|
const allQues = [] |
|
|
|
// 发布才需要校验 |
|
if (status) { |
|
if (isNaN(form.suggestTime) || form.suggestTime < 1 || form.suggestTime % 1) return Util.warningMsg('估计用时请输入正整数') |
|
let invalid = 0 |
|
|
|
loop1: |
|
for (const i in paper) { |
|
const e = paper[i] |
|
const chineseNum = this.arabicToChinese(+i + 1) |
|
if (!e.questionType) { |
|
Util.warningMsg('请选择题型') |
|
invalid = 1 |
|
break |
|
} |
|
if (!e.questionNum) { |
|
Util.warningMsg('请输入目标题数') |
|
invalid = 1 |
|
break |
|
} |
|
if (!e.outlineName) { |
|
Util.warningMsg(`第${chineseNum}大题请输入大题名称`) |
|
invalid = 1 |
|
break |
|
} |
|
if (!e.targetScore) { |
|
Util.warningMsg('请输入目标分值') |
|
invalid = 1 |
|
break |
|
} |
|
|
|
// 该大题里的小题总数需等于目标题数 |
|
if (+e.questionNum !== e.examQuestions.length) { |
|
Util.warningMsg(`第${chineseNum}大题的小题总数跟目标题数不一致，请重新修改`) |
|
invalid = 1 |
|
break |
|
} |
|
|
|
// 填空题需要拿每个小空的分数计算 |
|
if (e.questionType === 'fill_blank') { |
|
let totalScore = 0 |
|
|
|
for (const j in e.examQuestions) { |
|
const n = e.examQuestions[j] |
|
const { fillScores } = n |
|
if (fillScores) { |
|
for (const e of fillScores) { |
|
if (e.val === '' || e.val === undefined || e.val === null) { |
|
Util.warningMsg(`第${chineseNum}大题的第${this.arabicToChinese(+j + 1)}小题填空分数未填写完成，请重新修改`) |
|
invalid = 1 |
|
break loop1 |
|
} |
|
totalScore = Decimal(totalScore).add(e.val || 0).toNumber() |
|
} |
|
} |
|
} |
|
|
|
if (+e.targetScore !== totalScore) { |
|
Util.warningMsg(`第${chineseNum}大题的小题总分跟目标分值不一致，请重新修改`) |
|
invalid = 1 |
|
break |
|
} |
|
} else if (+e.targetScore !== e.examQuestions.reduce((e, j) => (e += +j.score), 0)) { |
|
// 该大题里的小题总分需等于目标分值 |
|
Util.warningMsg(`第${chineseNum}大题的小题总分跟目标分值不一致，请重新修改`) |
|
invalid = 1 |
|
break |
|
} |
|
|
|
// 试题里存在被禁用或者被删除的，不予提交 |
|
if (e.examQuestions.some(e => !e.status || e.isDel)) { |
|
Util.warningMsg(`当前试卷存在已被删除或已被禁用的试题，请进行相应调整 `) |
|
invalid = 1 |
|
break |
|
} |
|
e.examQuestions.map((n, j) => { |
|
e.uuid = getUuid() |
|
n.outlineName = e.outlineName |
|
n.paperIndex = i |
|
n.quesIndex = j |
|
n.repeat = false |
|
}) |
|
allQues.push(...e.examQuestions) |
|
} |
|
if (invalid) return false |
|
} |
|
this.submiting = true |
|
|
|
form.professionalId = form.professionalId.join() |
|
form.particularYear = +(dayjs(form.particularYear).format('YYYY')) |
|
form.libraryId = this.libraryId |
|
form.questionCount = overview.questionCount |
|
form.remarks = this.$refs.remarks.getUEContent() |
|
form.score = overview.totalScore |
|
form.status = status |
|
|
|
paper.map(e => { |
|
// 复制不需要传id |
|
if (isCopy) { |
|
e.paperId = '' |
|
e.outlineId = '' |
|
} |
|
e.targetScore = +e.targetScore |
|
|
|
e.examQuestions = e.examQuestions.map((n, j) => { |
|
// 填空题的各个填空分数处理 |
|
if (n.questionType === 'fill_blank') { |
|
const { fillScores } = n |
|
n.jsonText = JSON.stringify({ |
|
questionVersionId: n.questionVersionId, |
|
scores: fillScores ? fillScores.map(m => m.val) : [] |
|
}) |
|
} |
|
|
|
return { |
|
questionVersionId: n.questionVersionId, |
|
serialNumber: n.serialNumber, |
|
score: +n.score, |
|
jsonText: n.jsonText, |
|
paperId: !isCopy && this.paperId || '', |
|
outlineId: !isCopy && e.outlineId || '', |
|
} |
|
}) |
|
}) |
|
if (typeof form.classificationId === 'object') form.classificationId = form.classificationId[form.classificationId.length - 1] |
|
|
|
const { questionTypes } = QuesConst |
|
form.questionType = [...new Set(paper.map(e => questionTypes.find(n => n.id === e.questionType).name))].join(',') // 试题类型 |
|
form.createSource = 1 |
|
if (isCopy) form.paperId = '' |
|
this.tempForm = form |
|
|
|
|
|
// 如果有重复的试题，则弹框显示这些试题 |
|
const repeats = this.hasRepeatQues(allQues) |
|
if (repeats.length) { |
|
this.repeatVisible = true |
|
this.repeatQues = repeats |
|
return false |
|
} |
|
|
|
this.saveTestPaper() |
|
}, |
|
// 预览 |
|
preview () { |
|
window.open(this.$router.resolve(`preview?id=${this.paperId}`).href) |
|
}, |
|
// 返回 |
|
back () { |
|
this.$router.back() |
|
}, |
|
// 拖拽面板 |
|
drag () { |
|
const el = document.querySelector('#layer') |
|
if (el) { |
|
const drag = e => { |
|
e.stopPropagation && e.stopPropagation() |
|
e.preventDefault && e.preventDefault() |
|
e.cancelBubble = true |
|
e.returnValue = false |
|
let x = e.clientX - el.offsetLeft |
|
let y = e.clientY - el.offsetTop |
|
let left = 0 |
|
let top = 0 |
|
|
|
document.onmousemove = function (eve) { |
|
left = eve.clientX - x |
|
top = eve.clientY - y |
|
el.style.left = left + 'px' |
|
el.style.top = top + 'px' |
|
} |
|
document.onmouseup = e => { |
|
document.onmousemove = null |
|
document.onmouseup = null |
|
} |
|
} |
|
el.onmousedown = drag |
|
} |
|
}, |
|
} |
|
}; |
|
</script> |
|
|
|
<style lang="scss" scoped> |
|
.input-form.model { |
|
height: calc(100vh - 130px); |
|
} |
|
|
|
.tem-btn { |
|
position: absolute; |
|
top: 0; |
|
right: 0; |
|
} |
|
|
|
.ques { |
|
li { |
|
padding-bottom: 10px; |
|
margin: 20px 0 10px; |
|
border: 1px solid #dbdbdb; |
|
} |
|
|
|
.top { |
|
display: flex; |
|
justify-content: space-between; |
|
align-items: center; |
|
padding: 15px; |
|
} |
|
|
|
.serial { |
|
margin-right: 10px; |
|
font-size: 13px; |
|
} |
|
|
|
.shrink { |
|
margin-left: 10px; |
|
cursor: pointer; |
|
transition: .5s; |
|
|
|
&.active { |
|
transform: rotate(180deg); |
|
} |
|
} |
|
|
|
.sum { |
|
margin: 0 15px 15px; |
|
font-size: 13px; |
|
color: $main-color; |
|
} |
|
|
|
.ques-wrap { |
|
// transition: 2s; |
|
transition-property: height; |
|
transition-duration: .25s, 1s; |
|
|
|
&.hide { |
|
height: 0; |
|
} |
|
} |
|
|
|
.chosen { |
|
box-shadow: 0 0 7px rgba(239, 239, 239, .8); |
|
// border: solid 2px #3089dc !important; |
|
} |
|
|
|
.ques-item { |
|
display: flex; |
|
align-items: flex-start; |
|
padding: 15px; |
|
} |
|
|
|
/deep/img { |
|
max-width: 100%; |
|
} |
|
|
|
.ques-info { |
|
position: relative; |
|
width: calc(100% - 40px); |
|
padding: 10px; |
|
margin-left: 20px; |
|
border: 1px solid #e9e9e9; |
|
overflow: hidden; |
|
|
|
&.disabled, |
|
&.del, |
|
&.repeat { |
|
border-color: #f00; |
|
|
|
&:after { |
|
content: '已 禁 用'; |
|
position: absolute; |
|
top: 17px; |
|
right: -33px; |
|
padding: 5px 36px; |
|
font-size: 14px; |
|
color: #fff; |
|
background-color: #f00; |
|
transform: rotate(45deg); |
|
opacity: .6; |
|
} |
|
} |
|
|
|
&.del { |
|
&:after { |
|
content: '已 删 除'; |
|
} |
|
} |
|
|
|
&.repeat { |
|
border-color: #ff962a; |
|
|
|
&:after { |
|
content: '存在重复题'; |
|
background-color: #ff962a; |
|
} |
|
} |
|
} |
|
|
|
.top-line { |
|
display: flex; |
|
justify-content: space-between; |
|
align-items: baseline; |
|
margin-bottom: 10px; |
|
line-height: 28px; |
|
} |
|
|
|
.stem-info { |
|
display: inline-flex; |
|
align-items: baseline; |
|
flex: 1; |
|
} |
|
|
|
.labels { |
|
display: inline-flex; |
|
align-items: center; |
|
} |
|
|
|
.label { |
|
padding: 3px; |
|
margin-right: 10px; |
|
font-size: 12px; |
|
line-height: 1; |
|
color: $main-color; |
|
white-space: nowrap; |
|
border: 1px solid; |
|
border-radius: 2px; |
|
} |
|
|
|
/deep/.html-parse { |
|
table { |
|
display: table; |
|
margin-bottom: 10px; |
|
border-collapse: collapse; |
|
|
|
th, |
|
td { |
|
padding: 5px 10px; |
|
border: 1px solid #DDD; |
|
} |
|
} |
|
} |
|
|
|
.stem { |
|
margin-bottom: 10px; |
|
} |
|
|
|
/deep/.l-input { |
|
width: 100px; |
|
margin: 0 10px; |
|
|
|
&.sort-input { |
|
width: 56px; |
|
} |
|
|
|
.el-input__inner { |
|
height: 28px; |
|
line-height: 28px; |
|
} |
|
} |
|
|
|
.opt { |
|
display: flex; |
|
flex-wrap: wrap; |
|
padding-left: 10px; |
|
margin-bottom: 5px; |
|
font-size: 14px; |
|
color: #707070; |
|
line-height: 1.6; |
|
|
|
.text { |
|
max-width: calc(100% - 20px); |
|
} |
|
} |
|
|
|
.bottom-line { |
|
display: flex; |
|
align-items: baseline; |
|
margin-top: 10px; |
|
font-size: 13px; |
|
color: #333; |
|
} |
|
|
|
.ans { |
|
max-width: calc(100% - 100px); |
|
} |
|
|
|
.actions { |
|
display: inline-flex; |
|
align-items: center; |
|
|
|
.el-button { |
|
margin: 0 20px 0 0; |
|
} |
|
} |
|
|
|
.input-wrap { |
|
display: inline-flex; |
|
align-items: center; |
|
font-size: 12px; |
|
white-space: nowrap; |
|
} |
|
} |
|
|
|
.diff-text { |
|
line-height: 1.6; |
|
|
|
.em { |
|
font-weight: 600; |
|
} |
|
|
|
.coe { |
|
padding-left: 32px; |
|
} |
|
} |
|
|
|
.layer { |
|
z-index: 2000; |
|
position: fixed; |
|
top: 40%; |
|
right: 10px; |
|
width: 265px; |
|
max-height: 300px; |
|
background-color: #fff; |
|
box-shadow: 0 0 7px rgba(235, 235, 235, .8); |
|
overflow: auto; |
|
cursor: move; |
|
|
|
.table { |
|
text-align: center; |
|
border-collapse: collapse; |
|
|
|
th { |
|
padding: 10px 8px; |
|
font-size: 13px; |
|
color: #fff; |
|
background-color: #2bbb61; |
|
} |
|
|
|
td { |
|
padding: 10px; |
|
font-size: 12px; |
|
color: #333; |
|
|
|
&:first-child { |
|
background-color: #f1f1f1; |
|
} |
|
} |
|
} |
|
} |
|
|
|
/deep/.editques-dia { |
|
.el-drawer__header { |
|
margin-bottom: 0; |
|
} |
|
} |
|
</style> |