Merge branch 'merge-20251113-tag' into release-20250328-master

# Conflicts:
#	servers/boe-server-all/src/main/java/com/xboe/module/course/api/CourseManageApi.java
#	servers/boe-server-all/src/main/java/com/xboe/module/course/service/impl/CourseServiceImpl.java

servers/boe-server-all/pom.xml

@@ -171,6 +171,11 @@
             <artifactId>javax.mail-api</artifactId>
             <version>1.5.6</version>
         </dependency>
+<!--        <dependency>-->
+<!--            <groupId>com.sun.mail</groupId>-->
+<!--            <artifactId>javax.mail</artifactId>-->
+<!--            <version>1.5.6</version>-->
+<!--        </dependency>-->
 
         <dependency>
             <groupId>org.apache.commons</groupId>

servers/boe-server-all/src/main/java/com/xboe/api/ThirdApi.java

@@ -45,10 +45,7 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletRequest;
 import java.io.UnsupportedEncodingException;
 import java.net.URLEncoder;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.Optional;
+import java.util.*;
 import java.util.concurrent.ForkJoinPool;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
@@ -407,4 +404,20 @@ public class ThirdApi {
                         .body()).orElseThrow(() -> new RuntimeException("token校验失败"));
         log.info("-------delOnLineById = " + resp);
     }
+
+    //获取字典信息
+    public List<Dict> getDictItems(CommonSearchVo searcher) {
+        try {
+            List<Dict> dictList = dictRemoteClient.getList(searcher);
+            if(!Objects.isNull(dictList) && dictList.size() > 0){
+//               List<String> dicts =  dictList.stream().map(Dict::getValue).collect(Collectors.toList());
+               return dictList;
+            }else {
+               return null;
+            }
+        } catch (Exception e) {
+            log.error("-------获取字典信息 = " + e.getMessage());
+        }
+        return null;
+    }
 }

servers/boe-server-all/src/main/java/com/xboe/config/ElasticSearchIndexInitializer.java

@@ -0,0 +1,36 @@
+package com.xboe.config;
+
+import com.xboe.module.boecase.service.IElasticSearchIndexService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.context.event.ApplicationReadyEvent;
+import org.springframework.context.event.EventListener;
+import org.springframework.stereotype.Component;
+
+/**
+ * ElasticSearch索引初始化器
+ * 在Spring Boot启动完成并监听到配置文件加载完毕后，检查并创建所需的ES索引
+ * 
+ * @author AI Assistant
+ */
+@Slf4j
+@Component
+public class ElasticSearchIndexInitializer {
+    
+    @Autowired
+    private IElasticSearchIndexService elasticSearchIndexService;
+    
+    /**
+     * 监听Spring Boot应用启动完成事件
+     * ApplicationReadyEvent在应用启动完成、所有配置加载完毕后触发
+     */
+    @EventListener(ApplicationReadyEvent.class)
+    public void initializeElasticSearchIndices() {
+        if (elasticSearchIndexService.checkIndexExists()) {
+            log.info("ElasticSearch索引 ai_chat_messages 已存在");
+        } else {
+            log.info("ElasticSearch索引 ai_chat_messages 不存在，开始创建...");
+            elasticSearchIndexService.createIndex();
+        }
+    }
+}

servers/boe-server-all/src/main/java/com/xboe/config/ThreadPoolConfig.java

@@ -0,0 +1,72 @@
+package com.xboe.config;
+
+import lombok.extern.slf4j.Slf4j;
+import okhttp3.Dispatcher;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
+
+import java.util.concurrent.ThreadPoolExecutor;
+
+/**
+ * 线程池配置类
+ */
+@Configuration
+@Slf4j
+public class ThreadPoolConfig {
+
+    /**
+     * 执行AI文档接口的的线程池
+     * 策略：单线程等待队列
+     */
+    @Bean(name = "aiDocExecutor")
+    public ThreadPoolTaskExecutor aiDocExecutor() {
+        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
+        // 设置核心线程数
+        int corePoolSize = Runtime.getRuntime().availableProcessors();
+        executor.setCorePoolSize(Math.max(4, corePoolSize));
+        // 设置最大线程数
+        executor.setMaxPoolSize(Math.max(16, corePoolSize * 2));
+        // 设置队列容量（确保任务排队）
+        executor.setQueueCapacity(100);
+        // keepalive
+        executor.setKeepAliveSeconds(30);
+        executor.setWaitForTasksToCompleteOnShutdown(true);
+        executor.setAwaitTerminationSeconds(30);
+        // 设置线程名称前缀
+        executor.setThreadNamePrefix("ai_doc_task-");
+        // 设置拒绝策略（当队列满时，由调用线程处理该任务）
+        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
+        // 初始化线程池
+        executor.initialize();
+        log.info("AI文档线程池初始化完成 - 核心线程: {}, 最大线程: {}, 队列容量: {}",
+                executor.getCorePoolSize(),
+                executor.getMaxPoolSize(),
+                executor.getQueueCapacity());
+        return executor;
+    }
+
+    /**
+     * event-stream线程池
+     * @return
+     */
+    @Bean(name = "eventStreamExecutor")
+    public ThreadPoolTaskExecutor eventStreamExecutor() {
+        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
+        executor.setCorePoolSize(10);
+        executor.setMaxPoolSize(500);
+        executor.setQueueCapacity(10);
+        executor.setThreadNamePrefix("event-stream-");
+        executor.setKeepAliveSeconds(300);
+        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
+        executor.setWaitForTasksToCompleteOnShutdown(true);
+        executor.initialize();
+        return executor;
+    }
+
+    @Bean(name = "customDispatcher")
+    public Dispatcher customDispatcher(@Qualifier("eventStreamExecutor") ThreadPoolTaskExecutor eventStreamExecutor) {
+        return new Dispatcher(eventStreamExecutor.getThreadPoolExecutor());
+    }
+}

servers/boe-server-all/src/main/java/com/xboe/constants/CaseAiConstants.java

@@ -0,0 +1,10 @@
+package com.xboe.constants;
+
+public class CaseAiConstants {
+
+    public static final String CASE_AI_INDEX_NAME = "ai_chat_messages";
+
+    public static final String CASE_DOC_UPLOAD_INTERFACE_NAME = "文档上传";
+
+    public static final String CASE_DOC_DELETE_INTERFACE_NAME = "文档删除";
+}

servers/boe-server-all/src/main/java/com/xboe/enums/CaseAiChatStatusEnum.java

@@ -0,0 +1,41 @@
+package com.xboe.enums;
+
+public enum CaseAiChatStatusEnum {
+
+    REFERS(0, "引用文档"),
+
+    CHAT(1, "聊天中"),
+
+    CHAT_COMPLETED(2, "聊天完成"),
+
+    SUGGESTIONS(3, "建议"),
+
+    API_COMPLETED(4, "接口完成"),
+    ;
+
+    private final int code;
+
+    private final String label;
+
+    CaseAiChatStatusEnum(int code, String label) {
+        this.code = code;
+        this.label = label;
+    }
+
+    public static CaseAiChatStatusEnum getByCode(int code) {
+        for (CaseAiChatStatusEnum value : values()) {
+            if (value.code == code) {
+                return value;
+            }
+        }
+        return API_COMPLETED;
+    }
+
+    public int getCode() {
+        return code;
+    }
+
+    public String getLabel() {
+        return label;
+    }
+}

servers/boe-server-all/src/main/java/com/xboe/enums/CaseDocumentLogRunStatusEnum.java

@@ -0,0 +1,50 @@
+package com.xboe.enums;
+
+/**
+ * AI调用日志接口运行状态枚举
+ */
+public enum CaseDocumentLogRunStatusEnum {
+
+    RUNNING(0, "运行中"),
+    COMPLETED(1, "运行完成");
+
+    private final Integer code;
+    private final String desc;
+
+    CaseDocumentLogRunStatusEnum(Integer code, String desc) {
+        this.code = code;
+        this.desc = desc;
+    }
+
+    public Integer getCode() {
+        return code;
+    }
+
+    public String getDesc() {
+        return desc;
+    }
+
+    /**
+     * 根据code获取描述
+     */
+    public static String getDescByCode(Integer code) {
+        for (CaseDocumentLogRunStatusEnum statusEnum : values()) {
+            if (statusEnum.getCode().equals(code)) {
+                return statusEnum.getDesc();
+            }
+        }
+        return "";
+    }
+
+    /**
+     * 根据code获取枚举
+     */
+    public static CaseDocumentLogRunStatusEnum getByCode(Integer code) {
+        for (CaseDocumentLogRunStatusEnum statusEnum : values()) {
+            if (statusEnum.getCode().equals(code)) {
+                return statusEnum;
+            }
+        }
+        return null;
+    }
+}

servers/boe-server-all/src/main/java/com/xboe/module/assistance/service/ISmtpEmailService.java

@@ -0,0 +1,17 @@
+package com.xboe.module.assistance.service;
+
+/**
+ * SMTP邮件服务接口
+ */
+public interface ISmtpEmailService {
+    
+    /**
+     * 使用SMTP直接发送邮件
+     * @param to 收件人邮箱
+     * @param subject 邮件主题
+     * @param htmlMsg 邮件内容（HTML格式）
+     * @param from 发件人邮箱
+     * @throws Exception 发送异常
+     */
+    void sendMailBySmtp(String to, String subject, String htmlMsg, String from) throws Exception;
+}

servers/boe-server-all/src/main/java/com/xboe/module/assistance/service/impl/SmtpEmailServiceImpl.java

@@ -0,0 +1,101 @@
+package com.xboe.module.assistance.service.impl;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Properties;
+
+import javax.mail.Authenticator;
+import javax.mail.Message;
+import javax.mail.MessagingException;
+import javax.mail.PasswordAuthentication;
+import javax.mail.Session;
+import javax.mail.Transport;
+import javax.mail.internet.InternetAddress;
+import javax.mail.internet.MimeMessage;
+
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+
+import com.xboe.module.assistance.service.ISmtpEmailService;
+
+@Service
+@Slf4j
+public class SmtpEmailServiceImpl implements ISmtpEmailService {
+
+    //region 默认SMTP服务器配置信息
+    private static final String SMTP_HOST = "mail.boe.com.cn";
+    private static final String SMTP_USERNAME = "boeu_learning@boe.com.cn";
+    private static final String SMTP_PASSWORD = "boeLms20251112Syse";
+    private static final String SMTP_PORT = "465";
+    private static final String SMTP_ENCRYPTION = "ssl";
+    //endregion
+
+    @Override
+    public void sendMailBySmtp(String to, String subject, String htmlMsg, String from) throws Exception {
+        // 检查参数
+        if (StringUtils.isBlank(to)) {
+            throw new Exception("发送邮件失败，未指定收件人");
+        }
+        
+        if (StringUtils.isBlank(subject)) {
+            throw new Exception("发送邮件失败，未指定邮件主题");
+        }
+        
+        if (StringUtils.isBlank(htmlMsg)) {
+            throw new Exception("发送邮件失败，未指定邮件内容");
+        }
+        // 初始化配置项
+
+        // 设置SMTP属性
+        Properties props = new Properties();
+        props.put("mail.smtp.host", SMTP_HOST);
+        props.put("mail.smtp.port", SMTP_PORT);
+        props.put("mail.smtp.auth", "true");
+
+        if ("ssl".equalsIgnoreCase(SMTP_ENCRYPTION)) {
+            props.put("mail.smtp.ssl.enable", "true");
+            props.put("mail.smtp.ssl.trust", SMTP_HOST);
+//            props.put("mail.smtp.ssl.protocols", "TLSv1.2");
+        } else if ("tls".equalsIgnoreCase(SMTP_ENCRYPTION)) {
+            props.put("mail.smtp.starttls.enable", "true");
+        }
+
+        Authenticator authenticator = new Authenticator() {
+            @Override
+            protected PasswordAuthentication getPasswordAuthentication() {
+                return new PasswordAuthentication(SMTP_USERNAME, SMTP_PASSWORD);
+            }
+        };
+        // 创建会话
+        Session session = Session.getInstance(props, authenticator);
+        session.setDebug(true); // 查看调试信息
+
+        try {
+            // 创建邮件消息
+            Message message = new MimeMessage(session);
+            
+            // 设置发件人
+            message.setFrom(new InternetAddress(SMTP_USERNAME));
+            
+            // 设置收件人
+            message.setRecipients(Message.RecipientType.TO, InternetAddress.parse(to));
+            
+            // 设置邮件主题
+            message.setSubject(subject);
+            
+            // 设置邮件内容
+            message.setContent(htmlMsg, "text/html;charset=UTF-8");
+
+            // 发送日期
+            message.setSentDate(new Date());
+            
+            // 发送邮件
+            log.info("发送邮件. 发件人: {}, 收件人: {}, 标题: {}", SMTP_USERNAME, to, subject);
+            Transport.send(message);
+            
+        } catch (MessagingException e) {
+            throw new Exception("发送邮件失败", e);
+        }
+    }
+}

servers/boe-server-all/src/main/java/com/xboe/module/boecase/api/CaseAiChatApi.java

@@ -3,8 +3,13 @@ package com.xboe.module.boecase.api;
 import com.xboe.core.api.ApiBaseController;
 import com.xboe.core.JsonResponse;
 import com.xboe.module.boecase.dto.CaseAiChatDto;
+import com.xboe.module.boecase.entity.AiChatConversationData;
 import com.xboe.module.boecase.service.ICaseAiChatService;
+import com.xboe.module.boecase.service.ICaseAiPermissionService;
+import com.xboe.module.boecase.service.IElasticSearchIndexService;
 import com.xboe.module.boecase.vo.CaseAiMessageVo;
+import com.xboe.module.excel.ExportsExcelSenderUtil;
+import lombok.Data;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.MediaType;
@@ -12,7 +17,12 @@ import org.springframework.web.bind.annotation.*;
 import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
 
 import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
 import java.nio.charset.StandardCharsets;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
 import java.util.List;
 
 /**
@@ -31,6 +41,12 @@ public class CaseAiChatApi extends ApiBaseController {
      */
     @Autowired
     private ICaseAiChatService caseAiChatService;
+    
+    @Autowired
+    private ICaseAiPermissionService caseAiPermissionService;
+
+    @Autowired
+    private IElasticSearchIndexService elasticSearchIndexService;
 
     /**
      * 聊天
@@ -63,4 +79,108 @@ public class CaseAiChatApi extends ApiBaseController {
             return error("查询失败", e.getMessage());
         }
     }
-}
+    
+    /**
+     * 导出会话记录为Excel
+     * @param startTime 开始时间
+     * @param endTime 结束时间
+     * @param response HTTP响应
+     */
+    @GetMapping("/export-conversations")
+    public void downloadConversationExcel(@RequestParam String startTime, 
+                                          @RequestParam String endTime, 
+                                          HttpServletResponse response) {
+        try {
+            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+            LocalDateTime start = LocalDateTime.parse(startTime, formatter);
+            LocalDateTime end = LocalDateTime.parse(endTime, formatter);
+            
+            // TODO: 这里需要修改为实际返回数据的方法
+            caseAiChatService.downloadConversationExcel(start, end);
+            
+            response.setContentType("application/vnd.ms-excel");
+            response.setHeader("Content-Disposition", "attachment; filename=conversations.xls");
+            
+            // 示例数据，实际应该从Service获取
+            LinkedHashMap<String, String> headers = new LinkedHashMap<>();
+            headers.put("会话ID", "conversationId");
+            headers.put("会话名称", "conversationName");
+            headers.put("用户", "user");
+            headers.put("开始时间", "startTime");
+            headers.put("会话时长", "duration");
+            
+            List<ConversationExcelVo> dataList = new ArrayList<>();
+            // 这里应该填充实际数据
+            
+            ExportsExcelSenderUtil.export(headers, dataList, response.getOutputStream(), "yyyy-MM-dd HH:mm:ss");
+        } catch (Exception e) {
+            log.error("导出会话记录为Excel异常", e);
+        }
+    }
+    
+    /**
+     * 判断当前登录用户是否显示"案例专家"功能入口
+     * @return 是否显示功能入口
+     */
+    @GetMapping("/show-entrance")
+    public JsonResponse<Boolean> showCaseAiEntrance() {
+        try {
+            String currentUserCode = getCurrent().getCode();
+            boolean shouldShow = caseAiPermissionService.shouldShowCaseAiEntrance(currentUserCode);
+//            return success(shouldShow);
+            JsonResponse<Boolean> result = success(shouldShow);
+            result.setMessage(currentUserCode);
+            return result;
+        } catch (Exception e) {
+            log.error("判断案例专家功能入口显示权限异常", e);
+            return error("判断失败", e.getMessage());
+        }
+    }
+
+    /**
+     * 手动刷新索引
+     * @return
+     */
+    @PostMapping("/index/refresh")
+    public JsonResponse<String> deleteAndCreateEsIndex() {
+        if (elasticSearchIndexService.checkIndexExists()) {
+            boolean deleteResult = elasticSearchIndexService.deleteIndex();
+            if (deleteResult) {
+                elasticSearchIndexService.createIndex();
+                return success("刷新成功");
+            }
+        } else {
+            elasticSearchIndexService.createIndex();
+        }
+        return error("刷新失败");
+    }
+
+    @PostMapping("/es/create")
+    public JsonResponse<String> createNewConversation(@RequestBody CaseAiMessageVo caseAiMessageVo,
+                                                      @RequestParam String conversationId,
+                                                      @RequestParam String userId) {
+        AiChatConversationData aiChatConversationData = new AiChatConversationData();
+        aiChatConversationData.setConversationId(conversationId);
+        aiChatConversationData.setQuery(caseAiMessageVo.getQuery());
+        aiChatConversationData.appendAnswer(caseAiMessageVo.getAnswer());
+        aiChatConversationData.setCaseRefers(caseAiMessageVo.getCaseRefer());
+        aiChatConversationData.setSuggestions(caseAiMessageVo.getSuggestions());
+        aiChatConversationData.setUserId(userId);
+        if (elasticSearchIndexService.createData(aiChatConversationData)) {
+            return success("创建成功");
+        }
+        return error("创建失败");
+    }
+    
+    /**
+     * 用于Excel导出的VO类
+     */
+    @Data
+    static class ConversationExcelVo {
+        private String conversationId;
+        private String conversationName;
+        private String user;
+        private String startTime;
+        private String duration;
+    }
+}

servers/boe-server-all/src/main/java/com/xboe/module/boecase/api/CaseDocumentLogApi.java

@@ -7,6 +7,12 @@ import com.xboe.core.log.AutoLog;
 import com.xboe.module.boecase.dto.CaseDocumentLogQueryDto;
 import com.xboe.module.boecase.service.ICaseDocumentLogService;
 import com.xboe.module.boecase.service.ICaseKnowledgeService;
+import com.xboe.module.boecase.service.ICasesService;
+import com.xboe.module.boecase.entity.Cases;
+import com.xboe.module.boecase.entity.CaseDocumentLog;
+import com.xboe.common.utils.IDGenerator;
+import com.xboe.common.utils.StringUtil;
+import java.time.LocalDateTime;
 import com.xboe.module.boecase.vo.CaseDocumentLogVo;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.web.bind.annotation.*;
