Compare commits

..

6 Commits

Author SHA1 Message Date
Caojr
4ede914452 szx-1279 增加监控表 2025-11-03 17:53:26 +08:00
Caojr
309599f43f 增加异常日志 2025-11-03 10:57:42 +08:00
Caojr
20e3b001d5 szx-1277 增加boe_course_teacher删除记录逻辑 2025-10-30 14:37:40 +08:00
Caojr
a37f90aeaa szx-1277 增加参数 2025-10-30 12:08:59 +08:00
Caojr
e767345c1e szx-1277 hrbp审核接口修改course服务调用接 2025-10-30 11:45:21 +08:00
Caojr
6fe6f7c6e5 临时注释多余的completeStatus接口调用 2025-10-10 10:15:11 +08:00
67 changed files with 219 additions and 6727 deletions

View File

@@ -161,21 +161,11 @@
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
</dependency>
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpmime</artifactId>
<version>4.5.13</version>
</dependency>
<dependency>
<groupId>javax.mail</groupId>
<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>
@@ -237,23 +227,6 @@
<artifactId>elasticsearch-rest-high-level-client</artifactId>
<version>7.9.0</version> <!-- 请根据实际需求选择合适的版本 -->
</dependency>
<dependency>
<groupId>com.squareup.okhttp3</groupId>
<artifactId>okhttp</artifactId>
<version>4.2.0</version>
</dependency>
<dependency>
<groupId>com.squareup.okhttp3</groupId>
<artifactId>okhttp-sse</artifactId>
<version>4.2.0</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>2.0.31</version>
</dependency>
<dependency>
<groupId>com.xboe</groupId>

View File

@@ -1,36 +0,0 @@
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();
}
}
}

View File

@@ -1,39 +0,0 @@
package com.xboe.config;
import org.apache.activemq.command.ActiveMQTopic;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jms.annotation.EnableJms;
import org.springframework.jms.config.DefaultJmsListenerContainerFactory;
import org.springframework.jms.config.JmsListenerContainerFactory;
import javax.jms.ConnectionFactory;
import javax.jms.Topic;
@EnableJms
@Configuration
public class MqConfig {
@Value("${activemq.topic.name}")
private String topicName;
/**
* 配置topic
*/
@Bean
public Topic broadcastTopic() {
return new ActiveMQTopic(topicName);
}
// 配置JmsListenerContainerFactory为发布/订阅模式
@Bean
public JmsListenerContainerFactory<?> jmsListenerContainerFactory(ConnectionFactory connectionFactory) {
DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
factory.setConnectionFactory(connectionFactory);
factory.setPubSubDomain(true); // 设置为发布/订阅模式
factory.setSubscriptionDurable(false); // 非持久订阅
return factory;
}
}

View File

@@ -1,90 +0,0 @@
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;
}
/**
* 异步存会话数据线程池
* @return
*/
@Bean(name = "esChatExecutor")
public ThreadPoolTaskExecutor esChatExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(10);
executor.setMaxPoolSize(500);
executor.setQueueCapacity(10);
executor.setThreadNamePrefix("es-chat-");
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());
}
}

View File

@@ -1,14 +0,0 @@
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 = "文档删除";
public static final String CHAT_SYS_ERR_MSG = "服务繁忙,请稍后再试。";
public static final String CHAT_NET_ERR_MSG = "网络异常,请稍后再试。";
}

View File

@@ -1,33 +0,0 @@
package com.xboe.enums;
import lombok.Getter;
import java.util.Arrays;
/**
* 错误码枚举
*/
@Getter
public enum CaseAiChatErrCodeEnum {
SUCCESS(0, "成功"),
INTERNAL_ERROR(1, "内部错误"),
AIOT_ERROR(2, "AIoT平台错误"),
;
private final int code;
private final String label;
CaseAiChatErrCodeEnum(int code, String label) {
this.code = code;
this.label = label;
}
public static CaseAiChatErrCodeEnum getByCode(int code) {
return Arrays.stream(values()).filter(e -> e.code == code)
.findFirst().orElse(SUCCESS);
}
}

View File

@@ -1,41 +0,0 @@
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;
}
}

View File

@@ -1,50 +0,0 @@
package com.xboe.enums;
/**
* AI调用日志业务处理状态枚举
*/
public enum CaseDocumentLogCaseStatusEnum {
SUCCESS(1, "处理成功"),
FAILED(2, "处理失败");
private final Integer code;
private final String desc;
CaseDocumentLogCaseStatusEnum(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 (CaseDocumentLogCaseStatusEnum statusEnum : values()) {
if (statusEnum.getCode().equals(code)) {
return statusEnum.getDesc();
}
}
return "";
}
/**
* 根据code获取枚举
*/
public static CaseDocumentLogCaseStatusEnum getByCode(Integer code) {
for (CaseDocumentLogCaseStatusEnum statusEnum : values()) {
if (statusEnum.getCode().equals(code)) {
return statusEnum;
}
}
return null;
}
}

View File

@@ -1,51 +0,0 @@
package com.xboe.enums;
/**
* AI调用日志接口调用状态枚举
*/
public enum CaseDocumentLogOptStatusEnum {
CALLING(0, "调用中"),
SUCCESS(1, "调用成功"),
FAILED(2, "调用失败");
private final Integer code;
private final String desc;
CaseDocumentLogOptStatusEnum(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 (CaseDocumentLogOptStatusEnum statusEnum : values()) {
if (statusEnum.getCode().equals(code)) {
return statusEnum.getDesc();
}
}
return "";
}
/**
* 根据code获取枚举
*/
public static CaseDocumentLogOptStatusEnum getByCode(Integer code) {
for (CaseDocumentLogOptStatusEnum statusEnum : values()) {
if (statusEnum.getCode().equals(code)) {
return statusEnum;
}
}
return null;
}
}

View File

@@ -1,39 +0,0 @@
package com.xboe.enums;
/**
* AI调用日志操作类型枚举
*/
public enum CaseDocumentLogOptTypeEnum {
CREATE("create", "新增"),
DELETE("delete", "删除"),
UPDATE("update", "更改");
private final String code;
private final String desc;
CaseDocumentLogOptTypeEnum(String code, String desc) {
this.code = code;
this.desc = desc;
}
public String getCode() {
return code;
}
public String getDesc() {
return desc;
}
/**
* 根据code获取描述
*/
public static String getDescByCode(String code) {
for (CaseDocumentLogOptTypeEnum typeEnum : values()) {
if (typeEnum.getCode().equals(code)) {
return typeEnum.getDesc();
}
}
return "";
}
}

View File

@@ -1,50 +0,0 @@
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;
}
}

View File

@@ -1,17 +0,0 @@
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;
}

View File

@@ -1,101 +0,0 @@
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);
}
}
}

View File

