更新处理逻辑，准备插入语句。

DBScript/李庚谱/001-DDL.sql

@@ -769,4 +769,49 @@ create table RWA_CALC_RS_TASKPARAM_ALLHIS
     PARAM_CALC_RESULT VARCHAR(300) comment '参数计算结果',
     PARAM_CALC_TOOK   DECIMAL(30, 6) comment '计算耗时',
     primary key (CALCINDEX, PARAM_ID)
-) comment '计算参数结果';
+) comment '计算参数结果';
+
+
+drop table if exists RWA_APM_BUS_RS_ACCADJUSTMENT;
+create table RWA_APM_BUS_RS_ACCADJUSTMENT
+(
+    CALCINDEX                     VARCHAR(60) comment '计算实例号',
+    SDATE                         VARCHAR(8) comment '起始数据日期',
+    EDATE                         VARCHAR(8) comment '截止数据日期',
+    TERM                          VARCHAR(8) comment '年月',
+    DATA_DATE                     VARCHAR(8) comment '数据日期',
+    GL_CODE                       VARCHAR(60) comment '总账科目号',
+    SUBJECT_DESC                  VARCHAR(60) comment '科目名称',
+    LOAN_REFERENCE_NO             VARCHAR(60) comment '债项编号',
+    BALANCE_ON                    DECIMAL(30, 6) comment '本期余额',
+    BALANCE_OFF                   DECIMAL(30, 6) comment '转换前资产',
+    RESERVE                       DECIMAL(30, 6) comment '计提准备金',
+    CURRENCY                      VARCHAR(60) comment '币种代码',
+    RISK_EXPOSURE_LEV01_CODE      VARCHAR(60) comment '一级风险暴露分类代码',
+    RISK_EXPOSURE_LEV01_CODE_NAME VARCHAR(200) comment '一级风险暴露分类名称',
+    RISK_EXPOSURE_LEV02_CODE      VARCHAR(60) comment '二级风险暴露分类代码',
+    RISK_EXPOSURE_LEV02_CODE_NAME VARCHAR(200) comment '二级风险暴露分类名称',
+    RISK_EXPOSURE_LEV03_CODE      VARCHAR(60) comment '三级风险暴露分类代码',
+    RISK_EXPOSURE_LEV03_CODE_NAME VARCHAR(200) comment '三级风险暴露分类名称',
+    RISK_EXPOSURE_LEV04_CODE      VARCHAR(60) comment '四级风险暴露分类代码',
+    RISK_EXPOSURE_LEV04_CODE_NAME VARCHAR(200) comment '四级风险暴露分类名称',
+    RISK_RESULT                   VARCHAR(60) comment '风险暴露类别',
+    LOAN_WEIGHT                   DECIMAL(30, 6) comment '债项风险权重',
+    COVERAGE_RISK                 DECIMAL(30, 6) comment '缓释覆盖部分的风险暴露',
+    COVERAGE_RWA                  DECIMAL(30, 6) comment '缓释覆盖部分的RWA',
+    UNFINISH_EAD                  DECIMAL(30, 6) comment '未缓释的风险暴露',
+    UNFINISH_RWA                  DECIMAL(30, 6) comment '未缓释RWA',
+    RWA                           DECIMAL(30, 6) comment 'RWA',
+    CUST_NAME                     VARCHAR(60) comment '客户名称',
+    CUST_NO                       VARCHAR(60) comment '客户号',
+    BP_CUST_NO                    VARCHAR(60) comment '核心客户号',
+    INVEST_INDUSTRY               VARCHAR(60) comment '行业名称',
+    BUSINESS_LINE                 VARCHAR(60) comment '业务条线',
+    EFF_DATE                      VARCHAR(60) comment '生效日',
+    DUE_DATE                      VARCHAR(60) comment '到期日',
+    SOFT_RULE_TYPE                VARCHAR(60) not null comment '规则类型-配置在总分勾稽规则定义中，规则类型为ACCOUNT',
+    SOFT_RULE_MAINID              VARCHAR(60) not null comment '规则主编号-配置在总分勾稽规则定义中，即规则编号',
+    SOFT_RULE_SUBID               VARCHAR(60) not null comment '规则次编号-为空',
+
+    primary key (CALCINDEX, GL_CODE, LOAN_REFERENCE_NO)
+) comment '总账差异结果表';

Procedure/backend/project/src/main/java/com/sundata/product/rwa/calc/running/CalcRunning.java

