chat-backend/takai-ai/src/main/java/com/takai/ai/service/impl/TakaiAiServiceImpl.java

package com.takai.ai.service.impl;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.takai.ai.domain.TakaiSysOss;
import com.takai.ai.domain.dto.TakaiDialogDetailReqDTO;
import com.takai.ai.domain.entity.*;
import com.takai.ai.mapper.*;
import com.takai.ai.service.ITakaiAiService;
import com.takai.ai.utils.MinioUtil;
import com.takai.ai.utils.SnowflakeDigitGenerator;
import com.takai.common.annotation.DataSource;
import com.takai.common.config.DeepseekConfig;
import com.takai.common.core.redis.RedisCache;
import com.takai.common.enums.DataSourceType;
import com.takai.ai.domain.dto.TakaiDialogReqDTO;
import com.takai.ai.domain.dto.TakaiDialogRespDTO;
import com.takai.ai.domain.dto.TakaiQuestionDTO;
import com.takai.common.utils.StringUtils;
import com.takai.common.utils.uuid.IdUtils;
import lombok.extern.slf4j.Slf4j;
import okhttp3.*;
import okhttp3.sse.EventSource;
import okhttp3.sse.EventSourceListener;
import okhttp3.sse.EventSources;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;

import javax.validation.constraints.NotNull;
import java.io.IOException;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
 * 高井 业务层处理
 *
 * @author takai
 */
@Slf4j
@Service
@DataSource(DataSourceType.MASTER)
public class TakaiAiServiceImpl implements ITakaiAiService {
    private static final Logger logger = LoggerFactory.getLogger(TakaiAiServiceImpl.class);
    @Autowired
    private TakaiDialogMapper takaiDialogMapper;

    @Autowired
    private TakaiApplicationMapper takaiApplicationMapper;

    @Autowired
    private TakaiQuestionMapper takaiQuestionMapper;

    @Autowired
    private TakaiKnowledgeMapper takaiKnowledgeMapper;

    @Autowired
    private TakaiDocumentMapper takaiDocumentMapper;

    @Autowired
    private TakaiSysOssConfigMapper takaiSysOssConfigMapper;

    @Autowired
    private TakaiSysOssMapper takaiSysOssMapper;

    @Autowired
    private MinioUtil minioUtil;

    @Autowired
    private TakaiDocumentSettingsMapper takaiDocumentSettingsMapper;

    @Autowired
    private DeepseekConfig deepseekConfig;

    @Autowired
    private TakaiAppInfoMapper takaiAppInfoMapper;

    @Autowired
    private TakaiMediaReplacementMapper takaiMediaReplacementMapper;

    @Autowired
    private RedisCache redisCache;

    @Autowired
    public RedisTemplate redisTemplate;

    public static final String START_SIGN = "【";
    public static final String END_SIGN = "】";
    public static final String SYMBOL = "【示意图序号";

    public static final String USER_STR = "user";

    public static final String TODAY = "今天";

    public static final String BEFOR = "天前";

    @Override
    public void initDeepseekInfo() {
        //获取应用列表
//        List<TakaiApplication> appList = takaiApplicationMapper.selectApplicationList(null);
        setRedisCache(null);
    }

    private void setRedisCache(String knowledgeId) {
        //获取知识库列表
        List<TakaiKnowledge> knowledgeList = null;
        if (StringUtils.isEmpty(knowledgeId)) {
            knowledgeList = takaiKnowledgeMapper.selectKnowledgeList(null);
        } else {
            knowledgeList = takaiKnowledgeMapper.selectKnowledgeList(TakaiKnowledge.builder().knowledgeId(knowledgeId).build());
        }

        //获取知识列表
        if (!knowledgeList.isEmpty()) {
            for (TakaiKnowledge bmKnowledge : knowledgeList) {
                TakaiDocument conditon = TakaiDocument.builder().knowledgeId(bmKnowledge.getKnowledgeId()).build();
                List<TakaiDocument> documentList = takaiDocumentMapper.selectDocumentList(conditon);
                if (!documentList.isEmpty()) {
                    for (TakaiDocument bmDocument : documentList) {
                        //获取知识图片列表
                        TakaiMediaReplacement conditonR = TakaiMediaReplacement.builder().documentId(bmDocument.getDocumentId()).build();
                        List<TakaiMediaReplacement> imageList = takaiMediaReplacementMapper.selectMediaList(conditonR);
                        if (!imageList.isEmpty()) {
                            for (TakaiMediaReplacement image : imageList) {
                                redisCache.setCacheObject(image.getOriginText(), image.getMediaUrl());
                            }
                        }
                    }
                }
            }
        }
    }