@@ -1,238 +0,0 @@
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.dto.CaseAiMsgLikeDto;
import com.xboe.module.boecase.dto.EsFieldDTO;
import com.xboe.module.boecase.dto.GetCaseAiMsgDto;
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 lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
import javax.servlet.http.HttpServletResponse;
import java.nio.charset.StandardCharsets;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.List;
/**
* AI对话管理API
*/
@Slf4j(topic = "caseAiChatLogger")
@RestController
@RequestMapping(value = "/xboe/m/boe/case/ai")
public class CaseAiChatApi extends ApiBaseController {
/**
* 聊天
* @param caseAiChatDto
* @param response
* @return
*/
@Autowired
private ICaseAiChatService caseAiChatService;
@Autowired
private ICaseAiPermissionService caseAiPermissionService;
@Autowired
private IElasticSearchIndexService elasticSearchIndexService;
/**
* 聊天
* @param caseAiChatDto
* @param response
* @return
*/
@PostMapping(value = "/chat", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public SseEmitter chat(@RequestBody CaseAiChatDto caseAiChatDto,
HttpServletResponse response) {
response.setContentType("text/event-stream");
response.setCharacterEncoding(StandardCharsets.UTF_8.name());
// 获取当前用户
return caseAiChatService.chat(caseAiChatDto, getCurrent());
}
/**
* 停止当前聊天输出
* @param conversationId 会话ID
* @return 是否成功停止
*/
@GetMapping("/stop")
public JsonResponse<Boolean> stopChat(@RequestParam String conversationId) {
try {
boolean result = caseAiChatService.stopChatOutput(conversationId);
if (result) {
return success(true, "成功停止输出");
} else {
return success(false, "未找到对应的会话或会话已结束");
}
} catch (Exception e) {
log.error("停止聊天输出异常", e);
return error("停止输出失败", e.getMessage());
}
}
/**
* 赞消息
* @param caseAiMsgLikeDto
* @return
*/
@PostMapping("/likeMsg")
public JsonResponse<Boolean> likeMsg(@RequestBody CaseAiMsgLikeDto caseAiMsgLikeDto) {
try {
caseAiMsgLikeDto.setOperation(true);
if (caseAiChatService.msgFeedback(caseAiMsgLikeDto)) {
return success(true, "保存成功");
} else {
return success(false, "保存失败");
}
} catch (Exception e) {
log.error("消息赞/踩操作保存异常", e);
return error("保存失败", e.getMessage());
}
}
/**
* 消息问题反馈保存
* @param caseAiMsgLikeDto
* @return
*/
@PostMapping("/msgFeedback")
public JsonResponse<Boolean> msgFeedback(@RequestBody CaseAiMsgLikeDto caseAiMsgLikeDto) {
try {
caseAiMsgLikeDto.setOperation(false);
if (caseAiChatService.msgFeedback(caseAiMsgLikeDto)) {
return success(true, "保存成功");
} else {
return success(false, "保存失败");
}
} catch (Exception e) {
log.error("消息问题反馈保存异常", e);
return error("保存失败", e.getMessage());
}
}
/**
* 获取消息
*
* @param getCaseAiMsgDto
*/
@PostMapping("/getCaseAiMsg")
public JsonResponse<List<CaseAiMessageVo>> getCaseAiMsgDetail(@RequestBody GetCaseAiMsgDto getCaseAiMsgDto) {
try {
List<CaseAiMessageVo> caseAiMessageVoList = caseAiChatService.getCaseAiMsg(getCaseAiMsgDto);
return success(caseAiMessageVoList);
} catch (Exception e) {
log.error("获取消息详情异常", e);
return error("获取失败", e.getMessage());
}
}
/**
* 根据conversationId查看会话内消息记录
* @param conversationId 会话ID
* @return 消息记录列表
*/
@GetMapping("/messages")
public JsonResponse<List<CaseAiMessageVo>> getConversationMessages(@RequestParam String conversationId) {
try {
List<CaseAiMessageVo> messages = caseAiChatService.getConversationMessages(conversationId);
return success(messages);
} catch (Exception e) {
log.error("查询会话消息记录异常", e);
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) {
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
LocalDate startDate = LocalDate.parse(startTime, formatter);
LocalDate endDate = LocalDate.parse(endTime, formatter);
caseAiChatService.getConversationExcel(startDate.atStartOfDay(), endDate.atTime(23, 59, 59), response);
}
/**
* 判断当前登录用户是否显示"案例专家"功能入口
* @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("刷新失败");
}
/**
* 添加索引字段
* @param esFieldDTO
* @return
*/
@PostMapping("/index/add_field")
public JsonResponse<String> addField(@RequestBody EsFieldDTO esFieldDTO) {
boolean result = elasticSearchIndexService.updateIndex(esFieldDTO.getFieldName(), esFieldDTO.getIndexProperties());
return result ? success("添加成功") : 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("创建失败");
}
}

View File

@@ -1,331 +0,0 @@
package com.xboe.module.boecase.api;
import com.xboe.common.PageList;
import com.xboe.core.JsonResponse;
import com.xboe.core.api.ApiBaseController;
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.*;
import javax.annotation.Resource;
/**
* AI调用日志管理API
*/
@Slf4j
@RestController
@RequestMapping(value = "/xboe/m/boe/caseDocumentLog")
public class CaseDocumentLogApi extends ApiBaseController {
@Resource
private ICaseDocumentLogService caseDocumentLogService;
@Resource
private ICaseKnowledgeService caseKnowledgeService;
@Resource
private ICasesService casesService;
/**
* AI调用日志分页查询
*
* @param queryDto 查询条件
* @return 分页结果
*/
@PostMapping("/pageQuery")
@AutoLog(module = "AI调用日志", action = "分页查询", info = "AI调用日志分页查询")
public JsonResponse<PageList<CaseDocumentLogVo>> pageQuery(@RequestBody CaseDocumentLogQueryDto queryDto) {
try {
PageList<CaseDocumentLogVo> result = caseDocumentLogService.pageQuery(
queryDto.getPageIndex(),
queryDto.getPageSize(),
queryDto
);
return success(result);
} catch (Exception e) {
log.error("AI调用日志分页查询失败", e);
return error("查询失败", e.getMessage());
}
}
/**
* 清空日志(根据筛选条件)
*
* @param queryDto 查询条件
* @return 删除结果
*/
@PostMapping("/clearLogs")
@AutoLog(module = "AI调用日志", action = "清空日志", info = "AI调用日志清空操作")
public JsonResponse<Integer> clearLogs(@RequestBody CaseDocumentLogQueryDto queryDto) {
try {
int deletedCount = caseDocumentLogService.clearLogsByCondition(queryDto);
return success(deletedCount);
} catch (Exception e) {
log.error("AI调用日志清空失败", e);
return error("清空失败", e.getMessage());
}
}
/**
* 重试AI调用
*
* @param request 重试请求参数
* @return 重试结果
*/
@PostMapping("/retry")
@AutoLog(module = "AI调用日志", action = "重试调用", info = "AI调用日志重试操作")
public JsonResponse<Boolean> retry(@RequestBody RetryRequest request) {
try {
boolean result = caseDocumentLogService.retryByLogId(request.getLogId());
return success(result);
} catch (Exception e) {
log.error("AI调用重试失败", e);
return error("重试失败", e.getMessage());
}
// 先走挡板
// return success(true);
}
/**
* 根据案例ID上传案例文档到知识库
*
* @param request 上传请求参数
* @return 上传结果
*/
@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());
}
}
/**
* 直接创建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());
}
}
/**
* 文档上传回调接口
*
* @param request 回调请求参数
* @return 回调结果
*/
@PostMapping("/uploadCallback")
@AutoLog(module = "AI调用日志", action = "文档上传回调", info = "文档上传回调接口")
public CallbackResponse uploadCallback(@RequestBody CallbackRequest request) {
try {
log.info("收到文档上传回调taskId: {}, fileStatus: {}, message: {}",
request.getTaskId(), request.getFileStatus(), request.getMessage());
boolean result = caseKnowledgeService.handleUploadCallback(
request.getTaskId(),
request.getMessage(),
request.getFileStatus()
);
CallbackResponse response = new CallbackResponse();
response.setSuccess(result);
response.setCode(result ? 0 : -1);
response.setMessage(result ? "回调处理成功" : "回调处理失败");
return response;
} catch (Exception e) {
log.error("文档上传回调处理失败", e);
CallbackResponse response = new CallbackResponse();
response.setSuccess(false);
response.setCode(-1);
response.setMessage("回调处理异常: " + e.getMessage());
return response;
}
}
/**
* 回调请求参数
*/
public static class CallbackRequest {
private String taskId;
private String message;
private String fileStatus;
public String getTaskId() {
return taskId;
}
public void setTaskId(String taskId) {
this.taskId = taskId;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public String getFileStatus() {
return fileStatus;
}
public void setFileStatus(String fileStatus) {
this.fileStatus = fileStatus;
}
}
/**
* 回调响应参数
*/
public static class CallbackResponse {
private boolean success;
private int code;
private String message;
public boolean isSuccess() {
return success;
}
public void setSuccess(boolean success) {
this.success = success;
}
public int getCode() {
return code;
}
public void setCode(int code) {
this.code = code;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}
/**
* 上传案例请求参数
*/
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;
}
}
}

View File

@@ -1,41 +0,0 @@
package com.xboe.module.boecase.api;
import com.xboe.module.boecase.task.CaseUploadTask;
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;
/**
* 清除处理位置标记,使下次任务从头开始执行
*/
@PostMapping("/reset")
public void resetLastProcessedId() {
stringRedisTemplate.delete(CaseUploadTask.CASE_UPLOAD_LAST_ID_KEY);
log.info("已清除上次处理位置标记");
}
/**
* 清除处理位置标记,使下次任务从头开始执行
*/
@PostMapping("/reload/reset")
public void resetReloadProcessedId() {
stringRedisTemplate.delete(CaseUploadTask.CASE_RELOAD_LAST_ID_KEY);
log.info("已清除上次处理位置标记");
}
}

View File