@@ -1,5 +1,6 @@
 package com.sundata.product.rwa.calc.running;
 
+import cn.hutool.core.date.format.FastDateFormat;
 import cn.hutool.core.lang.UUID;
 import cn.hutool.core.util.StrUtil;
 
@@ -7,14 +8,17 @@ import com.sundata.product.rwa.calc.running.threads.CalcRecursiveTask;
 import com.sundata.product.rwa.calc.running.threads.CalcTaskResult;
 import com.sundata.product.rwa.calc.running.threads.CalcUnitThreadFactory;
 import com.sundata.product.rwa.calc.running.threads.fianl.CalcTaskResultType;
+import com.sundata.product.rwa.calc.service.CalcException;
 import com.sundata.product.rwa.calc.service.CalcResult;
 import com.sundata.product.rwa.calc.service.CalcUnit;
+import com.sundata.product.rwa.calc.utils.DateChecker;
 import org.jgrapht.Graph;
 import org.jgrapht.graph.DefaultDirectedGraph;
 import org.jgrapht.graph.DefaultEdge;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.util.Calendar;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -29,6 +33,31 @@ public class CalcRunning {
 
     public CalcTaskResult startCalc(String calculateInstanceNumber, CalcUnit calcUnit, Map<String, Object> context) {
 
+        // 处理基础参数，在实际情况中可能需要修改
+        context.put("CALCINDEX", calculateInstanceNumber);
+        if (!context.containsKey("dataDate")) {
+            String dataDate = (String) context.get("dataDate");
+            DateChecker.isSimpleDateFormat(dataDate);
+            throw new CalcException("缺少必要参数 dataDate，请在传入参数中必要的传入 dataDate");
+        }
+        Calendar calendar = DateChecker.getSimpleCalendar((String) context.get("dataDate"));
+        if (!context.containsKey("SDATE") && StrUtil.isBlank(context.get("SDATE").toString())) {
+            log.warn("没有传入 SDATE 通过 dataDate 转换获取");
+            context.put("SDATE", FastDateFormat.getInstance(DateChecker.SHORT_DATE_PATTERN).format(calendar.getTime()));
+        }
+        if (!context.containsKey("EDATE") && StrUtil.isBlank(context.get("EDATE").toString())) {
+            log.warn("没有传入 EDATE 通过 dataDate 转换获取");
+            context.put("EDATE", FastDateFormat.getInstance(DateChecker.SHORT_DATE_PATTERN).format(calendar.getTime()));
+        }
+        if (!context.containsKey("TERM") && StrUtil.isBlank(context.get("TERM").toString())) {
+            log.warn("没有传入 TERM 通过 dataDate 转换获取");
+            context.put("TERM", FastDateFormat.getInstance(DateChecker.SHORT_MONTH_PATTERN).format(calendar.getTime()));
+        }
+        if (!context.containsKey("DATA_DATE") && StrUtil.isBlank(context.get("DATA_DATE").toString())) {
+            log.warn("没有传入 DATA_DATE 通过 dataDate 转换获取");
+            context.put("DATA_DATE", context.get("dataDate"));
+        }
+
         if (StrUtil.isEmpty(calculateInstanceNumber)) {
             calculateInstanceNumber = UUID.randomUUID(Boolean.TRUE).toString(Boolean.TRUE);
         }

Procedure/backend/project/src/main/java/com/sundata/product/rwa/calc/service/implement/CalcTaskService.java

@@ -57,12 +57,7 @@ public class CalcTaskService {
      * @return 满足条件的计算任务
      */
     public List<MeteringManageModel> takeShouldRunMetering(String dateStr) {
-        if (StrUtil.isBlank(dateStr)) {
-            throw new IllegalArgumentException("日期字符串为空");
-        }
-        if (dateStr.length() != 10 || !ReUtil.contains("^\\d{4}-[0,1]{1}\\d{1}-[0,1,2,3]{1}\\d{1}", dateStr)) {
-            throw new IllegalArgumentException("日期字符串不满足格式");
-        }
+        DateChecker.isSimpleDateFormat(dateStr);
         List<MeteringManageModel> meteringManageModels = getAllMeteringManageModel();
 //        List<DictTree> frequencies = nounManageService.getNounTree("FREQUENCY");
         List<MeteringManageModel> shouldRunMetering = new ArrayList<>();

Procedure/backend/project/src/main/java/com/sundata/product/rwa/calc/service/implement/units/GeneralLedgerUnit.java

@@ -1,23 +1,27 @@
 package com.sundata.product.rwa.calc.service.implement.units;
 
-import cn.hutool.core.math.MathUtil;
+import cn.hutool.core.convert.NumberChineseFormatter;
+import cn.hutool.core.convert.NumberWordFormatter;
 import cn.hutool.core.util.NumberUtil;
 import cn.hutool.core.util.StrUtil;
 import cn.hutool.extra.spring.SpringUtil;
-import cn.hutool.extra.template.TemplateUtil;
 import com.sundata.common.util.DBExecutor;
 import com.sundata.product.rwa.calc.service.CalcResult;
 import com.sundata.product.rwa.calc.service.CalcUnit;
 import com.sundata.product.rwa.calc.service.finals.CalcType;
 import com.sundata.product.rwa.calc.utils.FinalStrs;
 import com.sundata.product.rwa.calc.utils.UnitStaticFun;
+import com.sundata.product.rwa.resultList.model.DiffconfigListModel;
 import com.sundata.product.rwa.resultList.model.RuleListModel;
+import com.sundata.product.rwa.resultList.service.DiffconfigListService;
 import com.sundata.product.rwa.resultList.service.RuleListService;
 import org.apache.commons.text.StringSubstitutor;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.math.BigDecimal;
+import java.text.DecimalFormat;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
@@ -102,9 +106,20 @@ public class GeneralLedgerUnit extends CalcUnit {
         StringSubstitutor sub = new StringSubstitutor(context);
         RuleListService ruleListService = SpringUtil.getBean(RuleListService.class);
         List<RuleListModel> ruleListModels = ruleListService.rule_list(new RuleListModel());
+        DiffconfigListService diffconfigListService = SpringUtil.getBean(DiffconfigListService.class);
+        List<DiffconfigListModel> diffconfigListModels = diffconfigListService.rule_querylist(new DiffconfigListModel());
+        Map<String, DiffconfigListModel> subjectDiffConfig = new HashMap<>();
+
+        for (DiffconfigListModel diffconfigListModel : diffconfigListModels) {
+            List<RuleListModel> ruleListModelList = diffconfigListService.rule_queryone2(diffconfigListModel.getRuleNo());
+            for (RuleListModel ruleListModel : ruleListModelList) {
+                subjectDiffConfig.put(ruleListModel.getGlCode(), diffconfigListModel);
+            }
+        }
         // TODO 需要获取容忍度处理逻辑，并将容忍度处理逻辑处理为一个基于科目编号的map，下面的处理过程中，根据实际容忍度处理结果
         // TODO 这两个表不存在 select * from RWA_LEART_INS_LEDGRESULT; select * from RWA_APM_BUS_RS_ACCADJUSTMENT;
         for (RuleListModel ruleListModel : ruleListModels) {
+
             String subjectSql = sub.replace(ruleListModel.getSubjectSql());
             String productSql = sub.replace(ruleListModel.getProductSql());
             String subjectSum = DBExecutor.doQuery(subjectSql);
@@ -115,23 +130,57 @@ public class GeneralLedgerUnit extends CalcUnit {
             if (!NumberUtil.isNumber(productSum)) {
                 continue;
             }
-//            Double subjectSumDouble = Double.valueOf(subjectSum);
-//            Double productSumDouble = Double.valueOf(productSum);
-            BigDecimal subjectSumBigDecimal = new BigDecimal(subjectSum);
-            BigDecimal productSumBigDecimal = new BigDecimal(productSum);
-            BigDecimal result = subjectSumBigDecimal.subtract(productSumBigDecimal);// 取 总账-勾稽明细
-
-            if (result.compareTo(BigDecimal.ZERO) < 0) {
+            BigDecimal subjectSumBigDecimal = new BigDecimal(subjectSum); // 总账汇总金额(万元)
+            BigDecimal productSumBigDecimal = new BigDecimal(productSum); // 勾稽汇总金额(万元)
+            BigDecimal differAmt = subjectSumBigDecimal.subtract(productSumBigDecimal);// 取 总账-勾稽明细 // 核对差异金额 不是万元
+
+
+//            String
+            String riskType = null;
+            String offProjectType = null;
+//            private String calcMethod;   //计算方式
+//            private String positiveRiskType;   //正差异风险暴露分类
+//            private String negativeRiskType;   //负差异风险暴露分类
+//            private String positiveOffProjectType;   //正差异表外项目分类
+//            private String negativeOffProjectType;   //负差异表外项目分类
+            if (differAmt.compareTo(BigDecimal.ZERO) < 0) {
                 // 如果 为负数 总账 小于 勾稽明细
-
-            }else if(result.compareTo(BigDecimal.ZERO) > 0) {
+                riskType = ruleListModel.getNegativeRiskType();
+                offProjectType = ruleListModel.getNegativeOffProjectType();
+            } else if (differAmt.compareTo(BigDecimal.ZERO) > 0) {
                 // 如果 为正数 总账 大于 勾稽明细
-
-            }else {
+                riskType = ruleListModel.getPositiveRiskType();
+                offProjectType = ruleListModel.getPositiveOffProjectType();
+            } else {
                 // 如果 为 0 总账等于勾稽明细
-
+                riskType = "";
+                offProjectType = "";
             }
 
+            DiffconfigListModel diffconfigListModel = subjectDiffConfig.get(ruleListModel.getGlCode());
+            boolean isInDiff = true;
+//            BigDecimal differAmt = BigDecimal.ZERO; // 核对差异金额(万元)
+            BigDecimal differRate = differAmt.divide(subjectSumBigDecimal); // 核对差异率%
+            String percThreshold = "[0.0-0.0]"; // 差异容忍度%
+            if (diffconfigListModel != null) {
+//                close - close
+//                close - open
+//                open - close
+//                open - open
+
+                String intervalType = diffconfigListModel.getIntervalType();
+
+                if (StrUtil.isBlank(intervalType) || intervalType.indexOf("-")!=6) {// 默认 闭-闭区间
+                    intervalType = "[close-close]";
+                }
+                intervalType = StrUtil.replace(intervalType,"[close","[");
+                intervalType = StrUtil.replace(intervalType,"close]","]");
+                intervalType = StrUtil.replace(intervalType,"open]",")");
+                intervalType = StrUtil.replace(intervalType,"[open","(");
+                String[] split = intervalType.split("-");
+                DecimalFormat df = new DecimalFormat("#,##0.00");
+                percThreshold = split[0]+ df.format(diffconfigListModel.getUpperLimit()) + "-" + df.format(diffconfigListModel.getLowerLimit()) + split[1];
+            }
         }
     }
 }

Procedure/backend/project/src/main/java/com/sundata/product/rwa/calc/utils/DateChecker.java

@@ -1,5 +1,10 @@
 package com.sundata.product.rwa.calc.utils;
 
+import cn.hutool.core.date.DatePattern;
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.util.ReUtil;
+import cn.hutool.core.util.StrUtil;
+
 import java.time.LocalDate;
 import java.time.temporal.TemporalAdjusters;
 import java.util.Calendar;
@@ -7,6 +12,40 @@ import java.util.Date;
 
 public class DateChecker {
 
+    public static final String NORM_DATE_REGEX = "^\\d{4}-[0,1]{1}\\d{1}-[0,1,2,3]{1}\\d{1}";
+    public static final String NORM_DATE_PATTERN = DatePattern.NORM_DATE_PATTERN;
+    public static final String NORM_MONTH_PATTERN = DatePattern.NORM_MONTH_PATTERN;
+    public static final String SHORT_DATE_PATTERN = "yyyyMMdd";
+    public static final String SHORT_MONTH_PATTERN = "yyyyMM";
+
+
+    public static void isSimpleDateFormat(String dateStr) {
+        isDateFormat(dateStr, NORM_DATE_REGEX);
+    }
+
+    public static void isDateFormat(String dateStr, String regex) {
+        if (StrUtil.isBlank(dateStr)) {
+            throw new IllegalArgumentException("日期字符串为空");
+        }
+        if (dateStr.length() != 10 || !ReUtil.contains(regex, dateStr)) {
+            throw new IllegalArgumentException("日期字符串不满足格式");
+        }
+    }
+
+    public static Calendar getSimpleCalendar(String dateStr) {
+        isSimpleDateFormat(dateStr);
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(DateUtil.parse(dateStr));
+        return calendar;
+    }
+
+    public static Calendar getCalendar(String dateStr, String regex) {
+        isDateFormat(dateStr, regex);
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(DateUtil.parse(dateStr));
+        return calendar;
+    }
+
     // 重载方法：支持 java.util.Date
     public static boolean isStartOfYear(Date date) {
         Calendar calendar = Calendar.getInstance();

Procedure/backend/project/src/main/java/com/sundata/product/rwa/resultList/mapper/DiffconfigListMapper.java

@@ -14,7 +14,7 @@ public interface DiffconfigListMapper {
     Boolean diffconfig_deleteone1(@Param("ruleNo") String ruleNo);
     void diffconfig_addone1 (@Param("list") List<RuleListModel> RuleListModelDemo) ;
     void  diffconfig_deleteone(@Param("ruleNo") String ruleNo);
-    public List<Object> rule_querylist1 (@Param("ruleNo") String ruleNo);
-    public List<Object> rule_querylist2 (@Param("ruleNo") String ruleNo);
-    public List<Object> rule_queryoruleAreaType (@Param("ruleAreaType") String ruleAreaType);
+    public List<RuleListModel> rule_querylist1 (@Param("ruleNo") String ruleNo);
+    public List<DiffconfigListModel> rule_querylist2 (@Param("ruleNo") String ruleNo);
+    public List<RuleListModel> rule_queryoruleAreaType (@Param("ruleAreaType") String ruleAreaType);
 }

Procedure/backend/project/src/main/java/com/sundata/product/rwa/resultList/model/DiffconfigListModel.java

@@ -8,8 +8,8 @@ public class DiffconfigListModel {
     private String  dataDate;   //数据日期
     private String  ruleNo;   //规则编号
     private String  ruleName;   //规则名称
-    private String  upperLimit;   //容忍度下限%
-    private String  lowerLimit;   //容忍度上限%
+    private double  upperLimit;   //容忍度下限%
+    private double  lowerLimit;   //容忍度上限%
     private String  intervalType;   //区间开闭类型
     private String  ruleAreaType;   //适用范围类型
 
@@ -69,19 +69,19 @@ public class DiffconfigListModel {
         this.ruleName = ruleName;
     }
 
-    public String getUpperLimit() {
+    public double getUpperLimit() {
         return upperLimit;
     }
 
-    public void setUpperLimit(String upperLimit) {
+    public void setUpperLimit(double upperLimit) {
         this.upperLimit = upperLimit;
     }
 
-    public String getLowerLimit() {
+    public double getLowerLimit() {
         return lowerLimit;
     }
 
-    public void setLowerLimit(String lowerLimit) {
+    public void setLowerLimit(double lowerLimit) {
         this.lowerLimit = lowerLimit;
     }
 

Procedure/backend/project/src/main/java/com/sundata/product/rwa/resultList/service/DiffconfigListService.java

@@ -4,14 +4,12 @@ import com.sundata.common.util.DBExecutor;
 import com.sundata.product.rwa.resultList.mapper.DiffconfigListMapper;
 import com.sundata.product.rwa.resultList.model.DiffconfigListModel;
 import com.sundata.product.rwa.resultList.model.RuleListModel;
-import org.apache.xmlbeans.impl.xb.xsdschema.Public;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.concurrent.atomic.AtomicReference;
 
 @Service
 public class DiffconfigListService {
@@ -40,22 +38,22 @@ public class DiffconfigListService {
     }
 
     public Map<String, Object> rule_queryone(String ruleNo){
-         List<Object> result1 = rule_queryone1(ruleNo);
-        List<Object> result2 = rule_queryone2(ruleNo);
+         List<DiffconfigListModel> result1 = rule_queryone1(ruleNo);
+        List<RuleListModel> result2 = rule_queryone2(ruleNo);
 
         Map<String, Object> results = new HashMap<>();
         results.put("result1", result1);
         results.put("result2", result2);
         return results;
     }
-    public  List<Object> rule_queryone1(String ruleNo){
+    public  List<DiffconfigListModel> rule_queryone1(String ruleNo){
         return diffconfigListMapper.rule_querylist2(ruleNo);
     }
-    public  List<Object> rule_queryone2(String ruleNo){
+    public List<RuleListModel> rule_queryone2(String ruleNo){
         return diffconfigListMapper.rule_querylist1(ruleNo);
     }
 
-    public List<Object> rule_queryoruleAreaType(String ruleAreaType){
+    public List<RuleListModel> rule_queryoruleAreaType(String ruleAreaType){
         return diffconfigListMapper.rule_queryoruleAreaType(ruleAreaType);
     }