package com.ycl.jxkg.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.github.pagehelper.PageHelper;
|
import com.github.pagehelper.PageInfo;
|
import com.ycl.jxkg.base.Result;
|
import com.ycl.jxkg.domain.ExamPaperAnswerInfo;
|
import com.ycl.jxkg.domain.entity.*;
|
import com.ycl.jxkg.domain.other.KeyValue;
|
import com.ycl.jxkg.domain.vo.admin.paper.ExamPaperAnswerPageRequestVO;
|
import com.ycl.jxkg.domain.vo.admin.paper.UserAnswerPageRequestVO;
|
import com.ycl.jxkg.domain.vo.student.exam.ExamPaperSubmitItemVO;
|
import com.ycl.jxkg.domain.vo.student.exam.ExamPaperSubmitVO;
|
import com.ycl.jxkg.domain.vo.student.exampaper.ExamPaperAnswerPageResponseVO;
|
import com.ycl.jxkg.domain.vo.student.exampaper.ExamPaperAnswerPageVO;
|
import com.ycl.jxkg.domain.vo.student.exampaper.UserAnswerPageResponseVO;
|
import com.ycl.jxkg.enums.ExamPaperTypeEnum;
|
import com.ycl.jxkg.enums.QuestionTypeEnum;
|
import com.ycl.jxkg.mapper.ExamPaperMapper;
|
import com.ycl.jxkg.mapper.ExamPaperScoreMapper;
|
import com.ycl.jxkg.mapper.QuestionMapper;
|
import com.ycl.jxkg.mapper.TaskExamCustomerAnswerMapper;
|
import com.ycl.jxkg.service.ExamPaperScoreDetailService;
|
import com.ycl.jxkg.service.ExamPaperScoreService;
|
import com.ycl.jxkg.service.TextContentService;
|
import com.ycl.jxkg.utils.DateTimeUtil;
|
import com.ycl.jxkg.utils.ExamUtil;
|
import com.ycl.jxkg.utils.JsonUtil;
|
import lombok.RequiredArgsConstructor;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.List;
|
import java.util.stream.Collectors;
|
|
@Service
|
@RequiredArgsConstructor
|
public class ExamPaperScoreServiceImpl extends ServiceImpl<ExamPaperScoreMapper, ExamPaperScore> implements ExamPaperScoreService {
|
|
private final ExamPaperScoreMapper examPaperScoreMapper;
|
private final ExamPaperMapper examPaperMapper;
|
private final TextContentService textContentService;
|
private final QuestionMapper questionMapper;
|
private final ExamPaperScoreDetailService examPaperScoreDetailService;
|
private final TaskExamCustomerAnswerMapper taskExamCustomerAnswerMapper;
|
|
|
@Override
|
public PageInfo<ExamPaperAnswerPageResponseVO> studentPage(ExamPaperAnswerPageVO requestVM) {
|
return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc").doSelectPageInfo(() ->
|
examPaperScoreMapper.studentPage(requestVM));
|
}
|
|
|
@Override
|
public ExamPaperAnswerInfo calculateExamPaperAnswer(ExamPaperSubmitVO examPaperSubmitVO, User user) {
|
ExamPaperAnswerInfo examPaperAnswerInfo = new ExamPaperAnswerInfo();
|
Date now = new Date();
|
ExamPaper examPaper = examPaperMapper.selectById(examPaperSubmitVO.getId());
|
ExamPaperTypeEnum paperTypeEnum = ExamPaperTypeEnum.fromCode(examPaper.getPaperType());
|
//任务试卷只能做一次
|
if (paperTypeEnum == ExamPaperTypeEnum.RandomOrder) {
|
ExamPaperScore examPaperScore = examPaperScoreMapper.getByPidUid(examPaperSubmitVO.getId(), user.getId());
|
if (null != examPaperScore)
|
return null;
|
}
|
//TODO:待完成
|
// String frameTextContent = textContentService.getById(examPaper.getFrameTextContentId()).getContent();
|
// List<ExamPaperTitleItemObject> examPaperTitleItemObjects = JsonUtil.toJsonListObject(frameTextContent, ExamPaperTitleItemObject.class);
|
// List<Integer> questionIds = examPaperTitleItemObjects.stream().flatMap(t -> t.getQuestionItems().stream().map(q -> q.getId())).collect(Collectors.toList());
|
// List<Question> questions = questionMapper.selectByIds(questionIds);
|
// //将题目结构的转化为题目答案
|
// List<ExamPaperQuestionCustomerAnswer> examPaperQuestionCustomerAnswers = examPaperTitleItemObjects.stream()
|
// .flatMap(t -> t.getQuestionItems().stream()
|
// .map(q -> {
|
// Question question = questions.stream().filter(tq -> tq.getId().equals(q.getId())).findFirst().get();
|
// ExamPaperSubmitItemVO customerQuestionAnswer = examPaperSubmitVO.getAnswerItems().stream()
|
// .filter(tq -> tq.getQuestionId().equals(q.getId()))
|
// .findFirst()
|
// .orElse(null);
|
// return ExamPaperQuestionCustomerAnswerFromVM(question, customerQuestionAnswer, examPaper, q.getItemOrder(), user, now);
|
// })
|
// ).collect(Collectors.toList());
|
//
|
// ExamPaperAnswer examPaperAnswer = ExamPaperAnswerFromVM(examPaperSubmitVO, examPaper, examPaperQuestionCustomerAnswers, user, now);
|
// examPaperAnswerInfo.setExamPaper(examPaper);
|
// examPaperAnswerInfo.setExamPaperAnswer(examPaperAnswer);
|
// examPaperAnswerInfo.setExamPaperQuestionCustomerAnswers(examPaperQuestionCustomerAnswers);
|
return examPaperAnswerInfo;
|
}
|
|
@Override
|
@Transactional
|
public String judge(ExamPaperSubmitVO examPaperSubmitVO) {
|
// ExamPaperScore examPaperScore = examPaperScoreMapper.selectById(examPaperSubmitVO.getId());
|
// List<ExamPaperSubmitItemVO> judgeItems = examPaperSubmitVO.getAnswerItems().stream().filter(d -> d.getDoRight() == null).collect(Collectors.toList());
|
// List<ExamPaperAnswerUpdate> examPaperAnswerUpdates = new ArrayList<>(judgeItems.size());
|
// Integer customerScore = examPaperScore.getUserScore();
|
// Integer questionCorrect = examPaperScore.getQuestionCorrect();
|
// for (ExamPaperSubmitItemVO d : judgeItems) {
|
// ExamPaperAnswerUpdate examPaperAnswerUpdate = new ExamPaperAnswerUpdate();
|
// examPaperAnswerUpdate.setId(d.getId());
|
// examPaperAnswerUpdate.setCustomerScore(ExamUtil.scoreFromVM(d.getScore()));
|
// boolean doRight = examPaperAnswerUpdate.getCustomerScore().equals(ExamUtil.scoreFromVM(d.getQuestionScore()));
|
// examPaperAnswerUpdate.setDoRight(doRight);
|
// examPaperAnswerUpdates.add(examPaperAnswerUpdate);
|
// customerScore += examPaperAnswerUpdate.getCustomerScore();
|
// if (examPaperAnswerUpdate.getDoRight()) {
|
// ++questionCorrect;
|
// }
|
// }
|
// examPaperScore.setUserScore(customerScore);
|
// examPaperScore.setQuestionCorrect(questionCorrect);
|
// examPaperScore.setStatus(ExamPaperAnswerStatusEnum.Complete.getCode());
|
// examPaperScoreMapper.updateById(examPaperScore);
|
// examPaperScoreDetailService.updateScore(examPaperAnswerUpdates);
|
//
|
// ExamPaperTypeEnum examPaperTypeEnum = ExamPaperTypeEnum.fromCode(examPaperScore.getPaperType());
|
// switch (examPaperTypeEnum) {
|
// case RandomOrder:
|
//TODO:待完成
|
//任务试卷批改完成后，需要更新任务的状态
|
// ExamPaper examPaper = examPaperMapper.selectById(examPaperAnswer.getExamPaperId());
|
// Integer taskId = examPaper.getTaskExamId();
|
// Integer userId = examPaperAnswer.getCreateUser();
|
// TaskExamCustomerAnswer taskExamCustomerAnswer = taskExamCustomerAnswerMapper.getByTUid(taskId, userId);
|
// TextContent textContent = textContentService.getById(taskExamCustomerAnswer.getTextContentId());
|
// List<TaskItemAnswerObject> taskItemAnswerObjects = JsonUtil.toJsonListObject(textContent.getContent(), TaskItemAnswerObject.class);
|
// taskItemAnswerObjects.stream()
|
// .filter(d -> d.getExamPaperAnswerId().equals(examPaperAnswer.getId()))
|
// .findFirst().ifPresent(taskItemAnswerObject -> taskItemAnswerObject.setStatus(examPaperAnswer.getStatus()));
|
// textContentService.jsonConvertUpdate(textContent, taskItemAnswerObjects, null);
|
// textContentService.updateById(textContent);
|
// break;
|
// default:
|
// break;
|
// }
|
// return ExamUtil.scoreToVM(customerScore);
|
return "1";
|
}
|
|
@Override
|
public ExamPaperSubmitVO examPaperAnswerToVM(Integer id) {
|
ExamPaperSubmitVO examPaperSubmitVO = new ExamPaperSubmitVO();
|
// ExamPaperScore examPaperScore = examPaperScoreMapper.selectById(id);
|
// examPaperSubmitVO.setId(examPaperScore.getId());
|
// examPaperSubmitVO.setDoTime(examPaperScore.getDoTime());
|
// examPaperSubmitVO.setScore(ExamUtil.scoreToVM(examPaperScore.getUserScore()));
|
// List<ExamPaperScoreDetail> examPaperScoreDetails = examPaperScoreDetailService.selectListByPaperAnswerId(examPaperScore.getId());
|
// List<ExamPaperSubmitItemVO> examPaperSubmitItemVOS = examPaperScoreDetails.stream()
|
// .map(a -> examPaperScoreDetailService.examPaperQuestionCustomerAnswerToVM(a))
|
// .collect(Collectors.toList());
|
// examPaperSubmitVO.setAnswerItems(examPaperSubmitItemVOS);
|
return examPaperSubmitVO;
|
}
|
|
@Override
|
public Integer selectAllCount() {
|
return examPaperScoreMapper.selectAllCount();
|
}
|
|
@Override
|
public Integer selectAllQuestionCount() {
|
return examPaperScoreMapper.selectAllQuestionCount();
|
}
|
|
|
@Override
|
public List<Integer> selectMothCount() {
|
Date startTime = DateTimeUtil.getMonthStartDay();
|
Date endTime = DateTimeUtil.getMonthEndDay();
|
List<KeyValue> mouthCount = examPaperScoreMapper.selectCountByDate(startTime, endTime);
|
List<String> mothStartToNowFormat = DateTimeUtil.MothStartToNowFormat();
|
return mothStartToNowFormat.stream().map(md -> {
|
KeyValue keyValue = mouthCount.stream().filter(kv -> kv.getName().equals(md)).findAny().orElse(null);
|
return null == keyValue ? 0 : keyValue.getValue();
|
}).collect(Collectors.toList());
|
}
|
|
|
/**
|
* 用户提交答案的转化存储对象
|
*
|
* @param question question
|
* @param customerQuestionAnswer customerQuestionAnswer
|
* @param examPaper examPaper
|
* @param itemOrder itemOrder
|
* @param user user
|
* @param now now
|
* @return ExamPaperQuestionCustomerAnswer
|
*/
|
private ExamPaperScoreDetail ExamPaperQuestionCustomerAnswerFromVM(Question question, ExamPaperSubmitItemVO customerQuestionAnswer, ExamPaper examPaper, Integer itemOrder, User user, Date now) {
|
ExamPaperScoreDetail examPaperScoreDetail = new ExamPaperScoreDetail();
|
examPaperScoreDetail.setQuestionId(question.getId());
|
examPaperScoreDetail.setExamPaperId(examPaper.getId());
|
examPaperScoreDetail.setQuestionScore(null);
|
// examPaperScoreDetail.setSubjectId(examPaper.getSubjectId());
|
examPaperScoreDetail.setItemOrder(itemOrder);
|
examPaperScoreDetail.setCreateTime(now);
|
examPaperScoreDetail.setCreateUser(user.getId());
|
examPaperScoreDetail.setQuestionType(question.getQuestionType());
|
examPaperScoreDetail.setQuestionContent(question.getContent());
|
if (null == customerQuestionAnswer) {
|
examPaperScoreDetail.setCustomerScore(0);
|
} else {
|
setSpecialFromVM(examPaperScoreDetail, question, customerQuestionAnswer);
|
}
|
return examPaperScoreDetail;
|
}
|
|
/**
|
* 判断提交答案是否正确，保留用户提交的答案
|
*
|
* @param examPaperScoreDetail examPaperQuestionCustomerAnswer
|
* @param question question
|
* @param customerQuestionAnswer customerQuestionAnswer
|
*/
|
private void setSpecialFromVM(ExamPaperScoreDetail examPaperScoreDetail, Question question, ExamPaperSubmitItemVO customerQuestionAnswer) {
|
QuestionTypeEnum questionTypeEnum = QuestionTypeEnum.fromCode(examPaperScoreDetail.getQuestionType());
|
switch (questionTypeEnum) {
|
case SingleChoice:
|
case TrueFalse:
|
examPaperScoreDetail.setAnswer(customerQuestionAnswer.getContent());
|
examPaperScoreDetail.setDoRight(question.getCorrect().equals(customerQuestionAnswer.getContent()));
|
examPaperScoreDetail.setCustomerScore(examPaperScoreDetail.getDoRight() ? null : 0);
|
break;
|
case MultipleChoice:
|
String customerAnswer = ExamUtil.contentToString(customerQuestionAnswer.getContentArray());
|
examPaperScoreDetail.setAnswer(customerAnswer);
|
examPaperScoreDetail.setDoRight(customerAnswer.equals(question.getCorrect()));
|
examPaperScoreDetail.setCustomerScore(examPaperScoreDetail.getDoRight() ? null : 0);
|
break;
|
case GapFilling:
|
String correctAnswer = JsonUtil.toJsonStr(customerQuestionAnswer.getContentArray());
|
examPaperScoreDetail.setAnswer(correctAnswer);
|
examPaperScoreDetail.setCustomerScore(0);
|
break;
|
default:
|
examPaperScoreDetail.setAnswer(customerQuestionAnswer.getContent());
|
examPaperScoreDetail.setCustomerScore(0);
|
break;
|
}
|
}
|
|
private ExamPaperScore ExamPaperAnswerFromVM(ExamPaperSubmitVO examPaperSubmitVO, ExamPaper examPaper, List<ExamPaperScoreDetail> examPaperScoreDetails, User user, Date now) {
|
Integer systemScore = examPaperScoreDetails.stream().mapToInt(a -> a.getCustomerScore()).sum();
|
long questionCorrect = examPaperScoreDetails.stream().filter(a -> a.getCustomerScore().equals(a.getQuestionScore())).count();
|
ExamPaperScore examPaperScore = new ExamPaperScore();
|
//TODO:待完成
|
// examPaperAnswer.setPaperName(examPaper.getName());
|
// examPaperAnswer.setDoTime(examPaperSubmitVO.getDoTime());
|
// examPaperAnswer.setExamPaperId(examPaper.getId());
|
// examPaperAnswer.setCreateUser(user.getId());
|
// examPaperAnswer.setCreateTime(now);
|
// examPaperAnswer.setSubjectId(examPaper.getSubjectId());
|
// examPaperAnswer.setQuestionCount(examPaper.getQuestionCount());
|
// examPaperAnswer.setPaperScore(examPaper.getScore());
|
// examPaperAnswer.setPaperType(examPaper.getPaperType());
|
// examPaperAnswer.setSystemScore(systemScore);
|
// examPaperAnswer.setUserScore(systemScore);
|
// examPaperAnswer.setTaskExamId(examPaper.getTaskExamId());
|
// examPaperAnswer.setQuestionCorrect((int) questionCorrect);
|
// boolean needJudge = examPaperQuestionCustomerAnswers.stream().anyMatch(d -> QuestionTypeEnum.needSaveTextContent(d.getQuestionType()));
|
// if (needJudge) {
|
// examPaperAnswer.setStatus(ExamPaperAnswerStatusEnum.WaitJudge.getCode());
|
// } else {
|
// examPaperAnswer.setStatus(ExamPaperAnswerStatusEnum.Complete.getCode());
|
// }
|
return examPaperScore;
|
}
|
|
|
@Override
|
public PageInfo<ExamPaperAnswerPageResponseVO> adminPage(ExamPaperAnswerPageRequestVO requestVM) {
|
return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize()).doSelectPageInfo(() ->
|
examPaperScoreMapper.adminPage(requestVM));
|
}
|
|
@Override
|
public List<ExamPaperAnswerPageResponseVO> list(ExamPaperAnswerPageRequestVO requestVM) {
|
return examPaperScoreMapper.adminPage(requestVM);
|
}
|
|
@Override
|
public PageInfo<ExamPaperAnswerPageResponseVO> pageExamPaper(ExamPaperAnswerPageRequestVO model) {
|
return PageHelper.startPage(model.getPageIndex(), model.getPageSize()).doSelectPageInfo(() ->
|
examPaperScoreMapper.pageExamPaper(model));
|
}
|
|
@Override
|
public PageInfo<UserAnswerPageResponseVO> pageUser(UserAnswerPageRequestVO model) {
|
return PageHelper.startPage(model.getPageIndex(), model.getPageSize()).doSelectPageInfo(() ->
|
examPaperScoreMapper.pageUser(model));
|
}
|
|
@Override
|
public Result queryMaxAndMinScore(Integer id) {
|
List<ExamPaperScore> list = new ArrayList<>();
|
ExamPaperScore max = examPaperScoreMapper.selectOne(new LambdaQueryWrapper<>(ExamPaperScore.class)
|
.eq(ExamPaperScore::getExamId, id)
|
.orderByDesc(ExamPaperScore::getTotalScore)
|
.last("limit 1"));
|
list.add(max);
|
if (null != max) {
|
ExamPaperScore min = examPaperScoreMapper.selectOne(new LambdaQueryWrapper<>(ExamPaperScore.class)
|
.eq(ExamPaperScore::getExamId, id)
|
.orderByAsc(ExamPaperScore::getTotalScore)
|
.last("limit 1"));
|
list.add(min);
|
}
|
return Result.ok(list);
|
}
|
}
|
