1. 暂存原子指标计算相关功能

src/main/java/com/supervision/police/controller/PromptController.java

@@ -4,6 +4,7 @@ import com.supervision.common.domain.R;
 import com.supervision.police.domain.NotePrompt;
 import com.supervision.police.service.NotePromptService;
 import io.swagger.annotations.ApiOperation;
+import io.swagger.v3.oas.annotations.Operation;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.web.bind.annotation.*;
@@ -28,8 +29,10 @@ public class PromptController {
      * @return
      */
     @GetMapping("/list")
+    @Operation(summary = "查询提示词列表")
     public R<List<NotePrompt>> listPrompt(@RequestParam(name = "caseType",defaultValue = "1") String caseType,@RequestParam("type") String type) {
         NotePrompt notePrompt = new NotePrompt();
+        notePrompt.setId("04ac794c-6457-11ef-a77c-0242ac11000d");
         notePrompt.setCaseType(caseType);
         notePrompt.setType(type);
         List<NotePrompt> notePrompts = promptService.listPrompt(notePrompt);

src/main/java/com/supervision/police/domain/ModelAtomicIndex.java

@@ -44,7 +44,7 @@ public class ModelAtomicIndex implements Serializable {
     public String caseTypeName;
     
     /**
-     * 指标来源
+     * 指标来源  1人工定义  2数据库查询	3图谱生成 4大模型 5:结构化推理
      */
     private String indexSource;
 

src/main/java/com/supervision/police/domain/NotePrompt.java

@@ -4,9 +4,12 @@ import com.baomidou.mybatisplus.annotation.FieldFill;
 import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
+import com.baomidou.mybatisplus.extension.handlers.Fastjson2TypeHandler;
+import com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler;
 import com.fasterxml.jackson.annotation.JsonFormat;
 import com.supervision.police.dto.TripleInfoDTO;
 import com.supervision.police.dto.TypeDTO;
+import com.supervision.police.handler.JsonTypeHandler;
 import lombok.Data;
 import org.json.JSONArray;
 
@@ -14,7 +17,7 @@ import java.io.Serializable;
 import java.time.LocalDateTime;
 import java.util.List;
 
-@TableName(value = "note_prompt")
+@TableName(value = "note_prompt",autoResultMap = true)
 @Data
 public class NotePrompt implements Serializable {
 
@@ -116,11 +119,13 @@ public class NotePrompt implements Serializable {
     /**
      * 
      */
-    private JSONArray keyword;
+    @TableField(typeHandler = JacksonTypeHandler.class)
+    private List<String> keyword;
 
     /**
      * 
      */
+    @TableField(typeHandler = JacksonTypeHandler.class)
     private JSONArray extractAttributes;
 
     /**

src/main/java/com/supervision/police/dto/AtomicData.java

@@ -1,7 +1,10 @@
 package com.supervision.police.dto;
 
+import com.supervision.police.dto.indexRule.OperandUnit;
 import lombok.Data;
 
+import java.util.List;
+
 /**
  * 原子指标逻辑
  */
@@ -13,14 +16,29 @@ public class AtomicData {
      */
     private String atomicIndex;
 
+    /**
+     * 原子指标来源
+     * 0：人工定义类型 1：数据库查询类型 2：图谱生成类型 3：结构提取类型
+     */
+    private String indexSource;
+
     /**
      * 原子指标逻辑
-     * 1 真实
-     * 2 虚构
      * 3 存在
      * 4 不存在
-     * 5 未知
      */
     private String relationalSymbol;
 
+    /**
+     * 组内逻辑关系
+     * 1 且
+     * 2 或
+     */
+    private String rowLogic;
+
+    /**
+     * 操作单元
+     */
+    private List<OperandUnit> operandUnitList;
+
 }

src/main/java/com/supervision/police/dto/JudgeLogic.java

@@ -1,7 +1,11 @@
 package com.supervision.police.dto;
 
+import cn.hutool.json.JSONUtil;
+import com.supervision.police.dto.indexRule.Operand;
+import com.supervision.police.dto.indexRule.OperandUnit;
 import lombok.Data;
 
+import java.util.ArrayList;
 import java.util.List;
 
 /**

src/main/java/com/supervision/police/dto/indexRule/AtomicResultContent.java

@@ -0,0 +1,28 @@
+package com.supervision.police.dto.indexRule;
+
+import lombok.Data;
+import org.springframework.context.ApplicationContext;
+
+import java.util.Map;
+
+/**
+ * 原子指标结果容器
+ */
+@Data
+public class AtomicResultContent {
+
+    private String atomicIndexId;
+
+    private String atomicIndexType;
+
+    /**
+     * 原子指标结果 -1:未知, 0:不存在, 1存在
+     */
+    private String result;
+
+
+    private Map<String, Object> properties;
+
+
+    ApplicationContext applicationContext;
+}

src/main/java/com/supervision/police/dto/indexRule/Operand.java

@@ -0,0 +1,38 @@
+package com.supervision.police.dto.indexRule;
+
+import lombok.Data;
+
+/**
+ * 操作数
+ */
+@Data
+public class Operand{
+
+    /**
+     * 原子指标id
+     */
+    private String atomicIndexId;
+
+
+    /**
+     * 属性key
+     */
+    private String propertyKey;
+
+    /**
+     * 值
+     */
+    private String value;
+
+    /**
+     *
+     * 操作数类型 0：人工定义类型 1：数据库查询类型 2：图谱生成类型 3：结构提取类型 4：值
+     */
+    private String operandType;
+
+    /**
+     * 聚合类型
+     * 0：合计 1：数量 2：任一
+     */
+    private String aggregateType;
+}

src/main/java/com/supervision/police/dto/indexRule/OperandUnit.java

@@ -0,0 +1,28 @@
+package com.supervision.police.dto.indexRule;
+
+import lombok.Data;
+
+/**
+ * 运算单元
+ */
+@Data
+public class OperandUnit {
+
+    /**
+     * 左操作数
+     */
+    private Operand leftOperand;
+
+
+    /**
+     * 操作符 > >= < <= = != 早于 晚于 包含
+     */
+    private String operator;
+
+
+    /**
+     * 右操作数 可为空
+     */
+    private Operand rightOperand;
+
+}

src/main/java/com/supervision/police/service/impl/ModelServiceImpl.java

@@ -116,6 +116,9 @@ public class ModelServiceImpl implements ModelService {
                     analyseGraphCase(analyseCaseDTO, result, ql, casePerson.getName());
                 } else if ("4".equals(atomicIndex.getIndexSource())) {
                     //
+                }else if ("5".equals(atomicIndex.getIndexSource())) {
+                    // todo: 结构化推理
+                    //analyseStructuredInference(analyseCaseDTO, result);
                 }
             } catch (Exception e) {
                 log.error(e.getMessage(), e);

src/test/java/com/supervision/demo/JudgeLogicTest.java

@@ -0,0 +1,256 @@
+package com.supervision.demo;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.json.JSONUtil;
+import com.supervision.common.utils.StringUtils;
+import com.supervision.constant.JudgeResultEnum;
+import com.supervision.police.dto.AtomicData;
+import com.supervision.police.dto.JudgeLogic;
+import com.supervision.police.dto.indexRule.Operand;
+import com.supervision.police.dto.indexRule.OperandUnit;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class JudgeLogicTest {
+
+    public static void main(String[] args) {
+
+
+    }
+
+
+    private static void dataDemo() {
+        List<JudgeLogic> judgeLogics = new ArrayList<>();
+
+
+        JudgeLogic judgeLogic = new JudgeLogic();
+        judgeLogic.setGroupLogic("1");
+        judgeLogic.setRowLogic("1");
+
+        List<AtomicData> atomicDataList = new ArrayList<>();
+        AtomicData atomicData1 = new AtomicData();
+        atomicData1.setAtomicIndex("1");
+        atomicData1.setRelationalSymbol("1");
+
+        AtomicData atomicData2 = new AtomicData();
+        atomicData2.setAtomicIndex("2");
+        atomicData2.setRelationalSymbol("2");
+        atomicData2.setRowLogic("2");
+        OperandUnit operandUnit = new OperandUnit();
+        Operand leftOperand = new Operand();
+        leftOperand.setPropertyKey("合同金额");
+        leftOperand.setAggregateType("1");
+
+        Operand operand = new Operand();
+        operand.setAtomicIndexId("22");
+        operand.setPropertyKey("合同金额");
+        operand.setAggregateType("1");
+
+        operandUnit.setLeftOperand(leftOperand);
+        operandUnit.setRightOperand(operand);
+        operandUnit.setOperator(">");
+
+        atomicData2.setOperandUnitList(List.of(operandUnit));
+
+        atomicDataList.add(atomicData1);
+        atomicDataList.add(atomicData2);
+
+        judgeLogic.setAtomicData(atomicDataList);
+
+        judgeLogics.add(judgeLogic);
+
+        System.out.println(JSONUtil.toJsonStr(judgeLogics));
+    }
+
+    private static boolean eval(List<JudgeLogic> judgeLogics) {
+        boolean finalJudgeResult = false;
+        // 遍历组
+        for (int i = 0; i < judgeLogics.size(); i++) {
+            // 组内结果
+            boolean innerGroupJudge = false;
+            JudgeLogic logic = judgeLogics.get(i);
+            // 获取组之间的的判断逻辑
+            String rowLogic = logic.getRowLogic();
+            // 首先对组内进行判断,判断组内的结果
+            List<AtomicData> atomicData = logic.getAtomicData();
+            for (int j = 0; j < atomicData.size(); j++) {
+                AtomicData data = atomicData.get(j);
+                // 先找到原子指标对应的大指标的结果
+
+
+                String atomicIndexResult = getAtomicResult(data.getAtomicIndex());
+                String relationalSymbol = data.getRelationalSymbol();
+                JudgeResultEnum instance = JudgeResultEnum.getInstance(relationalSymbol);
+                boolean ato = StrUtil.equals(atomicIndexResult, instance.getCode());
+                if (j == 0) {
+                    innerGroupJudge = ato;
+                } else if ("1".equals(rowLogic)) {
+                    innerGroupJudge = innerGroupJudge && ato;
+                } else if ("2".equals(rowLogic)) {
+                    innerGroupJudge = innerGroupJudge || ato;
+                }
+            }
+            // 组间进行判断
+            String groupLogic = logic.getGroupLogic();
+            if (i == 0) {
+                finalJudgeResult = innerGroupJudge;
+            } else {
+                // 如果组间判断为1 与,则进行与操作
+                if ("1".equals(groupLogic)) {
+                    finalJudgeResult = finalJudgeResult && innerGroupJudge;
+                    // 如果组间判断为或,则进行或操作
+                } else if ("2".equals(groupLogic)) {
+                    finalJudgeResult = finalJudgeResult || innerGroupJudge;
+                }
+            }
+        }
+        return finalJudgeResult;
+    }
+
+
+    private static boolean eval1(List<JudgeLogic> judgeLogics) {
+        boolean finalJudgeResult = false;
+
+        // 遍历每个 JudgeLogic（条件组）
+        for (int i = 0; i < judgeLogics.size(); i++) {
+            JudgeLogic logic = judgeLogics.get(i);
+            // 组内逻辑 ("1" 表示 AND，"2" 表示 OR)
+            String rowLogic = logic.getRowLogic();
+
+            // 计算当前组的判断结果
+            boolean innerGroupJudge = calculateGroupResult(logic.getAtomicData(), rowLogic);
+
+            // 根据组间逻辑 ("1" 表示 AND，"2" 表示 OR) 更新最终判断结果
+            if (i == 0) {
+                finalJudgeResult = innerGroupJudge;
+            } else {
+                finalJudgeResult = applyGroupLogic(finalJudgeResult, innerGroupJudge, logic.getGroupLogic());
+            }
+        }
+        return finalJudgeResult;
+    }
+
+    private static boolean calculateGroupResult(List<AtomicData> atomicDataList, String rowLogic) {
+        // 如果 atomicDataList 为空，直接返回 false
+        if (atomicDataList == null || atomicDataList.isEmpty()) {
+            return false;
+        }
+
+        boolean groupResult = false;
+
+        // 遍历 atomicDataList，根据组内逻辑计算组内判断结果
+        for (int i = 0; i < atomicDataList.size(); i++) {
+            AtomicData data = atomicDataList.get(i);
+
+            String rowLogic1 = data.getRowLogic();
+            List<OperandUnit> operandUnitList = data.getOperandUnitList();
+            // 获取原子指标对应的大指标的计算结果
+            String atomicIndexResult = getAtomicResult(data.getAtomicIndex());
+
+            // 获取运算符并计算当前原子指标是否满足条件
+            String relationalSymbol = data.getRelationalSymbol();
+            JudgeResultEnum instance = JudgeResultEnum.getInstance(relationalSymbol);
+            boolean currentResult = StrUtil.equals(atomicIndexResult, instance.getCode());
+
+            // 更新组内的判断结果
+            if (i == 0) {
+                groupResult = currentResult;
+            } else {
+                groupResult = applyRowLogic(groupResult, currentResult, rowLogic);
+            }
+        }
+        return groupResult;
+    }
+
+    private static boolean calculateOperandUnit(List<OperandUnit> operandUnitList, String rowLogic) {
+        // 如果 operandUnitList 为空，直接返回 false
+        if (operandUnitList == null || operandUnitList.isEmpty()) {
+            return false;
+        }
+
+        boolean groupResult = false;
+
+        // 遍历 atomicDataList，根据组内逻辑计算组内判断结果
+        /*for (int i = 0; i < operandUnitList.size(); i++) {
+            OperandUnit operandUnit = operandUnitList.get(i);
+
+            Operand leftOperand = operandUnit.getLeftOperand();
+
+            Object leftOperandValue = calculateOperand(leftOperand);
+            String operator = operandUnit.getOperator();
+            Object rightOperandValue = calculateOperand(operandUnit.getRightOperand());
+
+            // todo: 规则引擎表达式计算出结果
+            // 获取原子指标对应的大指标的计算结果
+            String atomicIndexResult = getAtomicResult(data.getAtomicIndex());
+
+            // 获取运算符并计算当前原子指标是否满足条件
+            String relationalSymbol = data.getRelationalSymbol();
+            JudgeResultEnum instance = JudgeResultEnum.getInstance(relationalSymbol);
+            boolean currentResult = StrUtil.equals(atomicIndexResult, instance.getCode());
+
+            // 更新组内的判断结果
+            if (i == 0) {
+                groupResult = currentResult;
+            } else {
+                groupResult = applyRowLogic(groupResult, currentResult, rowLogic);
+            }
+        }*/
+        return groupResult;
+    }
+
+    private static Object calculateOperand(Operand operand) {
+        // 根据 operandType 获取对应的值
+
+        Object value = null;
+        String operandType = operand.getOperandType();
+        if ("4".equals(operandType)) {
+            value = operand.getValue();
+        }
+        if ("property".equals(operandType)) {
+            value =  getPropertyValue(operand);
+        }
+
+
+        // todo: 聚合计算
+        return null;
+    }
+
+    private static Object getPropertyValue(Operand operand) {
+        String atomicIndexId = operand.getAtomicIndexId();
+        String propertyKey = operand.getPropertyKey();
+        return null;
+    }
+
+    private static Object getAggregateValue(String aggregateType, String value) {
+        return null;
+    }
+
+    private static boolean applyRowLogic(boolean existingResult, boolean newResult, String rowLogic) {
+        // 根据 rowLogic ("1" 表示 AND，"2" 表示 OR) 计算组内结果
+        if ("1".equals(rowLogic)) {
+            return existingResult && newResult;
+        } else if ("2".equals(rowLogic)) {
+            return existingResult || newResult;
+        }
+        return existingResult;
+    }
+
+    private static boolean applyGroupLogic(boolean existingResult, boolean newResult, String groupLogic) {
+        // 根据 groupLogic ("1" 表示 AND，"2" 表示 OR) 计算组间结果
+        if ("1".equals(groupLogic)) {
+            return existingResult && newResult;
+        } else if ("2".equals(groupLogic)) {
+            return existingResult || newResult;
+        }
+        return existingResult;
+    }
+
+
+    private static String getAtomicResult(String atomicIndexId) {
+        return null;
+    }
+}