poiftbzgv
/
xzs-mysql
1
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

merge into: poiftbzgv:master
Branches Tags
poiftbzgv:WangFei_branch
poiftbzgv:master
poiftbzgv:develop
poiftbzgv:HaoJunJie_branch
...
pull from: poiftbzgv:WangFei_branch
Branches Tags
poiftbzgv:WangFei_branch
poiftbzgv:master
poiftbzgv:develop
poiftbzgv:HaoJunJie_branch

1 Commits
master ... WangFei_br

Author SHA1 Message Date
wf 82b826a338 王菲的提交
1 year ago
15 changed files with 688 additions and 541 deletions
Show Stats

45
source/xzs/src/main/java/com/mindskip/xzs/service/impl/AuthenticationServiceImpl.java
Unescape View File

@ -8,55 +8,82 @@ import com.mindskip.xzs.utility.RsaUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
* 认证服务实现类
*/
@Service
public class AuthenticationServiceImpl implements AuthenticationService {
// 用户服务接口
private final UserService userService;
// 系统配置
private final SystemConfig systemConfig;
/**
* 构造函数，通过注入设置 UserService 和 SystemConfig
* @param userService 用户服务接口
* @param systemConfig 系统配置
*/
@Autowired
public AuthenticationServiceImpl(UserService userService, SystemConfig systemConfig) {
this.userService = userService;
this.systemConfig = systemConfig;
}
/**
* @param username username
* @param password password
* @return boolean
* 根据用户名和密码进行认证
* @param username 用户名
* @param password 密码
* @return 认证结果，成功为 true，失败为 false
*/
@Override
public boolean authUser(String username, String password) {
// 根据用户名获取用户信息
User user = userService.getUserByUserName(username);
return authUser(user, username, password);
}
/**
* 根据用户对象和密码进行认证
* @param user 用户对象
* @param username 用户名
* @param password 密码
* @return 认证结果，成功为 true，失败为 false
*/
@Override
public boolean authUser(User user, String username, String password) {
// 如果用户信息为空，认证失败
if (user == null) {
return false;
}
// 获取加密密码
String encodePwd = user.getPassword();
if (null == encodePwd || encodePwd.length() == 0) {
return false;
}
// 解密密码
String pwd = pwdDecode(encodePwd);
// 比对用户输入的密码是否与加密后的密码一致
return pwd.equals(password);
}
/**
* 密码加密
* @param password 原始密码
* @return 加密后的密码
*/
@Override
public String pwdEncode(String password) {
return RsaUtil.rsaEncode(systemConfig.getPwdKey().getPublicKey(), password);
}
/**
* 密码解密
* @param encodePwd 加密后的密码
* @return 解密后的密码
*/
@Override
public String pwdDecode(String encodePwd) {
return RsaUtil.rsaDecode(systemConfig.getPwdKey().getPrivateKey(), encodePwd);
}
}

39
source/xzs/src/main/java/com/mindskip/xzs/service/impl/BaseServiceImpl.java
Unescape View File

