Merge branch 'bug-branch' of chchen/exercise into master

题目编辑

ssj-common-elasticsearch/src/main/java/com/ssj/es/service/ExerciseQuestionSearchService.java

@@ -627,6 +627,19 @@ public class ExerciseQuestionSearchService extends BaseElasticService{
 		return this.bulk(bulkRequest);
 	}
 
+	public boolean insertOrUpdateBatch(String idName, List<ElasticEntity> elasticEntityList) {
+		BulkRequest bulkRequest = new BulkRequest();
+		UpdateRequest updateRequest;
+		for (ElasticEntity elasticEntity : elasticEntityList) {
+			updateRequest = new UpdateRequest(idName, elasticEntity.getId())
+					.doc(elasticEntity.getData())
+					.upsert(elasticEntity.getData());
+			bulkRequest.add(updateRequest);
+		}
+
+		return this.bulk(bulkRequest);
+	}
+
 	/**
 	 * 通过id列表批量查询题目
 	 * @param questionIds
@@ -673,4 +686,9 @@ public class ExerciseQuestionSearchService extends BaseElasticService{
 		}
 		return result;
 	}
+
+	@Override
+	protected boolean bulk(BulkRequest bulkRequest) {
+		return super.bulk(bulkRequest);
+	}
 }

ssj-kmt-exercise-api/src/main/java/com/ssj/aijia/kmt/exercise/controller/KmtExerciseController.java

@@ -21,6 +21,8 @@ import com.ssj.service.kmt.dto.KmtSysUserDTO;
 import com.ssj.service.kmt.dto.exercise.ExerciseQuestionRollbacks;
 import com.ssj.service.kmt.exercise.request.SubmitAnswerProofreadResultReq;
 import com.ssj.service.kmt.request.*;
+import com.ssj.service.kmt.request.rollbackai.AddExerciseQuestionRequest;
+import com.ssj.service.kmt.request.rollbackai.ExerciseQuestionDealRequest;
 import com.ssj.service.kmt.service.*;
 import com.ssj.service.sys.homework.service.HomeworkService;
 import com.ssj.service.sys.picturepredeal.service.PicturePreDealService;
@@ -80,6 +82,8 @@ public class KmtExerciseController extends BaseController {
 
     @Reference(version = "1.0", timeout = 60000)
     private KmtExerciseSubmitService kmtExerciseSubmitService;
+    @Reference(timeout = 60000)
+    private KmtExerciseQuestionDealService kmtExerciseQuestionDealService;
 
     /**
      * 废弃
@@ -626,4 +630,49 @@ public class KmtExerciseController extends BaseController {
         return responseEntity;
     }
 
+    @RequestMapping(value = "/addOrEditExerciseQuestion", method = RequestMethod.POST)
+    @ApiOperation(value = "新增、编辑题目", httpMethod = "POST", notes = "推荐题回调接口")
+    public ResponseEntity addOrEditExerciseQuestion(@RequestParam(name = "accessToken") String accessToken,
+                                                    @RequestBody AddExerciseQuestionRequest request) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        try {
+            String userId = tokenManager.getUserId(accessToken);
+            return kmtExerciseQuestionDealService.addOrEditExerciseQuestion(userId, request);
+        } catch (Exception e) {
+            logger.error("异常", e);
+            responseEntity.failure(ResponseConstant.CODE_500, "系统繁忙，请稍后重试");
+        }
+        return responseEntity;
+    }
+
+    @RequestMapping(value = "/deleteExerciseQuestion", method = RequestMethod.POST)
+    @ApiOperation(value = "删除题目", httpMethod = "POST", notes = "删除题目")
+    public ResponseEntity deleteExerciseQuestion(@RequestParam(name = "accessToken") String accessToken,
+                                                           @RequestBody ExerciseQuestionDealRequest request) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        try {
+            String userId = tokenManager.getUserId(accessToken);
+            return kmtExerciseQuestionDealService.deleteExerciseQuestion(userId, request);
+        } catch (Exception e) {
+            logger.error("异常", e);
+            responseEntity.failure(ResponseConstant.CODE_500, "系统繁忙，请稍后重试");
+        }
+        return responseEntity;
+    }
+
+    @RequestMapping(value = "/moveExerciseQuestion", method = RequestMethod.POST)
+    @ApiOperation(value = "移动题目", httpMethod = "POST", notes = "推荐题回调接口")
+    public ResponseEntity moveExerciseQuestion(@RequestParam(name = "accessToken") String accessToken,
+                                               @RequestBody ExerciseQuestionDealRequest request) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        try {
+            String userId = tokenManager.getUserId(accessToken);
+            return kmtExerciseQuestionDealService.moveExerciseQuestion(userId, request);
+        } catch (Exception e) {
+            logger.error("异常", e);
+            responseEntity.failure(ResponseConstant.CODE_500, "系统繁忙，请稍后重试");
+        }
+        return responseEntity;
+    }
+
 }

ssj-kmt-exercise-service-impl/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtExerciseQuestionDealServiceImpl.java

@@ -0,0 +1,343 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONArray;
+import com.ssj.bean.kmt.kmt.domain.KmtExerciseBook;
+import com.ssj.bean.kmt.kmt.domain.KmtExerciseQuestion;
+import com.ssj.bean.weixin.libmy.domain.TbLibManager;
+import com.ssj.dao.weixin.library.dao.IBookManagerDao;
+import com.ssj.es.service.ExerciseQuestionSearchService;
+import com.ssj.framework.core.util.PropertiesUtil;
+import com.ssj.framework.core.util.ResponseConstant;
+import com.ssj.framework.core.util.ResponseEntity;
+import com.ssj.framework.core.util.StringUtil;
+import com.ssj.framework.idworker.IdWorker;
+import com.ssj.framework.weixin.util.DateUtil;
+import com.ssj.kmt.utils.JSONFileUtil;
+import com.ssj.service.kmt.request.rollbackai.AddExerciseQuestionRequest;
+import com.ssj.service.kmt.request.rollbackai.ExerciseQuestionDealRequest;
+import com.ssj.service.kmt.service.KmtExerciseBookService;
+import com.ssj.service.kmt.service.KmtExerciseQuestionDealService;
+import com.ssj.service.kmt.service.KmtExerciseQuestionService;
+import com.ssj.service.mapper.KmtExerciseMapper;
+import com.ssj.service.task.SyncSaveExerciseBookCourseTask;
+import com.ssj.service.task.SyncSaveExerciseBookTask;
+import com.ssj.service.task.SyncSaveExerciseQuestionsTask;
+import com.ssj.taskthread.ThreadPool;
+import com.ssj.utils.ExerciseUtil;
+import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+@Service
+public class KmtExerciseQuestionDealServiceImpl implements KmtExerciseQuestionDealService {
+
+    protected Logger logger = LoggerFactory.getLogger(this.getClass());
+    @Autowired
+    private IBookManagerDao bookManagerDao;
+    @Autowired
+    private KmtExerciseQuestionService kmtExerciseQuestionService;
+    @Autowired
+    private KmtExerciseMapper kmtExerciseMapper;
+    @Autowired
+    private ExerciseQuestionSearchService exerciseQuestionSearchService;
+    @Autowired
+    private KmtExerciseBookService kmtExerciseBookService;
+
+    @Override
+    public ResponseEntity addOrEditExerciseQuestion(String userId, AddExerciseQuestionRequest request) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        if (isManagerSubmit(userId)){
+            String questionImage = getImagePath(request.getQuestion());
+            String answerImage = getImagePath(request.getAnswer());
+
+            if (StringUtils.isBlank(request.getQuestionId())){
+                //题目id不存在则是新增, 新增需要把一个num减1
+                KmtExerciseBook book  = kmtExerciseBookService.getById(request.getExerciseBookId());
+                KmtExerciseQuestion nextQuestion = kmtExerciseMapper.findByBookIdAndNum(book.getBookId(), request.getNum());
+                //新增小题
+                if (request.getQuestionClassType() == 2){
+                    KmtExerciseQuestion newQuestion = saveQuestion(book, request, nextQuestion, questionImage, answerImage);
+                    saveJSONFile(newQuestion, request, questionImage);
+                    ThreadPool.getInstance().addTask(new SyncSaveExerciseBookTask(kmtExerciseMapper, exerciseQuestionSearchService, book.getBookId()));
+                } else {
+                    //新增大题, 如果已存在当前大题号，则报错
+                    String bqi = kmtExerciseMapper.findBigQuestionIndexByBookCourseId(nextQuestion.getBookCourseId(), request.getBigQuestionIndex());
+                    if (StringUtil.isBlank(bqi)){
+                        KmtExerciseQuestion newQuestion = saveQuestion(book, request, nextQuestion, questionImage, answerImage);
+                        saveJSONFile(newQuestion, request, questionImage);
+                        ThreadPool.getInstance().addTask(new SyncSaveExerciseBookTask(kmtExerciseMapper, exerciseQuestionSearchService, book.getBookId()));
+                    } else {
+                        responseEntity.failure(ResponseConstant.CODE_000, "已存在大题号，请在大题号下直接添加小题");
+                    }
+                }
+            } else {
+                KmtExerciseQuestion kmtExerciseQuestion = kmtExerciseQuestionService.getById(request.getQuestionId());
+                if (!kmtExerciseQuestion.getBigQuestionIndex().equals(request.getBigQuestionIndex())){
+                    return responseEntity.failure(ResponseConstant.CODE_000, "大题号不能修改");
+                }
+                kmtExerciseMapper.updateQuestionEditData(request, questionImage, answerImage);
+                saveJSONFile(kmtExerciseQuestion, request, questionImage);
+            }
+            return responseEntity.success("成功");
+        } else {
+            return responseEntity.failure("没有操作权限");
+        }
+    }
+
+    /**
+     * 保存文件json和es
+     * @param kmtExerciseQuestion
+     * @param request
+     * @param questionImage
+     */
+    private void saveJSONFile (KmtExerciseQuestion kmtExerciseQuestion, AddExerciseQuestionRequest request, String questionImage){
+        String content = JSONFileUtil.readJSONFile(PropertiesUtil.getValue("EXERCISE_JSON_FILE_PATH") + kmtExerciseQuestion.getQuestionPath());
+        Map<String, Object> map = null;
+        if (StringUtil.isBlank(content)){
+            map = new HashMap<>();
+        } else {
+            map = JSON.parseObject(content, Map.class);
+        }
+        map.put("question", request.getQuestion());
+        map.put("question_text", request.getQuestionText());
+        map.put("question_json", Collections.singletonList(ExerciseUtil.getExerciseQuestionAnswerValue(questionImage)));
+        map.put("option_answer", request.getAnswer());
+        map.put("answer_json", request.getAnswerJson());
+        map.put("analysis", request.getQuestionAnalysis());
+        map.put("analysis_json", JSONArray.parse(request.getAnalysisJson()));
+        JSONFileUtil.saveJSONFile(PropertiesUtil.getValue("EXERCISE_JSON_FILE_PATH") + kmtExerciseQuestion.getQuestionPath(), JSON.toJSONString(map));
+    }
+
+    /**
+     * chax
+     * @param htmlStr
+     * @return
+     */
+    private String getImagePath (String htmlStr) {
+        String result = null;
+        List<String> list = new ArrayList<>();
+        String img = "";
+        Pattern p_image;
+        Matcher m_image;
+        // String regEx_img = "<img.*src=(.*?)[^>]*?>"; //图片链接地址
+        String regEx_img = "<img.*src\\s*=\\s*(.*?)[^>]*?>";
+        p_image = Pattern.compile(regEx_img, Pattern.CASE_INSENSITIVE);
+        m_image = p_image.matcher(htmlStr);
+        while (m_image.find()) {
+            // 得到<img />数据
+            img = m_image.group();
+            // 匹配<img>中的src数据
+            Matcher m = Pattern.compile("src\\s*=\\s*[\"|\']?(.*?)([\"|\']|>|\\s+)").matcher(img);
+            while (m.find()) {
+                list.add(m.group(1));
+            }
+        }
+        if (list.size() > 0){
+            result = list.get(0).replace(PropertiesUtil.getValue("STATIC_FILE_URL"), "");
+        }
+        return result;
+    }
+
+    private KmtExerciseQuestion saveQuestion(KmtExerciseBook book,AddExerciseQuestionRequest request, KmtExerciseQuestion nextQuestion, String questionImage, String answerImage){
+        kmtExerciseMapper.updateQuestionNumByBookIdAndNum(book.getBookId(), request.getNum());
+        KmtExerciseQuestion kmtExerciseQuestion = new KmtExerciseQuestion();
+        String newQuestionId = IdWorker.generateId();
+        kmtExerciseQuestion.setId(newQuestionId);
+        kmtExerciseQuestion.setBookId(nextQuestion.getBookId());
+        kmtExerciseQuestion.setUnitId(nextQuestion.getUnitId());
+        kmtExerciseQuestion.setBookCourseId(nextQuestion.getBookCourseId());
+        if (request.getQuestionClassType() == 2){
+            kmtExerciseQuestion.setBigQuestionIndex(nextQuestion.getBigQuestionIndex());
+            if (StringUtil.isBlank(nextQuestion.getParentId())){
+                kmtExerciseQuestion.setParentId(null);
+                kmtExerciseQuestion.setQuestionClassType(1);
+            } else {
+                kmtExerciseQuestion.setParentId(nextQuestion.getParentId());
+                kmtExerciseQuestion.setQuestionClassType(2);
+            }
+        } else {
+            kmtExerciseQuestion.setBigQuestionIndex(request.getBigQuestionIndex());
+            kmtExerciseQuestion.setParentId(null);
+            kmtExerciseQuestion.setQuestionClassType(0);
+        }
+        kmtExerciseQuestion.setPageIndex(nextQuestion.getPageIndex());
+        kmtExerciseQuestion.setImage(questionImage);
+        kmtExerciseQuestion.setCreateTime(new Date());
+        kmtExerciseQuestion.setDealStatus(3);
+        kmtExerciseQuestion.setAnswerImage(answerImage);
+        kmtExerciseQuestion.setNum(nextQuestion.getNum());
+        kmtExerciseQuestion.setSmallQuestionName(request.getSmallQuestionIndex());
+        kmtExerciseQuestion.setCourseName(nextQuestion.getCourseName());
+        kmtExerciseQuestion.setIsCommonFlag(nextQuestion.getIsCommonFlag());
+        kmtExerciseQuestion.setExerciseBookId(nextQuestion.getExerciseBookId());
+        kmtExerciseQuestion.setHandlerSubmitTime(DateUtil.parse_yyyyMMddHHmmss("1970-01-01 00:00:01"));
+        kmtExerciseQuestion.setQuestionPath(nextQuestion.getQuestionPath().substring(0, nextQuestion.getQuestionPath().lastIndexOf("/")) + "/" + newQuestionId + ".json");
+        logger.error(JSON.toJSONString(kmtExerciseQuestion));
+        kmtExerciseQuestion = kmtExerciseQuestionService.save(kmtExerciseQuestion);
+        if (request.getQuestionClassType() == 2 && StringUtil.isBlank(nextQuestion.getParentId())) {
+            kmtExerciseMapper.updateParentIdAndClassType(kmtExerciseQuestion.getId(), 2, book.getBookId(), request.getNum());
+        }
+        return kmtExerciseQuestion;
+    }
+
+
+
+    @Override
+    public ResponseEntity deleteExerciseQuestion(String userId, ExerciseQuestionDealRequest request) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        if (isManagerSubmit(userId)){
+            if (request.getQuestionClassType() == 2){
+                this.deleteOneQuestions(request.getQuestionId());
+            } else {
+                this.deleteOneBigQuestions(request.getQuestionId());
+            }
+            return responseEntity.success("成功");
+        } else {
+            return responseEntity.failure("没有操作权限");
+        }
+    }
+
+    /**
+     * 删除小题
+     * @param questionId
+     */
+    private void deleteOneQuestions(String questionId){
+        KmtExerciseQuestion kmtExerciseQuestion = kmtExerciseQuestionService.getById(questionId);
+        if  (kmtExerciseQuestion != null){
+            //如果删除的是大题，找到第二个题，把它设置为大题
+            if (kmtExerciseQuestion.getQuestionClassType() == 1){
+                List<String> questionIds = kmtExerciseMapper.findQuestionIdByParentId(questionId);
+                int questionClassType = 0;
+                if (questionIds.size() > 2) {
+                    //删除后不只一个小题
+                    questionClassType = 1;
+                }
+
+                //更新兄弟题目字段
+                if (questionIds.size() > 1){
+                    String parentId = questionIds.get(1);
+                    kmtExerciseMapper.updateKmtExerciseQuestionClassTypeAndParentId(null, questionClassType, parentId);
+                    for (int i = 2; i < questionIds.size(); i++){
+                        kmtExerciseMapper.updateKmtExerciseQuestionClassTypeAndParentId(parentId, 2, questionIds.get(i));
+                    }
+                    ThreadPool.getInstance().addTask(new SyncSaveExerciseQuestionsTask(kmtExerciseMapper,
+                            exerciseQuestionSearchService, questionIds.subList(1, questionIds.size())));
+                }
+
+            }
+            logger.info("删除={}", JSON.toJSONString(kmtExerciseQuestion));
+            kmtExerciseQuestionService.delete(questionId);
+
+            //删除es
+            exerciseQuestionSearchService.delete(questionId);
+            QueryBuilder queryBuilder = QueryBuilders.termQuery("question_id.keyword", questionId);
+            exerciseQuestionSearchService.deleteByQuery("kmt_exercise_question_know", queryBuilder);
+        }
+    }
+
+    /**
+     * 删除大题
+     * @param questionId
+     */
+    private void deleteOneBigQuestions(String questionId){
+        List<String> questionIds = kmtExerciseMapper.findQuestionIdByParentId(questionId);
+        if (CollectionUtils.isNotEmpty(questionIds)){
+            for (String qid : questionIds) {
+                kmtExerciseQuestionService.delete(qid);
+            }
+            //删除es
+            QueryBuilder queryBuilder = QueryBuilders.termsQuery("id.keyword", questionIds);
+            exerciseQuestionSearchService.deleteByQuery("kmt_exercise_questions", queryBuilder);
+            queryBuilder = QueryBuilders.termsQuery("question_id.keyword", questionIds);
+            exerciseQuestionSearchService.deleteByQuery("kmt_exercise_question_know", queryBuilder);
+        }
+    }
+
+
+    @Override
+    public ResponseEntity moveExerciseQuestion(String userId, ExerciseQuestionDealRequest request) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        if (isManagerSubmit(userId)){
+            KmtExerciseQuestion kmtExerciseQuestion  = kmtExerciseQuestionService.getById(request.getQuestionId());
+            if (request.getQuestionClassType() == 2){
+                //如果一个小题不能移动
+                if(kmtExerciseQuestion.getQuestionClassType() == 0) {
+                    return responseEntity.failure(ResponseConstant.CODE_000, "单题不能移动小题，请使用移动大题功能");
+                }
+                //移动小题
+                if (request.getType() == 1){
+                    //上移
+                    kmtExerciseMapper.updateByBookIdAndNum(kmtExerciseQuestion.getBookId(), kmtExerciseQuestion.getNum(),kmtExerciseQuestion.getNum() - 1);
+                    kmtExerciseMapper.updateQuestionNumByQuestionId(kmtExerciseQuestion.getId(), kmtExerciseQuestion.getNum() - 1);
+                } else if (request.getType() == 2){
+                    kmtExerciseMapper.updateByBookIdAndNum(kmtExerciseQuestion.getBookId(), kmtExerciseQuestion.getNum(), kmtExerciseQuestion.getNum() + 1);
+                    kmtExerciseMapper.updateQuestionNumByQuestionId(kmtExerciseQuestion.getId(), kmtExerciseQuestion.getNum() + 1);
+                }
+            } else  if (request.getQuestionClassType() == 1){
+                if (request.getType() == 1){
+                    //大题上移, 先查找上一题的题目id列表
+                    KmtExerciseQuestion previousQuestion = kmtExerciseMapper.findByBookIdAndNum(kmtExerciseQuestion.getBookId(), kmtExerciseQuestion.getNum() - 1);
+                    if (previousQuestion ==null ||  !previousQuestion.getBookCourseId().equals(kmtExerciseQuestion.getBookCourseId())){
+                        return responseEntity.failure(ResponseConstant.CODE_000, "已移动到第一题位置");
+                    }
+
+                    List<KmtExerciseQuestion> previousQuestions = kmtExerciseMapper.findQuestionsByBookCourseIdAndBigIndex(previousQuestion.getBookCourseId(), previousQuestion.getBigQuestionIndex());
+                    List<KmtExerciseQuestion> thisQuestions = kmtExerciseMapper.findQuestionsByBookCourseIdAndBigIndex(kmtExerciseQuestion.getBookCourseId(), kmtExerciseQuestion.getBigQuestionIndex());
+                    if (previousQuestions != null && thisQuestions != null){
+                        int preSize = previousQuestions.size();
+                        int thisSize = thisQuestions.size();
+                        List<String> previousIds = previousQuestions.stream().map(KmtExerciseQuestion::getId).collect(Collectors.toList());
+                        List<String> thisIds = thisQuestions.stream().map(KmtExerciseQuestion::getId).collect(Collectors.toList());
+                        kmtExerciseMapper.updateQuestionMinusNumByQuestionIds(thisIds, preSize);
+                        kmtExerciseMapper.updateQuestionAddNumByQuestionIds(previousIds, thisSize);
+                    }
+                } else if (request.getType() == 2){
+                    List<KmtExerciseQuestion> thisQuestions = kmtExerciseMapper.findQuestionsByBookCourseIdAndBigIndex(kmtExerciseQuestion.getBookCourseId(), kmtExerciseQuestion.getBigQuestionIndex());
+                    int thisSize = thisQuestions.size();
+                    KmtExerciseQuestion nextQuestion = kmtExerciseMapper.findByBookIdAndNum(kmtExerciseQuestion.getBookId(), kmtExerciseQuestion.getNum() + thisSize);
+                    if (nextQuestion == null || !nextQuestion.getBookCourseId().equals(kmtExerciseQuestion.getBookCourseId())){
+                        return responseEntity.failure(ResponseConstant.CODE_000, "已移动到最后一题位置");
+                    }
+                    List<KmtExerciseQuestion> nextQuestions = kmtExerciseMapper.findQuestionsByBookCourseIdAndBigIndex(nextQuestion.getBookCourseId(), nextQuestion.getBigQuestionIndex());
+                    if (nextQuestions != null && thisQuestions != null){
+                        int nextSize = nextQuestions.size();
+                        List<String> nextIds = nextQuestions.stream().map(KmtExerciseQuestion::getId).collect(Collectors.toList());
+                        List<String> thisIds = thisQuestions.stream().map(KmtExerciseQuestion::getId).collect(Collectors.toList());
+                        kmtExerciseMapper.updateQuestionMinusNumByQuestionIds(nextIds, thisSize);
+                        kmtExerciseMapper.updateQuestionAddNumByQuestionIds(thisIds, nextSize);
+                    }
+                }
+            }
+            ThreadPool.getInstance().addTask(new SyncSaveExerciseBookCourseTask(kmtExerciseMapper, exerciseQuestionSearchService, kmtExerciseQuestion.getBookCourseId()));
+            return responseEntity.success("成功");
+        } else {
+            return responseEntity.failure("没有操作权限");
+        }
+    }
+
+    /**
+     * 是否是管理员提交
+     * @param userId
+     * @return
+     */
+    private boolean isManagerSubmit (String userId){
+        TbLibManager manager = bookManagerDao.findByUserIdAndType(userId, 18);
+        if (manager != null) {
+            //管理员把状态设置为3，不改任何状态
+            return true;
+        }
+        return false;
+    }
+
+}

