处理计算过程中的发起问题与数据参数问题

Procedure/backend/project/src/main/java/com/sundata/product/rwa/calc/controllers/CalcRunningController.java

@@ -1,12 +1,14 @@
 package com.sundata.product.rwa.calc.controllers;
 
 import com.sundata.common.annotation.Auth;
+import com.sundata.common.base.BaseAction;
 import com.sundata.product.rwa.calc.model.CalcInterfaceParam;
 import com.sundata.product.rwa.calc.running.threads.CalcTaskResult;
 import com.sundata.product.rwa.calc.service.CalcRunningService;
 import com.sundata.product.rwa.calc.service.implement.units.GeneralLedgerGetterUnit;
 import com.sundata.product.rwa.calc.service.implement.units.GeneralLedgerUnit;
 import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 
 import java.util.HashMap;
@@ -14,7 +16,7 @@ import java.util.Map;
 
 @Controller
 @RequestMapping("calc/start")
-public class CalcRunningController {
+public class CalcRunningController extends BaseAction {
 
     private final CalcRunningService calcRunningService;
 
@@ -34,7 +36,7 @@ public class CalcRunningController {
             verifyURL = false
     )
     @RequestMapping("GeneralLedgerGetter")
-    public CalcTaskResult startGeneralLedgerGetter(CalcInterfaceParam calcInterfaceParam) {
+    public CalcTaskResult startGeneralLedgerGetter(@RequestBody CalcInterfaceParam calcInterfaceParam) {
         Map<String, Object> context = new HashMap<>();
         context.put("dataDate", calcInterfaceParam.getDataDate());
         return calcRunningService.startCalc(calcInterfaceParam.getCalculateInstanceNumber(), new GeneralLedgerGetterUnit(calcInterfaceParam.getCalculateInstanceNumber(), calcInterfaceParam.getCalcCode(), 0, null), context);
@@ -52,7 +54,7 @@ public class CalcRunningController {
             verifyURL = false
     )
     @RequestMapping("GeneralLedger")
-    public CalcTaskResult startGeneralLedger(CalcInterfaceParam calcInterfaceParam) {
+    public CalcTaskResult startGeneralLedger(@RequestBody CalcInterfaceParam calcInterfaceParam) {
         Map<String, Object> context = new HashMap<>();
         context.put("dataDate", calcInterfaceParam.getDataDate());
         return calcRunningService.startCalc(calcInterfaceParam.getCalculateInstanceNumber(), new GeneralLedgerUnit(calcInterfaceParam.getCalculateInstanceNumber(), calcInterfaceParam.getCalcCode(), 0, null), context);

Procedure/backend/project/src/main/java/com/sundata/product/rwa/calc/controllers/curlshell.sh

@@ -1 +1 @@
-curl localhost:8080/calc/start/GeneralLedgerGetter -X POST -d ' { "calculateInstanceNumber": "xxx" , "calcCode":"xxx" ,"dataDate":"2025-03-07"  }' --header "Content-Type: application/json"
+ curl http://localhost:8080/calc/start/GeneralLedgerGetter -X POST -d "{\"calcCode\":\"xxx\" ,\"dataDate\":\"2025-03-07\"  }" --header "Content-Type: application/json"

Procedure/backend/project/src/main/java/com/sundata/product/rwa/calc/model/ParamCalcModel.java

@@ -0,0 +1,72 @@
+package com.sundata.product.rwa.calc.model;
+
+
+import com.sundata.product.rwa.reportformconfigreportcreater.model.ReportParamDefineModel;
+
+/**
+ * 计算参数对象
+ */
+public class ParamCalcModel {
+
+    /**
+     * 计算流水号
+     */
+    private final String calcindex;
+    /**
+     * 数据日期
+     */
+    private final String dataDate;
+
+    /**
+     * 计算用参数对象
+     */
+    private final ReportParamDefineModel model;
+
+    /**
+     * 计算参数对象的值
+     */
+    private Object value;
+
+
+    public ParamCalcModel(String calcindex, String dataDate, ReportParamDefineModel model) {
+        this.calcindex = calcindex;
+        this.dataDate = dataDate;
+        this.model = model;
+    }
+
+    public void setValue(Object value) {
+        this.value = value;
+    }
+
+    public String getCalcindex() {
+        return calcindex;
+    }
+
+    public String getDataDate() {
+        return dataDate;
+    }
+
+    public String getName() {
+        return getModel().getParamName();
+    }
+
+    public String getObjectName() {
+        return getModel().getParamObjectName();
+    }
+
+    public String getValueDataType() {
+        return getModel().getParamCalcType();
+    }
+
+    public String getParamCalcGetdata() {
+        return getModel().getParamCalcGetdata();
+    }
+
+    public Object getValue() {
+        return value;
+    }
+
+    public ReportParamDefineModel getModel() {
+        return model;
+    }
+}

Procedure/backend/project/src/main/java/com/sundata/product/rwa/calc/model/ParamCalcType.java

@@ -0,0 +1,81 @@
+package com.sundata.product.rwa.calc.model;
+
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.extra.spring.SpringUtil;
+import com.sundata.product.rwa.calc.param.ParamCalcDefault;
+import com.sundata.product.rwa.calc.param.ParamCalcSQL;
+import com.sundata.product.rwa.calc.param.ParamCalcSQLMap;
+import com.sundata.product.rwa.calc.param.ParamCalcSQLMapList;
+import com.sundata.product.rwa.calc.param.interfaces.ParamCalc;
+
+/**
+ * sys_noun： CALC_PROCESS_TYPE、PARAM_CALC_TYPE 方便处理过程中使用
+ * SELECT * FROM SYS_NOUN a where a.NOUNITEM = 'PARAM_CALC_TYPE';
+ * SELECT * FROM SYS_NOUN A WHERE A.NOUNITEM = 'CALC_PROCESS_TYPE'
+ */
+public enum ParamCalcType {
+
+    DEFAULT("常量") {
+        @Override
+        public ParamCalc getParamCalc(String className) {
+            return new ParamCalcDefault();
+        }
+    },JAVACLASS("实现类") {
+        @Override
+        public ParamCalc getParamCalc(String className) {
+            if (StrUtil.isEmpty(className)) {
+                return null;
+            }
+            return SpringUtil.getBean(className);
+        }
+    },SQLSTR("SQL语句") {
+        @Override
+        public ParamCalc getParamCalc(String className) {
+            return new ParamCalcSQL();
+        }
+    },SQLMAP("SQL语句-查询结果是一个Map") {
+        @Override
+        public ParamCalc getParamCalc(String className) {
+            return new ParamCalcSQLMap();
+        }
+    },SQLMAPLIST("SQL语句-查询结果是一个MapList") {
+        @Override
+        public ParamCalc getParamCalc(String className) {
+            return new ParamCalcSQLMapList();
+        }
+    }
+    ,OTHER("其他报表来源公式") {
+        @Override
+        public ParamCalc getParamCalc(String className) {
+            return null;
+        }
+    };
+    private final String name;
+
+    ParamCalcType(String name) {
+        this.name = name;
+    }
+    public String getName() {
+        return name;
+    }
+
+    public static ParamCalcType getParamCalcType(String nounValue) {
+        ParamCalcType paramCalcType = null;
+        if (nounValue != null) {
+            switch (nounValue) { // 根据字典获取枚举 字典分别为 PARAM_CALC_TYPE CALC_PROCESS_TYPE
+                case "01" -> paramCalcType = ParamCalcType.DEFAULT;
+                case "02" -> paramCalcType = ParamCalcType.JAVACLASS;
+                case "03" -> paramCalcType = ParamCalcType.SQLSTR;
+                case "04" -> paramCalcType = ParamCalcType.SQLMAP;
+                case "05" -> paramCalcType = ParamCalcType.SQLMAPLIST;
+            }
+        }
+        return paramCalcType;
+    }
+
+    /**
+     * 根据实际情况返回参数计算过程实例
+     * @return
+     */
+    public abstract ParamCalc getParamCalc(String className);
+}

Procedure/backend/project/src/main/java/com/sundata/product/rwa/calc/model/ReportParamCalcModel.java

@@ -0,0 +1,68 @@
+package com.sundata.product.rwa.calc.model;
+
+import com.sundata.product.rwa.reportformconfigreportcreater.model.ReportCalculationModel;
+import com.sundata.product.rwa.reportformconfigreportcreater.model.ReportParamDefineModel;
+
+public class ReportParamCalcModel {
+        /**
+     * 计算流水号
+     */
+    private final String calcindex;
+    /**
+     * 数据日期
+     */
+    private final String dataDate;
+
+    /**
+     * 行计算参数
+     */
+    private final ReportCalculationModel reportCalcModel;
+
+    private final ParamCalcModel paramCalcModel;
+
+    /**
+     * 计算参数对象的值
+     */
+    private Object value;
+
+
+    public ReportParamCalcModel(String calcindex, String dataDate, ReportCalculationModel reportCalcModel) {
+        this.calcindex = calcindex;
+        this.dataDate = dataDate;
+        this.reportCalcModel = reportCalcModel;
+        ReportParamDefineModel reportParamDefineModel = new ReportParamDefineModel();
+        reportParamDefineModel.setParamNo("x");
+        reportParamDefineModel.setDataDate(dataDate);
+        reportParamDefineModel.setCalcIndex(calcindex);
+        reportParamDefineModel.setParamName("计算单元名称");
+        reportParamDefineModel.setParamObjectName(reportCalcModel.getUnitCalcObjectName());
+        reportParamDefineModel.setParamCalcGetdata(reportCalcModel.getUnitCalcInfo());
+        reportParamDefineModel.setParamCalcType(reportCalcModel.getUnitCalcType());
+        this.paramCalcModel = new ParamCalcModel(this.calcindex, this.dataDate,reportParamDefineModel);
+    }
+
+    public void setValue(Object value) {
+        this.value = value;
+    }
+
+    public String getCalcindex() {
+        return calcindex;
+    }
+
+    public String getDataDate() {
+        return dataDate;
+    }
+
+    private ReportCalculationModel getReportCalcModel() {
+        return reportCalcModel;
+    }
+
+    public ParamCalcModel getParamCalcModel() {
+        return paramCalcModel;
+    }
+
+
+    public Object getValue() {
+        return value;
+    }
+}

Procedure/backend/project/src/main/java/com/sundata/product/rwa/calc/param/ParamCalcDefault.java

@@ -0,0 +1,20 @@
+package com.sundata.product.rwa.calc.param;
+
+import com.sundata.product.rwa.calc.model.ParamCalcModel;
+import com.sundata.product.rwa.calc.param.interfaces.ParamCalc;
+import org.apache.commons.text.StringSubstitutor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Map;
+
+public class ParamCalcDefault implements ParamCalc {
+    static final Logger log = LoggerFactory.getLogger(ParamCalcDefault.class);
+
+    @Override
+    public void calc(ParamCalcModel model, Map<String, Object> context) {
+        StringSubstitutor sub = new StringSubstitutor(context);
+        model.setValue(sub.replace(model.getParamCalcGetdata()));
+        log.debug(model.getParamCalcGetdata());
+    }
+}

Procedure/backend/project/src/main/java/com/sundata/product/rwa/calc/param/ParamCalcSQL.java

@@ -0,0 +1,30 @@
+package com.sundata.product.rwa.calc.param;
+
+import com.sundata.common.util.DBExecutor;
+import com.sundata.product.rwa.calc.model.ParamCalcModel;
+import com.sundata.product.rwa.calc.param.interfaces.ParamCalc;
+import org.apache.commons.text.StringSubstitutor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Map;
+
+/**
+ * 通过 SQL 执行出来的结果赋值给参数内容
+ */
+public class ParamCalcSQL implements ParamCalc {
+    private static final Logger log = LoggerFactory.getLogger(ParamCalcSQL.class);
+
+    @Override
+    public void calc(ParamCalcModel model, Map<String, Object> context) {
+        String sql = model.getParamCalcGetdata();
+        if (context != null) {
+            StringSubstitutor sub = new StringSubstitutor(context);
+            sql = sub.replace(sql);
+        }
+
+        String value = DBExecutor.doQuery(sql);
+        model.setValue(value);
+        log.info("数据处理完成：{}", value);
+    }
+}

Procedure/backend/project/src/main/java/com/sundata/product/rwa/calc/param/ParamCalcSQLMap.java

@@ -0,0 +1,42 @@
+package com.sundata.product.rwa.calc.param;
+
+import cn.hutool.extra.spring.SpringUtil;
+import com.sundata.product.rwa.calc.model.ParamCalcModel;
+import com.sundata.product.rwa.calc.param.interfaces.ParamCalc;
+import com.sundata.product.rwa.calc.service.implement.extend.UpperMapRowMapper;
+import org.apache.commons.text.StringSubstitutor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.jdbc.core.JdbcTemplate;
+
+import javax.sql.DataSource;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 通过 SQL 处理返回结果为 Map
+ */
+public class ParamCalcSQLMap implements ParamCalc {
+    private static final Logger log = LoggerFactory.getLogger(ParamCalcSQLMap.class);
+
+    @Override
+    public void calc(ParamCalcModel model, Map<String, Object> context) {
+
+        String sql = model.getParamCalcGetdata();
+        if (context != null) {
+            StringSubstitutor sub = new StringSubstitutor(context);
+            sql = sub.replace(sql);
+        }
+        JdbcTemplate jdbcTemplate = SpringUtil.getBean(JdbcTemplate.class);
+        if (jdbcTemplate == null) {
+            jdbcTemplate = new JdbcTemplate(SpringUtil.getBean(DataSource.class));
+        }
+        List<Map<String,Object>> mapList = jdbcTemplate.query(sql,new UpperMapRowMapper());
+        if (mapList.isEmpty()) {
+            log.error("脚本没有执行结果，请检查SQL逻辑:{}",model.getParamCalcGetdata());
+            throw new ArrayIndexOutOfBoundsException("脚本没有执行结果，请检查SQL逻辑");
+        }
+
+        model.setValue(mapList.get(0));
+    }
+}

Procedure/backend/project/src/main/java/com/sundata/product/rwa/calc/param/ParamCalcSQLMapList.java

@@ -0,0 +1,37 @@
+package com.sundata.product.rwa.calc.param;
+
+import cn.hutool.extra.spring.SpringUtil;
+import com.sundata.product.rwa.calc.model.ParamCalcModel;
+import com.sundata.product.rwa.calc.param.interfaces.ParamCalc;
+import com.sundata.product.rwa.calc.service.implement.extend.UpperMapRowMapper;
+import org.apache.commons.text.StringSubstitutor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.jdbc.core.JdbcTemplate;
+
+import javax.sql.DataSource;
+import java.util.List;
+import java.util.Map;
+
+public class ParamCalcSQLMapList implements ParamCalc {
+    private static final Logger log = LoggerFactory.getLogger(ParamCalcSQLMapList.class);
+
+    @Override
+    public void calc(ParamCalcModel model, Map<String, Object> context) {
+        String sql = model.getParamCalcGetdata();
+        if (context != null) {
+            StringSubstitutor sub = new StringSubstitutor(context);
+            sql = sub.replace(sql);
+        }
+        JdbcTemplate jdbcTemplate = SpringUtil.getBean(JdbcTemplate.class);
+        if (jdbcTemplate == null) {
+            jdbcTemplate = new JdbcTemplate(SpringUtil.getBean(DataSource.class));
+        }
+        List<Map<String, Object>> mapList = jdbcTemplate.query(sql, new UpperMapRowMapper());
+        if (mapList.isEmpty()) {
+            log.error("脚本没有执行结果，请检查SQL逻辑:{}", model.getParamCalcGetdata());
+            throw new ArrayIndexOutOfBoundsException("脚本没有执行结果，请检查SQL逻辑");
+        }
+        model.setValue(mapList);
+    }
+}

Procedure/backend/project/src/main/java/com/sundata/product/rwa/calc/param/interfaces/ParamCalc.java

@@ -0,0 +1,20 @@
+package com.sundata.product.rwa.calc.param.interfaces;
+
+import com.sundata.product.rwa.calc.model.ParamCalcModel;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Map;
+
+/**
+ * 根据实际情况针对不同类型的数据处理接口 常量、实现类、SQL语句 根据数据类型处理，若SQLMAP 与 SQLList 则按照实际的数据类型定义处理
+ */
+public interface ParamCalc {
+
+    /**
+     * 计算过程，主要用于参数的计算 计算过程应当对 model 中的 value 赋值
+     * @param model 参数对象，参数对象内容，需要处理计算逻辑再对 value 属性赋值
+     * @param context 计算用的参数
+     */
+    void calc(ParamCalcModel model, Map<String,Object> context);
+}

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

@@ -40,19 +40,19 @@ public class CalcRunningService {
             throw new CalcException("缺少必要参数 dataDate，请在传入参数中必要的传入 dataDate");
         }
         Calendar calendar = DateChecker.getSimpleCalendar((String) context.get("dataDate"));
-        if (!context.containsKey("SDATE") && StrUtil.isBlank(context.get("SDATE").toString())) {
+        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())) {
+        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())) {
+        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())) {
+        if (!context.containsKey("DATA_DATE") || StrUtil.isBlank(context.get("DATA_DATE").toString())) {
             log.warn("没有传入 DATA_DATE 通过 dataDate 转换获取");
             context.put("DATA_DATE", context.get("dataDate"));
         }

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

@@ -0,0 +1,45 @@
+package com.sundata.product.rwa.calc.service;
+
+import com.sundata.product.rwa.calc.model.ParamCalcModel;
+import com.sundata.product.rwa.calc.model.ParamCalcType;
+import com.sundata.product.rwa.calc.param.interfaces.ParamCalc;
+import com.sundata.product.rwa.reportformconfigreportcreater.mapper.ReportParamDefineMapper;
+import com.sundata.product.rwa.reportformconfigreportcreater.model.ReportParamDefineModel;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 报表参数计算的过程处理
+ */
+@Service
+public class ParamCalcService {
+
+    @Autowired
+    ReportParamDefineMapper reportParamDefineMapper;
+
+    /**
+     * 获取并计算全部报表参数
+     * @param calcindex 计算流水号
+     * @param dataDate 计算数据日期
+     * @return 全部报表参数配置的报表内容
+     */
+    public List<ParamCalcModel> calc(String calcindex, String dataDate , Map<String ,Object> context) {
+        List<ParamCalcModel> models = new ArrayList<>();
+        List<ReportParamDefineModel> paramDefineModels = reportParamDefineMapper.getDataList(new ReportParamDefineModel());
+        for (ReportParamDefineModel paramDefineModel : paramDefineModels) {
+            ParamCalcModel model = new ParamCalcModel(calcindex, dataDate, paramDefineModel);
+            ParamCalc paramCalc = ParamCalcType.getParamCalcType(model.getValueDataType()).getParamCalc(null);
+            if (paramCalc != null) {
+                paramCalc.calc(model,context);
+            }
+            models.add(model);
+        }
+        return models;
+    }
+
+}

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

@@ -0,0 +1,7 @@
+package com.sundata.product.rwa.calc.service;
+
+/**
+ * 报表计算过程逻辑
+ */
+public class ReportCalcService {
+}

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

@@ -0,0 +1,18 @@
+package com.sundata.product.rwa.calc.service;
+
+import com.sundata.product.rwa.reportformconfigreportcreater.mapper.ReportFillingConfigMapper;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+/**
+ * 报表参数计算逻辑
+ */
+@Service
+public class ReportParamCalcService {
+
+
+    @Autowired
+    ReportFillingConfigMapper reportFillingConfigMapper;
+
+
+}

Procedure/backend/project/src/main/java/com/sundata/product/rwa/calc/service/finals/CalcType.java

@@ -2,7 +2,10 @@ package com.sundata.product.rwa.calc.service.finals;
 
 public enum CalcType {
 
-    MAIN("计算任务"), STAGE("阶段"), DataImport("数据补录"), DataQuality("数据质量"), GeneralLedger("总账勾稽"),GeneralLedgerGetter("总账取数"), ProjectDivision("项目划分"), RiskExposure("风险暴露分类"), QualifiedSlowRelease("合格缓释认定"), SingleRWA("单笔债项RWA"), IntegratedRWA("法人RWA"), ReportInit("报表填报"), SQL("SQL任务");
+    MAIN("计算任务"), STAGE("阶段"), DataImport("数据补录"), DataQuality("数据质量"), GeneralLedger("总账勾稽"),GeneralLedgerGetter("总账取数"), ProjectDivision("项目划分"), RiskExposure("风险暴露分类"), QualifiedSlowRelease("合格缓释认定"), SingleRWA("单笔债项RWA"), IntegratedRWA("法人RWA"), ReportInit("报表填报"), SQL("SQL任务")
+    ,REPORTPARAM("报表参数计算"),ReportFill("报表生成"),PARAM("参数计算")
+    ;
+
 
     private final String name;
     private String id;

Procedure/backend/project/src/main/java/com/sundata/product/rwa/reportformconfigreportcreater/action/ReportFillingConfigAction.java

@@ -36,12 +36,12 @@ public class ReportFillingConfigAction extends BaseAction {
     }
 
     /**
-     * @author: 张艳杰
-     * @methodsName: createReportData
-     * @description: 获取当前树节点数据
+     * @author 张艳杰
+     * @methodsName createReportData
+     * @description 获取当前树节点数据
      * @param: HttpServletRequest request, HttpServletResponse response, @RequestBody ReportDefinitionModel model
-     * @return:
-     * @throws:
+     * @return
+     * @throws
      */
     @RequestMapping({"createReportData"})
     public void createReportData(HttpServletRequest request, HttpServletResponse response,
@@ -178,7 +178,7 @@ public class ReportFillingConfigAction extends BaseAction {
      */
     @RequestMapping({"isNotExist"})
     public void isNotExist(HttpServletRequest request, HttpServletResponse response, @RequestBody ReportDefinitionModel model) {
-        if (null != model && !model.getReportNo().isEmpty()){
+        if (null != model && model.getReportNo() != null && !model.getReportNo().isEmpty()){
             ReportDefinitionModel checkModel = reportFillingConfigService.selectReportData(model);
             if (null != checkModel) {
                 sendData(response,"该代码已存在");

Procedure/backend/project/src/main/java/com/sundata/product/rwa/reportformconfigreportcreater/service/ReportFillingConfigService.java

@@ -9,6 +9,7 @@ import com.sundata.product.rwa.datasupplementary.model.DictContentList;
 import com.sundata.product.rwa.reportformconfigreportcreater.mapper.ReportFillingConfigMapper;
 import com.sundata.product.rwa.reportformconfigreportcreater.model.ReportCalculationModel;
 import com.sundata.product.rwa.reportformconfigreportcreater.model.ReportDefinitionModel;
+import com.sundata.product.rwa.util.DataUtil;
 import org.apache.commons.collections.map.HashedMap;
 import org.apache.poi.hssf.usermodel.HSSFWorkbook;
 import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
@@ -17,6 +18,7 @@ import org.apache.poi.xssf.usermodel.XSSFWorkbook;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.dao.support.DataAccessUtils;
 import org.springframework.stereotype.Service;
 
 import java.io.*;
@@ -43,7 +45,7 @@ public class ReportFillingConfigService {
     }
 
     public void updateReportData(ReportDefinitionModel model) {
-        double version = Double.parseDouble(model.getReportVersion());
+        double version = (Double)DataUtil.getDataDefault(model.getReportVersion(),Double.class);
         model.setReportVersion(String.valueOf(new DecimalFormat("#.##").format(version + 0.1)));
         reportFillingConfigMapper.updateReportData(model);
     }

Procedure/backend/project/src/main/java/com/sundata/product/rwa/reportformconfigreportcreater/service/calc/ReportParamCalcUnit.java

@@ -0,0 +1,53 @@
+package com.sundata.product.rwa.reportformconfigreportcreater.service.calc;
+
+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 java.util.List;
+import java.util.Map;
+
+public class ReportParamCalcUnit extends CalcUnit {
+    /**
+     * 创建数据单元的绝对对象，对象必须包含如下参数
+     *
+     * @param calcCode    计算对象编号
+     * @param calcName    计算对象名称
+     * @param calcType    计算类型
+     * @param sequence
+     * @param initContext 计算单元初始化参数
+     */
+    public ReportParamCalcUnit(String calcCode, String calcName, CalcType calcType, int sequence, Map<String, Object> initContext) {
+        super(calcCode, calcName, calcType, sequence, initContext);
+    }
+
+    @Override
+    public boolean isCalcFinished(String calculateInstanceNumber) {
+        return false;
+    }
+
+    @Override
+    public void initResultContext(String calculateInstanceNumber) {
+
+    }
+
+    @Override
+    public List<CalcUnit> getSourceCalcUnits() {
+        return List.of();
+    }
+
+    @Override
+    public void afterCalc(Map<String, Object> context) {
+
+    }
+
+    @Override
+    public void beforeCalc(Map<String, Object> context) {
+
+    }
+
+    @Override
+    public void calc(CalcResult<String, Object> thisResult, String calculateInstanceNumber, Map<String, Object> context, Map<CalcUnit, CalcResult<String, Object>> sourceResults) {
+
+    }
+}