    @Override
    public SseEmitter sseInvoke(TakaiSseInfoParams sseParams) {
        TakaiApplication appInfo = takaiApplicationMapper.selectTargetApplication(TakaiApplication.builder().appId(sseParams.getAppId()).build());
        if (appInfo != null) {
            TakaiKnowledge knowledge = takaiKnowledgeMapper.selectTargetKnowledge(TakaiKnowledge.builder().knowledgeId(appInfo.getKnowledgeIds()).build());
            if (knowledge != null) {
                SseEmitter sseEmitter = new SseEmitter(0L);
                String url = deepseekConfig.getBaseurl() + deepseekConfig.getChat();
                TakaiAppInfo info = takaiAppInfoMapper.selectAppInfoByAppId(sseParams.getAppId());
                JSONObject json = JSONObject.parseObject(info.getAppInfo());
                String query = sseParams.getPrompt().get(sseParams.getPrompt().size() - 1).getContent();
                log.info("deepseek聊天请求参数：" + query);
                json.put("query", query);
                json.put("embeddingId", knowledge.getEmbeddingId());

                RequestBody requestBody = FormBody.create(MediaType.parse("application/json; charset=utf-8"), json.toJSONString());
                Request request = buildPostRequest(url, requestBody);
                // 使用EventSourceListener处理来自服务器的SSE事件
                EventSourceListener listener = new EventSourceListener() {
                    private String preData = "";
                    //图片识别
                    private String symbolData = "";

                    @Override
                    public void onOpen(@NotNull EventSource eventSource, @NotNull Response response) {
                        log.info("deepseek Connection opened. Headers: {}", response.headers());
                        log.info("deepseek Request URL: {}", response.request().url());
                    }

                    @Override
                    public void onClosed(@NotNull EventSource eventSource) {
                        log.info("deepseek Connection closed.");
                        sseEmitter.complete();
                    }

                    @Override
                    public void onEvent(@NotNull EventSource eventSource, String id, String type, @NotNull String data) {
                        if (!StringUtils.isEmpty(data)) {
                            String newData = data.substring(preData.length());
                            if (com.takai.common.utils.StringUtils.isNotEmpty(type) && "finish".equals(type)) {
                                logger.info("deepseek聊天结束", newData);
                            }
                            logger.info("deepseek聊天返回消息：" + data);
                            preData = data;
                            if (newData.indexOf(START_SIGN) > -1 || symbolData.length() > 0) {
                                symbolData = symbolData + newData;
                                //接收到了完整的图片标识
                                if (newData.indexOf(END_SIGN) > -1) {
                                    //是图片
                                    if (symbolData.indexOf(SYMBOL) > -1) {
                                        //获取完整Key
                                        int startPos = symbolData.indexOf(START_SIGN);
                                        int endPos = symbolData.indexOf(END_SIGN) + 1;
                                        String key = symbolData.substring(startPos, endPos);
                                        String url = redisCache.getCacheObject(key);
                                        if (org.springframework.util.StringUtils.hasText(url)) {
                                            if(url.contains("https://10.1.28.14:9000")){
                                                url = url.replace("https://10.1.28.14:9000", "https://minio.jkec.info:9000");
                                            }
                                            //匹配markdown图片格式
                                            symbolData = symbolData.replace(key, "![](" + url + ")");
                                        }
                                    }
                                    JSONObject json = new JSONObject();
                                    json.put("id", id);
                                    json.put("event", "add");
                                    long count = symbolData.chars().filter(c -> c == '【').count();
                                    if(count > 1){
                                        int firstPos = symbolData.indexOf(START_SIGN);
                                        if (firstPos != -1) {
                                            // 从第一个 '【' 的下一个位置开始查找第二个 '【'
                                            int secondPos = symbolData.indexOf(START_SIGN, firstPos + 1);
                                            if (secondPos != -1) {
                                                // 从第二个 '【' 开始截取
                                                json.put("data", symbolData.substring(0, secondPos));
                                                symbolData = symbolData.substring(secondPos);
                                                logger.info("截取结果{}: " + symbolData);
                                            }
                                        }
                                    }else{
                                        json.put("data", symbolData);
                                        symbolData = "";
                                    }
                                    log.info("deepseek返回信息：" + json);
                                    send(sseEmitter, json);
                                }
                            } else {
                                JSONObject json = new JSONObject();
                                json.put("id", id);
                                json.put("event", type);
                                json.put("data", newData);
                                log.info("deepseek返回信息：" + json);
                                send(sseEmitter, json);
                            }
                        }
                    }

                    @Override
                    public void onFailure(@NotNull EventSource eventSource, Throwable t, Response response) {
                        if (response != null) {
                            log.error("deepseek Connection failed. Response code: {}, message: {}, body: {}",
                                    response.code(), response.message(), response.body() != null ? response.body().toString() : "null");
                        } else {
                            log.error("deepseek Connection failed with no response", t);
                        }
                        sseEmitter.completeWithError(t);
                    }

                    private void send(SseEmitter sseEmitter, Object obj) {
                        try {
                            sseEmitter.send(obj);
                        } catch (IOException e) {
                            log.error("deepseek 推送数据失败", e);
                        }
                    }
                };

                OkHttpClient client = buildOkHttpClient();
                EventSource.Factory factory = EventSources.createFactory(client);
                final EventSource eventSources = factory.newEventSource(request, listener);

                // 客户端主动关闭连接
                sseEmitter.onCompletion(() -> {
                    logger.info("deepseek客户端主动关闭连接 -- SSE 连接关闭");
                });

                // 超时回调
                sseEmitter.onTimeout(() -> {
                    logger.info("deepseek客户端连接超时 -- SSE 连接关闭");
                    if(eventSources != null) {
                        logger.info("deepseek超时回调 -- 成功关闭SSE连接 ");
                        eventSources.cancel();
                    }
                });

                // 错误回调
                sseEmitter.onError(e -> {
                    logger.info("deepseek客户端回调失败 -- SSE 连接关闭");
                    if(eventSources != null) {
                        logger.info("deepseek错误回调 -- 成功关闭SSE连接 ");
                        eventSources.cancel();
                    }
                });
                return sseEmitter;
            }
        }
        return null;
    }

