王菲的提交

master
wf 1 year ago committed by 7alpaca7
parent 7acf74ac13
commit 5ddf6f80d3

@ -1,40 +1,27 @@
package com.mindskip.xzs.controller;
import com.mindskip.xzs.base.SystemCode;
import org.springframework.boot.autoconfigure.web.ErrorProperties;
import org.springframework.boot.autoconfigure.web.servlet.error.BasicErrorController;
import org.springframework.boot.web.servlet.error.DefaultErrorAttributes;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;
@RestController
public class ErrorController extends BasicErrorController {
// 错误路径常量
private static final String PATH = "/error";
// 构造函数,调用父类构造器初始化错误属性和配置
public ErrorController() {
super(new DefaultErrorAttributes(), new ErrorProperties());
}
@RequestMapping(produces = {MediaType.APPLICATION_JSON_VALUE})
@ResponseBody
// 错误处理方法返回JSON格式的错误信息
@RequestMapping(produces = {MediaType.APPLICATION_JSON_VALUE}) // 设置请求返回的媒体类型为JSON
@ResponseBody // 方法返回内容直接作为响应体
public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
Map<String, Object> error = new HashMap<>(2);
error.put("code", SystemCode.InnerError.getCode());
error.put("message", SystemCode.InnerError.getMessage());
return new ResponseEntity<>(error, HttpStatus.OK);
Map<String, Object> error = new HashMap<>(2); // 创建一个Map用于存储错误信息
error.put("code", SystemCode.InnerError.getCode()); // 错误代码,使用系统代码中的内部错误
error.put("message", SystemCode.InnerError.getMessage()); // 错误信息,使用系统代码中的错误信息
return new ResponseEntity<>(error, HttpStatus.OK); // 返回带有错误信息的响应HTTP状态码为200 OK
}
// 重写getErrorPath方法返回错误路径
@Override
public String getErrorPath() {
return PATH;
return PATH; // 返回错误处理的路径"/error"
}
}

@ -23,10 +23,11 @@ import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
@RestController("StudentDashboardController")
@RequestMapping(value = "/api/student/dashboard")
@RestController("StudentDashboardController") // 将该类标记为RestController用于处理HTTP请求
@RequestMapping(value = "/api/student/dashboard") // 所有请求的基础路径
public class DashboardController extends BaseApiController {
// 注入的服务,用于处理业务逻辑
private final UserService userService;
private final ExamPaperService examPaperService;
private final QuestionService questionService;
@ -34,6 +35,7 @@ public class DashboardController extends BaseApiController {
private final TaskExamCustomerAnswerService taskExamCustomerAnswerService;
private final TextContentService textContentService;
// 构造函数注入,用于初始化服务依赖
@Autowired
public DashboardController(UserService userService, ExamPaperService examPaperService, QuestionService questionService, TaskExamService taskExamService, TaskExamCustomerAnswerService taskExamCustomerAnswerService, TextContentService textContentService) {
this.userService = userService;
@ -44,83 +46,92 @@ public class DashboardController extends BaseApiController {
this.textContentService = textContentService;
}
// 处理POST请求返回学生的首页信息
@RequestMapping(value = "/index", method = RequestMethod.POST)
public RestResponse<IndexVM> index() {
IndexVM indexVM = new IndexVM();
User user = getCurrentUser();
IndexVM indexVM = new IndexVM(); // 创建IndexVM对象存储返回的首页信息
User user = getCurrentUser(); // 获取当前登录的学生用户
// 设置固定试卷的筛选条件
PaperFilter fixedPaperFilter = new PaperFilter();
fixedPaperFilter.setGradeLevel(user.getUserLevel());
fixedPaperFilter.setExamPaperType(ExamPaperTypeEnum.Fixed.getCode());
indexVM.setFixedPaper(examPaperService.indexPaper(fixedPaperFilter));
fixedPaperFilter.setGradeLevel(user.getUserLevel()); // 设置年级
fixedPaperFilter.setExamPaperType(ExamPaperTypeEnum.Fixed.getCode()); // 设置试卷类型为固定试卷
indexVM.setFixedPaper(examPaperService.indexPaper(fixedPaperFilter)); // 获取固定试卷列表并设置到indexVM
// 设置限时试卷的筛选条件
PaperFilter timeLimitPaperFilter = new PaperFilter();
timeLimitPaperFilter.setDateTime(new Date());
timeLimitPaperFilter.setGradeLevel(user.getUserLevel());
timeLimitPaperFilter.setExamPaperType(ExamPaperTypeEnum.TimeLimit.getCode());
timeLimitPaperFilter.setDateTime(new Date()); // 当前时间
timeLimitPaperFilter.setGradeLevel(user.getUserLevel()); // 设置年级
timeLimitPaperFilter.setExamPaperType(ExamPaperTypeEnum.TimeLimit.getCode()); // 设置试卷类型为限时试卷
// 获取限时试卷列表
List<PaperInfo> limitPaper = examPaperService.indexPaper(timeLimitPaperFilter);
List<PaperInfoVM> paperInfoVMS = limitPaper.stream().map(d -> {
PaperInfoVM vm = modelMapper.map(d, PaperInfoVM.class);
vm.setStartTime(DateTimeUtil.dateFormat(d.getLimitStartTime()));
vm.setEndTime(DateTimeUtil.dateFormat(d.getLimitEndTime()));
PaperInfoVM vm = modelMapper.map(d, PaperInfoVM.class); // 将PaperInfo转换为PaperInfoVM
vm.setStartTime(DateTimeUtil.dateFormat(d.getLimitStartTime())); // 格式化开始时间
vm.setEndTime(DateTimeUtil.dateFormat(d.getLimitEndTime())); // 格式化结束时间
return vm;
}).collect(Collectors.toList());
indexVM.setTimeLimitPaper(paperInfoVMS);
return RestResponse.ok(indexVM);
}
}).collect(Collectors.toList()); // 收集并转换成列表
indexVM.setTimeLimitPaper(paperInfoVMS); // 设置限时试卷到indexVM
return RestResponse.ok(indexVM); // 返回首页信息
}
// 处理POST请求返回学生的任务列表
@RequestMapping(value = "/task", method = RequestMethod.POST)
public RestResponse<List<TaskItemVm>> task() {
User user = getCurrentUser();
List<TaskExam> taskExams = taskExamService.getByGradeLevel(user.getUserLevel());
if (taskExams.size() == 0) {
User user = getCurrentUser(); // 获取当前登录的学生用户
List<TaskExam> taskExams = taskExamService.getByGradeLevel(user.getUserLevel()); // 获取与学生年级匹配的任务试卷
if (taskExams.size() == 0) { // 如果没有任务试卷,则返回空列表
return RestResponse.ok(new ArrayList<>());
}
List<Integer> tIds = taskExams.stream().map(taskExam -> taskExam.getId()).collect(Collectors.toList());
List<TaskExamCustomerAnswer> taskExamCustomerAnswers = taskExamCustomerAnswerService.selectByTUid(tIds, user.getId());
List<Integer> tIds = taskExams.stream().map(taskExam -> taskExam.getId()).collect(Collectors.toList()); // 获取任务试卷的ID列表
List<TaskExamCustomerAnswer> taskExamCustomerAnswers = taskExamCustomerAnswerService.selectByTUid(tIds, user.getId()); // 获取学生的任务答案
// 将任务试卷和学生答案映射为TaskItemVm对象
List<TaskItemVm> vm = taskExams.stream().map(t -> {
TaskItemVm itemVm = new TaskItemVm();
itemVm.setId(t.getId());
itemVm.setTitle(t.getTitle());
itemVm.setId(t.getId()); // 设置任务试卷ID
itemVm.setTitle(t.getTitle()); // 设置任务试卷标题
TaskExamCustomerAnswer taskExamCustomerAnswer = taskExamCustomerAnswers.stream()
.filter(tc -> tc.getTaskExamId().equals(t.getId())).findFirst().orElse(null);
List<TaskItemPaperVm> paperItemVMS = getTaskItemPaperVm(t.getFrameTextContentId(), taskExamCustomerAnswer);
itemVm.setPaperItems(paperItemVMS);
.filter(tc -> tc.getTaskExamId().equals(t.getId())).findFirst().orElse(null); // 获取学生的答案
List<TaskItemPaperVm> paperItemVMS = getTaskItemPaperVm(t.getFrameTextContentId(), taskExamCustomerAnswer); // 获取任务试卷的题目项
itemVm.setPaperItems(paperItemVMS); // 设置题目项到TaskItemVm
return itemVm;
}).collect(Collectors.toList());
return RestResponse.ok(vm);
}
}).collect(Collectors.toList()); // 收集并转换成列表
return RestResponse.ok(vm); // 返回任务列表
}
// 根据任务框架ID和学生答案获取任务试卷的题目项
private List<TaskItemPaperVm> getTaskItemPaperVm(Integer tFrameId, TaskExamCustomerAnswer taskExamCustomerAnswers) {
TextContent textContent = textContentService.selectById(tFrameId);
List<TaskItemObject> paperItems = JsonUtil.toJsonListObject(textContent.getContent(), TaskItemObject.class);
TextContent textContent = textContentService.selectById(tFrameId); // 获取任务框架的文本内容
List<TaskItemObject> paperItems = JsonUtil.toJsonListObject(textContent.getContent(), TaskItemObject.class); // 解析任务框架内容为TaskItemObject列表
// 如果有学生答案解析学生答案为TaskItemAnswerObject列表
List<TaskItemAnswerObject> answerPaperItems = null;
if (null != taskExamCustomerAnswers) {
TextContent answerTextContent = textContentService.selectById(taskExamCustomerAnswers.getTextContentId());
answerPaperItems = JsonUtil.toJsonListObject(answerTextContent.getContent(), TaskItemAnswerObject.class);
TextContent answerTextContent = textContentService.selectById(taskExamCustomerAnswers.getTextContentId()); // 获取答案文本内容
answerPaperItems = JsonUtil.toJsonListObject(answerTextContent.getContent(), TaskItemAnswerObject.class); // 解析学生答案内容
}
List<TaskItemAnswerObject> finalAnswerPaperItems = answerPaperItems;
// 将题目项和学生答案映射为TaskItemPaperVm对象
return paperItems.stream().map(p -> {
TaskItemPaperVm ivm = new TaskItemPaperVm();
ivm.setExamPaperId(p.getExamPaperId());
ivm.setExamPaperName(p.getExamPaperName());
ivm.setExamPaperId(p.getExamPaperId()); // 设置试卷ID
ivm.setExamPaperName(p.getExamPaperName()); // 设置试卷名称
if (null != finalAnswerPaperItems) {
finalAnswerPaperItems.stream()
.filter(a -> a.getExamPaperId().equals(p.getExamPaperId()))
.filter(a -> a.getExamPaperId().equals(p.getExamPaperId())) // 匹配学生答案
.findFirst()
.ifPresent(a -> {
ivm.setExamPaperAnswerId(a.getExamPaperAnswerId());
ivm.setStatus(a.getStatus());
ivm.setExamPaperAnswerId(a.getExamPaperAnswerId()); // 设置学生答案ID
ivm.setStatus(a.getStatus()); // 设置学生答案状态
});
}
return ivm;
}
).collect(Collectors.toList());
).collect(Collectors.toList()); // 收集并转换成列表
}
}

