网考存阅卷明细分

examcloud-core-oe-admin-api-provider/src/main/java/cn/com/qmth/examcloud/core/oe/admin/api/controller/ExamRecordQuestionsController.java

@@ -1,12 +1,27 @@
 package cn.com.qmth.examcloud.core.oe.admin.api.controller;
 
-import cn.com.qmth.examcloud.commons.helpers.QuestionOptionHelper;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import org.apache.commons.collections.CollectionUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
 import cn.com.qmth.examcloud.commons.exception.StatusException;
+import cn.com.qmth.examcloud.commons.helpers.QuestionOptionHelper;
 import cn.com.qmth.examcloud.core.oe.admin.base.utils.Check;
 import cn.com.qmth.examcloud.core.oe.admin.dao.entity.ExamQuestionEntity;
 import cn.com.qmth.examcloud.core.oe.admin.dao.entity.ExamRecordQuestionsEntity;
 import cn.com.qmth.examcloud.core.oe.admin.service.ExamRecordDataSyncService;
 import cn.com.qmth.examcloud.core.oe.admin.service.ExamRecordQuestionsService;
+import cn.com.qmth.examcloud.core.oe.admin.service.MarkResultService;
 import cn.com.qmth.examcloud.marking.api.StudentPaperCloudService;
 import cn.com.qmth.examcloud.marking.api.bean.SubjectiveScoreBean;
 import cn.com.qmth.examcloud.marking.api.request.GetSubjectiveScoreReq;
@@ -15,20 +30,6 @@ import cn.com.qmth.examcloud.question.commons.core.question.QuestionType;
 import cn.com.qmth.examcloud.web.support.ControllerSupport;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
-import org.apache.commons.collections.CollectionUtils;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestParam;
-import org.springframework.web.bind.annotation.RestController;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-
 
 /**
  * @author chenken
@@ -45,6 +46,9 @@ public class ExamRecordQuestionsController extends ControllerSupport {
     @Autowired
     private ExamRecordQuestionsService examRecordQuestionsService;
 
+    @Autowired
+    private MarkResultService markResultService;
+
     @Autowired
     private ExamRecordDataSyncService examRecordDataSyncService;
 
@@ -53,8 +57,7 @@ public class ExamRecordQuestionsController extends ControllerSupport {
 
     @ApiOperation(value = "获取交卷之后的所有试题作答信息")
     @GetMapping("/getExamRecordQuestions")
-    public ExamRecordQuestionsEntity getExamRecordQuestions(
-            @RequestParam Long examRecordDataId,
+    public ExamRecordQuestionsEntity getExamRecordQuestions(@RequestParam Long examRecordDataId,
             @RequestParam(required = false) String fromCache,
             @RequestParam(required = false, defaultValue = "false") Boolean withScore) {
         Check.isNull(examRecordDataId, "examRecordDataId不能为空");
@@ -65,7 +68,8 @@ public class ExamRecordQuestionsController extends ControllerSupport {
             }
         }
 
-        ExamRecordQuestionsEntity result = examRecordQuestionsService.getExamRecordQuestionsAndFixExamRecordDataIfNecessary(examRecordDataId);
+        ExamRecordQuestionsEntity result = examRecordQuestionsService
+                .getExamRecordQuestionsAndFixExamRecordDataIfNecessary(examRecordDataId);
         if (withScore) {
             List<ExamQuestionEntity> examQuestions = result.getExamQuestionEntities();
             if (CollectionUtils.isEmpty(examQuestions)) {
@@ -76,7 +80,8 @@ public class ExamRecordQuestionsController extends ControllerSupport {
             for (ExamQuestionEntity examQuestion : examQuestions) {
                 if (QuestionType.isObjective(examQuestion.getQuestionType())) {
                     // 客观题得分
-                    if (QuestionOptionHelper.isEqualAnswer(examQuestion.getCorrectAnswer(), examQuestion.getStudentAnswer())) {
+                    if (QuestionOptionHelper.isEqualAnswer(examQuestion.getCorrectAnswer(),
+                            examQuestion.getStudentAnswer())) {
                         examQuestion.setStudentScore(examQuestion.getQuestionScore());
                     } else {
                         examQuestion.setStudentScore(0d);
@@ -93,15 +98,19 @@ public class ExamRecordQuestionsController extends ControllerSupport {
     }
 
     private Map<Integer, Double> loadSubjectiveScores(Long examRecordDataId) {
-        GetSubjectiveScoreReq req = new GetSubjectiveScoreReq();
-        req.setExamRecordDataId(examRecordDataId);
 
         Map<Integer, Double> scoreMaps = null;
         try {
-            GetSubjectiveScoreResp resp = studentPaperCloudService.subjectiveScore(req);
-            List<SubjectiveScoreBean> scores = resp.getScores();
+            List<SubjectiveScoreBean> scores = markResultService.getScores(examRecordDataId);
+            if (CollectionUtils.isEmpty(scores)) {
+                GetSubjectiveScoreReq req = new GetSubjectiveScoreReq();
+                req.setExamRecordDataId(examRecordDataId);
+                GetSubjectiveScoreResp resp = studentPaperCloudService.subjectiveScore(req);
+                scores = resp.getScores();
+            }
             if (CollectionUtils.isNotEmpty(scores)) {
-                scoreMaps = scores.stream().collect(Collectors.toMap(SubjectiveScoreBean::getQuestionOrder, SubjectiveScoreBean::getScore, (k, v) -> v));
+                scoreMaps = scores.stream().collect(Collectors.toMap(SubjectiveScoreBean::getQuestionOrder,
+                        SubjectiveScoreBean::getScore, (k, v) -> v));
             }
         } catch (Exception e) {
             log.error(e.getMessage(), e);

examcloud-core-oe-admin-api-provider/src/main/java/cn/com/qmth/examcloud/core/oe/admin/api/provider/ExamRecordQuestionsCloudServiceProvider.java

@@ -1,22 +1,38 @@
 package cn.com.qmth.examcloud.core.oe.admin.api.provider;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.jsoup.Jsoup;
+import org.jsoup.nodes.Document;
+import org.jsoup.nodes.Element;
+import org.jsoup.select.Elements;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import com.mysql.cj.util.StringUtils;
+
 import cn.com.qmth.examcloud.core.oe.admin.api.ExamRecordQuestionsCloudService;
 import cn.com.qmth.examcloud.core.oe.admin.api.bean.QuerySubjectiveAnswerBean;
-import cn.com.qmth.examcloud.core.oe.admin.api.bean.SaveSubjectiveQuestionScoreBean;
 import cn.com.qmth.examcloud.core.oe.admin.api.bean.SubjectiveAnswerBean;
 import cn.com.qmth.examcloud.core.oe.admin.api.request.GetSubjectiveAnswerReq;
 import cn.com.qmth.examcloud.core.oe.admin.api.request.QuerySubjectiveAnswerListReq;
 import cn.com.qmth.examcloud.core.oe.admin.api.request.SaveSubjectiveQuestionScoreReq;
 import cn.com.qmth.examcloud.core.oe.admin.api.response.GetSubjectiveAnswerResp;
 import cn.com.qmth.examcloud.core.oe.admin.api.response.QuerySubjectiveAnswerListResp;
-import cn.com.qmth.examcloud.core.oe.admin.base.utils.Check;
 import cn.com.qmth.examcloud.core.oe.admin.dao.ExamRecordDataRepo;
 import cn.com.qmth.examcloud.core.oe.admin.dao.ExamRecordQuestionsRepo;
 import cn.com.qmth.examcloud.core.oe.admin.dao.entity.ExamQuestionEntity;
 import cn.com.qmth.examcloud.core.oe.admin.dao.entity.ExamRecordDataEntity;
 import cn.com.qmth.examcloud.core.oe.admin.dao.entity.ExamRecordQuestionsEntity;
 import cn.com.qmth.examcloud.core.oe.admin.service.ExamRecordQuestionsService;
-import cn.com.qmth.examcloud.core.oe.admin.service.bean.SubjectiveQuestionScoreInfo;
+import cn.com.qmth.examcloud.core.oe.admin.service.MarkResultService;
 import cn.com.qmth.examcloud.question.commons.core.question.AnswerType;
 import cn.com.qmth.examcloud.question.commons.core.question.DefaultQuestionStructure;
 import cn.com.qmth.examcloud.question.commons.core.question.DefaultQuestionUnit;
@@ -26,23 +42,8 @@ import cn.com.qmth.examcloud.support.cache.bean.CourseCacheBean;
 import cn.com.qmth.examcloud.support.cache.bean.QuestionCacheBean;
 import cn.com.qmth.examcloud.web.helpers.GlobalHelper;
 import cn.com.qmth.examcloud.web.support.ControllerSupport;
-import com.mysql.cj.util.StringUtils;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
-import org.jsoup.Jsoup;
-import org.jsoup.nodes.Document;
-import org.jsoup.nodes.Element;
-import org.jsoup.select.Elements;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.RequestBody;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Collectors;
 
 /**
  * @author chenken
@@ -53,13 +54,17 @@ import java.util.stream.Collectors;
 @Api(tags = "学生作答答案相关接口")
 @RestController
 @RequestMapping("${$rmp.cloud.oe}/examRecordQuestions")
-public class ExamRecordQuestionsCloudServiceProvider extends ControllerSupport implements ExamRecordQuestionsCloudService {
+public class ExamRecordQuestionsCloudServiceProvider extends ControllerSupport
+        implements ExamRecordQuestionsCloudService {
 
     private static final long serialVersionUID = -1058894529829651231L;
 
     @Autowired
     private ExamRecordQuestionsService examRecordQuestionsService;
 
+    @Autowired
+    private MarkResultService markResultService;
+
     @Autowired
     private ExamRecordDataRepo examRecordDataRepo;
 
@@ -73,7 +78,8 @@ public class ExamRecordQuestionsCloudServiceProvider extends ControllerSupport i
     @ApiOperation(value = "阅卷获取考试记录主观题答案信息")
     @PostMapping("/querySubjectiveAnswerList")
     public QuerySubjectiveAnswerListResp querySubjectiveAnswerList(@RequestBody QuerySubjectiveAnswerListReq req) {
-        List<ExamQuestionEntity> examQuestionList = examRecordQuestionsService.querySubjectiveAnswerList(req.getExamRecordDataId());
+        List<ExamQuestionEntity> examQuestionList = examRecordQuestionsService
+                .querySubjectiveAnswerList(req.getExamRecordDataId());
         QuerySubjectiveAnswerListResp resp = new QuerySubjectiveAnswerListResp();
         List<QuerySubjectiveAnswerBean> querySubjectiveAnswerBeanList = new ArrayList<QuerySubjectiveAnswerBean>();
         for (ExamQuestionEntity examQuestionEntity : examQuestionList) {
@@ -93,23 +99,29 @@ public class ExamRecordQuestionsCloudServiceProvider extends ControllerSupport i
     @Override
     @ApiOperation(value = "阅卷回传主观题得分")
     @PostMapping("/saveSubjectiveQuestionScore")
-    public void saveSubjectiveQuestionScore(@RequestBody SaveSubjectiveQuestionScoreReq req) {
-        Check.isNull(req.getExamRecordDataId(), "examRecordDataId 不能为空");
-        List<SaveSubjectiveQuestionScoreBean> saveSubjectiveQuestionScoreList = req.getSaveSubjectiveQuestionScoreList();
-        if (saveSubjectiveQuestionScoreList == null || saveSubjectiveQuestionScoreList.size() == 0) {
-            return;
-        }
-        long examRecordDataId = req.getExamRecordDataId();
-        List<SubjectiveQuestionScoreInfo> subjectiveQuestionScoreInfoList = new ArrayList<SubjectiveQuestionScoreInfo>();
-        for (SaveSubjectiveQuestionScoreBean bean : saveSubjectiveQuestionScoreList) {
-            SubjectiveQuestionScoreInfo info = new SubjectiveQuestionScoreInfo();
-            info.setExamRecordDataId(bean.getExamRecordDataId());
-            info.setOrder(bean.getOrder());
-            info.setQuestionId(bean.getQuestionId());
-            info.setScore(bean.getScore());
-            subjectiveQuestionScoreInfoList.add(info);
-        }
-        examRecordQuestionsService.saveSubjectiveQuestionScore(examRecordDataId, subjectiveQuestionScoreInfoList);
+    public void saveSubjectiveQuestionScore(@RequestBody @Validated SaveSubjectiveQuestionScoreReq req) {
+        markResultService.modifyScore(req);
+        // List<SaveSubjectiveQuestionScoreBean> saveSubjectiveQuestionScoreList
+        // = req
+        // .getSaveSubjectiveQuestionScoreList();
+        // if (saveSubjectiveQuestionScoreList == null ||
+        // saveSubjectiveQuestionScoreList.size() == 0) {
+        // return;
+        // }
+        // long examRecordDataId = req.getExamRecordDataId();
+        // List<SubjectiveQuestionScoreInfo> subjectiveQuestionScoreInfoList =
+        // new ArrayList<SubjectiveQuestionScoreInfo>();
+        // for (SaveSubjectiveQuestionScoreBean bean :
+        // saveSubjectiveQuestionScoreList) {
+        // SubjectiveQuestionScoreInfo info = new SubjectiveQuestionScoreInfo();
+        // info.setExamRecordDataId(bean.getExamRecordDataId());
+        // info.setOrder(bean.getOrder());
+        // info.setQuestionId(bean.getQuestionId());
+        // info.setScore(bean.getScore());
+        // subjectiveQuestionScoreInfoList.add(info);
+        // }
+        // examRecordQuestionsService.saveSubjectiveQuestionScore(examRecordDataId,
+        // subjectiveQuestionScoreInfoList);
 
     }
 
@@ -121,8 +133,8 @@ public class ExamRecordQuestionsCloudServiceProvider extends ControllerSupport i
     @PostMapping("/getSubjectiveAnswerList")
     public GetSubjectiveAnswerResp getSubjectiveAnswerList(@RequestBody GetSubjectiveAnswerReq req) {
         int rowCount = 100;
-        List<ExamRecordDataEntity> examRecordDataList =
-                examRecordDataRepo.findLimitedDataByExamIdAndIdMoreThan(req.getExamId(), req.getStartExamRecordId(), rowCount);
+        List<ExamRecordDataEntity> examRecordDataList = examRecordDataRepo
+                .findLimitedDataByExamIdAndIdMoreThan(req.getExamId(), req.getStartExamRecordId(), rowCount);
 
         if (null == examRecordDataList || examRecordDataList.isEmpty()) {
             return new GetSubjectiveAnswerResp(req.getStartExamRecordId(), null);
@@ -135,33 +147,38 @@ public class ExamRecordQuestionsCloudServiceProvider extends ControllerSupport i
             CourseCacheBean course = CacheHelper.getCourse(record.getCourseId());
             ExamRecordQuestionsEntity questionsEntity;
             if (null != recordQuestionsId) {
-                questionsEntity = GlobalHelper.getEntity(examRecordQuestionsRepo, recordQuestionsId, ExamRecordQuestionsEntity.class);
+                questionsEntity = GlobalHelper.getEntity(examRecordQuestionsRepo, recordQuestionsId,
+                        ExamRecordQuestionsEntity.class);
             } else {
-                questionsEntity = examRecordQuestionsService.getExamRecordQuestionsAndFixExamRecordDataIfNecessary(record.getId());
+                questionsEntity = examRecordQuestionsService
+                        .getExamRecordQuestionsAndFixExamRecordDataIfNecessary(record.getId());
             }
 
             List<ExamQuestionEntity> examQuestionList = questionsEntity.getExamQuestionEntities();
-            //获取所有的主观题
-            List<ExamQuestionEntity> subjectiveQuestionList = examQuestionList.stream().filter(p -> p.getQuestionType() == QuestionType.ESSAY ||
-                    p.getQuestionType() == QuestionType.FILL_UP).collect(Collectors.toList());
+            // 获取所有的主观题
+            List<ExamQuestionEntity> subjectiveQuestionList = examQuestionList.stream().filter(
+                    p -> p.getQuestionType() == QuestionType.ESSAY || p.getQuestionType() == QuestionType.FILL_UP)
+                    .collect(Collectors.toList());
 
             for (int i = 0; i < subjectiveQuestionList.size(); i++) {
                 ExamQuestionEntity sq = subjectiveQuestionList.get(i);
 
                 SubjectiveAnswerBean subjectiveAnswerBean;
 
-                //集合中是否已存在当前作答结果（因为套题会提前插入部分数据）
+                // 集合中是否已存在当前作答结果（因为套题会提前插入部分数据）
                 String questionId = sq.getQuestionId();
                 Integer order = sq.getOrder();
-                List<SubjectiveAnswerBean> existSubjectiveAnswerBeanList = subjectiveAnswerBeanList.stream().filter(p -> questionId.equals(p.getQuestionId())
-                        && order.equals(p.getOrder())).collect(Collectors.toList());
+                List<SubjectiveAnswerBean> existSubjectiveAnswerBeanList = subjectiveAnswerBeanList.stream()
+                        .filter(p -> questionId.equals(p.getQuestionId()) && order.equals(p.getOrder()))
+                        .collect(Collectors.toList());
 
-                //如果已经存在，则直接修改,因为套题一次性设置多个小题的题干，所以如果已经设置过就不再设置题干部分
+                // 如果已经存在，则直接修改,因为套题一次性设置多个小题的题干，所以如果已经设置过就不再设置题干部分
                 if (null != existSubjectiveAnswerBeanList && !existSubjectiveAnswerBeanList.isEmpty()) {
                     subjectiveAnswerBean = existSubjectiveAnswerBeanList.get(0);
 
                     subjectiveAnswerBean.setAnswerType(sq.getAnswerType());
-                    subjectiveAnswerBean.setRealAnswerType(transformedAnswerType(sq.getAnswerType(), sq.getQuestionType(), record.getExamId()));//实际的作答类型
+                    subjectiveAnswerBean.setRealAnswerType(
+                            transformedAnswerType(sq.getAnswerType(), sq.getQuestionType(), record.getExamId()));// 实际的作答类型
                     subjectiveAnswerBean.setCourseCode(course.getCode());
                     subjectiveAnswerBean.setExamId(req.getExamId());
                     subjectiveAnswerBean.setExamRecordDataId(record.getId());
@@ -173,12 +190,13 @@ public class ExamRecordQuestionsCloudServiceProvider extends ControllerSupport i
                     subjectiveAnswerBean.setAnswer(sq.getCorrectAnswer());
                 }
 
-                //不存在则重新实例化,并添加
+                // 不存在则重新实例化,并添加
                 else {
                     subjectiveAnswerBean = new SubjectiveAnswerBean();
 
                     subjectiveAnswerBean.setAnswerType(sq.getAnswerType());
-                    subjectiveAnswerBean.setRealAnswerType(transformedAnswerType(sq.getAnswerType(), sq.getQuestionType(), record.getExamId()));//实际的作答类型
+                    subjectiveAnswerBean.setRealAnswerType(
+                            transformedAnswerType(sq.getAnswerType(), sq.getQuestionType(), record.getExamId()));// 实际的作答类型
                     subjectiveAnswerBean.setCourseCode(course.getCode());
                     subjectiveAnswerBean.setExamId(req.getExamId());
                     subjectiveAnswerBean.setExamRecordDataId(record.getId());
@@ -189,26 +207,28 @@ public class ExamRecordQuestionsCloudServiceProvider extends ControllerSupport i
                     subjectiveAnswerBean.setStudentAnswer(transformedStudentAnswer(sq.getStudentAnswer()));
                     subjectiveAnswerBean.setAnswer(sq.getCorrectAnswer());
 
-                    /**题干部分相关处理逻辑**/
-                    //TODO 这是由于历史原因(套题下的小题共享同一个questionId)，导致这个恶心的变通实现方式,如果以后优化了套题的结构，可修改
-                    QuestionCacheBean getQuestionResp = CacheHelper.getQuestion(record.getExamId(),
-                            course.getCode(), record.getPaperType(), questionId);
-                    DefaultQuestionStructure questionStructure = getQuestionResp.getDefaultQuestion().getMasterVersion();
+                    /** 题干部分相关处理逻辑 **/
+                    // TODO
+                    // 这是由于历史原因(套题下的小题共享同一个questionId)，导致这个恶心的变通实现方式,如果以后优化了套题的结构，可修改
+                    QuestionCacheBean getQuestionResp = CacheHelper.getQuestion(record.getExamId(), course.getCode(),
+                            record.getPaperType(), questionId);
+                    DefaultQuestionStructure questionStructure = getQuestionResp.getDefaultQuestion()
+                            .getMasterVersion();
 
-                    //所有的小题单元
+                    // 所有的小题单元
                     List<DefaultQuestionUnit> questionUnits = questionStructure.getQuestionUnitList();
 
-                    //如果主题干不为空，则认为是套题(套题需要将大题题干和小题题干拼在一起)
-                    String mainBody = questionStructure.getBody();//主题干
+                    // 如果主题干不为空，则认为是套题(套题需要将大题题干和小题题干拼在一起)
+                    String mainBody = questionStructure.getBody();// 主题干
                     if (!StringUtils.isNullOrEmpty(mainBody)) {
-                        //第1小题的子题干
+                        // 第1小题的子题干
                         String subBody0 = questionUnits.get(0).getBody();
 
-                        //首先将本条数据添加（本条数据是完整的）
+                        // 首先将本条数据添加（本条数据是完整的）
                         subjectiveAnswerBean.setBody(mainBody + subBody0);
                         subjectiveAnswerBeanList.add(subjectiveAnswerBean);
 
-                        //其次，拼装套题的其它几个小题的题干（只初始化题干和唯一标识）,并提前添加到结果集中
+                        // 其次，拼装套题的其它几个小题的题干（只初始化题干和唯一标识）,并提前添加到结果集中
                         for (int j = 1; j < questionUnits.size(); j++) {
                             SubjectiveAnswerBean nextSubjectiveAnswerBean = new SubjectiveAnswerBean();
                             nextSubjectiveAnswerBean.setQuestionId(questionId);
@@ -217,7 +237,7 @@ public class ExamRecordQuestionsCloudServiceProvider extends ControllerSupport i
                             subjectiveAnswerBeanList.add(nextSubjectiveAnswerBean);
                         }
                     }
-                    //不是套题，则默认取第一条记录的题干
+                    // 不是套题，则默认取第一条记录的题干
                     else {
                         subjectiveAnswerBean.setBody(questionUnits.get(0).getBody());
                         subjectiveAnswerBeanList.add(subjectiveAnswerBean);
@@ -233,20 +253,23 @@ public class ExamRecordQuestionsCloudServiceProvider extends ControllerSupport i
     /**
      * 根据原始作答类型和学生实际作答推断出真实的作答类型
      *
-     * @param answerType   原始作答类型
-     * @param questionType 题型
-     * @param examId       考试id
+     * @param answerType
+     *            原始作答类型
+     * @param questionType
+     *            题型
+     * @param examId
+     *            考试id
      * @return
      */
     private String transformedAnswerType(AnswerType answerType, QuestionType questionType, Long examId) {
-        //需要图片作答的考试id(以英文逗号分隔)
+        // 需要图片作答的考试id(以英文逗号分隔)
         Object oExamId = CacheHelper.getSysProperty("oe.imgAnswer.examId").getValue();
         if (null != oExamId) {
             String strExamId = String.valueOf(oExamId);
             List<String> examIdList = Arrays.asList(strExamId.split(","));
-            //如果题型为问答题，且作答类型不为音频作答，且考试为需要图片作答，则此题为图片作答题
-            if (questionType == QuestionType.ESSAY &&
-                    (null == answerType || (null != answerType && answerType != AnswerType.SINGLE_AUDIO))) {
+            // 如果题型为问答题，且作答类型不为音频作答，且考试为需要图片作答，则此题为图片作答题
+            if (questionType == QuestionType.ESSAY
+                    && (null == answerType || (null != answerType && answerType != AnswerType.SINGLE_AUDIO))) {
                 if (examIdList.stream().anyMatch(eid -> eid.equals(String.valueOf(examId)))) {
                     return "image";
                 }
@@ -271,7 +294,7 @@ public class ExamRecordQuestionsCloudServiceProvider extends ControllerSupport i
             return studentAnswer;
         }
 
-        //图片题特殊处理(因为图片作答题中有html标签)
+        // 图片题特殊处理(因为图片作答题中有html标签)
         Document doc = Jsoup.parse(studentAnswer);
         Elements imgElements = doc.select("img[src]");
         String imgStudentAnswer = "";

examcloud-core-oe-admin-api-provider/src/main/java/cn/com/qmth/examcloud/core/oe/admin/api/provider/MarkResultCloudServiceProvider.java

@@ -0,0 +1,36 @@
+package cn.com.qmth.examcloud.core.oe.admin.api.provider;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import cn.com.qmth.examcloud.core.oe.admin.api.MarkResultCloudService;
+import cn.com.qmth.examcloud.core.oe.admin.api.request.ClearMarkResultReq;
+import cn.com.qmth.examcloud.core.oe.admin.api.response.ClearMarkResultResp;
+import cn.com.qmth.examcloud.core.oe.admin.service.MarkResultService;
+import cn.com.qmth.examcloud.web.support.ControllerSupport;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+
+@Api(tags = "阅卷分数接口")
+@RestController
+@RequestMapping("${$rmp.cloud.oe}/mark/result")
+public class MarkResultCloudServiceProvider extends ControllerSupport implements MarkResultCloudService {
+
+    private static final long serialVersionUID = 4538819077863159166L;
+
+    @Autowired
+    private MarkResultService markResultService;
+
+    @Override
+    @ApiOperation(value = "清空评卷结果")
+    @PostMapping("clear")
+    public ClearMarkResultResp clearScore(@RequestBody @Validated ClearMarkResultReq req) {
+        markResultService.clearScore(req);
+        return new ClearMarkResultResp();
+    }
+
+}

examcloud-core-oe-admin-dao/src/main/java/cn/com/qmth/examcloud/core/oe/admin/dao/MarkResultRepo.java

@@ -0,0 +1,19 @@
+package cn.com.qmth.examcloud.core.oe.admin.dao;
+
+import java.util.List;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.stereotype.Repository;
+
+import cn.com.qmth.examcloud.core.oe.admin.dao.entity.MarkResultEntity;
+
+@Repository
+public interface MarkResultRepo
+        extends JpaRepository<MarkResultEntity, Long>, JpaSpecificationExecutor<MarkResultEntity> {
+
+    void deleteByExamRecordDataId(Long examRecordDataId);
+
+    List<MarkResultEntity> findByExamRecordDataId(Long examRecordDataId);
+
+}

examcloud-core-oe-admin-dao/src/main/java/cn/com/qmth/examcloud/core/oe/admin/dao/entity/MarkResultEntity.java

@@ -0,0 +1,154 @@
+package cn.com.qmth.examcloud.core.oe.admin.dao.entity;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.Index;
+import javax.persistence.Table;
+
+import cn.com.qmth.examcloud.web.jpa.JpaEntity;
+
+@Entity
+@Table(name = "ec_oe_mark_result", indexes = {
+        @Index(name = "IDX_01", columnList = "studentPaperId,orders", unique = true),
+        @Index(name = "IDX_02", columnList = "examRecordDataId,orders", unique = true) })
+public class MarkResultEntity extends JpaEntity {
+
+    private static final long serialVersionUID = 4101954661852038672L;
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(nullable = false)
+    private Long rootOrgId;
+
+    @Column(nullable = false)
+    private Long examId;
+
+    @Column(nullable = false)
+    private Long workId;
+
+    @Column(nullable = false)
+    private Long examRecordDataId;
+
+    @Column(nullable = false)
+    private Long courseId;
+
+    @Column(nullable = false)
+    private Long studentPaperId;
+
+    @Column(nullable = false)
+    private Double score;
+
+    @Column(nullable = false)
+    private Integer orders;
+
+    @Column(nullable = false)
+    private String questionId;
+
+    @Column(nullable = false)
+    private Integer mainNumber;
+
+    @Column(nullable = false)
+    private Integer subNumber;
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public Long getRootOrgId() {
+        return rootOrgId;
+    }
+
+    public void setRootOrgId(Long rootOrgId) {
+        this.rootOrgId = rootOrgId;
+    }
+
+    public Long getExamId() {
+        return examId;
+    }
+
+    public void setExamId(Long examId) {
+        this.examId = examId;
+    }
+
+    public Long getWorkId() {
+        return workId;
+    }
+
+    public void setWorkId(Long workId) {
+        this.workId = workId;
+    }
+
+    public Long getExamRecordDataId() {
+        return examRecordDataId;
+    }
+
+    public void setExamRecordDataId(Long examRecordDataId) {
+        this.examRecordDataId = examRecordDataId;
+    }
+
+    public Long getCourseId() {
+        return courseId;
+    }
+
+    public void setCourseId(Long courseId) {
+        this.courseId = courseId;
+    }
+
+    public Long getStudentPaperId() {
+        return studentPaperId;
+    }
+
+    public void setStudentPaperId(Long studentPaperId) {
+        this.studentPaperId = studentPaperId;
+    }
+
+    public Double getScore() {
+        return score;
+    }
+
+    public void setScore(Double score) {
+        this.score = score;
+    }
+
+    public Integer getOrders() {
+        return orders;
+    }
+
+    public void setOrders(Integer orders) {
+        this.orders = orders;
+    }
+
+    public String getQuestionId() {
+        return questionId;
+    }
+
+    public void setQuestionId(String questionId) {
+        this.questionId = questionId;
+    }
+
+    public Integer getMainNumber() {
+        return mainNumber;
+    }
+
+    public void setMainNumber(Integer mainNumber) {
+        this.mainNumber = mainNumber;
+    }
+
+    public Integer getSubNumber() {
+        return subNumber;
+    }
+
+    public void setSubNumber(Integer subNumber) {
+        this.subNumber = subNumber;
+    }
+
+}

examcloud-core-oe-admin-service/src/main/java/cn/com/qmth/examcloud/core/oe/admin/service/MarkResultService.java

@@ -0,0 +1,17 @@
+package cn.com.qmth.examcloud.core.oe.admin.service;
+
+import java.util.List;
+
+import cn.com.qmth.examcloud.core.oe.admin.api.request.ClearMarkResultReq;
+import cn.com.qmth.examcloud.core.oe.admin.api.request.SaveSubjectiveQuestionScoreReq;
+import cn.com.qmth.examcloud.marking.api.bean.SubjectiveScoreBean;
+
+public interface MarkResultService {
+
+    void modifyScore(SaveSubjectiveQuestionScoreReq req);
+
+    void clearScore(ClearMarkResultReq req);
+
+    List<SubjectiveScoreBean> getScores(Long examRecordDataId);
+
+}

examcloud-core-oe-admin-service/src/main/java/cn/com/qmth/examcloud/core/oe/admin/service/impl/MarkResultServiceImpl.java

@@ -0,0 +1,91 @@
+package cn.com.qmth.examcloud.core.oe.admin.service.impl;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.commons.collections4.CollectionUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import cn.com.qmth.examcloud.core.oe.admin.api.bean.MarkResultScoreBean;
+import cn.com.qmth.examcloud.core.oe.admin.api.request.ClearMarkResultReq;
+import cn.com.qmth.examcloud.core.oe.admin.api.request.SaveSubjectiveQuestionScoreReq;
+import cn.com.qmth.examcloud.core.oe.admin.dao.MarkResultRepo;
+import cn.com.qmth.examcloud.core.oe.admin.dao.entity.MarkResultEntity;
+import cn.com.qmth.examcloud.core.oe.admin.service.ExamRecordQuestionsService;
+import cn.com.qmth.examcloud.core.oe.admin.service.MarkResultService;
+import cn.com.qmth.examcloud.core.oe.admin.service.bean.SubjectiveQuestionScoreInfo;
+import cn.com.qmth.examcloud.marking.api.bean.SubjectiveScoreBean;
+
+@Service
+public class MarkResultServiceImpl implements MarkResultService {
+
+    @Autowired
+    private MarkResultRepo markResultRepo;
+
+    @Autowired
+    private ExamRecordQuestionsService examRecordQuestionsService;
+
+    @Transactional
+    @Override
+    public void modifyScore(SaveSubjectiveQuestionScoreReq req) {
+        markResultRepo.deleteByExamRecordDataId(req.getExamRecordDataId());
+        markResultRepo.flush();
+        List<MarkResultEntity> ret = new ArrayList<>();
+        for (MarkResultScoreBean dto : req.getScores()) {
+            MarkResultEntity tem = new MarkResultEntity();
+            tem.setRootOrgId(req.getRootOrgId());
+            tem.setCourseId(req.getCourseId());
+            tem.setExamId(req.getExamId());
+            tem.setExamRecordDataId(req.getExamRecordDataId());
+            tem.setWorkId(req.getWorkId());
+            tem.setStudentPaperId(req.getStudentPaperId());
+            tem.setMainNumber(dto.getMainNumber());
+            tem.setOrders(dto.getOrders());
+            tem.setQuestionId(dto.getQuestionId());
+            tem.setScore(dto.getScore());
+            tem.setSubNumber(dto.getSubNumber());
+            ret.add(tem);
+        }
+        markResultRepo.saveAll(ret);
+        saveSubjectiveQuestionScore(req);
+    }
+
+    private void saveSubjectiveQuestionScore(SaveSubjectiveQuestionScoreReq req) {
+        List<SubjectiveQuestionScoreInfo> subjectiveQuestionScoreInfoList = new ArrayList<SubjectiveQuestionScoreInfo>();
+        for (MarkResultScoreBean bean : req.getScores()) {
+            SubjectiveQuestionScoreInfo info = new SubjectiveQuestionScoreInfo();
+            info.setExamRecordDataId(req.getExamRecordDataId());
+            info.setOrder(bean.getOrders());
+            info.setQuestionId(bean.getQuestionId());
+            info.setScore(bean.getScore());
+            subjectiveQuestionScoreInfoList.add(info);
+        }
+        examRecordQuestionsService.saveSubjectiveQuestionScore(req.getExamRecordDataId(),
+                subjectiveQuestionScoreInfoList);
+
+    }
+
+    @Transactional
+    @Override
+    public void clearScore(ClearMarkResultReq req) {
+        markResultRepo.deleteByExamRecordDataId(req.getExamRecordDataId());
+    }
+
+    @Override
+    public List<SubjectiveScoreBean> getScores(Long examRecordDataId) {
+        List<MarkResultEntity> es = markResultRepo.findByExamRecordDataId(examRecordDataId);
+        if (CollectionUtils.isEmpty(es)) {
+            return null;
+        }
+        List<SubjectiveScoreBean> ret = new ArrayList<>();
+        for (MarkResultEntity e : es) {
+            SubjectiveScoreBean b = new SubjectiveScoreBean();
+            ret.add(b);
+            b.setQuestionOrder(e.getOrders());
+            b.setScore(e.getScore());
+        }
+        return ret;
+    }
+}