@@ -1,77 +0,0 @@
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);
/**
* 限流默认QPS 40
*/
private final TokenBucketRateLimiter rateLimiter = new TokenBucketRateLimiter(40);
@Autowired
@Qualifier("aiDocExecutor")
private ThreadPoolTaskExecutor aiDocExecutor;
@Autowired
private ICaseKnowledgeService caseKnowledgeService;
public void process(CaseDocumentLogOptTypeEnum optTypeEnum, Cases... caseList) {
for (Cases cases : caseList) {
// 控制并发数量
while (currentTaskCount.get() >= 5) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
currentTaskCount.incrementAndGet();
aiDocExecutor.submit(() -> {
try {
// 限流
rateLimiter.acquire();
processCases(cases, optTypeEnum);
} finally {
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);
}
}
}

View File

@@ -1,55 +0,0 @@
package com.xboe.module.boecase.async;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
/**
* 令牌桶限流算法实现
*/
public class TokenBucketRateLimiter {
private final double permitsPerSecond; // 每秒生成的令牌数(即 TPS
private final AtomicLong nextFreeTicketMicros = new AtomicLong(0); // 下一个令牌可用的时间(微秒)
private final AtomicLong storedPermits = new AtomicLong(0); // 当前桶中存储的令牌数(本简化版不支持突发,可省略)
private static final long MICROSECONDS_PER_SECOND = 1_000_000L;
public TokenBucketRateLimiter(double permitsPerSecond) {
this.permitsPerSecond = permitsPerSecond;
this.nextFreeTicketMicros.set(System.nanoTime() / 1000); // 初始化为当前时间(微秒)
}
/**
* 获取一个令牌,阻塞直到可用
*/
public void acquire() {
long waitMicros = reserve(1);
if (waitMicros > 0) {
try {
long waitNanos = waitMicros * 1000; // 转为纳秒
TimeUnit.NANOSECONDS.sleep(waitNanos);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
/**
* 预留 1 个令牌,返回需要等待的微秒数
*/
private long reserve(int permits) {
long nowMicros = System.nanoTime() / 1000;
long nextFreeTicket = nextFreeTicketMicros.get();
long waitMicros = Math.max(0, nextFreeTicket - nowMicros);
long newNextFreeTicket = nowMicros + waitMicros + (long) (permits * MICROSECONDS_PER_SECOND / permitsPerSecond);
while (!nextFreeTicketMicros.compareAndSet(nextFreeTicket, newNextFreeTicket)) {
// CAS 失败,说明其他线程修改了时间,重试
nowMicros = System.nanoTime() / 1000;
nextFreeTicket = nextFreeTicketMicros.get();
waitMicros = Math.max(0, nextFreeTicket - nowMicros);
newNextFreeTicket = nowMicros + waitMicros + (long) (permits * MICROSECONDS_PER_SECOND / permitsPerSecond);
}
return waitMicros;
}
}

View File

@@ -1,24 +0,0 @@
package com.xboe.module.boecase.dao;
import com.xboe.core.orm.BaseDao;
import com.xboe.core.orm.FieldFilters;
import com.xboe.module.boecase.entity.CaseAiConversations;
import org.springframework.stereotype.Repository;
/**
* 案例AI会话信息DAO
*/
@Repository
public class CaseAiConversationsDao extends BaseDao<CaseAiConversations> {
/**
* 根据主键ID查询AI会话ID
* @param conversationId 主键ID
* @return AI会话ID
*/
public String findAiConversationIdById(String conversationId) {
CaseAiConversations conversation = this.getGenericDao().findOne(CaseAiConversations.class,
FieldFilters.eq("ai_conversation_id", conversationId));
return conversation != null ? conversation.getAiConversationId() : conversationId;
}
}

View File

@@ -1,25 +0,0 @@
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;
/**
* AI调用日志DAO
*/
@Repository
@Slf4j
public class CaseDocumentLogDao extends BaseDao<CaseDocumentLog> {
/**
* 根据taskId查询文档日志
* @param taskId 任务ID
* @return 文档日志
*/
public CaseDocumentLog findByTaskId(String taskId) {
return this.getGenericDao().findOne(CaseDocumentLog.class,
FieldFilters.eq("taskId", taskId));
}
}

View File

@@ -1,27 +0,0 @@
package com.xboe.module.boecase.dto;
import lombok.Data;
/**
* AI对话入参
*/
@Data
public class CaseAiChatDto {
/**
* 对话id
* 如果是新对话,传空
*/
private String conversationId;
/**
* 提问内容
*/
private String query;
/**
* 是否开启思考
* 0-否 1-是
*/
private Integer enableThinking;
}

View File

@@ -1,32 +0,0 @@
package com.xboe.module.boecase.dto;
import lombok.Data;
@Data
public class CaseAiMsgLikeDto {
/**
* 文档id
*/
private String docId;
/**
* 点赞状态:
* -1 踩
* 1 赞
* 0/null 无操作
*/
private String likeStatus;
/**
* 反馈
*/
private String feedback;
/**
* 操作
* true: 点踩
* false: 反馈
* 为空:其他情况
*/
private Boolean operation;
}

View File

@@ -1,48 +0,0 @@
package com.xboe.module.boecase.dto;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import java.time.LocalDateTime;
import java.util.List;
/**
* AI调用日志查询条件DTO
*/
@Data
public class CaseDocumentLogQueryDto extends PageDto {
/**
* 案例标题(模糊查询)
*/
private String caseTitle;
/**
* 操作类型create-新增delete-删除update-更改)
*/
private String optType;
/**
* 调用时间开始
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private LocalDateTime optTimeStart;
/**
* 调用时间结束
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private LocalDateTime optTimeEnd;
/**
* 接口调用状态
* 0-调用中, 1-调用成功, 2-调用失败
*/
private Integer optStatus;
/**
* 业务处理状态
* 1-处理成功, 2-处理失败
*/
private Integer caseStatus;
}

View File

@@ -1,49 +0,0 @@
package com.xboe.module.boecase.dto;
import lombok.Data;
import org.apache.commons.lang3.StringUtils;
import java.util.HashMap;
import java.util.Map;
@Data
public class EsFieldDTO {
/**
* 字段名称
*/
private String fieldName;
/**
* 字段属性
*/
private Properties properties;
public Map<String, Object> getIndexProperties() {
Map<String, Object> indexProperties = new HashMap<>();
if (properties != null) {
indexProperties.put("type", properties.type);
if (properties.index != null) {
indexProperties.put("index", properties.index);
}
if (StringUtils.isNotBlank(properties.analyzer)) {
indexProperties.put("analyzer", properties.analyzer);
}
if (StringUtils.isNotBlank(properties.searchAnalyzer)) {
indexProperties.put("search_analyzer", properties.searchAnalyzer);
}
}
return indexProperties;
}
@Data
public static class Properties {
private String type;
private Boolean index;
private String analyzer;
private String searchAnalyzer;
}
}

View File

@@ -1,16 +0,0 @@
package com.xboe.module.boecase.dto;
import lombok.Data;
@Data
public class GetCaseAiMsgDto {
/**
* 会话Id
*/
private String conversationId;
/**
* ES DocId
*/
private String docId;
}

View File

@@ -1,142 +0,0 @@
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();
/**
* 状态
* 0-正常
* 1-系统错误
* 2-AIoT平台错误
*/
private Integer status;
/**
* 错误信息
*/
private String errorMsg;
/**
* 案例引用列表
*/
private List<CaseReferVo> caseRefers = new ArrayList<>();
/**
* 建议列表
*/
private List<String> suggestions = new ArrayList<>();
/**
* 用户点赞状态
* -1: 踩
* 1
* 0/null 无操作
*/
private String likeStatus;
/**
* 用户踩的时候, 可以填写反馈意见
* 反馈意见
*/
private String feedback;
/**
* 用户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);
}
}
}

View File

@@ -1,38 +0,0 @@
package com.xboe.module.boecase.entity;
import com.xboe.core.SysConstant;
import com.xboe.core.orm.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Table;
/**
* 案例AI会话信息表
*/
@Data
@Entity
@EqualsAndHashCode(callSuper = false)
@Table(name = SysConstant.TABLE_PRE + "case_ai_conversations")
public class CaseAiConversations extends BaseEntity {
/**
* 会话ID由AI平台提供
*/
@Column(name = "ai_conversation_id", length = 100)
private String aiConversationId;
/**
* 会话名称
*/
@Column(name = "conversation_name", length = 200)
private String conversationName;
/**
* 会话对应用户ID
*/
@Column(name = "conversation_user", length = 50)
private String conversationUser;
}

View File

@@ -1,104 +0,0 @@
package com.xboe.module.boecase.entity;
import com.xboe.core.SysConstant;
import com.xboe.core.orm.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Table;
import java.time.LocalDateTime;
/**
* 案例文档日志信息表
*/
@Data
@Entity
@EqualsAndHashCode(callSuper = false)
@Table(name = SysConstant.TABLE_PRE + "case_document_log")
public class CaseDocumentLog extends BaseEntity {
/**
* 任务ID
*/
@Column(name = "task_id", length = 20)
private String taskId;
/**
* 案例id
*/
@Column(name = "case_id", length = 20)
private String caseId;
/**
* 案例标题
*/
@Column(name = "case_title", length = 200)
private String caseTitle;
/**
* 操作类型
*/
@Column(name = "opt_type")
private String optType;
/**
* 请求地址
*/
@Column(name = "request_url", length = 500)
private String requestUrl;
/**
* 请求参数
*/
@Column(name = "request_body", length = 4000)
private String requestBody;
/**
* 响应参数
*/
@Column(name = "response_body", length = 4000)
private String responseBody;
/**
* 调用时间
*/
@Column(name = "opt_time")
private LocalDateTime optTime;
/**
* 接口运行状态
* 0-运行中, 1-运行完毕
*/
@Column(name = "run_status")
private Integer runStatus;
/**
* 接口调用状态
* 0-调用中, 1-调用成功, 2-调用失败
*/
@Column(name = "opt_status")
private Integer optStatus;
/**
* 业务处理状态
* 1-处理成功, 2-处理失败
*/
@Column(name = "case_status")
private Integer caseStatus;
/**
* 执行时间(ms)
*/
@Column(name = "execute_duration")
private Long executeDuration;
/**
* 元数据处理状态
* 0-未处理
* 1-已处理
*/
@Column(name = "metadata_status")
private Integer metadataStatus;
}

View File

@@ -1,27 +0,0 @@
package com.xboe.module.boecase.mq;
import com.xboe.module.boecase.service.ICaseAiChatService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Component;
@Slf4j
@Component
public class BroadcastMessageConsumer {
@Autowired
private ICaseAiChatService iCaseAiChatService;
/**
* 接收会话终止广播消息
*
* @param conversationId 会话ID
*/
@JmsListener(destination = "${activemq.topic.name}")
public void receiveSessionTerminationBroadcastMessage(String conversationId) {
log.info("收到会话终止广播消息:{}", conversationId);
iCaseAiChatService.eventSourceCancel(conversationId);
}
}

View File

@@ -1,90 +0,0 @@
package com.xboe.module.boecase.properties;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import java.util.List;
/**
* 案例专家AI相关配置项
*/
@ConfigurationProperties(prefix = "xboe.case.ai")
@Data
public class CaseAiProperties {
/**
* 接口地址
*/
private String baseUrl;
/**
* appKey
*/
private String appKey;
/**
* appSecret
*/
private String secretKey;
/**
* ai接口的apiCode
*/
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;
}

View File

@@ -1,13 +0,0 @@
package com.xboe.module.boecase.service;
/**
* 获取accesstoken
*/
public interface IAiAccessTokenService {
/**
* 获取accesstoken
* @return
*/
String getAccessToken();
}

View File

@@ -1,92 +0,0 @@
package com.xboe.module.boecase.service;
import com.xboe.core.CurrentUser;
import com.xboe.module.boecase.dto.CaseAiChatDto;
import com.xboe.module.boecase.dto.CaseAiMsgLikeDto;
import com.xboe.module.boecase.dto.GetCaseAiMsgDto;
import com.xboe.module.boecase.entity.CaseAiConversations;
import com.xboe.module.boecase.vo.CaseAiMessageVo;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
import javax.servlet.http.HttpServletResponse;
import java.time.LocalDateTime;
import java.util.List;
/**
* AI案例对话
*/
public interface ICaseAiChatService {
/**
* 聊天
*
* @param caseAiChatDto
* @param currentUser
* @return
*/
SseEmitter chat(CaseAiChatDto caseAiChatDto, CurrentUser currentUser);
/**
* 创建新的AI对话会话
*
* @param userId 用户ID
* @param conversationName 对话名称
* @return 创建的会话信息
*/
CaseAiConversations createNewConversation(String userId, String conversationName);
/**
* 根据conversationId查看会话内消息记录
*
* @param conversationId 会话ID
* @return 消息记录列表
*/
List<CaseAiMessageVo> getConversationMessages(String conversationId);
/**
* 导出会话记录为Excel
* @param startTime 开始时间
* @param endTime 结束时间
* @param response
*/
void getConversationExcel(LocalDateTime startTime, LocalDateTime endTime, HttpServletResponse response);
/**
* 导出会话记录为Excel
*
* @param startTime 开始时间
* @param endTime 结束时间
*/
void downloadConversationExcel(LocalDateTime startTime, LocalDateTime endTime);
/**
* 停止当前聊天输出
*
* @param conversationId 会话ID
* @return 是否成功停止
*/
boolean stopChatOutput(String conversationId);
/**
* 取消eventSource
*
* @param conversationId 会话ID
*/
void eventSourceCancel(String conversationId);
/**
* 消息反馈保存
* likeStatus: 踩/赞
* feedBack: 反馈消息内容
*
* @param caseAiMsgLikeDto
*/
boolean msgFeedback(CaseAiMsgLikeDto caseAiMsgLikeDto);
/**
* 获取消息
*
* @param getCaseAiMsgDto
*/
List<CaseAiMessageVo> getCaseAiMsg(GetCaseAiMsgDto getCaseAiMsgDto);
}

View File

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

View File

@@ -1,49 +0,0 @@
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;
/**
* AI调用日志Service接口
*/
public interface ICaseDocumentLogService {
/**
* 分页查询AI调用日志
*
* @param pageIndex 页码
* @param pageSize 每页大小
* @param queryDto 查询条件
* @return 分页结果
*/
PageList<CaseDocumentLogVo> pageQuery(int pageIndex, int pageSize, CaseDocumentLogQueryDto queryDto);
/**
* 根据查询条件清空日志
* 仅删除当前筛选条件下的日志记录,非筛选范围内的日志不受影响
*
* @param queryDto 查询条件
* @return 删除的记录数
*/
int clearLogsByCondition(CaseDocumentLogQueryDto queryDto);
/**
* 根据logId重试AI调用
* 查询原始日志数据,重试执行后添加新的日志记录
*
* @param logId 日志ID
* @return 是否成功
*/
boolean retryByLogId(String logId);
/**
* 保存日志记录
*
* @param log 日志对象
* @return 是否成功
*/
boolean save(CaseDocumentLog log);
}

View File

@@ -1,75 +0,0 @@
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;
/**
* 案例-知识库
*/
public interface ICaseKnowledgeService {
/**
* 上传案例文档
*
* @param caseId 案例ID
* @return 是否成功
*/
boolean uploadCaseDocument(String caseId);
/**
* 上传案例文档
*
* @param cases 案例
* @return 是否成功
*/
boolean uploadCaseDocument(Cases cases);
/**
* 删除案例文档
*
* @param caseId 案例ID
* @return 是否成功
*/
boolean deleteCaseDocument(String caseId);
/**
* 删除案例文档
*
* @param cases 案例
* @return 是否成功
*/
boolean deleteCaseDocument(Cases cases);
/**
* 更新案例文档
*
* @param caseId 案例ID
* @return 是否成功
*/
boolean retryCaseDocument(String caseId, CaseDocumentLog originalLog);
/**
* 更新案例文档
*
* @param cases 案例
* @return 是否成功
*/
boolean updateCaseDocument(Cases cases);
/**
* 处理文档上传回调
*
* @param taskId 任务ID
* @param message 回调信息
* @param fileStatus 文件状态vectored: 成功, failed: 失败)
* @return 是否处理成功
*/
boolean handleUploadCallback(String taskId, String message, String fileStatus);
/**
* 批量检查文件状态
*/
@Transactional(rollbackFor = Throwable.class)
void batchCheckFileStatus();
}

View File

@@ -1,68 +0,0 @@
package com.xboe.module.boecase.service;
import com.xboe.module.boecase.entity.AiChatConversationData;
import com.xboe.module.boecase.vo.CaseAiMessageVo;
import java.util.List;
import java.util.Map;
/**
* es索引
*/
public interface IElasticSearchIndexService {
/**
* 查看索引是否存在
* @return
*/
boolean checkIndexExists();
/**
* 创建索引
*/
boolean createIndex();
/**
* 删除索引
* @return
*/
boolean deleteIndex();
/**
* 更新索引:添加索引字段
* @param fieldName
* @param fieldProperties
* @return
*/
boolean updateIndex(String fieldName, Map<String, Object> fieldProperties);
/**
* 新增数据
* @param data
* @return
*/
boolean createData(AiChatConversationData data);
/**
* 查询数据
* @param conversationId
* @return
*/
List<CaseAiMessageVo> queryData(String conversationId);
/**
* 更新数据
* @param docId
* @param data
* @return
*/
boolean updateData(String docId, AiChatConversationData data);
/**
* 通过docId查询数据
*
* @param docId ES docId
* @return
*/
List<CaseAiMessageVo> queryDataByDocId(String docId);
}

View File

@@ -1,88 +0,0 @@
package com.xboe.module.boecase.service.impl;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.xboe.common.utils.StringUtil;
import com.xboe.module.boecase.properties.CaseAiProperties;
import com.xboe.module.boecase.service.IAiAccessTokenService;
import lombok.extern.slf4j.Slf4j;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeUnit;
@EnableConfigurationProperties({CaseAiProperties.class})
@Service
@Slf4j(topic = "caseAiChatLogger")
public class AiAccessTokenServiceImpl implements IAiAccessTokenService {
private static final String ACCESS_TOKEN_CACHE_KEY = "case_ai_access_token";
@Autowired
private CaseAiProperties caseAiProperties;
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Override
public String getAccessToken() {
// 1. 先从Redis缓存中获取
String cachedToken = stringRedisTemplate.opsForValue().get(ACCESS_TOKEN_CACHE_KEY);
if (StringUtil.isNotBlank(cachedToken)) {
return cachedToken;
}
// 2. 缓存中没有,重新获取
try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
String tokenUrl = caseAiProperties.getBaseUrl() + "/apigateway/secret/getAppAccessToken" +
"?appKey=" + URLEncoder.encode(caseAiProperties.getAppKey(), StandardCharsets.UTF_8.name()) +
"&secretKey=" + URLEncoder.encode(caseAiProperties.getSecretKey(), StandardCharsets.UTF_8.name());
HttpGet httpGet = new HttpGet(tokenUrl);
try (CloseableHttpResponse response = httpClient.execute(httpGet)) {
int statusCode = response.getStatusLine().getStatusCode();
String responseBody = EntityUtils.toString(response.getEntity(), StandardCharsets.UTF_8);
if (statusCode == 200) {
JSONObject result = JSON.parseObject(responseBody);
if (result.getIntValue("code") == 0 && result.getBooleanValue("success")) {
JSONObject data = result.getJSONObject("data");
String accessToken = data.getString("accessToken");
Integer expiresIn = data.getInteger("expiresIn");
if (expiresIn == null) {
expiresIn = 7200;
}
// 3. 存储到Redis设置过期时间提前5分钟过期
int cacheSeconds = Math.max(expiresIn - 300, 60);
stringRedisTemplate.opsForValue().set(ACCESS_TOKEN_CACHE_KEY, accessToken,
cacheSeconds, TimeUnit.SECONDS);
log.info("获取access_token成功过期时间: {}秒", expiresIn);
return accessToken;
} else {
log.error("获取access_token失败接口返回失败response: {}", responseBody);
return null;
}
} else {
log.error("获取access_token失败HTTP请求失败status: {}, response: {}",
statusCode, responseBody);
return null;
}
}
} catch (Exception e) {
log.error("获取access_token异常", e);
return null;
}
}
}

View File

@@ -1,47 +0,0 @@
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;
}
}

View File

@@ -1,307 +0,0 @@
package com.xboe.module.boecase.service.impl;
import com.xboe.common.utils.StringUtil;
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;
import com.xboe.module.boecase.service.ICaseDocumentLogService;
import com.xboe.module.boecase.service.ICaseKnowledgeService;
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;
import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
/**
* AI调用日志Service实现类
*/
@Slf4j
@Service
@Transactional
public class CaseDocumentLogServiceImpl implements ICaseDocumentLogService {
@Resource
private CaseDocumentLogDao caseDocumentLogDao;
@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("runStatus", CaseDocumentLogRunStatusEnum.COMPLETED.getCode()));
// 案例标题模糊查询
if (StringUtil.isNotBlank(queryDto.getCaseTitle())) {
filters.add(FieldFilters.like("caseTitle", LikeMatchMode.ANYWHERE, queryDto.getCaseTitle()));
}
// 操作类型精确查询
if (StringUtil.isNotBlank(queryDto.getOptType())) {
filters.add(FieldFilters.eq("optType", queryDto.getOptType()));
}
// 调用时间区间查询
if (queryDto.getOptTimeStart() != null) {
filters.add(FieldFilters.ge("optTime", queryDto.getOptTimeStart()));
}
if (queryDto.getOptTimeEnd() != null) {
// 将结束时间调整为当天的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()));
}
// 业务处理状态
if (queryDto.getCaseStatus() != null) {
filters.add(FieldFilters.eq("caseStatus", queryDto.getCaseStatus()));
}
// 删除标识过滤
filters.add(FieldFilters.eq("deleted", false));
// 按创建时间降序排序
OrderCondition order = OrderCondition.desc("sysCreateTime");
// 执行分页查询
PageList<CaseDocumentLog> pageResult = caseDocumentLogDao.getGenericDao()
.findPage(pageIndex, pageSize, CaseDocumentLog.class, filters, order);
// 转换为VO对象
List<CaseDocumentLogVo> voList = pageResult.getList().stream()
.map(this::convertToVo)
.collect(Collectors.toList());
// 构建返回结果
PageList<CaseDocumentLogVo> result = new PageList<>();
result.setList(voList);
result.setCount(pageResult.getCount());
result.setPageSize(pageResult.getPageSize());
return result;
}
@Override
public int clearLogsByCondition(CaseDocumentLogQueryDto queryDto) {
// 构建查询条件(与分页查询相同的逻辑)
List<IFieldFilter> filters = new ArrayList<>();
// 运行状态过滤
filters.add(FieldFilters.eq("runStatus", CaseDocumentLogRunStatusEnum.COMPLETED.getCode()));
// 案例标题模糊查询
if (StringUtil.isNotBlank(queryDto.getCaseTitle())) {
filters.add(FieldFilters.like("caseTitle", LikeMatchMode.ANYWHERE, queryDto.getCaseTitle()));
}
// 操作类型精确查询
if (StringUtil.isNotBlank(queryDto.getOptType())) {
filters.add(FieldFilters.eq("optType", queryDto.getOptType()));
}
// 调用时间区间查询
if (queryDto.getOptTimeStart() != null) {
filters.add(FieldFilters.ge("optTime", queryDto.getOptTimeStart()));
}
if (queryDto.getOptTimeEnd() != null) {
// 将结束时间调整为当天的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()));
}
// 业务处理状态
if (queryDto.getCaseStatus() != null) {
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, filtersArray);
if (logsToDelete.isEmpty()) {
return 0;
}
// 批量设置删除标识为true逻辑删除
int deletedCount = 0;
for (CaseDocumentLog log : logsToDelete) {
log.setDeleted(true);
caseDocumentLogDao.update(log);
deletedCount++;
}
log.info("清空日志操作完成,共删除{}条记录", deletedCount);
return deletedCount;
}
@Override
public boolean retryByLogId(String logId) {
if (StringUtil.isBlank(logId)) {
log.error("重试失败logId不能为空");
return false;
}
// 1. 根据logId查询原始日志数据
CaseDocumentLog originalLog = caseDocumentLogDao.get(logId);
if (originalLog == null || originalLog.getDeleted()) {
log.error("重试失败未找到有效的日志记录logId: {}", logId);
return false;
}
log.info("开始异步重试AI调用原始日志ID: {}, 案例标题: {}, 操作类型: {}",
logId, originalLog.getCaseTitle(), originalLog.getOptType());
// 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 {
if (StringUtil.isBlank(caseId)) {
throw new IllegalArgumentException("案例ID不能为空");
}
log.info("[异步任务] 正在执行AI调用重试操作类型: {}, caseId: {}", optType, caseId);
// 根据操作类型执行对应的方法(这些方法内部会自动创建日志记录)
if (CaseDocumentLogOptTypeEnum.CREATE.getCode().equals(optType)) {
// 上传案例文档
retrySuccess = caseKnowledgeService.uploadCaseDocument(caseId);
log.info("[异步任务] 执行上传案例文档重试caseId: {}, 结果: {}", caseId, retrySuccess);
} else if (CaseDocumentLogOptTypeEnum.DELETE.getCode().equals(optType)) {
// 删除案例文档
retrySuccess = caseKnowledgeService.deleteCaseDocument(caseId);
log.info("[异步任务] 执行删除案例文档重试caseId: {}, 结果: {}", caseId, retrySuccess);
} else if (CaseDocumentLogOptTypeEnum.UPDATE.getCode().equals(optType)) {
// 更新案例文档
retrySuccess = caseKnowledgeService.retryCaseDocument(caseId, originalLog);
log.info("[异步任务] 执行更新案例文档重试caseId: {}, 结果: {}", caseId, retrySuccess);
} else {
throw new IllegalArgumentException("不支持的操作类型: " + optType);
}
if (retrySuccess) {
log.info("[异步任务] AI调用重试成功操作类型: {}, caseId: {}", optType, caseId);
} else {
log.warn("[异步任务] AI调用重试失败操作类型: {}, caseId: {}", optType, caseId);
}
} catch (Exception e) {
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;
}
}
/**
* 实体转换为VO
*/
private CaseDocumentLogVo convertToVo(CaseDocumentLog entity) {
CaseDocumentLogVo vo = new CaseDocumentLogVo();
BeanUtils.copyProperties(entity, vo);
// 操作类型转换为中文描述
vo.setOptType(CaseDocumentLogOptTypeEnum.getDescByCode(entity.getOptType()));
// 接口调用状态转换
vo.setOptStatusText(getOptStatusText(entity.getOptStatus()));
// 业务处理状态转换
vo.setCaseStatusText(getCaseStatusText(entity.getCaseStatus()));
return vo;
}
/**
* 获取接口调用状态描述
*/
private String getOptStatusText(Integer optStatus) {
if (optStatus == null) {
return "";
}
switch (optStatus) {
case 1:
return "调用成功";
case 2:
return "调用失败";
default:
return "";
}
}
/**
* 获取业务处理状态描述
*/
private String getCaseStatusText(Integer caseStatus) {
if (caseStatus == null) {
return "";
}
switch (caseStatus) {
case 1:
return "处理成功";
case 2:
return "处理失败";
default:
return "";
}
}
}

