diff --git a/src/main/java/com/xly/agent/SystemPromptGenerator.java b/src/main/java/com/xly/agent/SystemPromptGenerator.java new file mode 100644 index 0000000..49f0b85 --- /dev/null +++ b/src/main/java/com/xly/agent/SystemPromptGenerator.java @@ -0,0 +1,53 @@ +package com.xly.agent; + +import cn.hutool.core.util.ObjectUtil; +import cn.hutool.json.JSONConfig; +import cn.hutool.json.JSONUtil; +import com.alibaba.fastjson2.JSON; +import com.alibaba.fastjson2.JSONObject; +import com.alibaba.fastjson2.JSONWriter; +import com.xly.entity.ParamRule; +import com.xly.entity.UserSceneSession; + +import java.util.List; + +public class SystemPromptGenerator { + + public static String generate(String toolName, UserSceneSession session) { + StringBuilder sb = new StringBuilder(); + + sb.append("你是一个无情的参数提取器，不是聊天助手。\n\n"); + sb.append("【核心任务】\n"); + sb.append("从用户输入中提取参数，并立即调用工具 ").append(toolName).append("。\n\n"); + sb.append("【绝对指令】\n"); + sb.append("1. 严禁与用户对话，严禁输出任何纯文本回复。\n"); + sb.append("2. 无论参数缺失多么严重，都必须直接调用工具，缺失字段填空字符串或0。\n"); + sb.append("3. 不要引导用户，后端程序会处理引导逻辑。\n\n"); + sb.append("【参数提取规则】\n"); + sb.append("用户输入格式为 \"参数名: 值\" 或 \"参数名 值\"，你必须识别参数名并提取对应的值。\n\n"); + sb.append("【可提取的参数列表】\n"); + List dynamicParamRuleAll = session.getCurrentTool().getParamRuleListAll(); + // 从参数定义中提取 + for (ParamRule paramRule : dynamicParamRuleAll) { + sb.append("- ").append(paramRule.getSParam()).append("\n"); + } + sb.append("\n【提取示例】\n"); + // 动态生成示例（取前3个参数作为示例） + int count = 0; + for (ParamRule paramRule : dynamicParamRuleAll) { + if (count++ >= 3) break; + sb.append("- 用户输入 \"").append(paramRule.getSParam()).append(": {值}\" → 提取 ").append(paramRule.getSParam()).append("\n"); + } + + if(ObjectUtil.isNotEmpty(session.getArgs())){ + sb.append("【已提取参数】\n"); + sb.append(JSON.toJSONString(session.getArgs(), JSONWriter.Feature.PrettyFormat)); + } + sb.append("\n【工具调用规则】\n"); + sb.append("1. 每次只调用一次工具\n"); + sb.append("2. 调用后立即停止，不要重复调用\n"); + sb.append("3. 不要总结，不要回复用户，只调用工具"); + + return sb.toString(); + } +} \ No newline at end of file diff --git a/src/main/java/com/xly/entity/ParamRule.java b/src/main/java/com/xly/entity/ParamRule.java index d69a6da..9e889dc 100644 --- a/src/main/java/com/xly/entity/ParamRule.java +++ b/src/main/java/com/xly/entity/ParamRule.java @@ -14,6 +14,7 @@ import java.time.LocalDateTime; @Data public class ParamRule { private Integer iOrder; + private String sId; private String sParamValue; private String sParentId; private String sParam; @@ -28,5 +29,9 @@ public class ParamRule { private Boolean bTipModel; private Boolean bEmpty; private Boolean bConfirmAfter; + private String sDynamicParamRuleSql; + private String sDynamicParam; + private String sDynamicParamName; + private Boolean bDynamicParam = false; } diff --git a/src/main/java/com/xly/entity/ToolMeta.java b/src/main/java/com/xly/entity/ToolMeta.java index 46f6601..996100e 100644 --- a/src/main/java/com/xly/entity/ToolMeta.java +++ b/src/main/java/com/xly/entity/ToolMeta.java @@ -46,6 +46,7 @@ public class ToolMeta { private List paramRuleList;//模型 private List paramRuleListCheck;//需要校验 private List paramRuleListAll;//所有的 + private List dynamicParamRule;//动态参数 private LocalDateTime tMakeDate; private String sVectorfiled; private String sVectorjson; diff --git a/src/main/java/com/xly/mapper/ToolMetaMapper.java b/src/main/java/com/xly/mapper/ToolMetaMapper.java index 89f3a21..9bebb69 100644 --- a/src/main/java/com/xly/mapper/ToolMetaMapper.java +++ b/src/main/java/com/xly/mapper/ToolMetaMapper.java @@ -15,5 +15,4 @@ public interface ToolMetaMapper { // XML配置方式 @Select("SELECT A.* FROM ai_tool AS A order by iOrder") List findAll(); - } \ No newline at end of file diff --git a/src/main/java/com/xly/service/XlyErpService.java b/src/main/java/com/xly/service/XlyErpService.java index 77880ec..7afa87c 100644 --- a/src/main/java/com/xly/service/XlyErpService.java +++ b/src/main/java/com/xly/service/XlyErpService.java @@ -362,6 +362,11 @@ public class XlyErpService { //重新生成新的aiAgent拿新的aiAgent 做选择 aiAgent = createConfirmeAgent(session); } + //存在动态参数需要重新定义引导语 + if(ObjectUtil.isNotEmpty(session.getCurrentTool())&&ObjectUtil.isNotEmpty(session.getCurrentTool().getDynamicParamRule())){ + sSystemPrompt = SystemPromptGenerator.generate(session.getCurrentTool().getSMethodName(),session); + aiAgent = createConfirmeAgent(session); + } Result rs = aiAgent.chat(userId, input,sSystemPrompt); sResponMessage = rs.content(); } @@ -954,7 +959,7 @@ public class XlyErpService { executors.put(one.getToolSpecification(),one.getToolExecutor()); }); } - +// operableChatMemoryProvider.clearSpecifiedMemory(session.getUserId()); aiAgent = AiServices.builder(ErpAiAgent.class) .chatModel(chatModel) .chatMemoryProvider(operableChatMemoryProvider) @@ -974,13 +979,18 @@ public class XlyErpService { if(ObjectUtil.isNotEmpty(dataList)){ dataList.forEach(one->{ immediateReturnToolNames.add(one.getsName()); - executors.put(one.getToolSpecification(),one.getToolExecutor()); + if(ObjectUtil.isNotEmpty(session.getCurrentTool()) && ObjectUtil.isNotEmpty(session.getCurrentTool().getDynamicParamRule())){ + ToolSpecification spec = dynamicToolProvider.buildToolSpecification(session.getCurrentTool()); + session.getCurrentTool().setDynamicParamRule(new ArrayList<>()); + executors.put(spec,one.getToolExecutor()); + }else{ + executors.put(one.getToolSpecification(),one.getToolExecutor()); + } }); } - ChatMemory chatMemory = operableChatMemoryProvider.get(session.getUserId()); + operableChatMemoryProvider.clearSpecifiedMemory(session.getUserId()); ErpAiAgent aiAgent = AiServices.builder(ErpAiAgent.class) .chatModel(chatModel) - .chatMemory(chatMemory) .chatMemoryProvider(operableChatMemoryProvider) .tools(executors,immediateReturnToolNames) .build(); diff --git a/src/main/java/com/xly/tool/DynamicToolProvider.java b/src/main/java/com/xly/tool/DynamicToolProvider.java index 6e0cc04..198a42b 100644 --- a/src/main/java/com/xly/tool/DynamicToolProvider.java +++ b/src/main/java/com/xly/tool/DynamicToolProvider.java @@ -1,22 +1,22 @@ package com.xly.tool; +import cn.hutool.core.bean.BeanUtil; import cn.hutool.core.date.DateUtil; import cn.hutool.core.util.BooleanUtil; import cn.hutool.core.util.ObjectUtil; import cn.hutool.core.util.StrUtil; +import cn.hutool.json.JSONArray; import cn.hutool.json.JSONUtil; import com.alibaba.fastjson2.JSONObject; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; -import com.xly.agent.AgentSystemPrompt; import com.xly.config.OperableChatMemoryProvider; import com.xly.constant.*; import com.xly.entity.*; import com.xly.exception.dto.BusinessException; -import com.xly.exception.dto.DataException; import com.xly.mapper.ParamRuleMapper; import com.xly.mapper.ToolMetaMapper; import com.xly.service.DynamicExeDbService; @@ -25,27 +25,22 @@ import com.xly.util.*; import dev.langchain4j.agent.tool.*; import dev.langchain4j.data.message.*; - -import dev.langchain4j.memory.ChatMemory; - import dev.langchain4j.model.chat.request.json.JsonObjectSchema; -import dev.langchain4j.model.chat.request.json.JsonSchema; import dev.langchain4j.service.tool.*; -import lombok.Getter; import lombok.RequiredArgsConstructor; -import lombok.Setter; import lombok.extern.slf4j.Slf4j; -import org.apache.ibatis.javassist.expr.NewArray; import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Service; import java.util.*; import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Function; import java.util.stream.Collectors; import java.util.stream.IntStream; @@ -188,8 +183,13 @@ public class DynamicToolProvider implements ToolProvider { if(ObjectUtil.isEmpty(args)) args = new HashMap<>(); Map finalArgs = args; argsNew.forEach((k, v)->{ - //获取对应的英文参数 - List data = meta.getParamRuleList().stream().filter(one->one.getSParam().equals(k)).collect(Collectors.toUnmodifiableList()); + //需要移除的老的参数 + List data = meta.getParamRuleList().stream().filter( + one-> one.getSParam().equals(k) + && ObjectUtil.isNotEmpty(v) + && !"0".equals(v) + && !"\"\"".equals(v) + ).collect(Collectors.toUnmodifiableList()); if(ObjectUtil.isNotEmpty(data) && data.size()>0){ finalArgs.remove(data.get(0).getSParamValue()); finalArgs.remove(data.get(0).getSParam()); @@ -198,7 +198,6 @@ public class DynamicToolProvider implements ToolProvider { finalArgs.put(k,v); } }); - // 2 【补全动态参数】动态参数补全 try{ args = applyValues(args, meta.getParamRuleListCheck()); @@ -213,6 +212,19 @@ public class DynamicToolProvider implements ToolProvider { // 2.1 【自动补全】应用参数的默认值 List paramRuleData = meta.getParamRuleListAll(); args = applyDefaultValues(args, paramRuleData); + //存入已采集参数 + session.setArgs(args); + // 2.1.1 根据当前获取的新参数判断是否存在有值必填例如动态参数、动态部件 + List dynamicParamRule = doSetParamgetArgsAfter(args, session); + if(ObjectUtil.isNotEmpty(dynamicParamRule)){ + String askMsg = hasDynamicParamRule(argsNew, session,dynamicParamRule); + session.getCurrentTool().setDynamicParamRule(dynamicParamRule); + //此处修改动态参数 + session.setSFunPrompts(askMsg); + addSystemMessage(session, askMsg); + // 需要提问用户 → 抛异常停止循环 + return String.valueOf(successResult(toolExecutionRequest, askMsg)); + } //客户选择行号转sSLaveId if(ObjectUtil.isNotEmpty(args) &&( @@ -222,6 +234,7 @@ public class DynamicToolProvider implements ToolProvider { ){ doSetSlaveIdToArgs( args, session); } + //存入已采集参数 session.setArgs(args); // 3. 【自动校验】检查必填项 List missing = checkRequiredParams(args, paramRuleData); @@ -238,6 +251,192 @@ public class DynamicToolProvider implements ToolProvider { }; } + /*** + * @Author 钱豹 + * @Date 22:50 2026/6/28 + * @Param [args, session] + * @return void + * @Description 获取动态参数 + **/ + private List doSetParamgetArgsAfter(Map argsNew,UserSceneSession session){ + //获取当前方法 + ToolMeta tool = session.getCurrentTool(); + Map argsOld = session.getArgs(); + Map args = DeepCopyUtils.deepCopy(argsNew); + if(ObjectUtil.isEmpty(argsOld)){ + argsOld = new HashMap<>(); + } + //根据新录入的参数获取规则 + AtomicReference> paramRuleDataAll = new AtomicReference<>(tool.getParamRuleListAll()); + List paramRuleData = tool.getParamRuleListAll(); + paramRuleData = paramRuleData.stream().filter(one-> + ( ObjectUtil.isNotEmpty(args.get(one.getSParam())) ||ObjectUtil.isNotEmpty(args.get(one.getSParamValue()))) + && ObjectUtil.isNotEmpty(one.getSDynamicParamRuleSql()) + ).collect(Collectors.toUnmodifiableList()); + List dynamicParamRule = new ArrayList<>(); + //为空的时候需要重新插入 不为空 表示之前已经放过了 + if(ObjectUtil.isNotEmpty(paramRuleData)){ + Map finalArgsOld = argsOld; + paramRuleData.forEach(one->{ + //根据新参数获取需要填写参数 + Map searMap = new HashMap<>(); + searMap.putAll(args); + //新参数如果值变了移除掉之前插入的 + List paramRuleDataAllNew = paramRuleDataAll.get().stream().filter(d-> + !one.getSParam().equals(d.getSDynamicParam()) + ||(one.getSParam().equals(d.getSDynamicParam()) && one.getSParamValue().equals(d.getSParamValue())) + ).collect(Collectors.toUnmodifiableList()); + List paramRuleList = tool.getParamRuleList().stream().filter(d-> + !one.getSParam().equals(d.getSDynamicParam()) + ||(one.getSParam().equals(d.getSDynamicParam()) && one.getSParamValue().equals(d.getSParamValue())) + ).collect(Collectors.toUnmodifiableList()); + List paramRuleListCheck = tool.getParamRuleListCheck().stream().filter(d-> + !one.getSParam().equals(d.getSDynamicParam()) + ||(one.getSParam().equals(d.getSDynamicParam()) && one.getSParamValue().equals(d.getSParamValue())) + ).collect(Collectors.toUnmodifiableList()); + paramRuleDataAllNew = deduplicateByParamValue(paramRuleDataAllNew); + paramRuleList = deduplicateByParamValue(paramRuleList); + paramRuleListCheck = deduplicateByParamValue(paramRuleListCheck); + session.getCurrentTool().setParamRuleList(paramRuleList); + session.getCurrentTool().setParamRuleListAll(paramRuleDataAllNew); + session.getCurrentTool().setParamRuleListCheck(paramRuleListCheck); +// paramRuleDataAll.set(paramRuleDataAllNew); + List paramRuleDataD = paramRuleDataAll.get().stream().filter(d-> searMap.get(one.getSParam()).equals(d.getSDynamicParam())).collect(Collectors.toUnmodifiableList()); + //如果不存在的加入方法参数中 + if(ObjectUtil.isEmpty(paramRuleDataD)){ + String sValue = searMap.get(one.getSParam()).toString(); + List addValue = new ArrayList<>(); + if(JSONUtil.isTypeJSONArray(sValue)){ + addValue = JSONUtil.toList(sValue,String.class); + }else{ + addValue.add(sValue); + } + for(String sVaule:addValue){ + searMap.put("sRuleId",one.getSId()); + searMap.put("sTooId",one.getSParentId()); + searMap.put("sParam",one.getSParam()); + searMap.put("sParamValue",sVaule); +// searMap.put("sParamValue",one.getSParamValue()); + searMap.put("sParamName",one.getSParam()); + String sSql = one.getSDynamicParamRuleSql(); + searMap.put("argsNew",JSONObject.toJSONString(args)); + searMap.put("argsAll",JSONObject.toJSONString(finalArgsOld)); + //如果不是SELECT 开头 + List> selectData = new ArrayList<>(); + List> dynamicParamRuleOne = new ArrayList<>(); + if(sSql.replaceAll(" ","").toLowerCase().startsWith("select") + || sSql.replaceAll(" ","").toLowerCase().startsWith("call")){ + selectData = this.dynamicExeDbService.findSql(searMap, sSql); + String sData = (ObjectUtil.isNotEmpty(selectData) + && ObjectUtil.isNotEmpty(selectData.get(0).get("sData")))?selectData.get(0).get("sData").toString():StrUtil.EMPTY; + if(ObjectUtil.isNotEmpty(sData)){ + dynamicParamRuleOne = JsonUtils.toList(sData,Map.class); + } + }else{ + //表示过程走自定义参数 + + } + if(ObjectUtil.isNotEmpty(dynamicParamRuleOne)){ + //转换成BEAN + //添加到方法中去 + List paramRuleDataAllAdd = tool.getParamRuleListAll().stream().collect(Collectors.toList()); + List paramRuleListAdd = tool.getParamRuleList().stream().collect(Collectors.toList()); + List paramRuleListCheckAdd = tool.getParamRuleListCheck().stream().collect(Collectors.toList()); + if(ObjectUtil.isEmpty(paramRuleDataAllAdd)){ + paramRuleDataAllAdd = new ArrayList<>(); + } + if(ObjectUtil.isEmpty(paramRuleListAdd)){ + paramRuleListAdd = new ArrayList<>(); + } + if(ObjectUtil.isEmpty(paramRuleListCheckAdd)){ + paramRuleListCheckAdd = new ArrayList<>(); + } + List finalParamRuleDataAllAdd = paramRuleDataAllAdd; + List finalParamRuleListAdd = paramRuleListAdd; + List finalParamRuleListCheckAdd = paramRuleListCheckAdd; + dynamicParamRuleOne.forEach(dynamicParamRuleData->{ + ParamRule paramRule = BeanUtil.toBean(dynamicParamRuleData,ParamRule.class); + dynamicParamRule.add(paramRule); + try{ + finalParamRuleDataAllAdd.add(paramRule); + finalParamRuleListAdd.add(paramRule); + if(paramRule.getBEmpty()){ + finalParamRuleListCheckAdd.add(paramRule); + } + }catch (Exception e){ + e.printStackTrace(); + } + }); + if(ObjectUtil.isNotEmpty(paramRuleDataAllAdd)){ + paramRuleDataAllAdd = deduplicateByParamValue(paramRuleDataAllAdd); + session.getCurrentTool().setParamRuleListAll(paramRuleDataAllAdd); + } + if(ObjectUtil.isNotEmpty(paramRuleListAdd)){ + paramRuleListAdd = deduplicateByParamValue(paramRuleListAdd); + session.getCurrentTool().setParamRuleList(paramRuleListAdd); + } + if(ObjectUtil.isNotEmpty(paramRuleListCheckAdd)){ + paramRuleListCheckAdd = deduplicateByParamValue(paramRuleListCheckAdd); + session.getCurrentTool().setParamRuleListCheck(paramRuleListCheckAdd); + } + } + } + } + }); + } + return dynamicParamRule; + } + /*** + * @Author 钱豹 + * @Date 0:58 2026/7/2 + * @Param [source, one] + * @return java.util.List + * @Description 去重 + **/ + private List deduplicateByParamValue(List source) { + if (source == null || source.isEmpty()) { + return new ArrayList<>(); + } + return source.stream() + .collect(Collectors.toMap( + ParamRule::getSParamValue, // 根据 sParamValue 去重 + Function.identity(), + (existing, replacement) -> existing // 保留第一个 + )) + .values() + .stream() + .collect(Collectors.toList()); + } + /*** + * @Author 钱豹 + * @Date 23:35 2026/6/28 + * @Param [argsNew, session] + * @return java.util.List + * @Description 存在动态参数返回提示 + **/ + private String hasDynamicParamRule(Map argsNew,UserSceneSession session,List dynamicParamRule){ + //获取当前方法 + ToolMeta meta = session.getCurrentTool(); + meta.setDynamicParamRule(dynamicParamRule); + session.setCurrentTool(meta); + Map argsOld = session.getArgs(); + Map args = DeepCopyUtils.deepCopy(argsNew); + if(ObjectUtil.isEmpty(argsOld)){ + argsOld = new HashMap<>(); + } + argsOld.putAll(args); + //根据获取的参数获取数据 + List dynamicParamRuleTs = dynamicParamRule.stream().map(ParamRule::getSParam).toList(); + session.setArgs(argsOld); + String askMsg = buildAskUserMessage(meta, dynamicParamRuleTs,args); + session.setSFunPrompts(askMsg); + String sSystemPrompt = buildMissParamPrompt(session,dynamicParamRule); + session.setSSystemPrompt(sSystemPrompt); + addSystemMessage(session, askMsg); + return askMsg; + } + + private void doSetSlaveIdToArgs(Map args,UserSceneSession session){ Map> data = session.getCurrentRowData(); List sSlaveIds = new ArrayList<>(); @@ -335,7 +534,7 @@ public class DynamicToolProvider implements ToolProvider { } - private ToolSpecification buildToolSpecification(ToolMeta meta) { + public ToolSpecification buildToolSpecification(ToolMeta meta) { ToolSpecification.Builder builder = ToolSpecification.builder() .name(meta.getSMethodNo()); @@ -373,7 +572,7 @@ public class DynamicToolProvider implements ToolProvider { if (paramDesc == null || paramDesc.isEmpty()) { continue; } - String sRuleCost = getConstMeg(paramRule); +// String sRuleCost = getConstMeg(paramRule); switch (paramType.toLowerCase()) { case "string": schemaBuilder.addStringProperty(paramDesc, paramDesc); @@ -522,7 +721,6 @@ public class DynamicToolProvider implements ToolProvider { argsOld = new HashMap<>(); } Map args = session.getArgs(); - List missing = checkRequiredParams(args, paramRuleDataCheck); if (!missing.isEmpty()) { String askMsg = buildAskUserMessage(meta, missing,args); @@ -635,7 +833,7 @@ public class DynamicToolProvider implements ToolProvider { markdown.append("请确认是否执行").append(sName).append("操作？请回复:  ").append("**确认**").append(" ") .append("**取消**"); } - + //添加参数 中英文 private Map transformationArgs(Map args, List paramDefs) { Map result = new HashMap<>(args); paramDefs.forEach(pd->{ @@ -643,7 +841,7 @@ public class DynamicToolProvider implements ToolProvider { String sValue = pd.getSParamValue(); Boolean bCheck = result.containsKey(name) && ObjectUtil.isNotEmpty(result.get(name)); Boolean bCheck2 = result.containsKey(sValue) && ObjectUtil.isNotEmpty(result.get(sValue)); - if (!bCheck2 && bCheck ) { + if (!bCheck2 && bCheck) { result.put(sValue,args.get(name)); } if(RuleCode.CONST.getCode().equals(pd.getSRule()) && ObjectUtil.isNotEmpty(result.get(sValue))){ @@ -658,7 +856,6 @@ public class DynamicToolProvider implements ToolProvider { }); return result; } - private Map applyValues(Map args, List paramDefsCheck) { Map result = new HashMap<>(args); result = transformationArgs( result, paramDefsCheck); @@ -762,29 +959,45 @@ public class DynamicToolProvider implements ToolProvider { private List checkRequiredParams(Map args, List paramDefs) { Map returnMap = transformationArgs( args, paramDefs); - return paramDefs.stream() - .filter(pd -> Boolean.TRUE.equals(pd.getBEmpty()) && pd.getBTipModel()) - .filter(pd -> checkMiss( returnMap, pd)) - .map(ParamRule::getSParam) + List paramDefsCheck = paramDefs.stream() + .filter(pd -> !"sDynamicPart".equals(pd.getSParamValue())).collect(Collectors.toUnmodifiableList()); + paramDefsCheck = paramDefsCheck.stream() + .filter(pd -> Boolean.TRUE.equals(pd.getBEmpty()) && pd.getBTipModel()).collect(Collectors.toUnmodifiableList()); + paramDefsCheck = paramDefsCheck.stream() + .filter(pd -> checkMiss( returnMap, pd)).collect(Collectors.toUnmodifiableList()); + return paramDefsCheck.stream().map(ParamRule::getSParam) .toList(); } + /*** + * @Author 钱豹 + * @Date 13:53 2026/7/1 + * @Param [returnMap, pd] + * @return java.lang.Boolean + * @Description 校验是否参数缺失 + **/ private Boolean checkMiss(Map returnMap,ParamRule pd) { if(ObjectUtil.isEmpty(returnMap)){ returnMap = new HashMap<>(); } - Boolean bBhcs = (ObjectUtil.isEmpty(returnMap.get(pd.getSParam()))); - Boolean bDbZero = false; - if(pd.getSParamValue().startsWith("d")){ - try{ - String sParam = pd.getSParam().toString(); - Object sParamV = returnMap.get(sParam); - bDbZero = (ObjectUtil.isEmpty(sParamV) || 0 ==Double.valueOf(sParamV.toString())); - }catch (Exception e){ - bDbZero = true; + if(pd.getBEmpty()){ + if(pd.getSParamValue().startsWith("d") && returnMap.get(pd.getSParam()) instanceof Number) { + try { + String sParam = pd.getSParam().toString(); + Object sParamV = returnMap.get(sParam); + return (ObjectUtil.isEmpty(sParamV) || 0 == Double.valueOf(sParamV.toString())); + } catch (Exception e) { + return true; + } + }else{ + try { + return ObjectUtil.isEmpty(returnMap.get(pd.getSParam())) && ObjectUtil.isEmpty(returnMap.get(pd.getSParamValue())); + } catch (Exception e) { + return true; + } } } - return bDbZero || bBhcs || (!returnMap.containsKey(pd.getSParamValue()) || (ObjectUtil.isEmpty(returnMap.get(pd.getSParamValue())))); + return false; } /*** @@ -837,6 +1050,14 @@ public class DynamicToolProvider implements ToolProvider { return sReturn; } + //参数进行处理 + private void doArgs(ToolMeta meta, Map args,List paramDefs) { + List paramDefsD = paramDefs.stream().filter(one-> ObjectUtil.isNotEmpty(one.getSDynamicParamRuleSql())).collect(Collectors.toUnmodifiableList()); + + + + } + private String executeToolAfter(ToolMeta meta, Map args,List paramDefs,UserSceneSession session) { String sBizContent = meta.getSBizContent(); Integer iBizType = meta.getIBizType(); @@ -1297,6 +1518,9 @@ public class DynamicToolProvider implements ToolProvider { StringBuilder sb = new StringBuilder(); sb.append("缺少参数请补全：\n"); List paramRuleData = meta.getParamRuleList(); + if(ObjectUtil.isNotEmpty(meta.getDynamicParamRule())){ + paramRuleData.addAll(meta.getDynamicParamRule()); + } for (String name : missing) { paramRuleData.stream() .filter(pd -> pd.getSParam().equals(name)) diff --git a/src/main/java/com/xly/util/JsonUtils.java b/src/main/java/com/xly/util/JsonUtils.java index c12a061..98cd34c 100644 --- a/src/main/java/com/xly/util/JsonUtils.java +++ b/src/main/java/com/xly/util/JsonUtils.java @@ -6,6 +6,7 @@ import com.fasterxml.jackson.databind.type.TypeFactory; import java.io.IOException; import java.util.List; +import java.util.Map; public class JsonUtils { @@ -21,7 +22,7 @@ public class JsonUtils { } // JSON字符串转List - public static List toList(String json, Class clazz) { + public static List toList(String json, Class clazz) { try { CollectionType listType = TypeFactory.defaultInstance() .constructCollectionType(List.class, clazz);