From 15e0cedf74415c64d5e8979591934bb78c7c4665 Mon Sep 17 00:00:00 2001 From: 670788339 <670788339@qq.com> Date: Thu, 30 Oct 2025 13:23:51 +0800 Subject: [PATCH] =?UTF-8?q?=E5=88=9B=E5=BB=BA=E6=A0=87=E7=AD=BE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../course/service/ICourseTagService.java | 3 + .../service/impl/CourseTagServiceImpl.java | 438 +++++++++++++++++- 2 files changed, 431 insertions(+), 10 deletions(-) diff --git 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 index 41e0abbd..adbe7b3b 100644 --- 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 @@ -8,6 +8,7 @@ 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; @@ -89,4 +90,6 @@ public interface ICourseTagService { List getTagsByIds(String id); CourseTag getTagByName(String tagName); + + void updateTags(Course oldCourse,Course newCourse,CurrentUser userInfo); } diff --git 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 index 543e54ca..d5877ee9 100644 --- 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 @@ -2,6 +2,8 @@ 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; @@ -23,6 +25,7 @@ import org.springframework.transaction.annotation.Transactional; import javax.annotation.Resource; import java.time.LocalDateTime; import java.util.*; +import java.util.stream.Collectors; /** * @ClassName:CourseTagServiceImpl @@ -56,17 +59,38 @@ public class CourseTagServiceImpl implements ICourseTagService { */ @Override public PageList query(Integer pageIndex, Integer pageSize, List filters, OrderCondition order) { - 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")); + 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); } - return courseTagDao.findPage(query.builder()); } /** @@ -345,4 +369,398 @@ public class CourseTagServiceImpl implements ICourseTagService { } return isExist; } + + + + + @Override + public void updateTags(Course oldCourse, Course newCourse, CurrentUser userInfo) { + log.info(" --- 标签修改 --- 在线课参数 oldCourse = " + oldCourse); + log.info(" --- 标签修改 --- 在线课参数 newCourse = " + newCourse); + log.info(" --- 标签修改 --- 用户信息 userInfo = " + userInfo); + + // 获取新旧课程的标签ID列表 + List oldTagIds = getTagIdsFromCourse(oldCourse); + List newTagIds = getTagIdsFromCourse(newCourse); + + if (oldCourse == null) { + // 新增课程 - 处理所有新标签 + handleNewCourseTags(newCourse, newTagIds, userInfo); + } else { + // 编辑课程 - 比较差异并处理 + handleEditCourseTags(oldCourse, newCourse, oldTagIds, newTagIds, userInfo); + } + } + + /** + * 从课程对象中提取标签ID列表 + */ + private List 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 newTagIds, CurrentUser userInfo) { + 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; + } + + // 创建课程-标签关联关系 + createCourseTagRelation(courseId, tag, userInfo); + + // 创建分类-标签关联关系 + createCourseTypeTagRelations(newCourse, tag, userInfo); + + // 更新标签使用计数并检查是否设置为公共标签 + updateTagUseCountAndPublicStatus(tag, userInfo); + } + } + + /** + * 处理编辑课程的标签逻辑 + */ + private void handleEditCourseTags(Course oldCourse, Course newCourse, + List oldTagIds, List newTagIds, CurrentUser userInfo) { + String courseId = newCourse.getId(); + + // 找出需要删除的标签（存在于旧课程但不在新课程中） + List tagsToRemove = oldTagIds.stream() + .filter(tagId -> !newTagIds.contains(tagId)) + .collect(Collectors.toList()); + + // 找出需要新增的标签（存在于新课程但不在旧课程中） + List 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; + } + + // 创建课程-标签关联关系 + createCourseTagRelation(courseId, tag, userInfo); + + // 创建分类-标签关联关系 + createCourseTypeTagRelations(newCourse, tag, userInfo); + + // 更新标签使用计数并检查是否设置为公共标签 + updateTagUseCountAndPublicStatus(tag, userInfo); + } + + // 处理分类变化导致的标签关联关系更新 + if (hasCourseTypeChanged(oldCourse, newCourse)) { + updateCourseTypeTagRelations(oldCourse, newCourse, newTagIds, userInfo); + } + } + + /** + * 创建课程-标签关联关系 + */ + private void createCourseTagRelation(String courseId, CourseTag tag, CurrentUser userInfo) { + // 检查是否已存在关联关系 + QueryBuilder query = QueryBuilder.from(CourseTagRelation.class); + List filters = new ArrayList<>(); + filters.add(FieldFilters.eq("courseId", Long.valueOf(courseId))); + filters.add(FieldFilters.eq("tagId", Long.valueOf(tag.getId()))); + query.addFilters(filters); + + List 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.getNickName()); + relation.setSysCreateTime(now); + + // 设置更新信息 + relation.setSysUpdateBy(userInfo.getNickName()); + relation.setSysUpdateTime(now); + + courseTagRelationDao.save(relation); + } else { + // 恢复已删除的关联关系 + CourseTagRelation relation = existingRelations.get(0); + if (relation.getDeleted()) { + relation.setDeleted(false); + + // 设置更新信息 + relation.setSysUpdateBy(userInfo.getNickName()); + relation.setSysUpdateTime(now); + + courseTagRelationDao.saveOrUpdate(relation); + } + } + } + + /** + * 创建分类-标签关联关系 + */ + private void createCourseTypeTagRelations(Course course, CourseTag tag, CurrentUser userInfo) { + String sysType1 = course.getSysType1(); + String sysType2 = course.getSysType2(); + String sysType3 = course.getSysType3(); + + // 根据分类级别创建相应的关联关系 + if (StringUtils.isNotBlank(sysType1)) { + createSingleCourseTypeTagRelation(sysType1, "0", "0", tag.getId(), userInfo); + } + + if (StringUtils.isNotBlank(sysType2)) { + createSingleCourseTypeTagRelation(sysType1, sysType2, "0", tag.getId(), userInfo); + } + + if (StringUtils.isNotBlank(sysType3)) { + createSingleCourseTypeTagRelation(sysType1, sysType2, sysType3, tag.getId(), userInfo); + } + } + + /** + * 创建单个分类-标签关联关系 + */ + private void createSingleCourseTypeTagRelation(String sysType1, String sysType2, String sysType3, + String tagId, CurrentUser userInfo) { + // 检查是否已存在关联关系 + QueryBuilder query = QueryBuilder.from(CourseTypeTagRelation.class); + List 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)); + query.addFilters(filters); + + List 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.getNickName()); + relation.setSysCreateTime(now); + + // 设置更新信息 + relation.setSysUpdateBy(userInfo.getNickName()); + relation.setSysUpdateTime(now); + + courseTypeTagRelationDao.save(relation); + } else { + // 恢复已删除的关联关系 + CourseTypeTagRelation relation = existingRelations.get(0); + if (relation.getDeleted()) { + relation.setDeleted(false); + + // 设置更新信息 + relation.setSysUpdateBy(userInfo.getNickName()); + relation.setSysUpdateTime(now); + + courseTypeTagRelationDao.saveOrUpdate(relation); + } + } + } + + /** + * 移除课程-标签关联关系 + */ + private void removeCourseTagRelation(String courseId, String tagId, CurrentUser userInfo) { + // 查找关联关系 + QueryBuilder query = QueryBuilder.from(CourseTagRelation.class); + List filters = new ArrayList<>(); + filters.add(FieldFilters.eq("courseId", Long.valueOf(courseId))); + filters.add(FieldFilters.eq("tagId", Long.valueOf(tagId))); + query.addFilters(filters); + + List relations = courseTagRelationDao.findList(query.builder()); + + if (!relations.isEmpty()) { + CourseTagRelation relation = relations.get(0); + + // 设置更新信息 + relation.setSysUpdateBy(userInfo.getNickName()); + 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.getNickName()); + tag.setSysUpdateTime(LocalDateTime.now()); + + courseTagDao.update(tag); + } + + // 检查是否需要删除分类-标签关联关系 + checkAndRemoveCourseTypeTagRelation(tagId, userInfo); + } + } + + /** + * 检查并删除分类-标签关联关系（如果没有其他课程使用） + */ + private void checkAndRemoveCourseTypeTagRelation(String tagId, CurrentUser userInfo) { + // 检查是否还有其他课程使用这个标签 + QueryBuilder query = QueryBuilder.from(CourseTagRelation.class); + List filters = new ArrayList<>(); + filters.add(FieldFilters.eq("tagId", Long.valueOf(tagId))); + filters.add(FieldFilters.eq("deleted", false)); + query.addFilters(filters); + + List activeRelations = courseTagRelationDao.findList(query.builder()); + + // 如果没有其他活跃的关联关系，删除分类-标签关联 + if (activeRelations.isEmpty()) { + QueryBuilder typeQuery = QueryBuilder.from(CourseTypeTagRelation.class); + List typeFilters = new ArrayList<>(); + typeFilters.add(FieldFilters.eq("tagId", tagId)); + typeQuery.addFilters(typeFilters); + + List typeRelations = courseTypeTagRelationDao.findList(typeQuery.builder()); + + LocalDateTime now = LocalDateTime.now(); + + for (CourseTypeTagRelation relation : typeRelations) { + // 设置更新信息 + relation.setSysUpdateBy(userInfo.getNickName()); + relation.setSysUpdateTime(now); + + courseTypeTagRelationDao.setDeleted(relation.getId()); + } + } + } + + /** + * 更新标签使用计数并检查公共标签状态 + */ + private void updateTagUseCountAndPublicStatus(CourseTag tag, CurrentUser userInfo) { + // 统计当前活跃的关联关系数量 + QueryBuilder query = QueryBuilder.from(CourseTagRelation.class); + List filters = new ArrayList<>(); + filters.add(FieldFilters.eq("tagId", Long.valueOf(tag.getId()))); + filters.add(FieldFilters.eq("deleted", false)); + query.addFilters(filters); + + List 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.getNickName()); + tag.setSysUpdateTime(now); + + courseTagDao.update(tag); + } + + /** + * 检查课程分类是否发生变化 + */ + 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 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.getNickName()); + entity.setSysCreateTime(now); + entity.setSysUpdateBy(userInfo.getNickName()); + entity.setSysUpdateTime(now); + } + + /** + * 设置实体的更新信息（编辑时使用） + */ + private void setUpdateInfo(BaseEntity entity, CurrentUser userInfo) { + entity.setSysUpdateBy(userInfo.getNickName()); + entity.setSysUpdateTime(LocalDateTime.now()); + } + + + }