View File

@@ -19,9 +19,7 @@ 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.*;
@@ -92,9 +90,6 @@ public class CasesServiceImpl implements ICasesService {
@Resource
private ThirdApi thirdApi;
@Autowired
private CaseAiDocumentAsyncHandler caseAiDocumentAsyncHandler;
/**
* 案例分页查询,用于门户的查询
*/
@@ -804,11 +799,7 @@ public class CasesServiceImpl implements ICasesService {
*/
@Override
public void delete(String id) {
Cases cases = casesDao.get(id);
// 原删除
casesDao.setDeleted(id);
// 增加逻辑
caseAiDocumentAsyncHandler.process(CaseDocumentLogOptTypeEnum.DELETE, cases);
}
/**
@@ -995,8 +986,6 @@ public class CasesServiceImpl implements ICasesService {
cases.setMajorIds(majorIds);
cases.setMajorType(stringBuffer.toString());
casesDao.save(cases);
// 增加逻辑
caseAiDocumentAsyncHandler.process(CaseDocumentLogOptTypeEnum.CREATE, cases);
}
@Override
@@ -1020,8 +1009,6 @@ public class CasesServiceImpl implements ICasesService {
cases.setMajorIds(majorIds);
cases.setMajorType(stringBuffer.toString());
casesDao.update(cases);
// 增加逻辑
caseAiDocumentAsyncHandler.process(CaseDocumentLogOptTypeEnum.UPDATE, cases);
}
@Override

View File

@@ -1,423 +0,0 @@
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.apache.commons.lang3.StringUtils;
import org.elasticsearch.ElasticsearchException;
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.action.update.UpdateRequest;
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.client.indices.PutMappingRequest;
import org.elasticsearch.common.bytes.BytesReference;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.rest.RestStatus;
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.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
@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 updateIndex(String fieldName, Map<String, Object> fieldProperties) {
if (elasticsearchClient == null) {
log.error("ElasticSearch客户端未配置");
return false;
}
// 执行新增字段请求
JSONObject newField = new JSONObject();
newField.put(fieldName, fieldProperties);
JSONObject properties = new JSONObject();
properties.put("properties", newField);
PutMappingRequest request = new PutMappingRequest(CaseAiConstants.CASE_AI_INDEX_NAME);
request.source(properties.toJSONString(), XContentType.JSON);
try {
AcknowledgedResponse response = elasticsearchClient.indices().putMapping(request, RequestOptions.DEFAULT);
if (response.isAcknowledged()) {
log.info("成功更新Elasticsearch索引: {}, 新增字段: {}", CaseAiConstants.CASE_AI_INDEX_NAME, fieldName);
return true;
} else {
log.error("更新索引 [{}] 未被确认(可能部分节点未响应)", CaseAiConstants.CASE_AI_INDEX_NAME);
return false;
}
} catch (Exception 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());
esData.put("status", conversationData.getStatus());
esData.put("errorMsg", conversationData.getErrorMsg());
// 构建 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) {
data.setDocId(hit.getId());
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.setConversationId((String) sourceMap.get("conversationId"));
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((Integer) sourceMap.get("durationSeconds"));
}
// 解析 suggestions
if (sourceMap.containsKey("suggestions")) {
Object suggestionsObj = sourceMap.get("suggestions");
if (suggestionsObj instanceof List) {
messageVo.setSuggestions((List<String>) suggestionsObj);
}
}
if (sourceMap.containsKey("status")) {
Object statusObj = sourceMap.get("status");
if (statusObj != null) {
messageVo.setStatus(Integer.valueOf(statusObj.toString()));
}
}
if (sourceMap.containsKey("errorMsg")) {
Object errorMsgObj = sourceMap.get("errorMsg");
if (errorMsgObj != null) {
messageVo.setErrorMsg(errorMsgObj.toString());
}
}
// 解析 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);
}
}
// 解析点赞状态
if (sourceMap.containsKey("likeStatus")) {
messageVo.setLikeStatus((String) sourceMap.get("likeStatus"));
}
// 解析反馈信息
if (sourceMap.containsKey("feedback")) {
messageVo.setFeedback((String) sourceMap.get("feedback"));
}
return messageVo;
} catch (Exception e) {
log.error("解析ES消息数据异常", e);
return null;
}
}
@Override
public boolean updateData(String docId, AiChatConversationData data) {
if (elasticsearchClient == null) {
log.error("未配置Elasticsearch客户端无法更新对话记录");
return false;
}
try{
UpdateRequest updateRequest = new UpdateRequest(CaseAiConstants.CASE_AI_INDEX_NAME, docId);
JSONObject esData = new JSONObject();
// 目前只支持更新点赞状态和反馈信息
if (StringUtils.isNotBlank(data.getLikeStatus())) {
// 进行点赞/踩或取消操作是, 将feedback字段置空
esData.put("likeStatus", data.getLikeStatus());
esData.put("feedback", "");
}
if (StringUtils.isNotBlank(data.getFeedback())) {
esData.put("feedback", data.getFeedback());
}
updateRequest.doc(esData.toJSONString(), XContentType.JSON);
elasticsearchClient.update(updateRequest, RequestOptions.DEFAULT);
return true;
} catch (ElasticsearchException e) {
if (e.status() == RestStatus.NOT_FOUND) {
log.error("文档不存在", e);
}
return false;
} catch (Exception e) {
log.error("更新对话记录异常", e);
return false;
}
}
/**
* 通过docId查询数据
*
* @param docId 会话ID
* @return
*/
@Override
public List<CaseAiMessageVo> queryDataByDocId(String docId) {
List<CaseAiMessageVo> list = new ArrayList<>();
if (elasticsearchClient == null) {
log.error("未配置Elasticsearch客户端无法查询消息记录");
return list;
}
try {
SearchRequest searchRequest = new SearchRequest(CaseAiConstants.CASE_AI_INDEX_NAME);
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.query(QueryBuilders.matchQuery("_id", docId));
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) {
data.setDocId(hit.getId());
list.add(data);
}
}
log.info("从 ES 中查询到 {} 条消息记录", list.size());
} catch (Exception e) {
log.error("从 ES 查询消息异常", e);
}
return list;
}
/**
* 获取ai_chat_messages索引的字段映射配置
* 根据项目中的会话消息数据结构规范定义映射
*
* @return JSON格式的映射配置
*/
private String getAiChatMessagesMapping() {
InputStream inputStream = getClass().getClassLoader().getResourceAsStream("case_ai_index.json");
if (inputStream != null) {
try (InputStreamReader isr = new InputStreamReader(inputStream);
BufferedReader reader = new BufferedReader(isr)) {
return reader.lines().collect(Collectors.joining(System.lineSeparator()));
} catch (IOException e) {
throw new RuntimeException("Resource read error: case_ai_index.json", e);
}
}
throw new RuntimeException("Resource not found: case_ai_index.json");
}
}