@ -1,6 +1,5 @@
package com.mindskip.xzs.controller.student;
import com.mindskip.xzs.base.BaseApiController;
import com.mindskip.xzs.base.RestResponse;
import com.mindskip.xzs.domain.Subject;
@ -14,34 +13,37 @@ import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.stream.Collectors;
@RestController("StudentEducationController")
@RequestMapping(value = "/api/student/education")
@RestController("StudentEducationController") // 将该类标记为RestController用于处理学生相关的HTTP请求
@RequestMapping(value = "/api/student/education") // 所有请求的基础路径
public class EducationController extends BaseApiController {
private final SubjectService subjectService;
private final SubjectService subjectService; // 注入的学科服务,用于处理与学科相关的业务逻辑
// 构造函数注入,用于初始化学科服务
@Autowired
public EducationController(SubjectService subjectService) {
this.subjectService = subjectService;
}
// 处理POST请求返回学生的学科列表
@RequestMapping(value = "/subject/list", method = RequestMethod.POST)
public RestResponse<List<SubjectVM>> list() {
User user = getCurrentUser();
List<Subject> subjects = subjectService.getSubjectByLevel(user.getUserLevel());
User user = getCurrentUser(); // 获取当前登录的学生用户
List<Subject> subjects = subjectService.getSubjectByLevel(user.getUserLevel()); // 获取根据学生年级筛选的学科列表
List<SubjectVM> subjectVMS = subjects.stream().map(d -> {
SubjectVM subjectVM = modelMapper.map(d, SubjectVM.class);
subjectVM.setId(String.valueOf(d.getId()));
SubjectVM subjectVM = modelMapper.map(d, SubjectVM.class); // 将Subject对象转换为SubjectVM对象
subjectVM.setId(String.valueOf(d.getId())); // 设置学科的ID
return subjectVM;
}).collect(Collectors.toList());
return RestResponse.ok(subjectVMS);
}).collect(Collectors.toList()); // 收集并转换成列表
return RestResponse.ok(subjectVMS); // 返回学科列表
}
// 处理POST请求根据学科ID返回学科编辑请求的视图模型
@RequestMapping(value = "/subject/select/{id}", method = RequestMethod.POST)
public RestResponse<SubjectEditRequestVM> select(@PathVariable Integer id) {
Subject subject = subjectService.selectById(id);
SubjectEditRequestVM vm = modelMapper.map(subject, SubjectEditRequestVM.class);
return RestResponse.ok(vm);
Subject subject = subjectService.selectById(id); // 根据学科ID获取学科信息
SubjectEditRequestVM vm = modelMapper.map(subject, SubjectEditRequestVM.class); // 将Subject对象转换为SubjectEditRequestVM对象
return RestResponse.ok(vm); // 返回学科编辑视图模型
}
}

