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-24 18:28:26 +08:00
parent 6f5603dd8b
commit 8968409b2d
55 changed files with 2144 additions and 2570 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -10,6 +10,7 @@ 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.dto.study.TbLearningRecord;
import org.xyzh.common.vo.ChapterVO;
import org.xyzh.common.vo.CourseVO;
import org.springframework.web.bind.annotation.PostMapping;

70
schoolNewsServ/study/src/main/java/org/xyzh/study/controller/LearningRecordController.java
View File

@@ -7,6 +7,10 @@ import org.springframework.web.bind.annotation.*;
import org.xyzh.api.study.record.LearningRecordService;
import org.xyzh.common.core.domain.ResultDomain;
import org.xyzh.common.dto.study.TbLearningRecord;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.PathVariable;
/**
* @description 学习记录控制器
@@ -16,7 +20,7 @@ import org.xyzh.common.dto.study.TbLearningRecord;
* @since 2025-10-15
*/
@RestController
@RequestMapping("/study/record")
@RequestMapping("/study/records")
public class LearningRecordController {
private static final Logger logger = LoggerFactory.getLogger(LearningRecordController.class);
@@ -26,68 +30,46 @@ public class LearningRecordController {
/**
* 获取学习记录
*/
@GetMapping("/list")
public ResultDomain<TbLearningRecord> getLearningRecords(
@RequestParam(required = false) String userID,
@RequestParam(required = false) String resourceType,
@RequestParam(required = false) String resourceID) {
return null;
// return learningRecordService.getLearningRecords(userID, courseID, taskID);
@PostMapping("/list")
public ResultDomain<TbLearningRecord> getLearningRecordList(@RequestBody TbLearningRecord learningRecord) {
return learningRecordService.getLearningRecord(learningRecord);
}
/**
* 创建学习记录
*/
@PostMapping("/create")
public ResultDomain<TbLearningRecord> createLearningRecord(@RequestBody TbLearningRecord record) {
return null;
// return learningRecordService.createLearningRecord(record);
@PostMapping("/record")
public ResultDomain<TbLearningRecord> insertLearningRecord(@RequestBody TbLearningRecord record) {
return learningRecordService.insertLearningRecord(record);
}
/**
* 更新学习记录
*/
@PutMapping("/update")
@PutMapping("/record")
public ResultDomain<TbLearningRecord> updateLearningRecord(@RequestBody TbLearningRecord record) {
return null;
// return learningRecordService.updateLearningRecord(record);
return learningRecordService.updateLearningRecord(record);
}
/**
* 删除学习记录
*/
@DeleteMapping("/{recordID}")
public ResultDomain<Boolean> deleteLearningRecord(@PathVariable("recordID") String recordID) {
return null;
// return learningRecordService.deleteLearningRecord(recordID);
@DeleteMapping("/record")
public ResultDomain<Boolean> deleteLearningRecord(@RequestBody TbLearningRecord learningRecord) {
return learningRecordService.deleteLearningRecord(learningRecord.getID());
}
@PutMapping("/complete")
public ResultDomain<TbLearningRecord> markLearningComplete(@RequestBody TbLearningRecord learningRecord) {
return learningRecordService.markLearningComplete(learningRecord);
}
/**
* 根据ID获取学习记录
* 查询用户课程的学习记录
*/
@GetMapping("/{recordID}")
public ResultDomain<TbLearningRecord> getRecordById(@PathVariable("recordID") String recordID) {
return null;
// return learningRecordService.getRecordById(recordID);
}
/**
* 更新学习进度
*/
@PutMapping("/{recordID}/progress")
public ResultDomain<TbLearningRecord> updateLearningProgress(
@PathVariable("recordID") String recordID,
@RequestParam Integer progress) {
return null;
// return learningRecordService.updateLearningProgress(recordID, progress);
}
/**
* 完成学习
*/
@PostMapping("/{recordID}/complete")
public ResultDomain<TbLearningRecord> completeLearning(@PathVariable("recordID") String recordID) {
return null;
// return learningRecordService.completeLearning(recordID);
@PostMapping("/course/records")
public ResultDomain<TbLearningRecord> getCourseLearningRecord(@RequestBody TbLearningRecord learningRecord) {
return learningRecordService.getCourseLearningRecord(learningRecord);
}
}

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

@@ -15,8 +15,6 @@ 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;
import org.springframework.web.bind.annotation.PostMapping;
@@ -65,6 +63,11 @@ public class LearningTaskController {
return learningTaskService.getTaskById(taskID);
}
@GetMapping("/{taskID}/user")
public ResultDomain<TaskVO> getTaskUser(@PathVariable("taskID") String taskID) {
return learningTaskService.getTaskUser(taskID);
}
/**
* 创建任务
*/
@@ -157,4 +160,6 @@ public class LearningTaskController {
return learningTaskService.getUserProgress(userID);
}
}

4
schoolNewsServ/study/src/main/java/org/xyzh/study/mapper/LearningRecordMapper.java
View File

@@ -62,7 +62,7 @@ public interface LearningRecordMapper extends BaseMapper<TbLearningRecord> {
* @author yslg
* @since 2025-10-15
*/
TbLearningRecord selectByUserIdAndCourseId(@Param("userId") String userId, @Param("courseId") String courseId);
List<TbLearningRecord> selectByUserIdAndCourseId(@Param("userId") String userId, @Param("courseId") String courseId);
/**
* @description 根据状态查询学习记录列表
@@ -107,7 +107,7 @@ public interface LearningRecordMapper extends BaseMapper<TbLearningRecord> {
* @author yslg
* @since 2025-10-15
*/
int deleteLearningRecord(TbLearningRecord learningRecord);
int deleteLearningRecord(@Param("recordId") String recordId);
/**
* @description 批量插入学习记录

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

@@ -1,162 +0,0 @@
package org.xyzh.study.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
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;
/**
* @description TaskCourseMapper.java文件描述 任务课程关联数据访问层
* @filename TaskCourseMapper.java
* @author yslg
* @copyright xyzh
* @since 2025-10-15
*/
@Mapper
public interface TaskCourseMapper extends BaseMapper<TbTaskCourse> {
/**
* @description 查询任务课程关联列表
* @param filter 过滤条件
* @return List<TbTaskCourse> 任务课程关联列表
* @author yslg
* @since 2025-10-15
*/
List<TbTaskCourse> selectTaskCourses(TbTaskCourse filter);
/**
* @description 根据关联ID查询关联信息
* @param relationId 关联ID
* @return TbTaskCourse 关联信息
* @author yslg
* @since 2025-10-15
*/
TbTaskCourse selectByRelationId(@Param("relationId") String relationId);
/**
* @description 根据任务ID查询课程关联列表
* @param taskId 任务ID
* @return List<TbTaskCourse> 课程关联列表
* @author yslg
* @since 2025-10-15
*/
List<TbTaskCourse> selectByTaskId(@Param("taskId") String taskId);
List<TaskItemVO> selectTaskItemByTaskId(@Param("taskId") String taskId);
/**
* @description 根据课程ID查询任务关联列表
* @param courseId 课程ID
* @return List<TbTaskCourse> 任务关联列表
* @author yslg
* @since 2025-10-15
*/
List<TbTaskCourse> selectByCourseId(@Param("courseId") String courseId);
/**
* @description 根据任务ID和课程ID查询关联信息
* @param taskId 任务ID
* @param courseId 课程ID
* @return TbTaskCourse 关联信息
* @author yslg
* @since 2025-10-15
*/
TbTaskCourse selectByTaskIdAndCourseId(@Param("taskId") String taskId, @Param("courseId") String courseId);
/**
* @description 检查任务课程关联是否存在
* @param taskId 任务ID
* @param courseId 课程ID
* @param excludeId 排除的关联ID（用于更新时排除自身）
* @return int 存在的数量
* @author yslg
* @since 2025-10-15
*/
int countByTaskIdAndCourseId(@Param("taskId") String taskId, @Param("courseId") String courseId, @Param("excludeId") String excludeId);
/**
* @description 插入任务课程关联
* @param taskCourse 任务课程关联
* @return int 影响行数
* @author yslg
* @since 2025-10-15
*/
int insertTaskCourse(TbTaskCourse taskCourse);
/**
* @description 更新任务课程关联
* @param taskCourse 任务课程关联
* @return int 影响行数
* @author yslg
* @since 2025-10-15
*/
int updateTaskCourse(TbTaskCourse taskCourse);
/**
* @description 删除任务课程关联
* @param taskCourse 任务课程关联
* @return int 影响行数
* @author yslg
* @since 2025-10-15
*/
int deleteTaskCourse(TbTaskCourse taskCourse);
/**
* @description 批量插入任务课程关联
* @param taskCourseList 任务课程关联列表
* @return int 影响行数
* @author yslg
* @since 2025-10-15
*/
int batchInsertTaskCourses(@Param("taskCourseList") List<TbTaskCourse> taskCourseList);
/**
* @description 批量删除任务课程关联
* @param ids 关联ID列表
* @return int 影响行数
* @author yslg
* @since 2025-10-15
*/
int batchDeleteTaskCourses(@Param("ids") List<String> ids);
/**
* @description 根据任务ID批量删除课程关联
* @param taskId 任务ID
* @return int 影响行数
* @author yslg
* @since 2025-10-15
*/
int deleteByTaskId(@Param("taskId") String taskId);
/**
* @description 根据课程ID批量删除任务关联
* @param courseId 课程ID
* @return int 影响行数
* @author yslg
* @since 2025-10-15
*/
int deleteByCourseId(@Param("courseId") String courseId);
/**
* @description 分页查询任务课程关联
* @param filter 过滤条件
* @param pageParam 分页参数
* @return List<TbTaskCourse> 任务课程关联列表
* @author yslg
* @since 2025-10-15
*/
List<TbTaskCourse> selectTaskCoursesPage(@Param("filter") TbTaskCourse filter, @Param("pageParam") PageParam pageParam);
/**
* @description 统计任务课程关联总数
* @param filter 过滤条件
* @return long 总数
* @author yslg
* @since 2025-10-15
*/
long countTaskCourses(@Param("filter") TbTaskCourse filter);
}

194
schoolNewsServ/study/src/main/java/org/xyzh/study/mapper/TaskItemMapper.java Normal file
View File

@@ -0,0 +1,194 @@
package org.xyzh.study.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
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.TbTaskItem;
import org.xyzh.common.vo.TaskItemVO;
import java.util.List;
/**
* @description TaskItemMapper.java文件描述 任务项关联数据访问层
* @filename TaskItemMapper.java
* @author yslg
* @copyright xyzh
* @since 2025-10-24
*/
@Mapper
public interface TaskItemMapper extends BaseMapper<TbTaskItem> {
/**
* @description 查询任务项关联列表
* @param filter 过滤条件
* @return List<TbTaskItem> 任务项关联列表
* @author yslg
* @since 2025-10-24
*/
List<TbTaskItem> selectTaskItems(TbTaskItem filter);
/**
* @description 根据关联ID查询关联信息
* @param relationId 关联ID
* @return TbTaskItem 关联信息
* @author yslg
* @since 2025-10-24
*/
TbTaskItem selectByRelationId(@Param("relationId") String relationId);
/**
* @description 根据任务ID查询项关联列表
* @param taskId 任务ID
* @return List<TbTaskItem> 项关联列表
* @author yslg
* @since 2025-10-24
*/
List<TbTaskItem> selectByTaskId(@Param("taskId") String taskId);
/**
* @description 根据任务ID和类型查询项关联列表
* @param taskId 任务ID
* @param itemType 项类型（1资源 2课程）
* @return List<TbTaskItem> 项关联列表
* @author yslg
* @since 2025-10-24
*/
List<TbTaskItem> selectByTaskIdAndType(@Param("taskId") String taskId, @Param("itemType") Integer itemType);
/**
* @description 根据任务ID查询任务项VO列表
* @param taskId 任务ID
* @return List<TaskItemVO> 任务项VO列表
* @author yslg
* @since 2025-10-24
*/
List<TaskItemVO> selectTaskItemVOByTaskId(@Param("taskId") String taskId);
/**
* @description 根据任务ID和用户ID查询任务项视图对象列表（包含该用户的学习状态）
* @param taskId 任务ID
* @param userId 用户ID
* @return List<TaskItemVO> 任务项视图对象列表
* @author yslg
* @since 2025-10-24
*/
List<TaskItemVO> selectTaskItemVOByTaskIdAndUserId(@Param("taskId") String taskId, @Param("userId") String userId);
/**
* @description 根据项ID查询任务关联列表
* @param itemId 项ID
* @param itemType 项类型（1资源 2课程）
* @return List<TbTaskItem> 任务关联列表
* @author yslg
* @since 2025-10-24
*/
List<TbTaskItem> selectByItemId(@Param("itemId") String itemId, @Param("itemType") Integer itemType);
/**
* @description 根据任务ID和项ID查询关联信息
* @param taskId 任务ID
* @param itemId 项ID
* @param itemType 项类型
* @return TbTaskItem 关联信息
* @author yslg
* @since 2025-10-24
*/
TbTaskItem selectByTaskIdAndItemId(@Param("taskId") String taskId, @Param("itemId") String itemId, @Param("itemType") Integer itemType);
/**
* @description 检查任务项关联是否存在
* @param taskId 任务ID
* @param itemId 项ID
* @param itemType 项类型
* @param excludeId 排除的关联ID（用于更新时排除自身）
* @return int 存在的数量
* @author yslg
* @since 2025-10-24
*/
int countByTaskIdAndItemId(@Param("taskId") String taskId, @Param("itemId") String itemId, @Param("itemType") Integer itemType, @Param("excludeId") String excludeId);
/**
* @description 插入任务项关联
* @param taskItem 任务项关联
* @return int 影响行数
* @author yslg
* @since 2025-10-24
*/
int insertTaskItem(TbTaskItem taskItem);
/**
* @description 更新任务项关联
* @param taskItem 任务项关联
* @return int 影响行数
* @author yslg
* @since 2025-10-24
*/
int updateTaskItem(TbTaskItem taskItem);
/**
* @description 删除任务项关联
* @param taskItem 任务项关联
* @return int 影响行数
* @author yslg
* @since 2025-10-24
*/
int deleteTaskItem(TbTaskItem taskItem);
/**
* @description 批量插入任务项关联
* @param taskItemList 任务项关联列表
* @return int 影响行数
* @author yslg
* @since 2025-10-24
*/
int batchInsertTaskItems(@Param("taskItemList") List<TbTaskItem> taskItemList);
/**
* @description 批量删除任务项关联
* @param ids 关联ID列表
* @return int 影响行数
* @author yslg
* @since 2025-10-24
*/
int batchDeleteTaskItems(@Param("ids") List<String> ids);
/**
* @description 根据任务ID批量删除项关联
* @param taskId 任务ID
* @return int 影响行数
* @author yslg
* @since 2025-10-24
*/
int deleteByTaskId(@Param("taskId") String taskId);
/**
* @description 根据项ID批量删除任务关联
* @param itemId 项ID
* @param itemType 项类型
* @return int 影响行数
* @author yslg
* @since 2025-10-24
*/
int deleteByItemId(@Param("itemId") String itemId, @Param("itemType") Integer itemType);
/**
* @description 分页查询任务项关联
* @param filter 过滤条件
* @param pageParam 分页参数
* @return List<TbTaskItem> 任务项关联列表
* @author yslg
* @since 2025-10-24
*/
List<TbTaskItem> selectTaskItemsPage(@Param("filter") TbTaskItem filter, @Param("pageParam") PageParam pageParam);
/**
* @description 统计任务项关联总数
* @param filter 过滤条件
* @return long 总数
* @author yslg
* @since 2025-10-24
*/
long countTaskItems(@Param("filter") TbTaskItem filter);
}

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

@@ -1,169 +0,0 @@
package org.xyzh.study.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
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;
/**
* @description TaskResourceMapper.java文件描述 任务资源关联数据访问层
* @filename TaskResourceMapper.java
* @author yslg
* @copyright xyzh
* @since 2025-10-15
*/
@Mapper
public interface TaskResourceMapper extends BaseMapper<TbTaskResource> {
/**
* @description 查询任务资源关联列表
* @param filter 过滤条件
* @return List<TbTaskResource> 任务资源关联列表
* @author yslg
* @since 2025-10-15
*/
List<TbTaskResource> selectTaskResources(TbTaskResource filter);
/**
* @description 根据关联ID查询关联信息
* @param relationId 关联ID
* @return TbTaskResource 关联信息
* @author yslg
* @since 2025-10-15
*/
TbTaskResource selectByRelationId(@Param("relationId") String relationId);
/**
* @description 根据任务ID查询资源关联列表
* @param taskId 任务ID
* @return List<TbTaskResource> 资源关联列表
* @author yslg
* @since 2025-10-15
*/
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
* @return List<TbTaskResource> 任务关联列表
* @author yslg
* @since 2025-10-15
*/
List<TbTaskResource> selectByResourceId(@Param("resourceId") String resourceId);
/**
* @description 根据任务ID和资源ID查询关联信息
* @param taskId 任务ID
* @param resourceId 资源ID
* @return TbTaskResource 关联信息
* @author yslg
* @since 2025-10-15
*/
TbTaskResource selectByTaskIdAndResourceId(@Param("taskId") String taskId, @Param("resourceId") String resourceId);
/**
* @description 检查任务资源关联是否存在
* @param taskId 任务ID
* @param resourceId 资源ID
* @param excludeId 排除的关联ID（用于更新时排除自身）
* @return int 存在的数量
* @author yslg
* @since 2025-10-15
*/
int countByTaskIdAndResourceId(@Param("taskId") String taskId, @Param("resourceId") String resourceId, @Param("excludeId") String excludeId);
/**
* @description 插入任务资源关联
* @param taskResource 任务资源关联
* @return int 影响行数
* @author yslg
* @since 2025-10-15
*/
int insertTaskResource(TbTaskResource taskResource);
/**
* @description 更新任务资源关联
* @param taskResource 任务资源关联
* @return int 影响行数
* @author yslg
* @since 2025-10-15
*/
int updateTaskResource(TbTaskResource taskResource);
/**
* @description 删除任务资源关联
* @param taskResource 任务资源关联
* @return int 影响行数
* @author yslg
* @since 2025-10-15
*/
int deleteTaskResource(TbTaskResource taskResource);
/**
* @description 批量插入任务资源关联
* @param taskResourceList 任务资源关联列表
* @return int 影响行数
* @author yslg
* @since 2025-10-15
*/
int batchInsertTaskResources(@Param("taskResourceList") List<TbTaskResource> taskResourceList);
/**
* @description 批量删除任务资源关联
* @param ids 关联ID列表
* @return int 影响行数
* @author yslg
* @since 2025-10-15
*/
int batchDeleteTaskResources(@Param("ids") List<String> ids);
/**
* @description 根据任务ID批量删除资源关联
* @param taskId 任务ID
* @return int 影响行数
* @author yslg
* @since 2025-10-15
*/
int deleteByTaskId(@Param("taskId") String taskId);
/**
* @description 根据资源ID批量删除任务关联
* @param resourceId 资源ID
* @return int 影响行数
* @author yslg
* @since 2025-10-15
*/
int deleteByResourceId(@Param("resourceId") String resourceId);
/**
* @description 分页查询任务资源关联
* @param filter 过滤条件
* @param pageParam 分页参数
* @return List<TbTaskResource> 任务资源关联列表
* @author yslg
* @since 2025-10-15
*/
List<TbTaskResource> selectTaskResourcesPage(@Param("filter") TbTaskResource filter, @Param("pageParam") PageParam pageParam);
/**
* @description 统计任务资源关联总数
* @param filter 过滤条件
* @return long 总数
* @author yslg
* @since 2025-10-15
*/
long countTaskResources(@Param("filter") TbTaskResource filter);
}

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

@@ -47,6 +47,8 @@ public interface TaskUserMapper extends BaseMapper<TbTaskUser> {
List<TbTaskUser> selectByTaskId(@Param("taskId") String taskId);
List<TaskItemVO> selectTaskItemByTaskId(@Param("taskId") String taskId);
List<TaskItemVO> selectUserTaskItem(@Param("taskId") String taskId, @Param("userId") String userId);
/**
* @description 根据用户ID查询任务关联列表
* @param userId 用户ID
@@ -105,6 +107,15 @@ public interface TaskUserMapper extends BaseMapper<TbTaskUser> {
*/
int insertTaskUser(TbTaskUser taskUser);
/**
* @description 更新任务用户关联
* @param taskUser 任务用户关联
* @return int 影响行数
* @author yslg
* @since 2025-10-24
*/
int updateTaskUser(TbTaskUser taskUser);
/**
* @description 删除任务用户关联
* @param taskUser 任务用户关联

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

@@ -21,6 +21,7 @@ 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.dto.study.TbCourseTag;
import org.xyzh.common.dto.study.TbLearningRecord;
import org.xyzh.common.dto.user.TbSysUser;
import org.xyzh.common.utils.IDUtils;
import org.xyzh.common.vo.ChapterVO;
@@ -107,6 +108,7 @@ public class SCCourseServiceImpl implements SCCourseService {
}).collect(Collectors.toList());
courseVO.setCourseChapters(chapterVOs);
}
resultDomain.success("获取课程详情成功", courseVO);
return resultDomain;
}

258
schoolNewsServ/study/src/main/java/org/xyzh/study/service/impl/SCLearningRecordServiceImpl.java
View File

@@ -1,15 +1,25 @@
package org.xyzh.study.service.impl;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
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.enums.TaskItemType;
import org.xyzh.common.dto.study.TbLearningRecord;
import org.xyzh.common.dto.study.TbTaskItem;
import org.xyzh.common.dto.study.TbTaskUser;
import org.xyzh.common.dto.user.TbSysUser;
import org.xyzh.common.vo.TaskItemVO;
import org.xyzh.api.study.record.LearningRecordService;
import org.xyzh.study.mapper.LearningRecordMapper;
import org.xyzh.study.mapper.TaskItemMapper;
import org.xyzh.study.mapper.TaskUserMapper;
import org.xyzh.system.utils.LoginUtil;
/**
* @description 学习记录服务实现类
@@ -26,62 +36,244 @@ public class SCLearningRecordServiceImpl implements LearningRecordService {
@Autowired
private LearningRecordMapper learningRecordMapper;
@Autowired
private TaskItemMapper taskItemMapper;
@Autowired
private TaskUserMapper taskUserMapper;
@Override
public ResultDomain<Boolean> deleteLearningRecord(String recordID) {
// TODO Auto-generated method stub
return null;
public ResultDomain<TbLearningRecord> insertLearningRecord(TbLearningRecord learningRecord) {
ResultDomain<TbLearningRecord> resultDomain = new ResultDomain<>();
TbSysUser user = LoginUtil.getCurrentUser();
if (user == null) {
resultDomain.fail("请先登录");
return resultDomain;
}
learningRecord.setUserID(user.getID());
learningRecord.setCreateTime(new Date());
if (learningRecord.getResourceType() == null) {
resultDomain.fail("资源类型不能为空");
return resultDomain;
}
if (learningRecord.getResourceType() == 1 && learningRecord.getResourceID() == null) {
resultDomain.fail("资源ID不能为空");
return resultDomain;
}
if (learningRecord.getResourceType() == 2 && (learningRecord.getCourseID() == null || learningRecord.getChapterID() == null || learningRecord.getNodeID() == null)) {
resultDomain.fail("课程信息不能为空");
return resultDomain;
}
List<TbLearningRecord> records = learningRecordMapper.selectLearningRecords(learningRecord);
if (records.size() > 0) {
resultDomain.fail("学习记录已存在");
return resultDomain;
}
List<TaskItemVO> allTaskItems = taskItemMapper.selectTaskItemVOByTaskIdAndUserId(learningRecord.getTaskID(), user.getID());
if (allTaskItems == null || allTaskItems.isEmpty()) {
TbTaskUser taskUser = new TbTaskUser();
taskUser.setTaskID(learningRecord.getTaskID());
taskUser.setUserID(user.getID());
taskUser.setProgress(new BigDecimal(0));
taskUser.setUpdater(user.getID());
// 全部完成
taskUser.setStatus(1);
taskUser.setUpdateTime(new Date());
taskUserMapper.updateTaskUser(taskUser);
}
int result = learningRecordMapper.insertLearningRecord(learningRecord);
if (result > 0) {
resultDomain.success("创建学习记录成功", learningRecord);
return resultDomain;
} else {
resultDomain.fail("创建学习记录失败");
return resultDomain;
}
}
@Override
public ResultDomain<TbLearningRecord> getResourceLearningRecords(Integer resourceType, String resourceID) {
// TODO Auto-generated method stub
return null;
public ResultDomain<TbLearningRecord> updateLearningRecord(TbLearningRecord learningRecord) {
ResultDomain<TbLearningRecord> resultDomain = new ResultDomain<>();
TbSysUser user = LoginUtil.getCurrentUser();
if (user == null) {
resultDomain.fail("请先登录");
return resultDomain;
}
learningRecord.setUpdater(user.getID());
int result = learningRecordMapper.updateLearningRecord(learningRecord);
if (result > 0) {
resultDomain.success("更新学习记录成功", learningRecord);
return resultDomain;
} else {
resultDomain.fail("更新学习记录失败");
return resultDomain;
}
}
@Override
public ResultDomain<Boolean> deleteLearningRecord(String recordID) {
ResultDomain<Boolean> resultDomain = new ResultDomain<>();
int result = learningRecordMapper.deleteLearningRecord(recordID);
if (result > 0) {
resultDomain.success("删除学习记录成功", true);
return resultDomain;
} else {
resultDomain.fail("删除学习记录失败");
return resultDomain;
}
}
@Override
public ResultDomain<TbLearningRecord> getLearningRecord(TbLearningRecord learningRecord) {
ResultDomain<TbLearningRecord> resultDomain = new ResultDomain<>();
List<TbLearningRecord> records = learningRecordMapper.selectLearningRecords(learningRecord);
resultDomain.success("获取学习记录成功", records);
return resultDomain;
}
@Override
public ResultDomain<TbLearningRecord> getCourseLearningRecord(TbLearningRecord learningRecord) {
ResultDomain<TbLearningRecord> resultDomain = new ResultDomain<>();
if (learningRecord.getCourseID() == null) {
resultDomain.fail("课程ID不能为空");
return resultDomain;
}
learningRecord.setResourceType(2);
List<TbLearningRecord> records = learningRecordMapper.selectLearningRecords(learningRecord);
resultDomain.success("获取学习记录成功", records);
return resultDomain;
}
@Override
public ResultDomain<TbLearningRecord> getResourceLearningRecords(TbLearningRecord learningRecord) {
ResultDomain<TbLearningRecord> resultDomain = new ResultDomain<>();
TbSysUser user = LoginUtil.getCurrentUser();
if (user == null) {
resultDomain.fail("请先登录");
return resultDomain;
}
learningRecord.setUserID(user.getID());
if (learningRecord.getResourceID() == null) {
resultDomain.fail("资源ID不能为空");
return resultDomain;
}
learningRecord.setResourceType(1);
List<TbLearningRecord> records = learningRecordMapper.selectLearningRecords(learningRecord);
resultDomain.success("获取学习记录成功", records);
return resultDomain;
}
@Override
public ResultDomain<TbLearningRecord> getTaskLearningStatistics(String taskID) {
// TODO Auto-generated method stub
return null;
// TODO Auto-generated method stub
return null;
}
@Override
public ResultDomain<TbLearningRecord> getUserLearningProgress(String userID, Integer resourceType,
String resourceID) {
// TODO Auto-generated method stub
return null;
}
@Override
public ResultDomain<TbLearningRecord> getUserLearningRecords(String userID, Integer resourceType, String taskID) {
// TODO Auto-generated method stub
return null;
String resourceID) {
// TODO Auto-generated method stub
return null;
}
@Override
public ResultDomain<TbLearningRecord> getUserLearningStatistics(String userID, Integer resourceType) {
// TODO Auto-generated method stub
return null;
// TODO Auto-generated method stub
return null;
}
@Override
public ResultDomain<TbLearningRecord> markLearningComplete(String userID, Integer resourceType, String resourceID,
String taskID) {
// TODO Auto-generated method stub
return null;
}
@Override
public ResultDomain<TbLearningRecord> saveLearningRecord(TbLearningRecord learningRecord) {
// TODO Auto-generated method stub
return null;
public ResultDomain<TbLearningRecord> markLearningComplete(TbLearningRecord learningRecord) {
ResultDomain<TbLearningRecord> resultDomain = new ResultDomain<>();
TbSysUser user = LoginUtil.getCurrentUser();
if (user == null) {
resultDomain.fail("请先登录");
return resultDomain;
}
learningRecord.setUpdater(user.getID());
learningRecord.setCompleteTime(new Date());
learningRecord.setIsComplete(true);
int result = learningRecordMapper.updateLearningRecord(learningRecord);
if (result > 0) {
// 检查是否完成了该任务的所有任务项
String taskId = learningRecord.getTaskID();
String userId = user.getID();
if (taskId != null && !taskId.isEmpty()) {
checkAndUpdateTaskCompletion(taskId, userId);
}
resultDomain.success("标记学习完成成功", learningRecord);
return resultDomain;
} else {
resultDomain.fail("标记学习完成失败");
return resultDomain;
}
}
@Override
public ResultDomain<TbLearningRecord> updateLearningProgress(String userID, Integer resourceType, String resourceID,
BigDecimal progress, Integer duration) {
// TODO Auto-generated method stub
return null;
/**
* @description 检查并更新任务完成状态
* @param taskId 任务ID
* @param userId 用户ID
* @author yslg
* @since 2025-10-24
*/
private void checkAndUpdateTaskCompletion(String taskId, String userId) {
try {
// 获取该任务下所有任务项（包含该用户的学习状态）
List<TaskItemVO> allTaskItems = taskItemMapper.selectTaskItemVOByTaskIdAndUserId(taskId, userId);
if (allTaskItems == null || allTaskItems.isEmpty()) {
return;
}
// 检查是否所有必须的任务项都已完成（status = 2）
boolean allCompleted = true;
int totalRequired = 0;
int completedRequired = 0;
for (TaskItemVO item : allTaskItems) {
if (item.getRequired() != null && item.getRequired()) {
totalRequired++;
if (item.getStatus() != null && item.getStatus() == 2) {
completedRequired++;
} else {
allCompleted = false;
}
}
}
if (!allCompleted) {
return;
}
// 计算总进度
BigDecimal progressPercent = BigDecimal.valueOf(100);
// 更新 task_user 状态
TbTaskUser taskUser = new TbTaskUser();
taskUser.setTaskID(taskId);
taskUser.setUserID(userId);
taskUser.setProgress(progressPercent);
taskUser.setUpdater(userId);
// 全部完成
taskUser.setStatus(2);
taskUser.setCompleteTime(new Date());
taskUserMapper.updateTaskUser(taskUser);
logger.info("更新任务用户状态成功 - taskId: {}, userId: {}, status: {}, progress: {}",
taskId, userId, taskUser.getStatus(), progressPercent);
} catch (Exception e) {
logger.error("检查并更新任务完成状态失败 - taskId: {}, userId: {}", taskId, userId, e);
}
}
}

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

@@ -20,16 +20,15 @@ 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.dto.study.TbTaskItem;
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.study.mapper.TaskItemMapper;
import org.xyzh.api.study.task.LearningTaskService;
import org.xyzh.common.core.enums.TaskItemType;
/**
* @description 学习任务服务实现类
@@ -50,19 +49,16 @@ public class SCLearningTaskServiceImpl implements LearningTaskService {
private TaskUserMapper taskUserMapper;
@Autowired
private TaskCourseMapper taskCourseMapper;
@Autowired
private TaskResourceMapper taskResourceMapper;
private TaskItemMapper taskItemMapper;
@Override
public ResultDomain<TbTaskCourse> addTaskCourse(TbTaskCourse taskCourse) {
public ResultDomain<TbTaskItem> addTaskCourse(TbTaskItem taskItem) {
// TODO Auto-generated method stub
return null;
}
@Override
public ResultDomain<TbTaskResource> addTaskResource(TbTaskResource taskResource) {
public ResultDomain<TbTaskItem> addTaskResource(TbTaskItem taskItem) {
// TODO Auto-generated method stub
return null;
}
@@ -148,22 +144,35 @@ public class SCLearningTaskServiceImpl implements LearningTaskService {
learningTask.setTaskID(taskID);
learningTask.setCreateTime(now);
learningTaskMapper.insertLearningTask(learningTask);
// 绑定课程
List<TbTaskCourse> taskCourses = taskVO.toTaskCourses();
// 绑定任务项（课程和资源）
List<TbTaskItem> taskItems = new ArrayList<>();
// 转换课程为任务项
List<TbTaskItem> taskCourses = taskVO.toTaskCourses();
taskCourses.forEach(item -> {
item.setTaskID(taskID);
item.setItemType(TaskItemType.COURSE.getValue());
item.setCreator(currentUser.getID());
item.setCreateTime(now);
});
taskCourseMapper.batchInsertTaskCourses(taskCourses);
// 绑定资源
List<TbTaskResource> taskResources = taskVO.toTaskResources();
taskItems.addAll(taskCourses);
// 转换资源为任务项
List<TbTaskItem> taskResources = taskVO.toTaskResources();
taskResources.forEach(item -> {
item.setTaskID(taskID);
item.setItemType(TaskItemType.RESOURCE.getValue());
item.setCreator(currentUser.getID());
item.setCreateTime(now);
});
taskResourceMapper.batchInsertTaskResources(taskResources);
taskItems.addAll(taskResources);
// 批量插入任务项
if (!taskItems.isEmpty()) {
taskItemMapper.batchInsertTaskItems(taskItems);
}
// 绑定用户
List<TbTaskUser> taskUsers = taskVO.toTaskUsers();
taskUsers.forEach(item -> {
@@ -202,19 +211,35 @@ public class SCLearningTaskServiceImpl implements LearningTaskService {
task.setUpdateTime(now);
learningTaskMapper.updateLearningTask(task);
// 2. 处理任务课程关联
// 2. 处理任务项关联（课程和资源）
List<TaskItemVO> newCourseItems = taskVO.getTaskCourses();
List<TaskItemVO> newResourceItems = taskVO.getTaskResources();
if (newCourseItems == null) {
newCourseItems = new ArrayList<>();
}
if (newResourceItems == null) {
newResourceItems = new ArrayList<>();
}
// 获取现有的课程关联
List<TbTaskCourse> existingCourses = taskCourseMapper.selectByTaskId(taskID);
Map<String, TbTaskCourse> existingCourseMap = existingCourses.stream()
.collect(Collectors.toMap(TbTaskCourse::getCourseID, course -> course));
// 获取现有的所有任务项
List<TbTaskItem> existingItems = taskItemMapper.selectByTaskId(taskID);
// 分离课程和资源
List<TbTaskItem> existingCourses = existingItems.stream()
.filter(item -> item.getItemType().equals(TaskItemType.COURSE.getValue()))
.collect(Collectors.toList());
List<TbTaskItem> existingResources = existingItems.stream()
.filter(item -> item.getItemType().equals(TaskItemType.RESOURCE.getValue()))
.collect(Collectors.toList());
Map<String, TbTaskItem> existingCourseMap = existingCourses.stream()
.collect(Collectors.toMap(TbTaskItem::getItemID, item -> item));
Map<String, TbTaskItem> existingResourceMap = existingResources.stream()
.collect(Collectors.toMap(TbTaskItem::getItemID, item -> item));
Set<String> newCourseIDs = new HashSet<>();
List<TbTaskCourse> coursesToInsert = new ArrayList<>();
Set<String> newResourceIDs = new HashSet<>();
List<TbTaskItem> itemsToInsert = new ArrayList<>();
// 处理新的课程关联
for (TaskItemVO item : newCourseItems) {
@@ -222,85 +247,62 @@ public class SCLearningTaskServiceImpl implements LearningTaskService {
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);
TbTaskItem taskItem = new TbTaskItem();
taskItem.setID(IDUtils.generateID());
taskItem.setTaskID(taskID);
taskItem.setItemType(TaskItemType.COURSE.getValue());
taskItem.setItemID(courseID);
taskItem.setRequired(item.getRequired());
taskItem.setOrderNum(item.getOrderNum());
taskItem.setCreator(user.getID());
taskItem.setCreateTime(now);
itemsToInsert.add(taskItem);
}
}
// 找出要删除的课程关联
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);
TbTaskItem taskItem = new TbTaskItem();
taskItem.setID(IDUtils.generateID());
taskItem.setTaskID(taskID);
taskItem.setItemType(TaskItemType.RESOURCE.getValue());
taskItem.setItemID(resourceID);
taskItem.setRequired(item.getRequired());
taskItem.setOrderNum(item.getOrderNum());
taskItem.setCreator(user.getID());
taskItem.setCreateTime(now);
itemsToInsert.add(taskItem);
}
}
// 找出要删除的资源关联
List<String> resourceIDsToDelete = existingResourceMap.values().stream()
.filter(resource -> !newResourceIDs.contains(resource.getResourceID()))
.map(TbTaskResource::getID)
.collect(Collectors.toList());
// 找出要删除的任务项
List<String> itemIDsToDelete = new ArrayList<>();
existingCourseMap.values().stream()
.filter(item -> !newCourseIDs.contains(item.getItemID()))
.forEach(item -> itemIDsToDelete.add(item.getID()));
existingResourceMap.values().stream()
.filter(item -> !newResourceIDs.contains(item.getItemID()))
.forEach(item -> itemIDsToDelete.add(item.getID()));
if (!resourceIDsToDelete.isEmpty()) {
taskResourceMapper.batchDeleteTaskResources(resourceIDsToDelete);
if (!itemIDsToDelete.isEmpty()) {
taskItemMapper.batchDeleteTaskItems(itemIDsToDelete);
}
if (!resourcesToInsert.isEmpty()) {
taskResourceMapper.batchInsertTaskResources(resourcesToInsert);
if (!itemsToInsert.isEmpty()) {
taskItemMapper.batchInsertTaskItems(itemsToInsert);
}
// 4. 处理任务用户关联
// 3. 处理任务用户关联
List<TaskItemVO> newUserItems = taskVO.getTaskUsers();
if (newUserItems == null) {
newUserItems = new ArrayList<>();
@@ -368,33 +370,143 @@ public class SCLearningTaskServiceImpl implements LearningTaskService {
resultDomain.fail("任务不存在");
return resultDomain;
}
List<TaskItemVO> taskCourses = taskCourseMapper.selectTaskItemByTaskId(taskID);
List<TaskItemVO> taskResources = taskResourceMapper.selectTaskItemByTaskId(taskID);
// 获取所有任务项
List<TaskItemVO> allTaskItems = taskItemMapper.selectTaskItemVOByTaskId(taskID);
// 一次循环完成分离和统计
List<TaskItemVO> taskCourses = new ArrayList<>();
List<TaskItemVO> taskResources = new ArrayList<>();
int completedTaskNum = 0;
int learningTaskNum = 0;
int notStartTaskNum = 0;
for (TaskItemVO item : allTaskItems) {
// 分离课程和资源
if (item.getItemType() != null) {
if (item.getItemType().equals(TaskItemType.COURSE.getValue())) {
taskCourses.add(item);
} else if (item.getItemType().equals(TaskItemType.RESOURCE.getValue())) {
taskResources.add(item);
}
}
// 统计状态
Integer status = item.getStatus();
if (status != null) {
if (status == 2) {
completedTaskNum++;
} else if (status == 1) {
learningTaskNum++;
} else if (status == 0) {
notStartTaskNum++;
}
}
}
taskVO.setCompletedTaskNum(completedTaskNum);
taskVO.setLearningTaskNum(learningTaskNum);
taskVO.setNotStartTaskNum(notStartTaskNum);
List<TaskItemVO> taskUsers = taskUserMapper.selectTaskItemByTaskId(taskID);
taskVO.setLearningTask(task);
taskVO.setTaskCourses(taskCourses);
taskVO.setTaskResources(taskResources);
taskVO.setTaskUsers(taskUsers);
taskVO.setTotalTaskNum(allTaskItems.size());
resultDomain.success("获取任务详情成功", taskVO);
return resultDomain;
}
@Override
public ResultDomain<TbTaskCourse> getTaskCourses(String taskID) {
// TODO Auto-generated method stub
return null;
public ResultDomain<TaskVO> getTaskUser(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> allTaskItems = taskItemMapper.selectTaskItemVOByTaskId(taskID);
// 一次循环完成分离和统计
List<TaskItemVO> taskCourses = new ArrayList<>();
List<TaskItemVO> taskResources = new ArrayList<>();
int completedTaskNum = 0;
int learningTaskNum = 0;
int notStartTaskNum = 0;
for (TaskItemVO item : allTaskItems) {
// 分离课程和资源
if (item.getItemType() != null) {
if (item.getItemType().equals(TaskItemType.COURSE.getValue())) {
taskCourses.add(item);
} else if (item.getItemType().equals(TaskItemType.RESOURCE.getValue())) {
taskResources.add(item);
}
}
// 统计状态
Integer status = item.getStatus();
if (status != null) {
if (status == 2) {
completedTaskNum++;
} else if (status == 1) {
learningTaskNum++;
} else if (status == 0) {
notStartTaskNum++;
}
}
}
taskVO.setCompletedTaskNum(completedTaskNum);
taskVO.setLearningTaskNum(learningTaskNum);
taskVO.setNotStartTaskNum(notStartTaskNum);
List<TaskItemVO> taskUsers = taskUserMapper.selectUserTaskItem(taskID, LoginUtil.getCurrentUser().getID());
taskVO.setLearningTask(task);
taskVO.setTaskCourses(taskCourses);
taskVO.setTaskResources(taskResources);
taskVO.setTaskUsers(taskUsers);
taskVO.setTotalTaskNum(allTaskItems.size());
resultDomain.success("获取任务详情成功", taskVO);
return resultDomain;
}
@Override
public ResultDomain<TbTaskItem> getTaskCourses(String taskID) {
ResultDomain<TbTaskItem> resultDomain = new ResultDomain<>();
List<TbTaskItem> taskCourses = taskItemMapper.selectByTaskIdAndType(taskID, TaskItemType.COURSE.getValue());
resultDomain.success("获取任务课程列表成功", taskCourses);
return resultDomain;
}
@Override
public ResultDomain<TbLearningTask> getTaskList(TbLearningTask filter) {
// TODO Auto-generated method stub
return null;
ResultDomain<TbLearningTask> resultDomain = new ResultDomain<>();
List<TbLearningTask> taskList = learningTaskMapper.selectLearningTasks(filter);
resultDomain.success("获取任务列表成功", taskList);
return resultDomain;
}
@Override
public ResultDomain<TbTaskResource> getTaskResources(String taskID) {
// TODO Auto-generated method stub
return null;
public ResultDomain<TbTaskItem> getTaskResources(String taskID) {
ResultDomain<TbTaskItem> resultDomain = new ResultDomain<>();
List<TbTaskItem> taskResources = taskItemMapper.selectByTaskIdAndType(taskID, TaskItemType.RESOURCE.getValue());
resultDomain.success("获取任务资源列表成功", taskResources);
return resultDomain;
}
@Override
@@ -407,14 +519,28 @@ public class SCLearningTaskServiceImpl implements LearningTaskService {
@Override
public ResultDomain<Boolean> removeTaskCourse(String taskID, String courseID) {
// TODO Auto-generated method stub
return null;
ResultDomain<Boolean> resultDomain = new ResultDomain<>();
TbTaskItem taskItem = taskItemMapper.selectByTaskIdAndItemId(taskID, courseID, TaskItemType.COURSE.getValue());
if (taskItem != null) {
taskItemMapper.deleteTaskItem(taskItem);
resultDomain.success("移除任务课程成功", true);
} else {
resultDomain.fail("任务课程不存在");
}
return resultDomain;
}
@Override
public ResultDomain<Boolean> removeTaskResource(String taskID, String resourceID) {
// TODO Auto-generated method stub
return null;
ResultDomain<Boolean> resultDomain = new ResultDomain<>();
TbTaskItem taskItem = taskItemMapper.selectByTaskIdAndItemId(taskID, resourceID, TaskItemType.RESOURCE.getValue());
if (taskItem != null) {
taskItemMapper.deleteTaskItem(taskItem);
resultDomain.success("移除任务资源成功", true);
} else {
resultDomain.fail("任务资源不存在");
}
return resultDomain;
}
@Override

45
schoolNewsServ/study/src/main/resources/mapper/LearningRecordMapper.xml
View File

@@ -6,9 +6,12 @@
<resultMap id="BaseResultMap" type="org.xyzh.common.dto.study.TbLearningRecord">
<id column="id" property="id" jdbcType="VARCHAR"/>
<result column="user_id" property="userID" jdbcType="VARCHAR"/>
<result column="task_id" property="taskID" jdbcType="VARCHAR"/>
<result column="resource_type" property="resourceType" jdbcType="INTEGER"/>
<result column="resource_id" property="resourceID" jdbcType="VARCHAR"/>
<result column="task_id" property="taskID" jdbcType="VARCHAR"/>
<result column="course_id" property="courseID" jdbcType="VARCHAR"/>
<result column="chapter_id" property="chapterID" jdbcType="VARCHAR"/>
<result column="node_id" property="nodeID" jdbcType="VARCHAR"/>
<result column="duration" property="duration" jdbcType="INTEGER"/>
<result column="progress" property="progress" jdbcType="DECIMAL"/>
<result column="is_complete" property="isComplete" jdbcType="BOOLEAN"/>
@@ -20,7 +23,7 @@
<!-- 基础字段 -->
<sql id="Base_Column_List">
id, user_id, resource_type, resource_id, task_id, duration, progress,
id, user_id, task_id, resource_type, resource_id, course_id, chapter_id, node_id, duration, progress,
is_complete, complete_time, last_learn_time, create_time, update_time
</sql>
@@ -30,14 +33,23 @@
<if test="userID != null and userID != ''">
AND user_id = #{userID}
</if>
<if test="taskID != null and taskID != ''">
AND task_id = #{taskID}
</if>
<if test="resourceType != null">
AND resource_type = #{resourceType}
</if>
<if test="resourceID != null and resourceID != ''">
AND resource_id = #{resourceID}
</if>
<if test="taskID != null and taskID != ''">
AND task_id = #{taskID}
<if test="courseID != null and courseID != ''">
AND course_id = #{courseID}
</if>
<if test="chapterID != null and chapterID != ''">
AND chapter_id = #{chapterID}
</if>
<if test="nodeID != null and nodeID != ''">
AND node_id = #{nodeID}
</if>
<if test="isComplete != null">
AND is_complete = #{isComplete}
@@ -85,7 +97,7 @@
SELECT
<include refid="Base_Column_List" />
FROM tb_learning_record
WHERE user_id = #{userId} AND resource_id = #{courseId}
WHERE user_id = #{userId} AND course_id = #{courseId} AND resource_type = 2
</select>
<!-- 根据状态查询学习记录列表 -->
@@ -113,11 +125,11 @@
<!-- 插入学习记录 -->
<insert id="insertLearningRecord" parameterType="org.xyzh.common.dto.study.TbLearningRecord">
INSERT INTO tb_learning_record (
id, user_id, resource_type, resource_id, task_id, duration, progress,
is_complete, complete_time, last_learn_time, create_time, update_time
id, user_id, task_id, resource_type, resource_id, course_id, chapter_id, node_id, duration, progress,
is_complete, complete_time, last_learn_time, create_time
) VALUES (
#{id}, #{userID}, #{resourceType}, #{resourceID}, #{taskID}, #{duration}, #{progress},
#{isComplete}, #{completeTime}, #{lastLearnTime}, #{createTime}, #{updateTime}
#{id}, #{userID}, #{taskID}, #{resourceType}, #{resourceID}, #{courseID}, #{chapterID}, #{nodeID}, #{duration}, #{progress},
#{isComplete}, #{completeTime}, #{lastLearnTime}, #{createTime}
)
</insert>
@@ -125,18 +137,6 @@
<update id="updateLearningRecord" parameterType="org.xyzh.common.dto.study.TbLearningRecord">
UPDATE tb_learning_record
<set>
<if test="userID != null and userID != ''">
user_id = #{userID},
</if>
<if test="resourceType != null">
resource_type = #{resourceType},
</if>
<if test="resourceID != null and resourceID != ''">
resource_id = #{resourceID},
</if>
<if test="taskID != null and taskID != ''">
task_id = #{taskID},
</if>
<if test="duration != null">
duration = #{duration},
</if>
@@ -152,6 +152,9 @@
<if test="lastLearnTime != null">
last_learn_time = #{lastLearnTime},
</if>
<if test="updater != null">
updater = #{updater},
</if>
<if test="updateTime != null">
update_time = #{updateTime},
</if>

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

@@ -226,7 +226,7 @@
<select id="selectUserLearningTasksPage" resultMap="BaseResultMap">
SELECT
tlt.id, tlt.task_id, tlt.name, tlt.description, tlt.start_time, tlt.end_time, tlt.status,
tlt.id, tlt.task_id, tlt.name, tlt.description, tlt.start_time, tlt.end_time, ttu.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

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

@@ -1,209 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.xyzh.study.mapper.TaskCourseMapper">
<!-- 基础结果映射 -->
<resultMap id="BaseResultMap" type="org.xyzh.common.dto.study.TbTaskCourse">
<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="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>
<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
</sql>
<!-- 通用条件 -->
<sql id="Where_Clause">
<where>
<if test="taskID != null and taskID != ''">
AND task_id = #{taskID}
</if>
<if test="courseID != null and courseID != ''">
AND course_id = #{courseID}
</if>
<if test="required != null">
AND required = #{required}
</if>
</where>
</sql>
<!-- selectTaskCourses -->
<select id="selectTaskCourses" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List"/>
FROM tb_task_course
<include refid="Where_Clause"/>
ORDER BY order_num ASC, create_time ASC
</select>
<!-- 根据关联ID查询关联信息 -->
<select id="selectByRelationId" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List" />
FROM tb_task_course
WHERE id = #{relationId}
</select>
<select id="selectByTaskId" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List" />
FROM tb_task_course
WHERE task_id = #{taskId}
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
<include refid="Base_Column_List" />
FROM tb_task_course
WHERE course_id = #{courseId}
ORDER BY order_num ASC, create_time ASC
</select>
<!-- 根据任务ID和课程ID查询关联信息 -->
<select id="selectByTaskIdAndCourseId" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List" />
FROM tb_task_course
WHERE task_id = #{taskId} AND course_id = #{courseId}
</select>
<!-- 检查任务课程关联是否存在 -->
<select id="countByTaskIdAndCourseId" resultType="int">
SELECT COUNT(1)
FROM tb_task_course
WHERE task_id = #{taskId} AND course_id = #{courseId}
<if test="excludeId != null and excludeId != ''">
AND id != #{excludeId}
</if>
</select>
<!-- 插入任务课程关联 -->
<insert id="insertTaskCourse" parameterType="org.xyzh.common.dto.study.TbTaskCourse">
INSERT INTO tb_task_course (
id, task_id, course_id, required, order_num, creator, create_time
) VALUES (
#{id}, #{taskID}, #{courseID}, #{required}, #{orderNum}, #{creator}, #{createTime}
)
</insert>
<!-- 更新任务课程关联 -->
<update id="updateTaskCourse" parameterType="org.xyzh.common.dto.study.TbTaskCourse">
UPDATE tb_task_course
<set>
<if test="taskID != null and taskID != ''">
task_id = #{taskID},
</if>
<if test="courseID != null and courseID != ''">
course_id = #{courseID},
</if>
<if test="required != null">
required = #{required},
</if>
<if test="orderNum != null">
order_num = #{orderNum},
</if>
<if test="creator != null and creator != ''">
creator = #{creator},
</if>
<if test="createTime != null">
create_time = #{createTime},
</if>
</set>
WHERE id = #{id}
</update>
<!-- 删除任务课程关联 -->
<delete id="deleteTaskCourse" parameterType="org.xyzh.common.dto.study.TbTaskCourse">
DELETE FROM tb_task_course
WHERE id = #{id}
</delete>
<!-- 批量插入任务课程关联 -->
<insert id="batchInsertTaskCourses" parameterType="java.util.List">
INSERT INTO tb_task_course (
id, task_id, course_id, required, order_num, creator, create_time
) VALUES
<foreach collection="taskCourseList" item="item" separator=",">
(
#{item.id}, #{item.taskID}, #{item.courseID}, #{item.required},
#{item.orderNum}, #{item.creator}, #{item.createTime}
)
</foreach>
</insert>
<!-- 批量删除任务课程关联 -->
<delete id="batchDeleteTaskCourses">
DELETE FROM tb_task_course
WHERE id IN
<foreach collection="ids" item="id" open="(" separator="," close=")">
#{id}
</foreach>
</delete>
<!-- 根据任务ID批量删除课程关联 -->
<delete id="deleteByTaskId">
DELETE FROM tb_task_course
WHERE task_id = #{taskId}
</delete>
<!-- 根据课程ID批量删除任务关联 -->
<delete id="deleteByCourseId">
DELETE FROM tb_task_course
WHERE course_id = #{courseId}
</delete>
<!-- 分页查询任务课程关联 -->
<select id="selectTaskCoursesPage" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List" />
FROM tb_task_course
<include refid="Where_Clause" />
ORDER BY order_num ASC, create_time ASC
LIMIT #{pageParam.pageSize} OFFSET #{pageParam.offset}
</select>
<!-- 统计任务课程关联总数 -->
<select id="countTaskCourses" resultType="long">
SELECT COUNT(1)
FROM tb_task_course
<include refid="Where_Clause" />
</select>
</mapper>

398
schoolNewsServ/study/src/main/resources/mapper/TaskItemMapper.xml Normal file
View File

@@ -0,0 +1,398 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.xyzh.study.mapper.TaskItemMapper">
<!-- 基础结果映射 -->
<resultMap id="BaseResultMap" type="org.xyzh.common.dto.study.TbTaskItem">
<id column="id" property="id" jdbcType="VARCHAR"/>
<result column="task_id" property="taskID" jdbcType="VARCHAR"/>
<result column="item_type" property="itemType" jdbcType="INTEGER"/>
<result column="item_id" property="itemID" jdbcType="VARCHAR"/>
<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"/>
<result column="updater" property="updater" jdbcType="VARCHAR"/>
<result column="update_time" property="updateTime" jdbcType="TIMESTAMP"/>
<result column="delete_time" property="deleteTime" jdbcType="TIMESTAMP"/>
<result column="deleted" property="deleted" jdbcType="BOOLEAN"/>
</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="item_type" property="itemType" jdbcType="INTEGER"/>
<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, item_type, item_id, required, order_num, creator, create_time,
updater, update_time, delete_time, deleted
</sql>
<!-- 通用条件 -->
<sql id="Where_Clause">
<where>
deleted = 0
<if test="taskID != null and taskID != ''">
AND task_id = #{taskID}
</if>
<if test="itemType != null">
AND item_type = #{itemType}
</if>
<if test="itemID != null and itemID != ''">
AND item_id = #{itemID}
</if>
<if test="required != null">
AND required = #{required}
</if>
</where>
</sql>
<!-- selectTaskItems -->
<select id="selectTaskItems" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List"/>
FROM tb_task_item
<include refid="Where_Clause"/>
ORDER BY order_num ASC, create_time ASC
</select>
<!-- 根据关联ID查询关联信息 -->
<select id="selectByRelationId" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List" />
FROM tb_task_item
WHERE id = #{relationId} AND deleted = 0
</select>
<!-- 根据任务ID查询项关联列表 -->
<select id="selectByTaskId" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List" />
FROM tb_task_item
WHERE task_id = #{taskId} AND deleted = 0
ORDER BY order_num ASC, create_time ASC
</select>
<!-- 根据任务ID和类型查询项关联列表 -->
<select id="selectByTaskIdAndType" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List" />
FROM tb_task_item
WHERE task_id = #{taskId} AND item_type = #{itemType} AND deleted = 0
ORDER BY order_num ASC, create_time ASC
</select>
<!-- 根据任务ID查询任务项VO列表（带学习状态） -->
<select id="selectTaskItemVOByTaskId" resultMap="TaskItemResultMap">
SELECT
tti.*,
CASE
WHEN tti.item_type = 1 THEN tr.title
WHEN tti.item_type = 2 THEN tc.name
END as item_name,
CASE
WHEN tti.item_type = 1 THEN tti.item_id
ELSE NULL
END as resource_id,
CASE
WHEN tti.item_type = 1 THEN tr.title
ELSE NULL
END as resource_name,
CASE
WHEN tti.item_type = 2 THEN tti.item_id
ELSE NULL
END as course_id,
CASE
WHEN tti.item_type = 2 THEN tc.name
ELSE NULL
END as course_name,
-- 学习状态：0未开始 1进行中 2已完成
CASE
-- 资源类型：直接从学习记录查询
WHEN tti.item_type = 1 THEN
CASE
WHEN lr_resource.is_complete = 1 THEN 2
WHEN lr_resource.id IS NOT NULL THEN 1
ELSE 0
END
-- 课程类型：判断所有节点是否完成
WHEN tti.item_type = 2 THEN
CASE
WHEN course_stats.total_nodes = 0 THEN 0
WHEN course_stats.completed_nodes = course_stats.total_nodes THEN 2
WHEN course_stats.completed_nodes > 0 THEN 1
ELSE 0
END
ELSE 0
END as status,
-- 学习进度
CASE
WHEN tti.item_type = 1 THEN COALESCE(lr_resource.progress, 0)
WHEN tti.item_type = 2 THEN
CASE
WHEN course_stats.total_nodes = 0 THEN 0
ELSE ROUND((course_stats.completed_nodes * 100.0 / course_stats.total_nodes), 2)
END
ELSE 0
END as progress
FROM tb_task_item tti
LEFT JOIN tb_resource tr ON tti.item_type = 1 AND tti.item_id = tr.resource_id AND tr.deleted = 0
LEFT JOIN tb_course tc ON tti.item_type = 2 AND tti.item_id = tc.course_id AND tc.deleted = 0
-- 资源学习记录
LEFT JOIN tb_learning_record lr_resource ON tti.item_type = 1
AND lr_resource.resource_type = 1
AND lr_resource.resource_id = tti.item_id
AND lr_resource.task_id = tti.task_id
AND lr_resource.deleted = 0
-- 课程学习统计（统计课程下所有节点的完成情况）
LEFT JOIN (
SELECT
tti.item_id as course_id,
COUNT(DISTINCT tcn.node_id) as total_nodes,
COUNT(DISTINCT CASE WHEN lr.is_complete = 1 THEN lr.node_id END) as completed_nodes
FROM tb_task_item tti
INNER JOIN tb_course_chapter tcc ON tti.item_type = 2 AND tti.item_id = tcc.course_id AND tcc.deleted = 0
INNER JOIN tb_course_node tcn ON tcc.chapter_id = tcn.chapter_id AND tcn.deleted = 0
LEFT JOIN tb_learning_record lr ON lr.resource_type = 2
AND tti.item_id = lr.course_id
AND lr.node_id = tcn.node_id
AND lr.deleted = 0
WHERE tti.task_id = #{taskId} AND tti.deleted = 0
GROUP BY tti.item_id
) course_stats ON tti.item_type = 2 AND course_stats.course_id = tti.item_id
WHERE tti.task_id = #{taskId} AND tti.deleted = 0
ORDER BY tti.order_num ASC, tti.create_time ASC
</select>
<!-- 根据任务ID和用户ID查询任务项视图对象列表（包含该用户的学习状态） -->
<select id="selectTaskItemVOByTaskIdAndUserId" resultMap="TaskItemResultMap">
SELECT
tti.*,
CASE
WHEN tti.item_type = 1 THEN tr.title
WHEN tti.item_type = 2 THEN tc.name
END as item_name,
CASE
WHEN tti.item_type = 1 THEN tti.item_id
ELSE NULL
END as resource_id,
CASE
WHEN tti.item_type = 1 THEN tr.title
ELSE NULL
END as resource_name,
CASE
WHEN tti.item_type = 2 THEN tti.item_id
ELSE NULL
END as course_id,
CASE
WHEN tti.item_type = 2 THEN tc.name
ELSE NULL
END as course_name,
-- 学习状态：0未开始 1进行中 2已完成
CASE
-- 资源类型：直接从学习记录查询
WHEN tti.item_type = 1 THEN
CASE
WHEN lr_resource.is_complete = 1 THEN 2
WHEN lr_resource.id IS NOT NULL THEN 1
ELSE 0
END
-- 课程类型：判断所有节点是否完成
WHEN tti.item_type = 2 THEN
CASE
WHEN course_stats.total_nodes = 0 THEN 0
WHEN course_stats.completed_nodes = course_stats.total_nodes THEN 2
WHEN course_stats.completed_nodes > 0 THEN 1
ELSE 0
END
ELSE 0
END as status,
-- 学习进度
CASE
WHEN tti.item_type = 1 THEN COALESCE(lr_resource.progress, 0)
WHEN tti.item_type = 2 THEN
CASE
WHEN course_stats.total_nodes = 0 THEN 0
ELSE ROUND((course_stats.completed_nodes * 100.0 / course_stats.total_nodes), 2)
END
ELSE 0
END as progress
FROM tb_task_item tti
LEFT JOIN tb_resource tr ON tti.item_type = 1 AND tti.item_id = tr.resource_id AND tr.deleted = 0
LEFT JOIN tb_course tc ON tti.item_type = 2 AND tti.item_id = tc.course_id AND tc.deleted = 0
-- 资源学习记录（限定用户）
LEFT JOIN tb_learning_record lr_resource ON tti.item_type = 1
AND lr_resource.resource_type = 1
AND lr_resource.resource_id = tti.item_id
AND lr_resource.task_id = tti.task_id
AND lr_resource.user_id = #{userId}
AND lr_resource.deleted = 0
-- 课程学习统计（统计课程下所有节点的完成情况，限定用户）
LEFT JOIN (
SELECT
tti.item_id as course_id,
COUNT(DISTINCT tcn.node_id) as total_nodes,
COUNT(DISTINCT CASE WHEN lr.is_complete = 1 THEN lr.node_id END) as completed_nodes
FROM tb_task_item tti
INNER JOIN tb_course_chapter tcc ON tti.item_type = 2 AND tti.item_id = tcc.course_id AND tcc.deleted = 0
INNER JOIN tb_course_node tcn ON tcc.chapter_id = tcn.chapter_id AND tcn.deleted = 0
LEFT JOIN tb_learning_record lr ON lr.resource_type = 2
AND tti.item_id = lr.course_id
AND lr.node_id = tcn.node_id
AND lr.user_id = #{userId}
AND lr.deleted = 0
WHERE tti.task_id = #{taskId} AND tti.deleted = 0
GROUP BY tti.item_id
) course_stats ON tti.item_type = 2 AND course_stats.course_id = tti.item_id
WHERE tti.task_id = #{taskId} AND tti.deleted = 0
ORDER BY tti.order_num ASC, tti.create_time ASC
</select>
<!-- 根据项ID查询任务关联列表 -->
<select id="selectByItemId" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List" />
FROM tb_task_item
WHERE item_id = #{itemId} AND item_type = #{itemType} AND deleted = 0
ORDER BY order_num ASC, create_time ASC
</select>
<!-- 根据任务ID和项ID查询关联信息 -->
<select id="selectByTaskIdAndItemId" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List" />
FROM tb_task_item
WHERE task_id = #{taskId} AND item_id = #{itemId} AND item_type = #{itemType} AND deleted = 0
</select>
<!-- 检查任务项关联是否存在 -->
<select id="countByTaskIdAndItemId" resultType="int">
SELECT COUNT(1)
FROM tb_task_item
WHERE task_id = #{taskId} AND item_id = #{itemId} AND item_type = #{itemType} AND deleted = 0
<if test="excludeId != null and excludeId != ''">
AND id != #{excludeId}
</if>
</select>
<!-- 插入任务项关联 -->
<insert id="insertTaskItem" parameterType="org.xyzh.common.dto.study.TbTaskItem">
INSERT INTO tb_task_item (
id, task_id, item_type, item_id, required, order_num, creator, create_time
) VALUES (
#{id}, #{taskID}, #{itemType}, #{itemID}, #{required}, #{orderNum}, #{creator}, #{createTime}
)
</insert>
<!-- 更新任务项关联 -->
<update id="updateTaskItem" parameterType="org.xyzh.common.dto.study.TbTaskItem">
UPDATE tb_task_item
<set>
<if test="taskID != null and taskID != ''">
task_id = #{taskID},
</if>
<if test="itemType != null">
item_type = #{itemType},
</if>
<if test="itemID != null and itemID != ''">
item_id = #{itemID},
</if>
<if test="required != null">
required = #{required},
</if>
<if test="orderNum != null">
order_num = #{orderNum},
</if>
<if test="updater != null and updater != ''">
updater = #{updater},
</if>
<if test="updateTime != null">
update_time = #{updateTime},
</if>
<if test="deleteTime != null">
delete_time = #{deleteTime},
</if>
<if test="deleted != null">
deleted = #{deleted},
</if>
</set>
WHERE id = #{id}
</update>
<!-- 删除任务项关联（软删除） -->
<update id="deleteTaskItem" parameterType="org.xyzh.common.dto.study.TbTaskItem">
UPDATE tb_task_item
SET deleted = 1, delete_time = NOW()
WHERE id = #{id}
</update>
<!-- 批量插入任务项关联 -->
<insert id="batchInsertTaskItems" parameterType="java.util.List">
INSERT INTO tb_task_item (
id, task_id, item_type, item_id, required, order_num, creator, create_time
) VALUES
<foreach collection="taskItemList" item="item" separator=",">
(
#{item.id}, #{item.taskID}, #{item.itemType}, #{item.itemID}, #{item.required},
#{item.orderNum}, #{item.creator}, #{item.createTime}
)
</foreach>
</insert>
<!-- 批量删除任务项关联（软删除） -->
<update id="batchDeleteTaskItems">
UPDATE tb_task_item
SET deleted = 1, delete_time = NOW()
WHERE id IN
<foreach collection="ids" item="id" open="(" separator="," close=")">
#{id}
</foreach>
</update>
<!-- 根据任务ID批量删除项关联（软删除） -->
<update id="deleteByTaskId">
UPDATE tb_task_item
SET deleted = 1, delete_time = NOW()
WHERE task_id = #{taskId}
</update>
<!-- 根据项ID批量删除任务关联（软删除） -->
<update id="deleteByItemId">
UPDATE tb_task_item
SET deleted = 1, delete_time = NOW()
WHERE item_id = #{itemId} AND item_type = #{itemType}
</update>
<!-- 分页查询任务项关联 -->
<select id="selectTaskItemsPage" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List" />
FROM tb_task_item
<include refid="Where_Clause" />
ORDER BY order_num ASC, create_time ASC
LIMIT #{pageParam.pageSize} OFFSET #{pageParam.offset}
</select>
<!-- 统计任务项关联总数 -->
<select id="countTaskItems" resultType="long">
SELECT COUNT(1)
FROM tb_task_item
<include refid="Where_Clause" />
</select>
</mapper>

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

@@ -1,208 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.xyzh.study.mapper.TaskResourceMapper">
<!-- 基础结果映射 -->
<resultMap id="BaseResultMap" type="org.xyzh.common.dto.study.TbTaskResource">
<id column="id" property="id" jdbcType="VARCHAR"/>
<result column="task_id" property="taskID" jdbcType="VARCHAR"/>
<result column="resource_id" property="resourceID" jdbcType="VARCHAR"/>
<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>
<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
</sql>
<!-- 通用条件 -->
<sql id="Where_Clause">
<where>
<if test="taskID != null and taskID != ''">
AND task_id = #{taskID}
</if>
<if test="resourceID != null and resourceID != ''">
AND resource_id = #{resourceID}
</if>
<if test="required != null">
AND required = #{required}
</if>
</where>
</sql>
<!-- selectTaskResources -->
<select id="selectTaskResources" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List"/>
FROM tb_task_resource
<include refid="Where_Clause"/>
ORDER BY order_num ASC, create_time ASC
</select>
<!-- 根据关联ID查询关联信息 -->
<select id="selectByRelationId" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List" />
FROM tb_task_resource
WHERE id = #{relationId}
</select>
<!-- 根据任务ID查询资源关联列表 -->
<select id="selectByTaskId" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List" />
FROM tb_task_resource
WHERE task_id = #{taskId}
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
<include refid="Base_Column_List" />
FROM tb_task_resource
WHERE resource_id = #{resourceId}
ORDER BY order_num ASC, create_time ASC
</select>
<!-- 根据任务ID和资源ID查询关联信息 -->
<select id="selectByTaskIdAndResourceId" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List" />
FROM tb_task_resource
WHERE task_id = #{taskId} AND resource_id = #{resourceId}
</select>
<!-- 检查任务资源关联是否存在 -->
<select id="countByTaskIdAndResourceId" resultType="int">
SELECT COUNT(1)
FROM tb_task_resource
WHERE task_id = #{taskId} AND resource_id = #{resourceId}
<if test="excludeId != null and excludeId != ''">
AND id != #{excludeId}
</if>
</select>
<!-- 插入任务资源关联 -->
<insert id="insertTaskResource" parameterType="org.xyzh.common.dto.study.TbTaskResource">
INSERT INTO tb_task_resource (
id, task_id, resource_id, required, order_num, creator, create_time
) VALUES (
#{id}, #{taskID}, #{resourceID}, #{required}, #{orderNum}, #{creator}, #{createTime}
)
</insert>
<!-- 更新任务资源关联 -->
<update id="updateTaskResource" parameterType="org.xyzh.common.dto.study.TbTaskResource">
UPDATE tb_task_resource
<set>
<if test="taskID != null and taskID != ''">
task_id = #{taskID},
</if>
<if test="resourceID != null and resourceID != ''">
resource_id = #{resourceID},
</if>
<if test="required != null">
required = #{required},
</if>
<if test="orderNum != null">
order_num = #{orderNum},
</if>
<if test="creator != null and creator != ''">
creator = #{creator},
</if>
<if test="createTime != null">
create_time = #{createTime},
</if>
</set>
WHERE id = #{id}
</update>
<!-- 删除任务资源关联 -->
<delete id="deleteTaskResource" parameterType="org.xyzh.common.dto.study.TbTaskResource">
DELETE FROM tb_task_resource
WHERE id = #{id}
</delete>
<!-- 批量插入任务资源关联 -->
<insert id="batchInsertTaskResources" parameterType="java.util.List">
INSERT INTO tb_task_resource (
id, task_id, resource_id, required, order_num, creator, create_time
) VALUES
<foreach collection="taskResourceList" item="item" separator=",">
(
#{item.id}, #{item.taskID}, #{item.resourceID}, #{item.required},
#{item.orderNum}, #{item.creator}, #{item.createTime}
)
</foreach>
</insert>
<!-- 批量删除任务资源关联 -->
<delete id="batchDeleteTaskResources">
DELETE FROM tb_task_resource
WHERE id IN
<foreach collection="ids" item="id" open="(" separator="," close=")">
#{id}
</foreach>
</delete>
<!-- 根据任务ID批量删除资源关联 -->
<delete id="deleteByTaskId">
DELETE FROM tb_task_resource
WHERE task_id = #{taskId}
</delete>
<!-- 根据资源ID批量删除任务关联 -->
<delete id="deleteByResourceId">
DELETE FROM tb_task_resource
WHERE resource_id = #{resourceId}
</delete>
<!-- 分页查询任务资源关联 -->
<select id="selectTaskResourcesPage" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List" />
FROM tb_task_resource
<include refid="Where_Clause" />
ORDER BY order_num ASC, create_time ASC
LIMIT #{pageParam.pageSize} OFFSET #{pageParam.offset}
</select>
<!-- 统计任务资源关联总数 -->
<select id="countTaskResources" resultType="long">
SELECT COUNT(1)
FROM tb_task_resource
<include refid="Where_Clause" />
</select>
</mapper>

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

@@ -94,6 +94,16 @@
ORDER BY ttu.create_time ASC
</select>
<select id="selectUserTaskItem" 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.user_id = #{userId} and ttu.deleted = 0 and tu.deleted = 0
ORDER BY ttu.create_time ASC
</select>
<!-- 根据用户ID查询任务关联列表 -->
<select id="selectByUserId" resultMap="BaseResultMap">
SELECT
@@ -142,14 +152,33 @@
<!-- 插入任务用户关联 -->
<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
id, task_id, user_id, dept_id,creator, create_time
) VALUES (
#{id}, #{taskID}, #{userID}, #{deptID}, #{status}, #{progress}, #{completeTime},
#{creator}, #{createTime}
#{id}, #{taskID}, #{userID}, #{deptID}, #{creator}, #{createTime}
)
</insert>
<!-- 更新任务用户关联 -->
<update id="updateTaskUser" parameterType="org.xyzh.common.dto.study.TbTaskUser">
UPDATE tb_task_user
<set>
<if test="status != null">
status = #{status},
</if>
<if test="progress != null">
progress = #{progress},
</if>
<if test="completeTime != null">
complete_time = #{completeTime},
</if>
<if test="updater != null">
updater = #{updater},
</if>
update_time = NOW()
</set>
WHERE task_id = #{taskID} AND user_id = #{userID} AND deleted = 0
</update>
<!-- 删除任务用户关联 -->
<delete id="deleteTaskUser" parameterType="org.xyzh.common.dto.study.TbTaskUser">
DELETE FROM tb_task_user