wangys/schoolNews
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

serv-课程任务

Browse Source
This commit is contained in:
wangys
2025-10-22 17:57:30 +08:00
parent eef1c029b4
commit d0cebe1995
37 changed files with 1785 additions and 232 deletions
Download Patch File Download Diff File Expand all files Collapse all files

71
schoolNewsServ/study/src/main/java/org/xyzh/study/controller/CourseController.java
View File

@@ -9,6 +9,7 @@ import org.xyzh.common.core.domain.ResultDomain;
import org.xyzh.common.core.page.PageRequest;
import org.xyzh.common.dto.study.TbCourse;
import org.xyzh.common.dto.study.TbCourseChapter;
import org.xyzh.common.dto.study.TbCourseNode;
import org.xyzh.common.vo.ChapterVO;
import org.xyzh.common.vo.CourseVO;
import org.springframework.web.bind.annotation.PostMapping;
@@ -63,11 +64,11 @@ public class CourseController {
}
/**
* 更新课程
* 更新课程基本信息
*/
@PutMapping("/course")
public ResultDomain<TbCourse> updateCourse(@RequestBody TbCourse course) {
return courseService.updateCourse(course);
public ResultDomain<CourseVO> updateCourse(@RequestBody CourseVO courseVO) {
return courseService.updateCourse(courseVO);
}
/**
@@ -78,14 +79,68 @@ public class CourseController {
return courseService.deleteCourse(courseID);
}
/**
* @description 创建课程章节
* @param chapter 课程章节
* @return ResultDomain<TbCourseChapter> 创建结果
* @author yslg
* @since 2025-10-22
*/
@PostMapping("/course/chapter")
public ResultDomain<TbCourseChapter> createChapter(@RequestBody TbCourseChapter chapter) {
return courseService.createChapter(chapter);
}
/**
* 更新课程章节
*/
@PutMapping("/course/chapter")
public ResultDomain<TbCourseChapter> updateChapter(@RequestBody TbCourseChapter chapter) {
return courseService.updateChapter(chapter);
}
/**
* 删除课程章节
*/
@DeleteMapping("/course/chapter/{chapterID}")
public ResultDomain<Boolean> deleteChapter(@PathVariable String chapterID) {
return courseService.deleteChapter(chapterID);
}
/**
* @description 创建课程章节节点
* @param node 课程章节节点
* @return ResultDomain<TbCourseNode> 创建结果
* @author yslg
* @since 2025-10-22
*/
@PostMapping("/course/chapter/node")
public ResultDomain<TbCourseNode> createChapterNode(@RequestBody TbCourseNode node) {
return courseService.createChapterNode(node);
}
/**
* 更新课程章节节点
*/
@PutMapping("/course/chapter/node")
public ResultDomain<TbCourseNode> updateChapterNode(@RequestBody TbCourseNode node) {
return courseService.updateChapterNode(node);
}
/**
* 删除课程章节节点
*/
@DeleteMapping("/course/chapter/node/{nodeID}")
public ResultDomain<Boolean> deleteChapterNode(@PathVariable String nodeID) {
return courseService.deleteChapterNode(nodeID);
}
/**
* 更新课程状态
*/
@PutMapping("/{courseID}/status")
public ResultDomain<TbCourse> updateCourseStatus(
@PathVariable String courseID,
@RequestParam Integer status) {
return courseService.updateCourseStatus(courseID, status);
@PutMapping("/course/status")
public ResultDomain<TbCourse> updateCourseStatus(@RequestBody TbCourse course) {
return courseService.updateCourseStatus(course);
}
/**

136
schoolNewsServ/study/src/main/java/org/xyzh/study/controller/LearningTaskController.java
View File

@@ -1,15 +1,25 @@
package org.xyzh.study.controller;
import java.util.List;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.xyzh.api.study.task.LearningTaskService;
import org.xyzh.common.core.domain.ResultDomain;
import org.xyzh.common.core.page.PageParam;
import org.xyzh.common.core.page.PageRequest;
import org.xyzh.common.dto.study.TbLearningTask;
import org.xyzh.common.dto.study.TbTaskUser;
import org.xyzh.common.vo.TaskItemVO;
import org.xyzh.common.vo.TaskVO;
import org.xyzh.common.dto.study.TbTaskCourse;
import org.xyzh.common.dto.study.TbTaskResource;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
/**
* @description 学习任务控制器
@@ -19,7 +29,7 @@ import org.xyzh.common.dto.study.TbTaskResource;
* @since 2025-10-15
*/
@RestController
@RequestMapping("/study/task")
@RequestMapping("/study/tasks")
public class LearningTaskController {
private static final Logger logger = LoggerFactory.getLogger(LearningTaskController.class);
@@ -34,63 +44,84 @@ public class LearningTaskController {
return learningTaskService.getTaskList(filter);
}
/**
* 获取任务列表分页
*/
@PostMapping("/page")
public ResultDomain<TbLearningTask> getTaskPage(@RequestBody PageRequest<TbLearningTask> pageRequest) {
TbLearningTask filter = pageRequest.getFilter();
PageParam pageParam = pageRequest.getPageParam();
return learningTaskService.getTaskPage(filter, pageParam);
}
/**
* 根据ID获取任务详情
*/
@GetMapping("/{taskID}")
public ResultDomain<TbLearningTask> getTaskById(@PathVariable String taskID) {
public ResultDomain<TaskVO> getTaskById(@PathVariable("taskID") String taskID) {
return learningTaskService.getTaskById(taskID);
}
/**
* 创建任务
*/
@PostMapping("/create")
public ResultDomain<TbLearningTask> createTask(@RequestBody TbLearningTask task) {
return learningTaskService.createTask(task);
@PostMapping("/task")
public ResultDomain<TaskVO> createTask(@RequestBody TaskVO taskVO) {
return learningTaskService.createTask(taskVO);
}
/**
* 更新任务
*/
@PutMapping("/update")
public ResultDomain<TbLearningTask> updateTask(@RequestBody TbLearningTask task) {
return learningTaskService.updateTask(task);
@PutMapping("/task")
public ResultDomain<TaskVO> updateTask(@RequestBody TaskVO taskVO) {
return learningTaskService.updateTask(taskVO);
}
/**
* 删除任务
*/
@DeleteMapping("/{taskID}")
public ResultDomain<Boolean> deleteTask(@PathVariable String taskID) {
@DeleteMapping("/task")
public ResultDomain<Boolean> deleteTask(@PathVariable("taskID") String taskID) {
return learningTaskService.deleteTask(taskID);
}
/**
* 更新任务状态
*/
@PutMapping("/{taskID}/status")
public ResultDomain<TbLearningTask> updateTaskStatus(
@PathVariable String taskID,
@RequestParam Integer status) {
return learningTaskService.updateTaskStatus(taskID, status);
@PutMapping("/status")
public ResultDomain<TbLearningTask> updateTaskStatus(@RequestBody TbLearningTask task) {
return learningTaskService.updateTaskStatus(task.getTaskID(), task.getStatus());
}
/**
* 获取任务用户列表
*/
@GetMapping("/{taskID}/users")
public ResultDomain<TbTaskUser> getTaskUsers(@PathVariable String taskID) {
public ResultDomain<TaskItemVO> getTaskUsers(@PathVariable("taskID") String taskID) {
return learningTaskService.getTaskUsers(taskID);
}
/**
* 批量添加任务用户
*/
@PostMapping("/{taskID}/users")
public ResultDomain<TbTaskUser> addTaskUser(@PathVariable("taskID") String taskID, @RequestBody Map<String, List<String>> map) {
List<String> userIDs = map.get("userIDs");
return learningTaskService.addTaskUser(taskID, userIDs);
}
@DeleteMapping("/{taskID}/users")
public ResultDomain<Boolean> removeTaskUser(@PathVariable("taskID") String taskID, @RequestBody Map<String, List<String>> map) {
List<String> userIDs = map.get("userIDs");
return learningTaskService.removeTaskUser(taskID, userIDs);
}
/**
* 分配任务给用户
*/
@PostMapping("/{taskID}/assign")
public ResultDomain<TbTaskUser> assignTaskToUser(
@PathVariable String taskID,
@RequestParam String userID) {
public ResultDomain<TbTaskUser> assignTaskToUser(@PathVariable("taskID") String taskID, @RequestParam String userID) {
return null;
// return learningTaskService.assignTaskToUser(taskID, userID);
}
@@ -99,70 +130,19 @@ public class LearningTaskController {
* 从用户移除任务
*/
@DeleteMapping("/{taskID}/user/{userID}")
public ResultDomain<Boolean> removeTaskFromUser(
@PathVariable String taskID,
@PathVariable String userID) {
public ResultDomain<Boolean> removeTaskFromUser(@PathVariable("taskID") String taskID, @PathVariable("userID") String userID) {
return null;
// return learningTaskService.removeTaskFromUser(taskID, userID);
}
/**
* 获取任务课程列表
* 用户获取个人任务列表（用户视角）
*/
@GetMapping("/{taskID}/courses")
public ResultDomain<TbTaskCourse> getTaskCourses(@PathVariable String taskID) {
return learningTaskService.getTaskCourses(taskID);
}
/**
* 添加课程到任务
*/
@PostMapping("/{taskID}/course")
public ResultDomain<TbTaskCourse> addCourseToTask(
@PathVariable String taskID,
@RequestParam String courseID) {
return null;
// return learningTaskService.addCourseToTask(taskID, courseID);
}
/**
* 从任务移除课程
*/
@DeleteMapping("/{taskID}/course/{courseID}")
public ResultDomain<Boolean> removeCourseFromTask(
@PathVariable String taskID,
@PathVariable String courseID) {
return null;
// return learningTaskService.removeCourseFromTask(taskID, courseID);
}
/**
* 获取任务资源列表
*/
@GetMapping("/{taskID}/resources")
public ResultDomain<TbTaskResource> getTaskResources(@PathVariable String taskID) {
return learningTaskService.getTaskResources(taskID);
}
/**
* 添加资源到任务
*/
@PostMapping("/{taskID}/resource")
public ResultDomain<TbTaskResource> addResourceToTask(
@PathVariable String taskID,
@RequestParam String resourceID) {
return null;
// return learningTaskService.addResourceToTask(taskID, resourceID);
}
/**
* 从任务移除资源
*/
@DeleteMapping("/{taskID}/resource/{resourceID}")
public ResultDomain<Boolean> removeResourceFromTask(
@PathVariable String taskID,
@PathVariable String resourceID) {
return null;
// return learningTaskService.removeResourceFromTask(taskID, resourceID);
@PostMapping("/users/page")
public ResultDomain<TbLearningTask> getUserTaskPage(@RequestBody PageRequest<TaskItemVO> pageRequest) {
TaskItemVO filter = pageRequest.getFilter();
PageParam pageParam = pageRequest.getPageParam();
return learningTaskService.getUserTaskPage(filter, pageParam);
}
}

3
schoolNewsServ/study/src/main/java/org/xyzh/study/mapper/LearningTaskMapper.java
View File

@@ -5,6 +5,7 @@ import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.xyzh.common.core.page.PageParam;
import org.xyzh.common.dto.study.TbLearningTask;
import org.xyzh.common.vo.TaskItemVO;
import java.util.List;
@@ -155,6 +156,8 @@ public interface LearningTaskMapper extends BaseMapper<TbLearningTask> {
*/
List<TbLearningTask> selectLearningTasksPage(@Param("filter") TbLearningTask filter, @Param("pageParam") PageParam pageParam);
List<TbLearningTask> selectUserLearningTasksPage(@Param("filter") TaskItemVO filter, @Param("pageParam") PageParam pageParam);
/**
* @description 统计学习任务总数
* @param filter 过滤条件

3
schoolNewsServ/study/src/main/java/org/xyzh/study/mapper/TaskCourseMapper.java
View File

@@ -5,6 +5,7 @@ import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.xyzh.common.core.page.PageParam;
import org.xyzh.common.dto.study.TbTaskCourse;
import org.xyzh.common.vo.TaskItemVO;
import java.util.List;
@@ -45,6 +46,8 @@ public interface TaskCourseMapper extends BaseMapper<TbTaskCourse> {
*/
List<TbTaskCourse> selectByTaskId(@Param("taskId") String taskId);
List<TaskItemVO> selectTaskItemByTaskId(@Param("taskId") String taskId);
/**
* @description 根据课程ID查询任务关联列表
* @param courseId 课程ID

10
schoolNewsServ/study/src/main/java/org/xyzh/study/mapper/TaskResourceMapper.java
View File

@@ -5,6 +5,7 @@ import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.xyzh.common.core.page.PageParam;
import org.xyzh.common.dto.study.TbTaskResource;
import org.xyzh.common.vo.TaskItemVO;
import java.util.List;
@@ -45,6 +46,15 @@ public interface TaskResourceMapper extends BaseMapper<TbTaskResource> {
*/
List<TbTaskResource> selectByTaskId(@Param("taskId") String taskId);
/**
* @description 根据任务ID查询任务资源关联列表
* @param taskId 任务ID
* @return List<TaskItemVO> 任务资源关联列表
* @author yslg
* @since 2025-10-15
*/
List<TaskItemVO> selectTaskItemByTaskId(@Param("taskId") String taskId);
/**
* @description 根据资源ID查询任务关联列表
* @param resourceId 资源ID

13
schoolNewsServ/study/src/main/java/org/xyzh/study/mapper/TaskUserMapper.java
View File

@@ -5,6 +5,7 @@ import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.xyzh.common.core.page.PageParam;
import org.xyzh.common.dto.study.TbTaskUser;
import org.xyzh.common.vo.TaskItemVO;
import java.util.List;
@@ -45,6 +46,7 @@ public interface TaskUserMapper extends BaseMapper<TbTaskUser> {
*/
List<TbTaskUser> selectByTaskId(@Param("taskId") String taskId);
List<TaskItemVO> selectTaskItemByTaskId(@Param("taskId") String taskId);
/**
* @description 根据用户ID查询任务关联列表
* @param userId 用户ID
@@ -103,15 +105,6 @@ public interface TaskUserMapper extends BaseMapper<TbTaskUser> {
*/
int insertTaskUser(TbTaskUser taskUser);
/**
* @description 更新任务用户关联
* @param taskUser 任务用户关联
* @return int 影响行数
* @author yslg
* @since 2025-10-15
*/
int updateTaskUser(TbTaskUser taskUser);
/**
* @description 删除任务用户关联
* @param taskUser 任务用户关联
@@ -137,7 +130,7 @@ public interface TaskUserMapper extends BaseMapper<TbTaskUser> {
* @author yslg
* @since 2025-10-15
*/
int batchDeleteTaskUsers(@Param("ids") List<String> ids);
int batchDeleteTaskUsers(@Param("taskId") String taskId, @Param("userIds") List<String> userIds);
/**
* @description 根据任务ID批量删除用户关联

329
schoolNewsServ/study/src/main/java/org/xyzh/study/service/impl/SCCourseServiceImpl.java
View File

@@ -2,8 +2,11 @@ package org.xyzh.study.service.impl;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import org.slf4j.Logger;
@@ -55,8 +58,10 @@ public class SCCourseServiceImpl implements SCCourseService {
@Override
public ResultDomain<TbCourse> getCourseList(TbCourse filter) {
// TODO: 实现获取课程列表
return null;
ResultDomain<TbCourse> resultDomain = new ResultDomain<>();
List<TbCourse> courses = courseMapper.selectCourses(filter);
resultDomain.success("获取课程列表成功", courses);
return resultDomain;
}
@Override
@@ -174,21 +179,248 @@ public class SCCourseServiceImpl implements SCCourseService {
}
@Override
public ResultDomain<TbCourse> updateCourse(TbCourse course) {
// TODO: 实现更新课程
return null;
public ResultDomain<CourseVO> updateCourse(CourseVO courseVO) {
ResultDomain<CourseVO> resultDomain = new ResultDomain<>();
TbSysUser user = LoginUtil.getCurrentUser();
if (user == null) {
resultDomain.fail("请先登录");
return resultDomain;
}
TbCourse course = courseVO.getCourse();
String courseID = course.getCourseID();
if (courseID == null || courseID.isEmpty()) {
resultDomain.fail("课程ID不能为空");
return resultDomain;
}
// 1. 更新课程基本信息
course.setUpdater(user.getID());
course.setUpdateTime(new Date());
courseMapper.updateCourse(course);
// 2. 处理章节和节点
List<ChapterVO> newChapterVOs = courseVO.getCourseChapters();
if (newChapterVOs == null) {
newChapterVOs = new ArrayList<>();
}
// 获取数据库中现有的章节
TbCourseChapter filter = new TbCourseChapter();
filter.setCourseID(courseID);
List<TbCourseChapter> existingChapters = courseChapterMapper.selectCourseChapters(filter);
Map<String, TbCourseChapter> existingChapterMap = existingChapters.stream()
.collect(Collectors.toMap(TbCourseChapter::getChapterID, chapter -> chapter));
// 获取数据库中现有的节点
List<String> existingChapterIDs = existingChapters.stream()
.map(TbCourseChapter::getChapterID)
.collect(Collectors.toList());
Map<String, List<TbCourseNode>> existingNodesMap = new HashMap<>();
if (!existingChapterIDs.isEmpty()) {
List<TbCourseNode> existingNodes = courseNodeMapper.selectCourseNodesByChapterIDs(existingChapterIDs);
existingNodesMap = existingNodes.stream()
.collect(Collectors.groupingBy(TbCourseNode::getChapterID));
}
// 收集新的章节ID和节点
List<TbCourseChapter> chaptersToInsert = new ArrayList<>();
List<TbCourseChapter> chaptersToUpdate = new ArrayList<>();
List<TbCourseNode> nodesToInsert = new ArrayList<>();
List<TbCourseNode> nodesToUpdate = new ArrayList<>();
Set<String> newChapterIDs = new HashSet<>();
Date now = new Date();
// 遍历新的章节
for (int i = 0; i < newChapterVOs.size(); i++) {
ChapterVO chapterVO = newChapterVOs.get(i);
TbCourseChapter chapter = chapterVO.getChapter();
String chapterID = chapter.getChapterID();
chapter.setCourseID(courseID);
chapter.setOrderNum(i);
// 判断是新增还是更新
if (chapterID == null || chapterID.isEmpty() || !existingChapterMap.containsKey(chapterID)) {
// 新增章节
chapterID = IDUtils.generateID();
chapter.setID(IDUtils.generateID());
chapter.setChapterID(chapterID);
chapter.setCreator(user.getID());
chapter.setCreateTime(now);
chaptersToInsert.add(chapter);
} else {
// 更新章节
chapter.setID(existingChapterMap.get(chapterID).getID());
chapter.setUpdater(user.getID());
chapter.setUpdateTime(now);
chaptersToUpdate.add(chapter);
}
newChapterIDs.add(chapterID);
// 处理该章节的节点
List<TbCourseNode> newNodes = chapterVO.getNodes();
if (newNodes == null) {
newNodes = new ArrayList<>();
}
List<TbCourseNode> existingNodesForChapter = existingNodesMap.getOrDefault(chapterID, new ArrayList<>());
Map<String, TbCourseNode> existingNodeMap = existingNodesForChapter.stream()
.collect(Collectors.toMap(TbCourseNode::getNodeID, node -> node));
Set<String> newNodeIDs = new HashSet<>();
// 遍历新的节点
for (int j = 0; j < newNodes.size(); j++) {
TbCourseNode node = newNodes.get(j);
String nodeID = node.getNodeID();
node.setChapterID(chapterID);
node.setOrderNum(j);
// 判断是新增还是更新
if (nodeID == null || nodeID.isEmpty() || !existingNodeMap.containsKey(nodeID)) {
// 新增节点
nodeID = IDUtils.generateID();
node.setID(IDUtils.generateID());
node.setNodeID(nodeID);
node.setCreator(user.getID());
node.setCreateTime(now);
nodesToInsert.add(node);
} else {
// 更新节点
node.setID(existingNodeMap.get(nodeID).getID());
node.setUpdater(user.getID());
node.setUpdateTime(now);
nodesToUpdate.add(node);
}
newNodeIDs.add(nodeID);
}
// 找出要删除的节点
List<String> nodeIDsToDelete = existingNodeMap.keySet().stream()
.filter(id -> !newNodeIDs.contains(id))
.collect(Collectors.toList());
if (!nodeIDsToDelete.isEmpty()) {
courseNodeMapper.batchDeleteCourseNodes(nodeIDsToDelete);
}
}
// 找出要删除的章节
List<String> chapterIDsToDelete = existingChapterMap.keySet().stream()
.filter(id -> !newChapterIDs.contains(id))
.collect(Collectors.toList());
// 删除章节及其节点
if (!chapterIDsToDelete.isEmpty()) {
for (String chapterId : chapterIDsToDelete) {
courseNodeMapper.deleteByChapterId(chapterId);
}
courseChapterMapper.batchDeleteCourseChapters(chapterIDsToDelete);
}
// 执行批量插入和更新
if (!chaptersToInsert.isEmpty()) {
courseChapterMapper.batchInsertCourseChapters(chaptersToInsert);
}
if (!chaptersToUpdate.isEmpty()) {
for (TbCourseChapter chapter : chaptersToUpdate) {
courseChapterMapper.updateCourseChapter(chapter);
}
}
if (!nodesToInsert.isEmpty()) {
courseNodeMapper.batchInsertCourseNodes(nodesToInsert);
}
if (!nodesToUpdate.isEmpty()) {
for (TbCourseNode node : nodesToUpdate) {
courseNodeMapper.updateCourseNode(node);
}
}
// 3. 处理标签
List<TbCourseTag> newTags = courseVO.getCourseTags();
if (newTags == null) {
newTags = new ArrayList<>();
}
// 获取现有标签
List<TbCourseTag> existingTags = courseTagMapper.selectByCourseId(courseID);
Map<String, TbCourseTag> existingTagMap = existingTags.stream()
.collect(Collectors.toMap(TbCourseTag::getTagID, tag -> tag));
Set<String> newTagIDs = new HashSet<>();
List<TbCourseTag> tagsToInsert = new ArrayList<>();
// 处理新标签
for (TbCourseTag tag : newTags) {
String tagID = tag.getTagID();
if (tagID == null || tagID.isEmpty() || !existingTagMap.containsKey(tagID)) {
// 新增标签
tag.setID(IDUtils.generateID());
tag.setCourseID(courseID);
tag.setCreator(user.getID());
tag.setCreateTime(now);
tagsToInsert.add(tag);
} else {
newTagIDs.add(tagID);
}
}
// 找出要删除的标签
List<String> tagIDsToDelete = existingTagMap.keySet().stream()
.filter(id -> !newTagIDs.contains(id))
.collect(Collectors.toList());
if (!tagIDsToDelete.isEmpty()) {
courseTagMapper.batchDeleteCourseTags(tagIDsToDelete);
}
if (!tagsToInsert.isEmpty()) {
courseTagMapper.batchInsertCourseTags(tagsToInsert);
}
resultDomain.success("更新课程成功", courseVO);
return resultDomain;
}
@Override
public ResultDomain<Boolean> deleteCourse(String courseID) {
// TODO: 实现删除课程
return null;
ResultDomain<Boolean> resultDomain = new ResultDomain<>();
TbCourse course = new TbCourse();
course.setCourseID(courseID);
int result = courseMapper.deleteCourse(course);
if (result > 0) {
resultDomain.success("删除课程成功", true);
return resultDomain;
} else {
resultDomain.fail("删除课程失败");
return resultDomain;
}
}
@Override
public ResultDomain<TbCourse> updateCourseStatus(String courseID, Integer status) {
// TODO: 实现更新课程状态
return null;
public ResultDomain<TbCourse> updateCourseStatus(TbCourse course) {
ResultDomain<TbCourse> resultDomain = new ResultDomain<>();
int result = courseMapper.updateCourse(course);
if (result > 0) {
resultDomain.success("更新课程状态成功", course);
return resultDomain;
}
else {
resultDomain.fail("更新课程状态失败");
return resultDomain;
}
}
@Override
@@ -217,20 +449,43 @@ public class SCCourseServiceImpl implements SCCourseService {
@Override
public ResultDomain<TbCourseChapter> createChapter(TbCourseChapter chapter) {
// TODO: 实现创建课程章节
return null;
ResultDomain<TbCourseChapter> resultDomain = new ResultDomain<>();
int result = courseChapterMapper.insertCourseChapter(chapter);
if (result > 0) {
resultDomain.success("创建课程章节成功", chapter);
return resultDomain;
} else {
resultDomain.fail("创建课程章节失败");
return resultDomain;
}
}
@Override
public ResultDomain<TbCourseChapter> updateChapter(TbCourseChapter chapter) {
// TODO: 实现更新课程章节
return null;
ResultDomain<TbCourseChapter> resultDomain = new ResultDomain<>();
int result = courseChapterMapper.updateCourseChapter(chapter);
if (result > 0) {
resultDomain.success("更新课程章节成功", chapter);
return resultDomain;
} else {
resultDomain.fail("更新课程章节失败");
return resultDomain;
}
}
@Override
public ResultDomain<Boolean> deleteChapter(String chapterID) {
// TODO: 实现删除课程章节
return null;
ResultDomain<Boolean> resultDomain = new ResultDomain<>();
TbCourseChapter chapter = new TbCourseChapter();
chapter.setChapterID(chapterID);
int result = courseChapterMapper.deleteCourseChapter(chapter);
if (result > 0) {
resultDomain.success("删除课程章节成功", true);
return resultDomain;
} else {
resultDomain.fail("删除课程章节失败");
return resultDomain;
}
}
@Override
@@ -238,4 +493,46 @@ public class SCCourseServiceImpl implements SCCourseService {
// TODO: 实现更新章节排序
return null;
}
@Override
public ResultDomain<TbCourseNode> createChapterNode(TbCourseNode node) {
ResultDomain<TbCourseNode> resultDomain = new ResultDomain<>();
int result = courseNodeMapper.insertCourseNode(node);
if (result > 0) {
resultDomain.success("创建课程章节节点成功", node);
return resultDomain;
}else{
resultDomain.fail("创建课程章节节点失败");
return resultDomain;
}
}
@Override
public ResultDomain<TbCourseNode> updateChapterNode(TbCourseNode node) {
ResultDomain<TbCourseNode> resultDomain = new ResultDomain<>();
int result = courseNodeMapper.updateCourseNode(node);
if (result > 0) {
resultDomain.success("更新课程章节节点成功", node);
return resultDomain;
}else{
resultDomain.fail("更新课程章节节点失败");
return resultDomain;
}
}
@Override
public ResultDomain<Boolean> deleteChapterNode(String nodeID) {
ResultDomain<Boolean> resultDomain = new ResultDomain<>();
TbCourseNode node = new TbCourseNode();
node.setNodeID(nodeID);
int result = courseNodeMapper.deleteCourseNode(node);
if (result > 0) {
resultDomain.success("删除课程章节节点成功", true);
return resultDomain;
} else {
resultDomain.fail("删除课程章节节点失败");
return resultDomain;
}
}
}

365
schoolNewsServ/study/src/main/java/org/xyzh/study/service/impl/SCLearningTaskServiceImpl.java
View File

@@ -1,19 +1,32 @@
package org.xyzh.study.service.impl;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.xyzh.common.core.domain.ResultDomain;
import org.xyzh.common.core.page.PageDomain;
import org.xyzh.common.core.page.PageParam;
import org.xyzh.common.dto.user.TbSysUser;
import org.xyzh.common.utils.IDUtils;
import org.xyzh.common.dto.study.TbLearningTask;
import org.xyzh.common.dto.study.TbTaskUser;
import org.xyzh.common.dto.study.TbTaskCourse;
import org.xyzh.common.dto.study.TbTaskResource;
import org.xyzh.common.vo.TaskItemVO;
import org.xyzh.common.vo.TaskVO;
import org.xyzh.study.mapper.LearningTaskMapper;
import org.xyzh.study.mapper.TaskUserMapper;
import org.xyzh.system.utils.LoginUtil;
import org.xyzh.study.mapper.TaskCourseMapper;
import org.xyzh.study.mapper.TaskResourceMapper;
import org.xyzh.api.study.task.LearningTaskService;
@@ -55,9 +68,31 @@ public class SCLearningTaskServiceImpl implements LearningTaskService {
}
@Override
public ResultDomain<TbTaskUser> addTaskUser(TbTaskUser taskUser) {
// TODO Auto-generated method stub
return null;
public ResultDomain<TbTaskUser> addTaskUser(String taskID, List<String> userIDs) {
ResultDomain<TbTaskUser> resultDomain = new ResultDomain<>();
TbSysUser user = LoginUtil.getCurrentUser();
if (user == null) {
resultDomain.fail("请先登录");
return resultDomain;
}
List<TbTaskUser> taskUsers = new ArrayList<>();
for (String userID : userIDs) {
TbTaskUser taskUser = new TbTaskUser();
taskUser.setID(IDUtils.generateID());
taskUser.setTaskID(taskID);
taskUser.setUserID(userID);
taskUser.setCreator(user.getID());
taskUser.setCreateTime(new Date());
taskUsers.add(taskUser);
}
int result = taskUserMapper.batchInsertTaskUsers(taskUsers);
if (result > 0) {
resultDomain.success("添加任务用户成功", taskUsers);
return resultDomain;
} else {
resultDomain.fail("添加任务用户失败");
return resultDomain;
}
}
@Override
@@ -67,9 +102,255 @@ public class SCLearningTaskServiceImpl implements LearningTaskService {
}
@Override
public ResultDomain<TbLearningTask> createTask(TbLearningTask task) {
// TODO Auto-generated method stub
return null;
public ResultDomain<TbLearningTask> getTaskPage(TbLearningTask filter, PageParam pageParam) {
ResultDomain<TbLearningTask> resultDomain = new ResultDomain<>();
List<TbLearningTask> taskList = learningTaskMapper.selectLearningTasksPage(filter, pageParam);
long total = learningTaskMapper.countLearningTasks(filter);
pageParam.setTotalElements(total);
pageParam.setTotalPages((int) Math.ceil((double) total / pageParam.getPageSize()));
PageDomain<TbLearningTask> pageDomain = new PageDomain<>();
pageDomain.setDataList(taskList);
pageDomain.setPageParam(pageParam);
resultDomain.success("获取任务列表分页成功", pageDomain);
return resultDomain;
}
@Override
public ResultDomain<TbLearningTask> getUserTaskPage(TaskItemVO filter, PageParam pageParam) {
ResultDomain<TbLearningTask> resultDomain = new ResultDomain<>();
TbSysUser user = LoginUtil.getCurrentUser();
if (user == null) {
resultDomain.fail("请先登录");
return resultDomain;
}
filter.setUserID(user.getID());
List<TbLearningTask> taskList = learningTaskMapper.selectUserLearningTasksPage(filter, pageParam);
long total = learningTaskMapper.countLearningTasks(filter);
pageParam.setTotalElements(total);
pageParam.setTotalPages((int) Math.ceil((double) total / pageParam.getPageSize()));
PageDomain<TbLearningTask> pageDomain = new PageDomain<>();
pageDomain.setDataList(taskList);
pageDomain.setPageParam(pageParam);
resultDomain.success("获取任务列表分页成功", pageDomain);
return resultDomain;
}
@Override
public ResultDomain<TaskVO> createTask(TaskVO taskVO) {
ResultDomain<TaskVO> resultDomain = new ResultDomain<>();
TbSysUser currentUser = LoginUtil.getCurrentUser();
String taskID = IDUtils.generateID();
Date now = new Date();
// 创建任务
TbLearningTask learningTask = taskVO.getLearningTask();
learningTask.setCreator(currentUser.getID());
learningTask.setID(IDUtils.generateID());
learningTask.setTaskID(taskID);
learningTask.setCreateTime(now);
learningTaskMapper.insertLearningTask(learningTask);
// 绑定课程
List<TbTaskCourse> taskCourses = taskVO.toTaskCourses();
taskCourses.forEach(item -> {
item.setTaskID(taskID);
item.setCreator(currentUser.getID());
item.setCreateTime(now);
});
taskCourseMapper.batchInsertTaskCourses(taskCourses);
// 绑定资源
List<TbTaskResource> taskResources = taskVO.toTaskResources();
taskResources.forEach(item -> {
item.setTaskID(taskID);
item.setCreator(currentUser.getID());
item.setCreateTime(now);
});
taskResourceMapper.batchInsertTaskResources(taskResources);
// 绑定用户
List<TbTaskUser> taskUsers = taskVO.toTaskUsers();
taskUsers.forEach(item -> {
item.setTaskID(taskID);
item.setCreator(currentUser.getID());
item.setCreateTime(now);
});
taskUserMapper.batchInsertTaskUsers(taskUsers);
resultDomain.success("创建任务成功", taskVO);
return resultDomain;
}
@Override
public ResultDomain<TaskVO> updateTask(TaskVO taskVO) {
ResultDomain<TaskVO> resultDomain = new ResultDomain<>();
TbSysUser user = LoginUtil.getCurrentUser();
if (user == null) {
resultDomain.fail("请先登录");
return resultDomain;
}
TbLearningTask task = taskVO.getLearningTask();
String taskID = task.getTaskID();
if (taskID == null || taskID.isEmpty()) {
resultDomain.fail("任务ID不能为空");
return resultDomain;
}
Date now = new Date();
// 1. 更新任务基本信息
task.setUpdater(user.getID());
task.setUpdateTime(now);
learningTaskMapper.updateLearningTask(task);
// 2. 处理任务课程关联
List<TaskItemVO> newCourseItems = taskVO.getTaskCourses();
if (newCourseItems == null) {
newCourseItems = new ArrayList<>();
}
// 获取现有的课程关联
List<TbTaskCourse> existingCourses = taskCourseMapper.selectByTaskId(taskID);
Map<String, TbTaskCourse> existingCourseMap = existingCourses.stream()
.collect(Collectors.toMap(TbTaskCourse::getCourseID, course -> course));
Set<String> newCourseIDs = new HashSet<>();
List<TbTaskCourse> coursesToInsert = new ArrayList<>();
// 处理新的课程关联
for (TaskItemVO item : newCourseItems) {
String courseID = item.getCourseID();
if (courseID == null || courseID.isEmpty()) {
continue;
}
newCourseIDs.add(courseID);
// 如果不存在，则新增
if (!existingCourseMap.containsKey(courseID)) {
TbTaskCourse taskCourse = new TbTaskCourse();
taskCourse.setID(IDUtils.generateID());
taskCourse.setTaskID(taskID);
taskCourse.setCourseID(courseID);
taskCourse.setCreator(user.getID());
taskCourse.setCreateTime(now);
coursesToInsert.add(taskCourse);
}
}
// 找出要删除的课程关联
List<String> courseIDsToDelete = existingCourseMap.values().stream()
.filter(course -> !newCourseIDs.contains(course.getCourseID()))
.map(TbTaskCourse::getID)
.collect(Collectors.toList());
if (!courseIDsToDelete.isEmpty()) {
taskCourseMapper.batchDeleteTaskCourses(courseIDsToDelete);
}
if (!coursesToInsert.isEmpty()) {
taskCourseMapper.batchInsertTaskCourses(coursesToInsert);
}
// 3. 处理任务资源关联
List<TaskItemVO> newResourceItems = taskVO.getTaskResources();
if (newResourceItems == null) {
newResourceItems = new ArrayList<>();
}
// 获取现有的资源关联
List<TbTaskResource> existingResources = taskResourceMapper.selectByTaskId(taskID);
Map<String, TbTaskResource> existingResourceMap = existingResources.stream()
.collect(Collectors.toMap(TbTaskResource::getResourceID, resource -> resource));
Set<String> newResourceIDs = new HashSet<>();
List<TbTaskResource> resourcesToInsert = new ArrayList<>();
// 处理新的资源关联
for (TaskItemVO item : newResourceItems) {
String resourceID = item.getResourceID();
if (resourceID == null || resourceID.isEmpty()) {
continue;
}
newResourceIDs.add(resourceID);
// 如果不存在，则新增
if (!existingResourceMap.containsKey(resourceID)) {
TbTaskResource taskResource = new TbTaskResource();
taskResource.setID(IDUtils.generateID());
taskResource.setTaskID(taskID);
taskResource.setResourceID(resourceID);
taskResource.setCreator(user.getID());
taskResource.setCreateTime(now);
resourcesToInsert.add(taskResource);
}
}
// 找出要删除的资源关联
List<String> resourceIDsToDelete = existingResourceMap.values().stream()
.filter(resource -> !newResourceIDs.contains(resource.getResourceID()))
.map(TbTaskResource::getID)
.collect(Collectors.toList());
if (!resourceIDsToDelete.isEmpty()) {
taskResourceMapper.batchDeleteTaskResources(resourceIDsToDelete);
}
if (!resourcesToInsert.isEmpty()) {
taskResourceMapper.batchInsertTaskResources(resourcesToInsert);
}
// 4. 处理任务用户关联
List<TaskItemVO> newUserItems = taskVO.getTaskUsers();
if (newUserItems == null) {
newUserItems = new ArrayList<>();
}
// 获取现有的用户关联
List<TbTaskUser> existingUsers = taskUserMapper.selectByTaskId(taskID);
Map<String, TbTaskUser> existingUserMap = existingUsers.stream()
.collect(Collectors.toMap(TbTaskUser::getUserID, taskUser -> taskUser));
Set<String> newUserIDs = new HashSet<>();
List<TbTaskUser> usersToInsert = new ArrayList<>();
// 处理新的用户关联
for (TaskItemVO item : newUserItems) {
String userID = item.getUserID();
if (userID == null || userID.isEmpty()) {
continue;
}
newUserIDs.add(userID);
// 如果不存在，则新增
if (!existingUserMap.containsKey(userID)) {
TbTaskUser taskUser = new TbTaskUser();
taskUser.setID(IDUtils.generateID());
taskUser.setTaskID(taskID);
taskUser.setUserID(userID);
taskUser.setCreator(user.getID());
taskUser.setCreateTime(now);
usersToInsert.add(taskUser);
}
}
// 找出要删除的用户关联
List<String> userIDsToDelete = existingUserMap.values().stream()
.filter(taskUser -> !newUserIDs.contains(taskUser.getUserID()))
.map(TbTaskUser::getID)
.collect(Collectors.toList());
if (!userIDsToDelete.isEmpty()) {
taskUserMapper.batchDeleteTaskUsers(taskID, userIDsToDelete);
}
if (!usersToInsert.isEmpty()) {
taskUserMapper.batchInsertTaskUsers(usersToInsert);
}
resultDomain.success("更新任务成功", taskVO);
return resultDomain;
}
@Override
@@ -79,9 +360,23 @@ public class SCLearningTaskServiceImpl implements LearningTaskService {
}
@Override
public ResultDomain<TbLearningTask> getTaskById(String taskID) {
// TODO Auto-generated method stub
return null;
public ResultDomain<TaskVO> getTaskById(String taskID) {
ResultDomain<TaskVO> resultDomain = new ResultDomain<>();
TaskVO taskVO = new TaskVO();
TbLearningTask task = learningTaskMapper.selectByTaskId(taskID);
if (task == null) {
resultDomain.fail("任务不存在");
return resultDomain;
}
List<TaskItemVO> taskCourses = taskCourseMapper.selectTaskItemByTaskId(taskID);
List<TaskItemVO> taskResources = taskResourceMapper.selectTaskItemByTaskId(taskID);
List<TaskItemVO> taskUsers = taskUserMapper.selectTaskItemByTaskId(taskID);
taskVO.setLearningTask(task);
taskVO.setTaskCourses(taskCourses);
taskVO.setTaskResources(taskResources);
taskVO.setTaskUsers(taskUsers);
resultDomain.success("获取任务详情成功", taskVO);
return resultDomain;
}
@Override
@@ -103,9 +398,11 @@ public class SCLearningTaskServiceImpl implements LearningTaskService {
}
@Override
public ResultDomain<TbTaskUser> getTaskUsers(String taskID) {
// TODO Auto-generated method stub
return null;
public ResultDomain<TaskItemVO> getTaskUsers(String taskID) {
ResultDomain<TaskItemVO> resultDomain = new ResultDomain<>();
List<TaskItemVO> taskUsers = taskUserMapper.selectTaskItemByTaskId(taskID);
resultDomain.success("获取任务用户列表成功", taskUsers);
return resultDomain;
}
@Override
@@ -121,21 +418,45 @@ public class SCLearningTaskServiceImpl implements LearningTaskService {
}
@Override
public ResultDomain<Boolean> removeTaskUser(String taskID, String userID) {
// TODO Auto-generated method stub
return null;
}
public ResultDomain<Boolean> removeTaskUser(String taskID, List<String> userIDs) {
@Override
public ResultDomain<TbLearningTask> updateTask(TbLearningTask task) {
// TODO Auto-generated method stub
return null;
ResultDomain<Boolean> resultDomain = new ResultDomain<>();
TbSysUser user = LoginUtil.getCurrentUser();
if (user == null) {
resultDomain.fail("请先登录");
return resultDomain;
}
int result = taskUserMapper.batchDeleteTaskUsers(taskID, userIDs);
if (result > 0) {
resultDomain.success("移除任务用户成功", true);
return resultDomain;
} else {
resultDomain.fail("移除任务用户失败");
return resultDomain;
}
}
@Override
public ResultDomain<TbLearningTask> updateTaskStatus(String taskID, Integer status) {
// TODO Auto-generated method stub
return null;
ResultDomain<TbLearningTask> resultDomain = new ResultDomain<>();
TbSysUser user = LoginUtil.getCurrentUser();
if (user == null) {
resultDomain.fail("请先登录");
return resultDomain;
}
TbLearningTask task = new TbLearningTask();
task.setUpdater(user.getID());
task.setUpdateTime(new Date());
task.setTaskID(taskID);
task.setStatus(status);
int result = learningTaskMapper.updateLearningTask(task);
if (result > 0) {
resultDomain.success("更新任务状态成功", task);
return resultDomain;
} else {
resultDomain.fail("更新任务状态失败");
return resultDomain;
}
}
@Override

54
schoolNewsServ/study/src/main/resources/mapper/CourseMapper.xml
View File

@@ -50,29 +50,32 @@
</where>
</sql>
<sql id="Filter_Clause">
<if test="filter != null">
<if test="filter.courseID != null and filter.courseID != ''">
AND course_id = #{filter.courseID}
<where>
deleted = 0
<if test="filter != null">
<if test="filter.courseID != null and filter.courseID != ''">
AND course_id = #{filter.courseID}
</if>
</if>
</if>
<if test="filter.name != null and filter.name != ''">
AND name LIKE CONCAT('%', #{filter.name}, '%')
</if>
<if test="filter.teacher != null and filter.teacher != ''">
AND teacher LIKE CONCAT('%', #{filter.teacher}, '%')
</if>
<if test="filter.status != null">
AND status = #{filter.status}
</if>
<if test="filter.orderNum != null">
AND order_num = #{filter.orderNum}
</if>
<if test="filter.creator != null and filter.creator != ''">
AND creator = #{filter.creator}
</if>
<if test="filter.createTime != null">
AND create_time = #{filter.createTime}
</if>
<if test="filter.name != null and filter.name != ''">
AND name LIKE CONCAT('%', #{filter.name}, '%')
</if>
<if test="filter.teacher != null and filter.teacher != ''">
AND teacher LIKE CONCAT('%', #{filter.teacher}, '%')
</if>
<if test="filter.status != null">
AND status = #{filter.status}
</if>
<if test="filter.orderNum != null">
AND order_num = #{filter.orderNum}
</if>
<if test="filter.creator != null and filter.creator != ''">
AND creator = #{filter.creator}
</if>
<if test="filter.createTime != null">
AND create_time = #{filter.createTime}
</if>
</where>
</sql>
<!-- selectCourses -->
@@ -189,9 +192,6 @@
<update id="updateCourse" parameterType="org.xyzh.common.dto.study.TbCourse">
UPDATE tb_course
<set>
<if test="courseID != null and courseID != ''">
course_id = #{courseID},
</if>
<if test="name != null and name != ''">
name = #{name},
</if>
@@ -235,13 +235,13 @@
deleted = #{deleted},
</if>
</set>
WHERE id = #{id}
WHERE course_id = #{courseID}
</update>
<!-- 删除课程 -->
<delete id="deleteCourse" parameterType="org.xyzh.common.dto.study.TbCourse">
DELETE FROM tb_course
WHERE id = #{id}
WHERE course_id = #{courseID}
</delete>
<!-- 批量插入课程 -->

4
schoolNewsServ/study/src/main/resources/mapper/CourseNodeMapper.xml
View File

@@ -225,8 +225,7 @@
</select>
<!-- selectCourseNodesByChapterIDs -->
<select id="selectCourseNodesByChapterIDs">
<select id="selectCourseNodesByChapterIDs" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List" />
FROM tb_course_node
@@ -235,5 +234,6 @@
#{chapterID}
</foreach>
AND deleted = 0
ORDER BY order_num ASC, create_time ASC
</select>
</mapper>

51
schoolNewsServ/study/src/main/resources/mapper/LearningTaskMapper.xml
View File

@@ -41,6 +41,21 @@
</where>
</sql>
<sql id="Filter_Clause">
<where>
deleted = 0
<if test="filter.taskID != null and filter.taskID != ''">
AND task_id = #{taskID}
</if>
<if test="filter.name != null and filter.name != ''">
AND name LIKE CONCAT('%', #{filter.name}, '%')
</if>
<if test="filter.status != null">
AND status = #{filter.status}
</if>
</where>
</sql>
<!-- selectLearningTasks -->
<select id="selectLearningTasks" resultMap="BaseResultMap">
SELECT
@@ -125,10 +140,10 @@
<insert id="insertLearningTask" parameterType="org.xyzh.common.dto.study.TbLearningTask">
INSERT INTO tb_learning_task (
id, task_id, name, description, start_time, end_time, status,
creator, updater, create_time, update_time, delete_time, deleted
creator, create_time
) VALUES (
#{id}, #{taskID}, #{name}, #{description}, #{startTime}, #{endTime}, #{status},
#{creator}, #{updater}, #{createTime}, #{updateTime}, #{deleteTime}, #{deleted}
#{creator}, #{createTime}
)
</insert>
@@ -167,26 +182,25 @@
deleted = #{deleted},
</if>
</set>
WHERE id = #{id}
WHERE task_id = #{taskID}
</update>
<!-- 删除学习任务 -->
<delete id="deleteLearningTask" parameterType="org.xyzh.common.dto.study.TbLearningTask">
DELETE FROM tb_learning_task
WHERE id = #{id}
WHERE task_id = #{taskID}
</delete>
<!-- 批量插入学习任务 -->
<insert id="batchInsertLearningTasks" parameterType="java.util.List">
INSERT INTO tb_learning_task (
id, task_id, name, description, start_time, end_time, status,
creator, updater, create_time, update_time, delete_time, deleted
creator, create_time
) VALUES
<foreach collection="learningTaskList" item="item" separator=",">
(
#{item.id}, #{item.taskID}, #{item.name}, #{item.description}, #{item.startTime},
#{item.endTime}, #{item.status}, #{item.creator}, #{item.updater},
#{item.createTime}, #{item.updateTime}, #{item.deleteTime}, #{item.deleted}
#{item.endTime}, #{item.status}, #{item.creator}, #{item.createTime}
)
</foreach>
</insert>
@@ -194,9 +208,9 @@
<!-- 批量删除学习任务 -->
<delete id="batchDeleteLearningTasks">
DELETE FROM tb_learning_task
WHERE id IN
<foreach collection="ids" item="id" open="(" separator="," close=")">
#{id}
WHERE task_id IN
<foreach collection="ids" item="taskID" open="(" separator="," close=")">
#{taskID}
</foreach>
</delete>
@@ -205,7 +219,20 @@
SELECT
<include refid="Base_Column_List" />
FROM tb_learning_task
<include refid="Where_Clause" />
<include refid="Filter_Clause" />
ORDER BY create_time DESC
LIMIT #{pageParam.pageSize} OFFSET #{pageParam.offset}
</select>
<select id="selectUserLearningTasksPage" resultMap="BaseResultMap">
SELECT
tlt.id, tlt.task_id, tlt.name, tlt.description, tlt.start_time, tlt.end_time, tlt.status,
tlt.creator, tlt.updater, tlt.create_time, tlt.update_time
FROM tb_task_user ttu
INNER JOIN tb_learning_task tlt ON ttu.task_id = tlt.task_id
WHERE ttu.user_id = #{filter.userID}
AND tlt.deleted = 0
AND ttu.deleted = 0
ORDER BY create_time DESC
LIMIT #{pageParam.pageSize} OFFSET #{pageParam.offset}
</select>
@@ -214,7 +241,7 @@
<select id="countLearningTasks" resultType="long">
SELECT COUNT(1)
FROM tb_learning_task
<include refid="Where_Clause" />
<include refid="Filter_Clause" />
</select>
</mapper>

30
schoolNewsServ/study/src/main/resources/mapper/TaskCourseMapper.xml
View File

@@ -13,6 +13,24 @@
<result column="create_time" property="createTime" jdbcType="TIMESTAMP"/>
</resultMap>
<resultMap id="TaskItemResultMap" type="org.xyzh.common.vo.TaskItemVO">
<id column="id" property="id" jdbcType="VARCHAR"/>
<result column="task_id" property="taskID" jdbcType="VARCHAR"/>
<result column="course_id" property="courseID" jdbcType="VARCHAR"/>
<result column="course_name" property="courseName" jdbcType="VARCHAR"/>
<result column="resource_id" property="resourceID" jdbcType="VARCHAR"/>
<result column="resource_name" property="resourceName" jdbcType="VARCHAR"/>
<result column="user_id" property="userID" jdbcType="VARCHAR"/>
<result column="user_name" property="userName" jdbcType="VARCHAR"/>
<result column="status" property="status" jdbcType="INTEGER"/>
<result column="progress" property="progress" jdbcType="DECIMAL"/>
<result column="complete_time" property="completeTime" jdbcType="TIMESTAMP"/>
<result column="required" property="required" jdbcType="BOOLEAN"/>
<result column="order_num" property="orderNum" jdbcType="INTEGER"/>
<result column="creator" property="creator" jdbcType="VARCHAR"/>
<result column="create_time" property="createTime" jdbcType="TIMESTAMP"/>
</resultMap>
<!-- 基础字段 -->
<sql id="Base_Column_List">
id, task_id, course_id, required, order_num, creator, create_time
@@ -50,7 +68,6 @@
WHERE id = #{relationId}
</select>
<!-- 根据任务ID查询课程关联列表 -->
<select id="selectByTaskId" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List" />
@@ -59,6 +76,17 @@
ORDER BY order_num ASC, create_time ASC
</select>
<!-- 根据任务ID查询课程关联列表 -->
<select id="selectTaskItemByTaskId" resultMap="TaskItemResultMap">
SELECT
ttc.*,
tc.name as course_name
FROM tb_task_course ttc
INNER JOIN tb_course tc ON ttc.course_id = tc.course_id
WHERE ttc.task_id = #{taskId} and ttc.deleted = 0 and tc.deleted = 0
ORDER BY ttc.order_num ASC, ttc.create_time ASC
</select>
<!-- 根据课程ID查询任务关联列表 -->
<select id="selectByCourseId" resultMap="BaseResultMap">
SELECT

27
schoolNewsServ/study/src/main/resources/mapper/TaskResourceMapper.xml
View File

@@ -13,6 +13,24 @@
<result column="create_time" property="createTime" jdbcType="TIMESTAMP"/>
</resultMap>
<resultMap id="TaskItemResultMap" type="org.xyzh.common.vo.TaskItemVO">
<id column="id" property="id" jdbcType="VARCHAR"/>
<result column="task_id" property="taskID" jdbcType="VARCHAR"/>
<result column="course_id" property="courseID" jdbcType="VARCHAR"/>
<result column="course_name" property="courseName" jdbcType="VARCHAR"/>
<result column="resource_id" property="resourceID" jdbcType="VARCHAR"/>
<result column="resource_name" property="resourceName" jdbcType="VARCHAR"/>
<result column="user_id" property="userID" jdbcType="VARCHAR"/>
<result column="user_name" property="userName" jdbcType="VARCHAR"/>
<result column="status" property="status" jdbcType="INTEGER"/>
<result column="progress" property="progress" jdbcType="DECIMAL"/>
<result column="complete_time" property="completeTime" jdbcType="TIMESTAMP"/>
<result column="required" property="required" jdbcType="BOOLEAN"/>
<result column="order_num" property="orderNum" jdbcType="INTEGER"/>
<result column="creator" property="creator" jdbcType="VARCHAR"/>
<result column="create_time" property="createTime" jdbcType="TIMESTAMP"/>
</resultMap>
<!-- 基础字段 -->
<sql id="Base_Column_List">
id, task_id, resource_id, required, order_num, creator, create_time
@@ -59,6 +77,15 @@
ORDER BY order_num ASC, create_time ASC
</select>
<select id="selectTaskItemByTaskId" resultMap="TaskItemResultMap">
SELECT
ttr.*,
tr.title as resource_name
FROM tb_task_resource ttr
INNER JOIN tb_resource tr ON ttr.resource_id = tr.resource_id
WHERE ttr.task_id = #{taskId} and ttr.deleted = 0 and tr.deleted = 0
ORDER BY ttr.order_num ASC, ttr.create_time ASC
</select>
<!-- 根据资源ID查询任务关联列表 -->
<select id="selectByResourceId" resultMap="BaseResultMap">
SELECT

79
schoolNewsServ/study/src/main/resources/mapper/TaskUserMapper.xml
View File

@@ -16,6 +16,24 @@
<result column="update_time" property="updateTime" jdbcType="TIMESTAMP"/>
</resultMap>
<resultMap id="TaskItemResultMap" type="org.xyzh.common.vo.TaskItemVO">
<id column="id" property="id" jdbcType="VARCHAR"/>
<result column="task_id" property="taskID" jdbcType="VARCHAR"/>
<result column="course_id" property="courseID" jdbcType="VARCHAR"/>
<result column="course_name" property="courseName" jdbcType="VARCHAR"/>
<result column="resource_id" property="resourceID" jdbcType="VARCHAR"/>
<result column="resource_name" property="resourceName" jdbcType="VARCHAR"/>
<result column="user_id" property="userID" jdbcType="VARCHAR"/>
<result column="username" property="username" jdbcType="VARCHAR"/>
<result column="status" property="status" jdbcType="INTEGER"/>
<result column="progress" property="progress" jdbcType="DECIMAL"/>
<result column="complete_time" property="completeTime" jdbcType="TIMESTAMP"/>
<result column="required" property="required" jdbcType="BOOLEAN"/>
<result column="order_num" property="orderNum" jdbcType="INTEGER"/>
<result column="creator" property="creator" jdbcType="VARCHAR"/>
<result column="create_time" property="createTime" jdbcType="TIMESTAMP"/>
</resultMap>
<!-- 基础字段 -->
<sql id="Base_Column_List">
id, task_id, user_id, dept_id, status, progress, complete_time,
@@ -66,6 +84,16 @@
ORDER BY create_time DESC
</select>
<select id="selectTaskItemByTaskId" resultMap="TaskItemResultMap">
SELECT
ttu.*,
tu.username
FROM tb_task_user ttu
INNER JOIN tb_sys_user tu ON ttu.user_id = tu.id
WHERE ttu.task_id = #{taskId} and ttu.deleted = 0 and tu.deleted = 0
ORDER BY ttu.create_time ASC
</select>
<!-- 根据用户ID查询任务关联列表 -->
<select id="selectByUserId" resultMap="BaseResultMap">
SELECT
@@ -115,64 +143,29 @@
<insert id="insertTaskUser" parameterType="org.xyzh.common.dto.study.TbTaskUser">
INSERT INTO tb_task_user (
id, task_id, user_id, dept_id, status, progress, complete_time,
creator, create_time, update_time
creator, create_time
) VALUES (
#{id}, #{taskID}, #{userID}, #{deptID}, #{status}, #{progress}, #{completeTime},
#{creator}, #{createTime}, #{updateTime}
#{creator}, #{createTime}
)
</insert>
<!-- 更新任务用户关联 -->
<update id="updateTaskUser" parameterType="org.xyzh.common.dto.study.TbTaskUser">
UPDATE tb_task_user
<set>
<if test="taskID != null and taskID != ''">
task_id = #{taskID},
</if>
<if test="userID != null and userID != ''">
user_id = #{userID},
</if>
<if test="deptID != null and deptID != ''">
dept_id = #{deptID},
</if>
<if test="status != null">
status = #{status},
</if>
<if test="progress != null">
progress = #{progress},
</if>
<if test="completeTime != null">
complete_time = #{completeTime},
</if>
<if test="creator != null and creator != ''">
creator = #{creator},
</if>
<if test="createTime != null">
create_time = #{createTime},
</if>
<if test="updateTime != null">
update_time = #{updateTime},
</if>
</set>
WHERE id = #{id}
</update>
<!-- 删除任务用户关联 -->
<delete id="deleteTaskUser" parameterType="org.xyzh.common.dto.study.TbTaskUser">
DELETE FROM tb_task_user
WHERE id = #{id}
WHERE task_id = #{taskID}
</delete>
<!-- 批量插入任务用户关联 -->
<insert id="batchInsertTaskUsers" parameterType="java.util.List">
INSERT INTO tb_task_user (
id, task_id, user_id, dept_id, status, progress, complete_time,
creator, create_time, update_time
creator, create_time
) VALUES
<foreach collection="taskUserList" item="item" separator=",">
(
#{item.id}, #{item.taskID}, #{item.userID}, #{item.deptID}, #{item.status},
#{item.progress}, #{item.completeTime}, #{item.creator}, #{item.createTime}, #{item.updateTime}
#{item.progress}, #{item.completeTime}, #{item.creator}, #{item.createTime}
)
</foreach>
</insert>
@@ -180,9 +173,9 @@
<!-- 批量删除任务用户关联 -->
<delete id="batchDeleteTaskUsers">
DELETE FROM tb_task_user
WHERE id IN
<foreach collection="ids" item="id" open="(" separator="," close=")">
#{id}
WHERE (task_id, user_id) IN
<foreach collection="userIds" item="userID" open="(" separator="," close=")">
(#{taskId}, #{userID})
</foreach>
</delete>