ssj-kmt-exercise-service-impl/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtExerciseServiceImpl.java

@@ -1693,9 +1693,9 @@ public class KmtExerciseServiceImpl implements KmtExerciseService {
             //读取大字段文件
             if (StringUtil.isNotBlank(kmtExerciseQuestion.getQuestionPath())){
                 String path = PropertiesUtil.getValue("EXERCISE_JSON_FILE_PATH") + kmtExerciseQuestion.getQuestionPath();
-                logger.debug("文件路径:{}", path);
+                logger.error("文件路径:{}", path);
                 String content = JSONFileUtil.readJSONFile(path);
-                logger.debug("文件内容：{}", content);
+                logger.error("文件内容：{}", content);
                 if (StringUtils.isNotBlank(content)){
                     JSONObject jsonObject = JSONObject.parseObject(content);
                     kmtExerciseQuestion.setQuestion(jsonObject.getString("question"));
@@ -1703,7 +1703,7 @@ public class KmtExerciseServiceImpl implements KmtExerciseService {
                     kmtExerciseQuestion.setAnswer(jsonObject.getString("option_answer"));
                     kmtExerciseQuestion.setAnswerJson(jsonObject.getString("answer_json"));
                     kmtExerciseQuestion.setQuestionAnalysis(jsonObject.getString("analysis"));
-                    kmtExerciseQuestion.setAnalysisJson(jsonObject.getString("analysis_json"));
+                    kmtExerciseQuestion.setAnalysisJson(jsonObject.getString("analysis_json"));;
                     kmtExerciseQuestion.setOriginAnswer(jsonObject.getString("question_answer"));
                 }
             }

ssj-kmt-exercise-service-impl/src/main/java/com/ssj/service/task/SyncSaveExerciseBookCourseTask.java

@@ -0,0 +1,116 @@
+package com.ssj.service.task;
+
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import com.alibaba.fastjson.TypeReference;
+import com.ssj.bean.kmt.kmt.domain.KmtExerciseQuestion;
+import com.ssj.bean.sys.homework.domain.HomeworkPicture;
+import com.ssj.es.entiy.ElasticEntity;
+import com.ssj.es.service.ExerciseQuestionSearchService;
+import com.ssj.framework.core.util.PropertiesUtil;
+import com.ssj.framework.core.util.StringUtil;
+import com.ssj.kmt.utils.JSONFileUtil;
+import com.ssj.service.mapper.KmtExerciseMapper;
+import com.ssj.service.sys.homework.request.CorrectionRequest;
+import com.ssj.taskthread.Task;
+import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.elasticsearch.action.bulk.BulkRequest;
+import org.elasticsearch.action.update.UpdateRequest;
+import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+
+public class SyncSaveExerciseBookCourseTask extends Task {
+
+    private String bookCourseId = null;
+
+    private KmtExerciseMapper kmtExerciseMapper;
+
+    private ExerciseQuestionSearchService exerciseQuestionSearchService;
+
+    public SyncSaveExerciseBookCourseTask(KmtExerciseMapper kmtExerciseMapper, ExerciseQuestionSearchService exerciseQuestionSearchService,  String bookCourseId) {
+        this.bookCourseId = bookCourseId;
+        this.kmtExerciseMapper = kmtExerciseMapper;
+        this.exerciseQuestionSearchService = exerciseQuestionSearchService;
+    }
+
+    @Override
+    public void run() {
+        try {
+            Thread.sleep(2000);
+            List<KmtExerciseQuestion> kmtExerciseQuestions = kmtExerciseMapper.findByBookCourseId(this.bookCourseId);
+            this.appendQuestionDataFromJSONFile(kmtExerciseQuestions);
+            for (KmtExerciseQuestion kmtExerciseQuestion : kmtExerciseQuestions){
+                exerciseQuestionSearchService.save(JSON.parseObject(JSON.toJSONString(kmtExerciseQuestion), new TypeReference<Map<String, Object>>() {}));
+            }
+            List<String> questionIds = kmtExerciseQuestions.stream().map(KmtExerciseQuestion::getId).collect(Collectors.toList());
+            List<Map<String, Object>> knowEsData = kmtExerciseMapper.findData2EsByQuestionList(questionIds);
+            if (CollectionUtils.isNotEmpty(knowEsData)) {
+                this.appendQuestionMapFromJSONFile(knowEsData);
+
+                List<ElasticEntity> elasticEntityList = new ArrayList<>(knowEsData.size());
+                ElasticEntity elasticEntity;
+                String id = null;
+                for (Map<String, Object> kes : knowEsData) {
+                    id = kes.getOrDefault("id", "").toString();
+                    if (StringUtils.isBlank(id)){
+                        continue;
+                    }
+                    elasticEntity = new ElasticEntity();
+                    elasticEntity.setId(id);
+                    elasticEntity.setData(JSON.parseObject(JSON.toJSONString(kes), new TypeReference<Map<String, Object>>() {}));
+                    elasticEntityList.add(elasticEntity);
+                }
+                exerciseQuestionSearchService.insertOrUpdateBatch("kmt_exercise_question_know", elasticEntityList);
+            }
+        } catch (Exception e){
+            logger.error("异步保存es异常", e);
+        }
+    }
+
+    private void appendQuestionDataFromJSONFile(List<KmtExerciseQuestion> kmtExerciseQuestions) {
+        for (KmtExerciseQuestion kmtExerciseQuestion : kmtExerciseQuestions){
+            //读取大字段文件
+            if (StringUtil.isNotBlank(kmtExerciseQuestion.getQuestionPath())){
+                String content = JSONFileUtil.readJSONFile(PropertiesUtil.getValue("EXERCISE_JSON_FILE_PATH") + kmtExerciseQuestion.getQuestionPath());
+                if (StringUtils.isNotBlank(content)){
+                    JSONObject jsonObject = JSONObject.parseObject(content);
+                    kmtExerciseQuestion.setQuestion(jsonObject.getString("question"));
+                    kmtExerciseQuestion.setQuestionText(jsonObject.getString("question_text"));
+                    kmtExerciseQuestion.setQuestionJson(jsonObject.getString("question_json"));
+                    kmtExerciseQuestion.setOptionAnswer(jsonObject.getString("option_answer"));
+                    kmtExerciseQuestion.setOptionAnswerText(jsonObject.getString("option_answer_text"));
+                    kmtExerciseQuestion.setAnswerJson(jsonObject.getString("answer_json"));
+                    kmtExerciseQuestion.setAnalysis(jsonObject.getString("analysis"));
+                    kmtExerciseQuestion.setAnalysisJson(jsonObject.getString("analysis_json"));
+                }
+            }
+        }
+    }
+    private void appendQuestionMapFromJSONFile(List<Map<String, Object>> questions) {
+        for (Map<String, Object> map : questions){
+            //读取大字段文件
+            if (StringUtil.isNotBlank(map.get("question_path") + "")){
+                String content = JSONFileUtil.readJSONFile(PropertiesUtil.getValue("EXERCISE_JSON_FILE_PATH") + map.get("question_path"));
+                if (StringUtils.isNotBlank(content)){
+                    JSONObject jsonObject = JSONObject.parseObject(content);
+                    map.put("question",jsonObject.getString("question"));
+                    map.put("question_text",jsonObject.getString("question_text"));
+                    map.put("question_json",jsonObject.getString("question_json"));
+                    map.put("option_answer",jsonObject.getString("option_answer"));
+                    map.put("option_answer_text",jsonObject.getString("option_answer_text"));
+                    map.put("answer_json",jsonObject.getString("answer_json"));
+                    map.put("analysis",jsonObject.getString("analysis"));
+                    map.put("analysis_json",jsonObject.getString("analysis_json"));
+                }
+            }
+        }
+    }
+}

ssj-kmt-exercise-service-impl/src/main/java/com/ssj/service/task/SyncSaveExerciseBookTask.java

@@ -0,0 +1,117 @@
+package com.ssj.service.task;
+
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import com.alibaba.fastjson.TypeReference;
+import com.ssj.bean.kmt.kmt.domain.KmtExerciseQuestion;
+import com.ssj.bean.sys.homework.domain.HomeworkPicture;
+import com.ssj.es.entiy.ElasticEntity;
+import com.ssj.es.service.ExerciseQuestionSearchService;
+import com.ssj.framework.core.util.PropertiesUtil;
+import com.ssj.framework.core.util.StringUtil;
+import com.ssj.kmt.utils.JSONFileUtil;
+import com.ssj.service.mapper.KmtExerciseMapper;
+import com.ssj.service.sys.homework.request.CorrectionRequest;
+import com.ssj.taskthread.Task;
+import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.elasticsearch.action.bulk.BulkRequest;
+import org.elasticsearch.action.update.UpdateRequest;
+import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+
+public class SyncSaveExerciseBookTask extends Task {
+
+    private String bookId = null;
+
+    private KmtExerciseMapper kmtExerciseMapper;
+
+    private ExerciseQuestionSearchService exerciseQuestionSearchService;
+
+    public SyncSaveExerciseBookTask(KmtExerciseMapper kmtExerciseMapper, ExerciseQuestionSearchService exerciseQuestionSearchService,  String bookId) {
+        this.bookId = bookId;
+        this.kmtExerciseMapper = kmtExerciseMapper;
+        this.exerciseQuestionSearchService = exerciseQuestionSearchService;
+    }
+
+    @Override
+    public void run() {
+        try {
+            Thread.sleep(2000);
+            List<KmtExerciseQuestion> kmtExerciseQuestions = kmtExerciseMapper.findByBookId(this.bookId);
+            this.appendQuestionDataFromJSONFile(kmtExerciseQuestions);
+            for (KmtExerciseQuestion kmtExerciseQuestion : kmtExerciseQuestions){
+                exerciseQuestionSearchService.save(JSON.parseObject(JSON.toJSONString(kmtExerciseQuestion), new TypeReference<Map<String, Object>>() {}));
+            }
+            List<String> questionIds = kmtExerciseQuestions.stream().map(KmtExerciseQuestion::getId).collect(Collectors.toList());
+            List<Map<String, Object>> knowEsData = kmtExerciseMapper.findData2EsByQuestionList(questionIds);
+            if (CollectionUtils.isNotEmpty(knowEsData)) {
+                this.appendQuestionMapFromJSONFile(knowEsData);
+
+                List<ElasticEntity> elasticEntityList = new ArrayList<>(knowEsData.size());
+                ElasticEntity elasticEntity;
+                String id = null;
+                for (Map<String, Object> kes : knowEsData) {
+                    id = kes.getOrDefault("id", "").toString();
+                    if (StringUtils.isBlank(id)){
+                        continue;
+                    }
+                    elasticEntity = new ElasticEntity();
+                    elasticEntity.setId(id);
+                    elasticEntity.setData(JSON.parseObject(JSON.toJSONString(kes), new TypeReference<Map<String, Object>>() {}));
+                    elasticEntityList.add(elasticEntity);
+                }
+                exerciseQuestionSearchService.insertOrUpdateBatch("kmt_exercise_question_know", elasticEntityList);
+            }
+        } catch (Exception e){
+            logger.error("异步保存es异常", e);
+        }
+    }
+
+    private void appendQuestionDataFromJSONFile(List<KmtExerciseQuestion> kmtExerciseQuestions) {
+        for (KmtExerciseQuestion kmtExerciseQuestion : kmtExerciseQuestions){
+            //读取大字段文件
+            if (StringUtil.isNotBlank(kmtExerciseQuestion.getQuestionPath())){
+                String content = JSONFileUtil.readJSONFile(PropertiesUtil.getValue("EXERCISE_JSON_FILE_PATH") + kmtExerciseQuestion.getQuestionPath());
+                if (StringUtils.isNotBlank(content)){
+                    JSONObject jsonObject = JSONObject.parseObject(content);
+                    kmtExerciseQuestion.setQuestion(jsonObject.getString("question"));
+                    kmtExerciseQuestion.setQuestionText(jsonObject.getString("question_text"));
+                    kmtExerciseQuestion.setQuestionJson(jsonObject.getString("question_json"));
+                    kmtExerciseQuestion.setOptionAnswer(jsonObject.getString("option_answer"));
+                    kmtExerciseQuestion.setOptionAnswerText(jsonObject.getString("option_answer_text"));
+                    kmtExerciseQuestion.setAnswerJson(jsonObject.getString("answer_json"));
+                    kmtExerciseQuestion.setAnalysis(jsonObject.getString("analysis"));
+                    kmtExerciseQuestion.setAnalysisJson(jsonObject.getString("analysis_json"));
+                }
+            }
+        }
+    }
+    private void appendQuestionMapFromJSONFile(List<Map<String, Object>> questions) {
+        for (Map<String, Object> map : questions){
+            //读取大字段文件
+            if (StringUtil.isNotBlank(map.get("question_path") + "")){
+                String content = JSONFileUtil.readJSONFile(PropertiesUtil.getValue("EXERCISE_JSON_FILE_PATH") + map.get("question_path"));
+                if (StringUtils.isNotBlank(content)){
+                    JSONObject jsonObject = JSONObject.parseObject(content);
+                    map.put("question",jsonObject.getString("question"));
+                    map.put("question_text",jsonObject.getString("question_text"));
+                    map.put("question_json",jsonObject.getString("question_json"));
+                    map.put("option_answer",jsonObject.getString("option_answer"));
+                    map.put("option_answer_text",jsonObject.getString("option_answer_text"));
+                    map.put("answer_json",jsonObject.getString("answer_json"));
+                    map.put("analysis",jsonObject.getString("analysis"));
+                    map.put("analysis_json",jsonObject.getString("analysis_json"));
+                }
+            }
+        }
+    }
+}
+

ssj-kmt-exercise-service-impl/src/main/java/com/ssj/service/task/SyncSaveExerciseQuestionsTask.java

@@ -0,0 +1,115 @@
+package com.ssj.service.task;
+
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import com.alibaba.fastjson.TypeReference;
+import com.ssj.bean.kmt.kmt.domain.KmtExerciseQuestion;
+import com.ssj.bean.sys.homework.domain.HomeworkPicture;
+import com.ssj.es.entiy.ElasticEntity;
+import com.ssj.es.service.ExerciseQuestionSearchService;
+import com.ssj.framework.core.util.PropertiesUtil;
+import com.ssj.framework.core.util.StringUtil;
+import com.ssj.kmt.utils.JSONFileUtil;
+import com.ssj.service.mapper.KmtExerciseMapper;
+import com.ssj.service.sys.homework.request.CorrectionRequest;
+import com.ssj.taskthread.Task;
+import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.elasticsearch.action.bulk.BulkRequest;
+import org.elasticsearch.action.update.UpdateRequest;
+import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+
+public class SyncSaveExerciseQuestionsTask extends Task {
+
+    private List<String> questionIds = null;
+
+    private KmtExerciseMapper kmtExerciseMapper;
+
+    private ExerciseQuestionSearchService exerciseQuestionSearchService;
+
+    public SyncSaveExerciseQuestionsTask(KmtExerciseMapper kmtExerciseMapper, ExerciseQuestionSearchService exerciseQuestionSearchService,  List<String> questionIds) {
+        this.questionIds = questionIds;
+        this.kmtExerciseMapper = kmtExerciseMapper;
+        this.exerciseQuestionSearchService = exerciseQuestionSearchService;
+    }
+
+    @Override
+    public void run() {
+        try {
+            Thread.sleep(2000);
+            List<KmtExerciseQuestion> kmtExerciseQuestions = kmtExerciseMapper.findExerciseQuestionByIds(this.questionIds);
+            this.appendQuestionDataFromJSONFile(kmtExerciseQuestions);
+            for (KmtExerciseQuestion kmtExerciseQuestion : kmtExerciseQuestions){
+                exerciseQuestionSearchService.save(JSON.parseObject(JSON.toJSONString(kmtExerciseQuestion), new TypeReference<Map<String, Object>>() {}));
+            }
+
+            List<Map<String, Object>> knowEsData = kmtExerciseMapper.findData2EsByQuestionList(questionIds);
+            if (CollectionUtils.isNotEmpty(knowEsData)) {
+                this.appendQuestionMapFromJSONFile(knowEsData);
+
+                List<ElasticEntity> elasticEntityList = new ArrayList<>(knowEsData.size());
+                ElasticEntity elasticEntity;
+                String id = null;
+                for (Map<String, Object> kes : knowEsData) {
+                    id = kes.getOrDefault("id", "").toString();
+                    if (StringUtils.isBlank(id)){
+                        continue;
+                    }
+                    elasticEntity = new ElasticEntity();
+                    elasticEntity.setId(id);
+                    elasticEntity.setData(JSON.parseObject(JSON.toJSONString(kes), new TypeReference<Map<String, Object>>() {}));
+                    elasticEntityList.add(elasticEntity);
+                }
+                exerciseQuestionSearchService.insertOrUpdateBatch("kmt_exercise_question_know", elasticEntityList);
+            }
+        } catch (Exception e){
+            logger.error("异步保存es异常", e);
+        }
+    }
+
+    private void appendQuestionDataFromJSONFile(List<KmtExerciseQuestion> kmtExerciseQuestions) {
+        for (KmtExerciseQuestion kmtExerciseQuestion : kmtExerciseQuestions){
+            //读取大字段文件
+            if (StringUtil.isNotBlank(kmtExerciseQuestion.getQuestionPath())){
+                String content = JSONFileUtil.readJSONFile(PropertiesUtil.getValue("EXERCISE_JSON_FILE_PATH") + kmtExerciseQuestion.getQuestionPath());
+                if (StringUtils.isNotBlank(content)){
+                    JSONObject jsonObject = JSONObject.parseObject(content);
+                    kmtExerciseQuestion.setQuestion(jsonObject.getString("question"));
+                    kmtExerciseQuestion.setQuestionText(jsonObject.getString("question_text"));
+                    kmtExerciseQuestion.setQuestionJson(jsonObject.getString("question_json"));
+                    kmtExerciseQuestion.setOptionAnswer(jsonObject.getString("option_answer"));
+                    kmtExerciseQuestion.setOptionAnswerText(jsonObject.getString("option_answer_text"));
+                    kmtExerciseQuestion.setAnswerJson(jsonObject.getString("answer_json"));
+                    kmtExerciseQuestion.setAnalysis(jsonObject.getString("analysis"));
+                    kmtExerciseQuestion.setAnalysisJson(jsonObject.getString("analysis_json"));
+                }
+            }
+        }
+    }
+    private void appendQuestionMapFromJSONFile(List<Map<String, Object>> questions) {
+        for (Map<String, Object> map : questions){
+            //读取大字段文件
+            if (StringUtil.isNotBlank(map.get("question_path") + "")){
+                String content = JSONFileUtil.readJSONFile(PropertiesUtil.getValue("EXERCISE_JSON_FILE_PATH") + map.get("question_path"));
+                if (StringUtils.isNotBlank(content)){
+                    JSONObject jsonObject = JSONObject.parseObject(content);
+                    map.put("question",jsonObject.getString("question"));
+                    map.put("question_text",jsonObject.getString("question_text"));
+                    map.put("question_json",jsonObject.getString("question_json"));
+                    map.put("option_answer",jsonObject.getString("option_answer"));
+                    map.put("option_answer_text",jsonObject.getString("option_answer_text"));
+                    map.put("answer_json",jsonObject.getString("answer_json"));
+                    map.put("analysis",jsonObject.getString("analysis"));
+                    map.put("analysis_json",jsonObject.getString("analysis_json"));
+                }
+            }
+        }
+    }
+}

ssj-kmt-exercise-service/src/main/java/com/ssj/service/kmt/request/rollbackai/AddExerciseQuestionRequest.java

@@ -0,0 +1,142 @@
+package com.ssj.service.kmt.request.rollbackai;
+
+import io.swagger.annotations.ApiModelProperty;
+
+import java.io.Serializable;
+
+public class AddExerciseQuestionRequest implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @ApiModelProperty(name = "questionClassType", value = "大小题类型，1 大题，2小题", required = true)
+    private int  questionClassType;
+
+    @ApiModelProperty(name = "exerciseBookId", value = "练习册id", required = true)
+    private String  exerciseBookId;
+
+    @ApiModelProperty(name = "questionId", value = "题目id, 存在为修改", required = false)
+    private String  questionId;
+
+    @ApiModelProperty(name = "bigQuestionIndex", value = "大题号", required = true)
+    private String  bigQuestionIndex;
+
+    @ApiModelProperty(name = "smallQuestionIndex", value = "小题号", required = true)
+    private String  smallQuestionIndex;
+
+    @ApiModelProperty(name = "question", value = "原题目", required = true)
+    private String  question;
+
+    @ApiModelProperty(name = "questionText", value = "题目，题目文本", required = true)
+    private String  questionText;
+
+    @ApiModelProperty(name = "answer", value = "原答案", required = true)
+    private String  answer;
+
+    @ApiModelProperty(name = "answerJson", value = "答案json", required = true)
+    private String  answerJson;
+
+    @ApiModelProperty(name = "questionAnalysis", value = "原解析", required = true)
+    private String  questionAnalysis;
+
+    @ApiModelProperty(name = "analysisJson", value = "解析json", required = true)
+    private String  analysisJson;
+
+    @ApiModelProperty(name = "num", value = "当前题的num, 题目插入到前一题", required = false)
+    private int  num;
+
+    public int getQuestionClassType() {
+        return questionClassType;
+    }
+
+    public void setQuestionClassType(int questionClassType) {
+        this.questionClassType = questionClassType;
+    }
+
+    public String getExerciseBookId() {
+        return exerciseBookId;
+    }
+
+    public void setExerciseBookId(String exerciseBookId) {
+        this.exerciseBookId = exerciseBookId;
+    }
+
+    public String getQuestionId() {
+        return questionId;
+    }
+
+    public void setQuestionId(String questionId) {
+        this.questionId = questionId;
+    }
+
+    public String getBigQuestionIndex() {
+        return bigQuestionIndex;
+    }
+
+    public void setBigQuestionIndex(String bigQuestionIndex) {
+        this.bigQuestionIndex = bigQuestionIndex;
+    }
+
+    public String getSmallQuestionIndex() {
+        return smallQuestionIndex;
+    }
+
+    public void setSmallQuestionIndex(String smallQuestionIndex) {
+        this.smallQuestionIndex = smallQuestionIndex;
+    }
+
+    public String getQuestion() {
+        return question;
+    }
+
+    public void setQuestion(String question) {
+        this.question = question;
+    }
+
+    public String getQuestionText() {
+        return questionText;
+    }
+
+    public void setQuestionText(String questionText) {
+        this.questionText = questionText;
+    }
+
+    public String getAnswer() {
+        return answer;
+    }
+
+    public void setAnswer(String answer) {
+        this.answer = answer;
+    }
+
+    public String getAnswerJson() {
+        return answerJson;
+    }
+
+    public void setAnswerJson(String answerJson) {
+        this.answerJson = answerJson;
+    }
+
+    public String getQuestionAnalysis() {
+        return questionAnalysis;
+    }
+
+    public void setQuestionAnalysis(String questionAnalysis) {
+        this.questionAnalysis = questionAnalysis;
+    }
+
+    public String getAnalysisJson() {
+        return analysisJson;
+    }
+
+    public void setAnalysisJson(String analysisJson) {
+        this.analysisJson = analysisJson;
+    }
+
+    public int getNum() {
+        return num;
+    }
+
+    public void setNum(int num) {
+        this.num = num;
+    }
+}

ssj-kmt-exercise-service/src/main/java/com/ssj/service/kmt/request/rollbackai/ExerciseQuestionDealRequest.java

@@ -0,0 +1,45 @@
+package com.ssj.service.kmt.request.rollbackai;
+
+import io.swagger.annotations.ApiModelProperty;
+import org.hibernate.validator.constraints.NotBlank;
+
+import java.io.Serializable;
+
+public class ExerciseQuestionDealRequest implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @ApiModelProperty(name = "type", value = "1上移, 2下移", required = false)
+    private int  type;
+
+    @ApiModelProperty(name = "questionClassType", value = "1移动大题，2移动小题", required = true)
+    private int  questionClassType;
+
+    @NotBlank
+    @ApiModelProperty(name = "questionId", value = "题目id", required = true)
+    private String  questionId;
+
+    public int getType() {
+        return type;
+    }
+
+    public void setType(int type) {
+        this.type = type;
+    }
+
+    public int getQuestionClassType() {
+        return questionClassType;
+    }
+
+    public void setQuestionClassType(int questionClassType) {
+        this.questionClassType = questionClassType;
+    }
+
+    public String getQuestionId() {
+        return questionId;
+    }
+
+    public void setQuestionId(String questionId) {
+        this.questionId = questionId;
+    }
+}

