push

yd-csf-api/pom.xml

@@ -91,6 +91,12 @@
             <artifactId>yd-insurance-base-feign</artifactId>
             <version>${project.version}</version>
         </dependency>
+
+        <!-- 在 pom.xml 中添加 -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-jdbc</artifactId>
+        </dependency>
     </dependencies>
 
     <build>

yd-csf-api/src/main/java/com/yd/csf/api/dto/AlgorithmDto.java

+package com.yd.csf.api.dto;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import java.util.List;
+
+/**
+ * 算法DTO - 公共入参封装
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class AlgorithmDto {
+
+    /**
+     * 转介人业务ID（客户端用户表唯一业务ID）
+     */
+    private String brokerBizId;
+
+    /**
+     * 基本法配置表唯一业务ID（业务员绑定的基本法类型（类型中含多个基本法项目（基本法项目绑定公式）））
+     */
+    private String ruleBizId;
+
+    /**
+     * 基本法项目配置表唯一业务ID
+     */
+    private String ruleItemBizId;
+
+    /**
+     * 公式配置表唯一业务ID
+     */
+    private String formulaBizId;
+
+    /**
+     * 变量表业务ID集合列表
+     */
+    private List<String> variableBizIdList;
+
+    /**
+     * SQL模板表唯一业务ID
+     */
+    private String sqlTemplateBizId;
+
+    /**
+     * SQL模板条件入参参数及参数值对象（通用，用于各种SQL模板计算值入参条件参数值，这边集成大部分SQL模所需的条件参数，SQL模板会去匹配入参sqlTemplateParamDto有符合的就作为条件参数）
+     */
+    private SqlTemplateParamDto sqlTemplateParamDto;
+
+    /**
+     * 需要执行的基本法项目的执行顺序下标值列表（为空就是执行全部项目）
+     */
+    private List<Integer> executionOrderList;
+
+    /**
+     * 需要执行的基本法项目的执行顺序下标值列表是否取反执行（true-取反就是非executionOrderList的列表执行，false-不取反就是executionOrderList的列表执行）
+     */
+    private Boolean isNegateExecutionOrderList;
+}

yd-csf-api/src/main/java/com/yd/csf/api/dto/AlgorithmResDto.java

+package com.yd.csf.api.dto;
+
+import lombok.Data;
+
+import java.math.BigDecimal;
+import java.util.List;
+
+/**
+ * 算法-基本法计算-返回的对象
+ */
+@Data
+public class AlgorithmResDto {
+
+
+    /**
+     * 基本法配置表唯一业务ID（基本法类型）
+     */
+    private String ruleBizId;
+
+    /**
+     * 基本法项目配置表唯一业务ID
+     */
+    private String ruleItemBizId;
+
+    /**
+     * 计算值 - sqlAlgorithmResultDtoList集合里面的计算值和值
+     */
+    private BigDecimal calculatedValue;
+
+    /**
+     * 当前变量绑定的SQL模板计算结果集合列表（含计算值，以及计算值的提供者等等）（sql语句返回多个值作为算子计算）
+     */
+    private List<SqlAlgorithmResultDto> sqlAlgorithmResultDtoList;
+}

yd-csf-api/src/main/java/com/yd/csf/api/dto/GenerateAgentDetailFycDto.java

+package com.yd.csf.api.dto;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+/**
+ * 生成业务员（转介人）积分明细表记录入参
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class GenerateAgentDetailFycDto {
+
+    /**
+     * 业务员ID（客户端用户表唯一业务ID，转介人业务ID）
+     */
+    private String agentId;
+
+    /**
+     * 积分来源类型：保单转介费、一级管理奖、二级管理奖、辅导津贴奖、终身推荐奖
+     */
+    private String sourceType;
+
+    /**
+     * 积分提供的保单号
+     */
+    private String policyNo;
+
+    /**
+     * 保单发佣批次ID
+     */
+    private String batchBizId;
+
+    /**
+     * 转介人绑定的基本法列表对应计算值
+     */
+    private List<AlgorithmResDto> algorithmResDtoList;
+}

yd-csf-api/src/main/java/com/yd/csf/api/dto/RuleItemAlgorithmDto.java

+package com.yd.csf.api.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.math.BigDecimal;
+
+/**
+ * 基本法项目出参
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class RuleItemAlgorithmDto {
+
+    /**
+     * 基本法配置表唯一业务ID（基本法类型）
+     */
+    private String ruleBizId;
+
+    /**
+     * 基本法项目配置表唯一业务ID
+     */
+    private String ruleItemBizId;
+
+    /**
+     * 计算值
+     */
+    private BigDecimal calculatedValue;
+
+}

yd-csf-api/src/main/java/com/yd/csf/api/dto/SqlAlgorithmResultDto.java

+package com.yd.csf.api.dto;
+
+import lombok.Data;
+
+/**
+ * 执行SQL模板语句，返回的对象封装
+ */
+@Data
+public class SqlAlgorithmResultDto {
+
+    /**
+     * 计算的积分值提供者（业务员-客户端用户业务ID）
+     */
+    private String provider;
+
+    /**
+     * 计算值
+     */
+    private String calculatedValue;
+
+    //TODO 后续扩展
+}

yd-csf-api/src/main/java/com/yd/csf/api/dto/SqlTemplateParamDto.java

+package com.yd.csf.api.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * SQL模板条件入参参数及参数值对象（通用，用于各种SQL模板计算值入参条件参数值，这边集成大部分SQL模所需的条件参数，SQL模板会去匹配入参sqlTemplateParamDto有符合的就作为条件参数）
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class SqlTemplateParamDto {
+
+    /**
+     * 条件类型表唯一业务ID
+     */
+    private String conditionTypeBizId;
+
+    /**
+     * 保单号
+     */
+    private String policyNo;
+
+    /**
+     * 产品代码
+     */
+    private String productCode;
+
+    /**
+     * 保单绑定转介人业务ID（销售业务员，客户端用户表唯一业务ID）
+     */
+    private String brokerBizId;
+}

yd-csf-api/src/main/java/com/yd/csf/api/dto/VariableAlgorithmDto.java

+package com.yd.csf.api.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+/**
+ * 变量算法出参公共封装DTO
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class VariableAlgorithmDto {
+
+    /**
+     * 变量表唯一业务ID
+     */
+    private String variableBizId;
+
+    /**
+     * 变量编码
+     */
+    private String variableCode;
+
+    /**
+     * 变量名称中文名
+     */
+    private String nameCn;
+
+    /**
+     * 计算值 - sqlAlgorithmResultDtoList集合里面的计算值和值
+     */
+    private String calculatedValue;
+
+    /**
+     * 当前变量绑定的SQL模板计算结果集合列表（含计算值，以及计算值的提供者等等）
+     */
+    private List<SqlAlgorithmResultDto> sqlAlgorithmResultDtoList;
+}

yd-csf-api/src/main/java/com/yd/csf/api/service/ApiAgentDetailFycService.java

+package com.yd.csf.api.service;
+
+import com.yd.common.result.Result;
+import com.yd.csf.api.dto.GenerateAgentDetailFycDto;
+
+public interface ApiAgentDetailFycService {
+
+    Result saveAgentDetailFyc(GenerateAgentDetailFycDto dto);
+}

yd-csf-api/src/main/java/com/yd/csf/api/service/impl/ApiAgentDetailFycServiceImpl.java

