Merge remote-tracking branch 'origin/master' into prod_test

src/main/java/cn/cslg/pas/common/model/dify/FluxMessageVO.java

@@ -8,4 +8,5 @@ public class FluxMessageVO {
     private String field;
     private String content;
     private Integer id;
+    private Integer status;
 }

src/main/java/cn/cslg/pas/common/model/dify/confessionSession/ConfessionSessionDetailVO.java

@@ -24,4 +24,9 @@ public class ConfessionSessionDetailVO {
     private String discoveryResult;
     private String dialogueConversationId;
     private String aiUpdateConversationId;
+    /**
+     * 生成文档生成内容
+     */
+    private String patentResult;
+    private Integer status;
 }

src/main/java/cn/cslg/pas/common/model/dify/confessionSession/UpdateResultDTO.java

@@ -0,0 +1,10 @@
+package cn.cslg.pas.common.model.dify.confessionSession;
+
+import lombok.Data;
+
+@Data
+public class UpdateResultDTO {
+   private Integer confessionSessionId;
+   private String result;
+
+}

src/main/java/cn/cslg/pas/common/model/dify/generatePatentResult/ExportPatentDTO.java

@@ -0,0 +1,8 @@
+package cn.cslg.pas.common.model.dify.generatePatentResult;
+
+import lombok.Data;
+
+@Data
+public class ExportPatentDTO {
+    private Integer confessionSessionId;
+}

src/main/java/cn/cslg/pas/common/model/dify/generatePatentResult/GeneratePatentResultDTO.java

@@ -0,0 +1,20 @@
+package cn.cslg.pas.common.model.dify.generatePatentResult;
+
+import lombok.Data;
+
+@Data
+public class GeneratePatentResultDTO {
+    /**
+     * 会话id*
+     */
+   private int confessionSessionId;
+    /**
+     * 生成类型 0全部生成  1生成权要2生成摘要3生成标题4生成技术领域5生成背景技术6生成发明内容7生成具体实施方式"
+     */
+   private int type;
+    /**
+     * 0进行下一步生成 1从当前步骤全部生成 2从选定步骤全部重新生成
+     */
+   private  int operateType;
+
+}

src/main/java/cn/cslg/pas/common/model/dify/generatePatentResult/PatentFileVO.java

@@ -0,0 +1,14 @@
+package cn.cslg.pas.common.model.dify.generatePatentResult;
+
+import lombok.Data;
+
+@Data
+public class PatentFileVO {
+    private String claim;
+    private String title;
+    private String technicalField;
+    private String background;
+    private String inventionContent;
+    private String implementationMethod;
+    private String abstractContent;
+}

src/main/java/cn/cslg/pas/common/model/dify/generatePatentResult/PatentResultFactoryDTO.java

@@ -0,0 +1,18 @@
+package cn.cslg.pas.common.model.dify.generatePatentResult;
+
+import lombok.Data;
+import reactor.core.publisher.FluxSink;
+
+import java.util.List;
+
+@Data
+public class PatentResultFactoryDTO {
+    private Integer confessionSessionId;
+    private String conversationId;
+    private String apiKey;
+    private String userId;
+    private List<Integer> types;
+    private FluxSink fluxSink;
+    private Integer type;
+    private String targetMessageSplit;
+}

src/main/java/cn/cslg/pas/common/model/dify/generatePatentResult/UpdatePatentResultDTO.java

@@ -0,0 +1,15 @@
+package cn.cslg.pas.common.model.dify.generatePatentResult;
+
+import lombok.Data;
+
+@Data
+public class UpdatePatentResultDTO {
+    /**
+     * 会话id
+     */
+    private Integer confessionSessionId;
+    /**
+     * 申请文档结果json*
+     */
+    private String patentResult;
+}

src/main/java/cn/cslg/pas/common/model/enumVos/FluxMessageEventEnum.java

@@ -0,0 +1,5 @@
+package cn.cslg.pas.common.model.enumVos;
+
+public enum FluxMessageEventEnum {
+    all_start,all_end,start,end,message,error
+}

src/main/java/cn/cslg/pas/common/model/enumVos/PatentResultEnum.java

@@ -0,0 +1,11 @@
+package cn.cslg.pas.common.model.enumVos;
+
+public enum PatentResultEnum {
+    claim,
+    title,
+    technicalField,
+    background,
+    inventionContent,
+    implementationMethod,
+    abstractContent
+}

src/main/java/cn/cslg/pas/common/utils/DataUtils.java