ssj-kmt-exercise-service/src/main/java/com/ssj/service/kmt/service/KmtExerciseQuestionDealService.java

@@ -0,0 +1,31 @@
+package com.ssj.service.kmt.service;
+
+import com.ssj.framework.core.util.ResponseEntity;
+import com.ssj.service.kmt.request.rollbackai.AddExerciseQuestionRequest;
+import com.ssj.service.kmt.request.rollbackai.ExerciseQuestionDealRequest;
+
+public interface KmtExerciseQuestionDealService {
+
+
+
+    /**
+     * 新增编辑题目
+     * @param request
+     * @return
+     */
+    ResponseEntity addOrEditExerciseQuestion(String userId, AddExerciseQuestionRequest request);
+
+    /**
+     * 删除题目
+     * @param request
+     * @return
+     */
+    ResponseEntity deleteExerciseQuestion(String userId, ExerciseQuestionDealRequest request);
+
+    /**
+     * 移动题目
+     * @param request
+     * @return
+     */
+    ResponseEntity moveExerciseQuestion(String userId, ExerciseQuestionDealRequest request);
+}

ssj-kmt-exercise-service/src/main/java/com/ssj/service/kmt/service/KmtExerciseService.java

@@ -11,6 +11,10 @@ import com.ssj.service.kmt.dto.ExerciseQuetionDto;
 import com.ssj.service.kmt.dto.exercise.ExerciseQuestionRollbacks;
 import com.ssj.service.kmt.exercise.request.SubmitAnswerProofreadResultReq;
 import com.ssj.service.kmt.request.*;