    @Override
    public List<String> asyncCompletions(TakaiCompletionsParams params) {
        List<String> list = new ArrayList<>();
        TakaiApplication vo = takaiApplicationMapper.selectTargetApplication(TakaiApplication.builder().appId(params.getAppId()).build());
        if (vo != null) {
            TakaiPromptInfo info = new TakaiPromptInfo();
            info.setContent(deepseekConfig.getPrompt());
            info.setRole("user");
            params.getMessages().add(info);

            JSONObject jsonObject = new JSONObject();
            jsonObject.put("model", vo.getModel());
            jsonObject.put("messages", params.getMessages());
            JSONObject result = getasyncCompletions(jsonObject);
            if (result != null && result.getInteger("code") == 200) {
                JSONArray array = result.getJSONArray("data");
                list.addAll(array.toJavaList(String.class));
            }
        }
        return list;
    }

    private JSONObject getasyncCompletions(JSONObject jsonObject) {
        String url = deepseekConfig.getBaseurl() + deepseekConfig.getAsyncCompletions();
        RequestBody requestBody = FormBody.create(MediaType.parse("application/json; charset=utf-8"), jsonObject.toJSONString());
        Request request = buildPostRequest(url, requestBody);
        OkHttpClient client = buildOkHttpClient();
        try {
            Response response = client.newCall(request).execute();
            if (response.isSuccessful()) {
                String body = response.body().string();
                if (isJsonObject(body)) {
                    return JSON.parseObject(body);
                }
            }
        } catch (IOException e) {
            log.info("deepseek Request URL: {}", e.getMessage());
        }
        return null;
    }

    @Override
    public List<TakaiDialogRespDTO> getDialogDetail(String dialogId) {
        List<TakaiDialogRespDTO> detail = takaiDialogMapper.selectDialogDetail(dialogId);
        return detail;
    }

    @Override
    public void saveDialog(TakaiDialogReqDTO dialogReqDTO) {
        String dialogId = null;
        TakaiDialogRespDTO dialogVo = null;
        if (com.takai.common.utils.StringUtils.isNotEmpty(dialogReqDTO.getId())) {
            dialogVo = takaiDialogMapper.selectDialogById(dialogReqDTO.getId());
        }

        if (dialogVo == null) {
            takaiDialogMapper.insertDialog(dialogReqDTO);
            dialogId = dialogReqDTO.getId();
        } else {
            dialogId = dialogReqDTO.getId();
        }

        for (TakaiDialogDetailReqDTO dto : dialogReqDTO.getMessages()) {
            dto.setDialogId(dialogId);
            TakaiDialogRespDTO detail = takaiDialogMapper.selectDialogDetailById(dto.getId());
            if (detail == null) {
                takaiDialogMapper.insertDialogDetail(dto);
            }
        }
    }

    @Override
    public List<Object> getDialogList(String appId) {
        List<TakaiDialogRespDTO> dialogRespDTOS = takaiDialogMapper.selectDialogList(appId);
        //当前日期
        LocalDate today = LocalDate.now();
        //根据时间分组降序排序
        NavigableMap<LocalDateTime, List<TakaiDialogRespDTO>> groupList = dialogRespDTOS.stream().collect(Collectors.groupingBy(TakaiDialogRespDTO::getCreate_time, TreeMap::new, Collectors.toList())).descendingMap();
        List<Object> obj = new ArrayList();
        if (!groupList.isEmpty()) {
            for (Map.Entry<LocalDateTime, List<TakaiDialogRespDTO>> entry : groupList.entrySet()) {
                // 对比两个时间相差多少天
                long daysBetween = ChronoUnit.DAYS.between(today, entry.getKey());
                Map<String, Object> m = new HashMap();
                m.put("key", System.nanoTime());
                m.put("type", "group");
                if (daysBetween == 0l) {
                    m.put("label", TODAY);
                    m.put("children", setValue(entry.getValue()));
                    obj.add(m);
                } else {
                    m.put("label", -daysBetween + BEFOR);
                    m.put("children", setValue(entry.getValue()));
                    obj.add(m);
                }
            }
        }
        return obj;
    }

    @Override
    public void DelDialogDetail(String id) {
        int result = takaiDialogMapper.delDialog(id);
        if (result > 0) {
            takaiDialogMapper.delDialogDetail(id);
        }
    }

    @Override
    public void updateDialog(TakaiDialogReqDTO dialogReqDTO) {
        takaiDialogMapper.updateDialog(dialogReqDTO);
    }

    @Override
    public List<TakaiDialogRespDTO> exportExcel(String dialogId) {
        return takaiDialogMapper.selectDialogExport(dialogId);
    }