@@ -33,7 +33,6 @@ public class DataUtils {
     public static final String PASSWORD_KEY = "835a9bdc-4f9f-4614-a0cc-493a12454156";
 
 
-
     /**
      * 对称加密
      */
@@ -179,12 +178,12 @@ public class DataUtils {
     }
 
 
-    public static String[] chars = new String[] { "a", "b", "c", "d", "e", "f",
+    public static String[] chars = new String[]{"a", "b", "c", "d", "e", "f",
             "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s",
             "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5",
             "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I",
             "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V",
-            "W", "X", "Y", "Z" };
+            "W", "X", "Y", "Z"};
 
     public static String generateShortUuid() {
         StringBuffer shortBuffer = new StringBuffer();
@@ -197,7 +196,7 @@ public class DataUtils {
         return shortBuffer.toString();
     }
 
-    public static <T> List<T> objToList(Object obj, Class<T> cla){
+    public static <T> List<T> objToList(Object obj, Class<T> cla) {
         List<T> list = new ArrayList<T>();
         if (obj instanceof ArrayList<?>) {
             for (Object o : (List<?>) obj) {
@@ -218,7 +217,7 @@ public class DataUtils {
             mdTemp = MessageDigest.getInstance("MD5");
             mdTemp.update(utfBytes);
             byte[] md5Bytes = mdTemp.digest();
-            byte[] by =  Base64.getEncoder().encode(md5Bytes);
+            byte[] by = Base64.getEncoder().encode(md5Bytes);
 
             encodeStr = Base64Utils.encodeToString(by);
         } catch (Exception e) {
@@ -226,6 +225,7 @@ public class DataUtils {
         }
         return encodeStr;
     }
+
     /*
      * 计算 HMAC-SHA1
      */
@@ -236,7 +236,7 @@ public class DataUtils {
             Mac mac = Mac.getInstance("HmacSHA1");
             mac.init(signingKey);
             byte[] rawHmac = mac.doFinal(data.getBytes());
-            byte[] by =Base64.getEncoder().encode(rawHmac);
+            byte[] by = Base64.getEncoder().encode(rawHmac);
             result = Base64Utils.encodeToString(by);
         } catch (Exception e) {
             throw new Error("Failed to generate HMAC : " + e.getMessage());
@@ -256,7 +256,7 @@ public class DataUtils {
         return string;
     }
 
-    public static String getMarkDownText(String markdownText){
+    public static String getMarkDownText(String markdownText) {
 
 
         // 配置解析器（支持表格等扩展）
@@ -276,10 +276,10 @@ public class DataUtils {
 //                .replaceAll("\\s+", " ")   // 合并多余空格
 //                .trim();
         // 输出普通文本
-      return  html;
+        return html;
     }
 
-    public static String getTextBeforeLastSignal(String input,String signal) {
+    public static String getTextBeforeLastSignal(String input, String signal) {
         if (input == null || input.isEmpty()) {
             return input; // 处理空字符串或null值
         }
@@ -295,6 +295,7 @@ public class DataUtils {
 
     private static final String[] units = {"", "十", "百", "千", "万", "十", "百", "千", "亿"};
     private static final String[] digits = {"零", "一", "二", "三", "四", "五", "六", "七", "八", "九"};
+
     public static String numberToChinese(int num) {
         if (num == 0) {
             return "零";
@@ -326,4 +327,17 @@ public class DataUtils {
         }
         return result;
     }
+
+    public static String aiAnswerThinkRemove(String content) {
+        String regex = "<think>[\\s\\S]*?</think>";
+        content = content.replaceAll(regex, "");
+        content = content.replaceAll("\n{2,}", "\n");
+        content = content.trim();
+        return content;
+    }
+    public static boolean isValidFormat(String regex,String input) {
+        // 定义正则表达式：4位数字-2位数字-2位数字-"会话"
+        // 编译正则模式并匹配整个输入字符串
+        return Pattern.matches(regex, input);
+    }
 }

src/main/java/cn/cslg/pas/controller/common/ConfessionSessionController.java

@@ -1,16 +1,20 @@
 package cn.cslg.pas.controller.common;
 
 import cn.cslg.pas.common.core.base.Constants;
+import cn.cslg.pas.common.model.cronModel.SystemFile;
 import cn.cslg.pas.common.model.dify.ChatMessageDTO;
 import cn.cslg.pas.common.model.dify.DifyHistoryMessageDTO;
 import cn.cslg.pas.common.model.dify.confessionSession.*;
 import cn.cslg.pas.common.model.dify.generateDiscoveryResult.UpdateDiscoveryResultDTO;
+import cn.cslg.pas.common.model.dify.generatePatentResult.ExportPatentDTO;
+import cn.cslg.pas.common.model.dify.generatePatentResult.UpdatePatentResultDTO;
 import cn.cslg.pas.common.utils.CacheUtils;
 import cn.cslg.pas.common.utils.LoginUtils;
 import cn.cslg.pas.common.utils.Response;
 import cn.cslg.pas.service.common.DifyService;
 import cn.cslg.pas.service.dify.ConfessionSessionService;
 import cn.cslg.pas.service.dify.DifySessionService;
+import cn.cslg.pas.service.dify.DifyTempleExportService;
 import com.alibaba.fastjson2.JSONObject;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -41,7 +45,7 @@ public class ConfessionSessionController {
     private CacheUtils cacheUtils;
     @Autowired
     private LoginUtils loginUtils;
-
+    private final DifyTempleExportService difyTempleExportService;
     //
     @RequestMapping(value = "/addConfessionSession", method = RequestMethod.POST)
     @Operation(summary = "生成交底书会话记录")
@@ -88,14 +92,29 @@ public class ConfessionSessionController {
     @RequestMapping(value = "/updateDiscoveryResult", method = RequestMethod.POST)
     @Operation(summary = "更新技术交底书理解结果")
     public Response updateDiscoryResult(@RequestBody UpdateDiscoveryResultDTO updateDiscoveryResultDTO) throws IOException {
-        Integer id = confessionSessionService.updateDiscoveryResult(updateDiscoveryResultDTO);
+       UpdateResultDTO updateResultDTO =new UpdateResultDTO();
+       updateResultDTO.setResult(updateDiscoveryResultDTO.getDiscoveryResult());
+       updateResultDTO.setConfessionSessionId(updateDiscoveryResultDTO.getConfessionSessionId());
+        Integer id = confessionSessionService.updateResult(updateResultDTO);
+        return Response.success(id);
+    }
+
+    @RequestMapping(value = "/updatePatentResult", method = RequestMethod.POST)
+    @Operation(summary = "更新专利申请文档结果")
+    public Response updatePatentResult(@RequestBody UpdatePatentResultDTO updatePatentResultDTO) throws IOException {
+        UpdateResultDTO updateResultDTO =new UpdateResultDTO();
+        updateResultDTO.setResult(updatePatentResultDTO.getPatentResult());
+        updateResultDTO.setConfessionSessionId(updatePatentResultDTO.getConfessionSessionId());
+        Integer id = confessionSessionService.updateResult(updateResultDTO);
         return Response.success(id);
     }
 
-    @RequestMapping(value = "/detail", method = RequestMethod.POST)
-    @Operation(summary = "查询会话记录详情")
-    public Response detail(@RequestBody ConfessionSessionDetailDTO confessionSessionDetailDTO) throws IOException {
-        ConfessionSessionDetailVO  confessionSessionDetailVO = confessionSessionService.getConfessionSessionDetail(confessionSessionDetailDTO);
-        return Response.success(confessionSessionDetailVO);
+    @RequestMapping(value = "/exportPatentResult", method = RequestMethod.POST)
+    @Operation(summary = "导出专利申请文档")
+    public Response exportPatentResult(@RequestBody ExportPatentDTO exportPatentDTO) throws Exception {
+       SystemFile systemFile= difyTempleExportService.exportPatentFile(exportPatentDTO);
+        return Response.success(systemFile);
     }
+
+
 }

src/main/java/cn/cslg/pas/controller/outApi/DifyController.java

@@ -4,14 +4,13 @@ import cn.cslg.pas.common.core.base.Constants;
 import cn.cslg.pas.common.model.dify.*;
 import cn.cslg.pas.common.model.dify.confessionSession.ConfessionSessionDetailDTO;
 import cn.cslg.pas.common.model.dify.confessionSession.ConfessionSessionDetailVO;
+import cn.cslg.pas.common.model.dify.generatePatentResult.GeneratePatentResultDTO;
 import cn.cslg.pas.common.utils.CacheUtils;
 import cn.cslg.pas.common.utils.LoginUtils;
 import cn.cslg.pas.common.utils.Response;
+import cn.cslg.pas.factorys.difyFactory.GeneratePatentResultService;
 import cn.cslg.pas.service.common.DifyService;
-import cn.cslg.pas.service.dify.ConfessionSessionService;
-import cn.cslg.pas.service.dify.DifySessionService;
-import cn.cslg.pas.service.dify.GenerateDiscoveryResultService;
-import cn.cslg.pas.service.dify.GenerateInstructionService;
+import cn.cslg.pas.service.dify.*;
 import com.alibaba.fastjson2.JSONObject;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -44,7 +43,7 @@ public class DifyController {
     private CacheUtils cacheUtils;
     @Autowired
     private LoginUtils loginUtils;
-
+    private final PatentResultService patentResultService;
     @RequestMapping(value = "/chatMessage", method = RequestMethod.POST, produces = MediaType.TEXT_EVENT_STREAM_VALUE)
     @Operation(summary = "发送对话")
     public Flux<String> chatMessage(@RequestBody ChatMessageDTO chatMessageDTO) throws IOException {
@@ -114,4 +113,10 @@ public class DifyController {
     public Flux<String> discoveryResultDialogue(@RequestBody ChatMessageDTO chatMessageDTO) throws Exception {
         return difyService.discoveryResultDialogue(chatMessageDTO);
     }
+
+    @RequestMapping(value = "/generatePatentResult", method = RequestMethod.POST, produces = MediaType.TEXT_EVENT_STREAM_VALUE)
+    @Operation(summary = "生成专利申请文档结果")
+    public Flux<String> generatePatentResult(@RequestBody GeneratePatentResultDTO generatePatentResultDTO) throws Exception {
+        return patentResultService.aiGeneratePatentResult(generatePatentResultDTO);
+    }
 }

src/main/java/cn/cslg/pas/domain/dify/ConfessionSession.java

@@ -33,5 +33,6 @@ public class ConfessionSession extends BaseEntity<ConfessionSession> {
     private Integer type;
     private String content;
     private String resultContent;
+    private Integer status;
 
 }

src/main/java/cn/cslg/pas/factorys/difyFactory/GenerateAbstructPatentResultImp.java

@@ -0,0 +1,159 @@
+package cn.cslg.pas.factorys.difyFactory;
+
+import cn.cslg.pas.common.model.dify.DifyChatMessageDTO;
+import cn.cslg.pas.common.model.dify.generatePatentResult.PatentFileVO;
+import cn.cslg.pas.common.model.dify.generatePatentResult.PatentResultFactoryDTO;
+import cn.cslg.pas.common.model.enumVos.FluxMessageEventEnum;
+import cn.cslg.pas.common.model.enumVos.PatentResultEnum;
+import cn.cslg.pas.common.utils.DataUtils;
+import cn.cslg.pas.common.utils.DateUtils;
+import cn.cslg.pas.domain.dify.ConfessionSession;
+import cn.cslg.pas.service.common.DifyService;
+import cn.cslg.pas.service.dify.AssoConfessionConversationService;
+import cn.cslg.pas.service.dify.ConfessionSessionService;
+import cn.cslg.pas.service.dify.FluxMessageService;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import okhttp3.*;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import reactor.core.publisher.FluxSink;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.Reader;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+@Component
+public class GenerateAbstructPatentResultImp implements GeneratePatentResultService {
+    @Autowired
+    private DifyService difyService;
+    @Autowired
+    private ConfessionSessionService confessionSessionService;
+    @Autowired
+    private PatentResultFactory patentResultFactory;
+    @Autowired
+    private AssoConfessionConversationService assoConfessionConversationService;
+    @Autowired
+    private FluxMessageService fluxMessageService;
+
+    @Override
+    public void generatePatentResult(PatentResultFactoryDTO patentResultFactoryDTO) {
+        OkHttpClient client = new OkHttpClient.Builder()
+                .connectTimeout(600, TimeUnit.SECONDS)
+                .writeTimeout(600, TimeUnit.SECONDS)
+                .readTimeout(600, TimeUnit.SECONDS)
+                .build();
+        String conversationId = patentResultFactoryDTO.getConversationId();
+        String userId = patentResultFactoryDTO.getUserId();
+        String apiKey = patentResultFactoryDTO.getApiKey();
+        String targetMessageSplit = patentResultFactoryDTO.getTargetMessageSplit();
+        Integer confessionSessionId = patentResultFactoryDTO.getConfessionSessionId();
+        FluxSink emitter = patentResultFactoryDTO.getFluxSink();
+        Integer type = patentResultFactoryDTO.getType();
+
+        ConfessionSession confessionSession = confessionSessionService.getById(confessionSessionId);
+        String discoveryResult = confessionSession.getContent();
+        String result = confessionSession.getResultContent();
+        List<Integer> types = patentResultFactoryDTO.getTypes();
+        DifyChatMessageDTO difyChatMessageDTO = new DifyChatMessageDTO();
+        difyChatMessageDTO.setConversationId(conversationId);
+        Map<String, Object> map = new HashMap<>();
+        map.put("discovery_result", discoveryResult);
+        map.put("patent_field", "abstractContent");
+        if (result != null) {
+            PatentFileVO patentFileVO = JSONObject.parseObject(result, PatentFileVO.class);
+            String claims = patentFileVO.getClaim();
+            map.put("claims", claims);
+        }
+        difyChatMessageDTO.setInputs(map);
+        difyChatMessageDTO.setConversationId(conversationId);
+        difyChatMessageDTO.setResponseMode("streaming");
+        difyChatMessageDTO.setUser(userId);
+        difyChatMessageDTO.setQuery("生成摘要");
+        difyChatMessageDTO.setFiles(new ArrayList<>());
+        Request request = difyService.getGeneratePatentResultResultRequest(confessionSessionId, difyChatMessageDTO, apiKey);
+
+        StringBuilder aiContentBuilder = new StringBuilder();
+        client.newCall(request).enqueue(new Callback() {
+            @Override
+            public void onFailure(Call call, IOException e) {
+                emitter.error(e);
+            }
+
+            @Override
+            public void onResponse(Call call, Response response) throws IOException {
+                if (!response.isSuccessful()) {
+                    emitter.error(new IOException("Unexpected code: " + response));
+                    return;
+                }
+                String filed=PatentResultEnum.abstractContent.toString();
+                Boolean ifSendMessage = false;
+                String localConversationId = conversationId;
+                String startMessage = fluxMessageService.getFluxMessage(filed, FluxMessageEventEnum.start.toString(), "", confessionSessionId, type - 1);
+                emitter.next(startMessage);
+                try (Reader reader = response.body().charStream()) {
+                    BufferedReader bufferedReader = new BufferedReader(reader);
+                    String line;
+                    String prefixToRemove = "data: ";
+                    while ((line = bufferedReader.readLine()) != null) {
+                        if (line.isEmpty()) {
+                            continue;
+                        }
+                        if (line.startsWith(prefixToRemove)) {
+                            line = line.substring(prefixToRemove.length());
+                            JSONObject jsonObject = JSON.parseObject(line);
+                            if (localConversationId == null) {
+                                localConversationId = jsonObject.get("conversation_id").toString();
+                                assoConfessionConversationService.addConversationId(confessionSessionId, localConversationId, 50);
+                                difyChatMessageDTO.setConversationId(localConversationId);
+                            }
+                            String event = jsonObject.get("event").toString();
+
+                            if (event.equals("message")) {
+                                String answer = jsonObject.get("answer").toString();
+                                aiContentBuilder.append(answer);
+                                    String message = fluxMessageService.getFluxMessage(filed, FluxMessageEventEnum.message.toString(), answer, confessionSessionId, type - 1);
+                                    emitter.next(message);
+                            }
+                        }
+                    }
+
+                } catch (IOException e) {
+                    emitter.error(e);
+                    emitter.complete();
+                } finally {
+                }
+                //保存结果
+                PatentFileVO patentFileVO = new PatentFileVO();
+                if (result != null) {
+                    patentFileVO = JSONObject.parseObject(result, PatentFileVO.class);
+                }
+                String content =aiContentBuilder.toString();
+                content= DataUtils.aiAnswerThinkRemove(content);
+                patentFileVO.setAbstractContent(content);
+                confessionSessionService.updatePatentResult(confessionSession, type, patentFileVO);
+                String message = fluxMessageService.getFluxMessage(filed, FluxMessageEventEnum.end.toString(), "", confessionSessionId, type);
+                emitter.next(message);
+                //继续往下进行任务
+                if (types != null && types.size() > 0) {
+                    Integer temType = types.remove(0);
+                    patentResultFactoryDTO.setTypes(types);
+                    patentResultFactoryDTO.setType(temType);
+                    GeneratePatentResultService generatePatentResultService = patentResultFactory.getClass(temType);
+                    generatePatentResultService.generatePatentResult(patentResultFactoryDTO);
+                } else {
+                    String allEndMessage = fluxMessageService.getFluxMessage("", FluxMessageEventEnum.all_end.toString(), "", confessionSessionId, type);
+
+                    emitter.next(allEndMessage);
+                    emitter.complete();
+                }
+            }
+        });
+
+    }
+}

src/main/java/cn/cslg/pas/factorys/difyFactory/GenerateBackgroundPatentResultImp.java

@@ -0,0 +1,159 @@
+package cn.cslg.pas.factorys.difyFactory;
+
+import cn.cslg.pas.common.model.dify.DifyChatMessageDTO;
+import cn.cslg.pas.common.model.dify.generatePatentResult.PatentFileVO;
+import cn.cslg.pas.common.model.dify.generatePatentResult.PatentResultFactoryDTO;
+import cn.cslg.pas.common.model.enumVos.FluxMessageEventEnum;
+import cn.cslg.pas.common.model.enumVos.PatentResultEnum;
+import cn.cslg.pas.common.utils.DataUtils;
+import cn.cslg.pas.domain.dify.ConfessionSession;
+import cn.cslg.pas.service.common.DifyService;
+import cn.cslg.pas.service.dify.AssoConfessionConversationService;
+import cn.cslg.pas.service.dify.ConfessionSessionService;
+import cn.cslg.pas.service.dify.FluxMessageService;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import okhttp3.*;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import reactor.core.publisher.FluxSink;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.Reader;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+@Component
+public class GenerateBackgroundPatentResultImp implements GeneratePatentResultService {
+    @Autowired
+    private DifyService difyService;
+    @Autowired
+    private ConfessionSessionService confessionSessionService;
+    @Autowired
+    private PatentResultFactory patentResultFactory;
+    @Autowired
+    private AssoConfessionConversationService assoConfessionConversationService;
+    @Autowired
+    private FluxMessageService fluxMessageService;
+
+    @Override
+    public void generatePatentResult(PatentResultFactoryDTO patentResultFactoryDTO) {
+        OkHttpClient client = new OkHttpClient.Builder()
+                .connectTimeout(600, TimeUnit.SECONDS)
+                .writeTimeout(600, TimeUnit.SECONDS)
+                .readTimeout(600, TimeUnit.SECONDS)
+                .build();
+        String conversationId = patentResultFactoryDTO.getConversationId();
+        String userId = patentResultFactoryDTO.getUserId();
+        String apiKey = patentResultFactoryDTO.getApiKey();
+        String targetMessageSplit = patentResultFactoryDTO.getTargetMessageSplit();
+        Integer confessionSessionId = patentResultFactoryDTO.getConfessionSessionId();
+        FluxSink emitter = patentResultFactoryDTO.getFluxSink();
+        Integer type = patentResultFactoryDTO.getType();
+
+        ConfessionSession confessionSession = confessionSessionService.getById(confessionSessionId);
+        String discoveryResult = confessionSession.getContent();
+        String result = confessionSession.getResultContent();
+        List<Integer> types = patentResultFactoryDTO.getTypes();
+        DifyChatMessageDTO difyChatMessageDTO = new DifyChatMessageDTO();
+        difyChatMessageDTO.setConversationId(conversationId);
+        Map<String, Object> map = new HashMap<>();
+        map.put("discovery_result", discoveryResult);
+        map.put("patent_field", "background");
+        if (result != null) {
+            PatentFileVO patentFileVO = JSONObject.parseObject(result, PatentFileVO.class);
+            String claims = patentFileVO.getClaim();
+            map.put("claims", claims);
+        }
+        difyChatMessageDTO.setInputs(map);
+        difyChatMessageDTO.setConversationId(conversationId);
+        difyChatMessageDTO.setResponseMode("streaming");
+        difyChatMessageDTO.setUser(userId);
+        difyChatMessageDTO.setQuery("生成背景技术");
+        difyChatMessageDTO.setFiles(new ArrayList<>());
+        Request request = difyService.getGeneratePatentResultResultRequest(confessionSessionId, difyChatMessageDTO, apiKey);
+
+
+        StringBuilder aiContentBuilder = new StringBuilder();
+        client.newCall(request).enqueue(new Callback() {
+            @Override
+            public void onFailure(Call call, IOException e) {
+                emitter.error(e);
+            }
+
+            @Override
+            public void onResponse(Call call, Response response) throws IOException {
+                if (!response.isSuccessful()) {
+                    emitter.error(new IOException("Unexpected code: " + response));
+                    return;
+                }
+                String filed=PatentResultEnum.background.toString();
+                Boolean ifSendMessage = false;
+                String localConversationId = conversationId;
+                String startMessage = fluxMessageService.getFluxMessage(filed, FluxMessageEventEnum.start.toString(), "", confessionSessionId, type - 1);
+                emitter.next(startMessage);
+                try (Reader reader = response.body().charStream()) {
+                    BufferedReader bufferedReader = new BufferedReader(reader);
+                    String line;
+                    String prefixToRemove = "data: ";
+                    while ((line = bufferedReader.readLine()) != null) {
+                        if (line.isEmpty()) {
+                            continue;
+                        }
+                        if (line.startsWith(prefixToRemove)) {
+                            line = line.substring(prefixToRemove.length());
+                            JSONObject jsonObject = JSON.parseObject(line);
+                            if (localConversationId == null) {
+                                localConversationId = jsonObject.get("conversation_id").toString();
+                                assoConfessionConversationService.addConversationId(confessionSessionId, localConversationId, 50);
+                                difyChatMessageDTO.setConversationId(localConversationId);
+                            }
+                            String event = jsonObject.get("event").toString();
+
+                            if (event.equals("message")) {
+                                String answer = jsonObject.get("answer").toString();
+                                aiContentBuilder.append(answer);
+                                    String message = fluxMessageService.getFluxMessage(filed, FluxMessageEventEnum.message.toString(), answer, confessionSessionId, type - 1);
+                                    emitter.next(message);
+                            }
+                        }
+                    }
+
+                } catch (IOException e) {
+                    emitter.error(e);
+                    emitter.complete();
+                } finally {
+                }
+                //保存结果
+                PatentFileVO patentFileVO = new PatentFileVO();
+                if (result != null) {
+                    patentFileVO = JSONObject.parseObject(result, PatentFileVO.class);
+                }
+                String content =aiContentBuilder.toString();
+                content= DataUtils.aiAnswerThinkRemove(content);
+                patentFileVO.setBackground(content);
+                confessionSessionService.updatePatentResult(confessionSession, type, patentFileVO);
+                String message = fluxMessageService.getFluxMessage(filed, FluxMessageEventEnum.end.toString(), "", confessionSessionId, type);
+                emitter.next(message);
+                //继续往下进行任务
+                if (types != null && types.size() > 0) {
+                    Integer temType = types.remove(0);
+                    patentResultFactoryDTO.setTypes(types);
+                    patentResultFactoryDTO.setType(temType);
+                    GeneratePatentResultService generatePatentResultService = patentResultFactory.getClass(temType);
+                    generatePatentResultService.generatePatentResult(patentResultFactoryDTO);
+                } else {
+                    String allEndMessage = fluxMessageService.getFluxMessage("", FluxMessageEventEnum.all_end.toString(), "", confessionSessionId, type);
+
+                    emitter.next(allEndMessage);
+                    emitter.complete();
+                }
+            }
+        });
+
+    }
+}

src/main/java/cn/cslg/pas/factorys/difyFactory/GenerateClaimPatentResultImp.java

@@ -0,0 +1,154 @@
+package cn.cslg.pas.factorys.difyFactory;
+
+import cn.cslg.pas.common.model.dify.DifyChatMessageDTO;
+import cn.cslg.pas.common.model.dify.generatePatentResult.PatentFileVO;
+import cn.cslg.pas.common.model.dify.generatePatentResult.PatentResultFactoryDTO;
+
+import cn.cslg.pas.common.model.enumVos.FluxMessageEventEnum;
+import cn.cslg.pas.common.model.enumVos.PatentResultEnum;
+import cn.cslg.pas.common.utils.DataUtils;
+import cn.cslg.pas.domain.dify.AssoConfessionConversation;
+import cn.cslg.pas.domain.dify.ConfessionSession;
+import cn.cslg.pas.service.common.DifyService;
+import cn.cslg.pas.service.dify.AssoConfessionConversationService;
+import cn.cslg.pas.service.dify.ConfessionSessionService;
+
+import cn.cslg.pas.service.dify.FluxMessageService;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import okhttp3.*;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.FluxSink;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.Reader;
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+
+@Component
+public class GenerateClaimPatentResultImp implements GeneratePatentResultService {
+    @Autowired
+    private DifyService difyService;
+    @Autowired
+    private ConfessionSessionService confessionSessionService;
+    @Autowired
+    private PatentResultFactory patentResultFactory;
+    @Autowired
+    private AssoConfessionConversationService assoConfessionConversationService;
+    @Autowired
+    private FluxMessageService fluxMessageService;
+    @Override
+    public void generatePatentResult(PatentResultFactoryDTO patentResultFactoryDTO) {
+        OkHttpClient client = new OkHttpClient.Builder()
+                .connectTimeout(600, TimeUnit.SECONDS)
+                .writeTimeout(600, TimeUnit.SECONDS)
+                .readTimeout(600, TimeUnit.SECONDS)
+                .build();
+        String conversationId = patentResultFactoryDTO.getConversationId();
+        String userId = patentResultFactoryDTO.getUserId();
+        String apiKey = patentResultFactoryDTO.getApiKey();
+        String targetMessageSplit = patentResultFactoryDTO.getTargetMessageSplit();
+        Integer confessionSessionId = patentResultFactoryDTO.getConfessionSessionId();
+        FluxSink emitter = patentResultFactoryDTO.getFluxSink();
+        Integer type = patentResultFactoryDTO.getType();
+
+        ConfessionSession confessionSession = confessionSessionService.getById(confessionSessionId);
+        String discoveryResult = confessionSession.getContent();
+        String result = confessionSession.getResultContent();
+        List<Integer> types = patentResultFactoryDTO.getTypes();
+        DifyChatMessageDTO difyChatMessageDTO = new DifyChatMessageDTO();
+        difyChatMessageDTO.setConversationId(conversationId);
+        Map<String, Object> map = new HashMap<>();
+        map.put("discovery_result", discoveryResult);
+        map.put("patent_field", "claim");
+        difyChatMessageDTO.setInputs(map);
+        difyChatMessageDTO.setConversationId(conversationId);
+        difyChatMessageDTO.setResponseMode("streaming");
+        difyChatMessageDTO.setUser(userId);
+        difyChatMessageDTO.setQuery("生成权要");
+        difyChatMessageDTO.setFiles(new ArrayList<>());
+        Request request = difyService.getGeneratePatentResultResultRequest(confessionSessionId, difyChatMessageDTO, apiKey);
+
+
+        StringBuilder aiContentBuilder = new StringBuilder();
+        client.newCall(request).enqueue(new Callback() {
+            @Override
+            public void onFailure(Call call, IOException e) {
+                emitter.error(e);
+            }
+
+            @Override
+            public void onResponse(Call call, Response response) throws IOException {
+                if (!response.isSuccessful()) {
+                    emitter.error(new IOException("Unexpected code: " + response));
+                    return;
+                }
+                String localConversationId = conversationId;
+                String startMessage= fluxMessageService.getFluxMessage(PatentResultEnum.claim.toString(), FluxMessageEventEnum.start.toString(),"",confessionSessionId,type-1);
+                emitter.next(startMessage);
+                try (Reader reader = response.body().charStream()) {
+                    BufferedReader bufferedReader = new BufferedReader(reader);
+                    String line;
+                    String prefixToRemove = "data: ";
+                    while ((line = bufferedReader.readLine()) != null) {
+                        if (line.isEmpty()) {
+                            continue;
+                        }
+                        if (line.startsWith(prefixToRemove)) {
+                            line = line.substring(prefixToRemove.length());
+                            JSONObject jsonObject = JSON.parseObject(line);
+                            if (localConversationId == null) {
+                                localConversationId = jsonObject.get("conversation_id").toString();
+                                assoConfessionConversationService.addConversationId(confessionSessionId, localConversationId, 50);
+                                difyChatMessageDTO.setConversationId(localConversationId);
+                            }
+                            String event = jsonObject.get("event").toString();
+
+                            if (event.equals("message")) {
+                                String answer = jsonObject.get("answer").toString();
+                                aiContentBuilder.append(answer);
+                                    String message= fluxMessageService.getFluxMessage(PatentResultEnum.claim.toString(), FluxMessageEventEnum.message.toString(),answer,confessionSessionId,type-1);
+                                    emitter.next(message);
+
+                            }
+                        }
+                    }
+
+                } catch (IOException e) {
+                    emitter.error(e);
+                    emitter.complete();
+                } finally {
+                }
+                //保存结果
+                PatentFileVO patentFileVO = new PatentFileVO();
+                if (result != null) {
+                    patentFileVO = JSONObject.parseObject(result, PatentFileVO.class);
+                }
+                String content =aiContentBuilder.toString();
+                content= DataUtils.aiAnswerThinkRemove(content);
+                patentFileVO.setClaim(content);
+                confessionSessionService.updatePatentResult(confessionSession, type, patentFileVO);
+                String message= fluxMessageService.getFluxMessage(PatentResultEnum.claim.toString(), FluxMessageEventEnum.end.toString(),"",confessionSessionId,type);
+                emitter.next(message);
+                //继续往下进行任务
+                if (types!=null&&types.size() > 0) {
+                    Integer temType = types.remove(0);
+                    patentResultFactoryDTO.setTypes(types);
+                    patentResultFactoryDTO.setType(temType);
+                    GeneratePatentResultService generatePatentResultService = patentResultFactory.getClass(temType);
+                    generatePatentResultService.generatePatentResult(patentResultFactoryDTO);
+                }
+                else {
+                    String allEndMessage= fluxMessageService.getFluxMessage("", FluxMessageEventEnum.all_end.toString(),"",confessionSessionId,type);
+
+                    emitter.next(allEndMessage);
+                    emitter.complete();
+                }
+            }
+        });
+
+    }
+}

src/main/java/cn/cslg/pas/factorys/difyFactory/GenerateImplementationMethodImp.java

@@ -0,0 +1,171 @@
+package cn.cslg.pas.factorys.difyFactory;
+
+import cn.cslg.pas.common.model.dify.DifyChatMessageDTO;
+import cn.cslg.pas.common.model.dify.generatePatentResult.PatentFileVO;
+import cn.cslg.pas.common.model.dify.generatePatentResult.PatentResultFactoryDTO;
+import cn.cslg.pas.common.model.enumVos.FluxMessageEventEnum;
+import cn.cslg.pas.common.model.enumVos.PatentResultEnum;
+import cn.cslg.pas.common.utils.ClaimUtils.ClaimSplitUtils;
+import cn.cslg.pas.common.utils.DataUtils;
+import cn.cslg.pas.common.vo.PatentRightParams;
+import cn.cslg.pas.common.vo.RePatentClaim;
+import cn.cslg.pas.domain.dify.ConfessionSession;
+import cn.cslg.pas.factorys.difyFactory.GeneratePatentResultService;
+import cn.cslg.pas.factorys.difyFactory.PatentResultFactory;
+import cn.cslg.pas.service.common.DifyService;
+import cn.cslg.pas.service.dify.AssoConfessionConversationService;
+import cn.cslg.pas.service.dify.ConfessionSessionService;
+import cn.cslg.pas.service.dify.FluxMessageService;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import okhttp3.*;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import reactor.core.publisher.FluxSink;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.Reader;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+@Component
+public class GenerateImplementationMethodImp implements GeneratePatentResultService {
+    @Autowired
+    private DifyService difyService;
+    @Autowired
+    private ConfessionSessionService confessionSessionService;
+    @Autowired
+    private PatentResultFactory patentResultFactory;
+    @Autowired
+    private AssoConfessionConversationService assoConfessionConversationService;
+    @Autowired
+    private FluxMessageService fluxMessageService;
+
+    @Override
+    public void generatePatentResult(PatentResultFactoryDTO patentResultFactoryDTO) {
+        OkHttpClient client = new OkHttpClient.Builder()
+                .connectTimeout(600, TimeUnit.SECONDS)
+                .writeTimeout(600, TimeUnit.SECONDS)
+                .readTimeout(600, TimeUnit.SECONDS)
+                .build();
+        String conversationId = patentResultFactoryDTO.getConversationId();
+        String userId = patentResultFactoryDTO.getUserId();
+        String apiKey = patentResultFactoryDTO.getApiKey();
+        String targetMessageSplit = patentResultFactoryDTO.getTargetMessageSplit();
+        Integer confessionSessionId = patentResultFactoryDTO.getConfessionSessionId();
+        FluxSink emitter = patentResultFactoryDTO.getFluxSink();
+        Integer type = patentResultFactoryDTO.getType();
+
+        ConfessionSession confessionSession = confessionSessionService.getById(confessionSessionId);
+        String discoveryResult = confessionSession.getContent();
+        String result = confessionSession.getResultContent();
+        List<Integer> types = patentResultFactoryDTO.getTypes();
+        DifyChatMessageDTO difyChatMessageDTO = new DifyChatMessageDTO();
+        difyChatMessageDTO.setConversationId(conversationId);
+        Map<String, Object> map = new HashMap<>();
+        map.put("discovery_result", discoveryResult);
+        map.put("patent_field", "implementationMethod");
+        if (result != null) {
+            PatentFileVO patentFileVO = JSONObject.parseObject(result, PatentFileVO.class);
+            String claims = patentFileVO.getClaim();
+            PatentRightParams params = new PatentRightParams();
+            params.setCountry("CN");
+            params.setContent(claims);
+            params.setPatentNo("CN");
+            List<RePatentClaim> rePatentClaims = ClaimSplitUtils.formatPatentRight(params);
+            List<String> claimList = rePatentClaims.stream().map(RePatentClaim::getContent).collect(Collectors.toList());
+            String claimJson = com.alibaba.fastjson2.JSON.toJSONString(claimList);
+            map.put("claims", claimJson);
+        }
+        difyChatMessageDTO.setInputs(map);
+        difyChatMessageDTO.setConversationId(conversationId);
+        difyChatMessageDTO.setResponseMode("streaming");
+        difyChatMessageDTO.setUser(userId);
+        difyChatMessageDTO.setQuery("生成具体实施方式");
+        difyChatMessageDTO.setFiles(new ArrayList<>());
+        Request request = difyService.getGeneratePatentResultResultRequest(confessionSessionId, difyChatMessageDTO, apiKey);
+
+
+        StringBuilder aiContentBuilder = new StringBuilder();
+        client.newCall(request).enqueue(new Callback() {
+            @Override
+            public void onFailure(Call call, IOException e) {
+                emitter.error(e);
+            }
+
+            @Override
+            public void onResponse(Call call, Response response) throws IOException {
+                if (!response.isSuccessful()) {
+                    emitter.error(new IOException("Unexpected code: " + response));
+                    return;
+                }
+                String filed = PatentResultEnum.implementationMethod.toString();
+                Boolean ifSendMessage = false;
+                String localConversationId = conversationId;
+                String startMessage = fluxMessageService.getFluxMessage(filed, FluxMessageEventEnum.start.toString(), "", confessionSessionId, type - 1);
+                emitter.next(startMessage);
+                try (Reader reader = response.body().charStream()) {
+                    BufferedReader bufferedReader = new BufferedReader(reader);
+                    String line;
+                    String prefixToRemove = "data: ";
+                    while ((line = bufferedReader.readLine()) != null) {
+                        if (line.isEmpty()) {
+                            continue;
+                        }
+                        if (line.startsWith(prefixToRemove)) {
+                            line = line.substring(prefixToRemove.length());
+                            JSONObject jsonObject = JSON.parseObject(line);
+                            if (localConversationId == null) {
+                                localConversationId = jsonObject.get("conversation_id").toString();
+                                assoConfessionConversationService.addConversationId(confessionSessionId, localConversationId, 50);
+                                difyChatMessageDTO.setConversationId(localConversationId);
+                            }
+                            String event = jsonObject.get("event").toString();
+
+                            if (event.equals("message")) {
+                                String answer = jsonObject.get("answer").toString();
+                                aiContentBuilder.append(answer);
+                                String message = fluxMessageService.getFluxMessage(filed, FluxMessageEventEnum.message.toString(), answer, confessionSessionId, type - 1);
+                                emitter.next(message);
+                            }
+                        }
+                    }
+                } catch (IOException e) {
+                    emitter.error(e);
+                    emitter.complete();
+                } finally {
+                }
+                //保存结果
+                PatentFileVO patentFileVO = new PatentFileVO();
+                if (result != null) {
+                    patentFileVO = JSONObject.parseObject(result, PatentFileVO.class);
+                }
+                String content = aiContentBuilder.toString();
+                content = DataUtils.aiAnswerThinkRemove(content);
+                patentFileVO.setImplementationMethod(content);
+                confessionSessionService.updatePatentResult(confessionSession, type, patentFileVO);
+                String message = fluxMessageService.getFluxMessage(filed, FluxMessageEventEnum.end.toString(), "", confessionSessionId, type);
+                emitter.next(message);
+                //继续往下进行任务
+                if (types != null && types.size() > 0) {
+                    Integer temType = types.remove(0);
+                    patentResultFactoryDTO.setTypes(types);
+                    patentResultFactoryDTO.setType(temType);
+                    GeneratePatentResultService generatePatentResultService = patentResultFactory.getClass(temType);
+                    generatePatentResultService.generatePatentResult(patentResultFactoryDTO);
+                } else {
+                    String allEndMessage = fluxMessageService.getFluxMessage("", FluxMessageEventEnum.all_end.toString(), "", confessionSessionId, type);
+
+                    emitter.next(allEndMessage);
+                    emitter.complete();
+                }
+            }
+        });
+
+    }
+}

src/main/java/cn/cslg/pas/factorys/difyFactory/GenerateInventionContentPatentResultImp.java

@@ -0,0 +1,158 @@
+package cn.cslg.pas.factorys.difyFactory;
+
+import cn.cslg.pas.common.model.dify.DifyChatMessageDTO;
+import cn.cslg.pas.common.model.dify.generatePatentResult.PatentFileVO;
+import cn.cslg.pas.common.model.dify.generatePatentResult.PatentResultFactoryDTO;
+import cn.cslg.pas.common.model.enumVos.FluxMessageEventEnum;
+import cn.cslg.pas.common.model.enumVos.PatentResultEnum;
+import cn.cslg.pas.common.utils.DataUtils;
+import cn.cslg.pas.domain.dify.ConfessionSession;
+import cn.cslg.pas.service.common.DifyService;
+import cn.cslg.pas.service.dify.AssoConfessionConversationService;
+import cn.cslg.pas.service.dify.ConfessionSessionService;
+import cn.cslg.pas.service.dify.FluxMessageService;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import okhttp3.*;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import reactor.core.publisher.FluxSink;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.Reader;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+@Component
+public class GenerateInventionContentPatentResultImp implements GeneratePatentResultService {
+    @Autowired
+    private DifyService difyService;
+    @Autowired
+    private ConfessionSessionService confessionSessionService;
+    @Autowired
+    private PatentResultFactory patentResultFactory;
+    @Autowired
+    private AssoConfessionConversationService assoConfessionConversationService;
+    @Autowired
+    private FluxMessageService fluxMessageService;
+
+    @Override
+    public void generatePatentResult(PatentResultFactoryDTO patentResultFactoryDTO) {
+        OkHttpClient client = new OkHttpClient.Builder()
+                .connectTimeout(600, TimeUnit.SECONDS)
+                .writeTimeout(600, TimeUnit.SECONDS)
+                .readTimeout(600, TimeUnit.SECONDS)
+                .build();
+        String conversationId = patentResultFactoryDTO.getConversationId();
+        String userId = patentResultFactoryDTO.getUserId();
+        String apiKey = patentResultFactoryDTO.getApiKey();
+        String targetMessageSplit = patentResultFactoryDTO.getTargetMessageSplit();
+        Integer confessionSessionId = patentResultFactoryDTO.getConfessionSessionId();
+        FluxSink emitter = patentResultFactoryDTO.getFluxSink();
+        Integer type = patentResultFactoryDTO.getType();
+
+        ConfessionSession confessionSession = confessionSessionService.getById(confessionSessionId);
+        String discoveryResult = confessionSession.getContent();
+        String result = confessionSession.getResultContent();
+        List<Integer> types = patentResultFactoryDTO.getTypes();
+        DifyChatMessageDTO difyChatMessageDTO = new DifyChatMessageDTO();
+        difyChatMessageDTO.setConversationId(conversationId);
+        Map<String, Object> map = new HashMap<>();
+        map.put("discovery_result", discoveryResult);
+        map.put("patent_field", "inventionContent");
+        if (result != null) {
+            PatentFileVO patentFileVO = JSONObject.parseObject(result, PatentFileVO.class);
+            String claims = patentFileVO.getClaim();
+            map.put("claims", claims);
+        }
+        difyChatMessageDTO.setInputs(map);
+        difyChatMessageDTO.setConversationId(conversationId);
+        difyChatMessageDTO.setResponseMode("streaming");
+        difyChatMessageDTO.setUser(userId);
+        difyChatMessageDTO.setQuery("生成发明内容");
+        difyChatMessageDTO.setFiles(new ArrayList<>());
+        Request request = difyService.getGeneratePatentResultResultRequest(confessionSessionId, difyChatMessageDTO, apiKey);
+
+
+        StringBuilder aiContentBuilder = new StringBuilder();
+        client.newCall(request).enqueue(new Callback() {
+            @Override
+            public void onFailure(Call call, IOException e) {
+                emitter.error(e);
+            }
+
+            @Override
+            public void onResponse(Call call, Response response) throws IOException {
+                if (!response.isSuccessful()) {
+                    emitter.error(new IOException("Unexpected code: " + response));
+                    return;
+                }
+                String filed=PatentResultEnum.inventionContent.toString();
+                String localConversationId = conversationId;
+                String startMessage = fluxMessageService.getFluxMessage(filed, FluxMessageEventEnum.start.toString(), "", confessionSessionId, type - 1);
+                emitter.next(startMessage);
+                try (Reader reader = response.body().charStream()) {
+                    BufferedReader bufferedReader = new BufferedReader(reader);
+                    String line;
+                    String prefixToRemove = "data: ";
+                    while ((line = bufferedReader.readLine()) != null) {
+                        if (line.isEmpty()) {
+                            continue;
+                        }
+                        if (line.startsWith(prefixToRemove)) {
+                            line = line.substring(prefixToRemove.length());
+                            JSONObject jsonObject = JSON.parseObject(line);
+                            if (localConversationId == null) {
+                                localConversationId = jsonObject.get("conversation_id").toString();
+                                assoConfessionConversationService.addConversationId(confessionSessionId, localConversationId, 50);
+                                difyChatMessageDTO.setConversationId(localConversationId);
+                            }
+                            String event = jsonObject.get("event").toString();
+
+                            if (event.equals("message")) {
+                                String answer = jsonObject.get("answer").toString();
+                                aiContentBuilder.append(answer);
+                                    String message = fluxMessageService.getFluxMessage(filed, FluxMessageEventEnum.message.toString(), answer, confessionSessionId, type - 1);
+                                    emitter.next(message);
+                            }
+                        }
+                    }
+
+                } catch (IOException e) {
+                    emitter.error(e);
+                    emitter.complete();
+                } finally {
+                }
+                //保存结果
+                PatentFileVO patentFileVO = new PatentFileVO();
+                if (result != null) {
+                    patentFileVO = JSONObject.parseObject(result, PatentFileVO.class);
+                }
+                String content =aiContentBuilder.toString();
+                content= DataUtils.aiAnswerThinkRemove(content);
+                patentFileVO.setInventionContent(content);
+                confessionSessionService.updatePatentResult(confessionSession, type, patentFileVO);
+                String message = fluxMessageService.getFluxMessage(filed, FluxMessageEventEnum.end.toString(), "", confessionSessionId, type);
+                emitter.next(message);
+                //继续往下进行任务
+                if (types != null && types.size() > 0) {
+                    Integer temType = types.remove(0);
+                    patentResultFactoryDTO.setTypes(types);
+                    patentResultFactoryDTO.setType(temType);
+                    GeneratePatentResultService generatePatentResultService = patentResultFactory.getClass(temType);
+                    generatePatentResultService.generatePatentResult(patentResultFactoryDTO);
+                } else {
+                    String allEndMessage = fluxMessageService.getFluxMessage("", FluxMessageEventEnum.all_end.toString(), "", confessionSessionId, type);
+
+                    emitter.next(allEndMessage);
+                    emitter.complete();
+                }
+            }
+        });
+
+    }
+}

src/main/java/cn/cslg/pas/factorys/difyFactory/GeneratePatentResultService.java

@@ -0,0 +1,10 @@
+package cn.cslg.pas.factorys.difyFactory;
+
+import cn.cslg.pas.common.model.dify.generatePatentResult.PatentResultFactoryDTO;
+import reactor.core.publisher.Flux;
+
+import java.util.List;
+
+public interface GeneratePatentResultService {
+    public void generatePatentResult(PatentResultFactoryDTO patentResultFactoryDTO);
+}

src/main/java/cn/cslg/pas/factorys/difyFactory/GenerateTechnicalFieldPatentResultImp.java

@@ -0,0 +1,92 @@
+package cn.cslg.pas.factorys.difyFactory;
+
+import cn.cslg.pas.common.model.dify.DifyChatMessageDTO;
+import cn.cslg.pas.common.model.dify.generateDiscoveryResult.DiscoryResultVO;
+import cn.cslg.pas.common.model.dify.generatePatentResult.PatentFileVO;
+import cn.cslg.pas.common.model.dify.generatePatentResult.PatentResultFactoryDTO;
+import cn.cslg.pas.common.model.enumVos.FluxMessageEventEnum;
+import cn.cslg.pas.common.model.enumVos.PatentResultEnum;
+import cn.cslg.pas.domain.dify.ConfessionSession;
+import cn.cslg.pas.service.common.DifyService;
+import cn.cslg.pas.service.dify.AssoConfessionConversationService;
+import cn.cslg.pas.service.dify.ConfessionSessionService;
+import cn.cslg.pas.service.dify.FluxMessageService;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import okhttp3.*;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import reactor.core.publisher.FluxSink;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.Reader;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+@Component
+public class GenerateTechnicalFieldPatentResultImp implements GeneratePatentResultService {
+    @Autowired
+    private DifyService difyService;
+    @Autowired
+    private ConfessionSessionService confessionSessionService;
+    @Autowired
+    private PatentResultFactory patentResultFactory;
+    @Autowired
+    private AssoConfessionConversationService assoConfessionConversationService;
+    @Autowired
+    private FluxMessageService fluxMessageService;
+    @Override
+    public void generatePatentResult(PatentResultFactoryDTO patentResultFactoryDTO) {
+        String conversationId = patentResultFactoryDTO.getConversationId();
+        String userId = patentResultFactoryDTO.getUserId();
+        String apiKey = patentResultFactoryDTO.getApiKey();
+        String targetMessageSplit = patentResultFactoryDTO.getTargetMessageSplit();
+        Integer confessionSessionId = patentResultFactoryDTO.getConfessionSessionId();
+        FluxSink emitter = patentResultFactoryDTO.getFluxSink();
+        Integer type = patentResultFactoryDTO.getType();
+        List<Integer> types=patentResultFactoryDTO.getTypes();
+        ConfessionSession confessionSession = confessionSessionService.getById(confessionSessionId);
+        String discoveryResult = confessionSession.getContent();
+        String result = confessionSession.getResultContent();
+
+        String field =PatentResultEnum.technicalField.toString();
+        StringBuilder aiContentBuilder = new StringBuilder();
+        new Thread(()->{
+            String technicalField="";
+            if(discoveryResult!=null){
+               DiscoryResultVO discoryResultVO = JSONObject.parseObject(discoveryResult, DiscoryResultVO.class);
+                technicalField=discoryResultVO.getTechnicalField();
+            }
+            String startMessage= fluxMessageService.getFluxMessage(field, FluxMessageEventEnum.start.toString(),"",confessionSessionId,type-1);
+            emitter.next(startMessage);
+
+            String message = fluxMessageService.getFluxMessage(field, FluxMessageEventEnum.message.toString(), technicalField, confessionSessionId, type - 1);
+            emitter.next(message);
+            //保存结果
+            PatentFileVO patentFileVO = new PatentFileVO();
+            if (result != null) {
+                patentFileVO = JSONObject.parseObject(result, PatentFileVO.class);
+            }
+            patentFileVO.setTechnicalField(technicalField);
+            confessionSessionService.updatePatentResult(confessionSession, type, patentFileVO);
+            String endMessage = fluxMessageService.getFluxMessage(field, FluxMessageEventEnum.end.toString(), "", confessionSessionId, type);
+            emitter.next(endMessage);
+            if (types!=null&&types.size() > 0) {
+                Integer temType = types.remove(0);
+                patentResultFactoryDTO.setTypes(types);
+                patentResultFactoryDTO.setType(temType);
+                GeneratePatentResultService generatePatentResultService = patentResultFactory.getClass(temType);
+                generatePatentResultService.generatePatentResult(patentResultFactoryDTO);
+            }
+            else {
+                String allEndMessage= fluxMessageService.getFluxMessage("", FluxMessageEventEnum.all_end.toString(),"",confessionSessionId,type);
+                emitter.next(allEndMessage);
+                emitter.complete();
+            }
+        }).start();
+    }
+}

src/main/java/cn/cslg/pas/factorys/difyFactory/GenerateTitlePatentResultImp.java

@@ -0,0 +1,164 @@
+package cn.cslg.pas.factorys.difyFactory;
+
+import cn.cslg.pas.common.model.dify.DifyChatMessageDTO;
+import cn.cslg.pas.common.model.dify.generatePatentResult.PatentFileVO;
+import cn.cslg.pas.common.model.dify.generatePatentResult.PatentResultFactoryDTO;
+import cn.cslg.pas.common.model.enumVos.FluxMessageEventEnum;
+import cn.cslg.pas.common.model.enumVos.PatentResultEnum;
+import cn.cslg.pas.common.utils.DataUtils;
+import cn.cslg.pas.domain.dify.ConfessionSession;
+import cn.cslg.pas.service.common.DifyService;
+import cn.cslg.pas.service.dify.AssoConfessionConversationService;
+import cn.cslg.pas.service.dify.ConfessionSessionService;
+import cn.cslg.pas.service.dify.FluxMessageService;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import okhttp3.*;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import reactor.core.publisher.FluxSink;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.Reader;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+@Component
+public class GenerateTitlePatentResultImp implements GeneratePatentResultService {
+    @Autowired
+    private DifyService difyService;
+    @Autowired
+    private ConfessionSessionService confessionSessionService;
+    @Autowired
+    private PatentResultFactory patentResultFactory;
+    @Autowired
+    private AssoConfessionConversationService assoConfessionConversationService;
+    @Autowired
+    private FluxMessageService fluxMessageService;
+
+    @Override
+    public void generatePatentResult(PatentResultFactoryDTO patentResultFactoryDTO) {
+        OkHttpClient client = new OkHttpClient.Builder()
+                .connectTimeout(600, TimeUnit.SECONDS)
+                .writeTimeout(600, TimeUnit.SECONDS)
+                .readTimeout(600, TimeUnit.SECONDS)
+                .build();
+        String conversationId = patentResultFactoryDTO.getConversationId();
+        String userId = patentResultFactoryDTO.getUserId();
+        String apiKey = patentResultFactoryDTO.getApiKey();
+        String targetMessageSplit = patentResultFactoryDTO.getTargetMessageSplit();
+        Integer confessionSessionId = patentResultFactoryDTO.getConfessionSessionId();
+        FluxSink emitter = patentResultFactoryDTO.getFluxSink();
+        Integer type = patentResultFactoryDTO.getType();
+
+        ConfessionSession confessionSession = confessionSessionService.getById(confessionSessionId);
+        String discoveryResult = confessionSession.getContent();
+        String result = confessionSession.getResultContent();
+        List<Integer> types = patentResultFactoryDTO.getTypes();
+        DifyChatMessageDTO difyChatMessageDTO = new DifyChatMessageDTO();
+        difyChatMessageDTO.setConversationId(conversationId);
+        Map<String, Object> map = new HashMap<>();
+        map.put("discovery_result", discoveryResult);
+        map.put("patent_field", "title");
+        if (result != null) {
+            PatentFileVO patentFileVO = JSONObject.parseObject(result, PatentFileVO.class);
+            String claims = patentFileVO.getClaim();
+            map.put("claims", claims);
+        }
+        difyChatMessageDTO.setInputs(map);
+        difyChatMessageDTO.setConversationId(conversationId);
+        difyChatMessageDTO.setResponseMode("streaming");
+        difyChatMessageDTO.setUser(userId);
+        difyChatMessageDTO.setQuery("生成标题");
+        difyChatMessageDTO.setFiles(new ArrayList<>());
+        Request request = difyService.getGeneratePatentResultResultRequest(confessionSessionId, difyChatMessageDTO, apiKey);
+
+
+        StringBuilder aiContentBuilder = new StringBuilder();
+        client.newCall(request).enqueue(new Callback() {
+            @Override
+            public void onFailure(Call call, IOException e) {
+                emitter.error(e);
+            }
+
+            @Override
+            public void onResponse(Call call, Response response) throws IOException {
+                if (!response.isSuccessful()) {
+                    emitter.error(new IOException("Unexpected code: " + response));
+                    return;
+                }
+                String filed = PatentResultEnum.title.toString();
+                String localConversationId = conversationId;
+                String startMessage = fluxMessageService.getFluxMessage(filed, FluxMessageEventEnum.start.toString(), "", confessionSessionId, type - 1);
+                emitter.next(startMessage);
+                try (Reader reader = response.body().charStream()) {
+                    BufferedReader bufferedReader = new BufferedReader(reader);
+                    String line;
+                    String prefixToRemove = "data: ";
+                    while ((line = bufferedReader.readLine()) != null) {
+                        if (line.isEmpty()) {
+                            continue;
+                        }
+                        if (line.startsWith(prefixToRemove)) {
+                            line = line.substring(prefixToRemove.length());
+                            JSONObject jsonObject = JSON.parseObject(line);
+                            if (localConversationId == null) {
+                                localConversationId = jsonObject.get("conversation_id").toString();
+                                assoConfessionConversationService.addConversationId(confessionSessionId, localConversationId, 50);
+                                difyChatMessageDTO.setConversationId(localConversationId);
+                            }
+                            String event = jsonObject.get("event").toString();
+                            if (event.equals("message")) {
+                                String answer = jsonObject.get("answer").toString();
+                                aiContentBuilder.append(answer);
+                                String message = fluxMessageService.getFluxMessage(filed, FluxMessageEventEnum.message.toString(), answer, confessionSessionId, type - 1);
+                                emitter.next(message);
+
+                            }
+                        }
+                    }
+
+                } catch (IOException e) {
+                    emitter.error(e);
+                    emitter.complete();
+                } finally {
+                }
+                //保存结果
+                PatentFileVO patentFileVO = new PatentFileVO();
+                if (result != null) {
+                    patentFileVO = JSONObject.parseObject(result, PatentFileVO.class);
+                }
+                String content = aiContentBuilder.toString();
+                content = DataUtils.aiAnswerThinkRemove(content);
+                patentFileVO.setTitle(content);
+                String name = confessionSession.getConversationName();
+                Boolean ifValid = DataUtils.isValidFormat("^\\d{4}-\\d{2}-\\d{2}-会话$", name);
+                if (ifValid) {
+                   name= name.replaceAll("会话", content);
+                    confessionSession.setConversationName(name);
+                }
+                confessionSessionService.updatePatentResult(confessionSession, type, patentFileVO);
+                String message = fluxMessageService.getFluxMessage(filed, FluxMessageEventEnum.end.toString(), "", confessionSessionId, type);
+                emitter.next(message);
+                //继续往下进行任务
+                if (types != null && types.size() > 0) {
+                    Integer temType = types.remove(0);
+                    patentResultFactoryDTO.setTypes(types);
+                    patentResultFactoryDTO.setType(temType);
+                    GeneratePatentResultService generatePatentResultService = patentResultFactory.getClass(temType);
+                    generatePatentResultService.generatePatentResult(patentResultFactoryDTO);
+                } else {
+                    String allEndMessage = fluxMessageService.getFluxMessage("", FluxMessageEventEnum.all_end.toString(), "", confessionSessionId, type);
+
+                    emitter.next(allEndMessage);
+                    emitter.complete();
+                }
+            }
+        });
+
+    }
+}

src/main/java/cn/cslg/pas/factorys/difyFactory/PatentResultFactory.java

@@ -0,0 +1,35 @@
+package cn.cslg.pas.factorys.difyFactory;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.ApplicationContext;
+import org.springframework.stereotype.Component;
+
+@Component
+public class PatentResultFactory {
+    @Autowired
+    private ApplicationContext applicationContext;
+
+    public GeneratePatentResultService getClass(Integer type) {
+        switch (type) {
+            case 1:
+                return applicationContext.getBean(GenerateClaimPatentResultImp.class);
+
+            case 2:
+                return applicationContext.getBean(GenerateAbstructPatentResultImp.class);
+
+            case 3:
+                return applicationContext.getBean(GenerateTitlePatentResultImp.class);
+
+            case 4:
+                return applicationContext.getBean(GenerateTechnicalFieldPatentResultImp.class);
+
+            case 5:
+                return applicationContext.getBean(GenerateBackgroundPatentResultImp.class);
+            case 6:
+                return applicationContext.getBean(GenerateInventionContentPatentResultImp.class);
+            case 7:
+                return applicationContext.getBean(GenerateImplementationMethodImp.class);
+        }
+        return null;
+    }
+}

src/main/java/cn/cslg/pas/service/common/DifyService.java

@@ -837,7 +837,7 @@ public class DifyService {
             map.put("file_path", fileContent);
 
         map.put("data_Result", confessionSession.getResultContent());
-        map.put("ask_type", type.toString());
+        map.put("ask_type", "type.toString()");
         difyChatMessageDTO.setInputs(map);
         difyChatMessageDTO.setConversationId(conversationId);
         difyChatMessageDTO.setResponseMode("streaming");
@@ -900,4 +900,11 @@ public class DifyService {
             });
         });
     }
+
+    public Request getGeneratePatentResultResultRequest(Integer confessionSessionId,DifyChatMessageDTO difyChatMessageDTO,String aiKey){
+        String param = new Gson().toJson(difyChatMessageDTO);
+        RequestBody requestBody = RequestBody.create(MediaType.parse("application/json"), param);
+        Request request = this.getChatMessageRequest(requestBody,aiKey);
+        return request;
+    }
 }

src/main/java/cn/cslg/pas/service/dify/AssoConfessionConversationService.java

@@ -25,6 +25,22 @@ public class AssoConfessionConversationService extends ServiceImpl<AssoConfessio
         }
         return conversationId;
     }
+
+    public String addConversationId(Integer confessionSessionId, String conversationId, Integer type) {
+        LambdaQueryWrapper<AssoConfessionConversation> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(AssoConfessionConversation::getConfessionId, confessionSessionId)
+                .eq(AssoConfessionConversation::getType, type)
+                .eq(AssoConfessionConversation::getConversationId, conversationId);
+        AssoConfessionConversation assoConfessionConversation = this.getOne(queryWrapper, false);
+        if (assoConfessionConversation == null) {
+            assoConfessionConversation = new AssoConfessionConversation();
+            assoConfessionConversation.setConversationId(conversationId);
+            assoConfessionConversation.setConfessionId(confessionSessionId);
+            assoConfessionConversation.setType(type);
+            assoConfessionConversation.insert();
+        }
+        return conversationId;
+    }
 }
 
 

src/main/java/cn/cslg/pas/service/dify/AssoConfessionSessionFileService.java

@@ -28,4 +28,22 @@ public class AssoConfessionSessionFileService extends ServiceImpl<AssoConfession
 
         return guids;
     }
+
+    public AssoConfessionSessionFile addOnlyFiles(Integer confessionSessionId, Integer type, String guid) {
+        LambdaQueryWrapper<AssoConfessionSessionFile> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(AssoConfessionSessionFile::getConfessionSessionId, confessionSessionId)
+                .eq(AssoConfessionSessionFile::getType, type);
+        AssoConfessionSessionFile assoConfessionSessionFile = this.getOne(queryWrapper, false);
+        if (assoConfessionSessionFile == null) {
+            assoConfessionSessionFile = new AssoConfessionSessionFile();
+            assoConfessionSessionFile.setConfessionSessionId(confessionSessionId);
+            assoConfessionSessionFile.setType(type);
+            assoConfessionSessionFile.setGuid(guid);
+            assoConfessionSessionFile.insert();
+        } else {
+            assoConfessionSessionFile.setGuid(guid);
+            assoConfessionSessionFile.updateById();
+        }
+        return assoConfessionSessionFile;
+    }
 }

src/main/java/cn/cslg/pas/service/dify/ConfessionSessionService.java

@@ -3,10 +3,8 @@ package cn.cslg.pas.service.dify;
 import cn.cslg.pas.common.model.cronModel.SystemFile;
 import cn.cslg.pas.common.model.dify.confessionSession.*;
 import cn.cslg.pas.common.model.dify.generateDiscoveryResult.UpdateDiscoveryResultDTO;
-import cn.cslg.pas.common.utils.CacheUtils;
-import cn.cslg.pas.common.utils.DataUtils;
-import cn.cslg.pas.common.utils.FormatUtil;
-import cn.cslg.pas.common.utils.LoginUtils;
+import cn.cslg.pas.common.model.dify.generatePatentResult.PatentFileVO;
+import cn.cslg.pas.common.utils.*;
 import cn.cslg.pas.domain.dify.AssoConfessionConversation;
 import cn.cslg.pas.domain.dify.AssoConfessionSessionFile;
 import cn.cslg.pas.exception.ExceptionEnum;
@@ -14,6 +12,7 @@ import cn.cslg.pas.exception.XiaoShiException;
 import cn.cslg.pas.mapper.dify.AssoConfessionSessionFileMapper;
 import cn.cslg.pas.service.common.FileManagerService;
 import com.alibaba.fastjson.JSONObject;
+import com.alibaba.fastjson2.JSON;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
@@ -67,7 +66,9 @@ public class ConfessionSessionService extends ServiceImpl<ConfessionSessionMappe
         } catch (Exception e) {
         }
         if (name != null && !name.isEmpty()) {
-            name = DataUtils.getTextBeforeLastSignal(name,".");
+            name = DataUtils.getTextBeforeLastSignal(name, ".");
+        } else {
+            name = DateUtils.dateTimeToStr(new Date(), "yyyy-MM-dd") + "-会话";
         }
         ConfessionSession confessionSession = new ConfessionSession();
         confessionSession.setGuid(guid);
@@ -236,9 +237,16 @@ public class ConfessionSessionService extends ServiceImpl<ConfessionSessionMappe
         ConfessionSessionDetailVO confessionSessionDetailVO = new ConfessionSessionDetailVO();
         Integer confessionSessionId = confessionSessionDetailDTO.getConfessionSessionId();
         ConfessionSession confessionSession = this.getById(confessionSessionId);
+        Integer type = confessionSession.getType();
         BeanUtils.copyProperties(confessionSession, confessionSessionDetailVO);
-        confessionSessionDetailVO.setDiscoveryResult(confessionSession.getResultContent());
-
+        switch (type) {
+            case 4:
+                confessionSessionDetailVO.setDiscoveryResult(confessionSession.getResultContent());
+                break;
+            case 5:
+                confessionSessionDetailVO.setPatentResult(confessionSession.getResultContent());
+                break;
+        }
         //装载文件
         LambdaQueryWrapper<AssoConfessionSessionFile> queryWrapper = new LambdaQueryWrapper<>();
         queryWrapper.eq(AssoConfessionSessionFile::getConfessionSessionId, confessionSessionId);
@@ -253,14 +261,14 @@ public class ConfessionSessionService extends ServiceImpl<ConfessionSessionMappe
         } catch (Exception e) {
             e.printStackTrace();
         }
-        List<String> inFileGuids =assoConfessionSessionFiles.stream().filter(item->item.getType()!=null&&item.getType().equals(0)).map(AssoConfessionSessionFile::getGuid).collect(Collectors.toList());
-        List<String> outFileGuids =assoConfessionSessionFiles.stream().filter(item->item.getType()==null||item.getType().equals(1)).map(AssoConfessionSessionFile::getGuid).collect(Collectors.toList());
-        if(inFileGuids.size()>0){
-            List<SystemFile> systemFileList =systemFiles.stream().filter(item->inFileGuids.contains(item.getGuid())).collect(Collectors.toList());
+        List<String> inFileGuids = assoConfessionSessionFiles.stream().filter(item -> item.getType() != null && item.getType().equals(0)).map(AssoConfessionSessionFile::getGuid).collect(Collectors.toList());
+        List<String> outFileGuids = assoConfessionSessionFiles.stream().filter(item -> item.getType() == null || item.getType().equals(1)).map(AssoConfessionSessionFile::getGuid).collect(Collectors.toList());
+        if (inFileGuids.size() > 0) {
+            List<SystemFile> systemFileList = systemFiles.stream().filter(item -> inFileGuids.contains(item.getGuid())).collect(Collectors.toList());
             confessionSessionDetailVO.setDiscoveryFiles(systemFileList);
         }
-        if(outFileGuids.size()>0){
-            List<SystemFile> systemFileList =systemFiles.stream().filter(item->outFileGuids.contains(item.getGuid())).collect(Collectors.toList());
+        if (outFileGuids.size() > 0) {
+            List<SystemFile> systemFileList = systemFiles.stream().filter(item -> outFileGuids.contains(item.getGuid())).collect(Collectors.toList());
             confessionSessionDetailVO.setResultFiles(systemFileList);
         }
         //装载会话id
@@ -279,6 +287,22 @@ public class ConfessionSessionService extends ServiceImpl<ConfessionSessionMappe
         }
         return confessionSessionDetailVO;
     }
+
+    public Integer updateResult(UpdateResultDTO updateResultDTO) {
+        String discoveryResult = updateResultDTO.getResult();
+        Integer confessionSessionId = updateResultDTO.getConfessionSessionId();
+        LambdaUpdateWrapper<ConfessionSession> updateWrapper = new LambdaUpdateWrapper<>();
+        updateWrapper.set(ConfessionSession::getResultContent, discoveryResult).eq(ConfessionSession::getId, confessionSessionId);
+        this.update(updateWrapper);
+        return confessionSessionId;
+    }
+
+    public Integer updatePatentResult(ConfessionSession confessionSession, Integer status, PatentFileVO patentFileVO) {
+        confessionSession.setStatus(status);
+        confessionSession.setResultContent(JSON.toJSONString(patentFileVO));
+        confessionSession.updateById();
+        return confessionSession.getId();
+    }
 }
 
 

src/main/java/cn/cslg/pas/service/dify/DifyTempleExportService.java

@@ -1,8 +1,142 @@
 package cn.cslg.pas.service.dify;
 
+import cn.cslg.pas.common.model.cronModel.SystemFile;
+import cn.cslg.pas.common.model.dify.generatePatentResult.ExportPatentDTO;
+import cn.cslg.pas.common.model.dify.generatePatentResult.PatentFileVO;
+import cn.cslg.pas.common.utils.DataUtils;
+import cn.cslg.pas.common.utils.FileUtils;
+import cn.cslg.pas.domain.business.ReportTemple;
+import cn.cslg.pas.domain.dify.ConfessionSession;
+import cn.cslg.pas.domain.dify.ImplementationMessage;
+import cn.cslg.pas.exception.ExceptionEnum;
+import cn.cslg.pas.exception.XiaoShiException;
+import cn.cslg.pas.service.business.ReportTempleService;
+import cn.cslg.pas.service.common.FileManagerService;
+import cn.hutool.core.bean.BeanUtil;
+import com.alibaba.fastjson.JSONObject;
+import com.alibaba.fastjson2.JSON;
+import com.deepoove.poi.XWPFTemplate;
+import com.deepoove.poi.config.Configure;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
+import java.io.File;
+import java.util.*;
+
 @Service
 public class DifyTempleExportService {
+    @Autowired
+    private FileUtils fileUtils;
+    @Autowired
+    private FileManagerService fileManagerService;
+    @Autowired
+    private ReportTempleService reportTempleService;
+    @Autowired
+    private AssoConfessionSessionFileService assoConfessionSessionFileService;
+    @Autowired
+    private ConfessionSessionService confessionSessionService;
+
+    /**
+     * 导出专利申请文档
+     */
+    public SystemFile exportPatentFile(ExportPatentDTO exportPatentDTO) throws Exception {
+        SystemFile systemFile = new SystemFile();
+        Integer confessionSessionId = exportPatentDTO.getConfessionSessionId();
+        Integer templateId = 25;
+        Map<String, Object> map = new HashMap<>();
+        ConfessionSession confessionSession = confessionSessionService.getById(confessionSessionId);
+        String result = confessionSession.getResultContent();
+        if (result == null) {
+            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "无结果可导出");
+        }
+        PatentFileVO patentFileVO = JSON.parseObject(result, PatentFileVO.class);
+        map = BeanUtil.beanToMap(patentFileVO);
+        String claim = patentFileVO.getClaim();
+        if (claim != null) {
+            String[] claimStrs = claim.split("\n");
+            List<String> claims = Arrays.asList(claimStrs);
+            map.put("claims", claims);
+        }
+        String inventionContent = patentFileVO.getInventionContent();
+        if (inventionContent != null) {
+            String[] inventionContentStrs = inventionContent.split("\n");
+            List<String> inventionContents = Arrays.asList(inventionContentStrs);
+            map.put("inventionContents", inventionContents);
+        }
+        String implementationMethod = patentFileVO.getImplementationMethod();
+        if (implementationMethod != null) {
+            String[] implementationMethodStrs = implementationMethod.split("\n");
+            List<String> implementationMethods = Arrays.asList(implementationMethodStrs);
+            List<ImplementationMessage> implementationMessages = new ArrayList<>();
+            int i = 1;
+            for (String item : implementationMethods) {
+                if (i % 3 == 0) {
+                    ImplementationMessage implementationMessage = implementationMessages.get(implementationMessages.size() - 1);
+                    implementationMessage.setEffect(item);
+                }
+                else if (i % 3 == 2) {
+                    ImplementationMessage implementationMessage = implementationMessages.get(implementationMessages.size() - 1);
+                    implementationMessage.setExplain(item);
+                }
+                else if (i % 3 == 1) {
+                    ImplementationMessage implementationMessage = new ImplementationMessage();
+                    implementationMessage.setClaimStr(item);
+                    implementationMessages.add(implementationMessage);
+                }
+                i++;
+            }
+            map.put("implementation", implementationMessages);
+        }
+        ReportTemple reportTemplate = reportTempleService.getById(templateId);
+        String templateFilePath = fileUtils.getPath(reportTemplate.getTemplatePath());
+        String ids = this.generateFile(map, templateFilePath, confessionSession.getConversationName()+"-申请文档");
+
+        try {
+            String res = fileManagerService.getSystemFileFromFMS(Arrays.asList(ids));
+            List<SystemFile> systemFiles = JSONObject.parseArray(res, SystemFile.class);
+            if (systemFiles != null && systemFiles.size() > 0) {
+                systemFile = systemFiles.get(0);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        if (ids != null) {
+            assoConfessionSessionFileService.addOnlyFiles(confessionSessionId, 1, ids);
+        }
+        return systemFile;
+
+    }
+
+    public String generateFile(Map<String, Object> map, String templateFilePath, String name) throws Exception {
+        XWPFTemplate xwpfTemplate = this.getTemplate(map, templateFilePath);
+        String fileName = name + ".docx";
+        String directoryName = fileUtils.createDirectory();
+        String outPath = fileUtils.getSavePath(directoryName) + fileName;
+        File file = new File(outPath);
+        // 生成word保存在指定目录
+        xwpfTemplate.writeToFile(outPath);
+        xwpfTemplate.close();
+        List<String> ids = fileManagerService.uploadFileGetGuid2(Arrays.asList(file));
+        if (ids == null || ids.size() == 0) {
+            throw new XiaoShiException("保存记录失败");
+        }
+
+        return ids.get(0);
+    }
+
+    private XWPFTemplate getTemplate(Map<String, Object> map, String filePath) {
+        //装载标的专利信息
+        XWPFTemplate template = null;
+        try {
+            Configure configure = Configure.builder()
+                    .build();
+            template = XWPFTemplate.compile(filePath, configure).render(map);
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "未匹配到模版文件");
+        }
+        return template;
+    }
 
 }

src/main/java/cn/cslg/pas/service/dify/FluxMessageService.java

@@ -0,0 +1,19 @@
+package cn.cslg.pas.service.dify;
+
+import cn.cslg.pas.common.model.dify.FluxMessageVO;
+import com.alibaba.fastjson.JSONObject;
+import org.springframework.stereotype.Service;
+
+@Service
+public class FluxMessageService {
+    public String getFluxMessage(String field, String event, String content,Integer sessionId,Integer status) {
+        FluxMessageVO fluxMessage = new FluxMessageVO();
+        fluxMessage.setEvent(event);
+        fluxMessage.setField(field);
+        fluxMessage.setContent(content);
+        fluxMessage.setId(sessionId);
+        fluxMessage.setStatus(status);
+        String json = JSONObject.toJSONString(fluxMessage);
+        return json;
+    }
+}

src/main/java/cn/cslg/pas/service/dify/PatentResultService.java

@@ -0,0 +1,103 @@
+package cn.cslg.pas.service.dify;
+
+import cn.cslg.pas.common.model.dify.generatePatentResult.GeneratePatentResultDTO;
+import cn.cslg.pas.common.model.dify.generatePatentResult.PatentResultFactoryDTO;
+import cn.cslg.pas.common.model.enumVos.FluxMessageEventEnum;
+import cn.cslg.pas.common.model.enumVos.PatentResultEnum;
+import cn.cslg.pas.common.utils.LoginUtils;
+import cn.cslg.pas.domain.business.SystemDict;
+import cn.cslg.pas.domain.dify.ConfessionSession;
+import cn.cslg.pas.factorys.difyFactory.GeneratePatentResultService;
+import cn.cslg.pas.factorys.difyFactory.PatentResultFactory;
+import cn.cslg.pas.service.business.SystemDictService;
+import org.checkerframework.checker.units.qual.A;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.FluxSink;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Service
+public class PatentResultService {
+    @Autowired
+    private PatentResultFactory patentResultFactory;
+    @Autowired
+    private LoginUtils loginUtils;
+    @Autowired
+    private ConfessionSessionService confessionSessionService;
+    @Autowired
+    private SystemDictService systemDictService;
+    @Autowired
+    private AssoConfessionConversationService assoConfessionConversationService;
+    @Value("${DIFY.aiPatentResultKey}")
+    private String aiPatentResultKey;
+   @Autowired
+   private FluxMessageService fluxMessageService;
+    public Flux<String> aiGeneratePatentResult(GeneratePatentResultDTO generatePatentResultDTO) {
+
+        Integer userId = loginUtils.getId();
+        Integer confessionSessionId = generatePatentResultDTO.getConfessionSessionId();
+
+        List<Integer> types = this.formatTypes(generatePatentResultDTO);
+        Integer trueType = types.remove(0);
+        String conversationId = assoConfessionConversationService.getConversationId(confessionSessionId, 50);
+
+        return Flux.create(emitter -> {
+            String allStartMessage= fluxMessageService.getFluxMessage("", FluxMessageEventEnum.all_start.toString(),"",confessionSessionId,trueType-1);
+
+            emitter.next(allStartMessage);
+            PatentResultFactoryDTO patentResultFactoryDTO = new PatentResultFactoryDTO();
+            patentResultFactoryDTO.setFluxSink(emitter);
+            patentResultFactoryDTO.setConfessionSessionId(confessionSessionId);
+            patentResultFactoryDTO.setUserId(userId.toString());
+            patentResultFactoryDTO.setConversationId(conversationId);
+            patentResultFactoryDTO.setApiKey(aiPatentResultKey);
+            patentResultFactoryDTO.setType(trueType);
+            patentResultFactoryDTO.setTypes(types);
+            patentResultFactoryDTO.setTargetMessageSplit("</think>");
+            GeneratePatentResultService generatePatentResultService = patentResultFactory.getClass(trueType);
+            generatePatentResultService.generatePatentResult(patentResultFactoryDTO);
+        });
+
+    }
+
+    public List<Integer> formatTypes(GeneratePatentResultDTO generatePatentResultDTO) {
+        Integer type = generatePatentResultDTO.getType();
+        List<Integer> reTypes = new ArrayList<>();
+        Integer operateType = generatePatentResultDTO.getOperateType();
+        Integer confessionSessionId = generatePatentResultDTO.getConfessionSessionId();
+        ConfessionSession confessionSession = confessionSessionService.getById(confessionSessionId);
+        Integer status = confessionSession.getStatus();
+        Integer nowStatus = type;
+        Integer nextStatus = status + 1;
+        List<SystemDict> systemDictList = systemDictService.getSystemDictListByType(Arrays.asList("PATENT_FILE_FIELD"));
+        switch (operateType) {
+            case 0:
+                SystemDict systemDict = systemDictList.stream().filter(item -> item.getValue().equals(nextStatus.toString())).findFirst().orElse(null);
+                if (systemDict != null) {
+                    reTypes.add(nextStatus);
+                    return reTypes;
+                }
+                break;
+            case 1:
+                nowStatus = status;
+            case 2:
+                Integer finalStatus = nowStatus;
+                List<SystemDict> temSystemDicts = systemDictList.stream().filter(item -> Integer.parseInt(item.getValue()) > finalStatus).collect(Collectors.toList());
+                if (temSystemDicts.size() > 0) {
+                    List<String> values = temSystemDicts.stream().map(SystemDict::getValue).collect(Collectors.toList());
+                    values.forEach(item -> {
+                        reTypes.add(Integer.parseInt(item));
+                    });
+                }
+                break;
+        }
+        return reTypes;
+    }
+
+}

src/main/resources/application-dev.yml

@@ -93,4 +93,5 @@ DIFY:
   cliamKey: app-jF3akhYKgljPLdpeIpTNbs6f
   gInstructionKey: app-7ImBmlr7kvBTSvBj1mTvgKyp
   discoveryResultKey: app-G5gnZ4s7GlMEIft79fk7hUR7
+  aiPatentResultKey: app-KLneZ6O7qXL2DjKm169ltxJI
   url: http://192.168.2.24/v1/