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.*;
import com.takai.ai.domain.entity.*;
import com.takai.ai.mapper.*;
import com.takai.ai.service.ITakaiAiService;
import com.takai.ai.utils.ApprovalFlowManager;
import com.takai.ai.utils.ApprovalNode;
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.domain.entity.SysDictData;
import com.takai.common.core.redis.RedisCache;
import com.takai.common.enums.DataSourceType;
import com.takai.common.utils.StringUtils;
import com.takai.common.utils.uuid.IdUtils;
import com.takai.framework.web.service.SysPermissionService;
import com.takai.system.domain.DocumentAuditConfig;
import com.takai.system.domain.DocumentAuditInfo;
import com.takai.system.domain.TypeApp;
import com.takai.system.mapper.SysDictDataMapper;
import com.takai.system.mapper.TypeAppMapper;
import com.takai.system.mapper.DocumentAuditConfigMapper;
import com.takai.system.mapper.DocumentAuditInfoMapper;
import lombok.extern.slf4j.Slf4j;
import okhttp3.*;
import okhttp3.sse.EventSource;
import okhttp3.sse.EventSourceListener;
import okhttp3.sse.EventSources;
import org.apache.commons.collections4.MapUtils;
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.function.Function;
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;

    @Autowired
    private TakaiSliceInfoMapper takaiSliceInfoMapper;

    @Autowired
    private DocumentAuditConfigMapper documentAuditConfigMapper;

    @Autowired
    private DocumentAuditInfoMapper documentAuditInfoMapper;

    @Autowired
    private SysPermissionService permissionService;

    @Autowired
    private TypeAppMapper appTypeMapper;

    @Autowired
    private TakaiAppCollectMapper appCollectMapper;

    @Autowired
    private SysDictDataMapper sysDictDataMapper;

    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());
                            logger.info("deepseek聊天返回消息：" + data);
                            preData = data;
                            if (newData.indexOf(START_SIGN) > -1 || symbolData.length() > 0) {
                                symbolData = symbolData + newData;
                                //接收到了完整的图片标识
                                int endSignPos = symbolData.indexOf(END_SIGN);
                                if (endSignPos > -1) {
                                    JSONObject json = new JSONObject();
                                    json.put("id", id);
                                    json.put("event", "add");
                                    //是图片
                                    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 + ")");
                                        } else {
                                            logger.error("图片标识符"+key+"没有获取到对应的URL{}: " + symbolData);
                                        }
                                        //检查是否当前token包含其他图片的开始符号”【“
                                        int lastPos = symbolData.lastIndexOf(START_SIGN);
                                        if(lastPos > endSignPos){
                                            // 从'【' 开始截取
                                            newData = symbolData.substring(0, lastPos);
                                            symbolData = symbolData.substring(lastPos);
                                            logger.info("截取结果{}: " + symbolData);
                                        } else {
                                            newData = symbolData;
                                            symbolData = "";
                                        }
                                        newData = newData.replace(key, " ![](" + url + ")");
                                    } else {
                                        newData = symbolData;
                                        symbolData = "";
                                    }
                                    json.put("data", newData);

                                    log.info("获取到图片替换结束符号，返回前端信息：" + json);
                                    send(sseEmitter, json);
                                    //如果超过长度200还没收到】符号，直接返回。
                                } else if (symbolData.length() > 200) {
                                    JSONObject json = new JSONObject();
                                    json.put("id", id);
                                    json.put("event", "add");
                                    json.put("data", symbolData);
                                }
                            } else {
                                JSONObject json = new JSONObject();
                                json.put("id", id);
                                json.put("event", type);
                                json.put("data", newData);
                                log.info("deepseek返回信息：" + json);
                                send(sseEmitter, json);
                            }
                        }
                        if (com.takai.common.utils.StringUtils.isNotEmpty(type) && "finish".equals(type)) {
                            log.info("deepseek聊天结束");
                            JSONObject json = new JSONObject();
                            json.put("id", id);
                            json.put("event", type);
                            json.put("data", data);
                            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.put("chat_id", params.getChat_id());
            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);
        if(detail != null && detail.size() != 0){
            for(TakaiDialogRespDTO dto : detail){
                if(StringUtils.isNotEmpty(dto.getSliceJson())){
                    dto.setSliceInfo(JSON.parseObject(dto.getSliceJson(), TakaiSliceInfoDTO.class));
                }
            }
        }
        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) {
                if (dto.getSliceInfo() != null) dto.setSliceJson(JSON.toJSONString(dto.getSliceInfo()));
                takaiDialogMapper.insertDialogDetail(dto);
            }
        }
    }

    @Override
    public List<Object> getDialogList(String appId, String userId) {
        List<TakaiDialogRespDTO> dialogRespDTOS = takaiDialogMapper.selectDialogList(appId, userId);
        //当前日期
        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(), appId));
                    obj.add(m);
                } else {
                    m.put("label", -daysBetween + BEFOR);
                    m.put("children", setValue(entry.getValue(), appId));
                    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, boolean isAdmin) {
        ApprovalNode vo = getFirstApproverNode(); // 获取第一个审批对象
        if(vo != null){
            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())
                    .typeId(params.getTypeId())
                    .build();
            if(isAdmin){
                info.setStatus("3"); // 有直接创建权限无需审核
            }else{
                info.setStatus("5"); // 未开始审核状态
                info.setApprover(String.valueOf(vo.getApprover()));
                info.setNodeOrder(String.valueOf(vo.getNodeOrder()));
            }
            info.setCreateBy(params.getUserId());
            int i = takaiApplicationMapper.insertApplication(info);
            if (i > 0) {
                TypeApp appType = new TypeApp();
                appType.setTypeId(params.getTypeId() == null ? null : params.getTypeId());
                appType.setAppId(String.valueOf(appId));
                appTypeMapper.insertAppType(appType);

                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;
            }
        }else{
            // 没有审批人
            return 9;
        }
        return 0;
    }

    @Override
    public int updateApplication(TakaiApplicationParams params, String appId, boolean isAdmin) {
        ApprovalNode vo = getFirstApproverNode(); // 获取第一个审批对象
        if(vo != null){
            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())
                    .typeId(params.getTypeId())
                    .build();
            if(isAdmin){
                info.setStatus("3"); // 有直接修改权限无需审核
                info.setApprover(null);
                info.setNodeOrder(null);
            }else{
                info.setStatus("5"); // 未开始审核状态
                info.setApprover(String.valueOf(vo.getApprover()));
                info.setNodeOrder(String.valueOf(vo.getNodeOrder()));
            }
            info.setUpdateBy(params.getUserId());
            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;
        } else {
            return 9;
        }
    }

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

    @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");
                logger.info("删除切片调用python接口成功,返回结果：{}", body);
                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;
    }

    @Override
    public int addSlice(TakaiSliceUpdateParams params) {
        String url = deepseekConfig.getBaseurl() + deepseekConfig.getAddSlice();
        TakaiDocument info = takaiDocumentMapper.selectTargetDocument(TakaiDocument.builder().documentId(params.getDocumentId()).build());
        if(info != null){
            JSONObject json = new JSONObject();
            json.put("knowledge_id", params.getKnowledgeId());
            json.put("document_id", params.getDocumentId());
            json.put("slice_text", params.getSliceText());
            json.put("doc_name", info.getName());

            RequestBody requestBody = FormBody.create(MediaType.parse("application/json; charset=utf-8"), json.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) {
                        return 1;
                    }
                }
            }catch (Exception e) {
                logger.error("新增切片调用python接口失败", e.getMessage());
            }
        }
        return 0;
    }

    @Override
    public List<TakaiSliceInfo> selectByDocumentId(String documentId) {
        return takaiSliceInfoMapper.selectByDocumentId(documentId);
    }

    @Override
    public TakaiSliceInfo selectBySliceId(String sliceId) {
        return takaiSliceInfoMapper.selectBySliceId(sliceId);
    }

    @Override
    public List<SliceInfo> slicePageInfoList(List<String> list) {
        return takaiSliceInfoMapper.slicePageInfoList(list);
    }

    @Override
    public JSONObject searchSlice(String id) {
        String url = deepseekConfig.getBaseurl() + deepseekConfig.getSearchSlice() + "/" + id;
        Request request = buildGetRequest(url);
        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 obj;
                }
            }
        }catch (Exception e) {
            logger.error("切片得分调用python接口失败", e.getMessage());
        }
        return null;
    }

    @Override
    public List<Object> searchAppTypeGroupList(List<SysDictData> dictDataList, String userId) {
        List<Object> result =  new ArrayList();
        if (dictDataList!= null && dictDataList.size() > 0) {
            for (SysDictData dictData : dictDataList){
                Map<String, Object> map = new HashMap();
                TakaiApplication paramsVo = TakaiApplication.builder().approver(userId).flag("0").build();
                if(dictData.getDictCode() == 41){
                    Map<String, Object> l = searchAppTypeGroupList(paramsVo, dictData);
                    if(!MapUtils.isEmpty(l)){
                        result.add(l);
                    }
                }else{
                    paramsVo.setTypeId(Long.valueOf(dictData.getDictCode()));
                    List<TakaiApplicationResult> list = takaiApplicationMapper.selectApplicationList(paramsVo);
                    if(list != null && list.size() > 0){
                        List<Object> appInfoList = new ArrayList();
                        map.put("title", dictData.getDictLabel());
                        for (TakaiApplicationResult application : list){
                            Map<String, Object> infoMap = new HashMap();
                            infoMap.put("title", application.getName());
                            infoMap.put("appId", application.getAppId());
                            infoMap.put("showMenu", "false");
                            infoMap.put("chatMode", "LOCAL");
                            appInfoList.add(infoMap);
                        }
                        map.put("children", appInfoList);
                        result.add(map);
                    }
                }
            }
        }
        return result;
    }

    private Map<String, Object> searchAppTypeGroupList(TakaiApplication paramsVo, SysDictData dictData) {
        paramsVo.setTypeId(Long.valueOf(42));
        List<TakaiApplicationResult> list1 = takaiApplicationMapper.selectApplicationList(paramsVo);
        paramsVo.setTypeId(Long.valueOf(43));
        List<TakaiApplicationResult> list2 = takaiApplicationMapper.selectApplicationList(paramsVo);
        List<TakaiApplicationResult> list3 = new ArrayList();
        list3.addAll(list1);
        list3.addAll(list2);
        Map<String, Object> map = new HashMap();
        if (list3!= null && list3.size() > 0) {
            List<Object> l = new ArrayList<>();
            map.put("title", dictData.getDictLabel());
            // 分组
            Map<String, List<TakaiApplicationResult>> map1 = list3.stream().collect(Collectors.groupingBy(TakaiApplicationResult::getTypeId));
            for (Map.Entry<String, List<TakaiApplicationResult>> entry : map1.entrySet()) {
                List<TakaiApplicationResult> mp = entry.getValue();
                Map<String, Object> infoProjectMap = new HashMap();
                List<Object> projectInfoList = new ArrayList();
                for (TakaiApplicationResult application : mp){
                    SysDictData vo = sysDictDataMapper.selectDictDataById(Long.valueOf(application.getTypeId()));
                    infoProjectMap.put("title", vo.getDictLabel());
                    Map<String, Object> projectMap = new HashMap();
                    projectMap.put("appId", application.getAppId());
                    projectMap.put("showMenu", "false");
                    projectMap.put("chatMode", "LOCAL");
                    projectMap.put("title", application.getName());
                    projectInfoList.add(projectMap);
                }
                infoProjectMap.put("children", projectInfoList);
                l.add(infoProjectMap);
            }
            map.put("children", l);
        }
        return map;
    }

    @Override
    public List<TakaiApplication> applicationListByApprover(TakaiApplicationParams takaiApplicationParams) {
        TakaiApplication vo = TakaiApplication.builder().approver(takaiApplicationParams.getApprover())
                .build();
        return takaiApplicationMapper.selectAppListByApprover(vo);
    }

    @Override
    public int startAudit(String appId, String userId) {
        List<DocumentAuditConfig> list = documentAuditConfigMapper.selectDocumentAuditConfigListByBo(null);
        if(list != null && list.size() > 0) {
            ApprovalFlowManager flowManager = new ApprovalFlowManager();
            logger.info("开启审核");
            for (DocumentAuditConfig config : list) {
                // 添加审核节点
                flowManager.addNode(new ApprovalNode(config.getId(), config.getNodeOrder(), Long.valueOf(config.getApprover()), config.getChain()));
            }

            ApprovalNode vo = flowManager.getFirstApprover();
            int i = takaiApplicationMapper.updateApplication(TakaiApplication.builder()
                    .appId(appId)
                    .approver(String.valueOf(vo.getApprover()))
                    .nodeOrder(String.valueOf(vo.getNodeOrder()))
                    .status("1") // 待审核
                    .build());
            if(i > 0){
                DocumentAuditInfo info = new DocumentAuditInfo();
                info.setAppId(appId);
                info.setApprover(userId);
                info.setStatus("5");
                info.setNodeOrder(Integer.valueOf("0"));
                info.setCreateBy(userId);
                info.setCreateTime(new Date());
                documentAuditInfoMapper.insertDocumentAuditInfo(info); // 审核记录
            }
            return i;
        }else{
            return 9;
        }
    }

    @Override
    public int updateAuditApplication(TakaiApplicationParams appParams, String appId) {
//          获取审核配置信息 （人员，节点）
        List<DocumentAuditConfig> list = documentAuditConfigMapper.selectDocumentAuditConfigListByBo(null);
        if(list != null && list.size() > 0){
            if(("Y").equals(appParams.getStatus())){
                ApprovalFlowManager flowManager = new ApprovalFlowManager();
                logger.info("审核通过，开始审批流程");
                for (DocumentAuditConfig config: list){
                    // 添加审核节点
                    flowManager.addNode(new ApprovalNode(config.getId(), config.getNodeOrder(), Long.valueOf(config.getApprover()), config.getChain()));
                }
                // 根据审核节点获取下一个审核节点
                ApprovalNode nextNode = flowManager.getNextApproverByOrder(Integer.valueOf(appParams.getNodeOrder()));
                if (nextNode == null) {
                    //  审核通过，更新文档状态
                    logger.info("审核通过，到最后节点");
                    return saveAuditInfo(appParams, "3", appId);
                }else{
                    // 审核通过，下一个节点
                    int successI = takaiApplicationMapper.updateApplication(TakaiApplication.builder()
                            .appId(appId)
                            .status("2")
                            .approver(String.valueOf(nextNode.getApprover()))
                            .nodeOrder(String.valueOf(nextNode.getNodeOrder()))
                            .comment(appParams.getComment())
                            .build());
                    if(successI > 0){
                        DocumentAuditInfo info = new DocumentAuditInfo();
                        info.setAppId(appId);
                        info.setApprover(appParams.getApprover());
                        info.setComment(appParams.getComment());
                        info.setStatus("2");
                        info.setNodeOrder(Integer.valueOf(appParams.getNodeOrder()));
                        info.setCreateBy(appParams.getApprover());
                        info.setCreateTime(new Date());
                        documentAuditInfoMapper.insertDocumentAuditInfo(info); // 审核记录
                    }
                    return successI;
                }
            }else{
                //  审核拒绝，更新文档状态
                logger.info("审核拒绝，更新状态");
                return saveAuditInfo(appParams, "5", appId);
            }
        }
        return 0;
    }

    private int saveAuditInfo(TakaiApplicationParams appParams, String status, String appId){
        int successI = takaiApplicationMapper.updateApplication(TakaiApplication.builder()
                .appId(appId)
                .status(status)
                .approver(appParams.getApprover())
                .nodeOrder(appParams.getNodeOrder())
                .comment(appParams.getComment())
                .build());
        if(successI > 0){
            DocumentAuditInfo info = new DocumentAuditInfo();
            info.setAppId(appId);
            info.setApprover(appParams.getApprover());
            info.setComment(appParams.getComment());
            if("5".equals(status)){
                info.setStatus("4");
            }else{
                info.setStatus(status);
            }
            info.setNodeOrder(Integer.valueOf(appParams.getNodeOrder()));
            info.setCreateBy(appParams.getApprover());
            info.setCreateTime(new Date());
            documentAuditInfoMapper.insertDocumentAuditInfo(info); // 审核记录
        }
        return successI;
    }

    @Override
    public List<TakaiApplicationResult> selectAppByUserId(String userId) {
        return takaiApplicationMapper.selectAppByUserId(userId);
    }

    @Override
    public List<String> selectAppCollectList(String userId) {
        return appCollectMapper.selectAppCollectList(userId);
    }

    @Override
    public int insertAppCollect(AppCollect appCollect) {
        AppCollect collect = appCollectMapper.selectAppCollectDetail(appCollect.getAppId(), appCollect.getUserId());
        if (collect == null) {
            return appCollectMapper.insertAppCollect(appCollect);
        }
        return 0;
    }

    @Override
    public int deleteAppCollect(String userId, String appId) {
        return appCollectMapper.delAppCollect(userId, appId);
    }

    @Override
    public List<TakaiApplicationResult> selectRoleApp() {
        return takaiApplicationMapper.selectRoleApp();
    }

    @Override
    public List<TakaiApplicationResult> getChatAppList(List<TakaiApplicationResult> params, String userId) {
        List<TakaiApplicationResult> list = new ArrayList();
        for (TakaiApplicationResult app : params) {
            AppCollect appCollect = appCollectMapper.selectAppCollectDetail(app.getAppId(), userId);
            SysDictData dictData = null;
            if(app.getTypeId() != null && !"".equals(app.getTypeId())){
                dictData = sysDictDataMapper.selectDictDataById(Long.valueOf(app.getTypeId()));
            }

            TakaiApplicationResult appResult = new TakaiApplicationResult();
            appResult.setAppId(app.getAppId());
            appResult.setName(app.getName());
            appResult.setDesc(app.getDesc());
            appResult.setTypeId(app.getTypeId());
            appResult.setCreateTime(app.getCreateTime());
            appResult.setChatMode("LOCAL");
            appResult.setIsCollect(appCollect != null ? true : false);
            appResult.setTypeName(dictData != null ? dictData.getDictLabel() : "");
            list.add(appResult);
        }
        return list;
    }

    private ApprovalNode getFirstApproverNode() {
        List<DocumentAuditConfig> list = documentAuditConfigMapper.selectDocumentAuditConfigListByBo(null);
        if(list != null && list.size() > 0) {
            ApprovalFlowManager flowManager = new ApprovalFlowManager();
            logger.info("开启审核");
            for (DocumentAuditConfig config : list) {
                // 添加审核节点
                flowManager.addNode(new ApprovalNode(config.getId(), config.getNodeOrder(), Long.valueOf(config.getApprover()), config.getChain()));
            }

            return flowManager.getFirstApprover();
        }
        return null;
    }

    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, String appId) {
        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());
            map.put("appId", appId);
            map.put("showMenu", "false");
            map.put("chatMode", "LOCAL");
            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;
        }
    }

}