在线版本

标签创建移除旧版本部分代码
排序调整
2025-12-07 01:46:47 +08:00 · 2025-11-14 14:41:10 +08:00 · 2025-11-14 09:59:27 +08:00 · 2025-11-12 08:55:25 +08:00 · 2025-11-10 18:30:43 +08:00 · 2025-11-10 18:21:50 +08:00
37 changed files with 2824 additions and 96 deletions
--- a/servers/boe-server-all/src/main/java/com/xboe/api/ThirdApi.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/api/ThirdApi.java
@@ -8,9 +8,11 @@ import cn.hutool.json.JSONUtil;
 import com.alibaba.fastjson.JSON;
 import com.boe.feign.api.courseweb.entity.ExamTestDto;
 import com.boe.feign.api.courseweb.entity.ProjectStudyDto;
+import com.boe.feign.api.courseweb.remote.ExternalRemoteClient;
 import com.boe.feign.api.courseweb.remote.OffCourseRemoteClient;
 import com.boe.feign.api.courseweb.remote.ProjectAdminRemoteClient;
 import com.boe.feign.api.courseweb.remote.ProjectRemoteClient;
+import com.boe.feign.api.courseweb.reps.ExamStudyRecordParam;
 import com.boe.feign.api.infrastructure.entity.CommonSearchVo;
 import com.boe.feign.api.infrastructure.entity.Dict;
 import com.boe.feign.api.infrastructure.remote.DictRemoteClient;