View File

@@ -1,77 +0,0 @@
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);
}
}

View File

@@ -1,27 +0,0 @@
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("结束批量查询文件状态");
}
}

View File

@@ -1,222 +0,0 @@
package com.xboe.module.boecase.task;
import com.xboe.common.OrderCondition;
import com.xboe.constants.CaseAiConstants;
import com.xboe.core.orm.FieldFilters;
import com.xboe.core.orm.QueryBuilder;
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;
import java.util.stream.Collectors;
/**
* 旧案例上传
*/
@Component
@Slf4j
public class CaseUploadTask {
@Resource
private CasesDao casesDao;
@Resource
private CaseDocumentLogDao caseDocumentLogDao;
@Autowired
private CaseAiDocumentAsyncHandler caseAiDocumentAsyncHandler;
@Autowired
private StringRedisTemplate stringRedisTemplate;
public static final String CASE_UPLOAD_LAST_ID_KEY = "case:upload:last:id";
public static final String CASE_RELOAD_LAST_ID_KEY = "case:reload:last:id";
@XxlJob("reloadJob")
public void reloadJob() {
String currentLastId = null;
try {
// 从Redis获取上次处理的最后一条记录ID
String lastProcessedId = stringRedisTemplate.opsForValue().get(CASE_RELOAD_LAST_ID_KEY);
// 查询需要重新加载的案例
List<CaseDocumentLog> logsToReload = listToReload(lastProcessedId);
if (logsToReload.isEmpty()) {
return;
}
currentLastId = logsToReload.get(logsToReload.size() - 1).getId();
for (CaseDocumentLog log : logsToReload) {
String caseId = log.getCaseId();
Cases cases = casesDao.get(caseId);
if (cases != null && StringUtils.isNotBlank(cases.getFilePath())) {
// 更新
caseAiDocumentAsyncHandler.process(CaseDocumentLogOptTypeEnum.UPDATE, cases);
}
}
} catch (Exception e) {
log.error("[reload]执行重新上传任务时发生异常", e);
} finally {
if (currentLastId != null) {
stringRedisTemplate.opsForValue().set(CASE_RELOAD_LAST_ID_KEY, currentLastId);
log.info("[reload] 已重新上传案例最后一条caseDocumentLogId 已更新为: {}", currentLastId);
}
}
}
@XxlJob("oldDataUploadJob")
public void oldDataUploadJob() {
String currentLastId = null;
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;
}
currentLastId = casesToProcess.get(casesToProcess.size() - 1).getId();
// 批量检查这些案例是否已在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);
// }
List<CaseDocumentLog> thisCaseLogs = existingLogs.stream()
.filter(log -> cases.getId().equals(log.getCaseId()))
.collect(Collectors.toList());
if (thisCaseLogs == null || thisCaseLogs.isEmpty()) {
casesList.add(cases);
} else if (thisCaseLogs.stream()
.noneMatch(caseLog -> {
// 1. 是否存在已上传完成的案例
boolean hasCompleted = StringUtils.equals(caseLog.getRequestUrl(), CaseAiConstants.CASE_DOC_UPLOAD_INTERFACE_NAME)
&& Objects.equals(caseLog.getRunStatus(), CaseDocumentLogRunStatusEnum.COMPLETED.getCode())
&& Objects.equals(caseLog.getOptStatus(), CaseDocumentLogOptStatusEnum.SUCCESS.getCode())
&& Objects.equals(caseLog.getRunStatus(), CaseDocumentLogCaseStatusEnum.SUCCESS.getCode());
// 2. 是否存在上传中的案例
boolean hasUploading = StringUtils.equals(caseLog.getRequestUrl(), CaseAiConstants.CASE_DOC_UPLOAD_INTERFACE_NAME)
&& Objects.equals(caseLog.getRunStatus(), CaseDocumentLogRunStatusEnum.RUNNING.getCode());
return hasCompleted || hasUploading;
})) {
casesList.add(cases);
}
}
// log.info("过滤后需要处理的案例数量: {}", casesList.size());
if (!casesList.isEmpty()) {
// 调用异步处理方法
caseAiDocumentAsyncHandler.process(CaseDocumentLogOptTypeEnum.CREATE, casesList.toArray(new Cases[0]));
} else {
log.info("没有新的案例需要处理");
}
// 将当前处理的最后一条数据ID存入Redis
// log.info("旧案例上传任务执行完成");
} catch (Exception e) {
log.error("执行旧案例上传任务时发生异常", e);
} finally {
if (currentLastId != null) {
fixOnLastCase(currentLastId);
}
}
}
/**
* 查询需要处理的案例数据
*
* @param lastProcessedId 上次处理的最后一条记录ID
* @return 案例列表
*/
private List<Cases> findCasesToProcess(String lastProcessedId) {
QueryBuilder queryBuilder = QueryBuilder.from(Cases.class);
queryBuilder.addFilter(FieldFilters.eq("deleted", false));
// 只处理有文件路径的案例
queryBuilder.addFilter(FieldFilters.isNotNull("filePath"));
queryBuilder.addFilter(FieldFilters.ne("filePath", ""));
// 如果有上次处理的ID则从该ID之后开始查询
if (lastProcessedId != null && !lastProcessedId.isEmpty()) {
queryBuilder.addFilter(FieldFilters.gt("id", lastProcessedId));
}
// 按创建时间升序排序
queryBuilder.addOrder(OrderCondition.asc("id"));
// 限制每次处理的数量,避免一次性处理太多数据
queryBuilder.setPageSize(100);
return casesDao.findList(queryBuilder.builder());
}
/**
* 获取需要重新加载的案例
* @param lastProcessedId
* @return
*/
private List<CaseDocumentLog> listToReload(String lastProcessedId) {
QueryBuilder queryBuilder = QueryBuilder.from(CaseDocumentLog.class);
queryBuilder.addFilter(FieldFilters.eq("deleted", false));
queryBuilder.addFilter(FieldFilters.eq("requestUrl", CaseAiConstants.CASE_DOC_UPLOAD_INTERFACE_NAME));
queryBuilder.addFilter(FieldFilters.eq("caseStatus", CaseDocumentLogCaseStatusEnum.SUCCESS.getCode()));
queryBuilder.addFilter(FieldFilters.eq("metadataStatus", 0));
if (lastProcessedId != null && !lastProcessedId.isEmpty()) {
queryBuilder.addFilter(FieldFilters.gt("id", lastProcessedId));
}
queryBuilder.addOrder(OrderCondition.asc("id"));
queryBuilder.setPageSize(100);
return caseDocumentLogDao.findList(queryBuilder.builder());
}
private void fixOnLastCase(String currentLastId) {
stringRedisTemplate.opsForValue().set(CASE_UPLOAD_LAST_ID_KEY, currentLastId);
log.info("已处理案例最后一条记录ID已更新为: {}", currentLastId);
}
}