@@ -27,6 +33,9 @@ public class CaseDocumentLogApi extends ApiBaseController {
     @Resource
     private ICaseKnowledgeService caseKnowledgeService;
 
+    @Resource
+    private ICasesService casesService;
+
     /**
      * AI调用日志分页查询
      *
@@ -83,20 +92,106 @@ public class CaseDocumentLogApi extends ApiBaseController {
             log.error("AI调用重试失败", e);
             return error("重试失败", e.getMessage());
         }
+        // 先走挡板
+//        return success(true);
     }
 
     /**
-     * 重试请求参数
+     * 根据案例ID上传案例文档到知识库
+     *
+     * @param request 上传请求参数
+     * @return 上传结果
      */
-    public static class RetryRequest {
-        private String logId;
-
-        public String getLogId() {
-            return logId;
+    @PostMapping("/uploadCaseByID")
+    @AutoLog(module = "案例文档管理", action = "根据案例ID上传文档", info = "根据案例ID查询案例信息并上传文档到知识库")
+    public JsonResponse<Boolean> uploadCaseById(@RequestBody UploadCaseRequest request) {
+        try {
+            String caseId = request.getCaseId();
+            if (StringUtil.isBlank(caseId)) {
+                return badRequest("案例ID不能为空");
+            }
+            
+            // 查询案例信息
+            Cases caseInfo = casesService.selectById(caseId, false);
+            if (caseInfo == null || caseInfo.getDeleted()) {
+                return badRequest("案例不存在或已删除");
+            }
+            
+            log.info("开始上传案例文档到知识库，案例ID: {}, 案例标题: {}", caseId, caseInfo.getTitle());
+            
+            // 调用ICaseKnowledgeService的uploadCaseDocument方法
+            boolean result = caseKnowledgeService.uploadCaseDocument(caseId);
+            
+            if (result) {
+                log.info("案例文档上传成功，案例ID: {}", caseId);
+                return success(result, "案例文档上传成功");
+            } else {
+                log.warn("案例文档上传失败，案例ID: {}", caseId);
+                return success(result, "案例文档上传失败");
+            }
+            
+        } catch (Exception e) {
+            log.error("根据案例ID上传文档失败", e);
+            return error("上传失败", e.getMessage());
         }
+    }
 
-        public void setLogId(String logId) {
-            this.logId = logId;
+    /**
+     * 直接创建CaseDocumentLog数据
+     *
+     * @param logData 日志数据
+     * @return 创建结果
+     */
+    @PostMapping("/createLog")
+    @AutoLog(module = "案例文档日志", action = "创建日志记录", info = "直接创建一条CaseDocumentLog数据")
+    public JsonResponse<String> createLog(@RequestBody CaseDocumentLog logData) {
+        try {
+            // 参数校验
+            if (StringUtil.isBlank(logData.getCaseId())) {
+                return badRequest("案例ID不能为空");
+            }
+            if (StringUtil.isBlank(logData.getOptType())) {
+                return badRequest("操作类型不能为空");
+            }
+            
+            // 设置必要的默认值
+            if (StringUtil.isBlank(logData.getId())) {
+                logData.setId(IDGenerator.generate());
+            }
+            if (logData.getOptTime() == null) {
+                logData.setOptTime(LocalDateTime.now());
+            }
+            if (logData.getOptStatus() == null) {
+                logData.setOptStatus(0); // 默认为调用中
+            }
+            if (logData.getDeleted() == null) {
+                logData.setDeleted(false);
+            }
+            
+            // 如果提供了案例ID但没有案例标题，尝试查询案例信息补充标题
+            if (StringUtil.isBlank(logData.getCaseTitle()) && StringUtil.isNotBlank(logData.getCaseId())) {
+                try {
+                    Cases caseInfo = casesService.selectById(logData.getCaseId(), false);
+                    if (caseInfo != null) {
+                        logData.setCaseTitle(caseInfo.getTitle());
+                    }
+                } catch (Exception e) {
+                    log.warn("查询案例标题失败，案例ID: {}", logData.getCaseId(), e);
+                }
+            }
+            
+            log.info("创建CaseDocumentLog记录，案例ID: {}, 操作类型: {}", 
+                    logData.getCaseId(), logData.getOptType());
+            
+            // 保存日志记录
+            caseDocumentLogService.save(logData);
+            
+            log.info("CaseDocumentLog记录创建成功，日志ID: {}", logData.getId());
+            return success(logData.getId(), "日志记录创建成功");
+            
+        } catch (Exception e) {
+            log.error("创建CaseDocumentLog记录失败", e);
+            return error("创建失败", e.getMessage());
         }
     }
 
@@ -203,4 +298,34 @@ public class CaseDocumentLogApi extends ApiBaseController {
         }
     }
 
+    /**
+     * 上传案例请求参数
+     */
+    public static class UploadCaseRequest {
+        private String caseId;
+
+        public String getCaseId() {
+            return caseId;
+        }
+
+        public void setCaseId(String caseId) {
+            this.caseId = caseId;
+        }
+    }
+
+    /**
+     * 重试请求参数
+     */
+    public static class RetryRequest {
+        private String logId;
+
+        public String getLogId() {
+            return logId;
+        }
+
+        public void setLogId(String logId) {
+            this.logId = logId;
+        }
+    }
+
 }

servers/boe-server-all/src/main/java/com/xboe/module/boecase/api/CaseUploadTaskApi.java

@@ -0,0 +1,33 @@
+package com.xboe.module.boecase.api;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.redis.core.StringRedisTemplate;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import javax.annotation.Resource;
+
+/**
+ * 案例上传任务API
+ */
+@Slf4j
+@RestController
+@RequestMapping("/xboe/m/boe/caseUpload")
+public class CaseUploadTaskApi {
+
+    @Autowired
+    private StringRedisTemplate stringRedisTemplate;
+
+    private static final String CASE_UPLOAD_LAST_ID_KEY = "case:upload:last:id";
+
+    /**
+     * 清除处理位置标记，使下次任务从头开始执行
+     */
+    @PostMapping("/reset")
+    public void resetLastProcessedId() {
+        stringRedisTemplate.delete(CASE_UPLOAD_LAST_ID_KEY);
+        log.info("已清除上次处理位置标记");
+    }
+}

servers/boe-server-all/src/main/java/com/xboe/module/boecase/async/CaseAiDocumentAsyncHandler.java

@@ -0,0 +1,67 @@
+package com.xboe.module.boecase.async;
+
+import com.xboe.enums.CaseDocumentLogOptTypeEnum;
+import com.xboe.module.boecase.entity.Cases;
+import com.xboe.module.boecase.service.ICaseKnowledgeService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
+import org.springframework.stereotype.Component;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+@Component
+@Slf4j
+public class CaseAiDocumentAsyncHandler {
+
+    private final AtomicInteger currentTaskCount = new AtomicInteger(0);
+
+    @Autowired
+    @Qualifier("aiDocExecutor")
+    private ThreadPoolTaskExecutor aiDocExecutor;
+
+    @Autowired
+    private ICaseKnowledgeService caseKnowledgeService;
+
+    public void process(CaseDocumentLogOptTypeEnum optTypeEnum, Cases... caseList) {
+        for (Cases cases : caseList) {
+            // 控制并发数量
+            while (currentTaskCount.get() >= 15) {
+                try {
+                    Thread.sleep(100);
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                    break;
+                }
+            }
+
+            currentTaskCount.incrementAndGet();
+
+            aiDocExecutor.submit(() -> {
+                processCases(cases, optTypeEnum);
+                currentTaskCount.decrementAndGet();
+            });
+        }
+    }
+
+    private void processCases(Cases cases, CaseDocumentLogOptTypeEnum optTypeEnum) {
+        try {
+            switch (optTypeEnum) {
+                case UPDATE:
+                    caseKnowledgeService.updateCaseDocument(cases);
+                    break;
+                case DELETE:
+                    caseKnowledgeService.deleteCaseDocument(cases);
+                    break;
+                case CREATE:
+                default:
+                    caseKnowledgeService.uploadCaseDocument(cases);
+                    break;
+            }
+            log.info("处理案例成功，caseId: {}, 操作类型: {}", cases.getId(), optTypeEnum.getDesc());
+        } catch (Exception e) {
+            log.error("处理案例失败，caseId: {}, 操作类型: {}", cases.getId(), optTypeEnum.getDesc(), e);
+        }
+    }
+}

servers/boe-server-all/src/main/java/com/xboe/module/boecase/dao/CaseAiConversationsDao.java

@@ -18,7 +18,7 @@ public class CaseAiConversationsDao extends BaseDao<CaseAiConversations> {
      */
     public String findAiConversationIdById(String conversationId) {
         CaseAiConversations conversation = this.getGenericDao().findOne(CaseAiConversations.class, 
-            FieldFilters.eq("id", conversationId));
-        return conversation != null ? conversation.getAiConversationId() : null;
+            FieldFilters.eq("ai_conversation_id", conversationId));
+        return conversation != null ? conversation.getAiConversationId() : conversationId;
     }
 }

servers/boe-server-all/src/main/java/com/xboe/module/boecase/dao/CaseDocumentLogDao.java

@@ -1,6 +1,7 @@
 package com.xboe.module.boecase.dao;
 
 import com.xboe.core.orm.BaseDao;
+import com.xboe.core.orm.FieldFilters;
 import com.xboe.module.boecase.entity.CaseDocumentLog;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Repository;

servers/boe-server-all/src/main/java/com/xboe/module/boecase/dto/CaseAiChatDto.java

@@ -18,4 +18,10 @@ public class CaseAiChatDto {
      * 提问内容
      */
     private String query;
+
+    /**
+     * 是否开启思考
+     * 0-否 1-是
+     */
+    private Integer enableThinking;
 }

servers/boe-server-all/src/main/java/com/xboe/module/boecase/entity/AiChatConversationData.java

@@ -0,0 +1,115 @@
+package com.xboe.module.boecase.entity;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.xboe.module.boecase.vo.CaseReferVo;
+import lombok.Data;
+import lombok.extern.slf4j.Slf4j;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * AI聊天会话数据实体
+ * 纯数据容器，不与数据库交互
+ * 
+ * @author AI Assistant
+ */
+@Data
+@Slf4j
+public class AiChatConversationData {
+
+    /**
+     * 会话ID
+     */
+    private String conversationId;
+
+    /**
+     * 用户提问内容
+     */
+    private String query;
+
+    /**
+     * AI回答内容（使用StringBuilder收集流式数据）
+     */
+    private StringBuilder answer = new StringBuilder();
+
+    /**
+     * 案例引用列表
+     */
+    private List<CaseReferVo> caseRefers = new ArrayList<>();
+
+    /**
+     * 建议列表
+     */
+    private List<String> suggestions = new ArrayList<>();
+
+    /**
+     * 用户ID
+     */
+    private String userId;
+
+    /**
+     * 用户名称
+     */
+    private String userName;
+
+    /**
+     * 消息时间戳
+     */
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private LocalDateTime startTime;
+
+    /**
+     * 消息时间戳
+     */
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private LocalDateTime timestamp;
+
+    /**
+     * 聊天时长（秒）
+     */
+    private Integer durationSeconds;
+
+    // ================== 构造函数 ==================
+
+    public AiChatConversationData() {
+        this.startTime = LocalDateTime.now();
+    }
+
+    // ================== 便捷方法 ==================
+
+    /**
+     * 获取回答内容的字符串形式
+     */
+    public String getAnswerAsString() {
+        return this.answer.toString();
+    }
+
+    /**
+     * 追加回答内容
+     */
+    public void appendAnswer(String content) {
+        if (content != null) {
+            this.answer.append(content);
+        }
+    }
+
+    /**
+     * 添加案例引用
+     */
+    public void addCaseRefer(CaseReferVo caseRefer) {
+        if (caseRefer != null) {
+            this.caseRefers.add(caseRefer);
+        }
+    }
+
+    /**
+     * 添加建议
+     */
+    public void addSuggestion(String suggestion) {
+        if (suggestion != null && !suggestion.trim().isEmpty()) {
+            this.suggestions.add(suggestion);
+        }
+    }
+}

servers/boe-server-all/src/main/java/com/xboe/module/boecase/entity/CaseDocumentLog.java

@@ -67,6 +67,13 @@ public class CaseDocumentLog extends BaseEntity {
     @Column(name = "opt_time")
     private LocalDateTime optTime;
 
+    /**
+     * 接口运行状态
+     * 0-运行中, 1-运行完毕
+     */
+    @Column(name = "run_status")
+    private Integer runStatus;
+
     /**
      * 接口调用状态
      * 0-调用中, 1-调用成功, 2-调用失败

servers/boe-server-all/src/main/java/com/xboe/module/boecase/properties/CaseAiProperties.java

@@ -3,6 +3,8 @@ package com.xboe.module.boecase.properties;
 import lombok.Data;
 import org.springframework.boot.context.properties.ConfigurationProperties;
 
+import java.util.List;
+
 /**
  * 案例专家AI相关配置项
  */
@@ -30,13 +32,59 @@ public class CaseAiProperties {
      */
     private String aiApiCode;
 
+    /**
+     * 对话接口的apiCode
+     */
+    private String chatApiCode;
+
     /**
      * 案例知识库id
      */
     private String caseKnowledgeId;
 
+    /**
+     * 默认上传用户
+     * 当获取不到当前登录用户信息时会取这个
+     */
+    private String defaultUploadUser;
+
+    /**
+     * 案例详情页面地址
+     */
+    private String caseDetailUrlBase;
+
+    /**
+     * 文件上传是否使用回调接口
+     */
+    private boolean fileUploadUseCallback;
+
     /**
      * 文档上传回调接口地址
      */
     private String fileUploadCallbackUrl;
-}
+
+    /**
+     * 是否启用白名单
+     */
+    private boolean useWhiteList;
+
+    /**
+     * 白名单用户列表
+     */
+    private List<String> whiteUserCodeList;
+    
+    /**
+     * AI处理失败告警邮件收件人列表
+     */
+    private List<String> alertEmailRecipients;
+
+    /**
+     * 是否发送AI对话记录到邮箱
+     */
+    private boolean aiChatDataSendEmail;
+
+    /**
+     * AI对话记录保存根路径
+     */
+    private String aiChatRootPath;
+}

servers/boe-server-all/src/main/java/com/xboe/module/boecase/service/ICaseAiChatService.java

@@ -6,6 +6,7 @@ import com.xboe.module.boecase.entity.CaseAiConversations;
 import com.xboe.module.boecase.vo.CaseAiMessageVo;
 import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
 
+import java.time.LocalDateTime;
 import java.util.List;
 
 /**
@@ -35,4 +36,11 @@ public interface ICaseAiChatService {
      * @return 消息记录列表
      */
     List<CaseAiMessageVo> getConversationMessages(String conversationId);
-}
+
+    /**
+     * 导出会话记录为Excel
+     * @param startTime 开始时间
+     * @param endTime 结束时间
+     */
+    void downloadConversationExcel(LocalDateTime startTime, LocalDateTime endTime);
+}

servers/boe-server-all/src/main/java/com/xboe/module/boecase/service/ICaseAiPermissionService.java

@@ -0,0 +1,14 @@
+package com.xboe.module.boecase.service;
+
+/**
+ * 案例AI权限服务接口
+ */
+public interface ICaseAiPermissionService {
+
+    /**
+     * 判断指定用户是否显示"案例专家"功能入口
+     * @param userCode 用户编码
+     * @return 是否显示功能入口
+     */
+    boolean shouldShowCaseAiEntrance(String userCode);
+}

servers/boe-server-all/src/main/java/com/xboe/module/boecase/service/ICaseDocumentLogService.java

@@ -2,6 +2,7 @@ package com.xboe.module.boecase.service;
 
 import com.xboe.common.PageList;
 import com.xboe.module.boecase.dto.CaseDocumentLogQueryDto;
+import com.xboe.module.boecase.entity.CaseDocumentLog;
 import com.xboe.module.boecase.vo.CaseDocumentLogVo;
 
 /**
@@ -37,4 +38,12 @@ public interface ICaseDocumentLogService {
      */
     boolean retryByLogId(String logId);
 
+    /**
+     * 保存日志记录
+     *
+     * @param log 日志对象
+     * @return 是否成功
+     */
+    boolean save(CaseDocumentLog log);
+
 }

servers/boe-server-all/src/main/java/com/xboe/module/boecase/service/ICaseKnowledgeService.java

@@ -1,5 +1,9 @@
 package com.xboe.module.boecase.service;
 
+import com.xboe.module.boecase.entity.CaseDocumentLog;
+import com.xboe.module.boecase.entity.Cases;
+import org.springframework.transaction.annotation.Transactional;
+
 /**
  * 案例-知识库
  */
@@ -13,6 +17,14 @@ public interface ICaseKnowledgeService {
      */
     boolean uploadCaseDocument(String caseId);
 
+    /**
+     * 上传案例文档
+     *
+     * @param cases 案例
+     * @return 是否成功
+     */
+    boolean uploadCaseDocument(Cases cases);
+
     /**
      * 删除案例文档
      *
@@ -21,13 +33,29 @@ public interface ICaseKnowledgeService {
      */
     boolean deleteCaseDocument(String caseId);
 
+    /**
+     * 删除案例文档
+     *
+     * @param cases 案例
+     * @return 是否成功
+     */
+    boolean deleteCaseDocument(Cases cases);
+
     /**
      * 更新案例文档
      *
      * @param caseId 案例ID
      * @return 是否成功
      */
-    boolean updateCaseDocument(String caseId);
+    boolean retryCaseDocument(String caseId, CaseDocumentLog originalLog);
+
+    /**
+     * 更新案例文档
+     *
+     * @param cases 案例
+     * @return 是否成功
+     */
+    boolean updateCaseDocument(Cases cases);
 
     /**
      * 处理文档上传回调
@@ -38,4 +66,10 @@ public interface ICaseKnowledgeService {
      * @return 是否处理成功
      */
     boolean handleUploadCallback(String taskId, String message, String fileStatus);
+
+    /**
+     * 批量检查文件状态
+     */
+    @Transactional(rollbackFor = Throwable.class)
+    void batchCheckFileStatus();
 }

servers/boe-server-all/src/main/java/com/xboe/module/boecase/service/IElasticSearchIndexService.java

@@ -0,0 +1,43 @@
+package com.xboe.module.boecase.service;
+
+import com.xboe.module.boecase.entity.AiChatConversationData;
+import com.xboe.module.boecase.vo.CaseAiMessageVo;
+
+import java.util.List;
+
+/**
+ * es索引
+ */
+public interface IElasticSearchIndexService {
+
+    /**
+     * 查看索引是否存在
+     * @return
+     */
+    boolean checkIndexExists();
+
+    /**
+     * 创建索引
+     */
+    boolean createIndex();
+
+    /**
+     * 删除索引
+     * @return
+     */
+    boolean deleteIndex();
+
+    /**
+     * 新增数据
+     * @param data
+     * @return
+     */
+    boolean createData(AiChatConversationData data);
+
+    /**
+     * 查询数据
+     * @param conversationId
+     * @return
+     */
+    List<CaseAiMessageVo> queryData(String conversationId);
+}

servers/boe-server-all/src/main/java/com/xboe/module/boecase/service/impl/CaseAiChatServiceImpl.java

@@ -3,6 +3,8 @@ package com.xboe.module.boecase.service.impl;
 import com.alibaba.fastjson.JSONArray;
 import com.alibaba.fastjson.JSONObject;
 import com.xboe.core.CurrentUser;
+import com.xboe.core.orm.FieldFilters;
+import com.xboe.enums.CaseAiChatStatusEnum;
 import com.xboe.module.boecase.dao.CaseAiConversationsDao;
 import com.xboe.module.boecase.dao.CaseDocumentLogDao;
 import com.xboe.module.boecase.dao.CasesDao;
@@ -13,8 +15,14 @@ import com.xboe.module.boecase.entity.Cases;
 import com.xboe.module.boecase.properties.CaseAiProperties;
 import com.xboe.module.boecase.service.IAiAccessTokenService;
 import com.xboe.module.boecase.service.ICaseAiChatService;
+import com.xboe.module.boecase.service.IElasticSearchIndexService;
 import com.xboe.module.boecase.vo.CaseAiMessageVo;
 import com.xboe.module.boecase.vo.CaseReferVo;
+import com.xboe.module.boecase.entity.AiChatConversationData;
+import com.xboe.module.boecase.vo.ConversationExcelVo;
+import com.xboe.system.organization.vo.OrgSimpleVo;
+import com.xboe.system.user.service.IUserService;
+import lombok.Data;
 import lombok.extern.slf4j.Slf4j;
 import okhttp3.*;
 import okhttp3.sse.EventSource;
@@ -27,6 +35,11 @@ import org.apache.http.entity.StringEntity;
 import org.apache.http.impl.client.CloseableHttpClient;
 import org.apache.http.impl.client.HttpClients;
 import org.apache.http.util.EntityUtils;
+import org.apache.poi.ss.usermodel.Row;
+import org.apache.poi.ss.usermodel.Sheet;
+import org.apache.poi.ss.usermodel.Workbook;
+import org.apache.poi.ss.util.CellRangeAddress;
+import org.apache.poi.xssf.usermodel.XSSFWorkbook;
 import org.elasticsearch.action.index.IndexRequest;
 import org.elasticsearch.action.index.IndexResponse;
 import org.elasticsearch.action.search.SearchRequest;
@@ -41,17 +54,23 @@ import org.elasticsearch.search.builder.SearchSourceBuilder;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.StringUtils;
 import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
 
+import java.io.File;
 import java.io.IOException;
+import java.io.OutputStream;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.time.LocalDateTime;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
 import java.util.concurrent.TimeUnit;
 
 @EnableConfigurationProperties({CaseAiProperties.class})