@@ -73,6 +75,8 @@ public class ThirdApi {

    @Resource
    private ProjectRemoteClient projectRemoteClient;
+    @Resource
+    ExternalRemoteClient externalRemoteClient;

    @Resource
    private DictRemoteClient dictRemoteClient;
@@ -94,7 +98,8 @@ public class ThirdApi {
    private String syncOnLineScore;
    @Value("${coursesuilt.updateOnLineStatua}")
    private String updateOnLineStatua;
-
+    @Value("${coursesuilt.delOnLineById}")
+    private String delOnLineById;

    //获取例外人员的id
    public List<String> getUserId() {
@@ -262,11 +267,19 @@ public class ThirdApi {
    }

    public List<StudyCourse> getStudyCourseList(String studyId, String courseId, String token) {
+        log.info(" 1  studyId = "+ studyId + " ,courseId = " + courseId );
+        if ( studyId == null || courseId == null ){
+            log.error(" 在线课学习记录 参数不能为空 ");
+            return new ArrayList<>();
+        }
        StudyCourseVo studyCourseVo = new StudyCourseVo();
        studyCourseVo.setStudyId(studyId);
        studyCourseVo.setCourseId(courseId);
        ProjectStudyDto projectStudyDto = new ProjectStudyDto();
-        BeanUtil.copyProperties(studyCourseVo, studyCourseVo);
+//        BeanUtil.copyProperties(studyCourseVo, studyCourseVo);
+        projectStudyDto.setStudyId(Long.parseLong(studyId));
+        projectStudyDto.setCourseId(Long.parseLong(courseId));
+        log.info(" 12 在线课学习记录 studyId = "+ projectStudyDto.getStudyId() + " ,courseId = " + projectStudyDto.getCourseId() );
        projectRemoteClient.updateStudyStatus(projectStudyDto);
        return new ArrayList<>();
    }
@@ -382,4 +395,16 @@ public class ThirdApi {
                        .body()).orElseThrow(() -> new RuntimeException("token校验失败"));
        log.info("updateOrSaveCourse = " + resp);
    }
+
+    public void syncExamStudyRecord(ExamStudyRecordParam param) {
+        externalRemoteClient.syncExamStudyRecord(param);
+    }
+
+    public void delOnLineById(CourseParam param, String token) {
+        log.info("---------------同步在线课删除 ------- param " + param);
+        String resp = Optional.ofNullable(
+                HttpRequest.post(delOnLineById).body(JSONUtil.toJsonStr(param)).header("token", token).execute()
+                        .body()).orElseThrow(() -> new RuntimeException("token校验失败"));
+        log.info("-------delOnLineById = " + resp);
+    }
 }
--- a/servers/boe-server-all/src/main/java/com/xboe/data/service/impl/DataUserSyncServiceImpl.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/data/service/impl/DataUserSyncServiceImpl.java
@@ -2,11 +2,16 @@ package com.xboe.data.service.impl;

 import java.time.LocalDateTime;

+import javax.annotation.Resource;
 import javax.transaction.Transactional;

 import com.boe.feign.api.serverall.entity.UserData;
+import com.xboe.constants.CacheName;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.cache.Cache;
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.annotation.Cacheable;
 import org.springframework.retry.annotation.Recover;
 import org.springframework.retry.annotation.Retryable;
 import org.springframework.stereotype.Service;
@@ -39,6 +44,9 @@ public class DataUserSyncServiceImpl implements IDataUserSyncService {
    @Autowired
    TeacherDao teacherDao;

+    @Resource
+    private CacheManager cacheManager;
+

    @Override
    @Transactional
@@ -59,6 +67,8 @@ public class DataUserSyncServiceImpl implements IDataUserSyncService {
                a.setDeleted(user.getDeleted());
            }
            a.setLoginName(user.getCode());
+            a.setMobile(user.getMobile());
+            a.setEmail(user.getEmail());
            log.info("更新账号code");
            accountDao.update(a);
        } else {
@@ -71,14 +81,18 @@ public class DataUserSyncServiceImpl implements IDataUserSyncService {
            a.setRegTime(LocalDateTime.now());
            a.setSysId(user.getKid());
            a.setStatus(1);
+            a.setMobile(user.getMobile());
+            a.setEmail(user.getEmail());
            accountDao.save(a);
            log.info("账号不存在，新添加账号【" + user.getId() + "】");
        }
+
        if (u != null) {
            //更新部分用户字段
            u.setDepartId(user.getDepartId());
            u.setDepartName(user.getDepartName());
            u.setName(user.getName());
+            u.setMobileNo(user.getMobile());
            //2022-12-8 去掉用户类型的更新，因为返回的数据都是学员，
            //u.setUserType(user.getUserType());
            if (user.getLearningDuration() > 0) { //不大于0才会更新
@@ -106,9 +120,17 @@ public class DataUserSyncServiceImpl implements IDataUserSyncService {
            } else {
                u.setShowHome(true);//band16以下，及其它无bandLevel的信息
            }
+            u.setMobileNo(user.getMobile());
            userDao.save(u);
            log.info("添加新用户");
        }
+
+        Cache cache = cacheManager.getCache(CacheName.NAME_USER);
+        if(cache != null) {
+            cache.evict(CacheName.KEY_ACCOUNT + user.getId());
+            cache.evict(CacheName.KEY_USER + user.getId());
+        }
+
        //对机构的判断，不为空时才会处理，为空时不处理
        if (StringUtils.isNotBlank(user.getDepartId())) {
            org = orgDao.get(user.getDepartId());
--- a/servers/boe-server-all/src/main/java/com/xboe/module/course/api/CourseAuditApi.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/module/course/api/CourseAuditApi.java
@@ -9,6 +9,7 @@ import javax.servlet.http.HttpServletRequest;

 import com.xboe.api.ThirdApi;
 import com.xboe.module.course.dto.CourseParam;
+import com.xboe.module.course.service.*;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
@@ -28,10 +29,6 @@ import com.xboe.module.course.entity.Course;
 import com.xboe.module.course.entity.CourseAudit;
 import com.xboe.module.course.entity.CourseContent;
 import com.xboe.module.course.entity.CourseHRBPAudit;
-import com.xboe.module.course.service.ICourseAuditService;
-import com.xboe.module.course.service.ICourseContentService;
-import com.xboe.module.course.service.ICourseHRBPAuditService;
-import com.xboe.module.course.service.ICourseService;
 import com.xboe.standard.enums.BoedxContentType;
 import com.xboe.standard.enums.BoedxCourseType;

@@ -60,7 +57,8 @@ public class CourseAuditApi  extends ApiBaseController{
 	private ICourseContentService ccontentService;
 	@Resource
 	private ThirdApi thirdApi;
-
+	@Resource
+	private ICourseTagService tagService;

 	/**
 	 * 教师需要审核的课程
@@ -424,6 +422,21 @@ public class CourseAuditApi  extends ApiBaseController{
 		dto.getCourse().setEnabled(true);//设置启用状态问题
 		dto.getCourse().setPublished(false);//重新提交审核设置为未发布状态
 		try {
+			log.info("------课程提审-- 标签相关开始 ------- 课程ID = {} " , dto.getCourse().getId());
+			Course oldCourse = StringUtils.isBlank(dto.getCourse().getId()) ? null : courseService.get(dto.getCourse().getId());
+			if(oldCourse!=null && StringUtils.isNotEmpty(oldCourse.getTags())){
+				String[] tagArray = oldCourse.getTags().split(",");
+				// 检查每个元素是否为纯数字
+				for (String tag : tagArray) {
+					if (!tag.matches("\\d+")) { // 使用正则表达式检查是否为纯数字
+						log.info("-------- 不是纯数字 ------- tag = {} " , tag);
+						oldCourse.setTags(null); // 兼容
+						break;
+					}
+				}
+			}
+			tagService.updateTags(oldCourse,dto.getCourse(),cuser);
+			log.info("-----课程提审--- 标签相关结束 -------");

 			courseService.submitAndPublish(dto,cuser.getAccountId(),cuser.getName());
 			log.info("---------------在线课开始同步到讲师管理 ------- token = " + token);
--- a/servers/boe-server-all/src/main/java/com/xboe/module/course/api/CourseFullTextApi.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/module/course/api/CourseFullTextApi.java
@@ -11,7 +11,12 @@ import com.boe.feign.api.serverall.entity.UserData;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.xboe.api.ThirdApi;
+import com.xboe.core.orm.FieldFilters;
+import com.xboe.core.orm.IFieldFilter;
+import com.xboe.core.orm.QueryBuilder;
 import com.xboe.data.outside.IOutSideDataService;
+import com.xboe.module.course.entity.CourseTag;
+import com.xboe.module.course.service.*;
 import com.xboe.module.course.vo.TeacherVo;
 import com.xboe.school.study.entity.StudyCourse;
 import com.xboe.school.study.service.IStudyCourseService;
@@ -34,11 +39,6 @@ import com.xboe.module.course.dto.CourseTeacherDto;
 import com.xboe.module.course.entity.Course;
 import com.xboe.module.course.entity.CourseCrowd;
 import com.xboe.module.course.entity.CourseTeacher;
-import com.xboe.module.course.service.CourseToCourseFullText;
-import com.xboe.module.course.service.ICourseContentService;
-import com.xboe.module.course.service.ICourseFullTextSearch;
-import com.xboe.module.course.service.ICourseService;
-import com.xboe.module.course.service.ICourseTeacherService;

 import lombok.extern.slf4j.Slf4j;

@@ -63,7 +63,8 @@ public class CourseFullTextApi  extends ApiBaseController{
 	ICourseFullTextSearch fullTextSearch;
 	@Resource
 	IOrganizationService organizationService;
-
+	@Autowired
+	ICourseTagService courseTagService;
 	@Resource
 	IStudyCourseService IStudyCourseService;

@@ -76,6 +77,8 @@ public class CourseFullTextApi  extends ApiBaseController{
 	@Autowired
 	StringRedisTemplate redisTemplate;

+
+
 	/**
 	 * 课程的初始化
 	 * @return
@@ -310,7 +313,34 @@ public class CourseFullTextApi  extends ApiBaseController{
 		}

 		paras.setDevice(dto.getDevice());
-
+		String tagIds = dto.getTags();
+		log.info("课程查询 tagIds = " + tagIds);
+		if (tagIds != null && tagIds != ""){
+			paras.setTags(tagIds);
+		}else {
+			String tagName = dto.getKeyword();
+			log.info("课程查询 关键字 = " + tagName);
+			if (StringUtils.isNotEmpty(tagName)){
+				//精准查询
+//				CourseTag courseTag = courseTagService.getTagByName(tagName);
+//				log.info("课程查询 关键字对应标签 = " + courseTag);
+//				if (courseTag != null){
+//					paras.setTags(courseTag.getId());
+//				}
+				// 获取所有标签并进行模糊匹配
+				List<CourseTag> allTags = courseTagService.getAllTags();
+				List<String> matchedTagIds = new ArrayList<>();
+				for (CourseTag tag : allTags) {
+					// 使用模糊匹配（不区分大小写）
+					if (tag.getTagName() != null && tag.getTagName().toLowerCase().contains(tagName.toLowerCase())) {
+						matchedTagIds.add(tag.getId());
+					}
+				}
+				if (!matchedTagIds.isEmpty()) {
+					paras.setTags(String.join(",", matchedTagIds));
+				}
+			}
+		}
 		try {
 			//后续会根据当前用户的资源归属查询
 			PageList<CourseFullText> coursePageList = fullTextSearch.search(ICourseFullTextSearch.DEFAULT_INDEX_NAME,pager.getStartRow(), pager.getPageSize(),paras);
@@ -402,6 +432,12 @@ public class CourseFullTextApi  extends ApiBaseController{
 						c.setKeywordsList(keywordsList);
 					}
 				}
+				if (StringUtils.isNotBlank(c.getTags()) && c.getTags().matches("[0-9,]+")) {
+					List<CourseTag> tagList = courseTagService.getTagsByIds(c.getTags());
+					List<String> tags = tagList.stream().map(CourseTag::getTagName).collect(Collectors.toList());
+					c.setTagsList(tags);
+				}
+
 			}


--- a/servers/boe-server-all/src/main/java/com/xboe/module/course/api/CourseManageApi.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/module/course/api/CourseManageApi.java
@@ -9,6 +9,8 @@ import javax.servlet.http.HttpServletResponse;

 import com.xboe.api.ThirdApi;
 import com.xboe.module.course.dto.*;
+import com.xboe.module.course.entity.*;
+import com.xboe.module.course.service.*;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.GetMapping;
@@ -28,19 +30,6 @@ import com.xboe.data.dto.UserOrgIds;
 import com.xboe.data.outside.IOutSideDataService;
 import com.xboe.data.service.IDataUserSyncService;
 import com.xboe.module.assistance.service.IEmailService;
-import com.xboe.module.course.entity.Course;
-import com.xboe.module.course.entity.CourseContent;
-import com.xboe.module.course.entity.CourseCrowd;
-import com.xboe.module.course.entity.CourseHRBPAudit;
-import com.xboe.module.course.entity.CourseSection;
-import com.xboe.module.course.entity.CourseTeacher;
-import com.xboe.module.course.entity.CourseUpdateLog;
-import com.xboe.module.course.service.ICourseContentService;
-import com.xboe.module.course.service.ICourseCrowdService;
-import com.xboe.module.course.service.ICourseHRBPAuditService;
-import com.xboe.module.course.service.ICourseSectionService;
-import com.xboe.module.course.service.ICourseService;
-import com.xboe.module.course.service.ICourseTeacherService;
 import com.xboe.module.excel.ExportsExcelSenderUtil;
 import com.xboe.standard.enums.BoedxContentType;
 import com.xboe.standard.enums.BoedxCourseType;
@@ -91,10 +80,10 @@ public class CourseManageApi extends ApiBaseController{
 	
 	@Resource
 	private ICourseHRBPAuditService hrbpAuditService;
-	
+	@Resource
+	private ICourseTagService tagService;
 	@Resource
 	IOutSideDataService outSideDataService;
-	
 	@Autowired
    IDataUserSyncService userSyncService;
 	@Resource
@@ -169,14 +158,18 @@ public class CourseManageApi extends ApiBaseController{
 		List<CourseSection> sectionlist=sectionService.getByCourseId(id);
 		List<CourseTeacher> teachers=courseService.findTeachersByCourseId(id);
 		List<CourseCrowd> crowds=courseService.findCrowdByCourseId(id);
-		
-		//
+		if (StringUtils.isNotBlank(course.getTags()) && course.getTags().matches("[0-9,]+")){
+			List<CourseTag> tagList = tagService.getTagsByIds(course.getTags());
+			rs.put("tagList", tagList);
+		}
+
+
 		rs.put("course",course);
 		rs.put("contents",cclist);
 		rs.put("sections",sectionlist);
 		rs.put("teachers",teachers);
 		rs.put("crowds",crowds);
-		
+
 		
 		return success(rs);
 		
@@ -290,6 +283,25 @@ public class CourseManageApi extends ApiBaseController{
 		
 		//填充必要的信息
 		try {
+			log.info("-------- 标签相关开始 ------- 课程ID = {} " , dto.getCourse().getId());
+			CurrentUser userInfo = getCurrent();
+			Course oldCourse = StringUtils.isBlank(dto.getCourse().getId()) ? null : courseService.get(dto.getCourse().getId());
+			log.info("-------- 标签相关 ------- oldtags = {} " , oldCourse.getTags());
+			if(oldCourse!=null && StringUtils.isNotEmpty(oldCourse.getTags())){
+				String[] tagArray = oldCourse.getTags().split(",");
+				// 检查每个元素是否为纯数字
+				for (String tag : tagArray) {
+					if (!tag.matches("\\d+")) { // 使用正则表达式检查是否为纯数字
+						log.info("-------- 不是纯数字 ------- tag = {} " , tag);
+						oldCourse.setTags(null); // 兼容
+						break;
+					}
+				}
+			}
+			log.info("-------- 标签相关 updateTags ------- oldtags = {} " , oldCourse.getTags());
+			tagService.updateTags(oldCourse,dto.getCourse(),userInfo);
+			log.info("-------- 标签相关结束 -------");
+
 			if(StringUtils.isBlank(dto.getCourse().getId())) {
 				//只有在第一次添加保存时才会这样
 				fillCourseData(dto.getCourse());
@@ -345,6 +357,10 @@ public class CourseManageApi extends ApiBaseController{
 				//修改后重置，重新提交审核，重新发布
 				courseService.update(course,true);
 			}
+			//查询是否需要标签提示
+			String aid=getCurrent().getAccountId();
+			Boolean isTip = courseService.getCourseTip(aid);
+			course.setIsTip(isTip);
 			return success(course);
 		} catch (Exception e) {
 			log.error("整体保存课程信息错误",e);
@@ -886,7 +902,7 @@ public class CourseManageApi extends ApiBaseController{
 	 * @return
 	 */
 	@PostMapping("/delete")
-	public JsonResponse<Boolean> delete(String id,Boolean erasable,String title,String remark){
+	public JsonResponse<Boolean> delete(String id,Boolean erasable,String title,String remark, HttpServletRequest request){
 		if(StringUtils.isBlank(id)){
 			return badRequest("参数错误");
 		}
@@ -901,6 +917,11 @@ public class CourseManageApi extends ApiBaseController{
 		try {
 			CurrentUser cu=getCurrent();
 			courseService.delete(id, erasable,cu.getAccountId(), cu.getName(), remark);
+
+			String token = request.getHeader("Xboe-Access-Token");
+			CourseParam param = new CourseParam();
+			param.setId(id);
+			thirdApi.delOnLineById(param,token);
 			return success(true);
 		} catch (Exception e) {
 			log.error("管理员删除课程错误",e);
@@ -1169,5 +1190,10 @@ public class CourseManageApi extends ApiBaseController{
 		return success(courses);
 	}

-
+	@PostMapping("/saveTip")
+	public JsonResponse<Boolean> saveTip(){
+		String aid=getCurrent().getAccountId();
+		courseService.saveTip(aid);
+		return success(true);
+	}
 }
--- a/servers/boe-server-all/src/main/java/com/xboe/module/course/api/CourseTagApi.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/module/course/api/CourseTagApi.java
@@ -0,0 +1,192 @@
+package com.xboe.module.course.api;
+
+import com.xboe.common.OrderCondition;
+import com.xboe.common.PageList;
+import com.xboe.common.Pagination;
+import com.xboe.core.CurrentUser;
+import com.xboe.core.JsonResponse;
+import com.xboe.core.api.ApiBaseController;
+import com.xboe.core.orm.FieldFilters;
+import com.xboe.core.orm.IFieldFilter;
+import com.xboe.module.article.entity.Article;
+import com.xboe.module.article.service.IArticleService;
+import com.xboe.module.course.dto.CourseTagQueryDto;
+import com.xboe.module.course.dto.CourseTagRelationDto;
+import com.xboe.module.course.entity.CourseTag;
+import com.xboe.module.course.entity.CourseTagRelation;
+import com.xboe.module.course.service.ICourseTagService;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import javax.annotation.Resource;
+import javax.servlet.http.HttpServletRequest;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * @ClassName:CourseTagApi
+ * @author:zhengge@oracle.com
+ * @since:2025/7/2614:27
+ */
+@Slf4j
+@RestController
+@RequestMapping(value="/xboe/m/coursetag")
+public class CourseTagApi extends ApiBaseController {
+
+    @Resource
+    ICourseTagService courseTagService;
+
+    /**
+     * 标签列表：分页查询
+     * @param pager
+     * @param courseTagQueryDto
+     * @return
+     */
+   /* @RequestMapping(value="/page",method= {RequestMethod.GET,RequestMethod.POST})
+    public JsonResponse<PageList<CourseTag>> find(Pagination pager, CourseTagQueryDto courseTagQueryDto){
+        log.info("标签列表：分页查询 pager = " + pager);
+        log.info("标签列表：分页查询 courseTagQueryDto = " + courseTagQueryDto);
+        List<IFieldFilter> filters=new ArrayList<IFieldFilter>();
+        OrderCondition order = null;
+        if (courseTagQueryDto != null){
+            String tagId = courseTagQueryDto.getId();
+            String tagName = courseTagQueryDto.getTagName();
+            Boolean isHot = courseTagQueryDto.getIsHot();
+            String orderField = courseTagQueryDto.getOrderField();
+            Boolean isAsc = courseTagQueryDto.getOrderAsc();
+            if (StringUtils.isNotBlank(tagId)){
+                filters.add(FieldFilters.eq("id",tagId));
+            }
+            //课程标签名称:模糊查询
+            if (StringUtils.isNotBlank(tagName)){
+                filters.add(FieldFilters.like("tagName",tagName));
+            }
+            // 构建排序条件：支持先按lastSetHotTime降序，再按动态字段升/降序排列‌
+            if (isHot !=null ){
+                filters.add(FieldFilters.eq("isHot",isHot));
+                //order = OrderCondition.desc("lastSetHotTime");//固定降序
+            }
+            // 动态排序处理
+            if (StringUtils.isNotBlank(orderField)) {
+                if (order == null) {
+                    order = isAsc ?  OrderCondition.asc(orderField) : OrderCondition.desc(orderField);
+                } else {
+                    order = isAsc ? order.asc(orderField) : order.desc(orderField); // 链式追加排序条件
+                }
+            }
+        }
+        log.info("标签列表：分页查询 调用接口 filters = " + filters);
+        log.info("标签列表：分页查询 调用接口 order = " + order);
+        PageList<CourseTag> list=courseTagService.query(pager.getPageIndex(),pager.getPageSize(),filters,order);
+        return success(list);
+    }
+*/
+    /**
+     * 修改指定id的课程标签的公共属性
+     * @param id
+     * @param isPublic
+     * @return
+     */
+/*
+    @RequestMapping(value="/changePublicStatus",method= RequestMethod.POST)
+    public JsonResponse<Void> changePublicStatus(Long id,Boolean isPublic){
+        courseTagService.changePublicStatus(id,isPublic);
+        return success(null);
+    }
+*/
+
+    /**
+     * 修改指定id的课程标签的热点属性
+     * @param id
+     * @param isHot
+     * @return
+     */
+/*    @RequestMapping(value="/changeHotStatus",method= RequestMethod.POST)
+    public JsonResponse<Void> changeHotStatus(Long id,Boolean isHot){
+        courseTagService.changeHotStatus(id,isHot);
+        return success(null);
+    }*/
+
+    /**
+     * 分页查询：指定id的标签关联的所有课程
+     * @param courseTagQueryDto
+     * @return
+     */
+/*
+    @RequestMapping(value="/showCourseByTag",method= RequestMethod.POST)
+    public JsonResponse<PageList<CourseTagRelationDto>> showCourseByTag(Pagination pager, CourseTagQueryDto courseTagQueryDto){
+        PageList<CourseTagRelationDto> list=null;
+        if (courseTagQueryDto != null) {
+            Long tagId = Long.valueOf(courseTagQueryDto.getId());
+            Boolean isAsc = courseTagQueryDto.getOrderAsc()!=null?courseTagQueryDto.getOrderAsc():false;
+            list=courseTagService.getCourseByTag(pager.getPageIndex(),pager.getPageSize(),tagId,isAsc);
+        }
+        return success(list);
+    }
+*/
+
+    /**
+     * 解除指定id的课程和某个标签之间的关联关系
+     * @return
+     */
+/*
+    @RequestMapping(value="/unbind",method= RequestMethod.POST)
+    public JsonResponse<Void> unbindCourseTagRelation(CourseTagRelationDto courseTagRelationDto){
+        if (courseTagRelationDto!=null){
+            courseTagService.unbind(courseTagRelationDto.getId());
+            return success(null);
+        }
+        return error("解绑失败！");
+    }
+*/
+
+    /**
+     * 模糊检索标签
+     * @return 符合检索条件的所有公共标签
+     */
+    @RequestMapping(value="/searchTags",method= RequestMethod.POST)
+    public JsonResponse<List<CourseTag>> searchTags(String tagName,String typeId ,HttpServletRequest request){
+
+        CurrentUser cuser = getCurrent();
+        String aid = cuser.getAccountId();
+        List<CourseTag> courseTagList = courseTagService.searchTags(tagName,aid,typeId);
+        return success(courseTagList);
+    }
+
+    /**
+     * 创建新标签,并与当前课程绑定
+     * @param courseTagRelationDto
+     * @return
+     */
+    @RequestMapping(value="/createTag",method= RequestMethod.POST)
+    public JsonResponse<CourseTag> createTag(CourseTagRelationDto courseTagRelationDto){
+        if (StringUtils.isNotBlank(courseTagRelationDto.getTagName()) && !Pattern.matches("^[\\u4e00-\\u9fa5a-zA-Z0-9_-]+$", courseTagRelationDto.getTagName())) {
+            return error("标签名称只能包含中文、英文、数字、下划线和中横线");
+        }
+        if (courseTagRelationDto!=null){
+            CourseTag courseTag = courseTagService.createTag(courseTagRelationDto);
+            if (courseTag == null ){
+                return error("创建标签失败！");
+            }
+            return success(courseTag);
+        }
+        return error("创建标签失败！");
+    }
+
+    /**
+     * 创建新标签,并与当前课程绑定
+     * @param courseTagRelationDto
+     * @return
+     */
+    @RequestMapping(value="/getHotTagList",method= RequestMethod.POST)
+    public JsonResponse<List<CourseTag>> getHotTagList(CourseTagRelationDto courseTagRelationDto){
+            List<CourseTag> hotTagList = courseTagService.getHotTagList(courseTagRelationDto);
+            return success(hotTagList);
+    }
+
+}
--- a/servers/boe-server-all/src/main/java/com/xboe/module/course/dao/CourseTagDao.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/module/course/dao/CourseTagDao.java
@@ -0,0 +1,202 @@
+package com.xboe.module.course.dao;
+
+import com.xboe.common.OrderCondition;
+import com.xboe.common.PageList;
+import com.xboe.core.SysConstant;
+import com.xboe.core.orm.BaseDao;
+import com.xboe.core.orm.FieldFilters;
+import com.xboe.core.orm.IFieldFilter;
+import com.xboe.core.orm.IQuery;
+import com.xboe.module.course.entity.Course;
+import com.xboe.module.course.entity.CourseFile;
+import com.xboe.module.course.entity.CourseTag;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.jdbc.core.BeanPropertyRowMapper;
+import org.springframework.stereotype.Repository;
+
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+import javax.persistence.Query;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @ClassName:CourseTagDao
+ * @author:zhengge@oracle.com
+ * @since:2025/7/2516:50
+ */
+
+@Slf4j
+@Repository
+public class CourseTagDao extends BaseDao<CourseTag> {
+    @PersistenceContext
+    private EntityManager entityManager;
+
+    /**
+     * 获取热门标签列表(前10条)
+     * @return 热门标签列表
+     */
+    public List<CourseTag> getHotTagList() {
+            // 原生SQL：注意表名和列名需与数据库实际一致
+            String sql = "select t.*,COUNT(r.tag_id) AS relation_count\n" +
+                    "from boe_course_tag t\n" +
+                    "left join boe_course_tag_relation r\n" +
+                    "on t.id = r.tag_id AND r.deleted =0 \n" +
+                    "where t.deleted =0 and t.is_hot = true and t.status =0  \n" +
+                    "GROUP BY t.id\n" +
+                    "order by t.last_set_hot_time desc";  // 数据库字段为last_set_hot_time
+
+            // 创建原生查询并指定结果映射到CourseTag实体
+            javax.persistence.Query query = entityManager.createNativeQuery(sql, CourseTag.class);
+
+            // 分页：取前10条
+            query.setFirstResult(0);
+            query.setMaxResults(10);
+
+            // 执行查询并返回结果（已映射为CourseTag类型）
+            return query.getResultList();
+    }
+
+    /**
+     * 根据课程类型获取热门标签列表(前10条)
+     * @param sysType1 系统类型1
+     * @param sysType2 系统类型2
+     * @param sysType3 系统类型3
+     * @return 热门标签列表
+     */
+    public List<CourseTag> getHotTagListBySysTypes(String sysType1, String sysType2, String sysType3) {
+        // 原生SQL：注意表名和列名需与数据库实际一致（此处假设表名为course_tag、course_type_tag_relation）
+        String sql = "SELECT DISTINCT c.* FROM boe_course_tag c " +
+                "JOIN boe_course_type_tag_relation r ON c.id = r.tag_id " +
+                "WHERE r.deleted = 0 and c.status =0 " +
+                "AND c.is_hot = true ";  // 假设数据库字段为is_hot（与实体属性isHot对应）
+        if (StringUtils.isNotBlank(sysType1)){
+            sql += "AND r.sys_type1 = ?1 ORDER BY c.last_set_hot_time DESC";
+        }else if(StringUtils.isNotBlank(sysType2)){
+            sql += "AND r.sys_type2 = ?1 ORDER BY c.last_set_hot_time DESC";
+        }else {
+            sql += "AND r.sys_type3 = ?1 ORDER BY c.last_set_hot_time DESC";
+        }
+        // 创建原生查询并指定结果映射到CourseTag实体
+        javax.persistence.Query query = entityManager.createNativeQuery(sql, CourseTag.class);
+
+        // 绑定参数（注意参数索引从1开始）
+        if (StringUtils.isNotBlank(sysType1)){
+            query.setParameter(1, sysType1);
+        } else if (StringUtils.isNotBlank(sysType2)) {
+            query.setParameter(1, sysType2);
+        }else {
+            query.setParameter(1, sysType3);
+        }
+        // 分页：取前10条
+        query.setFirstResult(0);
+        query.setMaxResults(10);
+
+        // 执行查询并返回结果（已映射为CourseTag类型）
+        return query.getResultList();
+    }
+
+    public List<CourseTag> getTagsByIds(String id) {
+        String sql = "select * from " + SysConstant.TABLE_PRE + "course_tag where id in (" + id + "0)";
+        // 创建原生查询并指定结果映射到CourseTag实体
+        javax.persistence.Query query = entityManager.createNativeQuery(sql, CourseTag.class);
+        return query.getResultList();
+    }
+
+    public CourseTag getTagByName(String tagName) {
+        CourseTag courseTag = this.findOne(FieldFilters.eq("tag_name", tagName),FieldFilters.eq("deleted", false),FieldFilters.eq("status", 0));
+        return courseTag;
+    }
+
+    public PageList<CourseTag> getList() {
+        log.info("------- getList -----------  ");
+        String sql = "select * from boe_course_tag order by sys_create_time desc limit 10";
+        javax.persistence.Query query = entityManager.createNativeQuery(sql, CourseTag.class);
+        log.info("------- getList -----------getResultList =  " + query.getResultList() );
+        PageList<CourseTag> pageList = new PageList<>();
+        pageList.setCount(query.getResultList().size());
+        pageList.setPageSize(1);
+        pageList.setList(query.getResultList());
+
+        return pageList;
+    }
+
+    public List<CourseTag> searchTags(String tagName, String userId, String typeId) {
+        StringBuilder sql = new StringBuilder();
+        List<Object> parameters = new ArrayList<>();
+
+        // 只查询实际存在的字段
+        sql.append("SELECT id, tag_name, is_public, is_hot, use_count, last_set_public_time, last_set_hot_time, deleted, sys_create_time ");
+        sql.append("FROM ( ");
+        sql.append("    SELECT t.id, t.tag_name, t.is_public, t.is_hot, t.use_count, t.last_set_public_time, t.last_set_hot_time, t.deleted, t.sys_create_time,t.sys_update_time ");
+        sql.append("    FROM boe_course_tag_relation r  ");
+        sql.append("    INNER JOIN boe_course_tag t ON r.tag_id = t.id  ");
+        sql.append("    WHERE r.deleted = 0 AND t.deleted = 0 AND t.is_public = 0  AND t.status = 0 ");
+        if (StringUtils.isNotBlank(userId)) {
+            sql.append("        AND r.sys_create_aid = ? ");
+            parameters.add(Long.valueOf(userId));
+        }
+        if (StringUtils.isNotBlank(tagName)) {
+            sql.append("    AND t.tag_name LIKE ? ");
+            parameters.add("%" + tagName + "%");
+        }
+        sql.append("    GROUP BY t.id, t.tag_name, t.is_public, t.is_hot, t.use_count, t.last_set_public_time, t.last_set_hot_time, t.deleted, t.sys_create_time,t.sys_update_time ");
+        sql.append("    UNION ALL ");
+        sql.append("    SELECT id, tag_name, is_public, is_hot, use_count, last_set_public_time, last_set_hot_time, deleted, sys_create_time,sys_update_time ");
+        sql.append("    FROM boe_course_tag  ");
+        sql.append("    WHERE deleted = 0 AND is_public = 1 AND status = 0 ");
+        if (StringUtils.isNotBlank(tagName)) {
+            sql.append("    AND tag_name LIKE ? ");
+            parameters.add("%" + tagName + "%");
+        }
+        sql.append(") AS all_tags ");
+        sql.append("ORDER BY  ");
+
+        if (StringUtils.isNotBlank(typeId)) {
+            sql.append("    CASE WHEN id IN ( ");
+            sql.append("        SELECT tag_id  ");
+            sql.append("        FROM boe_course_type_tag_relation  ");
+            sql.append("        WHERE deleted = 0  ");
+            sql.append("            AND (sys_type1 = ? ");
+            sql.append("                 OR sys_type2 = ? ");
+            sql.append("                 OR sys_type3 = ?) ");
+            sql.append("        GROUP BY tag_id ");
+            sql.append("    ) THEN 0 ELSE 1 END ");
+            parameters.add(Long.valueOf(typeId));
+            parameters.add(Long.valueOf(typeId));
+            parameters.add(Long.valueOf(typeId));
+        }
+
+        sql.append("    sys_update_time DESC");
+        log.info("查询标签 searchTags sql = {} ", sql);
+        // 不使用实体类映射，手动处理结果集
+        Query query = entityManager.createNativeQuery(sql.toString());
+
+        for (int i = 0; i < parameters.size(); i++) {
+            query.setParameter(i + 1, parameters.get(i));
+        }
+
+        @SuppressWarnings("unchecked")
+        List<Object[]> results = query.getResultList();
+        List<CourseTag> courseTags = new ArrayList<>();
+
+        for (Object[] result : results) {
+            CourseTag tag = new CourseTag();
+            // 设置基本字段
+            if (result[0] != null) tag.setId(String.valueOf(result[0]));
+            if (result[1] != null) tag.setTagName(String.valueOf(result[1]));
+            if (result[2] != null) tag.setIsPublic(Boolean.valueOf(String.valueOf(result[2])));
+            if (result[3] != null) tag.setIsHot(Boolean.valueOf(String.valueOf(result[3])));
+            if (result[4] != null) tag.setUseCount(Integer.valueOf(String.valueOf(result[4])));
+            courseTags.add(tag);
+        }
+
+        return courseTags;
+    }
+
+
+
+
+
+}
--- a/servers/boe-server-all/src/main/java/com/xboe/module/course/dao/CourseTagRelationDao.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/module/course/dao/CourseTagRelationDao.java
@@ -0,0 +1,130 @@
+package com.xboe.module.course.dao;
+
+import com.xboe.common.PageList;
+import com.xboe.core.orm.BaseDao;
+import com.xboe.module.course.dto.CourseTagRelationDto;
+import com.xboe.module.course.entity.CourseTagRelation;
+import org.springframework.stereotype.Repository;
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+import javax.persistence.Query;
+import java.time.LocalDateTime;
+import java.util.Date;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * @ClassName:CourseTagRelationDao
+ * @author:zhengge@oracle.com
+ * @since:2025/7/2815:09
+ */
+@Repository
+public class CourseTagRelationDao extends BaseDao<CourseTagRelation> {
+
+    @PersistenceContext
+    private EntityManager entityManager;
+
+    private String sqlStr = "SELECT " +
+            "    r1.id as id, " +
+            "    c.id as courseId, " +
+            "    r1.tag_id as tagId, " +
+            "    c.`name` as courseName, " +
+            "    r1.sys_create_by as sysCreateBy, " +
+            "    r1.sys_create_time as sysCreateTime, " +
+            "    COALESCE(GROUP_CONCAT(DISTINCT t.tag_name ORDER BY t.tag_name), '') AS otherTags " +
+            "FROM " +
+            "    boe_course c " +
+            "JOIN " +
+            "    boe_course_tag_relation r1 ON c.id = r1.course_id " +
+            "LEFT JOIN " +
+            "    ( " +
+            "        boe_course_tag_relation r2 " +
+            "        JOIN boe_course_tag t ON r2.tag_id = t.id AND t.deleted = 0 " +
+            "    ) " +
+            "    ON c.id = r2.course_id AND r2.tag_id != r1.tag_id " +
+            "WHERE " +
+            "    r1.tag_id = :tagId AND r1.deleted = 0 " +
+            "    AND c.id IN ( " +
+            "        SELECT course_id " +
+            "        FROM boe_course_tag_relation " +
+            "        WHERE tag_id = :tagId " +
+            "    ) " +
+            "GROUP BY " +
+            "    c.id, c.`name` ";
+
+    public PageList<CourseTagRelationDto> findCoursesWithRelatedTagsDesc(Integer pageIndex, Integer pageSize, Long tagId){
+        String sql = sqlStr + " ORDER BY r1.sys_create_time DESC";
+        Query query = entityManager.createNativeQuery(sql);
+        query.setParameter("tagId", tagId);
+        query.setFirstResult((pageIndex - 1) * pageSize); // 设置起始位置
+        query.setMaxResults(pageSize); // 设置每页大小
+
+        Query countQuery = entityManager.createNativeQuery(sql);
+        countQuery.setParameter("tagId", tagId);
+        List<Object[]> totalresults = countQuery.getResultList();
+
+        List<Object[]> results = query.getResultList();
+        List<CourseTagRelationDto> list = results.stream()
+                .map(row -> {
+                    String id = String.valueOf(row[0]);
+                    String courseId = String.valueOf(row[1]);
+                    String tagId2 = String.valueOf(row[2]);
+                    return new CourseTagRelationDto(
+                            id,
+                            courseId,
+                            tagId2,
+                            (String) row[3],
+                            (String) row[4],
+                            (Date) row[5],
+                            (String) row[6]
+                    );
+                })
+                .collect(Collectors.toList());
+        return new PageList<CourseTagRelationDto>(list,totalresults!=null?totalresults.size():0);
+    }
+
+    public PageList<CourseTagRelationDto> findCoursesWithRelatedTagsAsc(Integer pageIndex, Integer pageSize, Long tagId) {
+        String sql = sqlStr + " ORDER BY r1.sys_create_time ASC";
+        Query query = entityManager.createNativeQuery(sql);
+        query.setParameter("tagId", tagId);
+        query.setFirstResult((pageIndex - 1) * pageSize); // 设置起始位置
+        query.setMaxResults(pageSize); // 设置每页大小
+
+        Query countQuery = entityManager.createNativeQuery(sql);
+        countQuery.setParameter("tagId", tagId);
+        List<Object[]> totalresults = countQuery.getResultList();
+
+        List<Object[]> results = query.getResultList();
+        List<CourseTagRelationDto> list = results.stream()
+                .map(row ->{
+                    String id = String.valueOf(row[0]);
+                    String courseId = String.valueOf(row[1]);
+                    String tagId2 = String.valueOf(row[2]);
+                    return new CourseTagRelationDto(
+                            id,
+                            courseId,
+                            tagId2,
+                            (String) row[3],
+                            (String) row[4],
+                            (Date) row[5],
+                            (String) row[6]
+                    );
+                        })
+                .collect(Collectors.toList());
+        return new PageList<CourseTagRelationDto>(list,totalresults!=null?totalresults.size():0);
+    }
+
+    public void reTagRelDelStatus(String id,String name) {
+        String sql = "UPDATE boe_course_tag_relation SET deleted = FALSE, sys_update_by = '" + name +
+                "', sys_update_time = NOW() WHERE id = " + id;
+        Query query = entityManager.createNativeQuery(sql);
+        query.executeUpdate();
+    }
+
+    public void reTypeTagRelDelStatus(String id,String name) {
+        String sql = "UPDATE boe_course_type_tag_relation SET deleted = FALSE, sys_update_by = '" + name +
+                "', sys_update_time = NOW() WHERE id = " + id;
+        Query query = entityManager.createNativeQuery(sql);
+        query.executeUpdate();
+    }
+}
--- a/servers/boe-server-all/src/main/java/com/xboe/module/course/dao/CourseTypeTagRelationDao.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/module/course/dao/CourseTypeTagRelationDao.java
@@ -0,0 +1,17 @@
+package com.xboe.module.course.dao;
+
+import com.xboe.core.orm.BaseDao;
+import com.xboe.module.course.entity.CourseTagRelation;
+import com.xboe.module.course.entity.CourseTypeTagRelation;
+import org.springframework.stereotype.Repository;
+
+/**
+ * @ClassName:CourseTypeTagRelationDao
+ * @author:zhengge@oracle.com
+ * @since:2025/8/113:42
+ */
+@Repository
+public class CourseTypeTagRelationDao extends BaseDao<CourseTypeTagRelation> {
+
+
+}
--- a/servers/boe-server-all/src/main/java/com/xboe/module/course/dao/TipDao.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/module/course/dao/TipDao.java
@@ -0,0 +1,12 @@
+package com.xboe.module.course.dao;
+
+import com.xboe.core.orm.BaseDao;
+import com.xboe.module.course.entity.Tip;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Repository;
+
+
+@Slf4j
+@Repository
+public class TipDao extends BaseDao<Tip> {
+}
--- a/servers/boe-server-all/src/main/java/com/xboe/module/course/dto/CourseQueryDto.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/module/course/dto/CourseQueryDto.java
@@ -1,5 +1,6 @@
 package com.xboe.module.course.dto;

+import com.xboe.module.course.entity.CourseTag;
 import lombok.Data;

 import java.util.List;
@@ -140,4 +141,6 @@ public class CourseQueryDto {
     */
    private String userId;

+    private String tags;
+
 }
--- a/servers/boe-server-all/src/main/java/com/xboe/module/course/dto/CourseTagQueryDto.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/module/course/dto/CourseTagQueryDto.java
@@ -0,0 +1,40 @@
+package com.xboe.module.course.dto;
+
+import lombok.Data;
+
+/**
+ * 课程标签查询的条件对象
+ * @ClassName:CourseTagQueryDto
+ * @author:zhengge@oracle.com
+ * @since:2025/7/2517:02
+ */
+@Data
+public class CourseTagQueryDto {
+
+    /**
+     * 标签id
+     */
+    private String id;
+
+    /**
+     * 标签名称
+     */
+    private String tagName;
+
+
+    /**
+     * 是否热点标签（ 0-否(默认) 1-是）
+     */
+    private Boolean isHot;
+
+    /**
+     * 排序字段
+     */
+    private String orderField;
+
+    /**
+     * 排序顺序
+     */
+    private Boolean orderAsc;
+
+}
--- a/servers/boe-server-all/src/main/java/com/xboe/module/course/dto/CourseTagRelationDto.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/module/course/dto/CourseTagRelationDto.java
@@ -0,0 +1,49 @@
+package com.xboe.module.course.dto;
+
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.Column;
+import java.time.LocalDateTime;
+import java.util.Date;
+
+/**
+ * @ClassName:CourseTagRelationDto
+ * @author:zhengge@oracle.com
+ * @since:2025/7/2815:00
+ */
+@Data
+@NoArgsConstructor
+public class CourseTagRelationDto{
+
+    private String id;
+    private String courseId;
+    private String tagId;
+    private String tagName;
+    private String courseName;
+    private String sysCreateBy;
+    private Date sysCreateTime;
+    private String otherTags; // 改为字符串类型，与 GROUP_CONCAT 结果匹配
+    private String sysType1;
+    private String sysType2;
+    private String sysType3;
+
+    // 添加匹配查询字段顺序的构造函数
+    public CourseTagRelationDto(
+            String id,
+            String courseId,
+            String tagId,
+            String courseName,
+            String sysCreateBy,
+            Date sysCreateTime,
+            String otherTags
+    ) {
+        this.id = id;
+        this.courseId = courseId;
+        this.tagId = tagId;
+        this.courseName = courseName;
+        this.sysCreateBy = sysCreateBy;
+        this.sysCreateTime = sysCreateTime;
+        this.otherTags = otherTags;
+    }
+}
--- a/servers/boe-server-all/src/main/java/com/xboe/module/course/entity/Course.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/module/course/entity/Course.java
@@ -396,7 +396,13 @@ public class Course extends BaseEntity {

    @Transient
    private String teacher;
-    
+
+    /**
+     * 新增在线课时是否需要标签提示
+     */
+    @Transient
+    private Boolean isTip;
+
    public Course(String id,String name,String summary,String coverImg,String sysCreateAid,String sysCreateBy,Integer type,LocalDateTime publishTime){
        super.setId(id);
        this.name=name;
--- a/servers/boe-server-all/src/main/java/com/xboe/module/course/entity/CourseTag.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/module/course/entity/CourseTag.java
@@ -0,0 +1,98 @@
+package com.xboe.module.course.entity;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.xboe.core.SysConstant;
+import com.xboe.core.orm.BaseEntity;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Table;
+import java.time.LocalDateTime;
+
+/**
+ * 在线课程的标签类
+ * @ClassName:CourseTag
+ * @author:zhengge@oracle.com
+ * @since:2025/7/25 16:37
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@Entity
+@Table(name = SysConstant.TABLE_PRE+"course_tag")
+public class CourseTag extends BaseEntity {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 标签名称
+     */
+    @Column(name = "tag_name",nullable=false, length = 50)
+    private String tagName;
+
+    /**
+     * 是否设置为公共标签
+     */
+    @Column(name = "is_public",length = 1)
+    private Boolean isPublic;
+
+    /**
+     * 是否设置为热点标签
+     */
+    @Column(name = "is_hot",length = 1)
+    private Boolean isHot;
+
+    /**
+     * 使用次数(关联课程数)
+     */
+    @Column(name = "use_count",length = 1)
+    private Integer useCount;
+
+    /**
+     * 1临时， 0正式
+     */
+    @Column(name = "status",length = 1)
+    private Integer status;
+
+    /**
+     * 最近设置为公共标签的时间
+     */
+    @Column(name = "last_set_public_time", nullable = true)
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime lastSetPublicTime;
+
+    /**
+     * 最近设置为热点标签的时间
+     */
+    @Column(name = "last_set_hot_time", nullable = true)
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime lastSetHotTime;
+
+    public CourseTag() {
+
+    }
+    public CourseTag(Long id, Boolean isPublic,Boolean isHot) {
+        this.setId(String.valueOf(id));
+        this.isPublic=isPublic;
+        this.isHot=isHot;
+    }
+
+
+    public CourseTag(String id,String tagName,String sysCreateBy,String sysCreateAid,LocalDateTime sysCreateTime,
+                     Boolean isPublic,Boolean isHot,Integer useCount,LocalDateTime lastSetPublicTime,LocalDateTime lastSetHotTime,Boolean deleted){
+        this.setId(id);
+        this.setTagName(tagName);
+        super.setSysCreateBy(sysCreateBy);
+        super.setSysCreateAid(sysCreateAid);
+        super.setSysCreateTime(sysCreateTime);
+        this.isPublic = isPublic;
+        this.isHot = isHot;
+        this.useCount = useCount;
+        this.lastSetPublicTime = lastSetPublicTime;
+        this.lastSetHotTime = lastSetHotTime;
+        super.setDeleted(deleted);
+    }
+
+
+}
--- a/servers/boe-server-all/src/main/java/com/xboe/module/course/entity/CourseTagRelation.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/module/course/entity/CourseTagRelation.java
@@ -0,0 +1,37 @@
+package com.xboe.module.course.entity;
+
+import com.xboe.core.SysConstant;
+import com.xboe.core.orm.BaseEntity;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Table;
+
+/**
+ * @ClassName:CourseTagRelation
+ * @author:zhengge@oracle.com
+ * @since:2025/7/2814:54
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@Entity
+@Table(name = SysConstant.TABLE_PRE+"course_tag_relation")
+public class CourseTagRelation extends BaseEntity {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 课程Id
+     */
+    @Column(name = "course_id",length = 20)
+    private Long courseId;
+
+    /**
+     * 标签id
+     */
+    @Column(name = "tag_id",length = 20)
+    private Long tagId;
+
+}
--- a/servers/boe-server-all/src/main/java/com/xboe/module/course/entity/CourseTeacher.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/module/course/entity/CourseTeacher.java
@@ -56,4 +56,5 @@ public class CourseTeacher extends IdBaseEntity {
    /**讲师类型 1 内部讲师  2外部讲师*/
    @Transient
    private Integer teacherType;
+
 }
--- a/servers/boe-server-all/src/main/java/com/xboe/module/course/entity/CourseTypeTagRelation.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/module/course/entity/CourseTypeTagRelation.java
@@ -0,0 +1,39 @@
+package com.xboe.module.course.entity;
+
+import com.xboe.core.SysConstant;
+import com.xboe.core.orm.BaseEntity;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Table;
+
+/**
+ * @ClassName:CourseTypeTagRelation
+ * @author:zhengge@oracle.com
+ * @since:2025/8/111:02
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@Entity
+@Table(name = SysConstant.TABLE_PRE+"course_type_tag_relation")
+public class CourseTypeTagRelation extends BaseEntity {
+
+    private static final long serialVersionUID = 1L;
+
+    @Column(name = "sys_type1",length = 20)
+    private String sysType1;
+
+    @Column(name = "sys_type2",length = 20)
+    private String sysType2;
+
+    @Column(name = "sys_type3",length = 20)
+    private String sysType3;
+
+    @Column(name = "tag_id",length = 20)
+    private String tagId;
+
+
+
+}
--- a/servers/boe-server-all/src/main/java/com/xboe/module/course/entity/Tip.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/module/course/entity/Tip.java
@@ -0,0 +1,36 @@
+package com.xboe.module.course.entity;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.xboe.core.SysConstant;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import javax.persistence.*;
+import java.time.LocalDateTime;
+
+/**
+ * @author by lyc
+ * @date 2025/11/10
+ */
+@Data
+@Entity
+@EqualsAndHashCode(callSuper = false)
+@Table(name = "tip")
+public class Tip {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "id", length = 20)
+    private Long id;
+
+    @Column(name = "aid", length = 30)
+    private String aid;
+
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @Column(name = "create_time", length = 30)
+    private LocalDateTime create_time;
+
+    // 0 标签提示
+    @Column(name = "type", length = 3)
+    private Integer type;
+
+}
--- a/servers/boe-server-all/src/main/java/com/xboe/module/course/service/CourseToCourseFullText.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/module/course/service/CourseToCourseFullText.java
@@ -52,6 +52,7 @@ public class CourseToCourseFullText {
 		cft.setTeacher("");
 		cft.setTeacherCode("");
 		cft.setType(c.getType());
+		cft.setTags(c.getTags());
 		if(c.getOpenCourse()==null) {
 			cft.setOpenCourse(0);
 		}else {
--- a/servers/boe-server-all/src/main/java/com/xboe/module/course/service/ICourseService.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/module/course/service/ICourseService.java
@@ -341,8 +341,12 @@ public interface ICourseService {
    List<Course> mobiledelList(Integer num,CourseQueryDto courseQueryDto);


+    List<Course> findByIds(List<String> courseIds);
+    void deletedStudyResourceBatchByCourseIdAndType(String courseId,Integer courseType);

+    void saveTip(String aid);

+    Boolean getCourseTip(String aid);

-
+//    void getPhpCourseData();
 }
--- a/servers/boe-server-all/src/main/java/com/xboe/module/course/service/ICourseTagService.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/module/course/service/ICourseTagService.java
@@ -0,0 +1,97 @@
+package com.xboe.module.course.service;
+
+import com.xboe.common.OrderCondition;
+import com.xboe.common.PageList;
+import com.xboe.core.CurrentUser;
+import com.xboe.core.JsonResponse;
+import com.xboe.core.orm.IFieldFilter;
+import com.xboe.module.article.entity.Article;
+import com.xboe.module.course.dto.CourseTagQueryDto;
+import com.xboe.module.course.dto.CourseTagRelationDto;
+import com.xboe.module.course.entity.Course;
+import com.xboe.module.course.entity.CourseTag;
+import com.xboe.module.course.entity.CourseTagRelation;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+
+import java.util.List;
+
+/**
+ * @InterfaceName:ICourseTagService
+ * @author:zhengge@oracle.com
+ * @since:2025/7/2516:53
+ */
+public interface ICourseTagService {
+
+    /**
+     * 分页查询标签列表,使用自定义filter
+     * @param pageIndex
+     * @param pageSize
+     * @return
+     */
+    PageList<CourseTag> query(Integer pageIndex, Integer pageSize, List<IFieldFilter> filters, OrderCondition order);
+
+    /**
+     * 分页查询指定id标签关联的课程列表,使用自定义filter
+     * @param pageIndex
+     * @param pageSize
+     * @return
+     */
+    PageList<CourseTagRelationDto> getCourseByTag(Integer pageIndex, Integer pageSize, Long tagId, Boolean isAsc);
+
+    /**
+     * 修改指定id的课程标签的公共属性
+     * @param id
+     * @param isPublic
+     * @return
+     */
+    void changePublicStatus(Long id,Boolean isPublic);
+
+    /**
+     * 修改指定id的课程标签的热点属性
+     * @param id
+     * @param isHot
+     * @return
+     */
+    void changeHotStatus(Long id,Boolean isHot);
+
+    /**
+     * 解除指定id的课程和某个标签之间的关联关系
+     * @return
+     */
+    void unbind(String id);
+
+    /**
+     * 根据标签名称进行检索(模糊查询)
+     * @param tagName
+     * @return 符合检索条件的所有公共标签
+     */
+    List<CourseTag> searchTags(String tagName,String userId,String typeId);
+
+    /**
+     * 创建新标签,并与当前课程绑定
+     * @param courseTagRelationDto
+     * @return
+     */
+    CourseTag createTag(CourseTagRelationDto courseTagRelationDto);
+
+    /**
+     * 根据课程类型获取热点标签
+     * @param courseTagRelationDto
+     * @return
+     */
+    List<CourseTag> getHotTagList(CourseTagRelationDto courseTagRelationDto);
+
+    /**
+     * 根据多个id获取标签
+     * @param id
+     * @return
+     */
+    List<CourseTag> getTagsByIds(String id);
+
+    CourseTag getTagByName(String tagName);
+
+    void updateTags(Course oldCourse,Course newCourse,CurrentUser userInfo);
+
+    List<CourseTag> getAllTags();
+}
--- a/servers/boe-server-all/src/main/java/com/xboe/module/course/service/impl/CourseServiceImpl.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/module/course/service/impl/CourseServiceImpl.java
@@ -1,5 +1,6 @@
 package com.xboe.module.course.service.impl;

+import java.io.IOException;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.format.DateTimeFormatter;
@@ -14,11 +15,28 @@ import java.util.stream.Stream;
 import javax.annotation.Resource;
 import javax.management.Query;

+import cn.hutool.core.collection.CollectionUtil;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.http.HttpRequest;
+import cn.hutool.http.HttpResponse;
+import cn.hutool.http.HttpUtil;
+import com.alibaba.fastjson.JSONObject;
+import com.alibaba.fastjson2.JSON;
 import com.xboe.api.ThirdApi;
 import com.xboe.core.orm.*;
+import com.xboe.module.course.dao.*;
+import com.xboe.module.course.dto.CourseTagRelationDto;
+import com.xboe.module.course.entity.*;
+import com.xboe.module.course.service.ICourseTagService;
 import com.xboe.school.study.dao.StudyCourseDao;
 import com.xboe.school.study.entity.StudyCourse;
 import org.apache.commons.lang3.StringUtils;
+import org.apache.http.client.HttpClient;
+import org.elasticsearch.client.RequestOptions;
+import org.elasticsearch.client.RestHighLevelClient;
+import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.elasticsearch.index.reindex.DeleteByQueryRequest;
 import org.hibernate.mapping.IdGenerator;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.redis.core.StringRedisTemplate;
@@ -34,24 +52,9 @@ import com.xboe.common.beans.KeyValue;
 import com.xboe.common.utils.IDGenerator;
 import com.xboe.common.utils.StringUtil;
 import com.xboe.core.event.IEventDataSender;
-import com.xboe.module.course.dao.CourseContentDao;
-import com.xboe.module.course.dao.CourseCrowdDao;
-import com.xboe.module.course.dao.CourseDao;
-import com.xboe.module.course.dao.CourseExamDao;
-import com.xboe.module.course.dao.CourseHRBPAuditDao;
-import com.xboe.module.course.dao.CourseHomeWorkDao;
-import com.xboe.module.course.dao.CourseSectionDao;
-import com.xboe.module.course.dao.CourseTeacherDao;
-import com.xboe.module.course.dao.CourseUpdateLogDao;
 import com.xboe.module.course.dto.CourseFullDto;
 import com.xboe.module.course.dto.CourseQueryDto;
 import com.xboe.module.course.dto.RankingDto;
-import com.xboe.module.course.entity.Course;
-import com.xboe.module.course.entity.CourseCrowd;
-import com.xboe.module.course.entity.CourseHRBPAudit;
-import com.xboe.module.course.entity.CourseSection;
-import com.xboe.module.course.entity.CourseTeacher;
-import com.xboe.module.course.entity.CourseUpdateLog;
 import com.xboe.module.course.service.ICourseFullTextSearch;
 import com.xboe.module.course.service.ICourseService;
 import com.xboe.module.interaction.service.ICourseGradeService;
@@ -91,7 +94,8 @@ public class CourseServiceImpl implements ICourseService {

    @Resource
    private CourseHRBPAuditDao courseHRBPAuditDao;
-
+    @Resource
+    private ICourseTagService courseTagService;

    @Resource
    private SysLogAuditDao logAuditDao;//审核日志记录
@@ -115,8 +119,11 @@ public class CourseServiceImpl implements ICourseService {
    @Autowired(required = false)
    private IEventDataSender eventSender;

+    @Resource
+    RestHighLevelClient restHighLevelClient;
+    @Resource
+    private TipDao tipDao;

-  
    /**
     * 生成过滤条件
     *
@@ -854,12 +861,14 @@ public class CourseServiceImpl implements ICourseService {
                    log.error("未配置事件消息发送的实现");
                }
            }
+
+            // 删除ES数据
+            deletedStudyResourceBatchByCourseIdAndType(id,c.getType());
        } else {
            //彻底删除，课件设置为无课程状态
            courseDao.setDeleted(id);
        }
        //记录删除日志信息
-
    }

    @Override
@@ -872,6 +881,11 @@ public class CourseServiceImpl implements ICourseService {
    public Course getAddView(String id) {
        Course c = courseDao.get(id);
        courseDao.updateFieldById(id, "views", c.getViews() + 1);
+        if (StringUtils.isNotBlank(c.getTags()) && c.getTags().matches("[0-9,]+")) {
+            List<CourseTag> tagList = courseTagService.getTagsByIds(c.getTags());
+            String tags = tagList.stream().map(CourseTag::getTagName).collect(Collectors.joining(","));
+            c.setTags(tags);
+        }
        return c;
    }

@@ -966,7 +980,6 @@ public class CourseServiceImpl implements ICourseService {

        Course c = full.getCourse();//当前的课程信息
        Course nowCourse = courseDao.get(c.getId());//修改之前的课程信息
-
        StringBuffer stringBuffer = new StringBuffer("[");
        //追加日志内容
        appendUpdateLog(stringBuffer, nowCourse, c);
@@ -984,6 +997,30 @@ public class CourseServiceImpl implements ICourseService {
        if (c.getVisible() == null) {
            c.setVisible(true);
        }
+        /*if (c.getTags() != null && !c.getTags().isEmpty()){
+            CourseTagRelationDto courseTagRelationDto = new CourseTagRelationDto();
+            courseTagRelationDto.setCourseId(c.getId());
+            courseTagRelationDto.setSysType1(c.getSysType1());
+            courseTagRelationDto.setSysType2(c.getSysType2());
+            courseTagRelationDto.setSysType3(c.getSysType3());
+            String tags = c.getTags();
+            List<CourseTag> tagList = courseTagService.getTagsByIds(tags);
+            if (ObjectUtil.isNotEmpty(tagList)){
+                for (CourseTag tag : tagList) {
+                    courseTagRelationDto.setTagName(tag.getTagName());
+                    courseTagService.createTag(courseTagRelationDto);
+                }
+            }
+        }*/
+
+        if (!nowCourse.getSysVersion().equals(c.getSysVersion())) {
+            log.warn("乐观锁冲突 - 课程ID: {}, 期望版本: {}, 实际版本: {}",
+                    c.getId(), c.getSysVersion(), nowCourse.getSysVersion());
+//            throw new RuntimeException("数据已被其他用户修改，请刷新页面后重试");
+            // 基本无概率同时修改同一课程 如有 以最后提交为准
+            c.setSysVersion(courseDao.getVersion(c.getId()));
+        }
+
        courseDao.update(c);
        c.setSysVersion(courseDao.getVersion(c.getId()));
        full.getCourse().setSysVersion(c.getSysVersion());
@@ -1071,12 +1108,13 @@ public class CourseServiceImpl implements ICourseService {

    @Override
    public void submitAndPublish(CourseFullDto full, String aid, String aname) throws Exception {
-
        Course c = full.getCourse();//当前的课程信息
+        log.info(" 课程 c = " + c.getId());
+        log.info(" 课程 c = " + c);
        c.setPublished(true);
        c.setPublishTime(LocalDateTime.now());
        courseDao.update(c);
-
+        log.info(" 课程 c = " + c.getId());
        //先清空教师信息， 教师信息如果不一样了，也要加入到日志中
        courseTeacherDao.deleteByField("courseId", c.getId());
        if (full.getTeachers() != null && !full.getTeachers().isEmpty()) {
@@ -1142,7 +1180,7 @@ public class CourseServiceImpl implements ICourseService {

    /***
     * 发布全文索引
-     * @param c
+     * @param
     */
 //	private void fullTextPublish(Course c) {
 //		if(fullTextSearch==null) {
@@ -1568,6 +1606,13 @@ public class CourseServiceImpl implements ICourseService {
        return list;
    }

+    @Override
+    public List<Course> findByIds(List<String> courseIds) {
+        QueryBuilder query = QueryBuilder.from(Course.class);
+        query.addFilter(FieldFilters.in("id", courseIds));
+        return courseDao.findList(query.builder());
+    }
+

    @Override
    public int countWaitAudit(String aid) {
@@ -1979,5 +2024,142 @@ public class CourseServiceImpl implements ICourseService {
        return courseDao.findListByHql("Select new Course(id,studys,score) from Course where id in(?1)", ids);
    }

+    /*
+    private class Result{
+        private Boolean success;
+        private Data data;
+        private class Data{
+            private List<Map<String,Object>> result;

+            public List<Map<String, Object>> getResult() {
+                return result;
+            }
+
+            public void setResult(List<Map<String, Object>> result) {
+                this.result = result;
+            }
+        }
+
+        public void setData(Data data) {
+            this.data = data;
+        }
+
+        public Boolean getSuccess() {
+            return success;
+        }
+
+        public void setSuccess(Boolean success) {
+            this.success = success;
+        }
+
+        public Data getData() {
+            return data;
+        }
+    }
+
+    @Override
+    public void getPhpCourseData() {
+        HttpRequest request = HttpUtil.createGet("https://u.boe.com/api/b1/new-employee/course-list");
+        HttpResponse response = request.execute();
+        String body = response.body();
+        Result result = JSON.parseObject(body,Result.class);
+        log.info("php课程数据获取成功");
+        List<Map<String,Object>> phpCourseDataList = result.getData().getResult();
+        for (Map<String, Object> phpCourseData : phpCourseDataList){
+            log.info("开始同步数据:"+phpCourseData.get("course_name"));
+        }
+        List<Map<String,Object>> phpStudyCourseList = null;
+        // 查询数据库中是否存在php课程数据
+        for (int i = 0; i < phpCourseDataList.size(); i++) {
+            // 查询php的课程数据在数据库中是否已经存在
+            String phpCourseName = (String) phpCourseDataList.get(i).get("course_name");
+            Boolean exist = isCourseName(phpCourseName,"");
+            if (!exist){
+                log.info(phpCourseName+"不存在,开始同步");
+                Course newCourse = new Course();
+                // 设置学习人数
+                int studys = Integer.parseInt(phpCourseDataList.get(i).get("learned_number").toString());
+                newCourse.setStudys(studys);
+                // 设置系统版本
+                int version = Integer.parseInt(phpCourseDataList.get(i).get("version").toString());
+                newCourse.setSysVersion(version);
+                // 设置电脑端还是手机端可见
+                int pcDevice = Integer.parseInt(phpCourseDataList.get(i).get("is_display_pc").toString());
+                int mobileDevice = Integer.parseInt(phpCourseDataList.get(i).get("is_display_mobile").toString());
+                if (pcDevice == 1 &&  mobileDevice == 1){
+                    newCourse.setDevice(3);
+                } else if (pcDevice == 0 && mobileDevice == 1) {
+                    newCourse.setDevice(2);
+                }else if(pcDevice == 1 && mobileDevice == 0){
+                    newCourse.setDevice(1);
+                }
+                // 判断是否按照顺序学习
+                int orderStudy = Integer.parseInt(phpCourseDataList.get(i).get("mod_type").toString());
+                newCourse.setOrderStudy(orderStudy == 1 ? true : false);
+                // 设置课程简介
+                String summary = (String) phpCourseDataList.get(i).get("course_desc_nohtml");
+                newCourse.setSummary(summary);
+                // 设置课程类型
+                int courseType = Integer.parseInt(phpCourseDataList.get(i).get("course_type").toString());
+                newCourse.setType(courseType == 0 ? 20 : 30);
+                // 设置学习时长
+                int courseTime = Integer.parseInt(phpCourseDataList.get(i).get("course_period").toString());
+                newCourse.setStudyTime(courseTime);
+                // 设置课程封面
+                newCourse.setCoverImg("https://u.boe.com/pc/images/bgimg/course.png");
+                newCourse.setName(phpCourseName);
+                newCourse.setStatus(5);
+                newCourse.setComments(0);
+                newCourse.setDeleted(false);
+                newCourse.setEnabled(true);
+                newCourse.setFavorites(0);
+                newCourse.setIsTop(false);
+                newCourse.setViews(0);
+                newCourse.setPraises(0);
+                newCourse.setTrampleCount(0);
+                newCourse.setShares(0);
+                newCourse.setScore(0f);
+
+                courseDao.save(newCourse);
+            }else {
+                log.info(phpCourseName+"存在");
+            }
+        }
+
+    }
+    */
+
+    @Override
+    public void deletedStudyResourceBatchByCourseIdAndType(String courseId, Integer courseType) {
+        DeleteByQueryRequest request = new DeleteByQueryRequest("new_study_resource");
+        BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder();
+        boolQueryBuilder.must(QueryBuilders.matchQuery("courseId", courseId));
+        boolQueryBuilder.must(QueryBuilders.matchQuery("courseType", courseType));
+        request.setQuery(boolQueryBuilder);
+        try {
+            restHighLevelClient.deleteByQuery(request, RequestOptions.DEFAULT);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public void saveTip(String aid) {
+        Tip item = new Tip();
+        item.setAid(aid);
+        item.setType(0);
+        item.setCreate_time(LocalDateTime.now());
+        tipDao.save(item);
+    }
+
+    @Override
+    public Boolean getCourseTip(String aid) {
+        log.info("getCourseTip aid = {} ",aid);
+        List<Tip> list = tipDao.findList(FieldFilters.eq("aid", aid));
+        log.info("getCourseTip list = {} ",list);
+        if (list != null && !list.isEmpty()){
+            return false;//已提示
+        }
+        return true; //用户需要提示
+    }
 }
--- a/servers/boe-server-all/src/main/java/com/xboe/module/course/service/impl/CourseTagServiceImpl.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/module/course/service/impl/CourseTagServiceImpl.java
@@ -0,0 +1,877 @@
+package com.xboe.module.course.service.impl;
+
+import com.xboe.common.OrderCondition;
+import com.xboe.common.PageList;
+import com.xboe.core.CurrentUser;
+import com.xboe.core.orm.BaseEntity;
+import com.xboe.core.orm.FieldFilters;
+import com.xboe.core.orm.IFieldFilter;
+import com.xboe.core.orm.QueryBuilder;
+import com.xboe.module.course.dao.CourseDao;
+import com.xboe.module.course.dao.CourseTagDao;
+import com.xboe.module.course.dao.CourseTagRelationDao;
+import com.xboe.module.course.dao.CourseTypeTagRelationDao;
+import com.xboe.module.course.dto.CourseTagRelationDto;
+import com.xboe.module.course.entity.Course;
+import com.xboe.module.course.entity.CourseTag;
+import com.xboe.module.course.entity.CourseTagRelation;
+import com.xboe.module.course.entity.CourseTypeTagRelation;
+import com.xboe.module.course.service.ICourseService;
+import com.xboe.module.course.service.ICourseTagService;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import javax.annotation.Resource;
+import java.time.LocalDateTime;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * @ClassName:CourseTagServiceImpl
+ * @author:zhengge@oracle.com
+ * @since:2025/7/2516:55
+ */
+@Slf4j
+@Service
+@Transactional
+public class CourseTagServiceImpl implements ICourseTagService {
+
+    @Resource
+    private CourseTagDao courseTagDao;
+    @Resource
+    PublishCourseUtil publishUtil;
+    @Resource
+    private CourseTagRelationDao courseTagRelationDao;
+
+    @Resource
+    private CourseTypeTagRelationDao courseTypeTagRelationDao;
+    @Resource
+    private CourseDao courseDao;
+
+    /**
+     * 课程标签分页查询
+     * @param pageIndex
+     * @param pageSize
+     * @param filters
+     * @param order
+     * @return
+     */
+    @Override
+    public PageList<CourseTag> query(Integer pageIndex, Integer pageSize, List<IFieldFilter> filters, OrderCondition order) {
+        try {
+          /*  QueryBuilder query=QueryBuilder.from(CourseTag.class);
+            query.setPageIndex(pageIndex);
+            query.setPageSize(pageSize);
+            filters.add(FieldFilters.eq("deleted",false));
+            query.addFilters(filters);
+            if(order!=null) {
+                query.addOrder(order);
+            }else {
+                query.addOrder(OrderCondition.desc("sysCreateTime"));
+            }
+            log.info("标签列表：分页查询 调用接口IMPL query = " + query.builder().toString());
+            return courseTagDao.findPage(query.builder());*/
+
+            if(pageSize==100){
+               log.info("--- 11 ----------------------");
+               return courseTagDao.getList();
+            }else{
+                log.info("--- 22 ----------------------");
+                QueryBuilder query = QueryBuilder.from(CourseTag.class);
+                query.setPageIndex(pageIndex);
+                query.setPageSize(pageSize);
+                filters.add(FieldFilters.eq("deleted", false));
+//            query.addFilters(filters);
+                query.addOrder(OrderCondition.desc("sysCreateTime"));
+                return courseTagDao.findPage(query.builder());
+            }
+
+        } catch (Exception e) {
+            log.error("课程标签分页查询异常 = " + e.getMessage());
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * 分页查询指定id标签关联的课程
+     * @param pageIndex
+     * @param pageSize
+     * @param tagId
+     * @param isAsc
+     * @return
+     */
+    @Override
+    public PageList<CourseTagRelationDto> getCourseByTag(Integer pageIndex, Integer pageSize, Long tagId, Boolean isAsc) {
+        PageList<CourseTagRelationDto> list = null;
+        if(isAsc) {
+            list =  courseTagRelationDao.findCoursesWithRelatedTagsAsc(pageIndex,pageSize,tagId);
+        }else {
+            list =  courseTagRelationDao.findCoursesWithRelatedTagsDesc(pageIndex,pageSize,tagId);
+        }
+        return list;
+    }
+
+    /**
+     * 修改指定id的课程标签的公共属性
+     * @param id
+     * @param isPublic
+     * @return
+     */
+    @Override
+    public void changePublicStatus(Long id, Boolean isPublic) {
+        CourseTag courseTag = courseTagDao.findOne(FieldFilters.eq("id", String.valueOf(id)));
+        if (courseTag!=null){
+            courseTag.setIsPublic(isPublic);
+            courseTag.setLastSetPublicTime(isPublic?LocalDateTime.now():null);
+            courseTagDao.update(courseTag);
+        }
+    }
+
+    /**
+     * 修改指定id的课程标签的热点属性
+     * @param id
+     * @param isHot
+     * @return
+     */
+    @Override
+    public void changeHotStatus(Long id, Boolean isHot) {
+        CourseTag courseTag = courseTagDao.findOne(FieldFilters.eq("id", String.valueOf(id)));
+        if (courseTag!=null){
+            courseTag.setIsHot(isHot);
+            courseTag.setLastSetHotTime(isHot?LocalDateTime.now():null);
+            courseTagDao.update(courseTag);
+        }
+    }
+
+    /**
+     * 解除指定id的课程和某个标签之间的关联关系
+     * @return
+     */
+    @Override
+    public void unbind(String id) {
+        //根据主键查询关联关系
+        CourseTagRelation courseTagRelation = courseTagRelationDao.findOne(FieldFilters.eq("id", id));
+        if (courseTagRelation != null){
+            //修改该标签关联课程数
+            CourseTag courseTag = courseTagDao.findOne(FieldFilters.eq("id", String.valueOf(courseTagRelation.getTagId())));
+            if (courseTag != null){
+                courseTag.setUseCount(courseTag.getUseCount()>1?courseTag.getUseCount()-1:0);
+                courseTagDao.updateFieldById(courseTag.getId(),"useCount",courseTag.getUseCount());
+            }
+            //解绑(删除关联关系)
+            courseTagRelationDao.setDeleted(id);
+            Course course = courseDao.get(courseTagRelation.getCourseId().toString());
+            String tags = course.getTags();
+            if (StringUtils.isNotBlank(tags)){
+                String[] tagIds = tags.split(",");
+                List<String> tagIdList = new ArrayList<>();
+                for (String tagId : tagIds){
+                    if (!tagId.equals(courseTagRelation.getTagId().toString())){
+                        tagIdList.add(tagId);
+                    }
+                }
+                // 数据格式:1,2,3
+                String s = StringUtils.join(tagIdList, ",");
+                if (!"".equals(s)){
+                    s+=",";
+                }
+                course.setTags(s);
+            }
+            // 同步ES
+            publishUtil.fullTextPublish(course);
+        }
+    }
+
+    /**
+     * 根据标签名称进行检索(模糊查询)
+     * @param tagName
+     * @return 符合检索条件的所有公共标签
+     */
+    public List<CourseTag> searchTags(String tagName){
+        QueryBuilder query=QueryBuilder.from(CourseTag.class);
+        List<IFieldFilter> filters = new ArrayList<>();
+        filters.add(FieldFilters.eq("deleted",false));//未删除
+        filters.add(FieldFilters.eq("isPublic",true));//公共标签
+        filters.add(FieldFilters.like("tagName",tagName));//模糊检索
+        query.addFilters(filters);
+        List<CourseTag> courseTagList = courseTagDao.findList(query.builder());
+        return courseTagList;
+    }
+
+    @Override
+    public List<CourseTag> searchTags(String tagName,String userId,String typeId){
+        List<CourseTag>  tagList = courseTagDao.searchTags(tagName,userId,typeId);
+        return tagList;
+    }
+
+    /**
+     * 创建新标签,并与指定课程绑定
+     * @return
+     */
+    /*@Override
+    public CourseTag createTag(CourseTagRelationDto courseTagRelationDto) {
+        CourseTag courseTag = null;
+        String tagName = courseTagRelationDto.getTagName();
+        Long courseId = Long.valueOf(courseTagRelationDto.getCourseId());
+        //1.创建标签：先判断是否已经存在该标签
+        QueryBuilder query=QueryBuilder.from(CourseTag.class);
+        List<IFieldFilter> filters = new ArrayList<>();
+        filters.add(FieldFilters.eq("tagName",tagName));//精确匹配
+        query.addFilters(filters);
+        List<CourseTag> courseTagList = courseTagDao.findList(query.builder());
+        if (courseTagList==null || courseTagList.size()==0){//1.1 如果该标签不存在，则新建标签
+            courseTag = new CourseTag();
+            courseTag.setTagName(tagName);
+            courseTag.setIsPublic(false);
+            courseTag.setIsHot(false);
+            courseTag.setUseCount(1);
+            courseTagDao.save(courseTag);
+            //新建一条标签和课程的关联关系
+            CourseTagRelation courseTagRelation = new CourseTagRelation();
+            courseTagRelation.setTagId(Long.valueOf(courseTag.getId()));
+            courseTagRelation.setCourseId(courseId);
+            courseTagRelationDao.save(courseTagRelation);
+        }else {//1.2 否则修改标签
+            courseTag=courseTagList.get(0);
+            // 当同一标签被3个及以上课管创建时，默认开启这个标签的公共化
+            if(courseTag.getUseCount() >= 3){
+                courseTag.setIsPublic(true);
+            }
+            courseTag.setDeleted(false);//有可能是之前被删除的标签，这里恢复为有效
+            //查找改课程与这个标签是否已经建立关联关系
+            query=QueryBuilder.from(CourseTagRelation.class);
+            filters = new ArrayList<>();
+            filters.add(FieldFilters.eq("tagId",Long.valueOf(courseTag.getId())));//精确匹配
+            filters.add(FieldFilters.eq("courseId",courseId));//精确匹配
+            query.addFilters(filters);
+            List<CourseTagRelation> courseTagRelationList = courseTagRelationDao.findList(query.builder());
+            //1.2.1 如果还未建立关联关系，则新建一条标签和课程的关联关系
+            if (courseTagRelationList==null || courseTagRelationList.size()==0){
+                CourseTagRelation courseTagRelation = new CourseTagRelation();
+                courseTagRelation.setTagId(Long.valueOf(courseTag.getId()));
+                courseTagRelation.setCourseId(courseId);
+                courseTagRelationDao.save(courseTagRelation);
+                //更新该标签的关联课程数量
+                courseTag.setUseCount(courseTag.getUseCount()+1);
+            }else {//1.2.2 否则修改该标签和课程的关联关系
+                CourseTagRelation courseTagRelation = courseTagRelationList.get(0);
+                if (courseTagRelation.getDeleted()){//之前"解绑",这里恢复为有效
+                    courseTagRelation.setDeleted(false);
+                    courseTagRelationDao.saveOrUpdate(courseTagRelation);
+                    //更新该标签的关联课程数量
+                    courseTag.setUseCount(courseTag.getUseCount()+1);
+                }
+            }
+            courseTagDao.saveOrUpdate(courseTag);
+        }
+        //2.创建该标签和课程分类之间的关联关系
+        courseTagRelationDto.setTagId(courseTag.getId());
+        createCourseTypeAndTagRelation(courseTagRelationDto);
+        return courseTag;
+    }
+*/
+    @Override
+    public CourseTag getTagByName(String tagName) {
+        CourseTag courseTag = courseTagDao.getTagByName(tagName);
+        return courseTag;
+    }
+
+    @Override
+    public List<CourseTag> getTagsByIds(String id) {
+        // id=17,18
+        List<CourseTag> courseTagList = courseTagDao.getTagsByIds(id);
+        return courseTagList;
+    }
+
+    /**
+     * 获取热门标签
+     * @param courseTagRelationDto
+     * @return
+     */
+    @Override
+    public List<CourseTag> getHotTagList(CourseTagRelationDto courseTagRelationDto) {
+        List<CourseTag> hotTagList = null;
+        if (StringUtils.isNotBlank(courseTagRelationDto.getSysType1()) ||
+                StringUtils.isNotBlank(courseTagRelationDto.getSysType2()) ||
+                StringUtils.isNotBlank(courseTagRelationDto.getSysType3())){
+            String sysType1 = courseTagRelationDto.getSysType1();
+            String sysType2 = courseTagRelationDto.getSysType2();
+            String sysType3 = courseTagRelationDto.getSysType3();
+            hotTagList = courseTagDao.getHotTagListBySysTypes(sysType1,sysType2,sysType3);
+        }else {
+            hotTagList = courseTagDao.getHotTagList();
+        }
+        return hotTagList;
+    }
+
+    /**
+     * 创建标签和课程分类之间的关联关系
+     * @param courseTagRelationDto
+     */
+    private void createCourseTypeAndTagRelation(CourseTagRelationDto courseTagRelationDto){
+        String sysType1 = courseTagRelationDto!=null?courseTagRelationDto.getSysType1():null;
+        String tagId = courseTagRelationDto!=null?courseTagRelationDto.getTagId():null;
+        if (StringUtils.isNotBlank(sysType1) && StringUtils.isNotBlank(tagId)){
+            String sysType2 = courseTagRelationDto.getSysType2();
+            String sysType3 = courseTagRelationDto.getSysType3();
+            //判断数据库中该课程分类和标签是否已经存在关联关系
+            if (!isHadCourseTypeAndTagRelation(courseTagRelationDto,true)){//不存在，则新建
+                CourseTypeTagRelation courseTypeTagRelation = new CourseTypeTagRelation();
+                courseTypeTagRelation.setSysType1(sysType1);
+                courseTypeTagRelation.setSysType2(StringUtils.isNotBlank(sysType2)?sysType2:"0");
+                courseTypeTagRelation.setSysType3(StringUtils.isNotBlank(sysType3)?sysType3:"0");
+                courseTypeTagRelation.setTagId(tagId);
+                courseTypeTagRelationDao.save(courseTypeTagRelation);
+            }
+        }
+    }
+
+    /**
+     * 判断数据库制定的课程分类和标签是否已经存在关联关系
+     * @param courseTagRelationDto
+     * @param clearFlag 清理标识  true：清理已存在的数据，只保留一条有效数据
+     * @return  true:已存在；false:不存在
+     */
+    private Boolean isHadCourseTypeAndTagRelation(CourseTagRelationDto courseTagRelationDto,Boolean clearFlag){
+        QueryBuilder query=QueryBuilder.from(CourseTypeTagRelation.class);
+        List<IFieldFilter> filters = new ArrayList<>();
+        filters.add(FieldFilters.eq("sysType1",courseTagRelationDto.getSysType1()));//一级分类
+        filters.add(FieldFilters.eq("sysType2",courseTagRelationDto.getSysType1()));//二级分类
+        filters.add(FieldFilters.eq("sysType3",courseTagRelationDto.getSysType1()));//三级分类
+        filters.add(FieldFilters.eq("tagId",courseTagRelationDto.getTagId()));
+        List<CourseTypeTagRelation> courseTypeTagRelList = courseTypeTagRelationDao.findList(query.addFilters(filters).builder());
+        Boolean isExist = (courseTypeTagRelList!=null && courseTypeTagRelList.size()>0)?true:false;
+        if (isExist && clearFlag ){
+            List<CourseTypeTagRelation> toRemove = new ArrayList<>();
+            for (CourseTypeTagRelation courseTypeTagRel : courseTypeTagRelList) {
+                if (courseTypeTagRel.getDeleted()) {//如果是逻辑删的本次物理删除
+                    courseTypeTagRelationDao.getGenericDao().delete(courseTypeTagRel);
+                    toRemove.add(courseTypeTagRel);
+                }
+            }
+            courseTypeTagRelList.removeAll(toRemove);//移除逻辑删的数据
+            //如果还存在有效数据
+            if (courseTypeTagRelList!=null && courseTypeTagRelList.size()>0){
+                //只保留一条有效数据，其余物理删除
+                for (int i = courseTypeTagRelList.size() - 1; i >= 1; i--) {
+                    CourseTypeTagRelation courseTypeTagRel = courseTypeTagRelList.get(i);
+                    if (courseTypeTagRel.getDeleted()) {
+                        courseTypeTagRelationDao.getGenericDao().delete(courseTypeTagRel);
+                        courseTypeTagRelList.remove(i); // 倒序删除不影响未遍历的索引
+                    }
+                }
+                isExist = true;//存在一条有效数据
+            }else {
+                isExist = false;//不存在有效数据了
+            }
+        }
+        return isExist;
+    }
+
+
+
+    /**
+     * 创建新标签
+     * @param courseTagRelationDto
+     * @return
+     */
+    @Override
+    public CourseTag createTag(CourseTagRelationDto courseTagRelationDto) {
+        CourseTag courseTag = null;
+        String tagName = courseTagRelationDto.getTagName();
+        //1.创建标签：先判断是否已经存在该标签
+        QueryBuilder query=QueryBuilder.from(CourseTag.class);
+        List<IFieldFilter> filters = new ArrayList<>();
+        filters.add(FieldFilters.eq("tagName",tagName));//精确匹配
+        filters.add(FieldFilters.eq("status",0));//正式
+        filters.add(FieldFilters.eq("deleted",false));//未删除的
+        query.addFilters(filters);
+        List<CourseTag> courseTagList = courseTagDao.findList(query.builder());
+        if (courseTagList==null || courseTagList.isEmpty() || !courseTagList.get(0).getIsPublic()){//1.1 如果该标签不存在 或私有标签，则新建标签
+            courseTag = new CourseTag();
+            courseTag.setTagName(tagName);
+            courseTag.setIsPublic(false);
+            courseTag.setIsHot(false);
+            courseTag.setStatus(1);
+            courseTag.setUseCount(1);
+            //初始给个时间， 变更公共会更新时间 关闭公共会设置null 后续不在自动变更为公共
+            courseTag.setLastSetPublicTime(LocalDateTime.now());
+            courseTagDao.save(courseTag);
+        }
+        return courseTag;
+    }
+
+
+    @Override
+    public void updateTags(Course oldCourse, Course newCourse, CurrentUser userInfo) {
+        log.info(" --- 标签修改 --- 在线课参数 oldCourse = {} " , oldCourse);
+        log.info(" --- 标签修改 --- 在线课参数 newCourse = {} " , newCourse);
+        log.info(" --- 标签修改 --- 用户信息 userInfo = {} " , userInfo);
+
+        // 获取新旧课程的标签ID列表
+        List<String> oldTagIds = getTagIdsFromCourse(oldCourse);
+        List<String> newTagIds = getTagIdsFromCourse(newCourse);
+        log.info(" --- 旧标签 oldTagIds = {} " , oldTagIds);
+        log.info(" --- 新修改  newTagIds = {} " , newTagIds);
+        if (oldCourse == null || oldTagIds.isEmpty()) {
+            // 新增课程 - 处理所有新标签
+            handleNewCourseTags(newCourse, newTagIds, userInfo);
+        } else {
+            // 编辑课程 - 比较差异并处理
+            handleEditCourseTags(oldCourse, newCourse, oldTagIds, newTagIds, userInfo);
+        }
+        log.info("完成课程标签更新: courseId={}", newCourse != null ? newCourse.getId() : "null");
+    }
+
+    @Override
+    public List<CourseTag> getAllTags() {
+        QueryBuilder query=QueryBuilder.from(CourseTag.class);
+        List<IFieldFilter> filters = new ArrayList<>();
+        filters.add(FieldFilters.eq("deleted",false));//未删除
+        filters.add(FieldFilters.eq("status",0));//正式标签
+        query.addFilters(filters);
+        List<CourseTag> courseTagList = courseTagDao.findList(query.builder());
+        return courseTagList;
+    }
+
+    /**
+     * 从课程对象中提取标签ID列表
+     */
+    private List<String> getTagIdsFromCourse(Course course) {
+        if (course == null || StringUtils.isBlank(course.getTags())) {
+            return new ArrayList<>();
+        }
+
+        String tags = course.getTags();
+        // 去除结尾的逗号并分割
+        if (tags.endsWith(",")) {
+            tags = tags.substring(0, tags.length() - 1);
+        }
+
+        if (StringUtils.isBlank(tags)) {
+            return new ArrayList<>();
+        }
+
+        return Arrays.asList(tags.split(","));
+    }
+
+    /**
+     * 处理新增课程的标签逻辑
+     */
+    private void handleNewCourseTags(Course newCourse, List<String> newTagIds, CurrentUser userInfo) {
+        log.info("处理新增课程的标签逻辑: courseId={}, tagCount={}", newCourse != null ? newCourse.getId() : "null", newTagIds.size());
+        String courseId = newCourse.getId();
+
+        for (String tagId : newTagIds) {
+            if (StringUtils.isBlank(tagId)) {
+                continue;
+            }
+
+            // 获取标签信息
+            CourseTag tag = courseTagDao.findOne(FieldFilters.eq("id", tagId.trim()));
+            if (tag == null) {
+                log.warn("标签不存在: {}", tagId);
+                continue;
+            }
+
+            //合并临时标签
+            tag = mergeTag(tag);
+
+            // 创建课程-标签关联关系
+            createCourseTagRelation(courseId, tag, userInfo);
+
+            // 创建分类-标签关联关系
+            createCourseTypeTagRelations(newCourse, tag, userInfo);
+
+            // 更新标签使用计数并检查是否设置为公共标签
+            updateTagUseCountAndPublicStatus(tag, userInfo);
+        }
+        log.info("完成新增课程标签处理: courseId={}", newCourse != null ? newCourse.getId() : "null");
+    }
+
+    /**
+     * 处理编辑课程的标签逻辑
+     */
+    private void handleEditCourseTags(Course oldCourse, Course newCourse,
+                                      List<String> oldTagIds, List<String> newTagIds, CurrentUser userInfo) {
+        log.info("处理编辑课程的标签逻辑: courseId={}, oldTagCount={}, newTagCount={}, toRemove={}, toAdd={}",
+                newCourse != null ? newCourse.getId() : "null",
+                oldTagIds.size(), newTagIds.size(),
+                oldTagIds.stream().filter(tagId -> !newTagIds.contains(tagId)).count(),
+                newTagIds.stream().filter(tagId -> !oldTagIds.contains(tagId)).count());
+
+        String courseId = newCourse.getId();
+
+        // 找出需要删除的标签（存在于旧课程但不在新课程中）
+        List<String> tagsToRemove = oldTagIds.stream()
+                .filter(tagId -> !newTagIds.contains(tagId))
+                .collect(Collectors.toList());
+
+        // 找出需要新增的标签（存在于新课程但不在旧课程中）
+        List<String> tagsToAdd = newTagIds.stream()
+                .filter(tagId -> !oldTagIds.contains(tagId))
+                .collect(Collectors.toList());
+
+        // 处理标签删除
+        for (String tagId : tagsToRemove) {
+            removeCourseTagRelation(courseId, tagId, userInfo);
+        }
+
+        // 处理标签新增
+        for (String tagId : tagsToAdd) {
+            CourseTag tag = courseTagDao.findOne(FieldFilters.eq("id", tagId.trim()));
+            if (tag == null) {
+                log.warn("标签不存在: {}", tagId);
+                continue;
+            }
+            //如果已有同名的正式标签 则需要合并
+            //合并临时标签
+            tag = mergeTag(tag);
+
+            // 创建课程-标签关联关系
+            createCourseTagRelation(courseId, tag, userInfo);
+
+            // 创建分类-标签关联关系
+            createCourseTypeTagRelations(newCourse, tag, userInfo);
+
+            // 更新标签使用计数并检查是否设置为公共标签
+            updateTagUseCountAndPublicStatus(tag, userInfo);
+        }
+
+        // 处理分类变化导致的标签关联关系更新
+        if (hasCourseTypeChanged(oldCourse, newCourse)) {
+            updateCourseTypeTagRelations(oldCourse, newCourse, newTagIds, userInfo);
+        }
+        log.info("完成编辑课程标签处理: courseId={}", newCourse != null ? newCourse.getId() : "null");
+    }
+
+
+    /**
+     * 合并标签
+     */
+    private CourseTag mergeTag(CourseTag tag){
+        //只处理临时标签 正式的忽略
+        if (tag.getStatus()==1){
+            QueryBuilder query=QueryBuilder.from(CourseTag.class);
+            List<IFieldFilter> filters = new ArrayList<>();
+            filters.add(FieldFilters.eq("tagName",tag.getTagName()));//精确匹配
+            filters.add(FieldFilters.eq("status",0));//正式
+            filters.add(FieldFilters.eq("deleted",false));//未删除的
+            query.addFilters(filters);
+            List<CourseTag> courseTagList = courseTagDao.findList(query.builder());
+            log.info("标签合并 createTag courseTagList = {} " , courseTagList);
+            //如果无同名正式标签 则转正
+            //有同名正式标签 则合并
+            if (courseTagList != null && !courseTagList.isEmpty()) {
+                //删除临时标签
+                tag.setSysUpdateBy("系统合并删除");
+                tag.setSysUpdateTime(LocalDateTime.now());
+                courseTagDao.setDeleted(tag.getId());
+                //返回同名正式标签
+                tag = courseTagList.get(0);
+            }
+        }
+        return tag;
+    }
+
+    /**
+     * 创建课程-标签关联关系
+     */
+    private void createCourseTagRelation(String courseId, CourseTag tag, CurrentUser userInfo) {
+        log.debug("创建课程-标签关联关系: courseId={}, tagId={}, tagName={}",
+                courseId, tag != null ? tag.getId() : "null", tag != null ? tag.getTagName() : "null");
+
+        // 检查是否已存在关联关系
+        QueryBuilder query = QueryBuilder.from(CourseTagRelation.class);
+        List<IFieldFilter> filters = new ArrayList<>();
+        filters.add(FieldFilters.eq("courseId", Long.valueOf(courseId)));
+        filters.add(FieldFilters.eq("tagId", Long.valueOf(tag.getId())));
+//        filters.add(FieldFilters.eq("deleted", false));
+        query.addFilters(filters);
+
+        List<CourseTagRelation> existingRelations = courseTagRelationDao.findList(query.builder());
+
+        LocalDateTime now = LocalDateTime.now();
+
+        if (existingRelations.isEmpty()) {
+            // 新建关联关系
+            CourseTagRelation relation = new CourseTagRelation();
+            relation.setCourseId(Long.valueOf(courseId));
+            relation.setTagId(Long.valueOf(tag.getId()));
+
+            // 设置创建信息
+            relation.setSysCreateAid(userInfo.getAccountId());
+            relation.setSysCreateBy(userInfo.getName());
+            relation.setSysCreateTime(now);
+
+            // 设置更新信息
+            relation.setSysUpdateBy(userInfo.getName());
+            relation.setSysUpdateTime(now);
+
+            courseTagRelationDao.save(relation);
+        } else {
+            // 恢复已删除的关联关系
+            CourseTagRelation relation = existingRelations.get(0);
+            if (relation.getDeleted()) {
+                courseTagRelationDao.reTagRelDelStatus(relation.getId(),userInfo.getName());
+//                relation.setDeleted(false);
+                // 设置更新信息
+//                relation.setSysUpdateBy(userInfo.getName());
+//                relation.setSysUpdateTime(now);
+//                courseTagRelationDao.saveOrUpdate(relation);
+            }
+        }
+        log.debug("完成课程-标签关联关系创建: courseId={}, tagId={}", courseId, tag != null ? tag.getId() : "null");
+
+    }
+
+    /**
+     * 创建分类-标签关联关系
+     */
+    private void createCourseTypeTagRelations(Course course, CourseTag tag, CurrentUser userInfo) {
+        log.debug("创建分类-标签关联关系: courseId={}, tagId={}, sysType1={}, sysType2={}, sysType3={}",
+                course != null ? course.getId() : "null",
+                tag != null ? tag.getId() : "null",
+                course != null ? course.getSysType1() : "null",
+                course != null ? course.getSysType2() : "null",
+                course != null ? course.getSysType3() : "null");
+
+        String sysType1 = course.getSysType1();
+        String sysType2 = course.getSysType2();
+        String sysType3 = course.getSysType3();
+
+        // 根据分类级别创建相应的关联关系
+        if (StringUtils.isNotBlank(sysType3)) {
+            createSingleCourseTypeTagRelation(sysType1, sysType2, sysType3, tag.getId(), userInfo);
+        }else if (StringUtils.isNotBlank(sysType2)) {
+            createSingleCourseTypeTagRelation(sysType1, sysType2, "0", tag.getId(), userInfo);
+        }else if (StringUtils.isNotBlank(sysType1)) {
+            createSingleCourseTypeTagRelation(sysType1, "0", "0", tag.getId(), userInfo);
+        }
+    }
+
+    /**
+     * 创建单个分类-标签关联关系
+     */
+    private void createSingleCourseTypeTagRelation(String sysType1, String sysType2, String sysType3,
+                                                   String tagId, CurrentUser userInfo) {
+        // 检查是否已存在关联关系
+        QueryBuilder query = QueryBuilder.from(CourseTypeTagRelation.class);
+        List<IFieldFilter> filters = new ArrayList<>();
+        filters.add(FieldFilters.eq("sysType1", sysType1));
+        filters.add(FieldFilters.eq("sysType2", sysType2));
+        filters.add(FieldFilters.eq("sysType3", sysType3));
+        filters.add(FieldFilters.eq("tagId", tagId));
+//        filters.add(FieldFilters.eq("deleted", false));
+        query.addFilters(filters);
+
+        List<CourseTypeTagRelation> existingRelations = courseTypeTagRelationDao.findList(query.builder());
+
+        LocalDateTime now = LocalDateTime.now();
+
+        if (existingRelations.isEmpty()) {
+            // 新建关联关系
+            CourseTypeTagRelation relation = new CourseTypeTagRelation();
+            relation.setSysType1(sysType1);
+            relation.setSysType2(sysType2);
+            relation.setSysType3(sysType3);
+            relation.setTagId(tagId);
+
+            // 设置创建信息
+            relation.setSysCreateAid(userInfo.getAccountId());
+            relation.setSysCreateBy(userInfo.getName());
+            relation.setSysCreateTime(now);
+
+            // 设置更新信息
+            relation.setSysUpdateBy(userInfo.getName());
+            relation.setSysUpdateTime(now);
+
+            courseTypeTagRelationDao.save(relation);
+        } else {
+            // 恢复已删除的关联关系
+            CourseTypeTagRelation relation = existingRelations.get(0);
+            if (relation.getDeleted()) {
+                courseTagRelationDao.reTypeTagRelDelStatus(relation.getId(),userInfo.getName());
+//                relation.setDeleted(false);
+//                // 设置更新信息
+//                relation.setSysUpdateBy(userInfo.getName());
+//                relation.setSysUpdateTime(now);
+//                courseTypeTagRelationDao.saveOrUpdate(relation);
+            }
+        }
+    }
+
+    /**
+     * 移除课程-标签关联关系
+     */
+    private void removeCourseTagRelation(String courseId, String tagId, CurrentUser userInfo) {
+        log.debug("移除课程-标签关联关系: courseId={}, tagId={}", courseId, tagId);
+        // 查找关联关系
+        QueryBuilder query = QueryBuilder.from(CourseTagRelation.class);
+        List<IFieldFilter> filters = new ArrayList<>();
+        filters.add(FieldFilters.eq("courseId", Long.valueOf(courseId)));
+        filters.add(FieldFilters.eq("tagId", Long.valueOf(tagId)));
+        query.addFilters(filters);
+
+        List<CourseTagRelation> relations = courseTagRelationDao.findList(query.builder());
+
+        if (!relations.isEmpty()) {
+            CourseTagRelation relation = relations.get(0);
+
+            // 设置更新信息
+            relation.setSysUpdateBy(userInfo.getName());
+            relation.setSysUpdateTime(LocalDateTime.now());
+
+            // 逻辑删除关联关系
+            courseTagRelationDao.setDeleted(relation.getId());
+
+            // 更新标签使用计数
+            CourseTag tag = courseTagDao.findOne(FieldFilters.eq("id", tagId));
+            if (tag != null) {
+                tag.setUseCount(Math.max(0, tag.getUseCount() - 1));
+
+                // 设置更新信息
+                tag.setSysUpdateBy(userInfo.getName());
+                tag.setSysUpdateTime(LocalDateTime.now());
+
+                courseTagDao.update(tag);
+            }
+
+            // 检查是否需要删除分类-标签关联关系
+            checkAndRemoveCourseTypeTagRelation(tagId, userInfo);
+        }
+        log.debug("完成课程-标签关联关系移除: courseId={}, tagId={}", courseId, tagId);
+    }
+
+    /**
+     * 检查并删除分类-标签关联关系（如果没有其他课程使用）
+     */
+    private void checkAndRemoveCourseTypeTagRelation(String tagId, CurrentUser userInfo) {
+        // 检查是否还有其他课程使用这个标签
+        QueryBuilder query = QueryBuilder.from(CourseTagRelation.class);
+        List<IFieldFilter> filters = new ArrayList<>();
+        filters.add(FieldFilters.eq("tagId", Long.valueOf(tagId)));
+        filters.add(FieldFilters.eq("deleted", false));
+        query.addFilters(filters);
+
+        List<CourseTagRelation> activeRelations = courseTagRelationDao.findList(query.builder());
+
+        // 如果没有其他活跃的关联关系，删除分类-标签关联
+        if (activeRelations.isEmpty()) {
+            QueryBuilder typeQuery = QueryBuilder.from(CourseTypeTagRelation.class);
+            List<IFieldFilter> typeFilters = new ArrayList<>();
+            typeFilters.add(FieldFilters.eq("tagId", tagId));
+            typeQuery.addFilters(typeFilters);
+
+            List<CourseTypeTagRelation> typeRelations = courseTypeTagRelationDao.findList(typeQuery.builder());
+
+            LocalDateTime now = LocalDateTime.now();
+
+            for (CourseTypeTagRelation relation : typeRelations) {
+                // 设置更新信息
+                relation.setSysUpdateBy(userInfo.getName());
+                relation.setSysUpdateTime(now);
+
+                courseTypeTagRelationDao.setDeleted(relation.getId());
+            }
+        }
+    }
+
+    /**
+     * 更新标签使用计数并检查公共标签状态
+     */
+    private void updateTagUseCountAndPublicStatus(CourseTag tag, CurrentUser userInfo) {
+        log.debug("更新标签使用计数和公共状态: tagId={}, tagName={}, beforeUseCount={}",
+                tag != null ? tag.getId() : "null",
+                tag != null ? tag.getTagName() : "null",
+                tag != null ? tag.getUseCount() : "null");
+
+        // 将标签状态设置为正式(status=0)
+        if (tag != null && tag.getStatus() == 1) {
+            tag.setStatus(0); // 正式标签
+        }
+        // 统计当前活跃的关联关系数量
+        QueryBuilder query = QueryBuilder.from(CourseTagRelation.class);
+        List<IFieldFilter> filters = new ArrayList<>();
+        filters.add(FieldFilters.eq("tagId", Long.valueOf(tag.getId())));
+        filters.add(FieldFilters.eq("deleted", false));
+        query.addFilters(filters);
+
+        List<CourseTagRelation> activeRelations = courseTagRelationDao.findList(query.builder());
+        int activeCount = activeRelations.size();
+
+        tag.setUseCount(activeCount);
+
+        LocalDateTime now = LocalDateTime.now();
+
+        // 检查是否满足设置为公共标签的条件
+        if (activeCount >= 3 && tag.getLastSetPublicTime() != null) {
+            // 只有从未手动关闭过公共标签的才自动开启
+            tag.setIsPublic(true);
+            tag.setLastSetPublicTime(now);
+        }
+
+        // 设置更新信息
+        tag.setSysUpdateBy(userInfo.getName());
+        tag.setSysUpdateTime(now);
+
+        courseTagDao.update(tag);
+        log.debug("完成标签使用计数和公共状态更新: tagId={}, tagName={}, afterUseCount={}, isPublic={}",
+                tag != null ? tag.getId() : "null",
+                tag != null ? tag.getTagName() : "null",
+                tag != null ? tag.getUseCount() : "null",
+                tag != null ? tag.getIsPublic() : "null");
+    }
+
+    /**
+     * 检查课程分类是否发生变化
+     */
+    private boolean hasCourseTypeChanged(Course oldCourse, Course newCourse) {
+        return !Objects.equals(oldCourse.getSysType1(), newCourse.getSysType1()) ||
+                !Objects.equals(oldCourse.getSysType2(), newCourse.getSysType2()) ||
+                !Objects.equals(oldCourse.getSysType3(), newCourse.getSysType3());
+    }
+
+    /**
+     * 更新分类-标签关联关系（当分类变化时）
+     */
+    private void updateCourseTypeTagRelations(Course oldCourse, Course newCourse,
+                                              List<String> tagIds, CurrentUser userInfo) {
+        // 移除旧的分类-标签关联关系
+        for (String tagId : tagIds) {
+            checkAndRemoveCourseTypeTagRelation(tagId, userInfo);
+        }
+
+        // 创建新的分类-标签关联关系
+        for (String tagId : tagIds) {
+            CourseTag tag = courseTagDao.findOne(FieldFilters.eq("id", tagId.trim()));
+            if (tag != null) {
+                createCourseTypeTagRelations(newCourse, tag, userInfo);
+            }
+        }
+    }
+
+    /**
+     * 设置实体的创建信息（新增时使用）
+     */
+    private void setCreateInfo(BaseEntity entity, CurrentUser userInfo) {
+        LocalDateTime now = LocalDateTime.now();
+        entity.setSysCreateAid(userInfo.getAccountId());
+        entity.setSysCreateBy(userInfo.getName());
+        entity.setSysCreateTime(now);
+        entity.setSysUpdateBy(userInfo.getName());
+        entity.setSysUpdateTime(now);
+    }
+
+    /**
+     * 设置实体的更新信息（编辑时使用）
+     */
+    private void setUpdateInfo(BaseEntity entity, CurrentUser userInfo) {
+        entity.setSysUpdateBy(userInfo.getName());
+        entity.setSysUpdateTime(LocalDateTime.now());
+    }
+
+
+
+}
--- a/servers/boe-server-all/src/main/java/com/xboe/module/exam/service/impl/AloneExamServiceImpl.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/module/exam/service/impl/AloneExamServiceImpl.java
@@ -8,6 +8,8 @@ import java.util.Map;

 import javax.annotation.Resource;

+import com.boe.feign.api.courseweb.reps.ExamStudyRecordParam;
+import com.xboe.api.ThirdApi;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -37,7 +39,10 @@ public class AloneExamServiceImpl implements IAloneExamService{
 	
 	@Resource
 	AloneExamDao aeDao;
-	
+	@Resource
+	private ThirdApi thirdApi;
+
+
 	@Override
 	@Transactional
 	public void save(AloneExamAnswer aea){
@@ -101,7 +106,18 @@ public class AloneExamServiceImpl implements IAloneExamService{
 //				//这种情况汶是不存在的
 //			}
 		}
-	}
+
+        try {
+            ExamStudyRecordParam param = new ExamStudyRecordParam();
+            param.setTestId(aea.getTestId());
+            param.setAid(aea.getAid());
+            thirdApi.syncExamStudyRecord(param);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+
+
+    }

 	@Override
 	@Transactional
--- a/servers/boe-server-all/src/main/java/com/xboe/school/study/api/StudyCourseApi.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/school/study/api/StudyCourseApi.java
@@ -1,15 +1,21 @@
 package com.xboe.school.study.api;

+import java.math.BigDecimal;
+import java.math.RoundingMode;
 import java.time.LocalDateTime;
 import java.util.*;
 import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
+import java.util.stream.Collectors;

+import cn.hutool.core.collection.CollectionUtil;
 import com.alibaba.nacos.shaded.com.google.common.util.concurrent.RateLimiter;
 import com.xboe.api.ThirdApi;
 import com.xboe.constants.CacheName;
 import com.xboe.module.course.vo.TeacherVo;
 import com.xboe.module.usergroup.service.IUserGroupService;
 import com.xboe.school.study.dao.StudyCourseDao;
+import com.xboe.school.vo.StudyTimeVo;
 import org.apache.commons.lang3.ArrayUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -253,6 +259,36 @@ public class StudyCourseApi extends ApiBaseController{
 			rs.put("progress", sc.getProgress());
 			//查询上次学习的是什么资源。查询用户的学习情况
 			List<StudyCourseItem> items=studyService.findByStudyId(sc.getId());
+			// 和内容匹配，根据内容的视频时长，计算学习进度
+			if(CollectionUtil.isNotEmpty(items) && CollectionUtil.isNotEmpty(cclist)){
+				// 根据ID转换map
+				Map<String, CourseContent> contentMap = cclist.stream().collect(Collectors.toMap(CourseContent::getId, Function.identity()));
+				for (StudyCourseItem item : items) {
+					CourseContent content = contentMap.get(item.getContentId());
+					if(null == content){
+						continue;
+					}
+
+					if(null==item.getLastStudyTime()
+							|| item.getLastStudyTime()<=0
+							|| null==content.getDuration()
+							|| content.getDuration()<=0){
+						continue;
+					}
+
+					BigDecimal lastStudyTime = new BigDecimal(item.getLastStudyTime());
+					BigDecimal duration = new BigDecimal(content.getDuration());
+					BigDecimal progress = lastStudyTime.divide(duration, 10, RoundingMode.HALF_UP);
+					if(progress.compareTo(BigDecimal.ZERO) < 0){
+						progress = BigDecimal.ZERO;
+					}else if(progress.compareTo(BigDecimal.ONE) > 0){
+						progress = BigDecimal.ONE;
+					}
+
+					item.setProgressVideo(progress);
+				}
+			}
+
 			rs.put("contentStudys",items);//学习的内容
 		}
 		
@@ -345,6 +381,8 @@ public class StudyCourseApi extends ApiBaseController{
 			}
 			//追加学习时长
 			studyService.appendStudyDuration(sci.getStudyId(),item.getId(),sci.getContentId(),sci.getDuration());
+
+			log.info(" 1 在线课学习记录 sci.getStudyId() = "+ sci.getStudyId() + " , sci.getCourseId() = " + sci.getCourseId() );
 			List<StudyCourse> allUserList = thirdApi.getStudyCourseList(sci.getStudyId() ,sci.getCourseId(), token);
 			log.info("在线课学习记录"+allUserList);
 			return success(item.getId());
@@ -575,7 +613,7 @@ public class StudyCourseApi extends ApiBaseController{
 	@Deprecated
 	@RequestMapping(value="/appendtime",method = {RequestMethod.GET,RequestMethod.POST})
 	public JsonResponse<String> appendTime(StudyTime studyTime, HttpServletRequest request){
-		
+
 		if(StringUtils.isBlank(studyTime.getStudyId())){
 			return error("参数错误");
 		}
@@ -605,7 +643,91 @@ public class StudyCourseApi extends ApiBaseController{
 			return error("记录学习时长错误",e.getMessage());
 		}
 	}
-	
+
+	/**
+	 * appendtime 于 study-video-time 合并
+	 * */
+	/*@RequestMapping(value="/updateStudyVideoTime1",method = {RequestMethod.GET,RequestMethod.POST})
+	public JsonResponse<String> updateStudyVideoTime1(StudyTimeVo studyTime, HttpServletRequest request){
+
+		//  0 study-video-time ,  1 appendtime
+		if (studyTime.getType() == 0){
+			if(StringUtils.isBlank(studyTime.getItemId())){
+				return error("参数错误");
+			}
+			if(studyTime.getVideoTime()==null){
+				return error("无时间点");
+			}
+			//检查是否已存在
+			try {
+				studyService.updateLastTime(studyTime.getItemId(),studyTime.getVideoTime(), getCurrent().getAccountId());
+				if (studyTime.getContentId() != null && studyTime.getCourseId() != null && studyTime.getProgressVideo() != null){
+					contentService.updateProcessVideo(studyTime.getContentId(), studyTime.getCourseId(), studyTime.getProgressVideo());
+				}
+				return success("true");
+			}catch(Exception e) {
+				log.error("updateStudyVideoTime type =0 记录最后学习时间错误",e);
+				return error("updateStudyVideoTime type =0 记录最后学习时间失败 ",e.getMessage());
+			}
+		}else if(studyTime.getType() == 1){
+			if(StringUtils.isBlank(studyTime.getStudyId())){
+				return error("参数错误");
+			}
+			if(StringUtils.isBlank(studyTime.getCourseId())){
+				return error("未指定课程");
+			}
+			if(StringUtils.isBlank(studyTime.getContentId())){
+				return error("未指定资源内容");
+			}
+
+			String token = request.getHeader("Xboe-Access-Token");
+			if (StringUtils.isEmpty(token)) {
+				token = request.getHeader("token");
+			}
+			try {
+				studyService.updateStudyDuration(studyTime.getStudyId(),null,studyTime.getContentId(),studyTime.getVideoTime(),studyTime.getCourseId());
+				List<StudyCourse> allUserList = thirdApi.getStudyCourseList(studyTime.getStudyId() ,studyTime.getCourseId(), token);
+				log.info("updateStudyVideoTime type =1 在线课学习记录 = " + allUserList);
+				return success(studyTime.getId());
+			}catch(Exception e) {
+				log.error("updateStudyVideoTime type =1 记录学习时长错误",e);
+				return error("updateStudyVideoTime type =1 记录学习时长错误 ",e.getMessage());
+			}
+		}else{
+			return error("type不能为空");
+		}
+	}*/
+
+	@RequestMapping(value="/updateStudyVideoTime",method = {RequestMethod.GET,RequestMethod.POST})
+	public JsonResponse<String> updateStudyVideoTime(StudyTimeVo studyTime, HttpServletRequest request){
+        try {
+            if(StringUtils.isBlank(studyTime.getItemId())){
+                return error("参数错误");
+            }
+            if(studyTime.getVideoTime()==null){
+                return error("无时间点");
+            }
+            if(StringUtils.isBlank(studyTime.getStudyId())){
+                return error("参数错误");
+            }
+            if(StringUtils.isBlank(studyTime.getCourseId())){
+                return error("未指定课程");
+            }
+            if(StringUtils.isBlank(studyTime.getContentId())){
+                return error("未指定资源内容");
+            }
+            studyService.updateStudyDuration(studyTime.getStudyId(),studyTime.getItemId(),studyTime.getContentId(),studyTime.getVideoTime(),studyTime.getCourseId());
+            if (studyTime.getContentId() != null && studyTime.getCourseId() != null && studyTime.getProgressVideo() != null){
+                contentService.updateProcessVideo(studyTime.getContentId(), studyTime.getCourseId(), studyTime.getProgressVideo());
+            }
+
+        } catch (Exception e) {
+			log.error("updateStudyVideoTime",e);
+			return error("学习时长记录失败",e.getMessage(),null);
+        }
+		return success("true");
+    }
+
 	/**获取最后一次的学习内容*/
 	@GetMapping("/last-study")
 	public JsonResponse<Map<String,Object>> lastStudy(){
--- a/servers/boe-server-all/src/main/java/com/xboe/school/study/api/StudyCourseESApi.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/school/study/api/StudyCourseESApi.java
@@ -3,9 +3,16 @@ package com.xboe.school.study.api;
 import java.io.IOException;
 import java.time.ZoneOffset;
 import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;

+import cn.hutool.core.collection.CollectionUtil;
+import com.xboe.module.course.entity.Course;
+import com.xboe.module.course.service.ICourseService;
+import org.apache.commons.compress.utils.Lists;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
@@ -42,6 +49,15 @@ public class StudyCourseESApi extends ApiBaseController{
 	@Autowired
 	IStudyCourseService service;

+	@Autowired
+	ICourseService courseService;
+
+	@Value("${xboe.upload.file.http_path}")
+	private String httpPath;
+
+	@Value("${xboe.image.course.default}")
+	private String defaultCourseImage;
+
 	@Resource
 	private PhpOnlineStudyRecordScheduledTasks phpOnlineStudyRecordScheduledTasks;

@@ -54,13 +70,61 @@ public class StudyCourseESApi extends ApiBaseController{
 		try {
 			dto.setAccountId(getCurrent().getAccountId());
 			PageList<CourseStudyDto> rs=search.search(page.getStartRow(),page.getPageSize(), dto);
+
+			handleCourseImage(rs);
+
 			return success(rs);
 		}catch(Exception e) {
 			log.error("查询报名学习ES失败",e);
 			return error("查询失败",e.getMessage());
 		}
 	}
-	
+
+	private void handleCourseImage(PageList<CourseStudyDto> rs) {
+		if (rs == null || CollectionUtil.isEmpty(rs.getList())) {
+			return;
+		}
+
+		List<String> emptyImageCourseIds = Lists.newArrayList();
+		for(CourseStudyDto courseStudyDto : rs.getList()) {
+			if(StringUtils.isBlank(courseStudyDto.getCourseImage())) {
+				// 过滤课程类型
+				if(courseStudyDto.getCourseType()==10
+					|| courseStudyDto.getCourseType()==20){
+					emptyImageCourseIds.add(courseStudyDto.getCourseId());
+				}else{
+					log.warn("课程图片为空，课程id为：{}，课程类型:{}",courseStudyDto.getCourseId(),courseStudyDto.getCourseType());
+				}
+			}
+		}
+
+		if(CollectionUtil.isEmpty(emptyImageCourseIds)){
+			return;
+		}
+
+		List<Course> courseList = courseService.findByIds(emptyImageCourseIds);
+		if(CollectionUtil.isNotEmpty(courseList)){
+			// courseList转换成map
+			Map<String, Course> courseMap = courseList.stream().collect(Collectors.toMap(Course::getId, course -> course));
+
+			// 赋值ES图片
+			for(CourseStudyDto courseStudyDto : rs.getList()) {
+				if(emptyImageCourseIds.contains(courseStudyDto.getCourseId())) {
+					Course currentCourse = courseMap.get(courseStudyDto.getCourseId());
+					if(null!=currentCourse){
+						if(StringUtils.isNotBlank(currentCourse.getCoverImg())){
+							// 拼接域名
+							courseStudyDto.setCourseImage(httpPath + currentCourse.getCoverImg());
+						}else{
+							// 赋值默认图片
+							courseStudyDto.setCourseImage(defaultCourseImage);
+						}
+					}
+				}
+			}
+		}
+	}
+
 	@RequestMapping(value="/list-by-ids",method = {RequestMethod.POST})
 	public JsonResponse<List<StudyCourse>> search(@RequestBody List<String> ids){
 		if(ids.isEmpty()) {
--- a/servers/boe-server-all/src/main/java/com/xboe/school/study/api/StudyCourseTask.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/school/study/api/StudyCourseTask.java
@@ -0,0 +1,262 @@
+package com.xboe.school.study.api;
+
+import com.xboe.api.ThirdApi;
+import com.xboe.school.study.entity.StudyCourse;
+import com.xboe.school.study.service.IStudyService;
+import com.xxl.job.core.handler.annotation.XxlJob;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.redis.connection.RedisConnection;
+import org.springframework.data.redis.core.Cursor;
+import org.springframework.data.redis.core.ScanOptions;
+import org.springframework.data.redis.core.StringRedisTemplate;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.TimeUnit;
+import java.util.function.BiConsumer;
+
+/**
+ * @author by lyc
+ * @date 2025/3/3
+ */
+@Component
+@Slf4j
+@RequiredArgsConstructor
+public class StudyCourseTask {
+
+    private final IStudyService studyService;
+    private final StringRedisTemplate redisTemplate;
+    @Resource
+    private ThirdApi thirdApi;
+
+    /**
+     * 定时任务
+     * 获取redis 中学习结束的数据更新入库
+     * */
+    @XxlJob("saveStudyCourseItemLastTime2")
+    public void saveStudyCourseItemLastTime2() {
+        // 1. 定义匹配模式（匹配所有目标key）
+        final String KEY_PATTERN = "studyContentId:*:last_active";
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss");
+        // 2. 使用SCAN安全遍历（避免阻塞）
+        ScanOptions options = ScanOptions.scanOptions()
+            .match(KEY_PATTERN)
+            .count(100) // 分页大小
+            .build();
+
+        try (RedisConnection connection = Objects.requireNonNull(redisTemplate.getConnectionFactory()).getConnection()) {
+            Cursor<byte[]> cursor = connection.scan(options);
+            // 3. 遍历处理符合条件的key
+            while (cursor.hasNext()) {
+                String redisKey = new String(cursor.next());
+                // 4. 获取剩余TTL（秒）
+                Long ttl = redisTemplate.getExpire(redisKey, TimeUnit.SECONDS);
+
+                // 5. 过滤条件：剩余时间 >= 29天23小时30分钟（转换为秒）
+                // 总需时间 = (30天 - 30分钟) = 29天23小时30分钟 = 2590200秒
+                // 5分钟 300秒 || 2592000 - 300 = 2591700
+                if (ttl <= 2590200) {
+                    try {
+                        // 6. 提取studyContentId
+                        String[] parts = redisKey.split(":");
+                        if (parts.length < 2) continue;
+                        String studyContentId = parts[1];
+                        // 7. 获取存储的时间点（示例逻辑）
+                        String redisValue = redisTemplate.opsForValue().get(redisKey);
+                        if (redisValue == null) continue;
+                        String[] partValues = redisValue.split("&");
+                        int lastStudyTime = Integer.parseInt(partValues[0]);
+                        LocalDateTime timestamp = null;
+                        if (partValues.length >= 2){
+                            timestamp = LocalDateTime.parse(partValues[1], formatter);
+                        }
+                        // 8. 更新数据库（调用已有服务方法）
+                        studyService.updateStudyCourseItemLastTime(studyContentId, lastStudyTime, timestamp);
+                        // 9. 删除Redis键（原子操作）
+                        redisTemplate.delete(redisKey);
+                        log.info("处理成功 key: {}, lastStudyTime: {}", redisKey, lastStudyTime);
+                    } catch (Exception e) {
+                        log.error("处理失败 key: {}", redisKey, e);
+                    }
+                }
+            }
+            cursor.close();
+        } catch (Exception e) {
+            log.error("定时任务执行异常", e);
+        }
+
+      /*  // 新增日志逻辑
+        if (ttl <= 172800) {
+            studyService.saveCourseExpireLog(
+                    studyContentId,
+                    lastStudyTime,
+                    redisKey,
+                    ttl,
+                    "system_job"
+            );
+        }*/
+
+    }
+
+
+    @XxlJob("saveStudyCourseItemLastTime")
+    public void saveStudyCourseItemLastTime() {
+        // 1. 定义匹配模式（匹配所有目标key）
+        final String KEY_PATTERN = "studyId:*:courseId:*:courseContentId:*:studyItemId:*";
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss");
+        // 2. 使用SCAN安全遍历（避免阻塞）
+        ScanOptions options = ScanOptions.scanOptions()
+                .match(KEY_PATTERN)
+                .count(100) // 分页大小
+                .build();
+
+        try (RedisConnection connection = Objects.requireNonNull(redisTemplate.getConnectionFactory()).getConnection()) {
+            Cursor<byte[]> cursor = connection.scan(options);
+            // 3. 遍历处理符合条件的key
+            while (cursor.hasNext()) {
+                String redisKey = new String(cursor.next());
+                log.info("-定时任务 saveStudyCourseItemLastTime ---redisKey = " + redisKey);
+                // 4. 获取剩余TTL（秒）
+                Long ttl = redisTemplate.getExpire(redisKey, TimeUnit.SECONDS);
+
+                // 5. 过滤条件：剩余时间 >= 29天23小时30分钟（转换为秒）
+                // 总需时间 = (30天 - 30分钟) = 29天23小时30分钟 = 2590200秒
+                // 5分钟 300秒 || 2592000 - 300 = 2591700
+                if (ttl <= 2590200) {
+                    try {
+                        // 6. 提取studyContentId
+                        String[] parts = redisKey.split(":");
+                        if (parts.length < 7) continue;
+                        String studyId = parts[1];
+                        String courseId = parts[3];
+                        String courseContentId = parts[5];
+                        String studyItemId = parts[7];
+                        // 7. 获取存储的时间点（示例逻辑）
+                        String redisValue = redisTemplate.opsForValue().get(redisKey);
+                        log.info("-定时任务 saveStudyCourseItemLastTime ---redisValue = " + redisValue);
+                        if (redisValue == null) continue;
+                        String[] partValues = redisValue.split("&");
+                        int studyVideoTtime = Integer.parseInt(partValues[0]);
+                        int appendtime = Integer.parseInt(partValues[1]);
+                        LocalDateTime timestamp = null;
+                        if (partValues.length >= 2){
+                            timestamp = LocalDateTime.parse(partValues[2], formatter);
+                        }
+                        // 8. 更新数据库（调用已有服务方法）
+                        studyService.newAppendStudyDuration(studyId,null,courseContentId,appendtime,timestamp);
+                        log.info("-定时任务 saveStudyCourseItemLastTime ---studyItemId = " + studyItemId);
+                        if (studyItemId != null && !studyItemId.equals("null")){
+                            log.info("-定时任务 saveStudyCourseItemLastTime --- boolean studyItemId = " + (studyItemId != null));
+                            // 8. 更新数据库（调用已有服务方法）
+                            studyService.updateStudyCourseItemLastTime(studyItemId, studyVideoTtime, timestamp);
+                        }
+                        List<StudyCourse> allUserList = thirdApi.getStudyCourseList(studyId , courseId, null);
+                        log.info("处理成功 allUserList: {}", allUserList);
+                        // 9. 删除Redis键（原子操作）
+                        redisTemplate.delete(redisKey);
+                        log.info("处理成功 key: {}, lastStudyTime: {}", redisKey, appendtime);
+                    } catch (Exception e) {
+                        log.error("处理失败 key: {}", redisKey, e);
+                    }
+                }
+            }
+            cursor.close();
+        } catch (Exception e) {
+            log.error("定时任务执行异常", e);
+        }
+
+
+    }
+
+
+    @XxlJob("saveStudyCourseItemLastTime1")
+    public void saveStudyCourseItemLastTime1() {
+        // 定义需要处理的键模式集合
+        processKeys("studyContentId:*:last_active", this::handleLastActiveKey);
+        processKeys("studyId:*:courseId:*:courseContentId:*", this::handleDurationKey);
+    }
+
+    private void processKeys(String keyPattern, BiConsumer<String, String> keyHandler) {
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss");
+        ScanOptions options = ScanOptions.scanOptions()
+                .match(keyPattern)
+                .count(100)
+                .build();
+
+        try (RedisConnection connection = Objects.requireNonNull(redisTemplate.getConnectionFactory()).getConnection()) {
+            Cursor<byte[]> cursor = connection.scan(options);
+            while (cursor.hasNext()) {
+                String redisKey = new String(cursor.next());
+                Long ttl = redisTemplate.getExpire(redisKey, TimeUnit.SECONDS);
+
+                if (ttl != null && ttl <= 2590200) {
+                    try {
+                        String redisValue = redisTemplate.opsForValue().get(redisKey);
+                        if (redisValue != null) {
+                            // 调用对应的处理方法
+                            keyHandler.accept(redisKey, redisValue);
+                        }
+                        redisTemplate.delete(redisKey);
+                        log.info("Key processed: {}", redisKey);
+                    } catch (Exception e) {
+                        log.error("Process failed [{}]", redisKey, e);
+                    }
+                }
+            }
+            cursor.close();
+        } catch (Exception e) {
+            log.error("Key processing error: {}", keyPattern, e);
+        }
+    }
+
+    // 处理 last_active 类型键
+    private void handleLastActiveKey(String redisKey, String redisValue) {
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss");
+        String[] parts = redisKey.split(":");
+        String studyContentId = parts[1];
+
+        String[] values = redisValue.split("&");
+        int lastStudyTime = Integer.parseInt(values[0]);
+        LocalDateTime timestamp = values.length >= 2 ?
+            LocalDateTime.parse(values[1], formatter) : null;
+
+        studyService.updateStudyCourseItemLastTime(studyContentId, lastStudyTime, timestamp);
+    }
+
+    // 处理 duration 类型键
+    private void handleDurationKey(String redisKey, String redisValue) {
+        String[] parts = redisKey.split(":");
+        String studyId = parts[1];
+        String courseId = parts[3];
+        String courseContentId = parts[5];
+
+        String[] values = redisValue.split("&");
+        int duration = Integer.parseInt(values[0]);
+        LocalDateTime timestamp = values.length >= 2 ?
+            LocalDateTime.parse(values[1], DateTimeFormatter.ISO_LOCAL_DATE_TIME) : null;
+
+        studyService.newAppendStudyDuration(studyId, null, courseContentId, duration, timestamp);
+
+        // 保留第三方调用
+        List<StudyCourse> allUserList = thirdApi.getStudyCourseList(studyId, courseId, null);
+        log.info("Study records synced: {}", allUserList.size());
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
--- a/servers/boe-server-all/src/main/java/com/xboe/school/study/entity/StudyCourseItem.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/school/study/entity/StudyCourseItem.java
@@ -1,10 +1,12 @@
 package com.xboe.school.study.entity;

+import java.math.BigDecimal;
 import java.time.LocalDateTime;

 import javax.persistence.Column;
 import javax.persistence.Entity;
 import javax.persistence.Table;
+import javax.persistence.Transient;

 import com.fasterxml.jackson.annotation.JsonFormat;
 import com.xboe.core.SysConstant;
@@ -128,5 +130,12 @@ public class StudyCourseItem extends IdEntity {
     */
    @Column(name = "status",length=1)
    private Integer status;
-    
+
+    /**
+     * 视频播放进度
+     * */
+//    @Column(name = "progress_video")
+    @Transient
+    private BigDecimal progressVideo;
+
 }
--- a/servers/boe-server-all/src/main/java/com/xboe/school/study/service/IStudyService.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/school/study/service/IStudyService.java
@@ -1,5 +1,6 @@
 package com.xboe.school.study.service;

+import java.time.LocalDateTime;
 import java.util.List;
 import java.util.Map;

@@ -7,7 +8,6 @@ import com.xboe.common.PageList;
 import com.xboe.school.study.dto.StudyContentDto;
 import com.xboe.school.study.entity.StudyCourseItem;
 import com.xboe.school.study.entity.StudyTime;
-import com.xboe.system.user.entity.User;

 /**
 * 学习情况处理,比较综合一个处理类
@@ -35,11 +35,12 @@ public interface IStudyService {
 	
 	/**
 	 * 更新最后的学习时间，及学习时间点
+	 *
 	 * @param studyContentId
 	 * @param lastStudyTime
 	 * @param aid
 	 */
-	void updateLastTime(String studyContentId,int lastStudyTime,String aid);
+	void updateLastTime(String studyContentId, int lastStudyTime, String aid);

 	/**
 	 * 资源学习记录
@@ -99,4 +100,9 @@ public interface IStudyService {

    List<StudyCourseItem> getList(String courseId, String contentId, String name, Integer status);

+	void updateStudyCourseItemLastTime(String studyContentId, int lastStudyTime, LocalDateTime timestamp);
+
+	void updateStudyDuration(String studyId,String studyItemId, String contentId, Integer videoTime,String courseId);
+
+	void newAppendStudyDuration(String studyId, String studyItemId, String courseContentId, int duration, LocalDateTime timestamp);
 }
--- a/servers/boe-server-all/src/main/java/com/xboe/school/study/service/impl/StudyServiceImpl.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/school/study/service/impl/StudyServiceImpl.java
@@ -1,5 +1,6 @@
 package com.xboe.school.study.service.impl;

+import java.time.Duration;
 import java.time.LocalDateTime;
 import java.time.format.DateTimeFormatter;
 import java.util.ArrayList;
@@ -9,12 +10,9 @@ import java.util.Map;

 import javax.transaction.Transactional;

-import com.xboe.module.article.entity.Article;
-import com.xboe.module.interaction.entity.Shares;
-import com.xboe.school.study.entity.StudyCourse;
-import com.xboe.system.user.entity.User;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.redis.core.StringRedisTemplate;
 import org.springframework.stereotype.Service;

 import com.xboe.common.OrderCondition;
@@ -51,7 +49,10 @@ public class StudyServiceImpl implements IStudyService{
 	
 	@Autowired
 	UserDao userDao;
-	
+	@Autowired
+	StringRedisTemplate redisTemplate;
+
+
 	@Override
 	public StudyCourseItem checkHas(String studyId,String contentId) {
 		List<StudyCourseItem> items = scItemDao.findList(FieldFilters.eq("studyId", studyId),FieldFilters.eq("contentId", contentId));
@@ -115,34 +116,74 @@ public class StudyServiceImpl implements IStudyService{
 		//增加内容的学习时长
 		if(StringUtils.isNotBlank(studyItemId)) {
 			//直接根据id更新
-//			String hql="Update StudyCourseItem set studyDuration=studyDuration+"+duration+",status=(case when status<2 then 2 else status end) where id=?1";
-//			scItemDao.update(hql,studyItemId);
 			String sql="Update boe_study_course_item set study_duration=study_duration+"+duration+",status=(case when status<2 then 2 else status end) where id=?1";
 			scItemDao.sqlUpdate(sql,studyItemId);
-			//scItemDao.updateMultiFieldById(studyItemId, UpdateBuilder.create("studyDuration", "studyDuration+"+duration,FieldUpdateType.EXPRESSION));
-			
+
 		}else {
-			//根据学习id和课程内容id更新
-//			scItemDao.update(UpdateBuilder.from(StudyCourseItem.class)
-//					.addUpdateField("studyDuration", "studyDuration+"+duration,FieldUpdateType.EXPRESSION)
-//					.addFilter(FieldFilters.eq("studyId", studyId))  
-//					.addFilter(FieldFilters.eq("contentId", courseContentId))
-//					.builder());
-//			
-//			String hql="Update StudyCourseItem set studyDuration=studyDuration+"+duration+",status=(case when status<2 then 2 else status end) where studyId=?1 and contentId=?2";
-//			scItemDao.update(hql,studyId,courseContentId);
 			String sql="Update boe_study_course_item set study_duration=study_duration+"+duration+",status=(case when status<2 then 2 else status end) where study_id=?1 and content_id=?2";
 			scItemDao.sqlUpdate(sql,studyId,courseContentId);
 		}
 		
-		//追加课程的学习时长
-		//scDao.updateMultiFieldById(studyId, UpdateBuilder.create("totalDuration", "totalDuration+"+duration,FieldUpdateType.EXPRESSION));
-		
 		String sql="Update boe_study_course set total_duration=total_duration+"+duration+",status=(case when status<2 then 2 else status end),progress=(case when progress=0 then 1 else progress end),last_time = '"+LocalDateTime.now()+"' where id=?1";
 		scDao.sqlUpdate(sql,studyId);
-		
 	}

+	@Override
+	@Transactional
+	public void newAppendStudyDuration(String studyId,String studyItemId,String courseContentId, int duration,LocalDateTime timestamp) {
+
+		//增加内容的学习时长
+		if(StringUtils.isNotBlank(studyItemId)) {
+			//直接根据id更新
+			String sql="Update boe_study_course_item set study_duration=study_duration+"+duration+",status=(case when status<2 then 2 else status end) where id=?1";
+			scItemDao.sqlUpdate(sql,studyItemId);
+
+		}else {
+			String sql="Update boe_study_course_item set study_duration=study_duration+"+duration+",status=(case when status<2 then 2 else status end) where study_id=?1 and content_id=?2";
+			scItemDao.sqlUpdate(sql,studyId,courseContentId);
+		}
+
+		String sql="Update boe_study_course set total_duration=total_duration+"+duration+",status=(case when status<2 then 2 else status end),progress=(case when progress=0 then 1 else progress end),last_time = '"+timestamp+"' where id=?1";
+		scDao.sqlUpdate(sql,studyId);
+	}
+
+	// 更新 前端传输已学习时长
+	@Override
+	public void updateStudyDuration(String studyId,String studyItemId,String courseContentId, Integer videoTime,String courseId) {
+
+		LocalDateTime now = LocalDateTime.now();
+		DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss");
+
+		String key = "studyId:" + studyId + ":courseId:" + courseId + ":courseContentId:" + courseContentId + ":studyItemId:" + studyItemId;
+		String currentValue = redisTemplate.opsForValue().get(key);
+		Integer lastDuration = 0;
+		Integer oldVideoTime = 0;
+		Integer sum = 10; // 原appendtime改为固定10秒调用一次接口
+		if (currentValue != null) {
+			String[] partValues = currentValue.split("&");
+			oldVideoTime = Integer.parseInt(partValues[0]);
+			lastDuration = Integer.parseInt(partValues[1]);
+			sum += lastDuration;
+			if(oldVideoTime > videoTime){
+				videoTime = oldVideoTime;// 取最大值最终入库
+			}
+		};
+
+		String value = videoTime + "&" + sum + "&" + now.format(formatter); // study_video_time & appendtime & time
+		log.info("-study-video-time-----value = " + value);
+
+		// 20250303 优化 多次更新改一次更新
+		// 更新Redis中的最后活跃时间（带30秒过期）
+		redisTemplate.opsForValue().set(
+				key,
+				value,
+				Duration.ofSeconds(2592000)
+		);
+		log.info("- 合并 updateStudyDuration -redis保存---value = " + value);
+//		Duration.ofDays(30)  也就是 2592000秒
+	}
+
+
 	@Override
 	@Transactional
 	public void appendStudyDuration(StudyTime st) {
@@ -165,7 +206,21 @@ public class StudyServiceImpl implements IStudyService{

 	@Override	
 	public List<StudyCourseItem> findByStudyId(String studyId) {
-		return scItemDao.findList(OrderCondition.desc("lastTime"),FieldFilters.eq("studyId", studyId));
+		List<StudyCourseItem> list = scItemDao.findList(OrderCondition.desc("lastTime"),FieldFilters.eq("studyId", studyId));
+		for (StudyCourseItem item : list){
+			log.info("-- studyIndex -查询上次学习的是什么资源。mysql查询---------------- item = " + item);
+			String redisKey = "studyId:" + studyId + ":courseId:" + item.getCourseId() + ":courseContentId:" + item.getContentId() + ":studyItemId:" + item.getId();
+			log.info("-- studyIndex -查询上次学习的是什么资源。查询用户的学习情况---------------- redisKey = " + redisKey);
+			String redisValue = redisTemplate.opsForValue().get(redisKey);
+			log.info("-- studyIndex -查询上次学习的是什么资源。查询用户的学习情况---------------- redisValue = " + redisValue);
+			if (redisValue != null) {
+				String[] values = redisValue.split("&");
+				int duration = Integer.parseInt(values[0]);
+				item.setLastStudyTime(duration);
+				log.info("-- studyIndex -----set 结果---------------- LastStudyTime = " + item.getLastStudyTime());
+			}
+		}
+		return list;
 	}

 	@Override
@@ -324,8 +379,26 @@ public class StudyServiceImpl implements IStudyService{

 	// 更新 前端传输已学习时长
 	@Override
-	@Transactional
 	public void updateLastTime(String studyContentId, int lastStudyTime,String aid) {
+		LocalDateTime now = LocalDateTime.now();
+		DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss");
+		String value = lastStudyTime + "&" + now.format(formatter); // 使用ISO8601时间格式
+		log.info("-study-video-time-----value = " + value);
+		// 20250303 优化 多次更新改一次更新
+		// 更新Redis中的最后活跃时间（带30秒过期）
+		redisTemplate.opsForValue().set(
+				"studyContentId:" + studyContentId + ":last_active",
+				value,
+				Duration.ofSeconds(2592000)
+		);
+		log.info("-study-video-time-redis保存---value = " + value);
+//		Duration.ofDays(30)  也就是 2592000秒
+	}
+
+	@Override
+	@Transactional
+	public void updateStudyCourseItemLastTime(String studyContentId, int lastStudyTime,LocalDateTime timestamp) {
+		log.info("-study-video-time-定时---studyContentId = " + studyContentId + ",lastStudyTime = " + lastStudyTime + ", timestamp = " + timestamp);
 		// 更新最后的学习时间点
 		LocalDateTime now=LocalDateTime.now();
 		UpdateBuilder update=UpdateBuilder.from(StudyCourseItem.class);
@@ -333,11 +406,12 @@ public class StudyServiceImpl implements IStudyService{
 		//只记录时间长的时候的处理
 		update.addFilter(FieldFilters.lt("lastStudyTime", lastStudyTime));
 		update.addUpdateField("lastStudyTime", lastStudyTime);
-		update.addUpdateField("lastTime", now);
+		update.addUpdateField("lastTime", timestamp==null ? now : timestamp);
 		scItemDao.update(update.builder());
-		//增加用户的学习时长,在api中调用
+		log.info("-study-video-time-mysql保存---studyContentId = " + studyContentId);
 	}

+
 	@Override
 	public Map<String,Object> getLast(String aid) {
 		//按lastTime排序，第一条,只是课件内容
--- a/servers/boe-server-all/src/main/java/com/xboe/school/vo/StudyTimeVo.java
+++ b/servers/boe-server-all/src/main/java/com/xboe/school/vo/StudyTimeVo.java
@@ -0,0 +1,19 @@
+package com.xboe.school.vo;
+
+import com.xboe.school.study.entity.StudyTime;
+import lombok.Data;
+
+/** appendtime 于 study-video-time 合并
+ *  appendtime 参数 StudyTime
+ *  study-video-time 参数 是 StudyTimeVo
+ */
+@Data
+public class StudyTimeVo extends StudyTime {
+
+    private String itemId;
+    private Integer videoTime;
+//    private String contentId; // 已继承
+//    private String courseId; // 已继承
+    private Float progressVideo;
+    private Integer type; // 0 study-video-time ,  1 appendtime
+}
--- a/servers/boe-server-all/src/main/resources/application-dev.yml
+++ b/servers/boe-server-all/src/main/resources/application-dev.yml
@@ -76,6 +76,9 @@ xboe:
    encryptor:
      algorithm: PBEWithMD5AndDES
      iv-generator-classname: org.jasypt.iv.NoIvGenerator
+  image:
+    course:
+      default: http://192.168.0.253/pc/images/bgimg/course.png
 xxl:
  job:
    accessToken: 65ddc683-22f5-83b4-de3a-3c97a0a29af0
--- a/servers/boe-server-all/src/main/resources/application-pre.yml
+++ b/servers/boe-server-all/src/main/resources/application-pre.yml
@@ -108,7 +108,9 @@ xboe:
    from: boeu_learning@boe.com.cn
    user:
    security:
-
+  image:
+    course:
+      default: http://10.251.132.75/pc/images/bgimg/course.png
 jasypt:
  encryptor:
    algorithm: PBEWithMD5AndDES
--- a/servers/boe-server-all/src/main/resources/application-prod.yml
+++ b/servers/boe-server-all/src/main/resources/application-prod.yml
@@ -74,6 +74,9 @@ xboe:
    encryptor:
      algorithm: PBEWithMD5AndDES
      iv-generator-classname: org.jasypt.iv.NoIvGenerator
+  image:
+    course:
+      default: https://u.boe.com/pc/images/bgimg/course.png
 xxl:
  job:
    accessToken: 65ddc683-22f5-83b4-de3a-3c97a0a29af0
--- a/servers/boe-server-all/src/main/resources/application-test.yml
+++ b/servers/boe-server-all/src/main/resources/application-test.yml
@@ -84,7 +84,7 @@ xboe:
    file:
      temp_path: /tmp
      save_path: /home/www/elearning/upload
-      http_path: http://10.251.186.27/upload
+      http_path: https://u-pre.boe.com/upload
  externalinterface:
    url:
      system: http://localhost:9091
@@ -108,7 +108,9 @@ xboe:
    from: boeu_learning@boe.com.cn
    user:
    security:
-
+  image:
+    course:
+      default: https://u-pre.boe.com/pc/images/bgimg/course.png
 jasypt:
  encryptor:
    algorithm: PBEWithMD5AndDES
--- a/servers/boe-server-all/src/main/resources/application.yml
+++ b/servers/boe-server-all/src/main/resources/application.yml
@@ -73,4 +73,5 @@ coursesuilt:
  updateOrSaveCourse: ${boe.domain}/manageApi/admin/teacherRecord/updateOrSaveCourse
  syncCourseStudent: ${boe.domain}/manageApi/admin/teacherRecord/syncCourseStudent
  syncOnLineScore: ${boe.domain}/manageApi/admin/teacherRecord/syncOnLineScore
-  updateOnLineStatua: ${boe.domain}/manageApi/admin/teacherRecord/updateOnLineStatua
+  updateOnLineStatua: ${boe.domain}/manageApi/admin/teacherRecord/updateOnLineStatua
+  delOnLineById: ${boe.domain}/manageApi/admin/teacherRecord/delOnLineById
Author	SHA1	Message	Date
670788339	5848f431a4	在线版本	2025-11-14 14:41:10 +08:00
670788339	d30853db33	标签创建移除旧版本部分代码	2025-11-14 09:59:27 +08:00
670788339	f4d5dd03df	排序调整	2025-11-12 08:55:25 +08:00
670788339	dcfb929aaf	id自增长	2025-11-10 18:30:43 +08:00
670788339	a50a29e33a	日志	2025-11-10 18:21:50 +08:00
670788339	10098e2e84	日志	2025-11-10 18:13:54 +08:00
670788339	16712cc020	标签提示	2025-11-10 17:51:29 +08:00
670788339	91cf87c8de	标签提示	2025-11-10 17:25:41 +08:00
670788339	2a3640b6e8	模糊查询	2025-11-08 15:39:37 +08:00
670788339	f5fc56c2d1	课程库热点标签排序	2025-11-08 15:22:59 +08:00
670788339	001106043c	标签查询排序调整	2025-11-07 11:25:22 +08:00
670788339	17999213cf	公共初始给个时间	2025-11-05 15:16:46 +08:00
670788339	9baa4c3595	存在私有也可创建	2025-11-05 14:27:00 +08:00
670788339	9119aa8579	存在私有也可创建	2025-11-05 14:23:03 +08:00
670788339	0b11c2ad9a	标签创建加判断	2025-11-05 14:02:33 +08:00
670788339	cb4eb1b1b6	标签	2025-11-05 13:34:56 +08:00
670788339	f9528a5705	恢复标签删除状态	2025-11-02 13:52:37 +08:00
670788339	28d84bd484	恢复标签删除状态	2025-11-02 13:35:19 +08:00
670788339	7f7279daa0	查询标签修改	2025-11-02 12:45:41 +08:00
670788339	99042619d2	查询标签修改	2025-11-02 10:30:02 +08:00
670788339	fb29e2b95c	查询标签修改	2025-11-01 17:27:09 +08:00
670788339	6bb4b6c4d5	课程详情页显示标签	2025-10-31 20:29:00 +08:00
670788339	264f31a69f	课程详情页显示标签	2025-10-31 20:08:17 +08:00
670788339	7f3b50b45c	课程查询tags调试	2025-10-31 15:30:50 +08:00
670788339	f315a94c81	课程查询tags	2025-10-31 15:08:45 +08:00
670788339	beeb3688a1	课程查询tags	2025-10-31 14:48:52 +08:00
670788339	5cffd908f5	课程查询tags	2025-10-31 13:53:05 +08:00
670788339	4d0f311bea	注释多余代码提交审核时创建标签	2025-10-31 10:41:51 +08:00
670788339	0979d26160	提审加日志	2025-10-31 09:37:25 +08:00
670788339	ddd8875b11	查询标签加日志	2025-10-30 20:20:10 +08:00
670788339	d5a1d65769	查询标签加日志	2025-10-30 19:55:40 +08:00
670788339	612410e863	合并标签	2025-10-30 18:37:50 +08:00
670788339	11628b35e2	合并标签	2025-10-30 18:18:54 +08:00
670788339	f799b6065e	合并标签	2025-10-30 18:06:14 +08:00
670788339	61e753e6db	合并标签	2025-10-30 17:59:01 +08:00
670788339	841aa47b4a	标签加status	2025-10-30 16:08:51 +08:00
670788339	2527e081d9	创建标签添加日志	2025-10-30 14:34:41 +08:00
670788339	9c529a061e	创建标签	2025-10-30 14:01:37 +08:00
670788339	15e0cedf74	创建标签	2025-10-30 13:23:51 +08:00
670788339	46fefd3fe0	searchTags调试	2025-10-29 17:20:18 +08:00
670788339	448bc0f1e4	searchTags调整	2025-10-29 16:29:15 +08:00
670788339	5d3745680a	searchTags调整	2025-10-29 16:17:58 +08:00
670788339	c7c92a3173	searchTags调整	2025-10-29 15:58:01 +08:00
670788339	0819502afa	searchTags调整	2025-10-29 15:40:58 +08:00
王卓煜	8c02b77724	标签管理解绑标签	2025-09-16 13:51:52 +08:00
王卓煜	e7036e04b0	修复标签管理三级分类搜索不到标签	2025-09-12 11:13:31 +08:00
王卓煜	95d1b90717	修复标签管理课程类型展示对应的标签	2025-09-12 10:07:37 +08:00
王卓煜	4d320ea855	修复缺少tags属性	2025-09-02 13:34:57 +08:00
王卓煜	acb58cf9d6	修复标签不开启公共化	2025-08-27 17:03:37 +08:00
王卓煜	6a04e5d58c	修复标签模块查询不显示以及新建标签	2025-08-22 15:11:14 +08:00
王卓煜	0e60251121	修复目前先按照精准匹配的逻辑，未来将开放语义匹配（向量搜索）等高级搜索功能。	2025-08-21 13:32:21 +08:00
王卓煜	9588235f87	修复前台热点标签10个位置，从热点池中选取前10，筛选和排序规则：1）手动标记热点的标签按标记时间倒序排列 2）关联课程数量>4门的标签，按关联课程数量多少倒序排列。如1）和2）合计不足10个，则前台根据实际数量显示。	2025-08-21 09:36:49 +08:00
王卓煜	7074255e94	修复管理端在线课程添加标签没有传递数据	2025-08-20 17:40:50 +08:00
王卓煜	f821112715	修复管理端在线课程添加标签没有传递数据	2025-08-20 17:26:25 +08:00
王卓煜	41649aa32d	修复管理端在线课程添加标签没有传递数据	2025-08-20 17:22:08 +08:00
王卓煜	6dc4e36222	修复当同一标签被3个及以上课管创建时，默认开启这个标签的公共化，同时标签管理员也可以手动关闭	2025-08-20 14:44:31 +08:00
zhengsongbo	5aba4ef45f	zhengsongbo:标签管理第一次提测 on 2025-08-02	2025-08-02 12:48:57 +08:00
joshen	618b0b3f62	Merge remote-tracking branch 'yx/master-20250414-lyc' into release-20250328-master	2025-05-13 15:37:05 +08:00
670788339	5836b147c4	在线删除同步授课记录	2025-04-29 15:58:37 +08:00
670788339	fb1d11ebab	取消lastStudyTime更新条件	2025-04-21 15:18:48 +08:00
670788339	add1d6abb2	取消lastStudyTime更新条件	2025-04-21 13:59:06 +08:00
670788339	eafe17b99a	studyindex 日志	2025-04-21 13:46:55 +08:00
670788339	d1b6573c25	studyindex调试	2025-04-21 11:40:22 +08:00
670788339	1039f80aec	调试	2025-04-18 11:15:36 +08:00
670788339	efc0605115	调试	2025-04-18 11:05:18 +08:00
670788339	d938425151	日志	2025-04-18 10:54:36 +08:00
670788339	00510562ca	日志	2025-04-18 10:40:50 +08:00
670788339	3e70e71e5a	合并影响的其他接口	2025-04-18 10:19:06 +08:00
670788339	24011a4470	合并影响的其他接口	2025-04-18 10:06:53 +08:00
670788339	8948165296	合并影响的其他接口	2025-04-18 09:49:59 +08:00
670788339	076b1828ad	合并	2025-04-18 09:16:47 +08:00
670788339	95312696f6	studyindex缓存获取duration	2025-04-17 13:36:30 +08:00
670788339	1aca002b8f	合并测试	2025-04-14 16:10:18 +08:00
670788339	50bdc39ce8	appendtime 于 study-video-time 合并	2025-04-14 14:08:01 +08:00
joshen	4fff780970	Merge branch '250408-bugfix-shl' into release-20250328-master # Conflicts: # servers/boe-server-all/src/main/java/com/xboe/module/course/service/ICourseService.java	2025-04-09 18:16:07 +08:00
sunhonglai	47813ea565	增加面授课删除	2025-04-08 17:43:37 +08:00
670788339	5aa62de3cb	@Transient	2025-04-03 09:09:58 +08:00
joshen	a309bc1ddf	Merge branch '250331-bugfix-shl-newmaster' into release-20250328-master	2025-04-02 16:57:24 +08:00
sunhonglai	6af4cdfc75	修改测试环境配置	2025-04-01 13:52:20 +08:00
sunhonglai	2a2759768b	修改个人中心我的报名图片不显示问题	2025-04-01 12:42:32 +08:00
sunhonglai	74bcec72bc	修改学习时长取值	2025-04-01 09:59:59 +08:00
sunhonglai	b8c171bf86	Merge branch '250331-bugfix-shl-newmaster' into 250331-bugfix-shl # Conflicts: # servers/boe-server-all/src/main/java/com/xboe/school/study/service/impl/StudyServiceImpl.java	2025-04-01 09:51:14 +08:00
sunhonglai	175e7f6c28	查询课程和修改课程学习上报进度，增加视频播放进度的处理	2025-04-01 08:32:41 +08:00
sunhonglai	5705bb8529	查询课程和修改课程学习上报进度，增加视频播放进度的处理	2025-03-31 13:14:14 +08:00
sunhonglai	87e5dd81f8	查询课程和修改课程学习上报进度，增加视频播放进度的处理	2025-03-31 11:27:13 +08:00
joshen	9924769bc8	Merge remote-tracking branch 'yx/master-20250227-lyc' into release-20250328-master	2025-03-29 12:38:10 +08:00
670788339	d4964ca7f1	日志	2025-03-29 12:22:11 +08:00
670788339	efdfa6f00c	study-video-time 最后修改时间调整	2025-03-29 10:51:08 +08:00
joshen	ceb30f7f1d	Merge remote-tracking branch 'yx/master-20250227-lyc' into release-20250328-master # Conflicts: # servers/boe-server-all/src/main/java/com/xboe/module/course/entity/CourseTeacher.java # servers/boe-server-all/src/main/java/com/xboe/school/study/api/StudyCourseApi.java	2025-03-28 15:32:27 +08:00
joshen	60d891edcf	Merge remote-tracking branch 'yx/250324-casebugfix-zsh'	2025-03-26 16:54:25 +08:00
emcchui	b9f00f2602	SZX-927：学员端-个人设置-手机号未同步到	2025-03-25 08:47:19 +08:00
emcchui	77884d3e7e	SZX-927：学员端-个人设置-手机号未同步到	2025-03-25 08:39:48 +08:00
emcchui	3a9a8d86af	SZX-927：学员端-个人设置-手机号未同步到	2025-03-24 18:10:41 +08:00
emcchui	3a139925c9	SZX-927：学员端-个人设置-手机号未同步到	2025-03-24 17:41:22 +08:00
emcchui	fdc0c7959e	SZX-927：学员端-个人设置-手机号未同步到	2025-03-24 16:27:50 +08:00
670788339	500fb090fb	在线课-外部讲师报错添加讲师类型	2025-03-19 13:17:06 +08:00
670788339	ee95435d01	在线课-外部讲师报错添加供应商	2025-03-19 13:08:54 +08:00
670788339	76f0d1933a	在线课-外部讲师报错	2025-03-19 11:56:48 +08:00
670788339	58d6f49006	考试提交调用加catch	2025-03-13 10:03:21 +08:00
670788339	c8ffdd561f	考试提交调用course项目同步	2025-03-10 16:03:10 +08:00
670788339	98611edcaa	考试提交调用course项目同步	2025-03-10 16:02:19 +08:00
670788339	8aea21bde7	参数转换	2025-03-10 14:32:21 +08:00
670788339	a79f6b43b2	日志	2025-03-10 14:22:03 +08:00
670788339	81ea19f0f3	study-video-time redis优化	2025-03-03 17:49:49 +08:00