+import com.ssj.service.kmt.request.rollbackai.AddExerciseQuestionRequest;
+import com.ssj.service.kmt.request.rollbackai.ExerciseQuestionDealRequest;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestParam;
 
 import java.util.List;
 import java.util.Map;

ssj-mybatis-service-impl/src/main/java/com/ssj/service/mapper/KmtExerciseMapper.java

@@ -20,6 +20,7 @@ import com.ssj.service.kmt.dto.exercise.KmtExerciseQuestionRollBackInfo;
 import com.ssj.service.kmt.exercisesys.dto.*;
 import com.ssj.service.kmt.exercisesys.request.*;
 import com.ssj.service.kmt.request.UnitAndPeriodListRequest;
+import com.ssj.service.kmt.request.rollbackai.AddExerciseQuestionRequest;
 import com.ssj.service.sys.homework.vo.HomeworkExerciseBookDto;
 import org.apache.ibatis.annotations.*;
 
@@ -1131,4 +1132,69 @@ public interface KmtExerciseMapper {
      * @return
      */
     List<ExerciseQuetionDto> findExerciseQuestionByQuestionId (@Param("questionId")String questionId, Page page);
+
+    /**
+     * 查询题目以及题目的小题
+     * @param questionId
+     * @return
+     */
+    @Select("select id, num from kmt_exercise_questions where id=#{questionId} or parent_id=#{questionId} order by num")
+    List<String> findQuestionIdByParentId (@Param("questionId")String questionId);
+
+    @Update("update kmt_exercise_questions set parent_id=#{parentId}, question_class_type=#{questionClassType}" +
+            " where id=#{id}")
+    int updateKmtExerciseQuestionClassTypeAndParentId (@Param("parentId")String parentId,
+                                                       @Param("questionClassType")int questionClassType,
+                                                       @Param("id")String id);
+
+    @Update("update kmt_exercise_questions set small_question_name=#{req.smallQuestionIndex}, image=#{questionImage}, " +
+            " answer_image=#{answerImage}, deal_status =3" +
+            " where id=#{req.questionId}")
+    int updateQuestionEditData (@Param("req") AddExerciseQuestionRequest req,
+                                @Param("questionImage") String questionImage,
+                                @Param("answerImage") String answerImage);
+
+    @Select("select * from kmt_exercise_questions where book_id=#{bookId} and num=#{num} limit 1")
+    KmtExerciseQuestion findByBookIdAndNum (@Param("bookId") String bookId,
+                                            @Param("num") int num);
+
+    @Update("update kmt_exercise_questions set num = num + 1 where book_id=#{bookId} and num >= #{num}")
+    int updateQuestionNumByBookIdAndNum (@Param("bookId") String bookId,
+                                         @Param("num") int num);
+
+    @Update("update kmt_exercise_questions set parent_id=#{parentId}, question_class_type=#{questionClassType} where book_id=#{bookId} and num = #{num}")
+    int updateParentIdAndClassType (@Param("parentId") String parentId,
+                                    @Param("questionClassType") int questionClassType,
+                                    @Param("bookId") String bookId,
+                                    @Param("num") int num);
+    @Select("select big_question_index from kmt_exercise_questions where book_course_id=#{bookCourseId} " +
+            " and big_question_index=#{bigQuestionIndex} ")
+    String findBigQuestionIndexByBookCourseId (@Param("bookCourseId") String bookCourseId,
+                                               @Param("bigQuestionIndex") String bigQuestionIndex);
+
+    @Select("select * from kmt_exercise_questions where book_course_id=#{bookCourseId} " +
+            " and big_question_index=#{bigQuestionIndex} ")
+    List<KmtExerciseQuestion> findQuestionsByBookCourseIdAndBigIndex (@Param("bookCourseId") String bookCourseId,
+                                               @Param("bigQuestionIndex") String bigQuestionIndex);
+
+    @Update("update kmt_exercise_questions set num = #{updateNum} where book_id=#{bookId} and num = #{num}")
+    int updateByBookIdAndNum (@Param("bookId") String bookId,
+                              @Param("updateNum") int updateNum,
+                              @Param("num") int num);
+
+    @Update("update kmt_exercise_questions set num = #{updateNum} where id=#{questionId}")
+    int updateQuestionNumByQuestionId (@Param("questionId") String questionId,
+                              @Param("updateNum") int updateNum);
+
+    int updateQuestionMinusNumByQuestionIds (@Param("questionIds") List<String> questionIds,
+                                       @Param("size") int size);
+
+    int updateQuestionAddNumByQuestionIds (@Param("questionIds") List<String> questionIds,
+                                             @Param("size") int size);
+
+    @Select("select * from kmt_exercise_questions where book_course_id=#{bookCourseId}")
+    List<KmtExerciseQuestion> findByBookCourseId (@Param("bookCourseId") String bookCourseId);
+
+    @Select("select * from kmt_exercise_questions where book_id=#{bookId} limit 2000")
+    List<KmtExerciseQuestion> findByBookId (@Param("bookId") String bookId);
 }