    @Override
    public int createKnowledge(TakaiKnowledgeParams knowledge) {
        SnowflakeDigitGenerator snowflakeDigitGenerator = new SnowflakeDigitGenerator(1, 1);
        long knowledgeId = snowflakeDigitGenerator.nextId();

        String url = deepseekConfig.getBaseurl() + deepseekConfig.getCreateKnowledge();
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("knowledge_id", "a" + knowledgeId);
        jsonObject.put("embedding_id", knowledge.getEmbeddingId());

        RequestBody requestBody = FormBody.create(MediaType.parse("application/json; charset=utf-8"), jsonObject.toJSONString());
        Request request = buildPostRequest(url, requestBody);
        OkHttpClient client = buildOkHttpClient();
        try {
            Response response = client.newCall(request).execute();
            if (response.isSuccessful()) {
                String body = response.body().string();
                JSONObject obj = JSON.parseObject(body);
                Integer code = obj.getInteger("code");
                if (code == 200) {
                    TakaiKnowledge params = TakaiKnowledge.builder()
                            .knowledgeId("a" + knowledgeId)
                            .name(knowledge.getName())
                            .embeddingId(knowledge.getEmbeddingId())
                            .description(knowledge.getDescription())
                            .build();
                    return takaiKnowledgeMapper.insertKnowledge(params);
                }
            } else {
                logger.error("创建知识库调用python接口失败,返回状态码：{}", response.code());
            }
        } catch (IOException e) {
            logger.error("创建知识库调用python接口失败", e.getMessage());
        }
        return 0;
    }

    @Override
    public int updateKnowledge(TakaiKnowledgeParams knowledge, String knowledgeId) {
        TakaiKnowledge params = TakaiKnowledge.builder().knowledgeId(knowledgeId)
                .name(knowledge.getName())
                .description(knowledge.getDescription())
                .embeddingId(knowledge.getEmbeddingId())
                .build();
        return takaiKnowledgeMapper.updateKnowledge(params);
    }

    @Override
    public TakaiKnowledge detailKnowledge(String knowledgeId) {
        TakaiKnowledge vo = TakaiKnowledge.builder().knowledgeId(knowledgeId).build();
        return takaiKnowledgeMapper.selectTargetKnowledge(vo);
    }

    @Override
    public int delKnowledge(String knowledgeId) {
        String url = deepseekConfig.getBaseurl() + deepseekConfig.getDeleteKnowledge() + "/" + knowledgeId;
        Request request = buildDeleteRequest(url);
        OkHttpClient client = buildOkHttpClient();
        Response response = null;
        try {
            response = client.newCall(request).execute();
            if (response.isSuccessful()) {
                String body = response.body().string();
                JSONObject obj = JSON.parseObject(body);
                Integer code = obj.getInteger("code");
                if (code == 200) {
//                    TakaiKnowledge info = takaiKnowledgeMapper.selectTargetKnowledge(TakaiKnowledge.builder().knowledgeId(knowledgeId).build());
                    List<TakaiMediaReplacement>  list = takaiMediaReplacementMapper.selectMediaList(TakaiMediaReplacement.builder().knowledgeId(knowledgeId).build());
                    List<TakaiDocument> documentList = takaiDocumentMapper.selectDocumentList(TakaiDocument.builder().knowledgeId(knowledgeId).build());
                    int knowledgeInt = takaiKnowledgeMapper.delKnowledge(knowledgeId);
                    if (knowledgeInt > 0) {
                        takaiDocumentMapper.delDocumentByKnowledgeId(knowledgeId);
                        takaiDocumentSettingsMapper.deleteDocumentSettingsByKnowledgeId(knowledgeId);

                        if(list != null && list.size() > 0){

                            try {
                                for(TakaiDocument document: documentList){
                                    logger.info("删除知识库->删除minio文件");
                                    minioUtil.remove("deepseek-doc", "/"+document.getName());
                                }

                                for (int k = 0; k < list.size(); k++ ) {
                                    logger.info("删除知识库->删除minio图片{}", k);
                                    String key = "/pdf/"+knowledgeId+"/"+list.get(k).getDocumentId()+"/【示意图序号_"+list.get(k).getDocumentId()+"_"+k+1+"】.jpg";
                                    logger.info("删除知识库->删除minio图片key{}", key);
                                    minioUtil.remove("deepseek-doc" , key);
                                }
                            } catch (Exception e) {
                                logger.error("删除知识库->删除minion文件失败", e.getMessage());
                                throw new RuntimeException(e);
                            }

                        }
                    }
                    return knowledgeInt;
                }
            }
        } catch (IOException e) {
            logger.error("删除知识库调用python接口失败", e.getMessage());
        }
        return 0;
    }