+package com.yd.csf.api.service.impl;
+
+import com.yd.common.result.Result;
+import com.yd.csf.api.dto.AlgorithmResDto;
+import com.yd.csf.api.dto.GenerateAgentDetailFycDto;
+import com.yd.csf.api.dto.SqlAlgorithmResultDto;
+import com.yd.csf.api.service.ApiAgentDetailFycService;
+import com.yd.csf.service.model.AgentAccumulatedFyc;
+import com.yd.csf.service.model.AgentDetailFyc;
+import com.yd.csf.service.service.IAgentAccumulatedFycService;
+import com.yd.csf.service.service.IAgentDetailFycService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+@Slf4j
+@Service
+public class ApiAgentDetailFycServiceImpl implements ApiAgentDetailFycService {
+
+    @Autowired
+    private IAgentDetailFycService iAgentDetailFycService;
+
+    @Autowired
+    private IAgentAccumulatedFycService iAgentAccumulatedFycService;
+
+    /**
+     * 基本法计算 - 保存积分明细表
+     * @param dto
+     * @return
+     */
+    @Override
+    public Result saveAgentDetailFyc(GenerateAgentDetailFycDto dto) {
+        List<AlgorithmResDto> algorithmResDtoList = dto.getAlgorithmResDtoList();
+        List<AgentDetailFyc> agentDetailFycList = new ArrayList<>();
+        //根据业务员ID查询业务员累计积分表
+        AgentAccumulatedFyc agentAccumulatedFyc = iAgentAccumulatedFycService.queryOne(dto.getAgentId());
+        BigDecimal totalFyc = BigDecimal.ZERO;
+        if (!Objects.isNull(agentAccumulatedFyc)) {
+            totalFyc = agentAccumulatedFyc.getTotalFyc();
+        }
+        if (!CollectionUtils.isEmpty(algorithmResDtoList)) {
+            for (AlgorithmResDto algorithmResDto : algorithmResDtoList){
+
+                if (!CollectionUtils.isEmpty(algorithmResDto.getSqlAlgorithmResultDtoList())) {
+                    for (SqlAlgorithmResultDto sqlAlgorithmResultDto : algorithmResDto.getSqlAlgorithmResultDtoList()) {
+                        AgentDetailFyc agentDetailFyc = new AgentDetailFyc();
+                        //变化前的业务员总FYC积分 -> 查询
+                        agentDetailFyc.setBeforeFyc(totalFyc);
+                        //累加积分值
+                        totalFyc = totalFyc.add(new BigDecimal(sqlAlgorithmResultDto.getCalculatedValue()));
+                        //变化值（-代表减少）
+                        agentDetailFyc.setChangeFyc(sqlAlgorithmResultDto.getCalculatedValue());
+                        //变化后的业务员总FYC积分
+                        agentDetailFyc.setAfterFyc(totalFyc);
+                        //业务员ID（客户端用户表唯一业务ID）获取积分的人
+                        agentDetailFyc.setAgentId(dto.getAgentId());
+                        //积分来源类型 TODO
+//                        agentDetailFyc.setSourceType();
+                        //积分来源基本法项目配置表唯一业务ID
+                        agentDetailFyc.setRuleItemBizId(algorithmResDto.getRuleItemBizId());
+                        //保单发佣批次ID
+                        agentDetailFyc.setBatchBizId(dto.getBatchBizId());
+                        //积分提供保单表唯一业务ID
+                        agentDetailFyc.setPolicyBizId(dto.getPolicyBizId());
+                        //积分提供者（客户端用户表唯一业务ID）
+                        agentDetailFyc.setProvideId(sqlAlgorithmResultDto.getProvider());
+                        agentDetailFycList.add(agentDetailFyc);
+                    }
+                }else {
+                    AgentDetailFyc agentDetailFyc = new AgentDetailFyc();
+                    //变化前的业务员总FYC积分 -> 查询
+                    agentDetailFyc.setBeforeFyc(totalFyc);
+                    //累加积分值
+                    totalFyc = totalFyc.add(algorithmResDto.getCalculatedValue());
+                    //变化值（-代表减少）
+                    agentDetailFyc.setChangeFyc(algorithmResDto.getCalculatedValue().toString());
+                    //变化后的业务员总FYC积分
+                    agentDetailFyc.setAfterFyc(totalFyc);
+                    //业务员ID（客户端用户表唯一业务ID）获取积分的人
+                    agentDetailFyc.setAgentId(dto.getAgentId());
+                    //积分来源类型 TODO
+//                        agentDetailFyc.setSourceType();
+                    //积分来源基本法项目配置表唯一业务ID
+                    agentDetailFyc.setRuleItemBizId(algorithmResDto.getRuleItemBizId());
+                    //保单发佣批次ID
+                    agentDetailFyc.setBatchBizId(dto.getBatchBizId());
+                    //积分提供保单表唯一业务ID
+                    agentDetailFyc.setPolicyBizId(dto.getPolicyBizId());
+                    //积分提供者（客户端用户表唯一业务ID）
+//                    agentDetailFyc.setProvideId(sqlAlgorithmResultDto.getProvider());
+                    agentDetailFycList.add(agentDetailFyc);
+                }
+            }
+        }
+
+        if (!CollectionUtils.isEmpty(agentDetailFycList)) {
+            //保存积分明细
+            iAgentDetailFycService.saveOrUpdateBatch(agentDetailFycList);
+
+            //更新累计积分表的业务员的累计积分字段值
+            if (!Objects.isNull(agentAccumulatedFyc)) {
+                agentAccumulatedFyc.setTotalFyc(totalFyc);
+                iAgentAccumulatedFycService.saveOrUpdate(agentAccumulatedFyc);
+            }
+        }
+        return Result.success();
+    }
+
+}

yd-csf-api/src/main/java/com/yd/csf/api/service/impl/ApiBasicLawCalculateServiceImpl.java

@@ -2,29 +2,30 @@ package com.yd.csf.api.service.impl;
 
 import com.yd.common.exception.BusinessException;
 import com.yd.common.result.Result;
+import com.yd.csf.api.dto.*;
+import com.yd.csf.api.service.ApiAgentDetailFycService;
 import com.yd.csf.api.service.ApiBasicLawCalculateService;
+import com.yd.csf.api.utils.FormulaParser;
+import com.yd.csf.feign.enums.VariableEnum;
 import com.yd.csf.feign.request.basiclawcalculate.ApiGenerateBillingRequest;
 import com.yd.csf.feign.response.basiclawcalculate.ApiGenerateBillingResponse;
-import com.yd.csf.service.dto.CommissionDto;
-import com.yd.csf.service.dto.PolicyDto;
-import com.yd.csf.service.dto.QueryPolicyBrokerDto;
-import com.yd.csf.service.model.Commission;
-import com.yd.csf.service.model.Policy;
-import com.yd.csf.service.model.PolicyBroker;
-import com.yd.csf.service.service.CommissionService;
-import com.yd.csf.service.service.PolicyBrokerService;
-import com.yd.csf.service.service.PolicyService;
+import com.yd.csf.service.dto.*;
+import com.yd.csf.service.model.*;
+import com.yd.csf.service.service.*;
 import com.yd.insurance.base.feign.client.ApiRelProductAnnouncementFeignClient;