@ -25,15 +25,16 @@ import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.Date;
@RestController("StudentExamPaperAnswerController")
@RequestMapping(value = "/api/student/exampaper/answer")
@RestController("StudentExamPaperAnswerController") // 标记为学生试卷答题控制器
@RequestMapping(value = "/api/student/exampaper/answer") // 基础请求路径
public class ExamPaperAnswerController extends BaseApiController {
private final ExamPaperAnswerService examPaperAnswerService;
private final ExamPaperService examPaperService;
private final SubjectService subjectService;
private final ApplicationEventPublisher eventPublisher;
private final ExamPaperAnswerService examPaperAnswerService; // 注入试卷答题服务
private final ExamPaperService examPaperService; // 注入试卷服务
private final SubjectService subjectService; // 注入学科服务
private final ApplicationEventPublisher eventPublisher; // 事件发布器
// 构造函数注入依赖的服务
@Autowired
public ExamPaperAnswerController(ExamPaperAnswerService examPaperAnswerService, ExamPaperService examPaperService, SubjectService subjectService, ApplicationEventPublisher eventPublisher) {
this.examPaperAnswerService = examPaperAnswerService;
@ -42,78 +43,79 @@ public class ExamPaperAnswerController extends BaseApiController {
this.eventPublisher = eventPublisher;
}
// 处理学生试卷答题分页列表的请求
@RequestMapping(value = "/pageList", method = RequestMethod.POST)
public RestResponse<PageInfo<ExamPaperAnswerPageResponseVM>> pageList(@RequestBody @Valid ExamPaperAnswerPageVM model) {
model.setCreateUser(getCurrentUser().getId());
PageInfo<ExamPaperAnswer> pageInfo = examPaperAnswerService.studentPage(model);
PageInfo<ExamPaperAnswerPageResponseVM> page = PageInfoHelper.copyMap(pageInfo, e -> {
model.setCreateUser(getCurrentUser().getId()); // 设置当前用户ID
PageInfo<ExamPaperAnswer> pageInfo = examPaperAnswerService.studentPage(model); // 获取分页数据
PageInfo<ExamPaperAnswerPageResponseVM> page = PageInfoHelper.copyMap(pageInfo, e -> { // 将分页数据转换为视图模型
ExamPaperAnswerPageResponseVM vm = modelMapper.map(e, ExamPaperAnswerPageResponseVM.class);
Subject subject = subjectService.selectById(vm.getSubjectId());
vm.setDoTime(ExamUtil.secondToVM(e.getDoTime()));
vm.setSystemScore(ExamUtil.scoreToVM(e.getSystemScore()));
vm.setUserScore(ExamUtil.scoreToVM(e.getUserScore()));
vm.setPaperScore(ExamUtil.scoreToVM(e.getPaperScore()));
vm.setSubjectName(subject.getName());
vm.setCreateTime(DateTimeUtil.dateFormat(e.getCreateTime()));
Subject subject = subjectService.selectById(vm.getSubjectId()); // 获取学科信息
vm.setDoTime(ExamUtil.secondToVM(e.getDoTime())); // 转换答题时间
vm.setSystemScore(ExamUtil.scoreToVM(e.getSystemScore())); // 转换系统得分
vm.setUserScore(ExamUtil.scoreToVM(e.getUserScore())); // 转换用户得分
vm.setPaperScore(ExamUtil.scoreToVM(e.getPaperScore())); // 转换试卷得分
vm.setSubjectName(subject.getName()); // 设置学科名称
vm.setCreateTime(DateTimeUtil.dateFormat(e.getCreateTime())); // 格式化创建时间
return vm;
});
return RestResponse.ok(page);
return RestResponse.ok(page); // 返回分页数据
}
// 处理学生提交试卷答题的请求
@RequestMapping(value = "/answerSubmit", method = RequestMethod.POST)
public RestResponse answerSubmit(@RequestBody @Valid ExamPaperSubmitVM examPaperSubmitVM) {
User user = getCurrentUser();
ExamPaperAnswerInfo examPaperAnswerInfo = examPaperAnswerService.calculateExamPaperAnswer(examPaperSubmitVM, user);
User user = getCurrentUser(); // 获取当前学生用户
ExamPaperAnswerInfo examPaperAnswerInfo = examPaperAnswerService.calculateExamPaperAnswer(examPaperSubmitVM, user); // 计算试卷答题
if (null == examPaperAnswerInfo) {
return RestResponse.fail(2, "试卷不能重复做");
return RestResponse.fail(2, "试卷不能重复做"); // 如果试卷已经提交过,返回错误
}
ExamPaperAnswer examPaperAnswer = examPaperAnswerInfo.getExamPaperAnswer();
Integer userScore = examPaperAnswer.getUserScore();
String scoreVm = ExamUtil.scoreToVM(userScore);
UserEventLog userEventLog = new UserEventLog(user.getId(), user.getUserName(), user.getRealName(), new Date());
ExamPaperAnswer examPaperAnswer = examPaperAnswerInfo.getExamPaperAnswer(); // 获取答题信息
Integer userScore = examPaperAnswer.getUserScore(); // 获取用户得分
String scoreVm = ExamUtil.scoreToVM(userScore); // 转换得分为视图模型格式
UserEventLog userEventLog = new UserEventLog(user.getId(), user.getUserName(), user.getRealName(), new Date()); // 创建用户事件日志
String content = user.getUserName() + " 提交试卷:" + examPaperAnswerInfo.getExamPaper().getName()
+ " 得分:" + scoreVm
+ " 耗时:" + ExamUtil.secondToVM(examPaperAnswer.getDoTime());
+ " 耗时:" + ExamUtil.secondToVM(examPaperAnswer.getDoTime()); // 日志内容
userEventLog.setContent(content);
eventPublisher.publishEvent(new CalculateExamPaperAnswerCompleteEvent(examPaperAnswerInfo));
eventPublisher.publishEvent(new UserEvent(userEventLog));
return RestResponse.ok(scoreVm);
eventPublisher.publishEvent(new CalculateExamPaperAnswerCompleteEvent(examPaperAnswerInfo)); // 发布试卷答题完成事件
eventPublisher.publishEvent(new UserEvent(userEventLog)); // 发布用户事件
return RestResponse.ok(scoreVm); // 返回得分
}
// 处理学生修改试卷答题的请求
@RequestMapping(value = "/edit", method = RequestMethod.POST)
public RestResponse edit(@RequestBody @Valid ExamPaperSubmitVM examPaperSubmitVM) {
// 检查是否存在未批改的题目
boolean notJudge = examPaperSubmitVM.getAnswerItems().stream().anyMatch(i -> i.getDoRight() == null && i.getScore() == null);
if (notJudge) {
return RestResponse.fail(2, "有未批改题目");
return RestResponse.fail(2, "有未批改题目"); // 如果有未批改题目,返回错误
}
ExamPaperAnswer examPaperAnswer = examPaperAnswerService.selectById(examPaperSubmitVM.getId());
ExamPaperAnswer examPaperAnswer = examPaperAnswerService.selectById(examPaperSubmitVM.getId()); // 获取试卷答题记录
ExamPaperAnswerStatusEnum examPaperAnswerStatusEnum = ExamPaperAnswerStatusEnum.fromCode(examPaperAnswer.getStatus());
if (examPaperAnswerStatusEnum == ExamPaperAnswerStatusEnum.Complete) {
return RestResponse.fail(3, "试卷已完成");
return RestResponse.fail(3, "试卷已完成"); // 如果试卷已完成,返回错误
}
String score = examPaperAnswerService.judge(examPaperSubmitVM);
User user = getCurrentUser();
UserEventLog userEventLog = new UserEventLog(user.getId(), user.getUserName(), user.getRealName(), new Date());
String content = user.getUserName() + " 批改试卷:" + examPaperAnswer.getPaperName() + " 得分:" + score;
String score = examPaperAnswerService.judge(examPaperSubmitVM); // 批改试卷并返回得分
User user = getCurrentUser(); // 获取当前学生用户
UserEventLog userEventLog = new UserEventLog(user.getId(), user.getUserName(), user.getRealName(), new Date()); // 创建用户事件日志
String content = user.getUserName() + " 批改试卷:" + examPaperAnswer.getPaperName() + " 得分:" + score; // 日志内容
userEventLog.setContent(content);
eventPublisher.publishEvent(new UserEvent(userEventLog));
return RestResponse.ok(score);
eventPublisher.publishEvent(new UserEvent(userEventLog)); // 发布用户事件
return RestResponse.ok(score); // 返回得分
}
// 处理学生查看试卷答题详情的请求
@RequestMapping(value = "/read/{id}", method = RequestMethod.POST)
public RestResponse<ExamPaperReadVM> read(@PathVariable Integer id) {
ExamPaperAnswer examPaperAnswer = examPaperAnswerService.selectById(id);
ExamPaperReadVM vm = new ExamPaperReadVM();
ExamPaperEditRequestVM paper = examPaperService.examPaperToVM(examPaperAnswer.getExamPaperId());
ExamPaperSubmitVM answer = examPaperAnswerService.examPaperAnswerToVM(examPaperAnswer.getId());
vm.setPaper(paper);
vm.setAnswer(answer);
return RestResponse.ok(vm);
ExamPaperAnswer examPaperAnswer = examPaperAnswerService.selectById(id); // 根据ID获取试卷答题记录
ExamPaperReadVM vm = new ExamPaperReadVM(); // 创建返回的视图模型
ExamPaperEditRequestVM paper = examPaperService.examPaperToVM(examPaperAnswer.getExamPaperId()); // 获取试卷信息
ExamPaperSubmitVM answer = examPaperAnswerService.examPaperAnswerToVM(examPaperAnswer.getId()); // 获取答题记录
vm.setPaper(paper); // 设置试卷信息
vm.setAnswer(answer); // 设置答题信息
return RestResponse.ok(vm); // 返回视图模型
}
}

@ -17,14 +17,15 @@ import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
@RestController("StudentExamPaperController")
@RequestMapping(value = "/api/student/exam/paper")
@RestController("StudentExamPaperController") // 标记为学生试卷控制器
@RequestMapping(value = "/api/student/exam/paper") // 基础请求路径
public class ExamPaperController extends BaseApiController {
private final ExamPaperService examPaperService;
private final ExamPaperAnswerService examPaperAnswerService;
private final ApplicationEventPublisher eventPublisher;
private final ExamPaperService examPaperService; // 注入试卷服务
private final ExamPaperAnswerService examPaperAnswerService; // 注入试卷答题服务
private final ApplicationEventPublisher eventPublisher; // 事件发布器
// 构造函数注入依赖的服务
@Autowired
public ExamPaperController(ExamPaperService examPaperService, ExamPaperAnswerService examPaperAnswerService, ApplicationEventPublisher eventPublisher) {
this.examPaperService = examPaperService;
@ -32,22 +33,22 @@ public class ExamPaperController extends BaseApiController {
this.eventPublisher = eventPublisher;
}
// 根据试卷ID获取试卷编辑请求视图模型
@RequestMapping(value = "/select/{id}", method = RequestMethod.POST)
public RestResponse<ExamPaperEditRequestVM> select(@PathVariable Integer id) {
ExamPaperEditRequestVM vm = examPaperService.examPaperToVM(id);
return RestResponse.ok(vm);
ExamPaperEditRequestVM vm = examPaperService.examPaperToVM(id); // 获取试卷信息
return RestResponse.ok(vm); // 返回试卷视图模型
}
// 获取学生的试卷分页列表
@RequestMapping(value = "/pageList", method = RequestMethod.POST)
public RestResponse<PageInfo<ExamPaperPageResponseVM>> pageList(@RequestBody @Valid ExamPaperPageVM model) {
PageInfo<ExamPaper> pageInfo = examPaperService.studentPage(model);
PageInfo<ExamPaperPageResponseVM> page = PageInfoHelper.copyMap(pageInfo, e -> {
PageInfo<ExamPaper> pageInfo = examPaperService.studentPage(model); // 获取试卷分页数据
PageInfo<ExamPaperPageResponseVM> page = PageInfoHelper.copyMap(pageInfo, e -> { // 转换分页数据为视图模型
ExamPaperPageResponseVM vm = modelMapper.map(e, ExamPaperPageResponseVM.class);
vm.setCreateTime(DateTimeUtil.dateFormat(e.getCreateTime()));
vm.setCreateTime(DateTimeUtil.dateFormat(e.getCreateTime())); // 格式化创建时间
return vm;
});
return RestResponse.ok(page);
return RestResponse.ok(page); // 返回分页数据
}
}

@ -40,34 +40,34 @@ public class QuestionAnswerController extends BaseApiController {
this.subjectService = subjectService;
}
// 获取学生答题记录的分页数据
@RequestMapping(value = "/page", method = RequestMethod.POST)
public RestResponse<PageInfo<QuestionPageStudentResponseVM>> pageList(@RequestBody QuestionPageStudentRequestVM model) {
model.setCreateUser(getCurrentUser().getId());
PageInfo<ExamPaperQuestionCustomerAnswer> pageInfo = examPaperQuestionCustomerAnswerService.studentPage(model);
PageInfo<QuestionPageStudentResponseVM> page = PageInfoHelper.copyMap(pageInfo, q -> {
Subject subject = subjectService.selectById(q.getSubjectId());
QuestionPageStudentResponseVM vm = modelMapper.map(q, QuestionPageStudentResponseVM.class);
vm.setCreateTime(DateTimeUtil.dateFormat(q.getCreateTime()));
TextContent textContent = textContentService.selectById(q.getQuestionTextContentId());
QuestionObject questionObject = JsonUtil.toJsonObject(textContent.getContent(), QuestionObject.class);
String clearHtml = HtmlUtil.clear(questionObject.getTitleContent());
vm.setShortTitle(clearHtml);
vm.setSubjectName(subject.getName());
model.setCreateUser(getCurrentUser().getId()); // 设置当前用户ID
PageInfo<ExamPaperQuestionCustomerAnswer> pageInfo = examPaperQuestionCustomerAnswerService.studentPage(model); // 获取分页数据
PageInfo<QuestionPageStudentResponseVM> page = PageInfoHelper.copyMap(pageInfo, q -> { // 将分页数据转换为视图模型
Subject subject = subjectService.selectById(q.getSubjectId()); // 获取学科信息
QuestionPageStudentResponseVM vm = modelMapper.map(q, QuestionPageStudentResponseVM.class); // 映射数据
vm.setCreateTime(DateTimeUtil.dateFormat(q.getCreateTime())); // 格式化创建时间
TextContent textContent = textContentService.selectById(q.getQuestionTextContentId()); // 获取题目内容
QuestionObject questionObject = JsonUtil.toJsonObject(textContent.getContent(), QuestionObject.class); // 解析题目内容
String clearHtml = HtmlUtil.clear(questionObject.getTitleContent()); // 清除HTML标签
vm.setShortTitle(clearHtml); // 设置短标题
vm.setSubjectName(subject.getName()); // 设置学科名称
return vm;
});
return RestResponse.ok(page);
return RestResponse.ok(page); // 返回分页数据
}
// 根据题目ID获取单个题目的答题信息
@RequestMapping(value = "/select/{id}", method = RequestMethod.POST)
public RestResponse<QuestionAnswerVM> select(@PathVariable Integer id) {
QuestionAnswerVM vm = new QuestionAnswerVM();
ExamPaperQuestionCustomerAnswer examPaperQuestionCustomerAnswer = examPaperQuestionCustomerAnswerService.selectById(id);
ExamPaperSubmitItemVM questionAnswerVM = examPaperQuestionCustomerAnswerService.examPaperQuestionCustomerAnswerToVM(examPaperQuestionCustomerAnswer);
QuestionEditRequestVM questionVM = questionService.getQuestionEditRequestVM(examPaperQuestionCustomerAnswer.getQuestionId());
vm.setQuestionVM(questionVM);
vm.setQuestionAnswerVM(questionAnswerVM);
return RestResponse.ok(vm);
QuestionAnswerVM vm = new QuestionAnswerVM(); // 创建答题视图模型
ExamPaperQuestionCustomerAnswer examPaperQuestionCustomerAnswer = examPaperQuestionCustomerAnswerService.selectById(id); // 获取答题记录
ExamPaperSubmitItemVM questionAnswerVM = examPaperQuestionCustomerAnswerService.examPaperQuestionCustomerAnswerToVM(examPaperQuestionCustomerAnswer); // 转换为答题项视图模型
QuestionEditRequestVM questionVM = questionService.getQuestionEditRequestVM(examPaperQuestionCustomerAnswer.getQuestionId()); // 获取题目编辑请求视图模型
vm.setQuestionVM(questionVM); // 设置题目视图模型
vm.setQuestionAnswerVM(questionAnswerVM); // 设置答题项视图模型
return RestResponse.ok(vm); // 返回答题信息
}
}

@ -5,14 +5,23 @@ import com.mindskip.xzs.service.QuestionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
/**
* Question
* BaseApiController API
*/
@RestController("StudentQuestionController")
@RequestMapping(value = "/api/student/question")
@RequestMapping(value = "/api/student/question") // 映射的 URL 前缀
public class QuestionController extends BaseApiController {
private final QuestionService questionService;
private final QuestionService questionService; // 注入的题目服务,用于处理题目相关的业务逻辑
/**
* QuestionService
*
* @param questionService
*/
@Autowired
public QuestionController(QuestionService questionService) {
this.questionService = questionService;
this.questionService = questionService; // 将 QuestionService 服务赋值给成员变量
}
}

@ -1,6 +1,5 @@
package com.mindskip.xzs.controller.student;
import com.mindskip.xzs.base.BaseApiController;
import com.mindskip.xzs.base.RestResponse;
import com.mindskip.xzs.service.FileUpload;
@ -16,36 +15,58 @@ import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.io.InputStream;
@RequestMapping("/api/student/upload")
@RestController("StudentUploadController")
/**
*
* BaseApiController API
*/
@RequestMapping("/api/student/upload") // 映射的 URL 前缀
@RestController("StudentUploadController") // 指定该控制器的名称
public class UploadController extends BaseApiController {
private final FileUpload fileUpload;
private final UserService userService;
private final FileUpload fileUpload; // 文件上传服务,用于处理文件上传逻辑
private final UserService userService; // 用户服务,用于处理用户信息相关的操作
/**
* FileUpload UserService
*
* @param fileUpload
* @param userService
*/
@Autowired
public UploadController(FileUpload fileUpload, UserService userService) {
this.fileUpload = fileUpload;
this.userService = userService;
this.fileUpload = fileUpload; // 将 FileUpload 服务赋值给成员变量
this.userService = userService; // 将 UserService 服务赋值给成员变量
}
/**
*
* 使 MultipartHttpServletRequest
* FileUpload UserService
*
* @param request HttpServletRequest
* @return RestResponse
*/
@RequestMapping("/image")
@ResponseBody
@ResponseBody // 表示返回的内容会自动转化为 JSON 格式
public RestResponse questionUploadAndReadExcel(HttpServletRequest request) {
// 转换请求类型为 MultipartHttpServletRequest
MultipartHttpServletRequest multipartHttpServletRequest = (MultipartHttpServletRequest) request;
// 获取上传的文件
MultipartFile multipartFile = multipartHttpServletRequest.getFile("file");
// 获取文件的大小
long attachSize = multipartFile.getSize();
// 获取文件的原始名称
String imgName = multipartFile.getOriginalFilename();
try (InputStream inputStream = multipartFile.getInputStream()) {
// 调用 fileUpload 服务进行文件上传,并获取上传后的文件路径
String filePath = fileUpload.uploadFile(inputStream, attachSize, imgName);
// 使用 userService 更新用户的头像
userService.changePicture(getCurrentUser(), filePath);
// 返回成功的响应,包含文件路径
return RestResponse.ok(filePath);
} catch (IOException e) {
// 捕获上传过程中可能出现的异常,并返回失败响应
return RestResponse.fail(2, e.getMessage());
}
}
}

@ -28,16 +28,29 @@ import java.util.List;
import java.util.UUID;
import java.util.stream.Collectors;
@RestController("StudentUserController")
@RequestMapping(value = "/api/student/user")
/**
*
*
*/
@RestController("StudentUserController") // 将该控制器命名为 "StudentUserController"
@RequestMapping(value = "/api/student/user") // 映射的 URL 前缀
public class UserController extends BaseApiController {
private final UserService userService;
private final UserEventLogService userEventLogService;
private final MessageService messageService;
private final AuthenticationService authenticationService;
private final ApplicationEventPublisher eventPublisher;
private final UserService userService; // 用户服务,用于处理用户相关的操作
private final UserEventLogService userEventLogService; // 用户事件日志服务
private final MessageService messageService; // 消息服务,用于处理消息相关操作
private final AuthenticationService authenticationService; // 认证服务,用于用户密码加密等操作
private final ApplicationEventPublisher eventPublisher; // 事件发布器,用于发布用户相关事件
/**
*
*
* @param userService
* @param userEventLogService
* @param messageService
* @param authenticationService
* @param eventPublisher
*/
@Autowired
public UserController(UserService userService, UserEventLogService userEventLogService, MessageService messageService, AuthenticationService authenticationService, ApplicationEventPublisher eventPublisher) {
this.userService = userService;
@ -47,93 +60,140 @@ public class UserController extends BaseApiController {
this.eventPublisher = eventPublisher;
}
/**
*
*
* @return
*/
@RequestMapping(value = "/current", method = RequestMethod.POST)
public RestResponse<UserResponseVM> current() {
User user = getCurrentUser();
UserResponseVM userVm = UserResponseVM.from(user);
return RestResponse.ok(userVm);
User user = getCurrentUser(); // 获取当前登录用户
UserResponseVM userVm = UserResponseVM.from(user); // 将用户信息转换为视图模型
return RestResponse.ok(userVm); // 返回响应
}
/**
*
*
*
* @param model
* @return
*/
@RequestMapping(value = "/register", method = RequestMethod.POST)
public RestResponse register(@RequestBody @Valid UserRegisterVM model) {
User existUser = userService.getUserByUserName(model.getUserName());
User existUser = userService.getUserByUserName(model.getUserName()); // 检查用户名是否已存在
if (null != existUser) {
return new RestResponse<>(2, "用户已存在");
return new RestResponse<>(2, "用户已存在"); // 如果已存在,返回错误
}
// 将注册信息转换为 User 对象
User user = modelMapper.map(model, User.class);
// 对密码进行加密
String encodePwd = authenticationService.pwdEncode(model.getPassword());
user.setUserUuid(UUID.randomUUID().toString());
user.setPassword(encodePwd);
user.setRole(RoleEnum.STUDENT.getCode());
user.setStatus(UserStatusEnum.Enable.getCode());
user.setLastActiveTime(new Date());
user.setCreateTime(new Date());
user.setDeleted(false);
userService.insertByFilter(user);
user.setUserUuid(UUID.randomUUID().toString()); // 设置用户 UUID
user.setPassword(encodePwd); // 设置加密后的密码
user.setRole(RoleEnum.STUDENT.getCode()); // 设置用户角色为学生
user.setStatus(UserStatusEnum.Enable.getCode()); // 设置用户状态为启用
user.setLastActiveTime(new Date()); // 设置最后活动时间
user.setCreateTime(new Date()); // 设置创建时间
user.setDeleted(false); // 设置删除状态
userService.insertByFilter(user); // 保存用户信息
// 记录用户注册日志
UserEventLog userEventLog = new UserEventLog(user.getId(), user.getUserName(), user.getRealName(), new Date());
userEventLog.setContent("欢迎 " + user.getUserName() + " 注册来到学之思开源考试系统");
// 发布用户注册事件
eventPublisher.publishEvent(new UserEvent(userEventLog));
return RestResponse.ok();
return RestResponse.ok(); // 返回成功响应
}
/**
*
*
*
* @param model
* @return
*/
@RequestMapping(value = "/update", method = RequestMethod.POST)
public RestResponse update(@RequestBody @Valid UserUpdateVM model) {
if (StringUtils.isBlank(model.getBirthDay())) {
model.setBirthDay(null);
model.setBirthDay(null); // 如果生日为空,设置为 null
}
User user = userService.selectById(getCurrentUser().getId());
modelMapper.map(model, user);
user.setModifyTime(new Date());
userService.updateByIdFilter(user);
User user = userService.selectById(getCurrentUser().getId()); // 获取当前用户
modelMapper.map(model, user); // 将更新信息映射到用户对象
user.setModifyTime(new Date()); // 设置修改时间
userService.updateByIdFilter(user); // 更新用户信息
// 记录用户资料更新日志
UserEventLog userEventLog = new UserEventLog(user.getId(), user.getUserName(), user.getRealName(), new Date());
userEventLog.setContent(user.getUserName() + " 更新了个人资料");
// 发布用户资料更新事件
eventPublisher.publishEvent(new UserEvent(userEventLog));
return RestResponse.ok();
return RestResponse.ok(); // 返回成功响应
}
/**
*
*
* @return
*/
@RequestMapping(value = "/log", method = RequestMethod.POST)
public RestResponse<List<UserEventLogVM>> log() {
User user = getCurrentUser();
List<UserEventLog> userEventLogs = userEventLogService.getUserEventLogByUserId(user.getId());
User user = getCurrentUser(); // 获取当前用户
List<UserEventLog> userEventLogs = userEventLogService.getUserEventLogByUserId(user.getId()); // 获取用户事件日志
List<UserEventLogVM> userEventLogVMS = userEventLogs.stream().map(d -> {
UserEventLogVM vm = modelMapper.map(d, UserEventLogVM.class);
vm.setCreateTime(DateTimeUtil.dateFormat(d.getCreateTime()));
UserEventLogVM vm = modelMapper.map(d, UserEventLogVM.class); // 将日志对象映射为视图模型
vm.setCreateTime(DateTimeUtil.dateFormat(d.getCreateTime())); // 格式化日志时间
return vm;
}).collect(Collectors.toList());
return RestResponse.ok(userEventLogVMS);
return RestResponse.ok(userEventLogVMS); // 返回事件日志
}
/**
*
*
* @param messageRequestVM
* @return
*/
@RequestMapping(value = "/message/page", method = RequestMethod.POST)
public RestResponse<PageInfo<MessageResponseVM>> messagePageList(@RequestBody MessageRequestVM messageRequestVM) {
messageRequestVM.setReceiveUserId(getCurrentUser().getId());
PageInfo<MessageUser> messageUserPageInfo = messageService.studentPage(messageRequestVM);
messageRequestVM.setReceiveUserId(getCurrentUser().getId()); // 设置当前用户为消息接收者
PageInfo<MessageUser> messageUserPageInfo = messageService.studentPage(messageRequestVM); // 获取分页消息
List<Integer> ids = messageUserPageInfo.getList().stream().map(d -> d.getMessageId()).collect(Collectors.toList());
List<Message> messages = ids.size() != 0 ? messageService.selectMessageByIds(ids) : null;
List<Message> messages = ids.size() != 0 ? messageService.selectMessageByIds(ids) : null; // 根据消息 ID 获取消息内容
PageInfo<MessageResponseVM> page = PageInfoHelper.copyMap(messageUserPageInfo, e -> {
MessageResponseVM vm = modelMapper.map(e, MessageResponseVM.class);
MessageResponseVM vm = modelMapper.map(e, MessageResponseVM.class); // 映射为消息响应视图模型
messages.stream().filter(d -> e.getMessageId().equals(d.getId())).findFirst().ifPresent(message -> {
vm.setTitle(message.getTitle());
vm.setContent(message.getContent());
vm.setSendUserName(message.getSendUserName());
});
vm.setCreateTime(DateTimeUtil.dateFormat(e.getCreateTime()));
vm.setCreateTime(DateTimeUtil.dateFormat(e.getCreateTime())); // 格式化消息时间
return vm;
});
return RestResponse.ok(page);
return RestResponse.ok(page); // 返回消息分页列表
}
/**
*
*
* @return
*/
@RequestMapping(value = "/message/unreadCount", method = RequestMethod.POST)
public RestResponse unReadCount() {
Integer count = messageService.unReadCount(getCurrentUser().getId());
return RestResponse.ok(count);
Integer count = messageService.unReadCount(getCurrentUser().getId()); // 获取未读消息数量
return RestResponse.ok(count); // 返回未读消息数量
}
/**
*
*
* @param id ID
* @return
*/
@RequestMapping(value = "/message/read/{id}", method = RequestMethod.POST)
public RestResponse read(@PathVariable Integer id) {
messageService.read(id);
return RestResponse.ok();
messageService.read(id); // 标记消息为已读
return RestResponse.ok(); // 返回成功响应
}
}

@ -1,22 +1,18 @@
package com.mindskip.xzs.controller.wx;
import com.mindskip.xzs.context.WxContext;
import com.mindskip.xzs.domain.User;
import com.mindskip.xzs.domain.UserToken;
import com.mindskip.xzs.utility.ModelMapperSingle;
import org.modelmapper.ModelMapper;
import org.springframework.beans.factory.annotation.Autowired;
public class BaseWXApiController {
// 定义一个静态的ModelMapper实例用于对象之间的转换
protected final static ModelMapper modelMapper = ModelMapperSingle.Instance();
// 自动注入WxContext包含微信上下文信息
@Autowired
private WxContext wxContext;
// 获取当前用户信息的方法
protected User getCurrentUser() {
return wxContext.getCurrentUser();
return wxContext.getCurrentUser(); // 从WxContext中获取当前用户
}
// 获取当前用户Token的方法
protected UserToken getUserToken() {
return wxContext.getCurrentUserToken();
return wxContext.getCurrentUserToken(); // 从WxContext中获取当前用户的Token
}
}

@ -1,24 +1,3 @@
package com.mindskip.xzs.controller.wx.student;
import com.mindskip.xzs.base.RestResponse;
import com.mindskip.xzs.configuration.property.SystemConfig;
import com.mindskip.xzs.controller.wx.BaseWXApiController;
import com.mindskip.xzs.domain.UserToken;
import com.mindskip.xzs.domain.enums.UserStatusEnum;
import com.mindskip.xzs.service.AuthenticationService;
import com.mindskip.xzs.service.UserService;
import com.mindskip.xzs.service.UserTokenService;
import com.mindskip.xzs.utility.WxUtil;
import com.mindskip.xzs.viewmodel.wx.student.user.BindInfo;
import com.mindskip.xzs.domain.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import javax.validation.constraints.NotBlank;
@Controller("WXStudentAuthController")
@RequestMapping(value = "/api/wx/student/auth")
@ResponseBody
@ -37,48 +16,76 @@ public class AuthController extends BaseWXApiController {
this.userTokenService = userTokenService;
}
/**
* OpenId
* @param model
* @return Token
*/
@RequestMapping(value = "/bind", method = RequestMethod.POST)
public RestResponse bind(@Valid BindInfo model) {
// 根据用户名获取用户信息。
User user = userService.getUserByUserName(model.getUserName());
if (user == null) {
// 如果没有找到对应的用户,返回错误信息。
return RestResponse.fail(2, "用户名或密码错误");
}
// 使用提供的用户名和密码对用户进行认证。
boolean result = authenticationService.authUser(user, model.getUserName(), model.getPassword());
if (!result) {
// 如果认证失败,返回错误信息。
return RestResponse.fail(2, "用户名或密码错误");
}
// 检查用户的状态,如果用户被禁用,返回相应的错误信息。
UserStatusEnum userStatusEnum = UserStatusEnum.fromCode(user.getStatus());
if (UserStatusEnum.Disable == userStatusEnum) {
return RestResponse.fail(3, "用户被禁用");
}
// 获取微信返回的OpenId。
String code = model.getCode();
String openid = WxUtil.getOpenId(systemConfig.getWx().getAppid(), systemConfig.getWx().getSecret(), code);
if (null == openid) {
// 如果获取OpenId失败返回错误信息。
return RestResponse.fail(4, "获取微信OpenId失败");
}
// 将获取到的OpenId与用户绑定。
user.setWxOpenId(openid);
// 使用UserTokenService为用户绑定生成Token。
UserToken userToken = userTokenService.bind(user);
return RestResponse.ok(userToken.getToken());
}
/**
*
* @param code Code
* @return Token
*/
@RequestMapping(value = "/checkBind", method = RequestMethod.POST)
public RestResponse checkBind(@Valid @NotBlank String code) {
// 获取微信OpenId。
String openid = WxUtil.getOpenId(systemConfig.getWx().getAppid(), systemConfig.getWx().getSecret(), code);
if (null == openid) {
// 如果获取OpenId失败返回错误信息。
return RestResponse.fail(3, "获取微信OpenId失败");
}
// 检查该OpenId是否已绑定用户Token。
UserToken userToken = userTokenService.checkBind(openid);
if (null != userToken) {
// 如果已绑定返回用户Token。
return RestResponse.ok(userToken.getToken());
}
// 如果未绑定,返回未绑定的错误信息。
return RestResponse.fail(2, "用户未绑定");
}
/**
*
* @return
*/
@RequestMapping(value = "/unBind", method = RequestMethod.POST)
public RestResponse unBind() {
// 获取当前用户的Token。
UserToken userToken = getUserToken();
// 调用UserTokenService解除绑定。
userTokenService.unBind(userToken);
return RestResponse.ok();
}

@ -1,33 +1,3 @@
package com.mindskip.xzs.controller.wx.student;
import com.mindskip.xzs.base.RestResponse;
import com.mindskip.xzs.controller.wx.BaseWXApiController;
import com.mindskip.xzs.domain.TaskExam;
import com.mindskip.xzs.domain.TaskExamCustomerAnswer;
import com.mindskip.xzs.domain.TextContent;
import com.mindskip.xzs.domain.User;
import com.mindskip.xzs.domain.enums.ExamPaperTypeEnum;
import com.mindskip.xzs.domain.task.TaskItemAnswerObject;
import com.mindskip.xzs.domain.task.TaskItemObject;
import com.mindskip.xzs.service.ExamPaperService;
import com.mindskip.xzs.service.TaskExamCustomerAnswerService;
import com.mindskip.xzs.service.TaskExamService;
import com.mindskip.xzs.service.TextContentService;
import com.mindskip.xzs.utility.DateTimeUtil;
import com.mindskip.xzs.utility.JsonUtil;
import com.mindskip.xzs.viewmodel.student.dashboard.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
@Controller("WXStudentDashboardController")
@RequestMapping(value = "/api/wx/student/dashboard")
@ResponseBody
@ -46,71 +16,98 @@ public class DashboardController extends BaseWXApiController {
this.taskExamCustomerAnswerService = taskExamCustomerAnswerService;
}
/**
*
* @return
*/
@RequestMapping(value = "/index", method = RequestMethod.POST)
public RestResponse<IndexVM> index() {
IndexVM indexVM = new IndexVM();
User user = getCurrentUser();
User user = getCurrentUser(); // 获取当前登录的用户
// 设置固定试卷的筛选条件
PaperFilter fixedPaperFilter = new PaperFilter();
fixedPaperFilter.setGradeLevel(user.getUserLevel());
fixedPaperFilter.setExamPaperType(ExamPaperTypeEnum.Fixed.getCode());
indexVM.setFixedPaper(examPaperService.indexPaper(fixedPaperFilter));
// 设置时间限制试卷的筛选条件
PaperFilter timeLimitPaperFilter = new PaperFilter();
timeLimitPaperFilter.setDateTime(new Date());
timeLimitPaperFilter.setGradeLevel(user.getUserLevel());
timeLimitPaperFilter.setExamPaperType(ExamPaperTypeEnum.TimeLimit.getCode());
// 获取时间限制试卷
List<PaperInfo> limitPaper = examPaperService.indexPaper(timeLimitPaperFilter);
List<PaperInfoVM> paperInfoVMS = limitPaper.stream().map(d -> {
PaperInfoVM vm = modelMapper.map(d, PaperInfoVM.class);
vm.setStartTime(DateTimeUtil.dateFormat(d.getLimitStartTime()));
vm.setEndTime(DateTimeUtil.dateFormat(d.getLimitEndTime()));
vm.setStartTime(DateTimeUtil.dateFormat(d.getLimitStartTime())); // 格式化开始时间
vm.setEndTime(DateTimeUtil.dateFormat(d.getLimitEndTime())); // 格式化结束时间
return vm;
}).collect(Collectors.toList());
indexVM.setTimeLimitPaper(paperInfoVMS);
return RestResponse.ok(indexVM);
return RestResponse.ok(indexVM); // 返回首页数据
}
/**
*
* @return
*/
@RequestMapping(value = "/task", method = RequestMethod.POST)
public RestResponse<List<TaskItemVm>> task() {
User user = getCurrentUser();
User user = getCurrentUser(); // 获取当前登录的用户
// 获取用户级别的任务
List<TaskExam> taskExams = taskExamService.getByGradeLevel(user.getUserLevel());
if (taskExams.size() == 0) {
return RestResponse.ok(new ArrayList<>());
return RestResponse.ok(new ArrayList<>()); // 如果没有任务,返回空列表
}
List<Integer> tIds = taskExams.stream().map(taskExam -> taskExam.getId()).collect(Collectors.toList());
// 根据任务ID获取用户的答案
List<TaskExamCustomerAnswer> taskExamCustomerAnswers = taskExamCustomerAnswerService.selectByTUid(tIds, user.getId());
// 构建任务项视图模型
List<TaskItemVm> vm = taskExams.stream().map(t -> {
TaskItemVm itemVm = new TaskItemVm();
itemVm.setId(t.getId());
itemVm.setTitle(t.getTitle());
// 获取该任务的用户答案
TaskExamCustomerAnswer taskExamCustomerAnswer = taskExamCustomerAnswers.stream()
.filter(tc -> tc.getTaskExamId().equals(t.getId())).findFirst().orElse(null);
// 获取任务项的试卷视图
List<TaskItemPaperVm> paperItemVMS = getTaskItemPaperVm(t.getFrameTextContentId(), taskExamCustomerAnswer);
itemVm.setPaperItems(paperItemVMS);
return itemVm;
}).collect(Collectors.toList());
return RestResponse.ok(vm);
}
return RestResponse.ok(vm); // 返回任务列表
}
/**
*
* @param tFrameId ID
* @param taskExamCustomerAnswers
* @return
*/
private List<TaskItemPaperVm> getTaskItemPaperVm(Integer tFrameId, TaskExamCustomerAnswer taskExamCustomerAnswers) {
// 获取任务试卷内容
TextContent textContent = textContentService.selectById(tFrameId);
List<TaskItemObject> paperItems = JsonUtil.toJsonListObject(textContent.getContent(), TaskItemObject.class);
List<TaskItemAnswerObject> answerPaperItems = null;
// 如果用户提交了答案,获取答案内容
if (null != taskExamCustomerAnswers) {
TextContent answerTextContent = textContentService.selectById(taskExamCustomerAnswers.getTextContentId());
answerPaperItems = JsonUtil.toJsonListObject(answerTextContent.getContent(), TaskItemAnswerObject.class);
}
// 将试卷项和用户答案匹配,构建视图模型
List<TaskItemAnswerObject> finalAnswerPaperItems = answerPaperItems;
return paperItems.stream().map(p -> {
TaskItemPaperVm ivm = new TaskItemPaperVm();
ivm.setExamPaperId(p.getExamPaperId());
ivm.setExamPaperName(p.getExamPaperName());
// 如果用户提交了答案,匹配并填充答案信息
if (null != finalAnswerPaperItems) {
finalAnswerPaperItems.stream()
.filter(a -> a.getExamPaperId().equals(p.getExamPaperId()))
@ -124,6 +121,4 @@ public class DashboardController extends BaseWXApiController {
}
).collect(Collectors.toList());
}
}

@ -1,44 +1,12 @@
package com.mindskip.xzs.controller.wx.student;
import com.mindskip.xzs.base.RestResponse;
import com.mindskip.xzs.controller.wx.BaseWXApiController;
import com.mindskip.xzs.domain.*;
import com.mindskip.xzs.domain.enums.QuestionTypeEnum;
import com.mindskip.xzs.event.CalculateExamPaperAnswerCompleteEvent;
import com.mindskip.xzs.event.UserEvent;
import com.mindskip.xzs.service.ExamPaperAnswerService;
import com.mindskip.xzs.service.ExamPaperService;
import com.mindskip.xzs.service.SubjectService;
import com.mindskip.xzs.utility.DateTimeUtil;
import com.mindskip.xzs.utility.ExamUtil;
import com.mindskip.xzs.utility.PageInfoHelper;
import com.mindskip.xzs.viewmodel.admin.exam.ExamPaperEditRequestVM;
import com.mindskip.xzs.viewmodel.student.exampaper.ExamPaperAnswerPageResponseVM;
import com.mindskip.xzs.viewmodel.student.exampaper.ExamPaperAnswerPageVM;
import com.github.pagehelper.PageInfo;
import com.mindskip.xzs.viewmodel.student.exam.ExamPaperReadVM;
import com.mindskip.xzs.viewmodel.student.exam.ExamPaperSubmitItemVM;
import com.mindskip.xzs.viewmodel.student.exam.ExamPaperSubmitVM;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import javax.validation.Valid;
import java.util.*;
import java.util.stream.Collectors;
@Controller("WXStudentExamPaperAnswerController")
@RequestMapping(value = "/api/wx/student/exampaper/answer")
@ResponseBody
@Controller("WXStudentExamPaperAnswerController") // 控制器类,处理学生的考试答题相关请求
@RequestMapping(value = "/api/wx/student/exampaper/answer") // 定义路径指定该控制器处理的请求URL
@ResponseBody // 表示返回的对象会自动转换为JSON格式
public class ExamPaperAnswerController extends BaseWXApiController {
private final ExamPaperAnswerService examPaperAnswerService;
private final SubjectService subjectService;
private final ApplicationEventPublisher eventPublisher;
private final ExamPaperService examPaperService;
private final ExamPaperAnswerService examPaperAnswerService; // 处理考试答题的服务
private final SubjectService subjectService; // 处理科目相关的服务
private final ApplicationEventPublisher eventPublisher; // 用于发布事件
private final ExamPaperService examPaperService; // 处理考试试卷相关的服务
@Autowired
public ExamPaperAnswerController(ExamPaperAnswerService examPaperAnswerService, SubjectService subjectService, ApplicationEventPublisher eventPublisher, ExamPaperService examPaperService) {
@ -48,88 +16,92 @@ public class ExamPaperAnswerController extends BaseWXApiController {
this.examPaperService = examPaperService;
}
// 获取学生答题记录的分页列表
@RequestMapping(value = "/pageList", method = RequestMethod.POST)
public RestResponse<PageInfo<ExamPaperAnswerPageResponseVM>> pageList(@Valid ExamPaperAnswerPageVM model) {
model.setCreateUser(getCurrentUser().getId());
PageInfo<ExamPaperAnswer> pageInfo = examPaperAnswerService.studentPage(model);
model.setCreateUser(getCurrentUser().getId()); // 获取当前用户学生的ID
PageInfo<ExamPaperAnswer> pageInfo = examPaperAnswerService.studentPage(model); // 获取学生的答题记录分页
PageInfo<ExamPaperAnswerPageResponseVM> page = PageInfoHelper.copyMap(pageInfo, e -> {
// 转换成ExamPaperAnswerPageResponseVM对象
ExamPaperAnswerPageResponseVM vm = modelMapper.map(e, ExamPaperAnswerPageResponseVM.class);
Subject subject = subjectService.selectById(vm.getSubjectId());
vm.setDoTime(ExamUtil.secondToVM(e.getDoTime()));
vm.setSystemScore(ExamUtil.scoreToVM(e.getSystemScore()));
vm.setUserScore(ExamUtil.scoreToVM(e.getUserScore()));
vm.setPaperScore(ExamUtil.scoreToVM(e.getPaperScore()));
vm.setSubjectName(subject.getName());
vm.setCreateTime(DateTimeUtil.dateFormat(e.getCreateTime()));
Subject subject = subjectService.selectById(vm.getSubjectId()); // 获取科目信息
vm.setDoTime(ExamUtil.secondToVM(e.getDoTime())); // 格式化做题时间
vm.setSystemScore(ExamUtil.scoreToVM(e.getSystemScore())); // 格式化系统得分
vm.setUserScore(ExamUtil.scoreToVM(e.getUserScore())); // 格式化用户得分
vm.setPaperScore(ExamUtil.scoreToVM(e.getPaperScore())); // 格式化试卷得分
vm.setSubjectName(subject.getName()); // 设置科目名称
vm.setCreateTime(DateTimeUtil.dateFormat(e.getCreateTime())); // 格式化创建时间
return vm;
});
return RestResponse.ok(page);
return RestResponse.ok(page); // 返回答题记录分页结果
}
// 提交学生的考试答案
@RequestMapping(value = "/answerSubmit", method = RequestMethod.POST)
public RestResponse answerSubmit(HttpServletRequest request) {
ExamPaperSubmitVM examPaperSubmitVM = requestToExamPaperSubmitVM(request);
User user = getCurrentUser();
ExamPaperAnswerInfo examPaperAnswerInfo = examPaperAnswerService.calculateExamPaperAnswer(examPaperSubmitVM, user);
ExamPaperSubmitVM examPaperSubmitVM = requestToExamPaperSubmitVM(request); // 获取提交的答题数据
User user = getCurrentUser(); // 获取当前用户(学生)
ExamPaperAnswerInfo examPaperAnswerInfo = examPaperAnswerService.calculateExamPaperAnswer(examPaperSubmitVM, user); // 计算答案并生成答题记录
if (null == examPaperAnswerInfo) {
return RestResponse.fail(2, "试卷不能重复做");
return RestResponse.fail(2, "试卷不能重复做"); // 如果试卷已经做过,返回错误提示
}
ExamPaperAnswer examPaperAnswer = examPaperAnswerInfo.getExamPaperAnswer();
Integer userScore = examPaperAnswer.getUserScore();
String scoreVm = ExamUtil.scoreToVM(userScore);
Integer userScore = examPaperAnswer.getUserScore(); // 获取学生的得分
String scoreVm = ExamUtil.scoreToVM(userScore); // 格式化得分
// 创建用户事件日志
UserEventLog userEventLog = new UserEventLog(user.getId(), user.getUserName(), user.getRealName(), new Date());
String content = user.getUserName() + " 提交试卷:" + examPaperAnswerInfo.getExamPaper().getName()
+ " 得分:" + scoreVm
+ " 耗时:" + ExamUtil.secondToVM(examPaperAnswer.getDoTime());
userEventLog.setContent(content);
eventPublisher.publishEvent(new CalculateExamPaperAnswerCompleteEvent(examPaperAnswerInfo));
eventPublisher.publishEvent(new UserEvent(userEventLog));
return RestResponse.ok(scoreVm);
userEventLog.setContent(content); // 设置事件日志内容
eventPublisher.publishEvent(new CalculateExamPaperAnswerCompleteEvent(examPaperAnswerInfo)); // 发布事件,计算答题完成
eventPublisher.publishEvent(new UserEvent(userEventLog)); // 发布用户事件
return RestResponse.ok(scoreVm); // 返回学生得分
}
// 从HttpServletRequest中提取提交的答案数据
private ExamPaperSubmitVM requestToExamPaperSubmitVM(HttpServletRequest request) {
ExamPaperSubmitVM examPaperSubmitVM = new ExamPaperSubmitVM();
examPaperSubmitVM.setId(Integer.parseInt(request.getParameter("id")));
examPaperSubmitVM.setDoTime(Integer.parseInt(request.getParameter("doTime")));
examPaperSubmitVM.setId(Integer.parseInt(request.getParameter("id"))); // 获取试卷ID
examPaperSubmitVM.setDoTime(Integer.parseInt(request.getParameter("doTime"))); // 获取答题时间
List<String> parameterNames = Collections.list(request.getParameterNames()).stream()
.filter(n -> n.contains("_"))
.filter(n -> n.contains("_")) // 筛选出包含“_”的参数名
.collect(Collectors.toList());
//题目答案按序号分组
// 按序号分组题目答案
Map<String, List<String>> questionGroup = parameterNames.stream().collect(Collectors.groupingBy(p -> p.substring(0, p.indexOf("_"))));
List<ExamPaperSubmitItemVM> answerItems = new ArrayList<>();
questionGroup.forEach((k, v) -> {
ExamPaperSubmitItemVM examPaperSubmitItemVM = new ExamPaperSubmitItemVM();
String p = v.get(0);
String[] keys = p.split("_");
examPaperSubmitItemVM.setQuestionId(Integer.parseInt(keys[1]));
examPaperSubmitItemVM.setItemOrder(Integer.parseInt(keys[0]));
QuestionTypeEnum typeEnum = QuestionTypeEnum.fromCode(Integer.parseInt(keys[2]));
String[] keys = p.split("_"); // 解析题目编号和类型
examPaperSubmitItemVM.setQuestionId(Integer.parseInt(keys[1])); // 设置题目ID
examPaperSubmitItemVM.setItemOrder(Integer.parseInt(keys[0])); // 设置题目序号
QuestionTypeEnum typeEnum = QuestionTypeEnum.fromCode(Integer.parseInt(keys[2])); // 获取题目类型
if (v.size() == 1) {
String content = request.getParameter(p);
examPaperSubmitItemVM.setContent(content);
examPaperSubmitItemVM.setContent(content); // 设置单个答案内容
if (typeEnum == QuestionTypeEnum.MultipleChoice) {
examPaperSubmitItemVM.setContentArray(Arrays.asList(content.split(",")));
examPaperSubmitItemVM.setContentArray(Arrays.asList(content.split(","))); // 多选题的答案处理
}
} else { //多个空 填空题
} else { // 对于填空题,处理多个答案
List<String> answers = v.stream().sorted(Comparator.comparingInt(ExamUtil::lastNum)).map(inputKey -> request.getParameter(inputKey)).collect(Collectors.toList());
examPaperSubmitItemVM.setContentArray(answers);
}
answerItems.add(examPaperSubmitItemVM);
answerItems.add(examPaperSubmitItemVM); // 将题目答案添加到答案列表
});
examPaperSubmitVM.setAnswerItems(answerItems);
examPaperSubmitVM.setAnswerItems(answerItems); // 设置答案项
return examPaperSubmitVM;
}
// 查看试卷的详细信息
@PostMapping(value = "/read/{id}")
public RestResponse<ExamPaperReadVM> read(@PathVariable Integer id) {
ExamPaperReadVM vm = new ExamPaperReadVM();
ExamPaperAnswer examPaperAnswer = examPaperAnswerService.selectById(id);
ExamPaperEditRequestVM paper = examPaperService.examPaperToVM(examPaperAnswer.getExamPaperId());
ExamPaperSubmitVM answer = examPaperAnswerService.examPaperAnswerToVM(examPaperAnswer.getId());
vm.setPaper(paper);
vm.setAnswer(answer);
return RestResponse.ok(vm);
ExamPaperAnswer examPaperAnswer = examPaperAnswerService.selectById(id); // 根据ID获取答题记录
ExamPaperEditRequestVM paper = examPaperService.examPaperToVM(examPaperAnswer.getExamPaperId()); // 获取试卷信息
ExamPaperSubmitVM answer = examPaperAnswerService.examPaperAnswerToVM(examPaperAnswer.getId()); // 获取答题信息
vm.setPaper(paper); // 设置试卷信息
vm.setAnswer(answer); // 设置答题信息
return RestResponse.ok(vm); // 返回试卷和答题信息
}
}

@ -1,31 +1,10 @@
package com.mindskip.xzs.controller.wx.student;
import com.mindskip.xzs.base.RestResponse;
import com.mindskip.xzs.controller.wx.BaseWXApiController;
import com.mindskip.xzs.domain.ExamPaper;
import com.mindskip.xzs.domain.Subject;
import com.mindskip.xzs.service.ExamPaperService;
import com.mindskip.xzs.service.SubjectService;
import com.mindskip.xzs.utility.DateTimeUtil;
import com.mindskip.xzs.utility.PageInfoHelper;
import com.mindskip.xzs.viewmodel.admin.exam.ExamPaperEditRequestVM;
import com.mindskip.xzs.viewmodel.student.exam.ExamPaperPageResponseVM;
import com.mindskip.xzs.viewmodel.student.exam.ExamPaperPageVM;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
@Controller("WXStudentExamController")
@RequestMapping(value = "/api/wx/student/exampaper")
@ResponseBody
@Controller("WXStudentExamController") // 控制器类,处理学生考试相关请求
@RequestMapping(value = "/api/wx/student/exampaper") // 定义路径指定该控制器处理的请求URL
@ResponseBody // 表示返回的对象会自动转换为JSON格式
public class ExamPaperController extends BaseWXApiController {
private final ExamPaperService examPaperService;
private final SubjectService subjectService;
private final ExamPaperService examPaperService; // 处理试卷相关的服务
private final SubjectService subjectService; // 处理科目相关的服务
@Autowired
public ExamPaperController(ExamPaperService examPaperService, SubjectService subjectService) {
@ -33,25 +12,27 @@ public class ExamPaperController extends BaseWXApiController {
this.subjectService = subjectService;
}
// 获取指定ID的试卷信息
@RequestMapping(value = "/select/{id}", method = RequestMethod.POST)
public RestResponse<ExamPaperEditRequestVM> select(@PathVariable Integer id) {
// 获取试卷信息并将其转换为ExamPaperEditRequestVM对象
ExamPaperEditRequestVM vm = examPaperService.examPaperToVM(id);
return RestResponse.ok(vm);
return RestResponse.ok(vm); // 返回试卷信息
}
// 获取学生试卷的分页列表
@RequestMapping(value = "/pageList", method = RequestMethod.POST)
public RestResponse<PageInfo<ExamPaperPageResponseVM>> pageList(@Valid ExamPaperPageVM model) {
model.setLevelId(getCurrentUser().getUserLevel());
PageInfo<ExamPaper> pageInfo = examPaperService.studentPage(model);
model.setLevelId(getCurrentUser().getUserLevel()); // 获取当前用户(学生)的级别
PageInfo<ExamPaper> pageInfo = examPaperService.studentPage(model); // 获取学生的试卷分页列表
PageInfo<ExamPaperPageResponseVM> page = PageInfoHelper.copyMap(pageInfo, e -> {
// 转换成ExamPaperPageResponseVM对象
ExamPaperPageResponseVM vm = modelMapper.map(e, ExamPaperPageResponseVM.class);
Subject subject = subjectService.selectById(vm.getSubjectId());
vm.setSubjectName(subject.getName());
vm.setCreateTime(DateTimeUtil.dateFormat(e.getCreateTime()));
Subject subject = subjectService.selectById(vm.getSubjectId()); // 获取科目信息
vm.setSubjectName(subject.getName()); // 设置科目名称
vm.setCreateTime(DateTimeUtil.dateFormat(e.getCreateTime())); // 格式化试卷创建时间
return vm;
});
return RestResponse.ok(page);
return RestResponse.ok(page); // 返回试卷的分页结果
}
}

@ -1,45 +1,13 @@
package com.mindskip.xzs.controller.wx.student;
import com.mindskip.xzs.base.RestResponse;
import com.mindskip.xzs.controller.wx.BaseWXApiController;
import com.mindskip.xzs.domain.Message;
import com.mindskip.xzs.domain.MessageUser;
import com.mindskip.xzs.domain.User;
import com.mindskip.xzs.domain.UserEventLog;
import com.mindskip.xzs.domain.enums.RoleEnum;
import com.mindskip.xzs.domain.enums.UserStatusEnum;
import com.mindskip.xzs.event.UserEvent;
import com.mindskip.xzs.service.AuthenticationService;
import com.mindskip.xzs.service.MessageService;
import com.mindskip.xzs.service.UserEventLogService;
import com.mindskip.xzs.service.UserService;
import com.mindskip.xzs.utility.DateTimeUtil;
import com.mindskip.xzs.utility.PageInfoHelper;
import com.mindskip.xzs.viewmodel.student.user.*;
import com.github.pagehelper.PageInfo;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.Date;
import java.util.List;
import java.util.UUID;
import java.util.stream.Collectors;
@Controller("WXStudentUserController")
@RequestMapping(value = "/api/wx/student/user")
@ResponseBody
@Controller("WXStudentUserController") // 控制器类,处理学生用户相关请求
@RequestMapping(value = "/api/wx/student/user") // 定义路径指定该控制器处理的请求URL
@ResponseBody // 返回结果会自动转换为JSON格式
public class UserController extends BaseWXApiController {
private final UserService userService;
private final UserEventLogService userEventLogService;
private final MessageService messageService;
private final AuthenticationService authenticationService;
private final ApplicationEventPublisher eventPublisher;
private final UserService userService; // 用户服务,用于处理用户相关操作
private final UserEventLogService userEventLogService; // 用户事件日志服务
private final MessageService messageService; // 消息服务,用于处理消息相关操作
private final AuthenticationService authenticationService; // 身份验证服务,用于密码加密等操作
private final ApplicationEventPublisher eventPublisher; // 事件发布器,用于发布用户事件
@Autowired
public UserController(UserService userService, UserEventLogService userEventLogService, MessageService messageService, AuthenticationService authenticationService, ApplicationEventPublisher eventPublisher) {
@ -50,100 +18,107 @@ public class UserController extends BaseWXApiController {
this.eventPublisher = eventPublisher;
}
// 获取当前用户信息
@RequestMapping(value = "/current", method = RequestMethod.POST)
public RestResponse<UserResponseVM> current() {
User user = getCurrentUser();
UserResponseVM userVm = UserResponseVM.from(user);
userVm.setBirthDay(DateTimeUtil.dateShortFormat(user.getBirthDay()));
return RestResponse.ok(userVm);
User user = getCurrentUser(); // 获取当前登录用户
UserResponseVM userVm = UserResponseVM.from(user); // 将用户信息转为UserResponseVM对象
userVm.setBirthDay(DateTimeUtil.dateShortFormat(user.getBirthDay())); // 格式化出生日期
return RestResponse.ok(userVm); // 返回用户信息
}
// 用户注册
@RequestMapping(value = "/register", method = RequestMethod.POST)
public RestResponse register(@Valid UserRegisterVM model) {
// 检查用户名是否已存在
User existUser = userService.getUserByUserName(model.getUserName());
if (null != existUser) {
return new RestResponse<>(2, "用户已存在");
}
User user = modelMapper.map(model, User.class);
String encodePwd = authenticationService.pwdEncode(model.getPassword());
user.setUserUuid(UUID.randomUUID().toString());
User user = modelMapper.map(model, User.class); // 将注册信息映射为用户对象
String encodePwd = authenticationService.pwdEncode(model.getPassword()); // 加密密码
user.setUserUuid(UUID.randomUUID().toString()); // 生成UUID
user.setPassword(encodePwd);
user.setRole(RoleEnum.STUDENT.getCode());
user.setStatus(UserStatusEnum.Enable.getCode());
user.setRole(RoleEnum.STUDENT.getCode()); // 设置角色为学生
user.setStatus(UserStatusEnum.Enable.getCode()); // 设置用户状态为启用
user.setLastActiveTime(new Date());
user.setCreateTime(new Date());
user.setDeleted(false);
userService.insertByFilter(user);
userService.insertByFilter(user); // 插入用户信息
UserEventLog userEventLog = new UserEventLog(user.getId(), user.getUserName(), user.getRealName(), new Date());
userEventLog.setContent("欢迎 " + user.getUserName() + " 注册来到学之思开源考试系统");
eventPublisher.publishEvent(new UserEvent(userEventLog));
return RestResponse.ok();
eventPublisher.publishEvent(new UserEvent(userEventLog)); // 发布用户注册事件
return RestResponse.ok(); // 返回注册成功响应
}
// 更新用户信息
@RequestMapping(value = "/update", method = RequestMethod.POST)
public RestResponse<UserResponseVM> update(@Valid UserUpdateVM model) {
if (StringUtils.isBlank(model.getBirthDay())) {
model.setBirthDay(null);
model.setBirthDay(null); // 如果生日为空则设置为null
}
User user = userService.selectById(getCurrentUser().getId());
modelMapper.map(model, user);
user.setModifyTime(new Date());
userService.updateByIdFilter(user);
User user = userService.selectById(getCurrentUser().getId()); // 获取当前用户信息
modelMapper.map(model, user); // 将更新的信息映射到用户对象
user.setModifyTime(new Date()); // 设置修改时间
userService.updateByIdFilter(user); // 更新用户信息
UserEventLog userEventLog = new UserEventLog(user.getId(), user.getUserName(), user.getRealName(), new Date());
userEventLog.setContent(user.getUserName() + " 更新了个人资料");
eventPublisher.publishEvent(new UserEvent(userEventLog));
UserResponseVM userVm = UserResponseVM.from(user);
return RestResponse.ok(userVm);
eventPublisher.publishEvent(new UserEvent(userEventLog)); // 发布用户信息更新事件
UserResponseVM userVm = UserResponseVM.from(user); // 转换成返回对象
return RestResponse.ok(userVm); // 返回更新后的用户信息
}
// 获取用户事件日志
@RequestMapping(value = "/log", method = RequestMethod.POST)
public RestResponse<List<UserEventLogVM>> log() {
User user = getCurrentUser();
List<UserEventLog> userEventLogs = userEventLogService.getUserEventLogByUserId(user.getId());
User user = getCurrentUser(); // 获取当前用户
List<UserEventLog> userEventLogs = userEventLogService.getUserEventLogByUserId(user.getId()); // 获取用户的事件日志
List<UserEventLogVM> userEventLogVMS = userEventLogs.stream().map(d -> {
UserEventLogVM vm = modelMapper.map(d, UserEventLogVM.class);
vm.setCreateTime(DateTimeUtil.dateFormat(d.getCreateTime()));
vm.setCreateTime(DateTimeUtil.dateFormat(d.getCreateTime())); // 格式化事件时间
return vm;
}).collect(Collectors.toList());
return RestResponse.ok(userEventLogVMS);
return RestResponse.ok(userEventLogVMS); // 返回事件日志列表
}
// 获取用户消息分页列表
@RequestMapping(value = "/message/page", method = RequestMethod.POST)
public RestResponse<PageInfo<MessageResponseVM>> messagePageList(MessageRequestVM messageRequestVM) {
messageRequestVM.setReceiveUserId(getCurrentUser().getId());
PageInfo<MessageUser> messageUserPageInfo = messageService.studentPage(messageRequestVM);
List<Integer> ids = messageUserPageInfo.getList().stream().map(d -> d.getMessageId()).collect(Collectors.toList());
List<Message> messages = ids.size() != 0 ? messageService.selectMessageByIds(ids) : null;
messageRequestVM.setReceiveUserId(getCurrentUser().getId()); // 设置接收者为当前用户
PageInfo<MessageUser> messageUserPageInfo = messageService.studentPage(messageRequestVM); // 获取消息分页
List<Integer> ids = messageUserPageInfo.getList().stream().map(d -> d.getMessageId()).collect(Collectors.toList()); // 获取消息ID列表
List<Message> messages = ids.size() != 0 ? messageService.selectMessageByIds(ids) : null; // 获取消息详情
PageInfo<MessageResponseVM> page = PageInfoHelper.copyMap(messageUserPageInfo, e -> {
MessageResponseVM vm = modelMapper.map(e, MessageResponseVM.class);
messages.stream().filter(d -> e.getMessageId().equals(d.getId())).findFirst().ifPresent(message -> {
vm.setTitle(message.getTitle());
vm.setContent(message.getContent());
vm.setSendUserName(message.getSendUserName());
vm.setTitle(message.getTitle()); // 设置消息标题
vm.setContent(message.getContent()); // 设置消息内容
vm.setSendUserName(message.getSendUserName()); // 设置发送者用户名
});
vm.setCreateTime(DateTimeUtil.dateFormat(e.getCreateTime()));
vm.setCreateTime(DateTimeUtil.dateFormat(e.getCreateTime())); // 格式化消息创建时间
return vm;
});
return RestResponse.ok(page);
return RestResponse.ok(page); // 返回消息分页结果
}
// 获取消息详情
@RequestMapping(value = "/message/detail/{id}", method = RequestMethod.POST)
public RestResponse messageDetail(@PathVariable Integer id) {
Message message = messageService.messageDetail(id);
return RestResponse.ok(message);
Message message = messageService.messageDetail(id); // 获取指定ID的消息详情
return RestResponse.ok(message); // 返回消息详情
}
// 获取未读消息数量
@RequestMapping(value = "/message/unreadCount", method = RequestMethod.POST)
public RestResponse unReadCount() {
Integer count = messageService.unReadCount(getCurrentUser().getId());
return RestResponse.ok(count);
Integer count = messageService.unReadCount(getCurrentUser().getId()); // 获取当前用户未读消息数量
return RestResponse.ok(count); // 返回未读消息数量
}
// 标记消息为已读
@RequestMapping(value = "/message/read/{id}", method = RequestMethod.POST)
public RestResponse read(@PathVariable Integer id) {
messageService.read(id);
return RestResponse.ok();
messageService.read(id); // 标记消息为已读
return RestResponse.ok(); // 返回成功响应
}
}

Loading…
Cancel
Save