    @Override
    public int uploadDocument(MultipartFile[] files, String knowledgeId) {
        List<TakaiSysOss> result = null;
        try {
            result = minioUtil.uploadMultiple(files);
        } catch (Exception e) {
            logger.error("上传文件失败", e.getMessage());
        }
        if (result != null && result.size() > 0) {
            List<UploadDocumentParams> params = new ArrayList<>();
            for (int i = 0; i<result.size(); i++) {
                SnowflakeDigitGenerator documentIdGenerator = new SnowflakeDigitGenerator(i, i);
                long documentId = documentIdGenerator.nextId();
                UploadDocumentParams param = new UploadDocumentParams();
                param.setDocument_id("a" + documentId);
                param.setName(result.get(i).getOriginalName());
                param.setUrl(result.get(i).getUrl());
                params.add(param);
            }

            TakaiDocumentSettings settings = new TakaiDocumentSettings();
            settings.setKnowledgeId(knowledgeId);
            JSONObject jsonObject = analysisFile(params, settings, "upload");

            if (jsonObject != null && jsonObject.containsKey("code") && jsonObject.getInteger("code") == 200) {
                for (UploadDocumentParams vo : params) {
                    TakaiKnowledge info  = takaiKnowledgeMapper.selectTargetKnowledge(TakaiKnowledge.builder().knowledgeId(knowledgeId).build());
                    if(info != null){
                        // 更新知识库文件大小，总字符数， 文件总数
                        JSONObject docInfo = jsonObject.getJSONObject("doc_info");
                        if(docInfo != null){
                            List<TakaiDocument> documentList = takaiDocumentMapper.selectDocumentList(TakaiDocument.builder().knowledgeId(knowledgeId).build());
                            Integer fileLen = docInfo.getInteger("file_size");
                            Integer wordNum = docInfo.getInteger("total_char_len");
                            Integer sliceTotal = docInfo.getInteger("slice_num");
                            TakaiKnowledge paramInfo = TakaiKnowledge.builder().knowledgeId(knowledgeId)
                                    .length(info.getLength() == null ? fileLen : info.getLength() + fileLen )       // 文件大小
                                    .wordNum(info.getWordNum() == null ? wordNum : info.getWordNum() + wordNum)      // 总字符数
                                    .documentSize(documentList == null || documentList.size() == 0 ? 1 : documentList.size() + 1) // 文件总数
                                    .build();
                            takaiKnowledgeMapper.updateKnowledge(paramInfo);

                            for (TakaiSysOss oss : result) {
                                // oss保存到数据库
                                takaiSysOssMapper.insertSysOss(oss);
                            }

                            // 保存知识信息
                            TakaiDocument document = TakaiDocument.builder()
                                    .documentId(vo.getDocument_id())
                                    .knowledgeId(knowledgeId)
                                    .customSeparator(String.format("[\"%s\"", "\\n") + "]")
                                    .sentenceSize("300")
                                    .name(vo.getName())
                                    .url(vo.getUrl())
                                    .sliceTotal(sliceTotal)
                                    .length(fileLen)
                                    .wordNum(wordNum)
                                    .build();
                            int documentIdInsert = takaiDocumentMapper.insertDocument(document);

                            if (documentIdInsert > 0) {
                                // 保存知识设置信息
                                SnowflakeDigitGenerator snowflakeDigitGenerator = new SnowflakeDigitGenerator(1, 1);
                                long id = snowflakeDigitGenerator.nextId();
                                TakaiDocumentSettings dSettings = new TakaiDocumentSettings();
                                dSettings.setId(String.valueOf(id));
                                dSettings.setKnowledgeId(knowledgeId);
                                dSettings.setDocumentId(vo.getDocument_id());
                                dSettings.setSetSlice("0");   // 默认 按标题段落切片
                                dSettings.setSetAnalyze("1"); // 默认 图片转换成标识符
                                dSettings.setSetTable("0");   // 默认 ttable转图片
                                takaiDocumentSettingsMapper.insertDocumentSettings(dSettings);
                            }
                        }
                    }
                }
                setRedisCache(knowledgeId);
                return 1;
            }
        }
        return 0;
    }


    @Override
    public int updateDocument(TakaiDocumentParams documentParams, String documentId) {
        int i = takaiDocumentMapper.updateDocument(TakaiDocument.builder()
                .documentId(documentId)
                .name(documentParams.getName())
                .build());
        return i;
    }

    @Override
    public List<TakaiDocument> documentList(TakaiDocumentParams documentParams) {
        return takaiDocumentMapper.selectDocumentList(TakaiDocument.builder().knowledgeId(documentParams.getKnowledge_id()).build());
    }

    @Override
    public TakaiDocument documentDetail(String documentId) {
        return takaiDocumentMapper.selectTargetDocument(TakaiDocument.builder().documentId(documentId).build());
    }

    @Override
    public int delDocument(String documentId) {
        TakaiDocument vo = takaiDocumentMapper.selectTargetDocument(TakaiDocument.builder().documentId(documentId).build());
        if(vo != null){
            String url = deepseekConfig.getBaseurl() + deepseekConfig.getDeleteDoc() + "/" + documentId + "/" + vo.getKnowledgeId();
            Request request = buildDeleteRequest(url);
            OkHttpClient client = buildOkHttpClient();
            try {
                Response response = client.newCall(request).execute();
                if (response.isSuccessful()) {
                    String body = response.body().string();
                    logger.info("删除知识文件调用python接口返回结果：{}", body);
                    JSONObject obj = JSON.parseObject(body);
                    Integer code = obj.getInteger("code");
                    if (code == 200) {
                        List<TakaiMediaReplacement> list = takaiMediaReplacementMapper.selectMediaList(TakaiMediaReplacement.builder().documentId(documentId).build());

                        // 删除图片
                        takaiMediaReplacementMapper.deleteMedia(documentId);

                        // 删除document文件
                        int i = takaiDocumentMapper.delDocument(documentId);

                        if(i > 0){
                            TakaiKnowledge info  = takaiKnowledgeMapper.selectTargetKnowledge(TakaiKnowledge.builder().knowledgeId(vo.getKnowledgeId()).build());
                            if(info != null){
                                // 更新知识库文件大小，总字符数， 文件总数
                                TakaiKnowledge paramInfo = TakaiKnowledge.builder().knowledgeId(vo.getKnowledgeId())
                                        .length(vo.getLength() == null ? info.getLength() == null ? 0 : info.getLength() : info.getLength() - vo.getLength())       // 文件大小
                                        .wordNum(vo.getWordNum() == null ? info.getWordNum() == null ? 0 : info.getWordNum() : info.getWordNum() - vo.getWordNum())      // 总字符数
                                        .documentSize(info.getDocumentSize() == null ? 0 : info.getDocumentSize() - 1) // 文件总数
                                        .build();
                                takaiKnowledgeMapper.updateKnowledge(paramInfo);
                            }

                            // 删除minio文件
                            try {
                                logger.info("删除minio文件");
                                minioUtil.remove("deepseek-doc", "/"+vo.getName());
                                if(list != null && list.size() > 0){
                                    for (int k=1; k<=list.size(); k++ ) {
                                        logger.info("删除minio图片{}", k);
                                        minioUtil.remove("deepseek-doc" , "/pdf/"+vo.getKnowledgeId()+"/"+documentId+"/【示意图序号_"+documentId+"_"+k+"】.jpg");
                                    }
                                }
                            } catch (Exception e) {
                                logger.error("删除minion文件失败", e.getMessage());
                                throw new RuntimeException(e);
                            }
                            return i;
                        }
                    }
                }
            } catch (IOException e) {
                logger.error("删除知识文件调用python接口失败", e.getMessage());
            }
        }
        return 0;
    }