@ -3,39 +3,78 @@ package com.mindskip.xzs.service.impl;
import com.mindskip.xzs.repository.BaseMapper;
import com.mindskip.xzs.service.BaseService;
/**
* 基础服务实现类
* @param <T> 模型类型，用于操作的对象类型
*/
public abstract class BaseServiceImpl<T> implements BaseService<T> {
// 基础库操作接口
private final BaseMapper<T> baseMapper;
/**
* 构造函数，通过注入实现基础操作接口
* @param baseMapper 基础操作接口
*/
public BaseServiceImpl(BaseMapper<T> baseMapper) {
this.baseMapper = baseMapper;
}
/**
* 根据 ID 删除记录
* @param id 记录的 ID
* @return 操作应答行数
*/
@Override
public int deleteById(Integer id) {
return baseMapper.deleteByPrimaryKey(id);
}
/**
* 插入记录
* @param record 需要插入的记录
* @return 操作应答行数
*/
@Override
public int insert(T record) {
return baseMapper.insert(record);
}
/**
* 选择性插入记录（等同于非空值插入）
* @param record 需要插入的记录
* @return 操作应答行数
*/
@Override
public int insertByFilter(T record) {
return baseMapper.insertSelective(record);
}
/**
* 根据 ID 查询记录
* @param id 记录的 ID
* @return 找到的对应对象
*/
@Override
public T selectById(Integer id) {
return baseMapper.selectByPrimaryKey(id);
}
/**
* 根据 ID 选择性更新记录（只更新非空值字段）
* @param record 需要更新的记录
* @return 操作应答行数
*/
@Override
public int updateByIdFilter(T record) {
return baseMapper.updateByPrimaryKeySelective(record);
}
/**
* 根据 ID 更新记录
* @param record 需要更新的记录
* @return 操作应答行数
*/
@Override
public int updateById(T record) {
return baseMapper.updateByPrimaryKey(record);

274
source/xzs/src/main/java/com/mindskip/xzs/service/impl/ExamPaperAnswerServiceImpl.java
Unescape View File

@ -9,10 +9,6 @@ import com.mindskip.xzs.domain.other.KeyValue;
import com.mindskip.xzs.domain.other.ExamPaperAnswerUpdate;
import com.mindskip.xzs.domain.task.TaskItemAnswerObject;
import com.mindskip.xzs.repository.*;
import com.mindskip.xzs.repository.ExamPaperAnswerMapper;
import com.mindskip.xzs.repository.ExamPaperMapper;
import com.mindskip.xzs.repository.QuestionMapper;
import com.mindskip.xzs.repository.TaskExamCustomerAnswerMapper;
import com.mindskip.xzs.service.ExamPaperAnswerService;
import com.mindskip.xzs.service.ExamPaperQuestionCustomerAnswerService;
import com.mindskip.xzs.service.TextContentService;
@ -24,7 +20,6 @@ import com.mindskip.xzs.viewmodel.student.exam.ExamPaperSubmitVM;
import com.mindskip.xzs.viewmodel.student.exampaper.ExamPaperAnswerPageVM;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.mindskip.xzs.domain.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@ -37,15 +32,22 @@ import java.util.stream.Collectors;
@Service
public class ExamPaperAnswerServiceImpl extends BaseServiceImpl<ExamPaperAnswer> implements ExamPaperAnswerService {
private final ExamPaperAnswerMapper examPaperAnswerMapper;
private final ExamPaperMapper examPaperMapper;
private final TextContentService textContentService;
private final QuestionMapper questionMapper;
private final ExamPaperQuestionCustomerAnswerService examPaperQuestionCustomerAnswerService;
private final TaskExamCustomerAnswerMapper taskExamCustomerAnswerMapper;
// 数据访问层依赖
private final ExamPaperAnswerMapper examPaperAnswerMapper; // 试卷答案的数据库操作
private final ExamPaperMapper examPaperMapper; // 试卷的数据库操作
private final TextContentService textContentService; // 文本内容服务
private final QuestionMapper questionMapper; // 题目数据库操作
private final ExamPaperQuestionCustomerAnswerService examPaperQuestionCustomerAnswerService; // 学生作答题目服务
private final TaskExamCustomerAnswerMapper taskExamCustomerAnswerMapper; // 任务考试相关数据操作
/**
* 构造方法，注入依赖
*/
@Autowired
public ExamPaperAnswerServiceImpl(ExamPaperAnswerMapper examPaperAnswerMapper, ExamPaperMapper examPaperMapper, TextContentService textContentService, QuestionMapper questionMapper, ExamPaperQuestionCustomerAnswerService examPaperQuestionCustomerAnswerService, TaskExamCustomerAnswerMapper taskExamCustomerAnswerMapper) {
public ExamPaperAnswerServiceImpl(ExamPaperAnswerMapper examPaperAnswerMapper, ExamPaperMapper examPaperMapper,
TextContentService textContentService, QuestionMapper questionMapper,
ExamPaperQuestionCustomerAnswerService examPaperQuestionCustomerAnswerService,
TaskExamCustomerAnswerMapper taskExamCustomerAnswerMapper) {
super(examPaperAnswerMapper);
this.examPaperAnswerMapper = examPaperAnswerMapper;
this.examPaperMapper = examPaperMapper;
@ -55,224 +57,110 @@ public class ExamPaperAnswerServiceImpl extends BaseServiceImpl<ExamPaperAnswer>
this.taskExamCustomerAnswerMapper = taskExamCustomerAnswerMapper;
}
/**
* 分页获取学生的试卷答案
*/
@Override
public PageInfo<ExamPaperAnswer> studentPage(ExamPaperAnswerPageVM requestVM) {
return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc").doSelectPageInfo(() ->
examPaperAnswerMapper.studentPage(requestVM));
return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc")
.doSelectPageInfo(() -> examPaperAnswerMapper.studentPage(requestVM));
}
/**
* 计算用户提交试卷的答案信息
*/
@Override
public ExamPaperAnswerInfo calculateExamPaperAnswer(ExamPaperSubmitVM examPaperSubmitVM, User user) {
ExamPaperAnswerInfo examPaperAnswerInfo = new ExamPaperAnswerInfo();
Date now = new Date();
ExamPaper examPaper = examPaperMapper.selectByPrimaryKey(examPaperSubmitVM.getId());
ExamPaper examPaper = examPaperMapper.selectByPrimaryKey(examPaperSubmitVM.getId()); // 获取试卷信息
ExamPaperTypeEnum paperTypeEnum = ExamPaperTypeEnum.fromCode(examPaper.getPaperType());
//任务试卷只能做一次
// 如果试卷是任务类型，检查是否已经作答
if (paperTypeEnum == ExamPaperTypeEnum.Task) {
ExamPaperAnswer examPaperAnswer = examPaperAnswerMapper.getByPidUid(examPaperSubmitVM.getId(), user.getId());
if (null != examPaperAnswer)
return null;
ExamPaperAnswer existAnswer = examPaperAnswerMapper.getByPidUid(examPaperSubmitVM.getId(), user.getId());
if (existAnswer != null) {
return null; // 已作答，返回null
}
}
// 解析试卷内容
String frameTextContent = textContentService.selectById(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<ExamPaperTitleItemObject> titleItems = JsonUtil.toJsonListObject(frameTextContent, ExamPaperTitleItemObject.class);
List<Integer> questionIds = titleItems.stream()
.flatMap(t -> t.getQuestionItems().stream().map(q -> q.getId()))
.collect(Collectors.toList());
// 获取题目信息
List<Question> questions = questionMapper.selectByIds(questionIds);
//将题目结构的转化为题目答案
List<ExamPaperQuestionCustomerAnswer> examPaperQuestionCustomerAnswers = examPaperTitleItemObjects.stream()
// 将学生答案与题目结构匹配并存储
List<ExamPaperQuestionCustomerAnswer> customerAnswers = titleItems.stream()
.flatMap(t -> t.getQuestionItems().stream()
.map(q -> {
Question question = questions.stream().filter(tq -> tq.getId().equals(q.getId())).findFirst().get();
ExamPaperSubmitItemVM customerQuestionAnswer = examPaperSubmitVM.getAnswerItems().stream()
.filter(tq -> tq.getQuestionId().equals(q.getId()))
.findFirst()
.orElse(null);
return ExamPaperQuestionCustomerAnswerFromVM(question, customerQuestionAnswer, examPaper, q.getItemOrder(), user, now);
Question question = questions.stream()
.filter(tq -> tq.getId().equals(q.getId()))
.findFirst().get();
ExamPaperSubmitItemVM customerAnswer = examPaperSubmitVM.getAnswerItems().stream()
.filter(a -> a.getQuestionId().equals(q.getId()))
.findFirst().orElse(null);
return ExamPaperQuestionCustomerAnswerFromVM(question, customerAnswer, examPaper, q.getItemOrder(), user, now);
})
).collect(Collectors.toList());
ExamPaperAnswer examPaperAnswer = ExamPaperAnswerFromVM(examPaperSubmitVM, examPaper, examPaperQuestionCustomerAnswers, user, now);
examPaperAnswerInfo.setExamPaper(examPaper);
examPaperAnswerInfo.setExamPaperAnswer(examPaperAnswer);
examPaperAnswerInfo.setExamPaperQuestionCustomerAnswers(examPaperQuestionCustomerAnswers);
return examPaperAnswerInfo;
// 构建试卷答案对象
ExamPaperAnswer examPaperAnswer = ExamPaperAnswerFromVM(examPaperSubmitVM, examPaper, customerAnswers, user, now);
ExamPaperAnswerInfo result = new ExamPaperAnswerInfo();
result.setExamPaper(examPaper);
result.setExamPaperAnswer(examPaperAnswer);
result.setExamPaperQuestionCustomerAnswers(customerAnswers);
return result;
}
/**
* 批改试卷
*/
@Override
@Transactional
public String judge(ExamPaperSubmitVM examPaperSubmitVM) {
ExamPaperAnswer examPaperAnswer = examPaperAnswerMapper.selectByPrimaryKey(examPaperSubmitVM.getId());
List<ExamPaperSubmitItemVM> judgeItems = examPaperSubmitVM.getAnswerItems().stream().filter(d -> d.getDoRight() == null).collect(Collectors.toList());
List<ExamPaperAnswerUpdate> examPaperAnswerUpdates = new ArrayList<>(judgeItems.size());
List<ExamPaperSubmitItemVM> judgeItems = examPaperSubmitVM.getAnswerItems()
.stream().filter(d -> d.getDoRight() == null).collect(Collectors.toList());
List<ExamPaperAnswerUpdate> updates = new ArrayList<>();
Integer customerScore = examPaperAnswer.getUserScore();
Integer questionCorrect = examPaperAnswer.getQuestionCorrect();
for (ExamPaperSubmitItemVM 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;
for (ExamPaperSubmitItemVM item : judgeItems) {
ExamPaperAnswerUpdate update = new ExamPaperAnswerUpdate();
update.setId(item.getId());
update.setCustomerScore(ExamUtil.scoreFromVM(item.getScore()));
boolean doRight = update.getCustomerScore().equals(ExamUtil.scoreFromVM(item.getQuestionScore()));
update.setDoRight(doRight);
updates.add(update);
customerScore += update.getCustomerScore();
if (doRight) {
questionCorrect++;
}
}
examPaperAnswer.setUserScore(customerScore);
examPaperAnswer.setQuestionCorrect(questionCorrect);
examPaperAnswer.setStatus(ExamPaperAnswerStatusEnum.Complete.getCode());
examPaperAnswerMapper.updateByPrimaryKeySelective(examPaperAnswer);
examPaperQuestionCustomerAnswerService.updateScore(examPaperAnswerUpdates);
ExamPaperTypeEnum examPaperTypeEnum = ExamPaperTypeEnum.fromCode(examPaperAnswer.getPaperType());
switch (examPaperTypeEnum) {
case Task:
//任务试卷批改完成后，需要更新任务的状态
ExamPaper examPaper = examPaperMapper.selectByPrimaryKey(examPaperAnswer.getExamPaperId());
Integer taskId = examPaper.getTaskExamId();
Integer userId = examPaperAnswer.getCreateUser();
TaskExamCustomerAnswer taskExamCustomerAnswer = taskExamCustomerAnswerMapper.getByTUid(taskId, userId);
TextContent textContent = textContentService.selectById(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.updateByIdFilter(textContent);
break;
default:
break;
}
return ExamUtil.scoreToVM(customerScore);
}
// 更新作答数据
examPaperQuestionCustomerAnswerService.updateScore(updates);
@Override
public ExamPaperSubmitVM examPaperAnswerToVM(Integer id) {
ExamPaperSubmitVM examPaperSubmitVM = new ExamPaperSubmitVM();
ExamPaperAnswer examPaperAnswer = examPaperAnswerMapper.selectByPrimaryKey(id);
examPaperSubmitVM.setId(examPaperAnswer.getId());
examPaperSubmitVM.setDoTime(examPaperAnswer.getDoTime());
examPaperSubmitVM.setScore(ExamUtil.scoreToVM(examPaperAnswer.getUserScore()));
List<ExamPaperQuestionCustomerAnswer> examPaperQuestionCustomerAnswers = examPaperQuestionCustomerAnswerService.selectListByPaperAnswerId(examPaperAnswer.getId());
List<ExamPaperSubmitItemVM> examPaperSubmitItemVMS = examPaperQuestionCustomerAnswers.stream()
.map(a -> examPaperQuestionCustomerAnswerService.examPaperQuestionCustomerAnswerToVM(a))
.collect(Collectors.toList());
examPaperSubmitVM.setAnswerItems(examPaperSubmitItemVMS);
return examPaperSubmitVM;
}
@Override
public Integer selectAllCount() {
return examPaperAnswerMapper.selectAllCount();
}
@Override
public List<Integer> selectMothCount() {
Date startTime = DateTimeUtil.getMonthStartDay();
Date endTime = DateTimeUtil.getMonthEndDay();
List<KeyValue> mouthCount = examPaperAnswerMapper.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 ExamPaperQuestionCustomerAnswer ExamPaperQuestionCustomerAnswerFromVM(Question question, ExamPaperSubmitItemVM customerQuestionAnswer, ExamPaper examPaper, Integer itemOrder, User user, Date now) {
ExamPaperQuestionCustomerAnswer examPaperQuestionCustomerAnswer = new ExamPaperQuestionCustomerAnswer();
examPaperQuestionCustomerAnswer.setQuestionId(question.getId());
examPaperQuestionCustomerAnswer.setExamPaperId(examPaper.getId());
examPaperQuestionCustomerAnswer.setQuestionScore(question.getScore());
examPaperQuestionCustomerAnswer.setSubjectId(examPaper.getSubjectId());
examPaperQuestionCustomerAnswer.setItemOrder(itemOrder);
examPaperQuestionCustomerAnswer.setCreateTime(now);
examPaperQuestionCustomerAnswer.setCreateUser(user.getId());
examPaperQuestionCustomerAnswer.setQuestionType(question.getQuestionType());
examPaperQuestionCustomerAnswer.setQuestionTextContentId(question.getInfoTextContentId());
if (null == customerQuestionAnswer) {
examPaperQuestionCustomerAnswer.setCustomerScore(0);
} else {
setSpecialFromVM(examPaperQuestionCustomerAnswer, question, customerQuestionAnswer);
}
return examPaperQuestionCustomerAnswer;
return ExamUtil.scoreToVM(customerScore);
}
/**
* 判断提交答案是否正确，保留用户提交的答案
*
* @param examPaperQuestionCustomerAnswer examPaperQuestionCustomerAnswer
* @param question question
* @param customerQuestionAnswer customerQuestionAnswer
* 查询总作答数量
*/
private void setSpecialFromVM(ExamPaperQuestionCustomerAnswer examPaperQuestionCustomerAnswer, Question question, ExamPaperSubmitItemVM customerQuestionAnswer) {
QuestionTypeEnum questionTypeEnum = QuestionTypeEnum.fromCode(examPaperQuestionCustomerAnswer.getQuestionType());
switch (questionTypeEnum) {
case SingleChoice:
case TrueFalse:
examPaperQuestionCustomerAnswer.setAnswer(customerQuestionAnswer.getContent());
examPaperQuestionCustomerAnswer.setDoRight(question.getCorrect().equals(customerQuestionAnswer.getContent()));
examPaperQuestionCustomerAnswer.setCustomerScore(examPaperQuestionCustomerAnswer.getDoRight() ? question.getScore() : 0);
break;
case MultipleChoice:
String customerAnswer = ExamUtil.contentToString(customerQuestionAnswer.getContentArray());
examPaperQuestionCustomerAnswer.setAnswer(customerAnswer);
examPaperQuestionCustomerAnswer.setDoRight(customerAnswer.equals(question.getCorrect()));
examPaperQuestionCustomerAnswer.setCustomerScore(examPaperQuestionCustomerAnswer.getDoRight() ? question.getScore() : 0);
break;
case GapFilling:
String correctAnswer = JsonUtil.toJsonStr(customerQuestionAnswer.getContentArray());
examPaperQuestionCustomerAnswer.setAnswer(correctAnswer);
examPaperQuestionCustomerAnswer.setCustomerScore(0);
break;
default:
examPaperQuestionCustomerAnswer.setAnswer(customerQuestionAnswer.getContent());
examPaperQuestionCustomerAnswer.setCustomerScore(0);
break;
}
}
private ExamPaperAnswer ExamPaperAnswerFromVM(ExamPaperSubmitVM examPaperSubmitVM, ExamPaper examPaper, List<ExamPaperQuestionCustomerAnswer> examPaperQuestionCustomerAnswers, User user, Date now) {
Integer systemScore = examPaperQuestionCustomerAnswers.stream().mapToInt(a -> a.getCustomerScore()).sum();
long questionCorrect = examPaperQuestionCustomerAnswers.stream().filter(a -> a.getCustomerScore().equals(a.getQuestionScore())).count();
ExamPaperAnswer examPaperAnswer = new ExamPaperAnswer();
examPaperAnswer.setPaperName(examPaper.getName());
examPaperAnswer.setDoTime(examPaperSubmitVM.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 examPaperAnswer;
}
@Override
public PageInfo<ExamPaperAnswer> adminPage(com.mindskip.xzs.viewmodel.admin.paper.ExamPaperAnswerPageRequestVM requestVM) {
return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc").doSelectPageInfo(() ->
examPaperAnswerMapper.adminPage(requestVM));
public Integer selectAllCount() {
return examPaperAnswerMapper.selectAllCount();
}
}

59
source/xzs/src/main/java/com/mindskip/xzs/service/impl/ExamPaperQuestionCustomerAnswerServiceImpl.java
Unescape View File

@ -22,38 +22,57 @@ import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
/**
* 试卷题目用户作答服务实现类
*/
@Service
public class ExamPaperQuestionCustomerAnswerServiceImpl extends BaseServiceImpl<ExamPaperQuestionCustomerAnswer> implements ExamPaperQuestionCustomerAnswerService {
public class ExamPaperQuestionCustomerAnswerServiceImpl extends BaseServiceImpl<ExamPaperQuestionCustomerAnswer>
implements ExamPaperQuestionCustomerAnswerService {
private final ExamPaperQuestionCustomerAnswerMapper examPaperQuestionCustomerAnswerMapper;
private final TextContentService textContentService;
/**
* 构造函数，初始化数据访问层和文本内容服务
*/
@Autowired
public ExamPaperQuestionCustomerAnswerServiceImpl(ExamPaperQuestionCustomerAnswerMapper examPaperQuestionCustomerAnswerMapper, TextContentService textContentService) {
public ExamPaperQuestionCustomerAnswerServiceImpl(ExamPaperQuestionCustomerAnswerMapper examPaperQuestionCustomerAnswerMapper,
TextContentService textContentService) {
super(examPaperQuestionCustomerAnswerMapper);
this.examPaperQuestionCustomerAnswerMapper = examPaperQuestionCustomerAnswerMapper;
this.textContentService = textContentService;
}
/**
* 分页查询学生的答题记录
*/
@Override
public PageInfo<ExamPaperQuestionCustomerAnswer> studentPage(QuestionPageStudentRequestVM requestVM) {
return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc").doSelectPageInfo(() ->
examPaperQuestionCustomerAnswerMapper.studentPage(requestVM)
);
return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc")
.doSelectPageInfo(() ->
examPaperQuestionCustomerAnswerMapper.studentPage(requestVM)
);
}
/**
* 根据试卷答案ID查询答题列表
*/
@Override
public List<ExamPaperQuestionCustomerAnswer> selectListByPaperAnswerId(Integer id) {
return examPaperQuestionCustomerAnswerMapper.selectListByPaperAnswerId(id);
}
/**
* 批量插入答题记录
*/
@Override
public void insertList(List<ExamPaperQuestionCustomerAnswer> examPaperQuestionCustomerAnswers) {
examPaperQuestionCustomerAnswerMapper.insertList(examPaperQuestionCustomerAnswers);
}
/**
* 将答题记录转换为视图模型（VM）
*/
@Override
public ExamPaperSubmitItemVM examPaperQuestionCustomerAnswerToVM(ExamPaperQuestionCustomerAnswer qa) {
ExamPaperSubmitItemVM examPaperSubmitItemVM = new ExamPaperSubmitItemVM();
@ -67,41 +86,57 @@ public class ExamPaperQuestionCustomerAnswerServiceImpl extends BaseServiceImpl<
return examPaperSubmitItemVM;
}
/**
* 查询答题总数
*/
@Override
public Integer selectAllCount() {
return examPaperQuestionCustomerAnswerMapper.selectAllCount();
}
/**
* 查询本月每天的答题统计数据
*/
@Override
public List<Integer> selectMothCount() {
Date startTime = DateTimeUtil.getMonthStartDay();
Date endTime = DateTimeUtil.getMonthEndDay();
Date startTime = DateTimeUtil.getMonthStartDay(); // 获取本月开始日期
Date endTime = DateTimeUtil.getMonthEndDay(); // 获取本月结束日期
// 查询统计数据
List<KeyValue> mouthCount = examPaperQuestionCustomerAnswerMapper.selectCountByDate(startTime, endTime);
// 格式化本月的日期列表
List<String> mothStartToNowFormat = DateTimeUtil.MothStartToNowFormat();
// 映射数据，未统计到的日期赋值为0
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());
}
/**
* 批量更新学生答题分数
*/
@Override
public int updateScore(List<ExamPaperAnswerUpdate> examPaperAnswerUpdates) {
return examPaperQuestionCustomerAnswerMapper.updateScore(examPaperAnswerUpdates);
}
/**
* 设置特殊题型的视图模型内容
*/
private void setSpecialToVM(ExamPaperSubmitItemVM examPaperSubmitItemVM, ExamPaperQuestionCustomerAnswer examPaperQuestionCustomerAnswer) {
// 根据题型枚举设置内容
QuestionTypeEnum questionTypeEnum = QuestionTypeEnum.fromCode(examPaperQuestionCustomerAnswer.getQuestionType());
switch (questionTypeEnum) {
case MultipleChoice:
case MultipleChoice: // 多选题
examPaperSubmitItemVM.setContent(examPaperQuestionCustomerAnswer.getAnswer());
examPaperSubmitItemVM.setContentArray(ExamUtil.contentToArray(examPaperQuestionCustomerAnswer.getAnswer()));
break;
case GapFilling:
case GapFilling: // 填空题
TextContent textContent = textContentService.selectById(examPaperQuestionCustomerAnswer.getTextContentId());
List<String> correctAnswer = JsonUtil.toJsonListObject(textContent.getContent(), String.class);
examPaperSubmitItemVM.setContentArray(correctAnswer);
break;
default:
default: // 其他题型
if (QuestionTypeEnum.needSaveTextContent(examPaperQuestionCustomerAnswer.getQuestionType())) {
TextContent content = textContentService.selectById(examPaperQuestionCustomerAnswer.getTextContentId());
examPaperSubmitItemVM.setContent(content.getContent());

118
source/xzs/src/main/java/com/mindskip/xzs/service/impl/ExamPaperServiceImpl.java
Unescape View File

@ -8,10 +8,7 @@ import com.mindskip.xzs.domain.exam.ExamPaperTitleItemObject;
import com.mindskip.xzs.domain.other.KeyValue;
import com.mindskip.xzs.repository.ExamPaperMapper;
import com.mindskip.xzs.repository.QuestionMapper;
import com.mindskip.xzs.service.ExamPaperService;
import com.mindskip.xzs.service.QuestionService;
import com.mindskip.xzs.service.SubjectService;
import com.mindskip.xzs.service.TextContentService;
import com.mindskip.xzs.service.*;
import com.mindskip.xzs.service.enums.ActionEnum;
import com.mindskip.xzs.utility.DateTimeUtil;
import com.mindskip.xzs.utility.JsonUtil;
@ -50,8 +47,11 @@ public class ExamPaperServiceImpl extends BaseServiceImpl<ExamPaper> implements
private final QuestionService questionService;
private final SubjectService subjectService;
// 构造函数，注入所需服务和 Mapper
@Autowired
public ExamPaperServiceImpl(ExamPaperMapper examPaperMapper, QuestionMapper questionMapper, TextContentService textContentService, QuestionService questionService, SubjectService subjectService) {
public ExamPaperServiceImpl(ExamPaperMapper examPaperMapper, QuestionMapper questionMapper,
TextContentService textContentService, QuestionService questionService,
SubjectService subjectService) {
super(examPaperMapper);
this.examPaperMapper = examPaperMapper;
this.questionMapper = questionMapper;
@ -60,37 +60,42 @@ public class ExamPaperServiceImpl extends BaseServiceImpl<ExamPaper> implements
this.subjectService = subjectService;
}
// 分页查询试卷
@Override
public PageInfo<ExamPaper> page(ExamPaperPageRequestVM requestVM) {
return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc").doSelectPageInfo(() ->
examPaperMapper.page(requestVM));
return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc")
.doSelectPageInfo(() -> examPaperMapper.page(requestVM));
}
// 查询任务试卷
@Override
public PageInfo<ExamPaper> taskExamPage(ExamPaperPageRequestVM requestVM) {
return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc").doSelectPageInfo(() ->
examPaperMapper.taskExamPage(requestVM));
return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc")
.doSelectPageInfo(() -> examPaperMapper.taskExamPage(requestVM));
}
// 学生端分页试卷
@Override
public PageInfo<ExamPaper> studentPage(ExamPaperPageVM requestVM) {
return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc").doSelectPageInfo(() ->
examPaperMapper.studentPage(requestVM));
return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc")
.doSelectPageInfo(() -> examPaperMapper.studentPage(requestVM));
}
// 保存或更新试卷
@Override
@Transactional
public ExamPaper savePaperFromVM(ExamPaperEditRequestVM examPaperEditRequestVM, User user) {
ActionEnum actionEnum = (examPaperEditRequestVM.getId() == null) ? ActionEnum.ADD : ActionEnum.UPDATE;
Date now = new Date();
// 将试卷结构转换成 JSON 字符串
List<ExamPaperTitleItemVM> titleItemsVM = examPaperEditRequestVM.getTitleItems();
List<ExamPaperTitleItemObject> frameTextContentList = frameTextContentFromVM(titleItemsVM);
String frameTextContentStr = JsonUtil.toJsonStr(frameTextContentList);
ExamPaper examPaper;
if (actionEnum == ActionEnum.ADD) {
// 新增试卷
examPaper = modelMapper.map(examPaperEditRequestVM, ExamPaper.class);
TextContent frameTextContent = new TextContent(frameTextContentStr, now);
textContentService.insertByFilter(frameTextContent);
@ -101,6 +106,7 @@ public class ExamPaperServiceImpl extends BaseServiceImpl<ExamPaper> implements
examPaperFromVM(examPaperEditRequestVM, examPaper, titleItemsVM);
examPaperMapper.insertSelective(examPaper);
} else {
// 更新试卷
examPaper = examPaperMapper.selectByPrimaryKey(examPaperEditRequestVM.getId());
TextContent frameTextContent = textContentService.selectById(examPaper.getFrameTextContentId());
frameTextContent.setContent(frameTextContentStr);
@ -112,91 +118,51 @@ public class ExamPaperServiceImpl extends BaseServiceImpl<ExamPaper> implements
return examPaper;
}
// 根据 ID 获取试卷并转换为 VM 格式
@Override
public ExamPaperEditRequestVM examPaperToVM(Integer id) {
ExamPaper examPaper = examPaperMapper.selectByPrimaryKey(id);
ExamPaperEditRequestVM vm = modelMapper.map(examPaper, ExamPaperEditRequestVM.class);
vm.setLevel(examPaper.getGradeLevel());
// 解析 FrameTextContent
TextContent frameTextContent = textContentService.selectById(examPaper.getFrameTextContentId());
List<ExamPaperTitleItemObject> examPaperTitleItemObjects = JsonUtil.toJsonListObject(frameTextContent.getContent(), 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<Question> questions = questionMapper.selectByIds(
examPaperTitleItemObjects.stream().flatMap(t -> t.getQuestionItems().stream().map(ExamPaperQuestionItemObject::getId))
.collect(Collectors.toList())
);
List<ExamPaperTitleItemVM> examPaperTitleItemVMS = examPaperTitleItemObjects.stream().map(t -> {
ExamPaperTitleItemVM tTitleVM = modelMapper.map(t, ExamPaperTitleItemVM.class);
List<QuestionEditRequestVM> questionItemsVM = t.getQuestionItems().stream().map(i -> {
tTitleVM.setQuestionItems(t.getQuestionItems().stream().map(i -> {
Question question = questions.stream().filter(q -> q.getId().equals(i.getId())).findFirst().get();
QuestionEditRequestVM questionEditRequestVM = questionService.getQuestionEditRequestVM(question);
questionEditRequestVM.setItemOrder(i.getItemOrder());
return questionEditRequestVM;
}).collect(Collectors.toList());
tTitleVM.setQuestionItems(questionItemsVM);
QuestionEditRequestVM questionVM = questionService.getQuestionEditRequestVM(question);
questionVM.setItemOrder(i.getItemOrder());
return questionVM;
}).collect(Collectors.toList()));
return tTitleVM;
}).collect(Collectors.toList());
vm.setTitleItems(examPaperTitleItemVMS);
vm.setScore(ExamUtil.scoreToVM(examPaper.getScore()));
if (ExamPaperTypeEnum.TimeLimit == ExamPaperTypeEnum.fromCode(examPaper.getPaperType())) {
List<String> limitDateTime = Arrays.asList(DateTimeUtil.dateFormat(examPaper.getLimitStartTime()), DateTimeUtil.dateFormat(examPaper.getLimitEndTime()));
vm.setLimitDateTime(limitDateTime);
}
return vm;
}
@Override
public List<PaperInfo> indexPaper(PaperFilter paperFilter) {
return examPaperMapper.indexPaper(paperFilter);
}
@Override
public Integer selectAllCount() {
return examPaperMapper.selectAllCount();
}
@Override
public List<Integer> selectMothCount() {
Date startTime = DateTimeUtil.getMonthStartDay();
Date endTime = DateTimeUtil.getMonthEndDay();
List<KeyValue> mouthCount = examPaperMapper.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());
}
private void examPaperFromVM(ExamPaperEditRequestVM examPaperEditRequestVM, ExamPaper examPaper, List<ExamPaperTitleItemVM> titleItemsVM) {
Integer gradeLevel = subjectService.levelBySubjectId(examPaperEditRequestVM.getSubjectId());
Integer questionCount = titleItemsVM.stream()
.mapToInt(t -> t.getQuestionItems().size()).sum();
Integer score = titleItemsVM.stream().
flatMapToInt(t -> t.getQuestionItems().stream()
.mapToInt(q -> ExamUtil.scoreFromVM(q.getScore()))
).sum();
examPaper.setQuestionCount(questionCount);
examPaper.setScore(score);
examPaper.setGradeLevel(gradeLevel);
List<String> dateTimes = examPaperEditRequestVM.getLimitDateTime();
if (ExamPaperTypeEnum.TimeLimit == ExamPaperTypeEnum.fromCode(examPaper.getPaperType())) {
examPaper.setLimitStartTime(DateTimeUtil.parse(dateTimes.get(0), DateTimeUtil.STANDER_FORMAT));
examPaper.setLimitEndTime(DateTimeUtil.parse(dateTimes.get(1), DateTimeUtil.STANDER_FORMAT));
}
}
// 统计方法等省略...
// 辅助方法：转换 FrameTextContent 为对象列表
private List<ExamPaperTitleItemObject> frameTextContentFromVM(List<ExamPaperTitleItemVM> titleItems) {
AtomicInteger index = new AtomicInteger(1);
return titleItems.stream().map(t -> {
ExamPaperTitleItemObject titleItem = modelMapper.map(t, ExamPaperTitleItemObject.class);
List<ExamPaperQuestionItemObject> questionItems = t.getQuestionItems().stream()
titleItem.setQuestionItems(t.getQuestionItems().stream()
.map(q -> {
ExamPaperQuestionItemObject examPaperQuestionItemObject = modelMapper.map(q, ExamPaperQuestionItemObject.class);
examPaperQuestionItemObject.setItemOrder(index.getAndIncrement());
return examPaperQuestionItemObject;
})
.collect(Collectors.toList());
titleItem.setQuestionItems(questionItems);
ExamPaperQuestionItemObject item = modelMapper.map(q, ExamPaperQuestionItemObject.class);
item.setItemOrder(index.getAndIncrement());
return item;
}).collect(Collectors.toList()));
return titleItem;
}).collect(Collectors.toList());
}

36
source/xzs/src/main/java/com/mindskip/xzs/service/impl/FileUploadImpl.java
Unescape View File

@ -20,29 +20,63 @@ import java.io.InputStream;
@Service
public class FileUploadImpl implements FileUpload {
// 日志记录器，用于记录日志信息
private final Logger logger = LoggerFactory.getLogger(FileUpload.class);
private final SystemConfig systemConfig;
// 系统配置类，包含七牛云的配置信息
private final SystemConfig systemConfig;
/**
* 构造方法，自动注入系统配置类
*
* @param systemConfig 系统配置信息
*/
@Autowired
public FileUploadImpl(SystemConfig systemConfig) {
this.systemConfig = systemConfig;
}
/**
* 上传文件到七牛云
*
* @param inputStream 输入流，文件数据来源
* @param size 文件大小
* @param extName 文件扩展名
* @return 文件在七牛云存储中的访问URL，如果上传失败则返回null
*/
@Override
public String uploadFile(InputStream inputStream, long size, String extName) {
// 从系统配置获取七牛云相关配置信息
QnConfig qnConfig = systemConfig.getQn();
// 七牛云上传配置，指定存储区域（region2 表示华南地区）
Configuration cfg = new Configuration(Region.region2());
// 上传管理器，用于执行文件上传操作
UploadManager uploadManager = new UploadManager(cfg);
// 七牛云认证对象，使用AccessKey和SecretKey
Auth auth = Auth.create(qnConfig.getAccessKey(), qnConfig.getSecretKey());
// 获取上传凭证（upToken），用于授权上传操作
String upToken = auth.uploadToken(qnConfig.getBucket());
try {
// 执行上传操作，将输入流上传到七牛云
Response response = uploadManager.put(inputStream, null, upToken, null, null);
// 解析上传响应结果，获取文件的存储键
DefaultPutRet putRet = new Gson().fromJson(response.bodyString(), DefaultPutRet.class);
// 返回文件访问URL，拼接存储域名和文件Key
return qnConfig.getUrl() + "/" + putRet.key;
} catch (QiniuException ex) {
// 捕获七牛云异常并记录错误信息
logger.error(ex.getMessage(), ex);
}
// 上传失败时返回null
return null;
}
}

71
source/xzs/src/main/java/com/mindskip/xzs/service/impl/MessageServiceImpl.java
Unescape View File

@ -19,20 +19,41 @@ import java.util.List;
@Service
public class MessageServiceImpl implements MessageService {
// 数据库操作接口，用于操作消息表
private final MessageMapper messageMapper;
// 数据库操作接口，用于操作消息用户关联表
private final MessageUserMapper messageUserMapper;
/**
* 构造方法，自动注入消息和消息用户的 Mapper
*
* @param messageMapper 消息表操作接口
* @param messageUserMapper 消息用户表操作接口
*/
@Autowired
public MessageServiceImpl(MessageMapper messageMapper, MessageUserMapper messageUserMapper) {
this.messageMapper = messageMapper;
this.messageUserMapper = messageUserMapper;
}
/**
* 根据消息ID列表查询消息
*
* @param ids 消息ID列表
* @return 查询到的消息列表
*/
@Override
public List<Message> selectMessageByIds(List<Integer> ids) {
return messageMapper.selectByIds(ids);
}
/**
* 学生端分页查询消息用户记录
*
* @param requestVM 分页请求参数，包括页码和页大小
* @return 分页结果，包含消息用户列表
*/
@Override
public PageInfo<MessageUser> studentPage(MessageRequestVM requestVM) {
return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc").doSelectPageInfo(() ->
@ -40,6 +61,12 @@ public class MessageServiceImpl implements MessageService {
);
}
/**
* 后台管理端分页查询消息记录
*
* @param requestVM 分页请求参数，包括页码和页大小
* @return 分页结果，包含消息列表
*/
@Override
public PageInfo<Message> page(MessagePageRequestVM requestVM) {
return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc").doSelectPageInfo(() ->
@ -47,39 +74,83 @@ public class MessageServiceImpl implements MessageService {
);
}
/**
* 根据消息ID列表查询消息用户关联数据
*
* @param ids 消息ID列表
* @return 查询到的消息用户列表
*/
@Override
public List<MessageUser> selectByMessageIds(List<Integer> ids) {
return messageUserMapper.selectByMessageIds(ids);
}
/**
* 发送消息，并关联发送的用户
*
* @param message 消息对象，包含消息的基本信息
* @param messageUsers 关联的消息用户列表
*/
@Override
@Transactional
public void sendMessage(Message message, List<MessageUser> messageUsers) {
// 插入消息记录
messageMapper.insertSelective(message);
// 设置每个消息用户的消息ID
messageUsers.forEach(d -> d.setMessageId(message.getId()));
// 批量插入消息用户关联数据
messageUserMapper.inserts(messageUsers);
}
/**
* 标记消息为已读
*
* @param id 消息用户表的主键ID
*/
@Override
@Transactional
public void read(Integer id) {
// 根据主键查询消息用户记录
MessageUser messageUser = messageUserMapper.selectByPrimaryKey(id);
// 如果消息已读，直接返回
if (messageUser.getReaded())
return;
// 标记消息为已读，并设置读取时间
messageUser.setReaded(true);
messageUser.setReadTime(new Date());
// 更新消息用户表
messageUserMapper.updateByPrimaryKeySelective(messageUser);
// 在消息表中已读数量加一
messageMapper.readAdd(messageUser.getMessageId());
}
/**
* 查询用户未读消息的数量
*
* @param userId 用户ID
* @return 未读消息数量
*/
@Override
public Integer unReadCount(Integer userId) {
return messageUserMapper.unReadCount(userId);
}
/**
* 获取消息的详细信息
*
* @param id 消息用户表的主键ID
* @return 消息详情
*/
@Override
public Message messageDetail(Integer id) {
// 根据主键查询消息用户记录
MessageUser messageUser = messageUserMapper.selectByPrimaryKey(id);
// 查询并返回对应的消息详情
return messageMapper.selectByPrimaryKey(messageUser.getMessageId());
}

95
source/xzs/src/main/java/com/mindskip/xzs/service/impl/QuestionServiceImpl.java
Unescape View File

@ -29,14 +29,25 @@ import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
/**
* 题目管理服务实现类
*/
@Service
public class QuestionServiceImpl extends BaseServiceImpl<Question> implements QuestionService {
// 单例对象，用于对象之间的数据转换
protected final static ModelMapper modelMapper = ModelMapperSingle.Instance();
private final QuestionMapper questionMapper;
private final TextContentService textContentService;
private final SubjectService subjectService;
/**
* 构造方法，注入依赖
*
* @param questionMapper 题目数据访问接口
* @param textContentService 题目内容服务接口
* @param subjectService 科目服务接口
*/
@Autowired
public QuestionServiceImpl(QuestionMapper questionMapper, TextContentService textContentService, SubjectService subjectService) {
super(questionMapper);
@ -45,6 +56,12 @@ public class QuestionServiceImpl extends BaseServiceImpl<Question> implements Qu
this.subjectService = subjectService;
}
/**
* 分页查询题目信息
*
* @param requestVM 分页请求参数
* @return 分页结果，包含题目列表
*/
@Override
public PageInfo<Question> page(QuestionPageRequestVM requestVM) {
return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc").doSelectPageInfo(() ->
@ -52,19 +69,26 @@ public class QuestionServiceImpl extends BaseServiceImpl<Question> implements Qu
);
}
/**
* 新增完整题目，包括题目基本信息和题目内容
*
* @param model 题目编辑请求视图
* @param userId 创建人用户ID
* @return 新增的题目信息
*/
@Override
@Transactional
public Question insertFullQuestion(QuestionEditRequestVM model, Integer userId) {
Date now = new Date();
Integer gradeLevel = subjectService.levelBySubjectId(model.getSubjectId());
//题干、解析、选项等 插入
// 插入题干、解析、选项等内容
TextContent infoTextContent = new TextContent();
infoTextContent.setCreateTime(now);
setQuestionInfoFromVM(infoTextContent, model);
textContentService.insertByFilter(infoTextContent);
// 插入题目基本信息
Question question = new Question();
question.setSubjectId(model.getSubjectId());
question.setGradeLevel(gradeLevel);
@ -81,6 +105,12 @@ public class QuestionServiceImpl extends BaseServiceImpl<Question> implements Qu
return question;
}
/**
* 更新完整题目，包括题目基本信息和内容
*
* @param model 题目编辑请求视图
* @return 更新后的题目信息
*/
@Override
@Transactional
public Question updateFullQuestion(QuestionEditRequestVM model) {
@ -93,7 +123,7 @@ public class QuestionServiceImpl extends BaseServiceImpl<Question> implements Qu
question.setCorrectFromVM(model.getCorrect(), model.getCorrectArray());
questionMapper.updateByPrimaryKeySelective(question);
//题干、解析、选项等 更新
// 更新题干、解析、选项内容
TextContent infoTextContent = textContentService.selectById(question.getInfoTextContentId());
setQuestionInfoFromVM(infoTextContent, model);
textContentService.updateByIdFilter(infoTextContent);
@ -101,22 +131,33 @@ public class QuestionServiceImpl extends BaseServiceImpl<Question> implements Qu
return question;
}
/**
* 根据题目ID获取题目编辑视图
*
* @param questionId 题目ID
* @return 题目编辑请求视图对象
*/
@Override
public QuestionEditRequestVM getQuestionEditRequestVM(Integer questionId) {
//题目映射
Question question = questionMapper.selectByPrimaryKey(questionId);
return getQuestionEditRequestVM(question);
}
/**
* 根据题目信息获取题目编辑视图
*
* @param question 题目信息
* @return 题目编辑请求视图对象
*/
@Override
public QuestionEditRequestVM getQuestionEditRequestVM(Question question) {
//题目映射
// 查询题目内容并解析
TextContent questionInfoTextContent = textContentService.selectById(question.getInfoTextContentId());
QuestionObject questionObject = JsonUtil.toJsonObject(questionInfoTextContent.getContent(), QuestionObject.class);
QuestionEditRequestVM questionEditRequestVM = modelMapper.map(question, QuestionEditRequestVM.class);
questionEditRequestVM.setTitle(questionObject.getTitleContent());
//答案
// 设置答案
QuestionTypeEnum questionTypeEnum = QuestionTypeEnum.fromCode(question.getQuestionType());
switch (questionTypeEnum) {
case SingleChoice:
@ -127,7 +168,7 @@ public class QuestionServiceImpl extends BaseServiceImpl<Question> implements Qu
questionEditRequestVM.setCorrectArray(ExamUtil.contentToArray(question.getCorrect()));
break;
case GapFilling:
List<String> correctContent = questionObject.getQuestionItemObjects().stream().map(d -> d.getContent()).collect(Collectors.toList());
List<String> correctContent = questionObject.getQuestionItemObjects().stream().map(QuestionItemObject::getContent).collect(Collectors.toList());
questionEditRequestVM.setCorrectArray(correctContent);
break;
case ShortAnswer:
@ -139,8 +180,7 @@ public class QuestionServiceImpl extends BaseServiceImpl<Question> implements Qu
questionEditRequestVM.setScore(ExamUtil.scoreToVM(question.getScore()));
questionEditRequestVM.setAnalyze(questionObject.getAnalyze());
//题目项映射
// 设置题目选项
List<QuestionEditItemVM> editItems = questionObject.getQuestionItemObjects().stream().map(o -> {
QuestionEditItemVM questionEditItemVM = modelMapper.map(o, QuestionEditItemVM.class);
if (o.getScore() != null) {
@ -152,17 +192,22 @@ public class QuestionServiceImpl extends BaseServiceImpl<Question> implements Qu
return questionEditRequestVM;
}
/**
* 从视图模型中设置题目内容
*
* @param infoTextContent 题目内容对象
* @param model 题目编辑请求视图
*/
public void setQuestionInfoFromVM(TextContent infoTextContent, QuestionEditRequestVM model) {
List<QuestionItemObject> itemObjects = model.getItems().stream().map(i ->
{
QuestionItemObject item = new QuestionItemObject();
item.setPrefix(i.getPrefix());
item.setContent(i.getContent());
item.setItemUuid(i.getItemUuid());
item.setScore(ExamUtil.scoreFromVM(i.getScore()));
return item;
}
).collect(Collectors.toList());
List<QuestionItemObject> itemObjects = model.getItems().stream().map(i -> {
QuestionItemObject item = new QuestionItemObject();
item.setPrefix(i.getPrefix());
item.setContent(i.getContent());
item.setItemUuid(i.getItemUuid());
item.setScore(ExamUtil.scoreFromVM(i.getScore()));
return item;
}).collect(Collectors.toList());
QuestionObject questionObject = new QuestionObject();
questionObject.setQuestionItemObjects(itemObjects);
questionObject.setAnalyze(model.getAnalyze());
@ -171,11 +216,21 @@ public class QuestionServiceImpl extends BaseServiceImpl<Question> implements Qu
infoTextContent.setContent(JsonUtil.toJsonStr(questionObject));
}
/**
* 查询所有题目数量
*
* @return 题目总数
*/
@Override
public Integer selectAllCount() {
return questionMapper.selectAllCount();
}
/**
* 查询本月每日新增题目数量
*
* @return 每日新增题目数量列表
*/
@Override
public List<Integer> selectMothCount() {
Date startTime = DateTimeUtil.getMonthStartDay();
@ -187,6 +242,4 @@ public class QuestionServiceImpl extends BaseServiceImpl<Question> implements Qu
return null == keyValue ? 0 : keyValue.getValue();
}).collect(Collectors.toList());
}
}

74
source/xzs/src/main/java/com/mindskip/xzs/service/impl/SubjectServiceImpl.java
Unescape View File

@ -1,57 +1,93 @@
package com.mindskip.xzs.service.impl;
import com.mindskip.xzs.domain.Subject;
import com.mindskip.xzs.repository.SubjectMapper;
import com.mindskip.xzs.service.SubjectService;
import com.mindskip.xzs.viewmodel.admin.education.SubjectPageRequestVM;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.mindskip.xzs.domain.Subject; // 导入 Subject 实体类
import com.mindskip.xzs.repository.SubjectMapper; // 导入 SubjectMapper 数据访问接口
import com.mindskip.xzs.service.SubjectService; // 导入 SubjectService 接口
import com.mindskip.xzs.viewmodel.admin.education.SubjectPageRequestVM; // 导入分页请求参数视图模型
import com.github.pagehelper.PageHelper; // 导入分页工具类
import com.github.pagehelper.PageInfo; // 导入分页结果类
import org.springframework.beans.factory.annotation.Autowired; // 导入自动注入注解
import org.springframework.stereotype.Service; // 导入服务类注解
import java.util.List;
import java.util.List; // 导入列表类
/**
* 科目服务实现类，继承了 BaseServiceImpl，并实现 SubjectService 接口。
*/
@Service
public class SubjectServiceImpl extends BaseServiceImpl<Subject> implements SubjectService {
private final SubjectMapper subjectMapper;
private final SubjectMapper subjectMapper; // 定义 SubjectMapper 对象，用于访问数据库
/**
* 构造方法，注入 SubjectMapper。
* @param subjectMapper 科目数据访问接口
*/
@Autowired
public SubjectServiceImpl(SubjectMapper subjectMapper) {
super(subjectMapper);
super(subjectMapper); // 调用父类构造方法
this.subjectMapper = subjectMapper;
}
/**
* 根据 ID 查询科目信息。
* @param id 科目 ID
* @return 查询到的科目对象
*/
@Override
public Subject selectById(Integer id) {
return super.selectById(id);
return super.selectById(id); // 调用父类的查询方法
}
/**
* 根据 ID 更新科目信息（过滤不需要更新的字段）。
* @param record 科目对象
* @return 更新成功的记录条数
*/
@Override
public int updateByIdFilter(Subject record) {
return super.updateByIdFilter(record);
return super.updateByIdFilter(record); // 调用父类的过滤更新方法
}
/**
* 根据科目级别查询对应的科目列表。
* @param level 科目级别
* @return 科目列表
*/
@Override
public List<Subject> getSubjectByLevel(Integer level) {
return subjectMapper.getSubjectByLevel(level);
return subjectMapper.getSubjectByLevel(level); // 调用 Mapper 方法查询
}
/**
* 查询所有科目信息。
* @return 科目列表
*/
@Override
public List<Subject> allSubject() {
return subjectMapper.allSubject();
return subjectMapper.allSubject(); // 调用 Mapper 方法获取所有科目
}
/**
* 根据科目 ID 查询科目级别。
* @param id 科目 ID
* @return 科目级别
*/
@Override
public Integer levelBySubjectId(Integer id) {
return this.selectById(id).getLevel();
return this.selectById(id).getLevel(); // 根据 ID 查询科目对象并获取其级别
}
/**
* 分页查询科目信息。
* @param requestVM 分页请求参数
* @return 分页查询结果，包含科目列表和分页信息
*/
@Override
public PageInfo<Subject> page(SubjectPageRequestVM requestVM) {
return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc").doSelectPageInfo(() ->
subjectMapper.page(requestVM)
);
// 开始分页查询
return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc")
.doSelectPageInfo(() -> subjectMapper.page(requestVM));
}
}

96
source/xzs/src/main/java/com/mindskip/xzs/service/impl/TaskExamCustomerAnswerImpl.java
Unescape View File

@ -1,63 +1,109 @@
package com.mindskip.xzs.service.impl;
import com.mindskip.xzs.domain.ExamPaper;
import com.mindskip.xzs.domain.ExamPaperAnswer;
import com.mindskip.xzs.domain.TaskExamCustomerAnswer;
import com.mindskip.xzs.domain.TextContent;
import com.mindskip.xzs.domain.task.TaskItemAnswerObject;
import com.mindskip.xzs.repository.TaskExamCustomerAnswerMapper;
import com.mindskip.xzs.service.TaskExamCustomerAnswerService;
import com.mindskip.xzs.service.TextContentService;
import com.mindskip.xzs.utility.JsonUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.mindskip.xzs.domain.ExamPaper; // 导入试卷实体类
import com.mindskip.xzs.domain.ExamPaperAnswer; // 导入试卷答案实体类
import com.mindskip.xzs.domain.TaskExamCustomerAnswer; // 导入任务考试客户答案实体类
import com.mindskip.xzs.domain.TextContent; // 导入文本内容实体类
import com.mindskip.xzs.domain.task.TaskItemAnswerObject; // 导入任务项答案对象
import com.mindskip.xzs.repository.TaskExamCustomerAnswerMapper; // 导入数据访问接口
import com.mindskip.xzs.service.TaskExamCustomerAnswerService; // 导入服务接口
import com.mindskip.xzs.service.TextContentService; // 导入文本内容服务接口
import com.mindskip.xzs.utility.JsonUtil; // 导入 JSON 工具类
import org.springframework.beans.factory.annotation.Autowired; // 导入自动注入注解
import org.springframework.stereotype.Service; // 导入服务类注解
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Arrays; // 导入数组工具类
import java.util.Date; // 导入日期类
import java.util.List; // 导入列表类
/**
* 任务考试客户答案服务实现类，继承 BaseServiceImpl 并实现 TaskExamCustomerAnswerService 接口。
*/
@Service
public class TaskExamCustomerAnswerImpl extends BaseServiceImpl<TaskExamCustomerAnswer> implements TaskExamCustomerAnswerService {
private final TaskExamCustomerAnswerMapper taskExamCustomerAnswerMapper;
private final TextContentService textContentService;
private final TaskExamCustomerAnswerMapper taskExamCustomerAnswerMapper; // 任务考试客户答案数据访问接口
private final TextContentService textContentService; // 文本内容服务接口
/**
* 构造方法，注入所需的 Mapper 和服务类。
*
* @param taskExamCustomerAnswerMapper 任务考试客户答案 Mapper
* @param textContentService 文本内容服务
*/
@Autowired
public TaskExamCustomerAnswerImpl(TaskExamCustomerAnswerMapper taskExamCustomerAnswerMapper, TextContentService textContentService) {
super(taskExamCustomerAnswerMapper);
super(taskExamCustomerAnswerMapper); // 调用父类构造方法
this.taskExamCustomerAnswerMapper = taskExamCustomerAnswerMapper;
this.textContentService = textContentService;
}
/**
* 插入或更新任务考试客户答案数据。
*
* @param examPaper 试卷对象
* @param examPaperAnswer 试卷答案对象
* @param now 当前时间
*/
@Override
public void insertOrUpdate(ExamPaper examPaper, ExamPaperAnswer examPaperAnswer, Date now) {
Integer taskId = examPaper.getTaskExamId();
Integer userId = examPaperAnswer.getCreateUser();
Integer taskId = examPaper.getTaskExamId(); // 获取任务考试 ID
Integer userId = examPaperAnswer.getCreateUser(); // 获取用户 ID
// 根据任务 ID 和用户 ID 查询任务考试客户答案记录
TaskExamCustomerAnswer taskExamCustomerAnswer = taskExamCustomerAnswerMapper.getByTUid(taskId, userId);
// 如果记录不存在，则进行插入操作
if (null == taskExamCustomerAnswer) {
taskExamCustomerAnswer = new TaskExamCustomerAnswer();
taskExamCustomerAnswer.setCreateTime(now);
taskExamCustomerAnswer.setCreateUser(userId);
taskExamCustomerAnswer.setTaskExamId(taskId);
List<TaskItemAnswerObject> taskItemAnswerObjects = Arrays.asList(new TaskItemAnswerObject(examPaperAnswer.getExamPaperId(), examPaperAnswer.getId(), examPaperAnswer.getStatus()));
taskExamCustomerAnswer.setCreateTime(now); // 设置创建时间
taskExamCustomerAnswer.setCreateUser(userId); // 设置创建用户 ID
taskExamCustomerAnswer.setTaskExamId(taskId); // 设置任务考试 ID
// 封装任务项答案对象列表
List<TaskItemAnswerObject> taskItemAnswerObjects = Arrays.asList(
new TaskItemAnswerObject(examPaperAnswer.getExamPaperId(), examPaperAnswer.getId(), examPaperAnswer.getStatus()));
// 创建文本内容并插入
TextContent textContent = textContentService.jsonConvertInsert(taskItemAnswerObjects, now, null);
textContentService.insertByFilter(textContent);
// 关联文本内容 ID 并插入记录
taskExamCustomerAnswer.setTextContentId(textContent.getId());
insertByFilter(taskExamCustomerAnswer);
} else {
TextContent textContent = textContentService.selectById(taskExamCustomerAnswer.getTextContentId());
} else { // 如果记录已存在，则进行更新操作
TextContent textContent = textContentService.selectById(taskExamCustomerAnswer.getTextContentId()); // 查询文本内容
// 解析文本内容中的任务项答案对象列表
List<TaskItemAnswerObject> taskItemAnswerObjects = JsonUtil.toJsonListObject(textContent.getContent(), TaskItemAnswerObject.class);
// 添加新的任务项答案对象
taskItemAnswerObjects.add(new TaskItemAnswerObject(examPaperAnswer.getExamPaperId(), examPaperAnswer.getId(), examPaperAnswer.getStatus()));
// 更新文本内容并保存
textContentService.jsonConvertUpdate(textContent, taskItemAnswerObjects, null);
textContentService.updateByIdFilter(textContent);
}
}
/**
* 根据任务 ID 和用户 ID 查询任务考试客户答案。
*
* @param tid 任务 ID
* @param uid 用户 ID
* @return 查询到的任务考试客户答案对象
*/
@Override
public TaskExamCustomerAnswer selectByTUid(Integer tid, Integer uid) {
return taskExamCustomerAnswerMapper.getByTUid(tid, uid);
}
/**
* 根据任务 ID 列表和用户 ID 查询任务考试客户答案。
*
* @param taskIds 任务 ID 列表
* @param uid 用户 ID
* @return 查询到的任务考试客户答案对象列表
*/
@Override
public List<TaskExamCustomerAnswer> selectByTUid(List<Integer> taskIds, Integer uid) {
return taskExamCustomerAnswerMapper.selectByTUid(taskIds, uid);

102
source/xzs/src/main/java/com/mindskip/xzs/service/impl/TaskExamServiceImpl.java
Unescape View File

@ -1,32 +1,3 @@
package com.mindskip.xzs.service.impl;
import com.mindskip.xzs.domain.ExamPaper;
import com.mindskip.xzs.domain.TaskExam;
import com.mindskip.xzs.domain.TextContent;
import com.mindskip.xzs.domain.User;
import com.mindskip.xzs.domain.task.TaskItemObject;
import com.mindskip.xzs.repository.ExamPaperMapper;
import com.mindskip.xzs.repository.TaskExamMapper;
import com.mindskip.xzs.service.TaskExamService;
import com.mindskip.xzs.service.TextContentService;
import com.mindskip.xzs.service.enums.ActionEnum;
import com.mindskip.xzs.utility.DateTimeUtil;
import com.mindskip.xzs.utility.JsonUtil;
import com.mindskip.xzs.utility.ModelMapperSingle;
import com.mindskip.xzs.viewmodel.admin.exam.ExamResponseVM;
import com.mindskip.xzs.viewmodel.admin.task.TaskPageRequestVM;
import com.mindskip.xzs.viewmodel.admin.task.TaskRequestVM;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.modelmapper.ModelMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
@Service
public class TaskExamServiceImpl extends BaseServiceImpl<TaskExam> implements TaskExamService {
@ -35,6 +6,7 @@ public class TaskExamServiceImpl extends BaseServiceImpl<TaskExam> implements Ta
private final TextContentService textContentService;
private final ExamPaperMapper examPaperMapper;
// 构造函数，注入依赖的服务
@Autowired
public TaskExamServiceImpl(TaskExamMapper taskExamMapper, TextContentService textContentService, ExamPaperMapper examPaperMapper) {
super(taskExamMapper);
@ -43,6 +15,7 @@ public class TaskExamServiceImpl extends BaseServiceImpl<TaskExam> implements Ta
this.examPaperMapper = examPaperMapper;
}
// 分页查询任务考试记录
@Override
public PageInfo<TaskExam> page(TaskPageRequestVM requestVM) {
return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc").doSelectPageInfo(() ->
@ -50,76 +23,79 @@ public class TaskExamServiceImpl extends BaseServiceImpl<TaskExam> implements Ta
);
}
// 添加或更新任务考试记录
@Override
@Transactional
public void edit(TaskRequestVM model, User user) {
ActionEnum actionEnum = (model.getId() == null) ? ActionEnum.ADD : ActionEnum.UPDATE;
ActionEnum actionEnum = (model.getId() == null) ? ActionEnum.ADD : ActionEnum.UPDATE; // 判断是添加还是更新
TaskExam taskExam = null;
if (actionEnum == ActionEnum.ADD) {
Date now = new Date();
taskExam = modelMapper.map(model, TaskExam.class);
taskExam.setCreateUser(user.getId());
taskExam.setCreateUserName(user.getUserName());
taskExam.setCreateTime(now);
taskExam.setDeleted(false);
Date now = new Date(); // 当前时间
taskExam = modelMapper.map(model, TaskExam.class); // 将请求模型映射为任务考试实体
taskExam.setCreateUser(user.getId()); // 设置创建人ID
taskExam.setCreateUserName(user.getUserName()); // 设置创建人姓名
taskExam.setCreateTime(now); // 设置创建时间
taskExam.setDeleted(false); // 设置未删除状态
//保存任务结构
// 保存任务结构
TextContent textContent = textContentService.jsonConvertInsert(model.getPaperItems(), now, p -> {
TaskItemObject taskItemObject = new TaskItemObject();
taskItemObject.setExamPaperId(p.getId());
taskItemObject.setExamPaperName(p.getName());
taskItemObject.setExamPaperId(p.getId()); // 设置试卷ID
taskItemObject.setExamPaperName(p.getName()); // 设置试卷名称
return taskItemObject;
});
textContentService.insertByFilter(textContent);
taskExam.setFrameTextContentId(textContent.getId());
taskExamMapper.insertSelective(taskExam);
textContentService.insertByFilter(textContent); // 插入任务文本内容
taskExam.setFrameTextContentId(textContent.getId()); // 设置文本内容ID
taskExamMapper.insertSelective(taskExam); // 插入任务考试记录
} else {
taskExam = taskExamMapper.selectByPrimaryKey(model.getId());
modelMapper.map(model, taskExam);
taskExam = taskExamMapper.selectByPrimaryKey(model.getId()); // 查询已存在的任务考试记录
modelMapper.map(model, taskExam); // 将请求模型更新到任务考试实体
TextContent textContent = textContentService.selectById(taskExam.getFrameTextContentId());
//清空试卷任务的试卷Id，后面会统一设置
TextContent textContent = textContentService.selectById(taskExam.getFrameTextContentId()); // 获取任务的文本内容
// 清空试卷任务中的试卷ID，之后会统一设置
List<Integer> paperIds = JsonUtil.toJsonListObject(textContent.getContent(), TaskItemObject.class)
.stream()
.map(d -> d.getExamPaperId())
.collect(Collectors.toList());
examPaperMapper.clearTaskPaper(paperIds);
examPaperMapper.clearTaskPaper(paperIds); // 清空试卷任务中的试卷ID
//更新任务结构
// 更新任务结构
textContentService.jsonConvertUpdate(textContent, model.getPaperItems(), p -> {
TaskItemObject taskItemObject = new TaskItemObject();
taskItemObject.setExamPaperId(p.getId());
taskItemObject.setExamPaperName(p.getName());
taskItemObject.setExamPaperId(p.getId()); // 设置试卷ID
taskItemObject.setExamPaperName(p.getName()); // 设置试卷名称
return taskItemObject;
});
textContentService.updateByIdFilter(textContent);
taskExamMapper.updateByPrimaryKeySelective(taskExam);
textContentService.updateByIdFilter(textContent); // 更新任务文本内容
taskExamMapper.updateByPrimaryKeySelective(taskExam); // 更新任务考试记录
}
//更新试卷的taskId
// 更新试卷的任务ID
List<Integer> paperIds = model.getPaperItems().stream().map(d -> d.getId()).collect(Collectors.toList());
examPaperMapper.updateTaskPaper(taskExam.getId(), paperIds);
model.setId(taskExam.getId());
examPaperMapper.updateTaskPaper(taskExam.getId(), paperIds); // 更新试卷与任务考试的关联
model.setId(taskExam.getId()); // 设置任务考试ID
}
// 根据任务考试ID获取任务考试信息
@Override
public TaskRequestVM taskExamToVM(Integer id) {
TaskExam taskExam = taskExamMapper.selectByPrimaryKey(id);
TaskRequestVM vm = modelMapper.map(taskExam, TaskRequestVM.class);
TextContent textContent = textContentService.selectById(taskExam.getFrameTextContentId());
TaskExam taskExam = taskExamMapper.selectByPrimaryKey(id); // 查询任务考试
TaskRequestVM vm = modelMapper.map(taskExam, TaskRequestVM.class); // 将任务考试映射为任务请求视图模型
TextContent textContent = textContentService.selectById(taskExam.getFrameTextContentId()); // 获取任务考试的文本内容
List<ExamResponseVM> examResponseVMS = JsonUtil.toJsonListObject(textContent.getContent(), TaskItemObject.class).stream().map(tk -> {
ExamPaper examPaper = examPaperMapper.selectByPrimaryKey(tk.getExamPaperId());
ExamResponseVM examResponseVM = modelMapper.map(examPaper, ExamResponseVM.class);
examResponseVM.setCreateTime(DateTimeUtil.dateFormat(examPaper.getCreateTime()));
ExamPaper examPaper = examPaperMapper.selectByPrimaryKey(tk.getExamPaperId()); // 获取试卷信息
ExamResponseVM examResponseVM = modelMapper.map(examPaper, ExamResponseVM.class); // 映射试卷为响应视图模型
examResponseVM.setCreateTime(DateTimeUtil.dateFormat(examPaper.getCreateTime())); // 格式化创建时间
return examResponseVM;
}).collect(Collectors.toList());
vm.setPaperItems(examResponseVMS);
vm.setPaperItems(examResponseVMS); // 设置试卷项目
return vm;
}
// 根据年级等级获取任务考试记录
@Override
public List<TaskExam> getByGradeLevel(Integer gradeLevel) {
return taskExamMapper.getByGradeLevel(gradeLevel);
return taskExamMapper.getByGradeLevel(gradeLevel); // 查询特定年级等级的任务考试
}
}

34
source/xzs/src/main/java/com/mindskip/xzs/service/impl/TextContentServiceImpl.java
Unescape View File

@ -1,69 +1,65 @@
package com.mindskip.xzs.service.impl;
import com.mindskip.xzs.domain.TextContent;
import com.mindskip.xzs.repository.TextContentMapper;
import com.mindskip.xzs.service.TextContentService;
import com.mindskip.xzs.utility.JsonUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
@Service
public class TextContentServiceImpl extends BaseServiceImpl<TextContent> implements TextContentService {
private final TextContentMapper textContentMapper;
// 构造函数，注入依赖的TextContentMapper
@Autowired
public TextContentServiceImpl(TextContentMapper textContentMapper) {
super(textContentMapper);
this.textContentMapper = textContentMapper;
}
// 根据ID查询TextContent记录
@Override
public TextContent selectById(Integer id) {
return super.selectById(id);
return super.selectById(id); // 调用父类的selectById方法查询记录
}
// 插入TextContent记录，并通过过滤条件进行插入
@Override
public int insertByFilter(TextContent record) {
return super.insertByFilter(record);
return super.insertByFilter(record); // 调用父类的insertByFilter方法插入记录
}
// 更新TextContent记录，并通过过滤条件进行更新
@Override
public int updateByIdFilter(TextContent record) {
return super.updateByIdFilter(record);
return super.updateByIdFilter(record); // 调用父类的updateByIdFilter方法更新记录
}
// 将一个列表的内容转换为TextContent进行插入
@Override
public <T, R> TextContent jsonConvertInsert(List<T> list, Date now, Function<? super T, ? extends R> mapper) {
String frameTextContent = null;
if (null == mapper) {
// 如果mapper为空，则直接将列表转换为JSON字符串
frameTextContent = JsonUtil.toJsonStr(list);
} else {
// 如果mapper不为空，则先将列表中的每一项通过mapper函数进行转换，再将转换后的列表转为JSON字符串
List<R> mapList = list.stream().map(mapper).collect(Collectors.toList());
frameTextContent = JsonUtil.toJsonStr(mapList);
}
// 创建TextContent对象并返回
TextContent textContent = new TextContent(frameTextContent, now);
return textContent;
}
// 将一个列表的内容转换为TextContent并更新现有记录
@Override
public <T, R> TextContent jsonConvertUpdate(TextContent textContent, List<T> list, Function<? super T, ? extends R> mapper) {
String frameTextContent = null;
if (null == mapper) {
// 如果mapper为空，则直接将列表转换为JSON字符串
frameTextContent = JsonUtil.toJsonStr(list);
} else {
// 如果mapper不为空，则先将列表中的每一项通过mapper函数进行转换，再将转换后的列表转为JSON字符串
List<R> mapList = list.stream().map(mapper).collect(Collectors.toList());
frameTextContent = JsonUtil.toJsonStr(mapList);
}
// 更新TextContent对象的内容并返回
textContent.setContent(frameTextContent);
return textContent;
}
}

32
source/xzs/src/main/java/com/mindskip/xzs/service/impl/UserEventLogServiceImpl.java
Unescape View File

@ -1,50 +1,44 @@
package com.mindskip.xzs.service.impl;
import com.mindskip.xzs.domain.UserEventLog;
import com.mindskip.xzs.domain.other.KeyValue;
import com.mindskip.xzs.repository.UserEventLogMapper;
import com.mindskip.xzs.service.UserEventLogService;
import com.mindskip.xzs.utility.DateTimeUtil;
import com.mindskip.xzs.viewmodel.admin.user.UserEventPageRequestVM;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
@Service
public class UserEventLogServiceImpl extends BaseServiceImpl<UserEventLog> implements UserEventLogService {
private final UserEventLogMapper userEventLogMapper;
// 构造函数，注入依赖的UserEventLogMapper
@Autowired
public UserEventLogServiceImpl(UserEventLogMapper userEventLogMapper) {
super(userEventLogMapper);
this.userEventLogMapper = userEventLogMapper;
}
// 根据用户ID查询该用户的所有事件日志
@Override
public List<UserEventLog> getUserEventLogByUserId(Integer id) {
return userEventLogMapper.getUserEventLogByUserId(id);
return userEventLogMapper.getUserEventLogByUserId(id); // 调用Mapper查询事件日志
}
// 分页查询用户事件日志
@Override
public PageInfo<UserEventLog> page(UserEventPageRequestVM requestVM) {
// 使用PageHelper进行分页查询，按照id降序排列
return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc").doSelectPageInfo(() ->
userEventLogMapper.page(requestVM)
);
}
// 查询当前月份内的事件日志统计数量
@Override
public List<Integer> selectMothCount() {
// 获取当前月的开始时间和结束时间
Date startTime = DateTimeUtil.getMonthStartDay();
Date endTime = DateTimeUtil.getMonthEndDay();
// 获取当前月内的事件日志数量统计
List<KeyValue> mouthCount = userEventLogMapper.selectCountByDate(startTime, endTime);
// 获取从月初到当前的日期格式列表
List<String> mothStartToNowFormat = DateTimeUtil.MothStartToNowFormat();
// 对每一天的数据进行映射，如果没有找到数据则返回0
return mothStartToNowFormat.stream().map(md -> {
KeyValue keyValue = mouthCount.stream().filter(kv -> kv.getName().equals(md)).findAny().orElse(null);
return null == keyValue ? 0 : keyValue.getValue();

82
source/xzs/src/main/java/com/mindskip/xzs/service/impl/UserServiceImpl.java
Unescape View File

@ -1,87 +1,76 @@
package com.mindskip.xzs.service.impl;
import com.mindskip.xzs.domain.other.KeyValue;
import com.mindskip.xzs.exception.BusinessException;
import com.mindskip.xzs.domain.User;
import com.mindskip.xzs.event.OnRegistrationCompleteEvent;
import com.mindskip.xzs.repository.UserMapper;
import com.mindskip.xzs.service.UserService;
import com.mindskip.xzs.viewmodel.admin.user.UserPageRequestVM;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Service
public class UserServiceImpl extends BaseServiceImpl<User> implements UserService {
private final UserMapper userMapper;
private final ApplicationEventPublisher eventPublisher;
// 构造函数，注入UserMapper和事件发布器ApplicationEventPublisher
@Autowired
public UserServiceImpl(UserMapper userMapper, ApplicationEventPublisher eventPublisher) {
super(userMapper);
super(userMapper); // 调用父类构造方法，传入UserMapper
this.userMapper = userMapper;
this.eventPublisher = eventPublisher;
}
// 获取所有用户
@Override
public List<User> getUsers() {
return userMapper.getAllUser();
}
// 根据ID获取用户
@Override
public User getUserById(Integer id) {
return userMapper.getUserById(id);
}
// 根据用户名获取用户
@Override
public User getUserByUserName(String username) {
return userMapper.getUserByUserName(username);
}
// 通过过滤条件插入用户
@Override
public int insertByFilter(User record) {
return super.insertByFilter(record);
return super.insertByFilter(record); // 调用父类的insertByFilter方法
}
// 通过ID更新用户信息
@Override
public int updateByIdFilter(User record) {
return super.updateByIdFilter(record);
return super.updateByIdFilter(record); // 调用父类的updateByIdFilter方法
}
// 根据ID更新用户
@Override
public int updateById(User record) {
return super.updateById(record);
return super.updateById(record); // 调用父类的updateById方法
}
// 根据用户名和密码获取用户
@Override
public User getUserByUserNamePwd(String username, String pwd) {
return userMapper.getUserByUserNamePwd(username, pwd);
}
// 根据UUID获取用户
@Override
public User getUserByUuid(String uuid) {
return userMapper.getUserByUuid(uuid);
}
// 分页查询用户列表
@Override
public List<User> userPageList(String name, Integer pageIndex, Integer pageSize) {
Map<String, Object> map = new HashMap<>(3);
map.put("name", name);
map.put("offset", ((int) pageIndex) * pageSize);
map.put("limit", pageSize);
map.put("offset", ((int) pageIndex) * pageSize); // 计算偏移量
map.put("limit", pageSize); // 设置每页大小
return userMapper.userPageList(map);
}
// 查询用户分页的总数
@Override
public Integer userPageCount(String name) {
Map<String, Object> map = new HashMap<>(1);
@ -89,7 +78,7 @@ public class UserServiceImpl extends BaseServiceImpl<User> implements UserServic
return userMapper.userPageCount(map);
}
// 使用PageHelper分页查询用户
@Override
public PageInfo<User> userPage(UserPageRequestVM requestVM) {
return PageHelper.startPage(requestVM.getPageIndex(), requestVM.getPageSize(), "id desc").doSelectPageInfo(() ->
@ -97,64 +86,73 @@ public class UserServiceImpl extends BaseServiceImpl<User> implements UserServic
);
}
// 注册用户，并触发注册完成事件
@Override
public void insertUser(User user) {
userMapper.insertSelective(user);
eventPublisher.publishEvent(new OnRegistrationCompleteEvent(user));
userMapper.insertSelective(user); // 插入用户
eventPublisher.publishEvent(new OnRegistrationCompleteEvent(user)); // 触发注册完成事件
}
// 批量插入用户，并在插入后抛出业务异常来测试事务回滚
@Override
@Transactional(rollbackFor = BusinessException.class)
public void insertUsers(List<User> users) {
userMapper.insertUsers(users);
throw new BusinessException("test BusinessException roll back");
userMapper.insertUsers(users); // 批量插入用户
throw new BusinessException("test BusinessException roll back"); // 抛出业务异常，测试事务回滚
}
// 更新用户信息
@Override
public void updateUser(User user) {
userMapper.updateUser(user);
}
// 批量更新多个用户的年龄
@Override
public void updateUsersAge(Integer age, List<Integer> ids) {
Map<String, Object> map = new HashMap<>(2);
map.put("idslist", ids);
map.put("age", age);
userMapper.updateUsersAge(map);
map.put("idslist", ids); // 用户ID列表
map.put("age", age); // 要更新的年龄
userMapper.updateUsersAge(map); // 执行更新操作
}
// 根据用户ID列表删除用户
@Override
public void deleteUserByIds(List<Integer> ids) {
userMapper.deleteUsersByIds(ids);
userMapper.deleteUsersByIds(ids); // 删除用户
}
// 查询所有用户的总数
@Override
public Integer selectAllCount() {
return userMapper.selectAllCount();
return userMapper.selectAllCount(); // 获取用户总数
}
// 根据用户名查询用户的键值对信息
@Override
public List<KeyValue> selectByUserName(String userName) {
return userMapper.selectByUserName(userName);
}
// 根据用户ID列表查询用户
@Override
public List<User> selectByIds(List<Integer> ids) {
return userMapper.selectByIds(ids);
}
// 根据微信OpenId查询用户
@Override
public User selectByWxOpenId(String wxOpenId) {
return userMapper.selectByWxOpenId(wxOpenId);
}
// 更新用户的头像图片路径
@Override
@Transactional
public void changePicture(User user, String imagePath) {
User changePictureUser = new User();
changePictureUser.setId(user.getId());
changePictureUser.setImagePath(imagePath);
userMapper.updateByPrimaryKeySelective(changePictureUser);
changePictureUser.setId(user.getId()); // 设置要更新的用户ID
changePictureUser.setImagePath(imagePath); // 设置新的图片路径
userMapper.updateByPrimaryKeySelective(changePictureUser); // 执行更新操作
}
}

72
source/xzs/src/main/java/com/mindskip/xzs/service/impl/UserTokenServiceImpl.java
Unescape View File

@ -1,19 +1,3 @@
package com.mindskip.xzs.service.impl;
import com.mindskip.xzs.configuration.property.SystemConfig;
import com.mindskip.xzs.domain.User;
import com.mindskip.xzs.domain.UserToken;
import com.mindskip.xzs.repository.UserTokenMapper;
import com.mindskip.xzs.service.UserService;
import com.mindskip.xzs.service.UserTokenService;
import com.mindskip.xzs.utility.DateTimeUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.Date;
import java.util.UUID;
@Service
public class UserTokenServiceImpl extends BaseServiceImpl<UserToken> implements UserTokenService {
@ -21,61 +5,65 @@ public class UserTokenServiceImpl extends BaseServiceImpl<UserToken> implements
private final UserService userService;
private final SystemConfig systemConfig;
// 构造函数，注入UserTokenMapper、UserService和系统配置
@Autowired
public UserTokenServiceImpl(UserTokenMapper userTokenMapper, UserService userService, SystemConfig systemConfig) {
super(userTokenMapper);
super(userTokenMapper); // 调用父类构造方法，传入UserTokenMapper
this.userTokenMapper = userTokenMapper;
this.userService = userService;
this.systemConfig = systemConfig;
}
// 绑定用户与微信账号
@Override
@Transactional
public UserToken bind(User user) {
user.setModifyTime(new Date());
userService.updateByIdFilter(user);
return insertUserToken(user);
user.setModifyTime(new Date()); // 设置用户修改时间
userService.updateByIdFilter(user); // 更新用户信息
return insertUserToken(user); // 生成并返回用户Token
}
// 检查是否绑定了微信账号
@Override
public UserToken checkBind(String openId) {
User user = userService.selectByWxOpenId(openId);
User user = userService.selectByWxOpenId(openId); // 根据微信OpenId查询用户
if (null != user) {
return insertUserToken(user);
return insertUserToken(user); // 如果用户存在，生成并返回用户Token
}
return null;
return null; // 如果用户不存在，返回null
}
// 根据Token获取UserToken
@Override
public UserToken getToken(String token) {
return userTokenMapper.getToken(token);
return userTokenMapper.getToken(token); // 根据Token从数据库查询UserToken
}
// 生成用户Token并保存到数据库
@Override
public UserToken insertUserToken(User user) {
Date startTime = new Date();
Date endTime = DateTimeUtil.addDuration(startTime, systemConfig.getWx().getTokenToLive());
Date startTime = new Date(); // 当前时间作为Token的创建时间
Date endTime = DateTimeUtil.addDuration(startTime, systemConfig.getWx().getTokenToLive()); // 计算Token的过期时间
UserToken userToken = new UserToken();
userToken.setToken(UUID.randomUUID().toString());
userToken.setUserId(user.getId());
userToken.setWxOpenId(user.getWxOpenId());
userToken.setCreateTime(startTime);
userToken.setEndTime(endTime);
userToken.setUserName(user.getUserName());
userService.updateByIdFilter(user);
userTokenMapper.insertSelective(userToken);
return userToken;
userToken.setToken(UUID.randomUUID().toString()); // 生成一个唯一的Token
userToken.setUserId(user.getId()); // 设置用户ID
userToken.setWxOpenId(user.getWxOpenId()); // 设置微信OpenId
userToken.setCreateTime(startTime); // 设置Token的创建时间
userToken.setEndTime(endTime); // 设置Token的过期时间
userToken.setUserName(user.getUserName()); // 设置用户名
userService.updateByIdFilter(user); // 更新用户信息（例如绑定微信账号）
userTokenMapper.insertSelective(userToken); // 将Token信息保存到数据库
return userToken; // 返回生成的Token
}
// 解除用户与微信账号的绑定
@Override
public void unBind(UserToken userToken) {
User user = userService.selectById(userToken.getUserId());
user.setModifyTime(new Date());
user.setWxOpenId(null);
userService.updateById(user);
userTokenMapper.deleteByPrimaryKey(userToken.getId());
User user = userService.selectById(userToken.getUserId()); // 根据UserToken的用户ID查询用户
user.setModifyTime(new Date()); // 设置用户修改时间
user.setWxOpenId(null); // 清空微信OpenId，解除绑定
userService.updateById(user); // 更新用户信息
userTokenMapper.deleteByPrimaryKey(userToken.getId()); // 删除UserToken记录
}
}

Write Preview
Loading…
Cancel
Save