-import com.yd.insurance.base.feign.dto.ApiProductRatioDto;
-import com.yd.insurance.base.feign.request.ApiQueryRatioRequest;
-import com.yd.insurance.base.feign.response.ApiQueryRatioResponse;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
 import org.springframework.stereotype.Service;
 import org.springframework.util.CollectionUtils;
-
-import java.util.ArrayList;
-import java.util.List;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+import javax.sql.DataSource;
+import java.math.BigDecimal;
+import java.util.*;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
@@ -44,6 +45,43 @@ public class ApiBasicLawCalculateServiceImpl implements ApiBasicLawCalculateServ
     @Autowired
     private PolicyBrokerService policyBrokerService;
 
+    @Autowired
+    private IFormulaConfigService iFormulaConfigService;
+
+    @Autowired
+    private IVariableService iVariableService;
+
+    @Autowired
+    private IRelObjectConditionService iRelObjectConditionService;
+
+    @Autowired
+    private IRelObjectSqlService iRelObjectSqlService;
+
+    @Autowired
+    private ICommissionSqlTemplateService iCommissionSqlTemplateService;
+
+    @Autowired
+    private IRuleItemConfigService iRuleItemConfigService;
+
+    @Autowired
+    private IRelObjectFormulaService iRelObjectFormulaService;
+
+    @Autowired
+    private ICommissionRuleBindingService iCommissionRuleBindingService;
+
+    @Autowired
+    private ApiAgentDetailFycService apiAgentDetailFycService;
+
+    /**
+     * 获取JdbcTemplate（需要注入）
+     */
+    @Autowired
+    private DataSource dataSource;
+
+    private NamedParameterJdbcTemplate getJdbcTemplate() {
+        return new NamedParameterJdbcTemplate(dataSource);
+    }
+
     /**
      * 生成出账
      * @param request
@@ -56,37 +94,19 @@ public class ApiBasicLawCalculateServiceImpl implements ApiBasicLawCalculateServ
         if (CollectionUtils.isEmpty(commissionList)) {
             throw new BusinessException("来佣数据不存在");
         }
-        // 根据保单号分组，取每组的第一条, 获取最后的去重的来佣列表
+        //根据保单号分组，取每组的第一条, 获取最后的去重的来佣列表
         List<Commission> distinctCommissionList = commissionList.stream()
                 .collect(Collectors.collectingAndThen(
                         Collectors.toMap(
-                                Commission::getPolicyNo,  // 保单号作为key
-                                Function.identity(),      // Commission对象本身作为value
-                                (existing, replacement) -> existing  // 遇到重复key时保留已存在的
+                                Commission::getPolicyNo,  //保单号作为key
+                                Function.identity(),      //Commission对象本身作为value
+                                (existing, replacement) -> existing  //遇到重复key时保留已存在的
                         ),
                         map -> new ArrayList<>(map.values())));
         //获取保单号列表
         List<String> policyNoList = distinctCommissionList.stream().map(Commission::getPolicyNo).collect(Collectors.toList());
         //查询保单列表信息
         List<Policy> policyList =  policyService.queryList(PolicyDto.builder().policyNoList(policyNoList).build());
-        //根据产品代码列表查询公告比例
-        ApiQueryRatioRequest ratioRequest = new ApiQueryRatioRequest();
-        List<ApiProductRatioDto> apiProductRatioDtoList = distinctCommissionList.stream().map(dto -> {
-            ApiProductRatioDto ratioDto = new ApiProductRatioDto();
-            if (!CollectionUtils.isEmpty(policyList)) {
-                //保单绑定的产品代码
-                List<Policy> policies = policyList.stream().filter(d -> d.getPolicyNo().equals(dto.getPolicyNo())).collect(Collectors.toList());
-                if (!CollectionUtils.isEmpty(policies)) {
-                    Policy policy = policies.get(0);
-                    ratioDto.setProductCode(policy.getProductCode());
-                }
-            }
-            //佣金期数(1=第一年; 2=第二年; 3=第三年; 4=第四年; 5=第五年等)
-            ratioDto.setCommissionPeriod(dto.getCommissionPeriod());
-            return ratioDto;
-        }).collect(Collectors.toList());
-        ratioRequest.setApiProductRatioDtoList(apiProductRatioDtoList);
-        Result<ApiQueryRatioResponse> result = apiRelProductAnnouncementFeignClient.queryRatio(ratioRequest);
 
         if (!CollectionUtils.isEmpty(policyList)) {
             //查询保单转介人（销售人员）关系数据
@@ -100,12 +120,541 @@ public class ApiBasicLawCalculateServiceImpl implements ApiBasicLawCalculateServ
                 if (!CollectionUtils.isEmpty(thisPolicyBrokerList)) {
                     //遍历当前保单绑定的转介人列表，根据人绑定的基本法项目（计算销售佣金，推荐佣金，辅导员佣金，终身推荐奖等。）绑定什么项目算什么金额，按照佣金项目执行顺序来计算。
                     for (PolicyBroker policyBroker : thisPolicyBrokerList) {
+                        //构造销售佣金基本法项目的顺序下标值执行
+                        List<Integer> executionOrderList = new ArrayList<>();
+                        executionOrderList.add(1);
+
+                        //保单出账先执行销售佣金基本法项目，入完到积分明细表里后，再执行保单绑定人的其他基本法项目
+                        Result<List<AlgorithmResDto>> result = policyBrokerAlgorithm(AlgorithmDto.builder()
+                                .brokerBizId(policyBroker.getBrokerBizId())
+                                .executionOrderList(executionOrderList)
+                                .isNegateExecutionOrderList(false)
+                                .build());
+
+                        //生成业务员（转介人）积分明细表记录（销售积分）
+                        generateAgentDetailFyc(GenerateAgentDetailFycDto.builder()
+                                .agentId(policyBroker.getBrokerBizId())
+                                .policyNo(policy.getPolicyNo())
+                                .algorithmResDtoList(result.getData())
+//                                .sourceType()
+                                .build());
+
+                        //生成保单发佣表记录
+
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
+    public Result saveBatchFortune() {
+
+    }
+    /**
+     * 生成业务员（转介人）积分明细表记录
+     * @return
+     */
+    public Result generateAgentDetailFyc(GenerateAgentDetailFycDto dto){
+        //基本法计算 - 保存积分明细表
+        apiAgentDetailFycService.saveAgentDetailFyc(dto);
+        return Result.success();
+    }
+
+    /**
+     * 算法-计算-转介人（销售业务员）绑定的基本法类型（基本法项目列表）对应的积分值
+     * @param algorithmDto
+     * @return
+     */
+    public Result<List<AlgorithmResDto>> policyBrokerAlgorithm(AlgorithmDto algorithmDto) {
+        //校验 - 转介人业务ID（客户端用户表唯一业务ID）不能为空
+        if (StringUtils.isBlank(algorithmDto.getBrokerBizId())) {
+            throw new BusinessException("转介人业务ID（客户端用户表唯一业务ID）不能为空");
+        }
+        List<CommissionRuleBinding> commissionRuleBindingList = iCommissionRuleBindingService.queryList(CommissionRuleBindingDto.builder().targetId(algorithmDto.getBrokerBizId()).build());
+        if (CollectionUtils.isEmpty(commissionRuleBindingList)) {
+            throw new BusinessException("业务员基本法绑定信息不存在");
+        }
+        CommissionRuleBinding commissionRuleBinding = commissionRuleBindingList.get(0);
+        algorithmDto.setRuleBizId(commissionRuleBinding.getRuleBizId());
+        return commissionRuleAlgorithm(algorithmDto);
+    }
+
+    /**
+     * 算法-计算-基本法类型
+     * @param algorithmDto 算法DTO - 公共入参封装
+     * @return
+     */
+    public Result<List<AlgorithmResDto>> commissionRuleAlgorithm(AlgorithmDto algorithmDto) {
+        //校验 - 基本法配置表唯一业务ID不能为空
+        if (StringUtils.isBlank(algorithmDto.getRuleBizId())) {
+            throw new BusinessException("基本法配置表唯一业务ID不能为空");
+        }
+        //查询基本法类型绑定的基本法项目列表 - 执行顺序，数值越小越先执行，用于控制佣金项目的计算顺序
+        List<RuleItemConfig> ruleItemConfigList = iRuleItemConfigService.queryList(RuleItemConfigDto.builder().ruleBizId(algorithmDto.getRuleBizId()).build());
+        if (CollectionUtils.isEmpty(ruleItemConfigList)) {
+            throw new BusinessException("基本法项目列表不存在");
+        }
+        List<AlgorithmResDto> algorithmResDtoList = new ArrayList<>();
+        //遍历基本法项目 - 计算对应值
+        for (RuleItemConfig ruleItemConfig : ruleItemConfigList) {
+            if (!CollectionUtils.isEmpty(algorithmDto.getExecutionOrderList())) {
+                //基本法项目执行顺序和是否在需要执行的基本法项目的执行顺序下标值列表中
+                List<Integer> isExistList = algorithmDto.getExecutionOrderList().stream().filter(s -> s.equals(ruleItemConfig.getExecutionOrder())).collect(Collectors.toList());
+                //需要执行的基本法项目的执行顺序下标值列表（为空就是执行全部项目）
+                if (algorithmDto.getIsNegateExecutionOrderList() && !CollectionUtils.isEmpty(isExistList)) {
+                    //取反并且isExistList非空 -> 跳出当前循环
+                    continue;
+                }
+                if (!algorithmDto.getIsNegateExecutionOrderList() && CollectionUtils.isEmpty(isExistList)) {
+                    //非取反并且isExistList空 -> 跳出当前循环
+                    continue;
+                }
+            }
+            algorithmDto.setRuleItemBizId(ruleItemConfig.getRuleItemBizId());
+            //算法-计算-基本法项目
+            Result<AlgorithmResDto> result = ruleItemAlgorithm(algorithmDto);
+            algorithmResDtoList.add(result.getData());
+        }
+        return Result.success(algorithmResDtoList);
+    }
+
+    /**
+     * 算法-计算-基本法项目
+     * @param algorithmDto 算法DTO - 公共入参封装
+     * @return
+     */
+    public Result<AlgorithmResDto> ruleItemAlgorithm(AlgorithmDto algorithmDto) {
+        //校验 - 基本法项目配置表唯一业务ID不能为空
+        if (StringUtils.isBlank(algorithmDto.getRuleItemBizId())) {
+            throw new BusinessException("基本法项目配置表唯一业务ID不能为空");
+        }
+        //查询对象公式关系 - 即基本法项目和公式关系数据
+        List<RelObjectFormula> relObjectFormulaList = iRelObjectFormulaService.queryList(RelObjectFormulaDto.builder().objectBizId(algorithmDto.getRuleItemBizId()).build());
+        if (CollectionUtils.isEmpty(relObjectFormulaList)) {
+            throw new BusinessException("基本法项目和公式关系数据不存在");
+        }
+        RelObjectFormula relObjectFormula = relObjectFormulaList.get(0);
+        //公式配置表唯一业务ID
+        algorithmDto.setFormulaBizId(relObjectFormula.getFormulaBizId());
+        Result<AlgorithmResDto> result = calculationFormulaAlgorithm(algorithmDto);
+        AlgorithmResDto dto = result.getData();
+        dto.setRuleBizId(algorithmDto.getRuleBizId());
+        dto.setRuleItemBizId(algorithmDto.getRuleItemBizId());
+        return Result.success(dto);
+    }
+
+    /**
+     * 算法-计算-公式
+     * @param algorithmDto 算法DTO - 公共入参封装
+     * @return
+     */
+    public Result<AlgorithmResDto> calculationFormulaAlgorithm(AlgorithmDto algorithmDto) {
+        AlgorithmResDto resDto = new AlgorithmResDto();
+        //校验算法DTO入参
+        checkAlgorithmDto(algorithmDto);
+        //获取计算公式对象
+        FormulaConfig formulaConfig = iFormulaConfigService.queryOne(algorithmDto.getFormulaBizId());
+        if (Objects.isNull(formulaConfig)) {
+            throw new BusinessException("计算公式对象不存在");
+        }
+        //获取计算公式（变量表唯一业务ID组合）
+        String calculationFormulaBizId = formulaConfig.getCalculationFormulaBizId();
+        if (StringUtils.isBlank(calculationFormulaBizId)) {
+            throw new BusinessException("获取计算公式（变量表唯一业务ID组合）不存在");
+        }
+        //解析计算公式-获取用到的变量表业务ID集合列表
+        //从公式字符串中解析出所有变量业务ID（返回列表，保持顺序）
+        List<String> variableBizIdList = new ArrayList<>();
+        try {
+            variableBizIdList = FormulaParser.parseVariableBizIdsOrdered(calculationFormulaBizId);
+        }catch (Exception e) {
+            throw new BusinessException("从公式字符串中解析出所有变量业务ID，解析失败");
+        }
+        //检测解析出来的变量表业务ID集合列表是否存在
+        if (CollectionUtils.isEmpty(variableBizIdList)) {
+            throw new BusinessException("解析计算公式-获取用到的变量表业务ID集合列表不存在");
+        }
+        //变量表业务ID集合列表去重
+        variableBizIdList = variableBizIdList.stream().distinct().collect(Collectors.toList());
+        algorithmDto.setVariableBizIdList(variableBizIdList);
+        //算法-计算-变量
+        Result<List<VariableAlgorithmDto>> variableResult = variableAlgorithm(algorithmDto);
+        if (variableResult.getCode() != 200) {
+            throw new BusinessException("变量计算失败: " + variableResult.getMsg());
+        }
+
+        List<VariableAlgorithmDto> variableValues = variableResult.getData();
+
+        //将变量值代入计算公式进行计算
+        BigDecimal result = evaluateFormula(calculationFormulaBizId, variableValues);
+
+        resDto.setCalculatedValue(result);
+
+        //TODO 前变量绑定的SQL模板计算结果集合列表（含计算值，以及计算值的提供者等等）
+//        resDto.setSqlAlgorithmResultDtoList();
+        return Result.success(resDto);
+    }
+
+    /**
+     * 计算公式 - 将变量值代入公式进行计算
+     * @param formula 公式字符串，如："(variable_1001 + variable_2123) * variable_4455"
+     * @param variableValues 变量值列表
+     * @return 计算结果
+     */
+    private BigDecimal evaluateFormula(String formula, List<VariableAlgorithmDto> variableValues) {
+        try {
+            //创建变量值映射表
+            Map<String, BigDecimal> variableMap = new HashMap<>();
+            for (VariableAlgorithmDto variable : variableValues) {
+                if (StringUtils.isNotBlank(variable.getCalculatedValue())) {
+                    try {
+                        BigDecimal value = new BigDecimal(variable.getCalculatedValue());
+                        variableMap.put(variable.getVariableBizId(), value);
+                    } catch (NumberFormatException e) {
+                        throw new BusinessException("变量值格式错误: " + variable.getVariableBizId() + " = " + variable.getCalculatedValue());
+                    }
+                }
+            }
+
+            //替换公式中的变量业务ID为实际数值
+            String expression = replaceVariablesWithValues(formula, variableMap);
+
+            //计算表达式
+            return calculateExpression(expression);
+
+        } catch (Exception e) {
+            log.error("计算公式失败, formula: {}, variables: {}", formula, variableValues, e);
+            throw new BusinessException("计算公式失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 将公式中的变量业务ID替换为实际数值
+     * @param formula 原始公式
+     * @param variableMap 变量映射表
+     * @return 替换后的表达式
+     */
+    private String replaceVariablesWithValues(String formula, Map<String, BigDecimal> variableMap) {
+        String expression = formula;
 
+        //按变量业务ID长度从长到短排序，避免替换时出现部分匹配的问题
+        List<String> sortedKeys = variableMap.keySet().stream()
+                .sorted((a, b) -> Integer.compare(b.length(), a.length()))
+                .collect(Collectors.toList());
+
+        for (String variableBizId : sortedKeys) {
+            BigDecimal value = variableMap.get(variableBizId);
+            if (value != null) {
+                //将变量业务ID替换为数值，确保完全匹配
+                expression = expression.replace(variableBizId, value.toString());
+            }
+        }
+
+        //检查是否还有未替换的变量
+        if (containsUnreplacedVariables(expression)) {
+            throw new BusinessException("公式中存在未计算的变量: " + expression);
+        }
+
+        return expression;
+    }
+
+    /**
+     * 检查表达式中是否还有未替换的变量
+     */
+    private boolean containsUnreplacedVariables(String expression) {
+        //假设变量业务ID的格式是 "variable_" 开头
+        return expression.matches(".*variable_\\w+.*");
+    }
+
+    /**
+     * 计算数学表达式
+     * @param expression 数学表达式，如："(100.5 + 200.3) * 50.2"
+     * @return 计算结果
+     */
+    private BigDecimal calculateExpression(String expression) {
+        try {
+            //使用JavaScript引擎计算表达式
+            ScriptEngineManager manager = new ScriptEngineManager();
+            ScriptEngine engine = manager.getEngineByName("JavaScript");
+
+            //计算表达式
+            Object result = engine.eval(expression);
+
+            //转换为BigDecimal
+            if (result instanceof Number) {
+                return new BigDecimal(result.toString());
+            } else {
+                throw new BusinessException("表达式计算结果不是数字类型: " + result);
+            }
+
+        } catch (ScriptException e) {
+            throw new BusinessException("表达式计算失败: " + expression + ", 错误: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 算法-计算-变量
+     * @param algorithmDto 算法DTO - 公共入参封装
+     * @return
+     */
+    public Result<List<VariableAlgorithmDto>> variableAlgorithm(AlgorithmDto algorithmDto) {
+        //校验算法DTO入参
+        checkAlgorithmDto(algorithmDto);
+        //查询变量表列表信息
+        List<Variable> variableList = iVariableService.queryList(VariableDto.builder()
+                .variableBizIdList(algorithmDto.getVariableBizIdList())
+                .build());
+        if (CollectionUtils.isEmpty(variableList)) {
+            throw new BusinessException("变量表列表信息不存在");
+        }
+        List<VariableAlgorithmDto> variableAlgorithmDtoList = new ArrayList<>();
+        //遍历变量列表 - 计算对应的值
+        for (Variable variable : variableList) {
+            VariableAlgorithmDto dto = new VariableAlgorithmDto();
+            BeanUtils.copyProperties(variable,dto);
+            //变量类型 - 固定值
+            if (VariableEnum.FIXED_VALUE.getItemValue().equals(variable.getType())) {
+                //固定值，直接取出固定值返回作为公式计算的值
+                dto.setCalculatedValue(variable.getValue());
+            }else if (VariableEnum.DYNAMIC_COMPUTATION.getItemValue().equals(variable.getType())){
+                //动态计算值 - 结合通用入参参数、条件、SQL模板计算出值
+                //校验 - 动态计算必须绑定SQL模板。查询对象和SQL模板配置关系表
+                List<RelObjectSql> relObjectSqlList = iRelObjectSqlService.queryList(RelObjectSqlDto.builder().objectBizId(variable.getVariableBizId()).build());
+                if (CollectionUtils.isEmpty(relObjectSqlList)) {
+                    throw new BusinessException("动态计算的变量必须要绑定SQL模板");
+                }
+                RelObjectSql relObjectSql = relObjectSqlList.get(0);
+                //SQL模板表唯一业务ID
+                algorithmDto.setSqlTemplateBizId(relObjectSql.getSqlTemplateBizId());
+                if (Objects.isNull(algorithmDto.getSqlTemplateParamDto())) {
+                    //对象空构造空对象
+                    algorithmDto.setSqlTemplateParamDto(new SqlTemplateParamDto());
+                }
+                //先查询是否有关联条件：有关联条件作为SQL模板的判断依据，有关联条件就查询关联条件类型业务ID带入到SQL模板关联查询判断条件情况。
+                List<RelObjectCondition> relObjectConditionList = iRelObjectConditionService.queryList(RelObjectConditionDto.builder()
+                        .objectBizId(variable.getVariableBizId())
+                        .build());
+                if (!CollectionUtils.isEmpty(relObjectConditionList)) {
+                    RelObjectCondition relObjectCondition = relObjectConditionList.get(0);
+                    //有关联条件就查询关联条件类型业务ID带入到SQL模板关联查询判断条件情况
+                    algorithmDto.getSqlTemplateParamDto().setConditionTypeBizId(relObjectCondition.getConditionTypeBizId());
+                }
+
+                //执行 - 算法 - SQL模板
+                Result<List<SqlAlgorithmResultDto>> result = sqlAlgorithm(algorithmDto);
+
+                // 设置SQL模板计算结果列表
+                dto.setSqlAlgorithmResultDtoList(result.getData());
+
+                // 计算值 - 对sqlAlgorithmResultDtoList中所有calculatedValue求和
+                if (result.getData() != null && !result.getData().isEmpty()) {
+                    BigDecimal sum = BigDecimal.ZERO;
+                    for (SqlAlgorithmResultDto sqlResult : result.getData()) {
+                        if (StringUtils.isNotBlank(sqlResult.getCalculatedValue())) {
+                            try {
+                                BigDecimal value = new BigDecimal(sqlResult.getCalculatedValue());
+                                sum = sum.add(value);
+                            } catch (NumberFormatException e) {
+                                log.warn("计算值格式错误，跳过: {}", sqlResult.getCalculatedValue());
+                            }
+                        }
+                    }
+                    dto.setCalculatedValue(sum.toString());
+                } else {
+                    dto.setCalculatedValue("0"); // 默认值
+                }
+            }
+            variableAlgorithmDtoList.add(dto);
+        }
+        return Result.success(variableAlgorithmDtoList);
+    }
+
+    /**
+     * 算法 - 执行 - SQL模板
+     * @param algorithmDto
+     * @return
+     */
+    public Result<List<SqlAlgorithmResultDto>> sqlAlgorithm(AlgorithmDto algorithmDto) {
+        //SQL模板表唯一业务ID非空
+        if (StringUtils.isBlank(algorithmDto.getSqlTemplateBizId())) {
+            throw new BusinessException("SQL模板表唯一业务ID不能为空");
+        }
+        //查询SQL模板对象
+        CommissionSqlTemplate commissionSqlTemplate = iCommissionSqlTemplateService.queryOne(algorithmDto.getSqlTemplateBizId());
+        if (Objects.isNull(commissionSqlTemplate)) {
+            throw new BusinessException("SQL模板对象不存在");
+        }
+        //SQL模板内容不能为空
+        if (StringUtils.isBlank(commissionSqlTemplate.getSqlTemplate())) {
+            throw new BusinessException("SQL模板内容SQL语句不能为空");
+        }
+        try {
+            //获取SQL模板内容
+            String sqlTemplate = commissionSqlTemplate.getSqlTemplate();
+
+            //构建SQL模板入参参数Map
+            Map<String, Object> paramMap = buildParamMap(algorithmDto);
+
+            //执行SQL查询
+            Object result = executeParameterizedQuery(sqlTemplate, paramMap);
+
+            //将查询结果转换为 List<SqlAlgorithmResultDto>
+            List<SqlAlgorithmResultDto> resultDtoList = convertToSqlAlgorithmResultDto(result);
+
+            return Result.success(resultDtoList);
+
+        } catch (Exception e) {
+            log.error("执行SQL模板失败, sqlTemplateBizId: {}", algorithmDto.getSqlTemplateBizId(), e);
+            throw new BusinessException("执行SQL模板失败: " + e.getMessage());
         }
     }
+
+    /**
+     * 将查询结果转换为 List<SqlAlgorithmResultDto>
+     * @param result 原始查询结果
+     * @return 转换后的结果列表
+     */
+    private List<SqlAlgorithmResultDto> convertToSqlAlgorithmResultDto(Object result) {
+        List<SqlAlgorithmResultDto> resultDtoList = new ArrayList<>();
+
+        if (result == null) {
+            return resultDtoList;
+        }
+
+        if (result instanceof List) {
+            List<?> resultList = (List<?>) result;
+            for (Object item : resultList) {
+                SqlAlgorithmResultDto dto = convertSingleResult(item);
+                if (dto != null) {
+                    resultDtoList.add(dto);
                 }
             }
+        } else {
+            // 单个结果的情况
+            SqlAlgorithmResultDto dto = convertSingleResult(result);
+            if (dto != null) {
+                resultDtoList.add(dto);
+            }
+        }
+
+        return resultDtoList;
+    }
+
+    /**
+     * 转换单个查询结果
+     * @param item 查询结果项
+     * @return 转换后的DTO
+     */
+    private SqlAlgorithmResultDto convertSingleResult(Object item) {
+        SqlAlgorithmResultDto dto = new SqlAlgorithmResultDto();
+
+        if (item instanceof Map) {
+            // 处理Map类型的结果（多列）
+            Map<String, Object> row = (Map<String, Object>) item;
+
+            // 根据实际数据库列名设置provider和calculatedValue
+            if (row.containsKey("provider")) {
+                dto.setProvider(row.get("provider") != null ? row.get("provider").toString() : null);
+            }
+            if (row.containsKey("calculated_value")) {
+                dto.setCalculatedValue(row.get("calculated_value") != null ? row.get("calculated_value").toString() : null);
+            }
+            // 可以添加其他字段的映射...
+
+        } else if (item instanceof String || item instanceof Number) {
+            // 处理单列查询结果
+            dto.setCalculatedValue(item.toString());
+            // 单列情况下，provider可以为空或设置默认值
+            dto.setProvider("default_provider");
+        }
+
+        return dto;
+    }
+
+    /**
+     * 构建参数Map
+     * @param algorithmDto
+     * @return
+     */
+    private Map<String, Object> buildParamMap(AlgorithmDto algorithmDto) {
+        SqlTemplateParamDto sqlTemplateParamDto = algorithmDto.getSqlTemplateParamDto();
+        if (Objects.isNull(sqlTemplateParamDto)) {
+            throw new BusinessException("SQL模板条件入参参数及参数值对象不能为空");
+        }
+        Map<String, Object> paramMap = new HashMap<>();
+        //添加参数 - 把所有SQL模板涉及到的参数都列出来put进去，SQL模板内容有对应的就替换，没有就不替换，就能达到高效通用性
+        //条件类型表唯一业务ID
+        paramMap.put("conditionTypeBizId", sqlTemplateParamDto.getConditionTypeBizId());
+        //保单号
+        paramMap.put("policyNo", sqlTemplateParamDto.getPolicyNo());
+        //产品代码
+        paramMap.put("productCode", sqlTemplateParamDto.getProductCode());
+        //保单绑定转介人业务ID
+        paramMap.put("brokerBizId", sqlTemplateParamDto.getBrokerBizId());
+        return paramMap;
+    }
+
+    /**
+     * 执行参数化查询
+     * @param sqlTemplate
+     * @param paramMap
+     * @return
+     */
+    private Object executeParameterizedQuery(String sqlTemplate, Map<String, Object> paramMap) {
+        //使用NamedParameterJdbcTemplate执行参数化查询
+        NamedParameterJdbcTemplate jdbcTemplate = getJdbcTemplate();
+
+        //判断SQL类型：查询还是更新
+        if (isSelectQuery(sqlTemplate)) {
+            //查询操作
+            List<Map<String, Object>> resultList = jdbcTemplate.queryForList(sqlTemplate, paramMap);
+
+            //根据业务需求处理结果
+            if (resultList.isEmpty()) {
                 return null;
+            } else if (resultList.size() == 1) {
+                Map<String, Object> singleResult = resultList.get(0);
+                //如果只有一列，直接返回值
+                if (singleResult.size() == 1) {
+                    return singleResult.values().iterator().next();
+                }
+                return singleResult;
+            } else {
+                return resultList;
+            }
+        } else {
+            //更新操作（INSERT/UPDATE/DELETE）
+            int affectedRows = jdbcTemplate.update(sqlTemplate, paramMap);
+            return affectedRows;
+        }
     }
 
+    /**
+     * 判断是否为SELECT查询
+     * @param sql
+     * @return
+     */
+    private boolean isSelectQuery(String sql) {
+        String trimmedSql = sql.trim().toLowerCase();
+        return trimmedSql.startsWith("select");
+    }
+
+    /**
+     * 校验算法DTO入参
+     * @param algorithmDto
+     * @return
+     */
+    public Result checkAlgorithmDto(AlgorithmDto algorithmDto) {
+        if (Objects.isNull(algorithmDto)) {
+            throw new BusinessException("算法DTO入参对象不能为空");
+        }
+        if (StringUtils.isBlank(algorithmDto.getFormulaBizId())) {
+            throw new BusinessException("公式配置表唯一业务ID不能为空");
+        }
+        if (CollectionUtils.isEmpty(algorithmDto.getVariableBizIdList())) {
+            throw new BusinessException("变量表业务ID集合列表不能为空");
+        }
+        return Result.success();
+    }
 }

yd-csf-api/src/main/java/com/yd/csf/api/utils/FormulaParser.java

+package com.yd.csf.api.utils;
+
+import java.util.*;
+import java.util.regex.*;
+
+/**
+ * 公式解析工具类
+ */
+public class FormulaParser {
+    
+    /**
+     * 从公式字符串中解析出所有变量业务ID
+     * @param calculationFormulaBizId 公式字符串，如 "(variable_1001 + variable_2123) * variable_4455"
+     * @return 变量业务ID的集合
+     */
+    public static Set<String> parseVariableBizIds(String calculationFormulaBizId) {
+        Set<String> variableIds = new HashSet<>();
+        
+        if (calculationFormulaBizId == null || calculationFormulaBizId.trim().isEmpty()) {
+            return variableIds;
+        }
+        
+        // 正则表达式匹配 variable_ 后面跟着数字的模式
+        Pattern pattern = Pattern.compile("variable_\\d+");
+        Matcher matcher = pattern.matcher(calculationFormulaBizId);
+        
+        while (matcher.find()) {
+            variableIds.add(matcher.group());
+        }
+        
+        return variableIds;
+    }
+    
+    /**
+     * 从公式字符串中解析出所有变量业务ID（返回列表，保持顺序）
+     * @param calculationFormulaBizId 公式字符串
+     * @return 变量业务ID的列表（按出现顺序）
+     */
+    public static List<String> parseVariableBizIdsOrdered(String calculationFormulaBizId) {
+        List<String> variableIds = new ArrayList<>();
+        
+        if (calculationFormulaBizId == null || calculationFormulaBizId.trim().isEmpty()) {
+            return variableIds;
+        }
+        
+        Pattern pattern = Pattern.compile("variable_\\d+");
+        Matcher matcher = pattern.matcher(calculationFormulaBizId);
+        
+        while (matcher.find()) {
+            variableIds.add(matcher.group());
+        }
+        
+        return variableIds;
+    }
+    
+    /**
+     * 从公式字符串中解析出纯数字ID部分
+     * @param calculationFormulaBizId 公式字符串
+     * @return 纯数字ID的集合
+     */
+    public static Set<Long> parseVariableNumericIds(String calculationFormulaBizId) {
+        Set<Long> numericIds = new HashSet<>();
+        
+        if (calculationFormulaBizId == null || calculationFormulaBizId.trim().isEmpty()) {
+            return numericIds;
+        }
+        
+        // 匹配 variable_ 后面的数字部分
+        Pattern pattern = Pattern.compile("variable_(\\d+)");
+        Matcher matcher = pattern.matcher(calculationFormulaBizId);
+        
+        while (matcher.find()) {
+            try {
+                Long numericId = Long.parseLong(matcher.group(1));
+                numericIds.add(numericId);
+            } catch (NumberFormatException e) {
+                // 忽略格式错误的ID
+                System.err.println("无效的数字ID: " + matcher.group(1));
+            }
+        }
+        
+        return numericIds;
+    }
+    
+    /**
+     * 替换公式中的变量业务ID为实际值
+     * @param formula 原始公式
+     * @param variableValues 变量值映射表
+     * @return 替换后的公式
+     */
+    public static String replaceVariablesWithValues(String formula, Map<String, Double> variableValues) {
+        if (formula == null || variableValues == null) {
+            return formula;
+        }
+        
+        String result = formula;
+        for (Map.Entry<String, Double> entry : variableValues.entrySet()) {
+            String variableId = entry.getKey();
+            Double value = entry.getValue();
+            
+            if (value != null) {
+                // 直接替换变量ID为数值
+                result = result.replace(variableId, value.toString());
+            }
+        }
+        
+        return result;
+    }
+    
+    /**
+     * 验证公式格式是否正确
+     * @param formula 公式字符串
+     * @return 验证结果
+     */
+    public static boolean validateFormulaFormat(String formula) {
+        if (formula == null || formula.trim().isEmpty()) {
+            return false;
+        }
+        
+        // 基本格式检查：包含变量、运算符和括号
+        // 这里可以添加更复杂的验证逻辑
+        String tempFormula = formula.replaceAll("variable_\\d+", "VAR")
+                                   .replaceAll("\\s+", "");
+        
+        // 简单的括号匹配检查
+        return isBracketBalanced(tempFormula);
+    }
+    
+    /**
+     * 检查括号是否平衡
+     */
+    private static boolean isBracketBalanced(String str) {
+        Deque<Character> stack = new ArrayDeque<>();
+        
+        for (char c : str.toCharArray()) {
+            if (c == '(') {
+                stack.push(c);
+            } else if (c == ')') {
+                if (stack.isEmpty() || stack.pop() != '(') {
+                    return false;
+                }
+            }
+        }
+        
+        return stack.isEmpty();
+    }
+}
\ No newline at end of file

yd-csf-feign/src/main/java/com/yd/csf/feign/enums/VariableEnum.java

+package com.yd.csf.feign.enums;
+
+/**
+ * 变量类型枚举
+ */
+public enum VariableEnum {
+
+    FIXED_VALUE("固定值","FIXED_VALUE"),
+    DYNAMIC_COMPUTATION("动态计算","DYNAMIC_COMPUTATION"),
+    ;
+    //字典项标签（名称）
+    private String itemLabel;
+    //字典项值
+    private String itemValue;
+
+    //构造函数
+    VariableEnum(String itemLabel, String itemValue) {
+        this.itemLabel = itemLabel;
+        this.itemValue = itemValue;
+    }
+
+    public String getItemLabel() {
+        return itemLabel;
+    }
+
+    public String getItemValue() {
+        return itemValue;
+    }
+}

yd-csf-service/src/main/java/com/yd/csf/service/dto/CommissionRuleBindingDto.java

+package com.yd.csf.service.dto;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class CommissionRuleBindingDto {
+
+    /**
+     * 基本法配置表唯一业务ID
+     */
+    private String ruleBizId;
+
+    /**
+     * 基本法项目配置表唯一业务ID
+     */
+    private String ruleItemBizId;
+
+    /**
+     * 绑定目标类型：AGENT-业务员, TEAM-团队
+     */
+    private String targetType;
+
+    /**
+     * 目标ID，业务员ID或团队ID
+     */
+    private String targetId;
+}

yd-csf-service/src/main/java/com/yd/csf/service/dto/RelObjectConditionDto.java

 package com.yd.csf.service.dto;
 
+import lombok.AllArgsConstructor;
+import lombok.Builder;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 @Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
 public class RelObjectConditionDto {
 
     /**

yd-csf-service/src/main/java/com/yd/csf/service/dto/RuleItemConfigDto.java

@@ -12,6 +12,11 @@ import lombok.NoArgsConstructor;
 public class RuleItemConfigDto {
 
     /**
+     * 基本法配置表唯一业务ID
+     */
+    private String ruleBizId;
+
+    /**
      * 基本法项目配置表唯一业务ID
      */
     private String ruleItemBizId;

yd-csf-service/src/main/java/com/yd/csf/service/dto/VariableDto.java

@@ -5,6 +5,8 @@ import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
+import java.util.List;
+
 @Data
 @Builder
 @NoArgsConstructor
@@ -17,6 +19,11 @@ public class VariableDto {
     private String variableBizId;
 
     /**
+     * 变量表唯一业务ID列表
+     */
+    private List<String> variableBizIdList;
+
+    /**
      * 变量名称中文名
      */
     private String nameCn;

yd-csf-service/src/main/java/com/yd/csf/service/model/AgentDetailFyc.java

@@ -44,10 +44,22 @@ public class AgentDetailFyc implements Serializable {
     private String sourceType;
 
     /**
-     * 积分提供保单表唯一业务ID
+     * 积分来源基本法项目配置表唯一业务ID
      */
-    @TableField("policy_biz_id")
-    private String policyBizId;
+    @TableField("rule_item_biz_id")
+    private String ruleItemBizId;
+
+    /**
+     * 保单发佣批次ID
+     */
+    @TableField("batch_bizId")
+    private String batchBizId;
+
+    /**
+     * 积分提供的保单号
+     */
+    @TableField("policy_no")
+    private String policyNo;
 
     /**
      * 积分提供者（客户端用户表唯一业务ID）

yd-csf-service/src/main/java/com/yd/csf/service/model/FormulaConfig.java

@@ -61,6 +61,12 @@ public class FormulaConfig implements Serializable {
     private String calculationFormulaBizId;
 
     /**
+     * 计算公式（变量表编码组合）
+     */
+    @TableField("calculation_formula_code")
+    private String calculationFormulaCode;
+
+    /**
      * 描述
      */
     @TableField("description")

yd-csf-service/src/main/java/com/yd/csf/service/model/Fortune.java

@@ -21,6 +21,11 @@ public class Fortune implements Serializable {
     private Long id;
 
     /**
+     * 保单发佣批次ID
+     */
+    private String batchBizId;
+
+    /**
      * 保单发佣业务id
      */
     private String fortuneBizId;

yd-csf-service/src/main/java/com/yd/csf/service/service/IAgentAccumulatedFycService.java

@@ -13,4 +13,5 @@ import com.baomidou.mybatisplus.extension.service.IService;
  */
 public interface IAgentAccumulatedFycService extends IService<AgentAccumulatedFyc> {
 
+    AgentAccumulatedFyc queryOne(String agentId);
 }

yd-csf-service/src/main/java/com/yd/csf/service/service/ICommissionRuleBindingService.java

 package com.yd.csf.service.service;
 
+import com.yd.csf.service.dto.CommissionRuleBindingDto;
 import com.yd.csf.service.model.CommissionRuleBinding;
 import com.baomidou.mybatisplus.extension.service.IService;
 
+import java.util.List;
+
 /**
  * <p>
  * 基本法绑定表 - 存储基本法与业务员或团队的绑定关系，支持灵活的权限分配 服务类
@@ -13,4 +16,5 @@ import com.baomidou.mybatisplus.extension.service.IService;
  */
 public interface ICommissionRuleBindingService extends IService<CommissionRuleBinding> {
 
+    List<CommissionRuleBinding> queryList(CommissionRuleBindingDto dto);
 }

yd-csf-service/src/main/java/com/yd/csf/service/service/ICommissionSqlTemplateService.java

@@ -24,4 +24,6 @@ public interface ICommissionSqlTemplateService extends IService<CommissionSqlTem
                                                      ApiCommissionSqlTemplatePageRequest request);
 
     List<CommissionSqlTemplate> queryList(CommissionSqlTemplateDto dto);
+
+    CommissionSqlTemplate queryOne(String sqlTemplateBizId);
 }

yd-csf-service/src/main/java/com/yd/csf/service/service/impl/AgentAccumulatedFycServiceImpl.java

 package com.yd.csf.service.service.impl;
 
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.yd.csf.service.model.AgentAccumulatedFyc;
 import com.yd.csf.service.dao.AgentAccumulatedFycMapper;
 import com.yd.csf.service.service.IAgentAccumulatedFycService;
@@ -17,4 +18,14 @@ import org.springframework.stereotype.Service;
 @Service
 public class AgentAccumulatedFycServiceImpl extends ServiceImpl<AgentAccumulatedFycMapper, AgentAccumulatedFyc> implements IAgentAccumulatedFycService {
 
+    /**
+     * 查询单个对象
+     * @param agentId
+     * @return
+     */
+    @Override
+    public AgentAccumulatedFyc queryOne(String agentId) {
+        return this.getOne(new LambdaQueryWrapper<AgentAccumulatedFyc>().eq(AgentAccumulatedFyc::getAgentId,agentId).last("limit 1"));
+    }
+
 }

yd-csf-service/src/main/java/com/yd/csf/service/service/impl/CommissionRuleBindingServiceImpl.java

 package com.yd.csf.service.service.impl;
 
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.yd.csf.service.dto.CommissionRuleBindingDto;
 import com.yd.csf.service.model.CommissionRuleBinding;
 import com.yd.csf.service.dao.CommissionRuleBindingMapper;
+import com.yd.csf.service.model.CommissionSqlTemplate;
 import com.yd.csf.service.service.ICommissionRuleBindingService;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.apache.commons.lang3.StringUtils;
 import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+
+import java.util.List;
 
 /**
  * <p>
@@ -17,4 +24,18 @@ import org.springframework.stereotype.Service;
 @Service
 public class CommissionRuleBindingServiceImpl extends ServiceImpl<CommissionRuleBindingMapper, CommissionRuleBinding> implements ICommissionRuleBindingService {
 
+    /**
+     * 查询列表
+     * @param dto
+     * @return
+     */
+    @Override
+    public List<CommissionRuleBinding> queryList(CommissionRuleBindingDto dto) {
+        List<CommissionRuleBinding> list = baseMapper.selectList(new LambdaQueryWrapper<CommissionRuleBinding>()
+                .eq(StringUtils.isNotBlank(dto.getTargetId()),CommissionRuleBinding::getTargetId,dto.getTargetId())
+        );
+        return list;
+    }
+
+
 }

yd-csf-service/src/main/java/com/yd/csf/service/service/impl/CommissionSqlTemplateServiceImpl.java

@@ -45,4 +45,14 @@ public class CommissionSqlTemplateServiceImpl extends ServiceImpl<CommissionSqlT
         );
         return list;
     }
+
+    /**
+     * 查询单个对象
+     * @param sqlTemplateBizId
+     * @return
+     */
+    @Override
+    public CommissionSqlTemplate queryOne(String sqlTemplateBizId) {
+        return this.getOne(new LambdaQueryWrapper<CommissionSqlTemplate>().eq(CommissionSqlTemplate::getSqlTemplateBizId,sqlTemplateBizId));
+    }
 }

yd-csf-service/src/main/java/com/yd/csf/service/service/impl/RuleItemConfigServiceImpl.java

@@ -53,7 +53,9 @@ public class RuleItemConfigServiceImpl extends ServiceImpl<RuleItemConfigMapper,
         List<RuleItemConfig> list = baseMapper.selectList(new LambdaQueryWrapper<RuleItemConfig>()
                 .eq(StringUtils.isNotBlank(dto.getRuleItemBizId()) && !dto.getIsExcludeMy(),RuleItemConfig::getRuleItemBizId,dto.getRuleItemBizId())
                 .eq(StringUtils.isNotBlank(dto.getItemName()),RuleItemConfig::getItemName,dto.getItemName())
+                .eq(StringUtils.isNotBlank(dto.getRuleBizId()),RuleItemConfig::getRuleBizId,dto.getRuleBizId())
                 .ne(dto.getIsExcludeMy(),RuleItemConfig::getRuleItemBizId,dto.getRuleItemBizId())
+                .orderByAsc(RuleItemConfig::getExecutionOrder)
         );
         return list;
     }