    @Override
    public void uploadUrl(TakaiDocumentObject object) {

    }

    @Override
    public int createApplication(TakaiApplicationParams params) {
        SnowflakeDigitGenerator snowflakeDigitGenerator = new SnowflakeDigitGenerator(1, 1);
        long appId = snowflakeDigitGenerator.nextId();

        TakaiApplication info = TakaiApplication.builder().appId(String.valueOf(appId))
                .name(params.getName())
                .desc(params.getDesc())
                .model(params.getModel())
                .knowledgeIds(params.getKnowledge_ids().toString())
                .topP(params.getTop_p())
                .temperature(params.getTemperature())
                .maxToken(params.getMax_token())
                .prompt(params.getPrompt())
                .knowledgeInfo(params.getKnowledge_info())
                .sliceCount(params.getSlice_count())
                .build();
        int i = takaiApplicationMapper.insertApplication(info);
        if (i > 0) {
            logger.info("create application success, id:{}, name:{}", appId, params.getName());
            TakaiAppInfo appInfo = new TakaiAppInfo();
            appInfo.setAppId(String.valueOf(appId));
            appInfo.setAppInfo(String.valueOf(JSONObject.from(info).toJSONString()));
            takaiAppInfoMapper.insertAppInfo(appInfo);

            List<String> list = params.getQuestionList();
            if (!list.isEmpty() && list.size() > 0) {
                for (String str : list) {
                    if (org.apache.commons.lang3.StringUtils.isNotBlank(str)) {
                        String uuid = IdUtils.simpleUUID();
                        TakaiQuestion question = TakaiQuestion.builder().id(uuid).question(str).appId(String.valueOf(appId)).build();
                        takaiQuestionMapper.insertQuestion(question);
                    }
                }
            }
        }
        return i;
    }

    @Override
    public int updateApplication(TakaiApplicationParams params, String appId) {
        TakaiApplication info = TakaiApplication.builder().appId(appId)
                .name(params.getName())
                .desc(params.getDesc())
                .model(params.getModel())
                .knowledgeIds(params.getKnowledge_ids().toString())
                .topP(params.getTop_p())
                .temperature(params.getTemperature())
                .maxToken(params.getMax_token())
                .prompt(params.getPrompt())
                .knowledgeInfo(params.getKnowledge_info())
                .sliceCount(params.getSlice_count())
                .build();
        int i = takaiApplicationMapper.updateApplication(info);
        if (1 > 0) {
            TakaiAppInfo appInfo = new TakaiAppInfo();
            appInfo.setAppId(appId);
            appInfo.setAppInfo(String.valueOf(JSONObject.from(info).toJSONString()));
            takaiAppInfoMapper.updateAppInfoByAppId(appInfo);
            logger.info("update application success, id:{}, name:{}", appId, params.getName());
            //预设问题写入数据库
            takaiQuestionMapper.delQuestionByAppId(appId);
            List<String> list = params.getQuestionList();
            if (!list.isEmpty() && list.size() > 0) {
                for (String str : list) {
                    if (org.apache.commons.lang3.StringUtils.isNotBlank(str)) {
                        String uuid = IdUtils.simpleUUID();
                        TakaiQuestion question = TakaiQuestion.builder().id(uuid).question(str).appId(String.valueOf(appId)).build();
                        takaiQuestionMapper.insertQuestion(question);
                    }
                }
            }
        }
        return i;
    }

    @Override
    public List<TakaiApplication> getApplicationList() {
        return takaiApplicationMapper.selectApplicationList(null);
    }

    @Override
    public JSONObject selectApplication(String appId) {
        JSONObject object = new JSONObject();
        TakaiApplication application = TakaiApplication.builder().appId(appId).build();
        TakaiApplication takaiApplication = takaiApplicationMapper.selectTargetApplication(application);
        List<TakaiQuestionDTO> list = takaiQuestionMapper.getQuestionList(appId);
        object.put("detail", takaiApplication);
        object.put("questionlist", list);
        return object;
    }

    @Override
    public int delApplication(String appId) {
        int i = takaiApplicationMapper.delApplication(appId);
        if (i > 0) {
            takaiAppInfoMapper.delAppInfoByAppId(appId);
            takaiQuestionMapper.delQuestionByAppId(appId);
        }
        return i;
    }

    @Override
    public List<TakaiQuestionDTO> selectQuestionByAppId(String appId) {
        List<TakaiQuestionDTO> List = takaiQuestionMapper.getQuestionList(appId);
        return List;
    }

