创建标签

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<CourseTag> getTagsByIds(String id);
 
     CourseTag getTagByName(String tagName);
+
+    void updateTags(Course oldCourse,Course newCourse,CurrentUser userInfo);
 }

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<CourseTag> query(Integer pageIndex, Integer pageSize, List<IFieldFilter> filters, OrderCondition order) {
-        QueryBuilder query=QueryBuilder.from(CourseTag.class);
+        try {
-        query.setPageIndex(pageIndex);
+          /*  QueryBuilder query=QueryBuilder.from(CourseTag.class);
-        query.setPageSize(pageSize);
+            query.setPageIndex(pageIndex);
-        filters.add(FieldFilters.eq("deleted",false));
+            query.setPageSize(pageSize);
-        query.addFilters(filters);
+            filters.add(FieldFilters.eq("deleted",false));
-        if(order!=null) {
+            query.addFilters(filters);
-            query.addOrder(order);
+            if(order!=null) {
-        }else {
+                query.addOrder(order);
-            query.addOrder(OrderCondition.desc("sysCreateTime"));
+            }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<String> oldTagIds = getTagIdsFromCourse(oldCourse);
+        List<String> newTagIds = getTagIdsFromCourse(newCourse);
+
+        if (oldCourse == null) {
+            // 新增课程 - 处理所有新标签
+            handleNewCourseTags(newCourse, newTagIds, userInfo);
+        } else {
+            // 编辑课程 - 比较差异并处理
+            handleEditCourseTags(oldCourse, newCourse, oldTagIds, newTagIds, userInfo);
+        }
+    }
+
+    /**
+     * 从课程对象中提取标签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) {
+        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<String> oldTagIds, List<String> newTagIds, CurrentUser userInfo) {
+        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;
+            }
+
+            // 创建课程-标签关联关系
+            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<IFieldFilter> filters = new ArrayList<>();
+        filters.add(FieldFilters.eq("courseId", Long.valueOf(courseId)));
+        filters.add(FieldFilters.eq("tagId", Long.valueOf(tag.getId())));
+        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.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<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));
+        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.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<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.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<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.getNickName());
+                relation.setSysUpdateTime(now);
+
+                courseTypeTagRelationDao.setDeleted(relation.getId());
+            }
+        }
+    }
+
+    /**
+     * 更新标签使用计数并检查公共标签状态
+     */
+    private void updateTagUseCountAndPublicStatus(CourseTag tag, CurrentUser userInfo) {
+        // 统计当前活跃的关联关系数量
+        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.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<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.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());
+    }
+
+
+
 }