View File

@@ -1,10 +0,0 @@
package com.xboe.module.boecase.vo;
import lombok.Data;
/**
* AI会话记录
*/
@Data
public class CaseAiConversationVo {
}

View File

@@ -1,79 +0,0 @@
package com.xboe.module.boecase.vo;
import lombok.Data;
import java.time.LocalDateTime;
import java.util.List;
/**
* AI会话消息记录VO
*/
@Data
public class CaseAiMessageVo {
/**
* ES docId
*/
private String docId;
/**
* 会话ID
*/
private String conversationId;
/**
* 用户提问内容
*/
private String query;
/**
* AI回答内容
*/
private String answer;
/**
* 会话开始时间
*/
private LocalDateTime startTime;
/**
* 会话时长(秒)
*/
private Integer durationSeconds;
/**
* 案例引用列表
*/
private List<CaseReferVo> caseRefer;
/**
* 建议列表
*/
private List<String> suggestions;
/**
* 状态
* 0-正常
* 1-系统错误
* 2-AIoT平台错误
*/
private Integer status;
/**
* 错误信息
*/
private String errorMsg;
/**
* 用户点赞状态
* -1: 踩
* 1
* 0/null 无操作
*/
private String likeStatus;
/**
* 用户踩的时候, 可以填写反馈意见
* 反馈意见
*/
private String feedback;
}

View File

@@ -1,76 +0,0 @@
package com.xboe.module.boecase.vo;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import java.time.LocalDateTime;
/**
* AI调用日志列表展示VO
*/
@Data
public class CaseDocumentLogVo {
/**
* 日志ID
*/
private String id;
/**
* 案例标题
*/
private String caseTitle;
/**
* 操作类型
*/
private String optType;
/**
* 调用接口名称
*/
private String requestUrl;
/**
* 调用时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private LocalDateTime optTime;
/**
* 请求参数
*/
private String requestBody;
/**
* 响应参数
*/
private String responseBody;
/**
* 接口调用结果
* 0-调用中, 1-调用成功, 2-调用失败
*/
private Integer optStatus;
/**
* 接口调用结果描述
*/
private String optStatusText;
/**
* 业务处理结果
* 1-处理成功, 2-处理失败
*/
private Integer caseStatus;
/**
* 业务处理结果描述
*/
private String caseStatusText;
/**
* 执行时间(ms)
*/
private Long executeDuration;
}

View File

@@ -1,52 +0,0 @@
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;
/**
* 案例引用信息VO
*/
@Data
public class CaseReferVo {
/**
* 案例ID
*/
private String caseId;
/**
* 案例标题
*/
private String title;
/**
* 作者姓名
*/
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;
/**
* 关键词列表
*/
private List<String> keywords;
/**
* 案例内容
*/
private String content;
}

View File

@@ -1,31 +0,0 @@
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;
}

View File

@@ -358,8 +358,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) {

View File

@@ -278,7 +278,7 @@ public class CourseFileApi extends ApiBaseController {
}
}
} catch (Exception e) {
log.error("读取视频时长错误");
log.error("读取视频时长错误", e);
// e.printStackTrace();
}
}

View File

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

View File

@@ -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);
}
}

View File

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

View File

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

View File

@@ -15,9 +15,13 @@ 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 com.xboe.api.ThirdApi;
import com.xboe.core.orm.*;
import com.xboe.module.course.dao.*;
import com.xboe.module.course.entity.*;
import com.xboe.school.study.dao.StudyCourseDao;
import com.xboe.school.study.entity.StudyCourse;
import org.apache.commons.lang3.StringUtils;
@@ -41,24 +45,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;
@@ -125,8 +114,12 @@ public class CourseServiceImpl implements ICourseService {
@Resource
RestHighLevelClient restHighLevelClient;
@Resource
private CourseTeacherDeletedRecordDao courseTeacherDeletedRecordDao;
@Resource
private ModifyLogDao modifyLogDao;
/**
* 生成过滤条件
*
@@ -183,7 +176,7 @@ 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) {
} else if (dto.getDevice() == Course.DEVICE_INTERNAL) {
filters.add(FieldFilters.eq("device", Course.DEVICE_INTERNAL));
}
@@ -281,13 +274,13 @@ public class CourseServiceImpl implements ICourseService {
//// Set<String>list=new HashSet<>();
//// if(s!=null&&!s.isEmpty()){
//// list=Arrays.stream(s.split(",")).collect(Collectors.toSet());
//// }else {
//// }else {
//// Set<String> ss = getSeache(dto);
//// String courseSearch=String.join(",",ss);
//// redisTemplate.opsForValue().set("course_search",courseSearch);
//// //设置过期时间为1分钟
//// redisTemplate.expire("course_search", 1, TimeUnit.MINUTES);
//// }
//// }
// Set<String> list = getSeache(dto);
// //有权限的查询,也同时查询出创建人的数据,在权限上
// if(TempFilterConfig.Manager_CourseFile_ByOrgIds) {
@@ -367,8 +360,9 @@ public class CourseServiceImpl implements ICourseService {
// // 使用distinct()配合自定义的去重条件
// .filter(distinctByKey(c -> c.getId()))
// .collect(Collectors.toList());
//// PageList<Course> rs=courseDao.findPage(pageIndex, pageSize, filters, oc);
//// long endTime = System.nanoTime();
/// / PageList<Course> rs=courseDao.findPage(pageIndex, pageSize, filters, oc);
/// / long endTime = System.nanoTime();
// //log.info("查询出的条数:"+rs.getCount());
// if(!mergedList.isEmpty()){
// //去掉未发布的课程
@@ -425,30 +419,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());
@@ -868,7 +862,7 @@ public class CourseServiceImpl implements ICourseService {
}
// 删除ES数据
deletedStudyResourceBatchByCourseIdAndType(id,c.getType());
deletedStudyResourceBatchByCourseIdAndType(id, c.getType());
} else {
//彻底删除,课件设置为无课程状态
courseDao.setDeleted(id);
@@ -920,6 +914,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()) {
@@ -1002,12 +997,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, "M2位置讲师名修改", JSONUtil.toJsonStr(ct), null);
}
}
//先清空受众信息,受众信息如果不一样了,也要加入到日志中
@@ -1056,12 +1054,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);
}
}
//先清空受众信息,受众信息如果不一样了,也要加入到日志中
@@ -1091,12 +1092,15 @@ public class CourseServiceImpl implements ICourseService {
c.setPublishTime(LocalDateTime.now());
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);
}
}
//先清空受众信息,受众信息如果不一样了,也要加入到日志中
@@ -2013,4 +2017,41 @@ 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);
}
}
}

View File

@@ -592,8 +592,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);

View File

@@ -11,22 +11,22 @@ spring:
cloud:
nacos:
discovery:
server-addr: 192.168.10.74:8848
server-addr: 192.168.0.253:8848
config:
server-addr: 192.168.10.74:8848
server-addr: 192.168.0.253:8848
redis:
database: 2
host: 39.104.123.58
password: Ebiz2020
port: 6378
database: 1
host: 192.168.0.253
password: boe@123
port: 6379
jpa:
hibernate:
ddl-auto: none
datasource:
driverClassName: com.mysql.jdbc.Driver
url: jdbc:mysql://rm-hp3cpkk0u50q90eu9vo.mysql.huhehaote.rds.aliyuncs.com:3306/ebiz_doc_manage?characterEncoding=utf8&useUnicode=true&serverTimezone=Asia/Shanghai&useSSL=false&allowMultiQueries=true
username: ebiz_ai
password: ebiz_ai123
url: jdbc:mysql://192.168.0.253:3306/boe_base?useSSL=false&useUnicode=true&characterEncoding=UTF8&zeroDateTimeBehavior=convertToNull
username: root
password: boe#1234A
type: com.zaxxer.hikari.HikariDataSource
hikari:
auto-commit: true
@@ -35,12 +35,6 @@ spring:
connection-timeout: 30000
max-lifetime: 1800000
maximum-pool-size: 20
activemq:
broker-url: tcp://192.168.10.74:61616
user: admin
password: admin
jms:
pub-sub-domain: true
logging:
level:
org:
@@ -85,16 +79,6 @@ xboe:
image:
course:
default: http://192.168.0.253/pc/images/bgimg/course.png
case:
ai:
base-url: http://10.10.181.114:30003
app-key: 6e9be45319184ac793aa127c362b0f0b
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
alert-email-recipients:
- liu.zixi@ebiz-digits.com
xxl:
job:
accessToken: 65ddc683-22f5-83b4-de3a-3c97a0a29af0
@@ -113,7 +97,7 @@ aop-log-record:
#不进行拦截的包或者类
excludeClassNames:
activemq:
broker-url: tcp://192.168.10.74:61616
broker-url: tcp://192.168.0.253:61616
user: admin
password: admin
elasticsearch:

View File

@@ -40,12 +40,6 @@ spring:
web:
resources:
static-locations: file:E:/Projects/BOE/10/static
activemq:
broker-url: tcp://10.251.129.51:61616
user: admin
password: admin
jms:
pub-sub-domain: true
server:
port: 9090
tomcat:
@@ -117,16 +111,6 @@ xboe:
image:
course:
default: http://10.251.132.75/pc/images/bgimg/course.png
case:
ai:
base-url: http://10.10.181.114:30003
app-key: 6e9be45319184ac793aa127c362b0f0b
secret-key: db4d24279e3d6dbf1524af42cd0bedd2
ai-api-code: 30800
case-knowledge-id: de2e006e-82fb-4ace-8813-f25c316be4ff
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

View File

@@ -33,12 +33,6 @@ spring:
connection-timeout: 30000
max-lifetime: 1800000
maximum-pool-size: 20
activemq:
broker-url: tcp://10.251.113.100:61616
user: admin
password: admin
jms:
pub-sub-domain: true
logging:
level:
org:
@@ -83,245 +77,6 @@ xboe:
image:
course:
default: https://u.boe.com/pc/images/bgimg/course.png
case:
ai:
base-url: https://gateway-internal.boe.com
# base-url: https://gateway-pro.boe.com
app-key: 3edef300b25642da949ccddf58441a0f
secret-key: 43bc8003a811a7f9c89cbecbfe4bbb22
ai-api-code: 30800
chat-api-code: 32065
# case-knowledge-id: f062c9e4-c6ad-437b-b5ca-bbb9fed9b442
# 20251117 张娟提供新版kId
case-knowledge-id: 0a4d5d9e-0dae-456e-a342-3dfd2046b9e3
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"
# 20251202 新增天使用户
- "30103141"
- "60001391"
- "61001278"
- "30101301"
- "10444837"
- "50102190"
- "10745030"
- "11417101"
- "11305432"
- "10103037"
- "10035168"
- "30118060"
- "11490910"
- "11402931"
- "50102196"
- "00004896"
- "98050025"
- "15014359"
- "98000758"
- "10111538"
- "62000137"
- "10621476"
- "11698996"
- "10626304"
- "1215826"
- "30101887"
- "10111915"
- "11456852"
- "126458"
- "30141438"
- "10209179"
- "22BT15420"
- "21BB2053"
- "10449861"
- "130325"
- "11331818"
- "10117022"
- "10105891"
- "121649"
- "110338"
- "1217784"
- "30105038"
- "98000792"
- "60001146"
- "11698607"
- "11493629"
- "10164819"
- "11463452"
- "10412122"
- "11677116"
- "98000780"
- "61004269"
- "1218902"
- "111038"
- "10056775"
- "50125311"
- "50100445"
- "00003320"
- "11672602"
- "30129421"
- "11433296"
- "11759796"
- "10063656"
- "10829939"
- "98050190"
- "10061076"
- "60001460"
- "10415155"
- "60000626"
- "110791"
- "60000984"
- "62000025"
- "11794394"
- "11681568"
- "00002915"
- "1210874"
- "132046"
- "10157955"
- "00004409"
- "10773520"
- "102403"
- "10119108"
- "10062300"
- "10334899"
- "10111689"
- "10258267"
- "60000327"
- "50100096"
- "10075741"
- "1000477"
- "1218405"
- "132666"
- "10183064"
- "50101990"
- "120869"
- "11291711"
- "11670020"
- "11321710"
- "10855714"
- "11331449"
- "50108923"
- "66001553"
- "81011081"
- "11098405"
- "10158509"
- "11327800"
- "10065717"
- "10897206"
- "30135784"
- "1200373"
- "10048566"
- "10059710"
- "11834720"
- "1200384"
- "60000973"
- "11282207"
- "40865"
- "10811920"
- "00003324"
- "00003937"
- "10031853"
- "1201730"
- "00004615"
- "10613607"
- "10166435"
- "11407507"
- "21BB0031"
- "00002198"
- "30104243"
- "10840493"
- "10046158"
- "132164"
- "11257354"
- "11753398"
- "10230265"
- "11293165"
- "10114925"
- "S638"
- "10833174"
- "10926203"
- "124046"
- "201181"
- "11319329"
- "10884794"
- "10331955"
- "60000847"
- "1411"
- "126581"
- "00003375"
- "132539"
- "98050455"
- "10053666"
- "11697194"
- "61002398"
- "00002971"
- "14157"
- "132989"
- "50103467"
- "37315"
- "10088583"
- "11048954"
- "110202"
- "30141433"
- "1000079"
- "11783149"
- "10025448"
- "98000579"
- "10614158"
- "30104381"
- "60000122"
- "11074875"
- "10009047"
- "10228087"
- "10875722"
- "10041401"
- "110679"
- "11167945"
- "11288196"
- "00003111"
- "11780879"
- "10836255"
- "10753364"
- "50102132"
- "10711537"
- "15001329"
- "11733703"
- "10450632"
- "98050011"
- "10224644"
- "120931"
- "10743223"
- "107873"
- "11141942"
- "120434"
- "126466"
- "98050020"
- "10928732"
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
@@ -345,11 +100,4 @@ aop-log-record:
password: admin
elasticsearch:
host: 10.251.88.218
port: 9200
ok:
http:
connect-timeout: 300
read-timeout: 300
write-timeout: 300
max-idle-connections: 200
keep-alive-duration: 300
port: 9200

View File

@@ -40,12 +40,6 @@ spring:
web:
resources:
static-locations: file:E:/Projects/BOE/10/static
activemq:
broker-url: tcp://10.251.129.25:61616
user: admin
password: admin
jms:
pub-sub-domain: true
server:
port: 9090
tomcat:
@@ -117,41 +111,6 @@ xboe:
image:
course:
default: https://u-pre.boe.com/pc/images/bgimg/course.png
case:
ai:
base-url: http://10.10.181.114:30003
app-key: 6e9be45319184ac793aa127c362b0f0b
secret-key: db4d24279e3d6dbf1524af42cd0bedd2
ai-api-code: 30800
chat-api-code: 32065
case-knowledge-id: de2e006e-82fb-4ace-8813-f25c316be4ff
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
@@ -163,8 +122,8 @@ boe:
ok:
http:
connect-timeout: 30
read-timeout: 300
write-timeout: 300
read-timeout: 30
write-timeout: 30
max-idle-connections: 200
keep-alive-duration: 300

View File

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

View File

@@ -1,82 +0,0 @@
{
"properties": {
"conversationId": {
"type": "keyword",
"index": true
},
"query": {
"type": "text",
"analyzer": "ik_max_word",
"search_analyzer": "ik_smart",
"fields": {
"keyword": {
"type": "keyword",
"ignore_above": 256
}
}
},
"answer": {
"type": "text",
"analyzer": "ik_max_word",
"search_analyzer": "ik_smart"
},
"caseRefer": {
"type": "nested",
"properties": {
"caseId": {
"type": "keyword",
"index": true
},
"title": {
"type": "text",
"analyzer": "ik_max_word",
"search_analyzer": "ik_smart"
},
"authorName": {
"type": "keyword",
"index": true
},
"keywords": {
"type": "text",
"analyzer": "ik_max_word",
"search_analyzer": "ik_smart"
},
"content": {
"type": "text",
"analyzer": "ik_max_word",
"search_analyzer": "ik_smart"
}
}
},
"suggestions": {
"type": "text",
"analyzer": "ik_max_word",
"search_analyzer": "ik_smart"
},
"userId": {
"type": "keyword",
"index": true
},
"timestamp": {
"type": "date",
"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"
},
"status": {
"type": "integer"
},
"errorMsg": {
"type": "text",
"analyzer": "ik_max_word",
"search_analyzer": "ik_smart"
},
"likeStatus": {
"type": "keyword",
"index": true
},
"feedback": {
"type": "text",
"analyzer": "ik_max_word",
"search_analyzer": "ik_smart"
}
}
}

View File

@@ -31,42 +31,26 @@
</encoder>
</appender>
<appender name="caseAiChat"
class="ch.qos.logback.core.rolling.RollingFileAppender">
<!-- Log file error output -->
<appender name="error" class="ch.qos.logback.core.rolling.RollingFileAppender">
<file>${log.path}/error.log</file>
<rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
<fileNamePattern>${log.path}/%d{yyyy-MM}/error.%d{yyyy-MM-dd}.%i.log.gz</fileNamePattern>
<maxFileSize>50MB</maxFileSize>
<maxHistory>30</maxHistory>
</rollingPolicy>
<encoder>
<pattern>%date [%thread] %-5level [%logger{50}] %file:%line - %msg%n</pattern>
<charset>UTF-8</charset>
</encoder>
<file>${log.path}/caseAiChat.log</file>
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<fileNamePattern>${log.path}/caseAiChat.%d{yyyy-MM-dd}.log</fileNamePattern>
</rollingPolicy>
<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
<level>ERROR</level>
</filter>
</appender>
<!-- Log file error output -->
<!-- <appender name="caseAiChat" class="ch.qos.logback.core.rolling.RollingFileAppender">-->
<!-- <file>${log.path}/caseAiChat.log</file>-->
<!-- <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">-->
<!-- <fileNamePattern>${log.path}/%d{yyyy-MM}/caseAiChat.%d{yyyy-MM-dd}.%i.log.gz</fileNamePattern>-->
<!-- <maxFileSize>50MB</maxFileSize>-->
<!-- <maxHistory>30</maxHistory>-->
<!-- </rollingPolicy>-->
<!-- <encoder>-->
<!-- <pattern>%date [%thread] %-5level [%logger{50}] %file:%line - %msg%n</pattern>-->
<!-- </encoder>-->
<!-- <filter class="ch.qos.logback.classic.filter.ThresholdFilter">-->
<!-- <level>ERROR</level>-->
<!-- </filter>-->
<!-- </appender>-->
<!-- Level: FATAL 0 ERROR 3 WARN 4 INFO 6 DEBUG 7 -->
<root level="INFO">
<appender-ref ref="info"/>
<!-- <appender-ref ref="console"/>-->
<!-- <appender-ref ref="error"/> -->
</root>
<logger name="caseAiChatLogger" additivity="false" level="INFO">
<appender-ref ref="caseAiChat"/>
</logger>
</configuration>

View File

@@ -47,26 +47,10 @@
</filter>
</appender>
<appender name="caseAiChat"
class="ch.qos.logback.core.rolling.RollingFileAppender">
<encoder>
<pattern>%date [%thread] %-5level [%logger{50}] %file:%line - %msg%n</pattern>
<charset>UTF-8</charset>
</encoder>
<File>${log.path}/caseAiChat.log</File>
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<FileNamePattern>${log.path}/caseAiChat.%d{yyyy-MM-dd}.log</FileNamePattern>
</rollingPolicy>
</appender>
<!-- Level: FATAL 0 ERROR 3 WARN 4 INFO 6 DEBUG 7 -->
<root level="INFO">
<appender-ref ref="debug"/>
<appender-ref ref="error"/>
<appender-ref ref="console"/>
</root>
<logger name="caseAiChatLogger" additivity="false" level="INFO">
<appender-ref ref="caseAiChat"/>
</logger>
</configuration>