    @Override
    public List<TakaiKnowledge> queryKnowledgeList() {
        return takaiKnowledgeMapper.selectKnowledgeList(null);
    }

    @Override
    public List<Object> selectDialogListByAppId(String appId, String userId) {
        List<TakaiDialogRespDTO> list = takaiDialogMapper.selectDialog(appId, userId);
        List<Object> result = setDialogList(list);
        return result;
    }

    @Override
    public TakaiDocumentSettings documentSetting(String documentId) {
        return takaiDocumentSettingsMapper.selectById(documentId);
    }

    @Override
    public int updateDocumentSetting(TakaiDocumentSettings documentSettings, String documentId) {
        TakaiDocumentSettings settings = new TakaiDocumentSettings();
        TakaiDocumentSettings settingsVo = takaiDocumentSettingsMapper.selectById(documentId);
        settings.setKnowledgeId(settingsVo.getKnowledgeId());
        settings.setSetSlice(documentSettings.getSetSlice());
        settings.setSliceValue(documentSettings.getSliceValue());
        settings.setSetAnalyze(documentSettings.getSetAnalyze());
        settings.setSetTable(documentSettings.getSetTable());
        TakaiDocument document = takaiDocumentMapper.selectTargetDocument(TakaiDocument.builder().documentId(documentId).build());
        List<UploadDocumentParams> listParams = new ArrayList<>();
        if (document != null) {
            UploadDocumentParams params = new UploadDocumentParams();
            params.setDocument_id(documentId);
            params.setName(document.getName());
            params.setUrl(document.getUrl());
            listParams.add(params);
        }

        JSONObject jsonObject = analysisFile(listParams, settings, "update");
        if (jsonObject != null && jsonObject.containsKey("code") && jsonObject.getInteger("code") == 200) {
            logger.info("update document setting success, id:{}", documentId);
            documentSettings.setDocumentId(documentId);
            return takaiDocumentSettingsMapper.updateDocumentSettings(documentSettings);
        }
        return 0;
    }

    @Override
    public JSONObject getSliceList(TakaiSliceParams params) {
        String url = deepseekConfig.getBaseurl() + deepseekConfig.getSlicePage();
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("document_id", params.getDocument_id());
        jsonObject.put("knowledge_id", params.getKnowledge_id());
        jsonObject.put("text", params.getText());
        jsonObject.put("pageNum", params.getPageNum());
        jsonObject.put("pageSize", params.getPageSize());

        RequestBody requestBody = FormBody.create(MediaType.parse("application/json; charset=utf-8"), jsonObject.toJSONString());
        Request request = buildPostRequest(url, requestBody);

        OkHttpClient client = buildOkHttpClient();
        Response response = null;
        try {
            response = client.newCall(request).execute();
            if (response.isSuccessful()) {
                String body = response.body().string();
                JSONObject obj = JSON.parseObject(body);
                Integer code = obj.getInteger("code");
                if (code == 200) {
                    return obj;
                }
            } else {
                logger.info("获取切片列表调用python接口失败,返回状态码：{}", response.code());
            }
        } catch (IOException e) {
            logger.error("获取切片列表调用python接口失败", e.getMessage());
        }
        return null;
    }

    @Override
    public int deleteSlice(String sliceId, String knowledgeId, String documentId) {
        String url = deepseekConfig.getBaseurl() + deepseekConfig.getDeleteSlice() + "/" + sliceId + "/" + knowledgeId +  "/" + documentId;
        Request request = buildDeleteRequest(url);
        OkHttpClient client = buildOkHttpClient();
        Response response = null;
        try {
            response = client.newCall(request).execute();
            if (response.isSuccessful()) {
                String body = response.body().string();
                JSONObject obj = JSON.parseObject(body);
                Integer code = obj.getInteger("code");
                if (code == 200) {
                    return 1;
                }
            }
        } catch (IOException e) {
            logger.error("删除切片调用python接口失败", e.getMessage());
        }
        return 0;
    }

    @Override
    public JSONObject getSliceDetail(String sliceId, String knowledgeId) {
        String url = deepseekConfig.getBaseurl() + deepseekConfig.getSliceDetail() + "/" + knowledgeId + "/" + sliceId;
        Request request = buildGetRequest(url);

        OkHttpClient client = buildOkHttpClient();
        try {
            Response response = client.newCall(request).execute();
            if (response.isSuccessful()) {
                String body = response.body().string();
                log.info("查询切片详情返回：" + body);
                return JSON.parseObject(body);
            } else {
                logger.info("获取切片详情调用python接口失败,返回状态码：{}", response.code());
            }
        } catch (IOException e) {
            log.error("查询切片详情调用python接口失败", e.getMessage());
        }
        return null;
    }

    @Override
    public int updateSliceInfo(TakaiSliceUpdateParams params) {
        String url = deepseekConfig.getBaseurl() + deepseekConfig.getUpdateSlice();
        JSONObject object = new JSONObject();
        object.put("knowledge_id", params.getKnowledgeId());
        object.put("slice_id", params.getSliceId());
        object.put("slice_text", params.getSliceText());
        object.put("document_id", params.getDocumentId());
        RequestBody requestBody = FormBody.create(MediaType.parse("application/json; charset=utf-8"), object.toJSONString());

        Request request = buildPutRequest(url, requestBody);
        OkHttpClient client = buildOkHttpClient();
        try {
            Response response = client.newCall(request).execute();
            if (response.isSuccessful()) {
                String body = response.body().string();
                JSONObject obj = JSON.parseObject(body);
                Integer code = obj.getInteger("code");
                if (code == 200) {
                    return 1;
                }
            }
        } catch (Exception e) {
            logger.error("更新切片信息调用python接口失败", e.getMessage());
        }
        return 0;
    }

    @Override
    public TakaiMediaReplacement getTakaiMediaReplacement() {
        TakaiMediaReplacement mrParams = TakaiMediaReplacement.builder()
                .documentId("a2912832435041734656")
                .originText("【示意图序号_a2912832435041734656_1】")
                .mediaType("image").build();
        TakaiMediaReplacement mrVo = takaiMediaReplacementMapper.selectTargetMedia(mrParams);
        return mrVo;
    }

    private JSONObject analysisFile(List<UploadDocumentParams> result, TakaiDocumentSettings settings, String flag) {
        String url = deepseekConfig.getBaseurl() + deepseekConfig.getUploadKnowledge();
        JSONObject json = new JSONObject();
        json.put("knowledge_id", settings.getKnowledgeId());
        json.put("docs", result);
        if ("upload".equals(flag)) {
            json.put("set_slice", "0");
            json.put("slice_value", null);
            json.put("set_analyze", "1");
            json.put("set_table", "0");
            json.put("flag", "upload");
        } else {
            json.put("set_slice", settings.getSetSlice());
            json.put("slice_value", settings.getSliceValue());
            json.put("set_analyze", settings.getSetAnalyze());
            json.put("set_table", settings.getSetTable());
            json.put("flag", "update");
        }

        RequestBody requestBody = RequestBody.create(MediaType.parse("application/json"), json.toJSONString());
        Request request = buildPostRequest(url, requestBody);
        OkHttpClient client = buildOkHttpClient();
        Response response = null;
        try {
            response = client.newCall(request).execute();
            if (response.isSuccessful()) {
                String body = response.body().string();
                JSONObject obj = JSON.parseObject(body);
                Integer code = obj.getInteger("code");
                if (code == 200) {
                    logger.info("上传文档调用python接口成功,返回内容：{}", body);
                    return obj;
                }
                return obj;
            } else {
                logger.error("上传文档调用python接口失败返回code：{}", response.code());
                return null;
            }
        } catch (IOException e) {
            logger.error("上传文档调用python接口失败", e.getMessage());
            return null;
        }
    }

    private List<Object> setDialogList(List<TakaiDialogRespDTO> list) {
        //根据时间分组降序排序
        NavigableMap<LocalDateTime, List<TakaiDialogRespDTO>> groupList = list.stream().collect(Collectors.groupingBy(TakaiDialogRespDTO::getCreate_time, TreeMap::new, Collectors.toList())).descendingMap();
        List<Object> obj = new ArrayList();
        if (!groupList.isEmpty()) {
            for (Map.Entry<LocalDateTime, List<TakaiDialogRespDTO>> entry : groupList.entrySet()) {
                List<TakaiDialogRespDTO> aList = entry.getValue();
                List<TakaiDialogRespDTO> detailList = takaiDialogMapper.selectDialogExport(aList.get(0).getId());
                Map<String, Object> map = new HashMap();
                map.put("dialog_name", aList.get(0).getDialog_name());
                map.put("length", detailList.size());
                map.put("create_time", aList.get(0).getCreate_time());
                map.put("did", aList.get(0).getDid());
                map.put("id", aList.get(0).getId());
                obj.add(map);
            }
        }
        return obj;
    }

    private List<Map<String, Object>> setValue(List<TakaiDialogRespDTO> list) {
        List<Map<String, Object>> l = new ArrayList();
        for (TakaiDialogRespDTO vo : list) {
            Map<String, Object> map = new HashMap();
            map.put("key", vo.getId());
            map.put("label", vo.getDialog_name());
            l.add(map);
        }
        return l;
    }

    private OkHttpClient buildOkHttpClient() {
        return new OkHttpClient.Builder()
                .connectTimeout(10, TimeUnit.SECONDS)
                .writeTimeout(50, TimeUnit.SECONDS)
                .readTimeout(10, TimeUnit.MINUTES)
                .build();
    }

    private Request buildGetRequest(String url) {
        return new Request.Builder()
                .addHeader("User-Agent", "insomnia/10.3.1")
                .url(url).get().build();
    }

    private Request buildPostRequest(String url, RequestBody requestBody) {
        return new Request.Builder()
                .addHeader("User-Agent", "insomnia/10.3.1")
                .addHeader("Content-Type", "application/json")
                .url(url).post(requestBody).build();
    }

    private Request buildPutRequest(String url, RequestBody requestBody) {
        return new Request.Builder()
                .addHeader("User-Agent", "insomnia/10.3.1")
                .url(url).put(requestBody).build();
    }

    private Request buildDeleteRequest(String url) {
        return new Request.Builder()
                .addHeader("Content-Type", "multipart/form-data")
                .addHeader("User-Agent", "insomnia/10.3.1")
                .url(url).delete().build();
    }

    private Request buildUploadPostRequest(String url, RequestBody requestBody) {
        return new Request.Builder()
                .addHeader("User-Agent", "insomnia/10.3.1")
                .addHeader("Content-Type", "application/json")
                .url(url).post(requestBody).build();
    }

    private boolean isJsonObject(String data) {
        try {
            JSON.parseObject(data);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

}