ssj-mybatis-service-impl/src/main/resources/mybatis/mapper/KmtExerciseMapper.xml

@@ -1999,4 +1999,18 @@
         from kmt_exercise_questions eq  left join kmt_exercise_book eb on eq.exercise_book_id=eb.id
         where eq.id=#{questionId}
     </select>
+
+    <update id="updateQuestionMinusNumByQuestionIds">
+        UPDATE kmt_exercise_questions set num= num - #{size} WHERE id in
+        <foreach collection="questionIds" item="id" index="index" open="(" close=")" separator=",">
+            #{id}
+        </foreach>
+    </update>
+
+    <update id="updateQuestionAddNumByQuestionIds">
+        UPDATE kmt_exercise_questions set num= num + #{size} WHERE id in
+        <foreach collection="questionIds" item="id" index="index" open="(" close=")" separator=",">
+            #{id}
+        </foreach>
+    </update>
 </mapper>

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtExerciseQuestionServiceImpl.java

@@ -944,7 +944,7 @@ public class KmtExerciseQuestionServiceImpl extends BaseServiceImpl<KmtExerciseQ
     }
 
     @Override
-    @Cacheable(value = "key", keyGenerator = "keyGenerator_ExerciseQuestion" , cacheManager="cacheManager")
+//    @Cacheable(value = "key", keyGenerator = "keyGenerator_ExerciseQuestion" , cacheManager="cacheManager")
     public List<ExerciseQuestionDto> findQuestionByBookIdAndPage(String bookId, String unitId, String bookCourseId,
                                                                  List<Integer> pageIndex, int bookYear) {
         //调用es前的方法，2020年2月19日16:58:53

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtExerciseServiceImpl.java

@@ -1693,9 +1693,9 @@ public class KmtExerciseServiceImpl implements KmtExerciseService {
             //读取大字段文件
             if (StringUtil.isNotBlank(kmtExerciseQuestion.getQuestionPath())){
                 String path = PropertiesUtil.getValue("EXERCISE_JSON_FILE_PATH") + kmtExerciseQuestion.getQuestionPath();
-                logger.debug("文件路径:{}", path);
+                logger.error("文件路径:{}", path);
                 String content = JSONFileUtil.readJSONFile(path);
-                logger.debug("文件内容：{}", content);
+                logger.error("文件内容：{}", content);
                 if (StringUtils.isNotBlank(content)){
                     JSONObject jsonObject = JSONObject.parseObject(content);
                     kmtExerciseQuestion.setQuestion(jsonObject.getString("question"));