@@ -62,14 +81,21 @@ public class CaseAiChatServiceImpl implements ICaseAiChatService {
     @Autowired
     private CaseAiProperties caseAiProperties;
 
+    @Autowired
+    @Qualifier("customDispatcher")
+    private Dispatcher dispatcher;
+
     @Autowired
     private IAiAccessTokenService aiAccessTokenService;
 
+    @Autowired
+    private IUserService userService;
+
     @Autowired
     private CaseAiConversationsDao caseAiConversationsDao;
 
-    @Autowired(required = false)
-    private RestHighLevelClient elasticsearchClient;
+    @Autowired
+    private IElasticSearchIndexService elasticSearchIndexService;
 
     @Autowired
     private CaseDocumentLogDao caseDocumentLogDao;
@@ -78,25 +104,26 @@ public class CaseAiChatServiceImpl implements ICaseAiChatService {
     private CasesDao casesDao;
 
     @Override
+    @Transactional
     public SseEmitter chat(CaseAiChatDto caseAiChatDto, CurrentUser currentUser) {
+        // 创建SSE响应器
+        SseEmitter sseEmitter = new SseEmitter();
         // 1. 获取conversationId
-        String conversationId = getOrCreateConversationId(caseAiChatDto, currentUser);
-        
-        // 2. 检查是否为新会话，如果是则保存会话记录
-        boolean isNewConversation = StringUtils.isEmpty(caseAiChatDto.getConversationId());
-        CaseAiConversations conversation = null;
-        if (isNewConversation) {
-            // 新会话，需要保存到数据库
-            conversation = new CaseAiConversations();
-            conversation.setAiConversationId(conversationId);
-            conversation.setConversationName("AI案例咨询-" + LocalDateTime.now());
-            conversation.setConversationUser(currentUser.getAccountId());
-            // 由于编译问题，这里先注释，实际部署时需要取消注释
-            caseAiConversationsDao.save(conversation);
+        String conversationId;
+        try {
+            conversationId = getOrCreateConversationId(caseAiChatDto, currentUser);
+        } catch (Exception e) {
+            log.error("获取会话ID失败", e);
+            errMessage(sseEmitter, "服务繁忙，请稍后再试。");
+            sseEmitter.complete();
+            return sseEmitter;
         }
+
+        // 2. 查询历史
+        List<CaseAiMessageVo> historyMessages = elasticSearchIndexService.queryData(conversationId);
         
         // 3. 构建请求参数
-        String userId = currentUser.getAccountId();
+        String userId = currentUser.getCode();
         String kId = caseAiProperties.getCaseKnowledgeId();
         JSONObject chatParam = new JSONObject();
         chatParam.put("userId", userId);
@@ -105,26 +132,49 @@ public class CaseAiChatServiceImpl implements ICaseAiChatService {
         chatParam.put("kIds", kIds);
         chatParam.put("query", caseAiChatDto.getQuery());
         chatParam.put("conversationId", conversationId);
+        chatParam.put("enableThinking", Objects.equals(caseAiChatDto.getEnableThinking(), 1));
+        if (historyMessages != null && !historyMessages.isEmpty()) {
+            // 最多10条历史，从后往前
+            JSONArray historyList = new JSONArray();
+            int size = historyMessages.size();
+            int startIndex = Math.max(0, size - 10);
+            for (int i = startIndex; i < size; i++) {
+                JSONObject conversationDetail = new JSONObject();
+                CaseAiMessageVo message = historyMessages.get(i);
+                conversationDetail.put("query", message.getQuery());
+                conversationDetail.put("content", message.getAnswer());
+                historyList.add(conversationDetail);
+            }
+            chatParam.put("historyList", historyList);
+        }
+        String chatParamStr = chatParam.toJSONString();
+        log.info("案例问答接口请求参数: [{}]", chatParamStr);
         
         // 4. 设置请求头
-        String accessToken = aiAccessTokenService.getAccessToken();
-        String apiCode = caseAiProperties.getAiApiCode();
+        String accessToken;
+        try {
+            accessToken = aiAccessTokenService.getAccessToken();
+        } catch (Exception e) {
+            log.error("获取access_token失败", e);
+            errMessage(sseEmitter, "服务繁忙，请稍后再试。");
+            sseEmitter.complete();
+            return sseEmitter;
+        }
+        String apiCode = caseAiProperties.getChatApiCode();
         Request.Builder builder = new Request.Builder();
         builder.url(caseAiProperties.getBaseUrl() + "/apigateway/chat/knowledge/v1/chat/completions");
         builder.addHeader("access_token", accessToken);
         builder.addHeader("X-AI-ApiCode", apiCode);
-        RequestBody bodyRequestBody = RequestBody.create(chatParam.toJSONString(), MediaType.parse("application/json"));
+        RequestBody bodyRequestBody = RequestBody.create(chatParamStr, MediaType.parse("application/json"));
         builder.post(bodyRequestBody);
         Request request = builder.build();
-        
-        // 5. 创建SSE响应器
-        SseEmitter sseEmitter = new SseEmitter();
+
         
         // 6. 用于收集对话数据的容器
-        ConversationData conversationData = new ConversationData();
-        conversationData.query = caseAiChatDto.getQuery();
-        conversationData.conversationId = conversationId;
-        conversationData.userId = userId;
+        AiChatConversationData conversationData = new AiChatConversationData();
+        conversationData.setQuery(caseAiChatDto.getQuery());
+        conversationData.setConversationId(conversationId);
+        conversationData.setUserId(userId);
         
         // 7. 创建事件监听器
         EventSourceListener listener = new EventSourceListener() {
@@ -137,7 +187,7 @@ public class CaseAiChatServiceImpl implements ICaseAiChatService {
             public void onClosed(@NotNull EventSource eventSource) {
                 log.info("调用接口 [{}] 接口关闭", request.url());
                 // 对话完成，保存到ES
-                saveConversationToES(conversationData);
+                elasticSearchIndexService.createData(conversationData);
                 sseEmitter.complete();
             }
 
@@ -153,37 +203,35 @@ public class CaseAiChatServiceImpl implements ICaseAiChatService {
                         Integer status = responseData.getInteger("status");
                         
                         if (status != null) {
-                            switch (status) {
-                                case 0: // 返回引用文件
-                                    // 处理文件引用并构建返给前端的数据
-                                    JSONObject modifiedData = handleFileReferAndBuildResponse(responseData, conversationData);
-                                    if (modifiedData != null) {
-                                        // 发送修改后的数据给前端
-                                        sseEmitter.send(modifiedData.toJSONString());
-                                        return; // 早期返回，不发送原始数据
-                                    }
-                                    break;
-                                case 1: // 流式对话中
-                                    String content = responseData.getString("content");
-                                    if (content != null) {
-                                        conversationData.answer.append(content);
-                                    }
-                                    break;
-                                case 2: // 回答完成
-                                    // 不做特殊处理
-                                    break;
-                                case 3: // 返回建议
-                                    handleSuggestions(responseData, conversationData);
-                                    break;
-                                case 4: // 接口交互完成
-                                    // 不做特殊处理
-                                    break;
+                            CaseAiChatStatusEnum statusEnum = CaseAiChatStatusEnum.getByCode(status);
+                            if (statusEnum == CaseAiChatStatusEnum.REFERS) { // 返回引用文件
+                                // 处理文件引用并构建返给前端的数据
+                                JSONObject modifiedData = handleFileReferAndBuildResponse(responseData, conversationData);
+                                if (modifiedData != null) {
+                                    // 发送修改后的数据给前端
+                                    sseEmitter.send(modifiedData.toJSONString());
+                                    return; // 早期返回，不发送原始数据
+                                }
+                            } else if (statusEnum == CaseAiChatStatusEnum.CHAT) { // 流式对话中
+                                String content = responseData.getString("content");
+                                if (content != null) {
+                                    conversationData.appendAnswer(content);
+                                }
+                            } else if (statusEnum == CaseAiChatStatusEnum.SUGGESTIONS) { // 返回建议
+                                handleSuggestions(responseData, conversationData);
+                            } else if (statusEnum == CaseAiChatStatusEnum.CHAT_COMPLETED || statusEnum == CaseAiChatStatusEnum.API_COMPLETED) { // 接口交互完成
+                                // 不做特殊处理
+                            } else {
+                                // 异常问题，取message内容
+                                String message = jsonData.getString("message");
+                                errMessage(sseEmitter, message);
+                                return;
                             }
                         }
+                        sseEmitter.send(responseData.toJSONString());
+                    } else {
+                        sseEmitter.send(data);
                     }
-                    
-                    // 发送给前端
-                    sseEmitter.send(data);
                 } catch (IOException e) {
                     log.error("调用接口处理监听数据时发生异常", e);
                 } catch (Exception e) {
@@ -199,6 +247,14 @@ public class CaseAiChatServiceImpl implements ICaseAiChatService {
             @Override
             public void onFailure(@NotNull EventSource eventSource, @Nullable Throwable e, @Nullable Response response) {
                 log.error("调用接口 [{}] 接口异常", request.url(), e);
+                
+                // 如果是 content-type 错误，尝试作为普通 HTTP 请求处理
+                if (e instanceof IllegalStateException && e.getMessage() != null && e.getMessage().contains("Invalid content-type")) {
+                    log.warn("服务器返回的 Content-Type 不是 text/event-stream，尝试作为普通 HTTP 请求处理");
+                    handleAsRegularHttpRequest(request, sseEmitter, conversationData);
+                    return;
+                }
+                
                 if (e != null) {
                     sseEmitter.completeWithError(e);
                 } else {
@@ -210,8 +266,10 @@ public class CaseAiChatServiceImpl implements ICaseAiChatService {
         // 8. 执行HTTP请求
         OkHttpClient client = new OkHttpClient.Builder()
                 .connectTimeout(60, TimeUnit.SECONDS)
-                .writeTimeout(60, TimeUnit.SECONDS)
-                .readTimeout(60, TimeUnit.SECONDS)
+                .writeTimeout(600, TimeUnit.SECONDS)
+                .readTimeout(600, TimeUnit.SECONDS)
+                .callTimeout(600, TimeUnit.SECONDS)
+                .dispatcher(dispatcher)
                 .build();
         EventSource.Factory factory = EventSources.createFactory(client);
         factory.newEventSource(request, listener);
@@ -228,7 +286,7 @@ public class CaseAiChatServiceImpl implements ICaseAiChatService {
         if (StringUtils.isEmpty(conversationId)) {
             // 新会话，调用创建会话接口
             String conversationName = "AI案例咨询-" + LocalDateTime.now().toString();
-            CaseAiConversations newConversation = createNewConversation(currentUser.getAccountId(), conversationName);
+            CaseAiConversations newConversation = createNewConversation(currentUser.getCode(), conversationName);
             return newConversation.getAiConversationId();
         } else {
             // 已存在会话，从数据库查询
@@ -237,6 +295,7 @@ public class CaseAiChatServiceImpl implements ICaseAiChatService {
     }
 
     @Override
+    @Transactional
     public CaseAiConversations createNewConversation(String userId, String conversationName) {
         try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
             String url = caseAiProperties.getBaseUrl() + "/apigateway/knowledge/v1/conversation";
@@ -244,7 +303,7 @@ public class CaseAiChatServiceImpl implements ICaseAiChatService {
             
             // 设置请求头
             String accessToken = aiAccessTokenService.getAccessToken();
-            String apiCode = caseAiProperties.getAiApiCode();
+            String apiCode = caseAiProperties.getChatApiCode();
             httpPost.setHeader("access_token", accessToken);
             httpPost.setHeader("X-AI-ApiCode", apiCode);
             httpPost.setHeader("Content-Type", "application/json");
@@ -293,48 +352,123 @@ public class CaseAiChatServiceImpl implements ICaseAiChatService {
 
     @Override
     public List<CaseAiMessageVo> getConversationMessages(String conversationId) {
-        List<CaseAiMessageVo> messages = new ArrayList<>();
+        if (StringUtils.isEmpty(conversationId)) {
+            log.warn("conversationId 为空, 不查询");
+            return new ArrayList<>();
+        }
+        return elasticSearchIndexService.queryData(conversationId);
+    }
+
+    @Override
+    public void downloadConversationExcel(LocalDateTime startTime, LocalDateTime endTime) {
+        // 1. 根据startTime和endTime，查询在这个时间区间内的CaseAiConversations数据
+        List<CaseAiConversations> conversations = caseAiConversationsDao.getGenericDao().findList(
+            CaseAiConversations.class,
+            FieldFilters.ge("sysCreateTime", startTime),
+            FieldFilters.le("sysCreateTime", endTime)
+        );
         
-        if (elasticsearchClient == null) {
-            log.warn("未配置Elasticsearch客户端，无法查询消息记录");
-            return messages;
+        // 准备Excel数据
+        List<ConversationExcelVo> excelDataList = new ArrayList<>();
+        
+        // 2. 遍历这组数据，根据aiConversationId从es中查询数据（可调用getConversationMessages()方法）
+        for (CaseAiConversations conversation : conversations) {
+            String aiConversationId = conversation.getAiConversationId();
+            String conversationName = conversation.getConversationName();
+            String conversationUser = conversation.getConversationUser();
+            
+            List<CaseAiMessageVo> messages = getConversationMessages(aiConversationId);
+            
+            // 计算会话时长
+            long duration = 0; // 默认为0，如果需要精确计算，需要从消息中提取时间信息
+            
+            // 3. 写入Excel，包括每个会话的用户，会话标题，会话内的问答记录，每次对话时长等
+            ConversationExcelVo excelData = new ConversationExcelVo();
+            excelData.setConversationId(aiConversationId);
+            excelData.setConversationName(conversationName);
+            excelData.setUser(conversationUser);
+            excelData.setMessages(messages);
+            
+            excelDataList.add(excelData);
         }
         
-        try {
-            // 根据conversationId从数据库查询AI会话ID
-            String aiConversationId = caseAiConversationsDao.findAiConversationIdById(conversationId);
-            if (StringUtils.isEmpty(aiConversationId)) {
-                log.warn("未找到conversationId: {}对应的AI会话ID", conversationId);
-                return messages;
-            }
-            
-            // 从 ES 中查询消息记录
-            SearchRequest searchRequest = new SearchRequest("ai_chat_messages"); // ES索引名，可以根据实际情况调整
-            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
-            searchSourceBuilder.query(QueryBuilders.termQuery("conversationId", aiConversationId));
-            searchSourceBuilder.size(1000); // 设置最大返回数量
-            searchRequest.source(searchSourceBuilder);
-            
-            SearchResponse searchResponse = elasticsearchClient.search(searchRequest, RequestOptions.DEFAULT);
-            SearchHits hits = searchResponse.getHits();
-            
-            for (SearchHit hit : hits) {
-                Map<String, Object> sourceMap = hit.getSourceAsMap();
-                CaseAiMessageVo messageVo = parseMessageFromES(sourceMap);
-                if (messageVo != null) {
-                    messages.add(messageVo);
+        // 写入Excel文件
+        Workbook workbook = new XSSFWorkbook();
+        Sheet sheet = workbook.createSheet("AI会话数据");
+        // 标题行
+        Row headerRow = sheet.createRow(0);
+        headerRow.createCell(0).setCellValue("会话ID");
+        headerRow.createCell(1).setCellValue("会话名称");
+        headerRow.createCell(2).setCellValue("用户");
+        headerRow.createCell(3).setCellValue("提问");
+        headerRow.createCell(4).setCellValue("回答");
+        headerRow.createCell(5).setCellValue("开始时间");
+        headerRow.createCell(6).setCellValue("问答时长(秒)");
+        
+        // 内容行
+        if (!excelDataList.isEmpty()) {
+            int rowNum = 1; // 从第二行开始写入数据
+            for (ConversationExcelVo excelData : excelDataList) {
+                List<CaseAiMessageVo> messages = excelData.getMessages();
+                
+                if (messages != null && !messages.isEmpty()) {
+                    // 记录起始行号，用于后续合并单元格
+                    int startRow = rowNum;
+                    
+                    // 遍历每个消息
+                    for (CaseAiMessageVo message : messages) {
+                        Row row = sheet.createRow(rowNum++);
+                        // 填充每行数据
+                        row.createCell(0).setCellValue(excelData.getConversationId());
+                        row.createCell(1).setCellValue(excelData.getConversationName());
+                        row.createCell(2).setCellValue(excelData.getUser());
+                        row.createCell(3).setCellValue(message.getQuery() != null ? message.getQuery() : "");
+                        row.createCell(4).setCellValue(message.getAnswer() != null ? message.getAnswer() : "");
+                        row.createCell(5).setCellValue(""); // 开始时间字段暂留空
+                        row.createCell(6).setCellValue(message.getDurationSeconds() != null ? message.getDurationSeconds() : 0);
+                    }
+                    
+                    // 合并单元格（会话ID、会话名称、用户三列）
+                    // 参数说明：起始行号，结束行号，起始列号，结束列号
+                    if (rowNum > startRow + 1) { // 只有当有多行时才合并
+                        sheet.addMergedRegion(new CellRangeAddress(startRow, rowNum - 1, 0, 0));
+                        sheet.addMergedRegion(new CellRangeAddress(startRow, rowNum - 1, 1, 1));
+                        sheet.addMergedRegion(new CellRangeAddress(startRow, rowNum - 1, 2, 2));
+                    }
+                } else {
+                    // 如果没有消息，则仍然创建一行显示基本信息
+                    Row row = sheet.createRow(rowNum++);
+                    row.createCell(0).setCellValue(excelData.getConversationId());
+                    row.createCell(1).setCellValue(excelData.getConversationName());
+                    row.createCell(2).setCellValue(excelData.getUser());
                 }
             }
-            
-            log.info("从 ES 中查询到 {} 条消息记录", messages.size());
-            
-        } catch (Exception e) {
-            log.error("从 ES 查询会话消息记录异常", e);
         }
-        
-        return messages;
+        // 3. 创建Excel文件并保存
+        if (caseAiProperties.isAiChatDataSendEmail()) {
+            // TODO 发送邮件附件
+        } else {
+            // 保存文件
+            String dirPath = caseAiProperties.getAiChatRootPath() + File.separator + startTime.format(DateTimeFormatter.ofPattern("yyyyMM"));
+            Path dir = Paths.get(dirPath);
+            if (!Files.exists(dir)) {
+                try {
+                    Files.createDirectories(dir);
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            String fileName = "AI会话数据-" + startTime.format(DateTimeFormatter.ofPattern("yyyyMMdd")) + "-" + System.currentTimeMillis() + ".xlsx";
+            Path filePath = dir.resolve(fileName);
+            try (OutputStream out = Files.newOutputStream(filePath)) {
+                workbook.write(out);
+                out.flush();
+            } catch (IOException e) {
+                log.error("保存文件错误", e);
+            }
+        }
     }
-    
+
     /**
      * 从 ES 数据中解析消息对象
      * @param sourceMap ES数据
@@ -386,10 +520,11 @@ public class CaseAiChatServiceImpl implements ICaseAiChatService {
     /**
      * 处理文件引用并构建返给前端的响应数据
      */
-    private JSONObject handleFileReferAndBuildResponse(JSONObject responseData, ConversationData conversationData) {
+    private JSONObject handleFileReferAndBuildResponse(JSONObject responseData, AiChatConversationData conversationData) {
         try {
             // 先处理文件引用，收集CaseReferVo数据
             List<CaseReferVo> currentCaseRefers = new ArrayList<>();
+            Set<String> docIds = new HashSet<>();
             
             JSONObject fileRefer = responseData.getJSONObject("fileRefer");
             if (fileRefer != null && fileRefer.containsKey("files")) {
@@ -400,22 +535,19 @@ public class CaseAiChatServiceImpl implements ICaseAiChatService {
                     if (docId != null) {
                         // 根据docId从 case_document_log 表查询案例数据
                         CaseReferVo caseRefer = getCaseReferByDocId(docId);
-                        if (caseRefer != null) {
+                        if (caseRefer != null && !docIds.contains(docId)) {
+                            docIds.add(docId);
                             currentCaseRefers.add(caseRefer);
-                            conversationData.caseRefers.add(caseRefer); // 也添加到总的收集器中
+                            conversationData.addCaseRefer(caseRefer); // 也添加到总的收集器中
                         }
                     }
                 }
             }
             
             // 构建返给前端的数据结构
-            JSONObject modifiedResponse = new JSONObject();
-            modifiedResponse.put("success", true);
-            modifiedResponse.put("code", 0);
-            modifiedResponse.put("message", "业务处理成功");
-            
             JSONObject data = new JSONObject();
             data.put("status", 0);
+            data.put("conversationId", conversationData.getConversationId());
             data.put("content", responseData.getString("content"));
             
             // 添加处理后的案例引用数据
@@ -427,6 +559,10 @@ public class CaseAiChatServiceImpl implements ICaseAiChatService {
                 caseReferObj.put("authorName", caseRefer.getAuthorName());
                 caseReferObj.put("keywords", caseRefer.getKeywords());
                 caseReferObj.put("content", caseRefer.getContent());
+                // 使用指定的时间格式
+                DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+                caseReferObj.put("uploadTime", caseRefer.getUploadTime() != null ? caseRefer.getUploadTime().format(formatter) : null);
+
                 caseReferArray.add(caseReferObj);
             }
             
@@ -447,10 +583,8 @@ public class CaseAiChatServiceImpl implements ICaseAiChatService {
             data.put("fileRefer", newFileRefer);
             data.put("suggestions", responseData.get("suggestions"));
             
-            modifiedResponse.put("data", data);
-            
             log.info("处理文件引用成功，返回 {} 个案例引用", currentCaseRefers.size());
-            return modifiedResponse;
+            return data;
             
         } catch (Exception e) {
             log.error("处理文件引用并构建响应数据异常", e);
@@ -461,7 +595,7 @@ public class CaseAiChatServiceImpl implements ICaseAiChatService {
     /**
      * 处理文件引用（原方法，保留用于数据收集）
      */
-    private void handleFileRefer(JSONObject responseData, ConversationData conversationData) {
+    private void handleFileRefer(JSONObject responseData, AiChatConversationData conversationData) {
         try {
             JSONObject fileRefer = responseData.getJSONObject("fileRefer");
             if (fileRefer != null && fileRefer.containsKey("files")) {
@@ -473,7 +607,7 @@ public class CaseAiChatServiceImpl implements ICaseAiChatService {
                         // 根据docId从 case_document_log 表查询案例数据
                         CaseReferVo caseRefer = getCaseReferByDocId(docId);
                         if (caseRefer != null) {
-                            conversationData.caseRefers.add(caseRefer);
+                            conversationData.addCaseRefer(caseRefer);
                         }
                     }
                 }
@@ -486,14 +620,14 @@ public class CaseAiChatServiceImpl implements ICaseAiChatService {
     /**
      * 处理建议
      */
-    private void handleSuggestions(JSONObject responseData, ConversationData conversationData) {
+    private void handleSuggestions(JSONObject responseData, AiChatConversationData conversationData) {
         try {
             JSONArray suggestions = responseData.getJSONArray("suggestions");
             if (suggestions != null) {
                 for (int i = 0; i < suggestions.size(); i++) {
                     String suggestion = suggestions.getString(i);
                     if (suggestion != null) {
-                        conversationData.suggestions.add(suggestion);
+                        conversationData.addSuggestion(suggestion);
                     }
                 }
             }
@@ -518,13 +652,17 @@ public class CaseAiChatServiceImpl implements ICaseAiChatService {
             if (caseEntity == null) {
                 return null;
             }
-            
+
+            String authorUserId = caseEntity.getAuthorId();
+            OrgSimpleVo authorOrg = userService.findOrgByUserId(authorUserId);
             // 构建 CaseReferVo
             CaseReferVo caseRefer = new CaseReferVo();
             caseRefer.setCaseId(caseEntity.getId());
             caseRefer.setTitle(caseEntity.getTitle());
             caseRefer.setAuthorName(caseEntity.getAuthorName());
-            caseRefer.setContent(caseEntity.getContent());
+            caseRefer.setContent(caseEntity.getSummary());
+            caseRefer.setUploadTime(caseEntity.getSysCreateTime());
+            caseRefer.setOrgInfo(authorOrg.getName());
             
             // 构建关键词列表
             List<String> keywords = new ArrayList<>();
@@ -543,60 +681,49 @@ public class CaseAiChatServiceImpl implements ICaseAiChatService {
     }
     
     /**
-     * 保存对话记录到ES
+     * 当 SSE 失败时，作为普通 HTTP 请求处理
      */
-    private void saveConversationToES(ConversationData conversationData) {
-        if (elasticsearchClient == null) {
-            log.warn("未配置Elasticsearch客户端，无法保存对话记录");
-            return;
-        }
-        
+    private void handleAsRegularHttpRequest(Request request, SseEmitter sseEmitter, AiChatConversationData conversationData) {
         try {
-            // 构建要保存的数据
-            JSONObject esData = new JSONObject();
-            esData.put("query", conversationData.query);
-            esData.put("answer", conversationData.answer.toString());
-            esData.put("conversationId", conversationData.conversationId);
-            esData.put("userId", conversationData.userId);
-            esData.put("timestamp", LocalDateTime.now().toString());
+            OkHttpClient client = new OkHttpClient.Builder()
+                    .connectTimeout(60, TimeUnit.SECONDS)
+                    .writeTimeout(60, TimeUnit.SECONDS)
+                    .readTimeout(60, TimeUnit.SECONDS)
+                    .build();
             
-            // 构建 caseRefer 数据
-            JSONArray caseReferArray = new JSONArray();
-            for (CaseReferVo caseRefer : conversationData.caseRefers) {
-                JSONObject caseReferObj = new JSONObject();
-                caseReferObj.put("caseId", caseRefer.getCaseId());
-                caseReferObj.put("title", caseRefer.getTitle());
-                caseReferObj.put("authorName", caseRefer.getAuthorName());
-                caseReferObj.put("keywords", caseRefer.getKeywords());
-                caseReferObj.put("content", caseRefer.getContent());
-                caseReferArray.add(caseReferObj);
+            Response response = client.newCall(request).execute();
+            if (response.isSuccessful()) {
+                String responseBody = response.body().string();
+                log.info("作为普通 HTTP 请求处理成功，将响应原封不动推送给前端");
+                
+                // 将响应内容原封不动地推送到 SseEmitter
+                JSONObject responseData = JSONObject.parseObject(responseBody);
+                if (responseBody.contains("message")) {
+                    errMessage(sseEmitter, responseData.getString("message"));
+                    sseEmitter.complete();
+                    return;
+                }
+                sseEmitter.send(responseBody);
+                sseEmitter.complete();
+            } else {
+                log.error("普通 HTTP 请求失败，状态码: {}", response.code());
+                sseEmitter.completeWithError(new RuntimeException("HTTP 请求失败，状态码: " + response.code()));
             }
-            esData.put("caseRefer", caseReferArray);
-            
-            // 添加建议
-            esData.put("suggestions", conversationData.suggestions);
-            
-            // 保存到ES
-            IndexRequest indexRequest = new IndexRequest("ai_chat_messages");
-            indexRequest.source(esData.toJSONString(), XContentType.JSON);
-            
-            IndexResponse indexResponse = elasticsearchClient.index(indexRequest, RequestOptions.DEFAULT);
-            log.info("保存对话记录到ES成功，文档ID: {}", indexResponse.getId());
-            
         } catch (Exception e) {
-            log.error("保存对话记录到ES异常", e);
+            log.error("处理普通 HTTP 请求异常", e);
+            sseEmitter.completeWithError(e);
         }
     }
-    
-    /**
-     * 对话数据容器
-     */
-    private static class ConversationData {
-        public String query;
-        public StringBuilder answer = new StringBuilder();
-        public List<CaseReferVo> caseRefers = new ArrayList<>();
-        public List<String> suggestions = new ArrayList<>();
-        public String conversationId;
-        public String userId;
+
+    private void errMessage(SseEmitter sseEmitter, String message) {
+        JSONObject jsonData = new JSONObject();
+        jsonData.put("status", 1);
+        jsonData.put("content", message);
+        try {
+            sseEmitter.send(jsonData.toJSONString());
+        } catch (IOException e) {
+            log.error("发送错误信息异常", e);
+            sseEmitter.completeWithError(e);
+        }
     }
 }

servers/boe-server-all/src/main/java/com/xboe/module/boecase/service/impl/CaseAiPermissionServiceImpl.java

@@ -0,0 +1,47 @@
+package com.xboe.module.boecase.service.impl;
+
+import com.xboe.module.boecase.properties.CaseAiProperties;
+import com.xboe.module.boecase.service.ICaseAiPermissionService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+/**
+ * 案例AI权限服务实现类
+ */
+@Slf4j
+@Service
+@Transactional
+public class CaseAiPermissionServiceImpl implements ICaseAiPermissionService {
+
+    @Autowired
+    private CaseAiProperties caseAiProperties;
+
+    /**
+     * 判断指定用户是否显示"案例专家"功能入口
+     * @param userCode 用户编码
+     * @return 是否显示功能入口
+     */
+    @Override
+    public boolean shouldShowCaseAiEntrance(String userCode) {
+        log.info("判断用户[{}]是否显示案例专家功能入口", userCode);
+        
+        // 如果不启用白名单，直接返回true
+        if (!caseAiProperties.isUseWhiteList()) {
+            log.info("未启用白名单，所有用户都显示功能入口");
+            return true;
+        }
+        
+        // 启用白名单时，判断当前用户是否在白名单中
+        List<String> whiteUserCodeList = caseAiProperties.getWhiteUserCodeList();
+        log.info("白名单列表：{}", whiteUserCodeList);
+        boolean isInWhiteList = whiteUserCodeList != null
+            && whiteUserCodeList.stream().anyMatch(userCode::equals);
+        
+        log.info("用户[{}]{}在白名单中", userCode, isInWhiteList ? "" : "不");
+        return isInWhiteList;
+    }
+}

servers/boe-server-all/src/main/java/com/xboe/module/boecase/service/impl/CaseDocumentLogServiceImpl.java

@@ -1,12 +1,12 @@
 package com.xboe.module.boecase.service.impl;
 
 import com.xboe.common.utils.StringUtil;
-import com.xboe.common.utils.IDGenerator;
 import com.xboe.common.OrderCondition;
 import com.xboe.common.PageList;
 import com.xboe.core.orm.FieldFilters;
 import com.xboe.core.orm.IFieldFilter;
 import com.xboe.core.orm.LikeMatchMode;
+import com.xboe.enums.CaseDocumentLogRunStatusEnum;
 import com.xboe.module.boecase.dao.CaseDocumentLogDao;
 import com.xboe.module.boecase.dto.CaseDocumentLogQueryDto;
 import com.xboe.module.boecase.entity.CaseDocumentLog;
@@ -16,6 +16,7 @@ import com.xboe.module.boecase.vo.CaseDocumentLogVo;
 import com.xboe.enums.CaseDocumentLogOptTypeEnum;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.BeanUtils;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -39,20 +40,16 @@ public class CaseDocumentLogServiceImpl implements ICaseDocumentLogService {
     @Resource
     private ICaseKnowledgeService caseKnowledgeService;
 
+    @Resource(name = "aiDocExecutor")
+    private ThreadPoolTaskExecutor aiDocExecutor;
+
     @Override
     public PageList<CaseDocumentLogVo> pageQuery(int pageIndex, int pageSize, CaseDocumentLogQueryDto queryDto) {
         // 构建查询条件
         List<IFieldFilter> filters = new ArrayList<>();
-        
-        // 删除标识过滤
-        filters.add(FieldFilters.eq("deleted", false));
 
-        // 接口调用状态
-        if (queryDto.getOptStatus() != null) {
-            filters.add(FieldFilters.eq("optStatus", queryDto.getOptStatus()));
-        } else {
-            filters.add(FieldFilters.ge("optStatus", 1));
-        }
+        // 运行状态过滤
+        filters.add(FieldFilters.eq("runStatus", CaseDocumentLogRunStatusEnum.COMPLETED.getCode()));
 
         // 案例标题模糊查询
         if (StringUtil.isNotBlank(queryDto.getCaseTitle())) {
@@ -69,7 +66,14 @@ public class CaseDocumentLogServiceImpl implements ICaseDocumentLogService {
             filters.add(FieldFilters.ge("optTime", queryDto.getOptTimeStart()));
         }
         if (queryDto.getOptTimeEnd() != null) {
-            filters.add(FieldFilters.le("optTime", queryDto.getOptTimeEnd()));
+            // 将结束时间调整为当天的23:59:59
+            LocalDateTime optTimeEnd = queryDto.getOptTimeEnd().withHour(23).withMinute(59).withSecond(59);
+            filters.add(FieldFilters.le("optTime", optTimeEnd));
+        }
+
+        // 接口调用状态
+        if (queryDto.getOptStatus() != null) {
+            filters.add(FieldFilters.eq("optStatus", queryDto.getOptStatus()));
         }
 
         // 业务处理状态
@@ -77,6 +81,9 @@ public class CaseDocumentLogServiceImpl implements ICaseDocumentLogService {
             filters.add(FieldFilters.eq("caseStatus", queryDto.getCaseStatus()));
         }
 
+        // 删除标识过滤
+        filters.add(FieldFilters.eq("deleted", false));
+
         // 按创建时间降序排序
         OrderCondition order = OrderCondition.desc("sysCreateTime");
 
@@ -102,16 +109,9 @@ public class CaseDocumentLogServiceImpl implements ICaseDocumentLogService {
     public int clearLogsByCondition(CaseDocumentLogQueryDto queryDto) {
         // 构建查询条件（与分页查询相同的逻辑）
         List<IFieldFilter> filters = new ArrayList<>();
-        
-        // 删除标识过滤
-        filters.add(FieldFilters.eq("deleted", false));
 
-        // 接口调用状态
-        if (queryDto.getOptStatus() != null) {
-            filters.add(FieldFilters.eq("optStatus", queryDto.getOptStatus()));
-        } else {
-            filters.add(FieldFilters.ge("optStatus", 1));
-        }
+        // 运行状态过滤
+        filters.add(FieldFilters.eq("runStatus", CaseDocumentLogRunStatusEnum.COMPLETED.getCode()));
 
         // 案例标题模糊查询
         if (StringUtil.isNotBlank(queryDto.getCaseTitle())) {
@@ -128,7 +128,14 @@ public class CaseDocumentLogServiceImpl implements ICaseDocumentLogService {
             filters.add(FieldFilters.ge("optTime", queryDto.getOptTimeStart()));
         }
         if (queryDto.getOptTimeEnd() != null) {
-            filters.add(FieldFilters.le("optTime", queryDto.getOptTimeEnd()));
+            // 将结束时间调整为当天的23:59:59
+            LocalDateTime optTimeEnd = queryDto.getOptTimeEnd().withHour(23).withMinute(59).withSecond(59);
+            filters.add(FieldFilters.le("optTime", optTimeEnd));
+        }
+
+        // 接口调用状态
+        if (queryDto.getOptStatus() != null) {
+            filters.add(FieldFilters.eq("optStatus", queryDto.getOptStatus()));
         }
 
         // 业务处理状态
@@ -136,9 +143,13 @@ public class CaseDocumentLogServiceImpl implements ICaseDocumentLogService {
             filters.add(FieldFilters.eq("caseStatus", queryDto.getCaseStatus()));
         }
 
+        // 删除标识过滤
+        filters.add(FieldFilters.eq("deleted", false));
+
         // 查询符合条件的所有记录
+        IFieldFilter[] filtersArray = filters.toArray(new IFieldFilter[0]);
         List<CaseDocumentLog> logsToDelete = caseDocumentLogDao.getGenericDao()
-                .findList(CaseDocumentLog.class, (IFieldFilter) filters);
+                .findList(CaseDocumentLog.class, filtersArray);
         
         if (logsToDelete.isEmpty()) {
             return 0;
@@ -170,56 +181,75 @@ public class CaseDocumentLogServiceImpl implements ICaseDocumentLogService {
             return false;
         }
         
-        log.info("开始重试AI调用，原始日志ID: {}, 案例标题: {}, 操作类型: {}", 
+        log.info("开始异步重试AI调用，原始日志ID: {}, 案例标题: {}, 操作类型: {}", 
                 logId, originalLog.getCaseTitle(), originalLog.getOptType());
         
-        // 2. 执行AI调用重试逻辑
+        // 2. 使用线程池异步执行AI调用重试逻辑
+        String optType = originalLog.getOptType();
+        String caseId = originalLog.getCaseId();
+        
+        aiDocExecutor.execute(() -> executeRetryLogic(optType, caseId, originalLog));
+        
+        // 立即返回true表示重试请求已接受，具体结果通过日志异步处理
+        return true;
+    }
+    
+    /**
+     * 执行AI调用重试逻辑
+     * @param optType 操作类型
+     * @param caseId 案例ID
+     */
+    private void executeRetryLogic(String optType, String caseId, CaseDocumentLog originalLog) {
         boolean retrySuccess = false;
         
         try {
-            // 根据操作类型调用对应的接口方法
-            String optType = originalLog.getOptType();
-            String caseId = originalLog.getCaseId();
-            
             if (StringUtil.isBlank(caseId)) {
                 throw new IllegalArgumentException("案例ID不能为空");
             }
             
-            log.info("正在执行AI调用重试，操作类型: {}, caseId: {}", optType, caseId);
+            log.info("[异步任务] 正在执行AI调用重试，操作类型: {}, caseId: {}", optType, caseId);
             
             // 根据操作类型执行对应的方法（这些方法内部会自动创建日志记录）
             if (CaseDocumentLogOptTypeEnum.CREATE.getCode().equals(optType)) {
                 // 上传案例文档
                 retrySuccess = caseKnowledgeService.uploadCaseDocument(caseId);
-                log.info("执行上传案例文档重试，caseId: {}, 结果: {}", caseId, retrySuccess);
+                log.info("[异步任务] 执行上传案例文档重试，caseId: {}, 结果: {}", caseId, retrySuccess);
                 
             } else if (CaseDocumentLogOptTypeEnum.DELETE.getCode().equals(optType)) {
                 // 删除案例文档
                 retrySuccess = caseKnowledgeService.deleteCaseDocument(caseId);
-                log.info("执行删除案例文档重试，caseId: {}, 结果: {}", caseId, retrySuccess);
+                log.info("[异步任务] 执行删除案例文档重试，caseId: {}, 结果: {}", caseId, retrySuccess);
                 
             } else if (CaseDocumentLogOptTypeEnum.UPDATE.getCode().equals(optType)) {
                 // 更新案例文档
-                retrySuccess = caseKnowledgeService.updateCaseDocument(caseId);
-                log.info("执行更新案例文档重试，caseId: {}, 结果: {}", caseId, retrySuccess);
+                retrySuccess = caseKnowledgeService.retryCaseDocument(caseId, originalLog);
+                log.info("[异步任务] 执行更新案例文档重试，caseId: {}, 结果: {}", caseId, retrySuccess);
                 
             } else {
                 throw new IllegalArgumentException("不支持的操作类型: " + optType);
             }
             
             if (retrySuccess) {
-                log.info("AI调用重试成功，操作类型: {}, caseId: {}", optType, caseId);
+                log.info("[异步任务] AI调用重试成功，操作类型: {}, caseId: {}", optType, caseId);
             } else {
-                log.warn("AI调用重试失败，操作类型: {}, caseId: {}", optType, caseId);
+                log.warn("[异步任务] AI调用重试失败，操作类型: {}, caseId: {}", optType, caseId);
             }
             
         } catch (Exception e) {
-            log.error("AI调用重试异常，操作类型: {}, caseId: {}", 
-                    originalLog.getOptType(), originalLog.getCaseId(), e);
-            retrySuccess = false;
+            log.error("[异步任务] AI调用重试异常，操作类型: {}, caseId: {}", 
+                    optType, caseId, e);
+        }
+    }
+
+    @Override
+    public boolean save(CaseDocumentLog caseDocumentLog) {
+        try {
+            caseDocumentLogDao.save(caseDocumentLog);
+            return true;
+        } catch (Exception e) {
+            log.error("保存CaseDocumentLog失败", e);
+            return false;
         }
-        
-        return retrySuccess;
     }
 
     /**
@@ -249,8 +279,6 @@ public class CaseDocumentLogServiceImpl implements ICaseDocumentLogService {
             return "";
         }
         switch (optStatus) {
-            case 0:
-                return "调用中";
             case 1:
                 return "调用成功";
             case 2:

servers/boe-server-all/src/main/java/com/xboe/module/boecase/service/impl/CasesServiceImpl.java

@@ -19,7 +19,9 @@ import com.xboe.common.utils.IDGenerator;
 import com.xboe.common.utils.StringUtil;
 import com.xboe.core.CurrentUser;
 import com.xboe.core.orm.*;
+import com.xboe.enums.CaseDocumentLogOptTypeEnum;
 import com.xboe.enums.CasesRankEnum;
+import com.xboe.module.boecase.async.CaseAiDocumentAsyncHandler;
 import com.xboe.module.boecase.dao.*;
 import com.xboe.module.boecase.dto.*;
 import com.xboe.module.boecase.entity.*;
@@ -90,6 +92,9 @@ public class CasesServiceImpl implements ICasesService {
     @Resource
     private ThirdApi thirdApi;
 
+    @Autowired
+    private CaseAiDocumentAsyncHandler caseAiDocumentAsyncHandler;
+
     /**
      * 案例分页查询，用于门户的查询
      */
@@ -799,7 +804,11 @@ public class CasesServiceImpl implements ICasesService {
      */
     @Override
     public void delete(String id) {
+        Cases cases = casesDao.get(id);
+        // 原删除
         casesDao.setDeleted(id);
+        // 增加逻辑
+        caseAiDocumentAsyncHandler.process(CaseDocumentLogOptTypeEnum.DELETE, cases);
     }
 
     /**
@@ -986,6 +995,8 @@ public class CasesServiceImpl implements ICasesService {
         cases.setMajorIds(majorIds);
         cases.setMajorType(stringBuffer.toString());
         casesDao.save(cases);
+        // 增加逻辑
+        caseAiDocumentAsyncHandler.process(CaseDocumentLogOptTypeEnum.CREATE, cases);
     }
 
     @Override
@@ -1009,6 +1020,8 @@ public class CasesServiceImpl implements ICasesService {
         cases.setMajorIds(majorIds);
         cases.setMajorType(stringBuffer.toString());
         casesDao.update(cases);
+        // 增加逻辑
+        caseAiDocumentAsyncHandler.process(CaseDocumentLogOptTypeEnum.UPDATE, cases);
     }
 
     @Override

servers/boe-server-all/src/main/java/com/xboe/module/boecase/service/impl/ElasticSearchIndexServiceImpl.java

@@ -0,0 +1,336 @@
+package com.xboe.module.boecase.service.impl;
+
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.xboe.constants.CaseAiConstants;
+import com.xboe.module.boecase.entity.AiChatConversationData;
+import com.xboe.module.boecase.service.IElasticSearchIndexService;
+import com.xboe.module.boecase.vo.CaseAiMessageVo;
+import com.xboe.module.boecase.vo.CaseReferVo;
+import lombok.extern.slf4j.Slf4j;
+import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
+import org.elasticsearch.action.index.IndexRequest;
+import org.elasticsearch.action.index.IndexResponse;
+import org.elasticsearch.action.search.SearchRequest;
+import org.elasticsearch.action.search.SearchResponse;
+import org.elasticsearch.action.support.master.AcknowledgedResponse;
+import org.elasticsearch.client.RequestOptions;
+import org.elasticsearch.client.RestHighLevelClient;
+import org.elasticsearch.client.indices.CreateIndexRequest;
+import org.elasticsearch.client.indices.CreateIndexResponse;
+import org.elasticsearch.client.indices.GetIndexRequest;
+import org.elasticsearch.common.settings.Settings;
+import org.elasticsearch.common.xcontent.XContentType;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.elasticsearch.search.SearchHit;
+import org.elasticsearch.search.SearchHits;
+import org.elasticsearch.search.builder.SearchSourceBuilder;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.io.IOException;
+import java.time.Duration;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+@Service
+@Slf4j
+public class ElasticSearchIndexServiceImpl implements IElasticSearchIndexService {
+
+    @Autowired(required = false)
+    private RestHighLevelClient elasticsearchClient;
+
+    @Override
+    public boolean checkIndexExists() {
+        if (elasticsearchClient == null) {
+            log.error("ElasticSearch客户端未配置");
+            return false;
+        }
+        // 检查索引是否存在
+        GetIndexRequest getIndexRequest = new GetIndexRequest(CaseAiConstants.CASE_AI_INDEX_NAME);
+        try {
+            return elasticsearchClient.indices().exists(getIndexRequest, RequestOptions.DEFAULT);
+        } catch (IOException e) {
+            log.error("查询ElasticSearch索引时发生异常", e);
+            return false;
+        }
+    }
+
+    @Override
+    public boolean createIndex() {
+        if (elasticsearchClient == null) {
+            log.error("ElasticSearch客户端未配置");
+            return false;
+        }
+        // 创建索引
+        CreateIndexRequest createIndexRequest = new CreateIndexRequest(CaseAiConstants.CASE_AI_INDEX_NAME);
+
+        // 设置索引配置
+        createIndexRequest.settings(Settings.builder()
+                .put("index.number_of_shards", 1)
+                .put("index.number_of_replicas", 0)
+                .put("index.analysis.analyzer.ik_max_word.tokenizer", "ik_max_word")
+                .put("index.analysis.analyzer.ik_smart.tokenizer", "ik_smart")
+        );
+
+        // 设置字段映射
+        String mapping = getAiChatMessagesMapping();
+        createIndexRequest.mapping(mapping, XContentType.JSON);
+
+        // 执行创建索引请求
+        CreateIndexResponse createIndexResponse = null;
+        try {
+            createIndexResponse = elasticsearchClient.indices()
+                    .create(createIndexRequest, RequestOptions.DEFAULT);
+        } catch (IOException e) {
+            log.error("创建ElasticSearch索引时发生异常", e);
+            return false;
+        }
+
+        if (createIndexResponse.isAcknowledged()) {
+            log.info("ElasticSearch索引 [{}] 创建成功", CaseAiConstants.CASE_AI_INDEX_NAME);
+            return true;
+        } else {
+            log.error("ElasticSearch索引 [{}] 创建可能失败，响应未确认", CaseAiConstants.CASE_AI_INDEX_NAME);
+            return false;
+        }
+    }
+
+    @Override
+    public boolean deleteIndex() {
+        if (elasticsearchClient == null) {
+            log.error("ElasticSearch客户端未配置");
+            return false;
+        }
+        // 执行删除索引请求
+        DeleteIndexRequest deleteRequest = new DeleteIndexRequest(CaseAiConstants.CASE_AI_INDEX_NAME);
+        try {
+            AcknowledgedResponse deleteResponse = elasticsearchClient.indices().delete(deleteRequest, RequestOptions.DEFAULT);
+            if (deleteResponse.isAcknowledged()) {
+                log.info("成功删除Elasticsearch索引: {}", CaseAiConstants.CASE_AI_INDEX_NAME);
+                return true;
+            } else {
+                log.error("删除索引 [{}] 未被确认（可能部分节点未响应）", CaseAiConstants.CASE_AI_INDEX_NAME);
+                return false;
+            }
+        } catch (IOException e) {
+            log.error("删除ElasticSearch索引时发生异常", e);
+            return false;
+        }
+    }
+
+    @Override
+    public boolean createData(AiChatConversationData conversationData) {
+        if (elasticsearchClient == null) {
+            log.error("未配置Elasticsearch客户端，无法保存对话记录");
+            return false;
+        }
+
+        try {
+            // 构建要保存的数据
+            JSONObject esData = new JSONObject();
+            esData.put("query", conversationData.getQuery());
+            esData.put("answer", conversationData.getAnswerAsString());
+            esData.put("conversationId", conversationData.getConversationId());
+            esData.put("userId", conversationData.getUserId());
+            // 持续时间
+            LocalDateTime now = LocalDateTime.now();
+            esData.put("startTime", conversationData.getStartTime().toString());
+            esData.put("timestamp", now.toString());
+            esData.put("durationSeconds", Duration.between(conversationData.getStartTime(), now).getSeconds());
+
+            // 构建 caseRefer 数据
+            JSONArray caseReferArray = new JSONArray();
+            for (CaseReferVo caseRefer : conversationData.getCaseRefers()) {
+                JSONObject caseReferObj = new JSONObject();
+                caseReferObj.put("caseId", caseRefer.getCaseId());
+                caseReferObj.put("title", caseRefer.getTitle());
+                caseReferObj.put("authorName", caseRefer.getAuthorName());
+                caseReferObj.put("keywords", caseRefer.getKeywords());
+                caseReferObj.put("content", caseRefer.getContent());
+                caseReferArray.add(caseReferObj);
+            }
+            esData.put("caseRefer", caseReferArray);
+
+            // 添加建议
+            esData.put("suggestions", conversationData.getSuggestions());
+
+            // 保存到ES
+            IndexRequest indexRequest = new IndexRequest("ai_chat_messages");
+            String dataStr = esData.toJSONString();
+            log.info("保存对话记录到ES：{}", dataStr);
+            indexRequest.source(dataStr, XContentType.JSON);
+
+            IndexResponse indexResponse = elasticsearchClient.index(indexRequest, RequestOptions.DEFAULT);
+            log.info("保存对话记录到ES成功，文档ID: {}", indexResponse.getId());
+            return true;
+        } catch (Exception e) {
+            log.error("保存对话记录到ES异常", e);
+            return false;
+        }
+    }
+
+    @Override
+    public List<CaseAiMessageVo> queryData(String conversationId) {
+        List<CaseAiMessageVo> list = new ArrayList<>();
+        if (elasticsearchClient == null) {
+            log.error("未配置Elasticsearch客户端，无法查询对话记录");
+            return list;
+        }
+        try {
+            // 从 ES 中查询消息记录
+            SearchRequest searchRequest = new SearchRequest(CaseAiConstants.CASE_AI_INDEX_NAME); // ES索引名，可以根据实际情况调整
+            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
+            searchSourceBuilder.query(QueryBuilders.termQuery("conversationId", conversationId));
+            searchSourceBuilder.size(1000); // 设置最大返回数量
+            searchRequest.source(searchSourceBuilder);
+
+            SearchResponse searchResponse = elasticsearchClient.search(searchRequest, RequestOptions.DEFAULT);
+            SearchHits hits = searchResponse.getHits();
+
+            for (SearchHit hit : hits) {
+                Map<String, Object> sourceMap = hit.getSourceAsMap();
+                CaseAiMessageVo data = parseMessageFromES(sourceMap);
+                if (data != null) {
+                    list.add(data);
+                }
+            }
+
+            log.info("从 ES 中查询到 {} 条消息记录", list.size());
+
+        } catch (Exception e) {
+            log.error("从 ES 查询会话消息记录异常", e);
+        }
+        return list;
+    }
+
+    private CaseAiMessageVo parseMessageFromES(Map<String, Object> sourceMap) {
+        try {
+            CaseAiMessageVo messageVo = new CaseAiMessageVo();
+            messageVo.setQuery((String) sourceMap.get("query"));
+            messageVo.setAnswer((String) sourceMap.get("answer"));
+            if (sourceMap.containsKey("startTime")) {
+                String startTimeStr = (String) sourceMap.get("startTime");
+                messageVo.setStartTime(LocalDateTime.parse(startTimeStr));
+            }
+            if (sourceMap.containsKey("durationSeconds")) {
+                messageVo.setDurationSeconds((Long) sourceMap.get("durationSeconds"));
+            }
+
+            // 解析 suggestions
+            if (sourceMap.containsKey("suggestions")) {
+                Object suggestionsObj = sourceMap.get("suggestions");
+                if (suggestionsObj instanceof List) {
+                    messageVo.setSuggestions((List<String>) suggestionsObj);
+                }
+            }
+
+            // 解析 caseRefer
+            if (sourceMap.containsKey("caseRefer")) {
+                Object caseReferObj = sourceMap.get("caseRefer");
+                if (caseReferObj instanceof List) {
+                    List<CaseReferVo> caseReferList = new ArrayList<>();
+                    List<Map<String, Object>> caseReferMaps = (List<Map<String, Object>>) caseReferObj;
+
+                    for (Map<String, Object> caseReferMap : caseReferMaps) {
+                        CaseReferVo caseRefer = new CaseReferVo();
+                        caseRefer.setCaseId((String) caseReferMap.get("caseId"));
+                        caseRefer.setTitle((String) caseReferMap.get("title"));
+                        caseRefer.setAuthorName((String) caseReferMap.get("authorName"));
+                        caseRefer.setContent((String) caseReferMap.get("content"));
+
+                        // 解析 keywords
+                        Object keywordsObj = caseReferMap.get("keywords");
+                        if (keywordsObj instanceof List) {
+                            caseRefer.setKeywords((List<String>) keywordsObj);
+                        }
+
+                        caseReferList.add(caseRefer);
+                    }
+                    messageVo.setCaseRefer(caseReferList);
+                }
+            }
+
+            return messageVo;
+        } catch (Exception e) {
+            log.error("解析ES消息数据异常", e);
+            return null;
+        }
+    }
+
+    /**
+     * 获取ai_chat_messages索引的字段映射配置
+     * 根据项目中的会话消息数据结构规范定义映射
+     *
+     * @return JSON格式的映射配置
+     */
+    private String getAiChatMessagesMapping() {
+        return "{\n" +
+                "  \"properties\": {\n" +
+                "    \"conversationId\": {\n" +
+                "      \"type\": \"keyword\",\n" +
+                "      \"index\": true\n" +
+                "    },\n" +
+                "    \"query\": {\n" +
+                "      \"type\": \"text\",\n" +
+                "      \"analyzer\": \"ik_max_word\",\n" +
+                "      \"search_analyzer\": \"ik_smart\",\n" +
+                "      \"fields\": {\n" +
+                "        \"keyword\": {\n" +
+                "          \"type\": \"keyword\",\n" +
+                "          \"ignore_above\": 256\n" +
+                "        }\n" +
+                "      }\n" +
+                "    },\n" +
+                "    \"answer\": {\n" +
+                "      \"type\": \"text\",\n" +
+                "      \"analyzer\": \"ik_max_word\",\n" +
+                "      \"search_analyzer\": \"ik_smart\"\n" +
+                "    },\n" +
+                "    \"caseRefer\": {\n" +
+                "      \"type\": \"nested\",\n" +
+                "      \"properties\": {\n" +
+                "        \"caseId\": {\n" +
+                "          \"type\": \"keyword\",\n" +
+                "          \"index\": true\n" +
+                "        },\n" +
+                "        \"title\": {\n" +
+                "          \"type\": \"text\",\n" +
+                "          \"analyzer\": \"ik_max_word\",\n" +
+                "          \"search_analyzer\": \"ik_smart\"\n" +
+                "        },\n" +
+                "        \"authorName\": {\n" +
+                "          \"type\": \"keyword\",\n" +
+                "          \"index\": true\n" +
+                "        },\n" +
+                "        \"keywords\": {\n" +
+                "          \"type\": \"text\",\n" +
+                "          \"analyzer\": \"ik_max_word\",\n" +
+                "          \"search_analyzer\": \"ik_smart\"\n" +
+                "        },\n" +
+                "        \"content\": {\n" +
+                "          \"type\": \"text\",\n" +
+                "          \"analyzer\": \"ik_max_word\",\n" +
+                "          \"search_analyzer\": \"ik_smart\"\n" +
+                "        }\n" +
+                "      }\n" +
+                "    },\n" +
+                "    \"suggestions\": {\n" +
+                "      \"type\": \"text\",\n" +
+                "      \"analyzer\": \"ik_max_word\",\n" +
+                "      \"search_analyzer\": \"ik_smart\"\n" +
+                "    },\n" +
+                "    \"userId\": {\n" +
+                "      \"type\": \"keyword\",\n" +
+                "      \"index\": true\n" +
+                "    },\n" +
+                "    \"timestamp\": {\n" +
+                "      \"type\": \"date\",\n" +
+                "      \"format\": \"yyyy-MM-dd HH:mm:ss||yyyy-MM-dd'T'HH:mm:ss||yyyy-MM-dd'T'HH:mm:ss.SSS||yyyy-MM-dd'T'HH:mm:ss.SSS'Z'||epoch_millis\"\n" +
+                "    }\n" +
+                "  }\n" +
+                "}";
+    }
+}

servers/boe-server-all/src/main/java/com/xboe/module/boecase/task/CaseAiChatDataTask.java

@@ -0,0 +1,77 @@
+package com.xboe.module.boecase.task;
+
+import com.xboe.module.boecase.service.ICaseAiChatService;
+import com.xxl.job.core.handler.annotation.XxlJob;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.time.LocalDateTime;
+import java.time.YearMonth;
+import java.time.format.DateTimeFormatter;
+
+@Component
+@Slf4j
+public class CaseAiChatDataTask {
+
+    @Autowired
+    private ICaseAiChatService caseAiChatService;
+
+
+    /**
+     * 查询上月聊天数据并下载
+     * cron: 0/10 * * * * ?
+     */
+    @XxlJob("chatDataExcelDownloadJob")
+    public void chatDataExcelDownload(String param) {
+        LocalDateTime startTime;
+        LocalDateTime endTime;
+        
+        if (param != null && !param.isEmpty()) {
+            // 解析参数，格式应为 "startTime,endTime"，例如 "2023-01-01T00:00:00,2023-01-31T23:59:59"
+            String[] times = param.split(",");
+            if (times.length == 2) {
+                DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss");
+                try {
+                    startTime = LocalDateTime.parse(times[0], formatter);
+                    endTime = LocalDateTime.parse(times[1], formatter);
+                    log.info("使用参数指定的时间范围: {} 到 {}", startTime, endTime);
+                } catch (Exception e) {
+                    log.error("解析时间参数失败，使用默认时间范围", e);
+                    // 使用默认逻辑
+                    LocalDateTime now = LocalDateTime.now();
+                    YearMonth lastMonth = YearMonth.from(now).minusMonths(1);
+                    startTime = now.minusMonths(1)
+                            .withDayOfMonth(1)
+                            .withHour(0)
+                            .withMinute(0)
+                            .withSecond(0);
+                    endTime = lastMonth.atEndOfMonth().atTime(23, 59, 59);
+                }
+            } else {
+                // 使用默认逻辑
+                LocalDateTime now = LocalDateTime.now();
+                YearMonth lastMonth = YearMonth.from(now).minusMonths(1);
+                startTime = now.minusMonths(1)
+                        .withDayOfMonth(1)
+                        .withHour(0)
+                        .withMinute(0)
+                        .withSecond(0);
+                endTime = lastMonth.atEndOfMonth().atTime(23, 59, 59);
+            }
+        } else {
+            // 使用默认逻辑
+            LocalDateTime now = LocalDateTime.now();
+            YearMonth lastMonth = YearMonth.from(now).minusMonths(1);
+            startTime = now.minusMonths(1)
+                    .withDayOfMonth(1)
+                    .withHour(0)
+                    .withMinute(0)
+                    .withSecond(0);
+            endTime = lastMonth.atEndOfMonth().atTime(23, 59, 59);
+        }
+        
+        // 执行
+        caseAiChatService.downloadConversationExcel(startTime, endTime);
+    }
+}

servers/boe-server-all/src/main/java/com/xboe/module/boecase/task/CaseDocumentLogTask.java

@@ -0,0 +1,27 @@
+package com.xboe.module.boecase.task;
+
+import com.xboe.module.boecase.service.ICaseKnowledgeService;
+import com.xxl.job.core.handler.annotation.XxlJob;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+@Slf4j
+public class CaseDocumentLogTask {
+
+    @Autowired
+    private ICaseKnowledgeService caseKnowledgeService;
+
+    /**
+     * 批量查询文件状态并修改
+     * 目前每次查看10条数据，批处理拟每10秒一次，每分钟可运行6次，60条数据
+     * cron: 0/10 * * * * ?
+     */
+    @XxlJob("batchCheckFileStatusJob")
+    public void batchCheckFileStatusJob() {
+//        log.info("开始批量查询文件状态");
+        caseKnowledgeService.batchCheckFileStatus();
+//        log.info("结束批量查询文件状态");
+    }
+}

servers/boe-server-all/src/main/java/com/xboe/module/boecase/task/CaseUploadTask.java

@@ -0,0 +1,140 @@
+package com.xboe.module.boecase.task;
+
+import com.xboe.constants.CaseAiConstants;
+import com.xboe.enums.CaseDocumentLogCaseStatusEnum;
+import com.xboe.enums.CaseDocumentLogOptStatusEnum;
+import com.xboe.enums.CaseDocumentLogOptTypeEnum;
+import com.xboe.enums.CaseDocumentLogRunStatusEnum;
+import com.xboe.module.boecase.async.CaseAiDocumentAsyncHandler;
+import com.xboe.module.boecase.dao.CaseDocumentLogDao;
+import com.xboe.module.boecase.dao.CasesDao;
+import com.xboe.module.boecase.entity.CaseDocumentLog;
+import com.xboe.module.boecase.entity.Cases;
+import com.xxl.job.core.handler.annotation.XxlJob;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.redis.core.StringRedisTemplate;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * 旧案例上传
+ */
+@Component
+@Slf4j
+public class CaseUploadTask {
+
+    @Resource
+    private CasesDao casesDao;
+
+    @Resource
+    private CaseDocumentLogDao caseDocumentLogDao;
+
+    @Autowired
+    private CaseAiDocumentAsyncHandler caseAiDocumentAsyncHandler;
+
+    @Autowired
+    private StringRedisTemplate stringRedisTemplate;
+
+    private static final String CASE_UPLOAD_LAST_ID_KEY = "case:upload:last:id";
+
+    @XxlJob("oldDataUploadJob")
+    public void oldDataUploadJob() {
+        try {
+//            log.info("开始执行旧案例上传任务");
+
+            // 从Redis获取上次处理的最后一条记录ID
+            String lastProcessedId = stringRedisTemplate.opsForValue().get(CASE_UPLOAD_LAST_ID_KEY);
+//            log.info("上次处理的最后一条记录ID: {}", lastProcessedId);
+
+            // 查询符合条件的案例数据
+            List<Cases> casesToProcess = findCasesToProcess(lastProcessedId);
+//            log.info("查询到待处理案例数量: {}", casesToProcess.size());
+
+            if (casesToProcess.isEmpty()) {
+//                log.info("没有需要处理的案例数据");
+                return;
+            }
+
+            // 批量检查这些案例是否已在CaseDocumentLog中存在记录，提升性能
+            List<String> caseIds = new ArrayList<>();
+            for (Cases cases : casesToProcess) {
+                caseIds.add(cases.getId());
+            }
+
+            // 一次性查询所有相关案例的记录
+            List<CaseDocumentLog> existingLogs = caseDocumentLogDao.getGenericDao()
+                    .findList(CaseDocumentLog.class,
+                            com.xboe.core.orm.FieldFilters.in("caseId", caseIds));
+
+            // 过滤出未在CaseDocumentLog中存在的案例
+            List<Cases> casesList = new ArrayList<>();
+            for (Cases cases : casesToProcess) {
+                boolean exists = false;
+                for (CaseDocumentLog log : existingLogs) {
+                    if (cases.getId().equals(log.getCaseId())
+                            && StringUtils.equals(log.getRequestUrl(), CaseAiConstants.CASE_DOC_UPLOAD_INTERFACE_NAME)
+                            && Objects.equals(log.getRunStatus(), CaseDocumentLogRunStatusEnum.COMPLETED.getCode())
+                            && Objects.equals(log.getOptStatus(), CaseDocumentLogOptStatusEnum.SUCCESS.getCode())
+                            && Objects.equals(log.getRunStatus(), CaseDocumentLogCaseStatusEnum.SUCCESS.getCode())) {
+                        exists = true;
+                        break;
+                    }
+                }
+                if (!exists) {
+                    casesList.add(cases);
+                }
+            }
+
+//            log.info("过滤后需要处理的案例数量: {}", casesList.size());
+
+            if (!casesList.isEmpty()) {
+                // 调用异步处理方法
+                caseAiDocumentAsyncHandler.process(CaseDocumentLogOptTypeEnum.CREATE, casesList.toArray(new Cases[0]));
+
+                // 将当前处理的最后一条数据ID存入Redis
+                String currentLastId = casesList.get(casesList.size() - 1).getId();
+                stringRedisTemplate.opsForValue().set(CASE_UPLOAD_LAST_ID_KEY, currentLastId);
+                log.info("已处理案例，最后一条记录ID已更新为: {}", currentLastId);
+            } else {
+                log.info("没有新的案例需要处理");
+            }
+
+//            log.info("旧案例上传任务执行完成");
+        } catch (Exception e) {
+            log.error("执行旧案例上传任务时发生异常", e);
+        }
+    }
+
+    /**
+     * 查询需要处理的案例数据
+     *
+     * @param lastProcessedId 上次处理的最后一条记录ID
+     * @return 案例列表
+     */
+    private List<Cases> findCasesToProcess(String lastProcessedId) {
+        com.xboe.core.orm.QueryBuilder queryBuilder = com.xboe.core.orm.QueryBuilder.from(Cases.class);
+        queryBuilder.addFilter(com.xboe.core.orm.FieldFilters.eq("deleted", false));
+        // 只处理有文件路径的案例
+        queryBuilder.addFilter(com.xboe.core.orm.FieldFilters.isNotNull("filePath"));
+        queryBuilder.addFilter(com.xboe.core.orm.FieldFilters.ne("filePath", ""));
+        
+        // 如果有上次处理的ID，则从该ID之后开始查询
+        if (lastProcessedId != null && !lastProcessedId.isEmpty()) {
+            queryBuilder.addFilter(com.xboe.core.orm.FieldFilters.gt("id", lastProcessedId));
+        }
+        
+        // 按创建时间升序排序
+        queryBuilder.addOrder(com.xboe.common.OrderCondition.asc("id"));
+        // 限制每次处理的数量，避免一次性处理太多数据
+        queryBuilder.setPageSize(100);
+        
+        return casesDao.findList(queryBuilder.builder());
+    }
+}

servers/boe-server-all/src/main/java/com/xboe/module/boecase/vo/CaseAiMessageVo.java

@@ -2,6 +2,7 @@ package com.xboe.module.boecase.vo;
 
 import lombok.Data;
 
+import java.time.LocalDateTime;
 import java.util.List;
 
 /**
@@ -20,6 +21,16 @@ public class CaseAiMessageVo {
      */
     private String answer;
 
+    /**
+     * 会话开始时间
+     */
+    private LocalDateTime startTime;
+
+    /**
+     * 会话时长(秒)
+     */
+    private Long durationSeconds;
+
     /**
      * 案例引用列表
      */

servers/boe-server-all/src/main/java/com/xboe/module/boecase/vo/CaseReferVo.java

@@ -1,7 +1,10 @@
 package com.xboe.module.boecase.vo;
 
+import com.fasterxml.jackson.annotation.JsonFormat;
 import lombok.Data;
+import org.springframework.format.annotation.DateTimeFormat;
 
+import java.time.LocalDateTime;
 import java.util.List;
 
 /**
@@ -25,6 +28,18 @@ public class CaseReferVo {
      */
     private String authorName;
 
+    /**
+     * 组织信息
+     */
+    private String orgInfo;
+
+    /**
+     * 上传时间
+     */
+    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private LocalDateTime uploadTime;
+
     /**
      * 关键词列表
      */

servers/boe-server-all/src/main/java/com/xboe/module/boecase/vo/ConversationExcelVo.java

@@ -0,0 +1,31 @@
+package com.xboe.module.boecase.vo;
+
+import lombok.Data;
+import java.time.LocalDateTime;
+import java.util.List;
+
+/**
+ * 会话Excel导出VO
+ */
+@Data
+public class ConversationExcelVo {
+    /**
+     * 会话ID
+     */
+    private String conversationId;
+    
+    /**
+     * 会话名称
+     */
+    private String conversationName;
+    
+    /**
+     * 用户
+     */
+    private String user;
+    
+    /**
+     * 问答记录
+     */
+    private List<CaseAiMessageVo> messages;
+}

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;
 
 	/**
 	 * 教师需要审核的课程
@@ -358,8 +356,10 @@ public class CourseAuditApi  extends ApiBaseController{
 				//修改在线课开课状态=已开课
 				String token = request.getHeader("Xboe-Access-Token");
 				CourseParam param = new CourseParam();
-				param.setId(courseId);
-				thirdApi.updateOnLineStatua(param,token);
+				param.setId(c.getId());
+                param.setOrgId(c.getOrgId());
+                param.setOrgName(c.getOrgName());
+				thirdApi.updateOrSaveCourse(param,token);
 			}
 			return success(true);
 		} catch (Exception e) {
@@ -424,6 +424,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);

servers/boe-server-all/src/main/java/com/xboe/module/course/api/CourseFileApi.java

@@ -15,6 +15,8 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
+import it.sauronsoftware.jave.Encoder;
+import it.sauronsoftware.jave.MultimediaInfo;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.orm.ObjectOptimisticLockingFailureException;
 import org.springframework.web.bind.annotation.GetMapping;
@@ -46,8 +48,6 @@ import com.xboe.module.scorm.SCORMParser;
 import com.xboe.standard.BaseConstant;
 import com.xboe.standard.enums.BoedxCourseFileType;
 
-import it.sauronsoftware.jave.Encoder;
-import it.sauronsoftware.jave.MultimediaInfo;
 import lombok.extern.slf4j.Slf4j;
 
 /**
@@ -256,7 +256,7 @@ public class CourseFileApi extends ApiBaseController {
         }
         String fileFullPath = SysConstant.getConfigValue(BaseConstant.CONFIG_UPLOAD_FILES_SAVEPATH) + file.getFilePath();
         if ("mp3,mp4".indexOf(file.getFileType()) > -1){
-        	log.info("上传 "+file.getFileType()+"文件:"+file.getFilePath());
+            log.info("上传 "+file.getFileType()+"文件:"+file.getFilePath());
             Encoder encoder = new Encoder();
             try {
                 //System.out.println(fileFullPath);
@@ -278,8 +278,8 @@ public class CourseFileApi extends ApiBaseController {
                     }
                 }
             } catch (Exception e) {
-                log.error("读取视频时长错误");
-//                e.printStackTrace();
+                log.error("读取视频时长错误", e);
+                return error("视频解析失败，尝试重新上传或联系管理员", "视频解析失败，尝试重新上传或联系管理员");
             }
         }
 

servers/boe-server-all/src/main/java/com/xboe/module/course/api/CourseFullTextApi.java

@@ -11,6 +11,9 @@ 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.*;
@@ -74,6 +77,8 @@ public class CourseFullTextApi  extends ApiBaseController{
 	@Autowired
 	StringRedisTemplate redisTemplate;
 
+
+
 	/**
 	 * 课程的初始化
 	 * @return
@@ -309,14 +314,30 @@ 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 = paras.getKeywords();
-			if (tagName != null && tagName != ""){
-				CourseTag courseTag = courseTagService.getTagByName(tagName);
-				if (courseTag != null){
-					paras.setTags(courseTag.getId().toString()+",");
+			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));
 				}
 			}
 		}
@@ -411,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);
+				}
+
 			}
 
 

servers/boe-server-all/src/main/java/com/xboe/module/course/api/CourseManageApi.java

@@ -2,11 +2,14 @@
 
 import java.io.OutputStream;
 import java.util.*;
+import java.util.stream.Collectors;
 
 import javax.annotation.Resource;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
+import com.boe.feign.api.infrastructure.entity.CommonSearchVo;
+import com.boe.feign.api.infrastructure.entity.Dict;
 import com.xboe.api.ThirdApi;
 import com.xboe.module.course.dto.*;
 import com.xboe.module.course.entity.*;
@@ -84,6 +87,7 @@ public class CourseManageApi extends ApiBaseController{
 	private ICourseTagService tagService;
 	@Resource
 	IOutSideDataService outSideDataService;
+	
 	@Autowired
     IDataUserSyncService userSyncService;
 	@Resource
@@ -158,7 +162,19 @@ 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())){
+
+        CommonSearchVo searcher = new CommonSearchVo();
+        searcher.setPid(637L);
+        searcher.setType(1);
+		List<Dict> dictList = thirdApi.getDictItems(searcher);
+		boolean isPermission = false;
+        if(dictList != null && dictList.size() > 0){
+			List<String> dicts =  dictList.stream().map(Dict::getValue).collect(Collectors.toList());
+			isPermission = dicts.contains(course.getOrgId());
+			rs.put("dicts",dicts);
+		}
+		log.error("-------是否仅内网查看 = " + isPermission);
+		if (StringUtils.isNotBlank(course.getTags()) && course.getTags().matches("[0-9,]+")){
 			List<CourseTag> tagList = tagService.getTagsByIds(course.getTags());
 			rs.put("tagList", tagList);
 		}
@@ -169,11 +185,30 @@ public class CourseManageApi extends ApiBaseController{
 		rs.put("sections",sectionlist);
 		rs.put("teachers",teachers);
 		rs.put("crowds",crowds);
+		rs.put("isPermission",isPermission);
+
 
 		
 		return success(rs);
 		
 	}
+	@GetMapping("/getDictIds")
+	public JsonResponse<Map<String,Object>> getDictIds(Long pid,Integer type){
+		CommonSearchVo searcher = new CommonSearchVo();
+		if(pid==null || type ==null){
+			return badRequest("参数错误");
+		}
+		Map<String,Object> rs=new HashMap<String,Object>();
+		searcher.setPid(pid);
+		searcher.setType(type);
+		List<Dict> dictList = thirdApi.getDictItems(searcher);
+		rs.put("dicts",null);
+		if(dictList != null && dictList.size() > 0){
+			List<String> dicts =  dictList.stream().map(Dict::getValue).collect(Collectors.toList());
+			rs.put("dicts",dicts);
+		}
+		return success(rs);
+	}
 	
 	/**
 	 * 管理员审核列表，教师的审核不在这里，此审核也应该移动CourseAuditApi中去
@@ -263,6 +298,7 @@ public class CourseManageApi extends ApiBaseController{
 	@PostMapping("/save")
 	@AutoLog(module = "课程",action = "保存课程基本信息",info = "")
 	public JsonResponse<CourseFullDto> saveCourseFull(@RequestBody CourseFullDto dto, HttpServletRequest request){
+		log.info("-------- 保存课程的全部信息 ------- 课程信息 = {} " , dto.getCourse());
 		if(dto.getCourse()==null){
 			return badRequest("无课程信息");
 		}
@@ -283,6 +319,27 @@ public class CourseManageApi extends ApiBaseController{
 		
 		//填充必要的信息
 		try {
+			log.info("-------- 标签相关开始 ------- 课程ID = {} " , dto.getCourse().getId());
+			log.info("-------- 标签相关开始 ------- 课程TAG = {} " , dto.getCourse().getTags());
+			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("-------- 不是纯数字 -------oldtags tag = {} " , tag);
+						oldCourse.setTags(null); // 兼容
+						break;
+					}
+				}
+			}
+			log.info("-------- 标签相关 updateTags ------- oldtags = {} " , oldCourse.getTags());
+			log.info("-------- 标签相关 updateTags ------- newtags = {} " , dto.getCourse().getTags());
+			tagService.updateTags(oldCourse,dto.getCourse(),userInfo);
+			log.info("-------- 标签相关结束 ------newtags = {} " , dto.getCourse().getTags());
+
 			if(StringUtils.isBlank(dto.getCourse().getId())) {
 				//只有在第一次添加保存时才会这样
 				fillCourseData(dto.getCourse());
@@ -310,8 +367,6 @@ public class CourseManageApi extends ApiBaseController{
 	
 	/***
 	 * 仅仅是保存
-	 * @param dto
-	 * @return
 	 */
 	@PostMapping("/save-only-course")
 	@AutoLog(module = "课程",action = "保存课程基本信息",info = "")
@@ -338,6 +393,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);
@@ -688,7 +747,6 @@ public class CourseManageApi extends ApiBaseController{
 	
 	/**
 	 * 审核课程，这个是管理人员的审核。老师审核不在这里处理.
-	 * @param id
 	 * @param title
 	 * @param pass
 	 * @param remark
@@ -722,7 +780,6 @@ public class CourseManageApi extends ApiBaseController{
 	
 	/**
 	 * 审核并发布,未完成的处理，
-	 * @param id
 	 * @param title
 	 * @param pass
 	 * @param remark
@@ -766,10 +823,6 @@ public class CourseManageApi extends ApiBaseController{
 	
 	/**
 	 * 发布课程信息,已经没有单独的发布了
-	 * @param id
-	 * @param title
-	 * @param pass
-	 * @param remark
 	 * @return
 	 */
 	@Deprecated
@@ -1167,5 +1220,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);
+	}
 }

servers/boe-server-all/src/main/java/com/xboe/module/course/api/CoursePortalApi.java

@@ -13,10 +13,7 @@ import com.xboe.module.course.dto.CourseTeacherDto;
 import com.xboe.module.course.dto.RankingDto;
 import com.xboe.module.course.dto.TeacherCourseDto;
 import com.xboe.module.course.entity.*;
-import com.xboe.module.course.service.ICourseContentService;
-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.course.service.*;
 import com.xboe.module.course.vo.CourseStudyVo;
 import com.xboe.module.course.vo.TeacherVo;
 import com.xboe.module.teacher.entity.Teacher;
@@ -33,6 +30,7 @@ import com.xboe.system.user.entity.User;
 import com.xboe.system.user.service.IUserService;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.redis.core.StringRedisTemplate;
 import org.springframework.web.bind.annotation.*;
@@ -97,6 +95,8 @@ public class CoursePortalApi extends ApiBaseController{
 
 	@Autowired
 	StringRedisTemplate redisTemplate;
+	@Resource
+	private ICourseTagService courseTagService;
 
 	/**
 	 * 根据多个课程id返回对应的课程的图片.返回结果如下，
@@ -261,7 +261,14 @@ public class CoursePortalApi extends ApiBaseController{
 		if(course==null || course.getDeleted()){
 			return badRequest("课程不存在或已被删除");
 		}
-		rs.put("course",course);
+		Course course1 = new Course();
+		BeanUtils.copyProperties(course,course1);
+		if (StringUtils.isNotBlank(course.getTags()) && course.getTags().matches("[0-9,]+")) {
+			List<CourseTag> tagList = courseTagService.getTagsByIds(course.getTags());
+			String tags = tagList.stream().map(CourseTag::getTagName).collect(Collectors.joining(","));
+			course1.setTags(tags);
+		}
+		rs.put("course",course1);
 
 		List<CourseCrowd> courseCrowdList = courseService.findCrowdByCourseId(id);
 		if(crowd!=null && crowd) {

servers/boe-server-all/src/main/java/com/xboe/module/course/api/CourseTagApi.java

@@ -23,8 +23,10 @@ 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
@@ -45,8 +47,10 @@ public class CourseTagApi extends ApiBaseController {
      * @param courseTagQueryDto
      * @return
      */
-    @RequestMapping(value="/page",method= {RequestMethod.GET,RequestMethod.POST})
+   /* @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){
@@ -76,21 +80,25 @@ public class CourseTagApi extends ApiBaseController {
                 }
             }
         }
+        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的课程标签的热点属性
@@ -98,16 +106,18 @@ public class CourseTagApi extends ApiBaseController {
      * @param isHot
      * @return
      */
-    @RequestMapping(value="/changeHotStatus",method= RequestMethod.POST)
-    public JsonResponse<Boolean> changeHotStatus(Long id,Boolean isHot){
-        return courseTagService.changeHotStatus(id,isHot);
-    }
+/*    @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;
@@ -118,11 +128,13 @@ public class CourseTagApi extends ApiBaseController {
         }
         return success(list);
     }
+*/
 
     /**
      * 解除指定id的课程和某个标签之间的关联关系
      * @return
      */
+/*
     @RequestMapping(value="/unbind",method= RequestMethod.POST)
     public JsonResponse<Void> unbindCourseTagRelation(CourseTagRelationDto courseTagRelationDto){
         if (courseTagRelationDto!=null){
@@ -131,18 +143,19 @@ public class CourseTagApi extends ApiBaseController {
         }
         return error("解绑失败！");
     }
+*/
 
     /**
      * 模糊检索标签
      * @return 符合检索条件的所有公共标签
      */
     @RequestMapping(value="/searchTags",method= RequestMethod.POST)
-    public JsonResponse<List<CourseTag>> searchTags(String tagName){
-        if (StringUtils.isNotBlank(tagName)){
-            List<CourseTag> courseTagList = courseTagService.searchTags(tagName);
-            return success(courseTagList);
-        }
-        return error("服务器端异常！");
+    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);
     }
 
     /**
@@ -152,8 +165,14 @@ public class CourseTagApi extends ApiBaseController {
      */
     @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("创建标签失败！");

servers/boe-server-all/src/main/java/com/xboe/module/course/dao/CourseTagDao.java

@@ -10,6 +10,7 @@ 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;
@@ -17,6 +18,7 @@ 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;
 
 /**
@@ -24,6 +26,8 @@ import java.util.List;
  * @author:zhengge@oracle.com
  * @since:2025/7/2516:50
  */
+
+@Slf4j
 @Repository
 public class CourseTagDao extends BaseDao<CourseTag> {
     @PersistenceContext
@@ -38,10 +42,10 @@ public class CourseTagDao extends BaseDao<CourseTag> {
             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\n" +
-                    "where t.is_hot = true\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,relation_count desc";  // 数据库字段为last_set_hot_time
+                    "order by t.last_set_hot_time desc";  // 数据库字段为last_set_hot_time
 
             // 创建原生查询并指定结果映射到CourseTag实体
             javax.persistence.Query query = entityManager.createNativeQuery(sql, CourseTag.class);
@@ -65,7 +69,7 @@ public class CourseTagDao extends BaseDao<CourseTag> {
         // 原生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 " +
+                "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";
@@ -101,7 +105,98 @@ public class CourseTagDao extends BaseDao<CourseTag> {
     }
 
     public CourseTag getTagByName(String tagName) {
-        CourseTag courseTag = this.findOne((FieldFilters.eq("tag_name", 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 ");
+        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 ");
+        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 ");
+        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 ");
+
+        if (StringUtils.isNotBlank(typeId)) {
+            sql.append("ORDER BY  ");
+            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;
+    }
+
+
+
+
+
 }

servers/boe-server-all/src/main/java/com/xboe/module/course/dao/CourseTagRelationDao.java

@@ -114,11 +114,17 @@ public class CourseTagRelationDao extends BaseDao<CourseTagRelation> {
         return new PageList<CourseTagRelationDto>(list,totalresults!=null?totalresults.size():0);
     }
 
-    public boolean countHotTags() {
-        String sql = "SELECT COUNT(*) FROM boe_course_tag WHERE is_hot = 1";
+    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);
-        Object result = query.getSingleResult();
-        long count = Long.parseLong(result.toString());
-        return   count >= 10;
+        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();
     }
 }

servers/boe-server-all/src/main/java/com/xboe/module/course/dao/CourseTeacherDeletedRecordDao.java

@@ -0,0 +1,9 @@
+package com.xboe.module.course.dao;
+
+import com.xboe.core.orm.BaseDao;
+import com.xboe.module.course.entity.CourseTeacherDeletedRecord;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public class CourseTeacherDeletedRecordDao extends BaseDao<CourseTeacherDeletedRecord> {
+}

servers/boe-server-all/src/main/java/com/xboe/module/course/dao/ModifyLogDao.java

@@ -0,0 +1,20 @@
+package com.xboe.module.course.dao;
+
+import com.xboe.core.orm.BaseDao;
+import com.xboe.module.course.entity.ModifyLog;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public class ModifyLogDao extends BaseDao<ModifyLog> {
+
+    public void insert(String requestId, String location, String body, String remark) {
+        ModifyLog entity = new ModifyLog();
+        entity.setRequestId(requestId);
+        entity.setLocation(location);
+        entity.setBody(body);
+        entity.setRemark(remark);
+
+        save(entity);
+    }
+
+}

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> {
+}

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;
@@ -141,4 +142,5 @@ public class CourseQueryDto {
     private String userId;
 
     private String tags;
+
 }

servers/boe-server-all/src/main/java/com/xboe/module/course/entity/Course.java

@@ -33,7 +33,10 @@ public class Course extends BaseEntity {
     
     /**所有的设备*/
     public static int DEVICE_ALL=3;
-    
+
+    /**仅内网*/
+    public static int DEVICE_INTERNAL=4;
+
     /**未提交，草稿*/
     public static final int STATUS_NONE=1;
     
@@ -396,7 +399,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;

servers/boe-server-all/src/main/java/com/xboe/module/course/entity/CourseTag.java

@@ -49,6 +49,12 @@ public class CourseTag extends BaseEntity {
     @Column(name = "use_count",length = 1)
     private Integer useCount;
 
+    /**
+     * 1临时， 0正式
+     */
+    @Column(name = "status",length = 1)
+    private Integer status;
+
     /**
      * 最近设置为公共标签的时间
      */

servers/boe-server-all/src/main/java/com/xboe/module/course/entity/CourseTeacherDeletedRecord.java

@@ -0,0 +1,43 @@
+package com.xboe.module.course.entity;
+
+import com.xboe.core.SysConstant;
+import com.xboe.core.orm.IdBaseEntity;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Table;
+
+/**
+ * 课程任课教师删除记录
+ */
+@Data
+@Entity
+@EqualsAndHashCode(callSuper = false)
+@Table(name = SysConstant.TABLE_PRE + "course_teacher_deleted_record")
+public class CourseTeacherDeletedRecord extends IdBaseEntity {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 课程id
+     */
+    @Column(name = "course_id", nullable = false, length = 20)
+    private String courseId;
+
+    /**
+     * 教师id，实际上就是aid
+     *
+     */
+    @Column(name = "teacher_id", nullable = false, length = 20)
+    private String teacherId;
+
+    /**
+     * 教师姓名
+     *
+     */
+    @Column(name = "teacher_name", length = 30)
+    private String teacherName;
+
+}

servers/boe-server-all/src/main/java/com/xboe/module/course/entity/ModifyLog.java

@@ -0,0 +1,45 @@
+package com.xboe.module.course.entity;
+
+import com.xboe.core.SysConstant;
+import com.xboe.core.orm.IdBaseEntity;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+
+import javax.persistence.Entity;
+import javax.persistence.Table;
+
+/**
+ * 讲师删除记录表
+ * 为了监控PngCode-SZX-1227问题临时创建的表
+ *
+ * @author guo jia
+ */
+@Data
+@Entity
+@ToString(callSuper = true)
+@EqualsAndHashCode(callSuper = true)
+@Table(name = SysConstant.TABLE_PRE + "modify_log")
+public class ModifyLog extends IdBaseEntity {
+
+    /**
+     * 请求ID
+     */
+    private String requestId;
+
+    /**
+     * 位置
+     */
+    private String location;
+
+    /**
+     * 请求body
+     */
+    private String body;
+
+    /**
+     * 备注信息
+     */
+    private String remark;
+
+}

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;
+
+}

servers/boe-server-all/src/main/java/com/xboe/module/course/service/ICourseService.java

@@ -343,4 +343,12 @@ public interface ICourseService {
 
     List<Course> findByIds(List<String> courseIds);
     void deletedStudyResourceBatchByCourseIdAndType(String courseId,Integer courseType);
+
+    void saveTip(String aid);
+
+    Boolean getCourseTip(String aid);
+
+    void rePublish(String courseId);
+
+//    void getPhpCourseData();
 }

servers/boe-server-all/src/main/java/com/xboe/module/course/service/ICourseTagService.java

@@ -2,10 +2,17 @@ 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;
 
@@ -42,12 +49,11 @@ public interface ICourseTagService {
 
     /**
      * 修改指定id的课程标签的热点属性
-     *
      * @param id
      * @param isHot
      * @return
      */
-    JsonResponse<Boolean> changeHotStatus(Long id, Boolean isHot);
+    void changeHotStatus(Long id,Boolean isHot);
 
     /**
      * 解除指定id的课程和某个标签之间的关联关系
@@ -60,7 +66,7 @@ public interface ICourseTagService {
      * @param tagName
      * @return 符合检索条件的所有公共标签
      */
-    List<CourseTag> searchTags(String tagName);
+    List<CourseTag> searchTags(String tagName,String userId,String typeId);
 
     /**
      * 创建新标签,并与当前课程绑定
@@ -85,5 +91,7 @@ public interface ICourseTagService {
 
     CourseTag getTagByName(String tagName);
 
-    void bindTag(String id, String tags);
+    void updateTags(Course oldCourse,Course newCourse,CurrentUser userInfo);
+
+    List<CourseTag> getAllTags();
 }

servers/boe-server-all/src/main/java/com/xboe/module/course/service/impl/CourseServiceImpl.java

@@ -15,13 +15,27 @@ import java.util.stream.Stream;
 import javax.annotation.Resource;
 import javax.management.Query;
 
+import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.collection.CollectionUtil;
+import cn.hutool.json.JSONUtil;
+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.entity.*;
+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;
@@ -42,24 +56,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;
@@ -126,9 +125,15 @@ public class CourseServiceImpl implements ICourseService {
 
     @Resource
     RestHighLevelClient restHighLevelClient;
+    @Resource
+    private TipDao tipDao;
 
+    @Resource
+    private CourseTeacherDeletedRecordDao courseTeacherDeletedRecordDao;
+
+    @Resource
+    private ModifyLogDao modifyLogDao;
 
-  
     /**
      * 生成过滤条件
      *
@@ -185,6 +190,8 @@ public class CourseServiceImpl implements ICourseService {
                 filters.add(FieldFilters.in("device", Course.DEVICE_MOBILE, Course.DEVICE_ALL));
             } else if (dto.getDevice() == Course.DEVICE_ALL) {
                 filters.add(FieldFilters.eq("device", Course.DEVICE_ALL));
+            } else if (dto.getDevice() == Course.DEVICE_INTERNAL) {
+                filters.add(FieldFilters.eq("device", Course.DEVICE_INTERNAL));
             }
 
         }
@@ -425,30 +432,30 @@ public class CourseServiceImpl implements ICourseService {
         if (TempFilterConfig.Manager_CourseFile_ByOrgIds) {
             if (dto.getIsSystemAdmin() == null || !dto.getIsSystemAdmin()) {
                 List<String> finalStrings = strings;
-                log.info("dto为"+dto);
-                if(dto.getIsCreateCourse()!=null&&dto.getIsCreateCourse()){
+                log.info("dto为" + dto);
+                if (dto.getIsCreateCourse() != null && dto.getIsCreateCourse()) {
                     listByFilters2.removeIf(e -> {
                         //去掉未发布的课程
                         if (!e.getPublished() && seache.contains(e.getId()) && !finalStrings.contains(e.getOrgId()) && !dto.getOrgAid().equals(e.getSysCreateAid())) {
                             return true;
                         }
                         //去掉所有条件都不符合的课程
-                        if(!seache.contains(e.getId())&&!dto.getReadIds().contains(e.getId())&& !finalStrings.contains(e.getOrgId()) && !dto.getOrgAid().equals(e.getSysCreateAid())){
+                        if (!seache.contains(e.getId()) && !dto.getReadIds().contains(e.getId()) && !finalStrings.contains(e.getOrgId()) && !dto.getOrgAid().equals(e.getSysCreateAid())) {
                             return true;
                         }
                         return false;
                     });
                     //将需要隐藏的做标记
                     listByFilters2.forEach(e -> {
-                        if ((seache.contains(e.getId())||dto.getReadIds().contains(e.getOrgId())) && !finalStrings.contains(e.getOrgId()) && !dto.getOrgAid().equals(e.getSysCreateAid())) {
+                        if ((seache.contains(e.getId()) || dto.getReadIds().contains(e.getOrgId())) && !finalStrings.contains(e.getOrgId()) && !dto.getOrgAid().equals(e.getSysCreateAid())) {
                             e.setIsPermission(false);
                         } else {
                             e.setIsPermission(true);
                         }
                     });
                     listByFilters2.sort(Comparator.comparing(Course::getIsPermission).reversed());
-                }else{
-                    List<Course> collect = listByFilters2.stream().filter(e ->dto.getReadIds().contains(e.getOrgId())||dto.getOrgAid().equals(e.getSysCreateAid())||finalStrings.contains(e.getOrgId())).collect(Collectors.toList());
+                } else {
+                    List<Course> collect = listByFilters2.stream().filter(e -> dto.getReadIds().contains(e.getOrgId()) || dto.getOrgAid().equals(e.getSysCreateAid()) || finalStrings.contains(e.getOrgId())).collect(Collectors.toList());
                     List<Course> paginate = paginate(collect, pageIndex, pageSize);
                     PageList<Course> rs = new PageList<>();
                     rs.setCount(collect.size());
@@ -493,7 +500,7 @@ public class CourseServiceImpl implements ICourseService {
         String sql = "SELECT DISTINCT\n" +
                 "rt.course_id\n" +
                 "FROM\n" +
-                "boe.student s INNER JOIN boe.router_task rt on s.pid=rt.router_id inner join boe_course c on c.id=rt.course_id\n" +
+                "boe_new.student s INNER JOIN boe_new.router_task rt on s.pid=rt.router_id inner join boe_course c on c.id=rt.course_id\n" +
                 "\n" +
                 "WHERE\n" +
                 "\n" +
@@ -516,7 +523,7 @@ public class CourseServiceImpl implements ICourseService {
         String sql = "SELECT DISTINCT\n" +
                 "pt.course_id\n" +
                 "FROM\n" +
-                "boe.student s INNER JOIN boe.project_task pt on s.pid=pt.project_id inner join boe_course c on c.id=pt.course_id\n" +
+                "boe_new.student s INNER JOIN boe_new.project_task pt on s.pid=pt.project_id inner join boe_course c on c.id=pt.course_id\n" +
                 "\n" +
                 "WHERE\n" +
                 "\n" +
@@ -573,8 +580,8 @@ public class CourseServiceImpl implements ICourseService {
         String sql = "SELECT DISTINCT\n" +
                 "\tc.id \n" +
                 "FROM\n" +
-                "\tboe.student s\n" +
-                "\tINNER JOIN boe.grow_task gt ON s.pid = gt.grow_id\n" +
+                "\tboe_new.student s\n" +
+                "\tINNER JOIN boe_new.grow_task gt ON s.pid = gt.grow_id\n" +
                 "\tINNER JOIN boe_course c ON gt.course_id = c.id \n" +
                 "WHERE\n" +
                 "\ts.type = 14 \n" +
@@ -868,7 +875,7 @@ public class CourseServiceImpl implements ICourseService {
             }
 
             // 删除ES数据
-            deletedStudyResourceBatchByCourseIdAndType(id,c.getType());
+            deletedStudyResourceBatchByCourseIdAndType(id, c.getType());
         } else {
             //彻底删除，课件设置为无课程状态
             courseDao.setDeleted(id);
@@ -920,6 +927,7 @@ public class CourseServiceImpl implements ICourseService {
             for (CourseTeacher ct : full.getTeachers()) {
                 ct.setCourseId(c.getId());
                 courseTeacherDao.save(ct);
+                addBoeCourseTeacherModifyLog(ct, "M1位置讲师名修改", JSONUtil.toJsonStr(ct), null);
             }
         }
         if (full.getCrowds() != null && !full.getCrowds().isEmpty()) {
@@ -928,7 +936,6 @@ public class CourseServiceImpl implements ICourseService {
                 courseCrowdDao.save(cc);
             }
         }
-
     }
 
     /**
@@ -999,16 +1006,42 @@ 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());
+            // 基本无概率同时修改同一课程 如有 以最后提交为准
+            c.setSysVersion(courseDao.getVersion(c.getId()));
+        }
+        log.info("-------- 课程保存 update ------- tag = {} " , c.getTags());
         courseDao.update(c);
         c.setSysVersion(courseDao.getVersion(c.getId()));
         full.getCourse().setSysVersion(c.getSysVersion());
 
+        // 兼容处理，记录下删除的关联数据
+        createCourseTeacherDeletedRecord(c.getId());
         //先清空教师信息， 教师信息如果不一样了，也要加入到日志中
         courseTeacherDao.deleteByField("courseId", c.getId());
         if (full.getTeachers() != null && !full.getTeachers().isEmpty()) {
             for (CourseTeacher ct : full.getTeachers()) {
                 ct.setCourseId(c.getId());
                 courseTeacherDao.saveOrUpdate(ct);
+                addBoeCourseTeacherModifyLog(ct, "M2位置讲师名修改", JSONUtil.toJsonStr(ct), null);
             }
         }
         //先清空受众信息,受众信息如果不一样了，也要加入到日志中
@@ -1025,9 +1058,7 @@ public class CourseServiceImpl implements ICourseService {
             publishUtil.removeByDocId(c.getFullTextId());
 
         }
-        // 添加课程对应的标签
-        String tags = full.getCourse().getTags();
-        courseTagService.bindTag(c.getId(), tags);
+
     }
 
     @Override
@@ -1059,12 +1090,15 @@ public class CourseServiceImpl implements ICourseService {
         c.setSysVersion(courseDao.getVersion(c.getId()));
         full.getCourse().setSysVersion(c.getSysVersion());
 
+        // 兼容处理，记录下删除的关联数据
+        createCourseTeacherDeletedRecord(c.getId());
         //先清空教师信息， 教师信息如果不一样了，也要加入到日志中
         courseTeacherDao.deleteByField("courseId", c.getId());
         if (full.getTeachers() != null && !full.getTeachers().isEmpty()) {
             for (CourseTeacher ct : full.getTeachers()) {
                 ct.setCourseId(c.getId());
                 courseTeacherDao.saveOrUpdate(ct);
+                addBoeCourseTeacherModifyLog(ct, "M3位置讲师名修改", JSONUtil.toJsonStr(ct), null);
             }
         }
         //先清空受众信息,受众信息如果不一样了，也要加入到日志中
@@ -1092,14 +1126,24 @@ public class CourseServiceImpl implements ICourseService {
         Course c = full.getCourse();//当前的课程信息
         c.setPublished(true);
         c.setPublishTime(LocalDateTime.now());
+        Course nowCourse = courseDao.get(c.getId());
+        if (!nowCourse.getSysVersion().equals(c.getSysVersion())) {
+            log.warn(" - 课程ID: {}, 期望版本: {}, 实际版本: {}",
+                    c.getId(), c.getSysVersion(), nowCourse.getSysVersion());
+            // 基本无概率同时修改同一课程 如有 以最后提交为准
+            c.setSysVersion(courseDao.getVersion(c.getId()));
+        }
         courseDao.update(c);
 
+        // 兼容处理，记录下删除的关联数据
+        createCourseTeacherDeletedRecord(c.getId());
         //先清空教师信息， 教师信息如果不一样了，也要加入到日志中
         courseTeacherDao.deleteByField("courseId", c.getId());
         if (full.getTeachers() != null && !full.getTeachers().isEmpty()) {
             for (CourseTeacher ct : full.getTeachers()) {
                 ct.setCourseId(c.getId());
                 courseTeacherDao.saveOrUpdate(ct);
+                addBoeCourseTeacherModifyLog(ct, "M4位置讲师名修改", JSONUtil.toJsonStr(ct), null);
             }
         }
         //先清空受众信息,受众信息如果不一样了，也要加入到日志中
@@ -1159,7 +1203,7 @@ public class CourseServiceImpl implements ICourseService {
 
     /***
      * 发布全文索引
-     * @param c
+     * @param
      */
 //	private void fullTextPublish(Course c) {
 //		if(fullTextSearch==null) {
@@ -2016,4 +2060,67 @@ public class CourseServiceImpl implements ICourseService {
             e.printStackTrace();
         }
     }
+
+    /**
+     * 删除boe_course_teacher数据时把删除的数据储存到boe_course_teacher_deleted_record表
+     * boe_course_teacher表没有deleted字段，兼容处理
+     *
+     * @param courseId 课程ID
+     */
+    private void createCourseTeacherDeletedRecord(String courseId) {
+        List<CourseTeacherDeletedRecord> courseTeacherList = courseTeacherDao.findList(FieldFilters.eq("courseId", courseId)).stream().map(ct -> {
+            CourseTeacherDeletedRecord courseTeacherDeletedRecord = new CourseTeacherDeletedRecord();
+            courseTeacherDeletedRecord.setCourseId(ct.getCourseId());
+            courseTeacherDeletedRecord.setTeacherId(ct.getTeacherId());
+            courseTeacherDeletedRecord.setTeacherName(ct.getTeacherName());
+            return courseTeacherDeletedRecord;
+        }).collect(Collectors.toList());
+
+        if (CollUtil.isNotEmpty(courseTeacherList)) {
+            courseTeacherDeletedRecordDao.saveList(courseTeacherList);
+        }
+    }
+
+    /**
+     * 增加boe_course_teacher的teacher_name字段被改为"BOE教师"的监控
+     */
+    private void addBoeCourseTeacherModifyLog(CourseTeacher ct, String location, String body, String remark) {
+        try {
+            if (ct == null) {
+                return;
+            }
+            if (Objects.equals(ct.getTeacherName(), "BOE教师")) {
+                modifyLogDao.insert(null, location, body, remark);
+            }
+        } catch (Exception e) {
+            log.error("创建boe_course_teacher记录失败", e);
+        }
+    }
+
+
+    @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; //用户需要提示
+    }
+
+    @Override
+    public void rePublish(String courseId) {
+        Course c = courseDao.get(courseId);
+        publishUtil.fullTextPublish(c);
+    }
 }

servers/boe-server-all/src/main/java/com/xboe/module/course/service/impl/CourseTagServiceImpl.java

@@ -2,7 +2,8 @@ package com.xboe.module.course.service.impl;
 
 import com.xboe.common.OrderCondition;
 import com.xboe.common.PageList;
-import com.xboe.core.JsonResponse;
+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;
@@ -15,6 +16,7 @@ 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;
@@ -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
@@ -40,6 +43,7 @@ public class CourseTagServiceImpl implements ICourseTagService {
     PublishCourseUtil publishUtil;
     @Resource
     private CourseTagRelationDao courseTagRelationDao;
+
     @Resource
     private CourseTypeTagRelationDao courseTypeTagRelationDao;
     @Resource
@@ -55,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);
-        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());
     }
 
     /**
@@ -105,32 +130,18 @@ public class CourseTagServiceImpl implements ICourseTagService {
 
     /**
      * 修改指定id的课程标签的热点属性
-     *
      * @param id
      * @param isHot
      * @return
      */
     @Override
-    public JsonResponse<Boolean> changeHotStatus(Long id, Boolean isHot) {
-        // 当标签切换为热点标签时才会判断，超过十个热点标签则禁止设置
-        JsonResponse<Boolean> objectJsonResponse = new JsonResponse<>();
-        if (isHot){
-            if (courseTagRelationDao.countHotTags()){
-                objectJsonResponse.setStatus(400);
-                objectJsonResponse.setMessage("超过十个热点标签，无法进行设置");
-                objectJsonResponse.setResult(false);
-                return objectJsonResponse;
-            }
-        }
+    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);
         }
-        objectJsonResponse.setStatus(200);
-        objectJsonResponse.setMessage("修改成功");
-        return objectJsonResponse;
     }
 
     /**
@@ -177,7 +188,6 @@ public class CourseTagServiceImpl implements ICourseTagService {
      * @param tagName
      * @return 符合检索条件的所有公共标签
      */
-    @Override
     public List<CourseTag> searchTags(String tagName){
         QueryBuilder query=QueryBuilder.from(CourseTag.class);
         List<IFieldFilter> filters = new ArrayList<>();
@@ -189,12 +199,17 @@ public class CourseTagServiceImpl implements ICourseTagService {
         return courseTagList;
     }
 
+    @Override
+    public List<CourseTag> searchTags(String tagName,String userId,String typeId){
+        List<CourseTag>  tagList = courseTagDao.searchTags(tagName,userId,typeId);
+        return tagList;
+    }
+
     /**
      * 创建新标签,并与指定课程绑定
-     * @param courseTagRelationDto
      * @return
      */
-    @Override
+    /*@Override
     public CourseTag createTag(CourseTagRelationDto courseTagRelationDto) {
         CourseTag courseTag = null;
         String tagName = courseTagRelationDto.getTagName();
@@ -255,44 +270,7 @@ public class CourseTagServiceImpl implements ICourseTagService {
         createCourseTypeAndTagRelation(courseTagRelationDto);
         return courseTag;
     }
-
-    @Override
-    public void bindTag(String id, String tags) {
-        // 将tags转换为数组
-        String[] tagIds = tags.split(",");
-        List<Long> tagIdList = new ArrayList<>();
-        for (String tagId : tagIds){
-            tagIdList.add(Long.valueOf(tagId));
-        }
-        for (Long tagId : tagIdList){
-            QueryBuilder courseTagQuery=QueryBuilder.from(CourseTag.class);
-            List<IFieldFilter> courseTagFilters = new ArrayList<>();
-            courseTagFilters.add(FieldFilters.eq("id",tagId.toString()));//精确匹配
-            courseTagQuery.addFilters(courseTagFilters);
-            //修改该标签关联课程数
-            CourseTag courseTag = courseTagDao.findOne(FieldFilters.eq("id", String.valueOf(tagId)));
-            if (courseTag!=null){
-                //更新该标签的关联课程数量
-                courseTag.setUseCount(courseTag.getUseCount()+1);
-                courseTagDao.saveOrUpdate(courseTag);
-            }
-            // 查询课程是否绑定了标签
-            QueryBuilder query=QueryBuilder.from(CourseTagRelation.class);
-            List<IFieldFilter> filters = new ArrayList<>();
-            filters.add(FieldFilters.eq("courseId",Long.valueOf(id)));
-            filters.add(FieldFilters.eq("tagId",Long.valueOf(tagId)));
-            query.addFilters(filters);
-            List<CourseTagRelation> courseTagRelationList = courseTagRelationDao.findList(query.builder());
-            // 如果没有绑定标签，那么就进行绑定
-            if (courseTagRelationList==null || courseTagRelationList.size()==0){
-                CourseTagRelation courseTagRelation = new CourseTagRelation();
-                courseTagRelation.setTagId(Long.valueOf(tagId));
-                courseTagRelation.setCourseId(Long.valueOf(id));
-                courseTagRelationDao.save(courseTagRelation);
-            }
-        }
-    }
-
+*/
     @Override
     public CourseTag getTagByName(String tagName) {
         CourseTag courseTag = courseTagDao.getTagByName(tagName);
@@ -390,4 +368,512 @@ public class CourseTagServiceImpl implements ICourseTagService {
         }
         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列表
+        log.info(" --- 旧标签1 oldTagIds = {} " , oldCourse.getTags());
+        log.info(" --- 新修改1  newTagIds = {} " , newCourse.getTags());
+        List<String> oldTagIds = getTagIdsFromCourse(oldCourse);
+        List<String> newTagIds = getTagIdsFromCourse(newCourse);
+        log.info(" --- 旧标签2 oldTagIds = {} " , oldTagIds);
+        log.info(" --- 新修改2  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());
+    }
+
+
+
 }

servers/boe-server-all/src/main/java/com/xboe/module/course/vo/RePublishVo.java

@@ -0,0 +1,14 @@
+package com.xboe.module.course.vo;
+
+import lombok.Data;
+
+/**
+ * @date 2025/11/17
+ */
+@Data
+public class RePublishVo {
+    /**
+     * 课程id
+     * */
+    private String courseId;
+}

servers/boe-server-all/src/main/java/com/xboe/module/popup/entity/Popup.java

@@ -1,5 +1,6 @@
 package com.xboe.module.popup.entity;
 
+import com.fasterxml.jackson.annotation.JsonFormat;
 import com.xboe.core.SysConstant;
 import com.xboe.core.orm.IdEntity;
 import lombok.Data;
@@ -24,12 +25,14 @@ public class   Popup extends IdEntity {
      * 开始时间
      * */
     @Column(name = "start_time")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
     private LocalDateTime startTime;
 
     /**
      * 结束时间
      * */
     @Column(name = "end_time")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
     private LocalDateTime endTime;
 
 

servers/boe-server-all/src/main/java/com/xboe/school/study/api/StudyCourseApi.java

@@ -10,14 +10,19 @@ import java.util.stream.Collectors;
 
 import cn.hutool.core.collection.CollectionUtil;
 import com.alibaba.nacos.shaded.com.google.common.util.concurrent.RateLimiter;
+import com.boe.feign.api.infrastructure.entity.CommonSearchVo;
+import com.boe.feign.api.infrastructure.entity.Dict;
 import com.xboe.api.ThirdApi;
 import com.xboe.constants.CacheName;
+import com.xboe.module.course.entity.*;
+import com.xboe.module.course.service.ICourseTagService;
 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.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.redis.core.StringRedisTemplate;
 import org.springframework.web.bind.annotation.GetMapping;
@@ -34,11 +39,6 @@ import com.xboe.common.utils.StringUtil;
 import com.xboe.core.CurrentUser;
 import com.xboe.core.JsonResponse;
 import com.xboe.core.api.ApiBaseController;
-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.CourseSection;
-import com.xboe.module.course.entity.CourseTeacher;
 import com.xboe.module.course.service.ICourseContentService;
 import com.xboe.module.course.service.ICourseSectionService;
 import com.xboe.module.course.service.ICourseService;
@@ -100,6 +100,8 @@ public class StudyCourseApi extends ApiBaseController{
 
 	@Autowired
 	StringRedisTemplate redisTemplate;
+	@Resource
+	private ICourseTagService courseTagService;
 
 	/**
 	 * 用于查询课程的学习记录
@@ -167,7 +169,14 @@ public class StudyCourseApi extends ApiBaseController{
 		if(course==null || course.getDeleted()){
 			return badRequest("课程不存在或已被删除");
 		}
-		rs.put("course",course);
+		Course course1 = new Course();
+		BeanUtils.copyProperties(course,course1);
+		if (StringUtils.isNotBlank(course.getTags()) && course.getTags().matches("[0-9,]+")) {
+			List<CourseTag> tagList = courseTagService.getTagsByIds(course.getTags());
+			String tags = tagList.stream().map(CourseTag::getTagName).collect(Collectors.joining(","));
+			course1.setTags(tags);
+		}
+		rs.put("course",course1);
 		
 		List<CourseCrowd> courseCrowdList = courseService.findCrowdByCourseId(cid);
 		if(crowd!=null && crowd) {
@@ -233,7 +242,30 @@ public class StudyCourseApi extends ApiBaseController{
 		rs.put("contents",cclist);
 		rs.put("sections",sectionlist);
 		rs.put("teachers",teachers);
-		
+		// 未选择仅内网时isPermission = false，不用区分内外网
+		boolean isPermission = false;
+		if(course.getDevice() ==4){
+			CommonSearchVo searcher = new CommonSearchVo();
+			searcher.setPid(637L);
+			searcher.setType(1);
+			List<Dict> dictList = thirdApi.getDictItems(searcher);
+			if(dictList != null && dictList.size() > 0){
+				List<String> dicts =  dictList.stream().map(Dict::getValue).collect(Collectors.toList());
+				// 选择仅内网 并且字典中配置了此课程资源归属，那么只能内网观看 返回 truw
+				isPermission = dicts.contains(course.getOrgId());
+			}
+		}
+		rs.put("isPermission",isPermission);
+
+		CommonSearchVo warn = new CommonSearchVo();
+		warn.setCode("course_warn");
+		warn.setType(1);
+		List<Dict> warns = thirdApi.getDictItems(warn);
+		if(warns != null && warns.size() > 0){
+			rs.put("warn",warns.get(0).getValue());
+			rs.put("warnTitle",warns.get(0).getName());
+		}
+
 		//检查是否已报名
 		StudyCourse sc=service.findByCourseIdAndAid(cid, aid);
 		if(pass==true && sc==null) {
@@ -567,8 +599,8 @@ public class StudyCourseApi extends ApiBaseController{
 		}
 		try {
 			studyService.finishVideoStudyItem(itemId, studyId,courseId,cnum,token);
-			List<StudyCourse> allUserList = thirdApi.getStudyCourseList(studyId ,courseId, token);
-			log.info("在线课学习记录"+allUserList);
+//			List<StudyCourse> allUserList = thirdApi.getStudyCourseList(studyId ,courseId, token);
+//			log.info("在线课学习记录"+allUserList);
 			return success(true);
 		}catch(Exception e) {
 			log.error("记录内容学习完成错误",e);

servers/boe-server-all/src/main/java/com/xboe/school/study/api/StudySignupRpcController.java

@@ -4,6 +4,8 @@ import com.xboe.common.beans.IdName;
 import com.xboe.common.beans.KeyValue;
 import com.xboe.core.JsonResponse;
 import com.xboe.core.api.ApiBaseController;
+import com.xboe.module.course.service.ICourseService;
+import com.xboe.module.course.vo.RePublishVo;
 import com.xboe.school.study.dto.BatchSignup;
 import com.xboe.school.study.entity.StudySignup;
 import com.xboe.school.study.service.IStudySignupService;
@@ -32,7 +34,8 @@ public class StudySignupRpcController extends ApiBaseController {
 
     @Resource
     IStudySignupService signupService;
-
+    @Resource
+    ICourseService courseService;
     /**
      * 批量添加学员
      *
@@ -106,4 +109,18 @@ public class StudySignupRpcController extends ApiBaseController {
         return StringUtils.isBlank(string);
     }
 
+    @PostMapping("/rePublish")
+    public JsonResponse<Boolean> rePublish(@RequestBody RePublishVo vo) {
+        if(vo==null || StringUtils.isBlank(vo.getCourseId())) {
+            return error("未指定id");
+        }
+        try {
+            courseService.rePublish(vo.getCourseId());
+        } catch (Exception e) {
+            log.error("解绑重新发布", e);
+            return error("解绑重新发布失败，请与管理员联系", e.getMessage());
+        }
+        return success(true);
+    }
+
 }

servers/boe-server-all/src/main/java/com/xboe/school/study/service/impl/StudyExamServiceImpl.java

@@ -10,6 +10,7 @@ import com.xboe.module.course.entity.CourseExam;
 import com.xboe.school.study.dao.StudyCourseDao;
 import com.xboe.school.study.dao.StudyCourseItemDao;
 import com.xboe.school.study.dao.StudyExamDao;
+import com.xboe.school.study.entity.StudyCourse;
 import com.xboe.school.study.entity.StudyCourseItem;
 import com.xboe.school.study.entity.StudyExam;
 import com.xboe.school.study.service.IStudyExamService;
@@ -170,15 +171,32 @@ public class StudyExamServiceImpl implements IStudyExamService{
 			}
 			builder.addGroupBy("studyId");
 			List<StudyExam> list1 = dao.findList(builder.builder());
-			log.info("------------QueryBuilder list1.size = " + list1.size() + ",0 = " + list1.get(0));
-
-			for(StudyExam item : list1){
-				log.info("-----------------CourseId = " + item.getCourseId() + " , StudyId = " + item.getStudyId() + " , StudentId = " + item.getStudentId());
-				int totalContent = courseContentDao.getCount(item.getCourseId());
-				log.info("----------准备判断进度-------totalContent = " + totalContent);
-				scDao.finishCheck1(item.getStudyId(),item.getCourseId(),totalContent);
-				log.info("----------判断进度完毕----------------------");
+			if(list1 != null && list1.size() > 0){
+				log.info("----------StudyExam--QueryBuilder list1.size = " + list1.size() + ",0 = " + list1.get(0));
+				for(StudyExam item : list1){
+					log.info("--------------StudyExam---CourseId = " + item.getCourseId() + " , StudyId = " + item.getStudyId() + " , StudentId = " + item.getStudentId());
+					int totalContent = courseContentDao.getCount(item.getCourseId());
+					log.info("--------StudyExam--准备判断进度-------totalContent = " + totalContent);
+					scDao.finishCheck1(item.getStudyId(),item.getCourseId(),totalContent);
+					log.info("--------StudyExam--判断进度完毕----------------------");
+				}
+			}else{
+				QueryBuilder builder1 = QueryBuilder.from(StudyCourse.class);
+				if (StringUtils.isEmpty(courseId)){
+				 	return;
+				}
+				builder1.addFilter(FieldFilters.eq("courseId", courseId));
+				List<StudyCourse> list2 = scDao.findList(builder1.builder());
+				log.info("------------StudyCourse list2.size = " + list2.size() + ",0 = " + list2.get(0));
+				for(StudyCourse item : list2){
+					log.info("-------------StudyCourse----CourseId = " + item.getCourseId() + " , StudyId = " + item.getId() + " , StudentId = " + item.getAid());
+					int totalContent = courseContentDao.getCount(item.getCourseId());
+					log.info("--------StudyCourse--准备判断进度-------totalContent = " + totalContent);
+					scDao.finishCheck1(item.getId(),item.getCourseId(),totalContent);
+					log.info("--------StudyCourse--判断进度完毕----------------------");
+				}
 			}
+
 		} catch (Exception exception) {
 			exception.printStackTrace();
 			log.info("------异常----------------------：" +exception.getMessage());

servers/boe-server-all/src/main/java/com/xboe/school/study/service/impl/StudyServiceImpl.java

@@ -282,11 +282,12 @@ public class StudyServiceImpl implements IStudyService{
 				return pageList;
 			}
 		}
+
 		String sql = "select a.id, a.course_id, a.course_name, a.aname, " +
-				"IFNULL(b.finish_time, '0') as finish_time, IFNULL(b.progress, 0) as progress, IFNULL(b.status, 1) as status " +
+				"IFNULL(b.finish_time, '0') as finish_time, IFNULL(b.progress, 0) as progress, IFNULL(b.status, 1) as status,b.score " +
 				"from (select id, course_id, course_name, aname, 0, 1 from boe_study_course where course_id = '" + courseId + "' and aname like '%"+name+"%') a " +
 				"left join " +
-				"(select bsc.id, bsc.course_id, bsc.course_name, bsc.aname, item.finish_time, item.progress, item.status " +
+				"(select bsc.id, bsc.course_id, bsc.course_name, bsc.aname, item.finish_time, item.progress, item.status,MAX(item.score) score " +
 				"from boe_study_course bsc left join boe_study_course_item item on item.course_id = bsc.course_id and item.study_id = bsc.id " +
 				"where bsc.course_id = '" + courseId + "' and item.content_id = '" + contentId + "' and item.aname like '%"+name+"%' group by bsc.id) b " +
 				"on a.course_id = b.course_id and a.id = b.id " +
@@ -315,6 +316,9 @@ public class StudyServiceImpl implements IStudyService{
 			sc.setProgress(Integer.valueOf(objs[5].toString()));
 			sc.setStatus(Integer.valueOf(objs[6].toString()));
 			sc.setAname(objs[3].toString());
+			if(objs[7] != null){
+				sc.setScore(Float.valueOf(objs[7].toString()));
+			}
 			item.add(sc);
 		}
 		log.info("资源完成情况人员"+item);

servers/boe-server-all/src/main/resources/application-dev.yml

@@ -87,6 +87,8 @@ xboe:
       ai-api-code: 30800
       case-knowledge-id: de2e006e-82fb-4ace-8813-f25c316be4ff
       file-upload-callback-url: http://192.168.0.253:9090/xboe/m/boe/caseDocumentLog/uploadCallback
+      alert-email-recipients: 
+        - liu.zixi@ebiz-digits.com
 xxl:
   job:
     accessToken: 65ddc683-22f5-83b4-de3a-3c97a0a29af0

servers/boe-server-all/src/main/resources/application-pre.yml

@@ -118,7 +118,9 @@ xboe:
       secret-key: db4d24279e3d6dbf1524af42cd0bedd2
       ai-api-code: 30800
       case-knowledge-id: de2e006e-82fb-4ace-8813-f25c316be4ff
-      file-upload-callback-url: http://192.168.0.253:9090/xboe/m/boe/caseDocumentLog/uploadCallback
+      file-upload-callback-url: http://10.251.132.75:9090/xboe/m/boe/caseDocumentLog/uploadCallback
+      alert-email-recipients: 
+        - liu.zixi@ebiz-digits.com
 jasypt:
   encryptor:
     algorithm: PBEWithMD5AndDES

servers/boe-server-all/src/main/resources/application-prod.yml

@@ -79,12 +79,43 @@ xboe:
       default: https://u.boe.com/pc/images/bgimg/course.png
   case:
     ai:
-      base-url: http://10.10.181.114:30003
-      app-key: 6e9be45319184ac793aa127c362b0f0b
-      secret-key: db4d24279e3d6dbf1524af42cd0bedd2
+      base-url: https://gateway-internal.boe.com
+#      base-url: https://gateway-pro.boe.com
+      app-key: 3edef300b25642da949ccddf58441a0f
+      secret-key: 43bc8003a811a7f9c89cbecbfe4bbb22
       ai-api-code: 30800
-      case-knowledge-id: de2e006e-82fb-4ace-8813-f25c316be4ff
-      file-upload-callback-url: http://192.168.0.253:9090/xboe/m/boe/caseDocumentLog/uploadCallback
+      chat-api-code: 32065
+      case-knowledge-id: f062c9e4-c6ad-437b-b5ca-bbb9fed9b442
+      caseDetailUrlBase: https://u.boe.com/pc/case/detail?id=
+      file-upload-callback-url: https://u.boe.com/systemapi/xboe/m/boe/caseDocumentLog/uploadCallback
+      use-white-list: true
+      white-user-code-list:
+        - "00004409"
+        - "10361430"
+        - "10867319"
+        - "00004746"
+        - "00004701"
+        - "00004471"
+        - "11311660"
+        - "10157955"
+        - "10726944"
+        - "110408"
+        - "10768019"
+        - "137812"
+        - "107863"
+        - "10046607"
+        - "110858"
+        - "98000352"
+        - "101215"
+        - "00005011"
+        - "10827857"
+        - "11339772"
+        - "pctest06"
+      alert-email-recipients:
+        - chengmeng@boe.com.cn
+        - liyubing@boe.com.cn
+        - lijian-hq@boe.com.cn
+      ai-chat-root-path: /home/www/elearning/upload/ai/chat
 xxl:
   job:
     accessToken: 65ddc683-22f5-83b4-de3a-3c97a0a29af0

servers/boe-server-all/src/main/resources/application-test.yml

@@ -117,8 +117,35 @@ xboe:
       app-key: 6e9be45319184ac793aa127c362b0f0b
       secret-key: db4d24279e3d6dbf1524af42cd0bedd2
       ai-api-code: 30800
+      chat-api-code: 32065
       case-knowledge-id: de2e006e-82fb-4ace-8813-f25c316be4ff
-      file-upload-callback-url: http://192.168.0.253:9090/xboe/m/boe/caseDocumentLog/uploadCallback
+      caseDetailUrlBase: https://u-pre.boe.com/pc/case/detail?id=
+      file-upload-callback-url: http://10.251.186.27:9090/xboe/m/boe/caseDocumentLog/uploadCallback
+      use-white-list: true
+      white-user-code-list:
+        - "00004409"
+        - "10361430"
+        - "10867319"
+        - "00004746"
+        - "00004701"
+        - "00004471"
+        - "11311660"
+        - "10157955"
+        - "10726944"
+        - "110408"
+        - "10768019"
+        - "137812"
+        - "107863"
+        - "10046607"
+        - "110858"
+        - "98000352"
+        - "101215"
+        - "00005011"
+        - "10827857"
+        - "11339772"
+      alert-email-recipients:
+        - chengmeng@boe.com.cn
+      ai-chat-root-path: /home/www/elearning/upload/ai/chat
 jasypt:
   encryptor:
     algorithm: PBEWithMD5AndDES
@@ -130,8 +157,8 @@ boe:
 ok:
   http:
     connect-timeout: 30
-    read-timeout: 30
-    write-timeout: 30
+    read-timeout: 300
+    write-timeout: 300
     max-idle-connections: 200
     keep-alive-duration: 300
 

servers/boe-server-all/src/main/resources/application.yml

@@ -15,6 +15,8 @@ spring:
     time-zone: GMT+8
   mvc:
     static-path-pattern: /cdn/**
+    async:
+      request-timeout: 600000
   jpa:
     database: MYSQL
     show-sql: false
@@ -44,8 +46,8 @@ server:
 ok:
   http:
     connect-timeout: 30
-    read-timeout: 30
-    write-timeout: 30
+    read-timeout: 300
+    write-timeout: 300
     max-idle-connections: 200
     keep-alive-duration: 300
 boe: