ZKJServer/src/main/java/com/sundata/internalevaluation/calc/calcUnit/RuleCalcUnit.java

package com.sundata.internalevaluation.calc.calcUnit;

import cn.hutool.extra.spring.SpringUtil;
import com.sundata.common.util.StringUtil;
import com.sundata.internalevaluation.calc.model.CalcResult;
import com.sundata.internalevaluation.calc.model.CalcUnit;
import com.sundata.internalevaluation.calc.model.finals.CalcType;
import com.sundata.internalevaluation.configuration.model.IndexConfigModel;
import com.sundata.internalevaluation.configuration.model.SysReqRule;
import com.sundata.internalevaluation.configuration.service.IndexConfigService;
import com.sundata.internalevaluation.script.ScriptUtil;
import com.sundata.internalevaluation.script.TemplateUtil;

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * Created by IntelliJ IDEA.
 *
 * @author JoeLazy
 * @date 2025-02-12 09:31:30
 * @description: 规则计算单元
 */
public class RuleCalcUnit extends CalcUnit {

    private SysReqRule reqRule;

    private final IndexConfigService indexConfigService;

    /**
     * 创建数据单元的绝对对象，对象必须包含如下参数
     *
     * @param calcCode    计算对象编号
     * @param calcName    计算对象名称
     * @param calcType    计算类型
     * @param initContext 计算单元初始化参数
     */
    public RuleCalcUnit(String calcCode, String calcName, CalcType calcType, Map<String, Object> initContext, SysReqRule reqRule) {
        super(calcCode, calcName, calcType, initContext);
        this.reqRule = reqRule;
        this.indexConfigService = SpringUtil.getBean(IndexConfigService.class);
    }

    /**
     * 判断是否已经计算过数据了
     *
     * @param calculateInstanceNumber 计算流水号
     * @return 是否计算过 true 计算过 false 没有计算过
     */
    @Override
    public boolean isCalcFinished(String calculateInstanceNumber) {
        // TODO  是否计算完成
        return false;
    }

    /**
     * 初始化计算结果的方法，如果已经计算过，在实现过程中，应当在此方法中根据计算流水号重新初始化 resultContext 结果对象，为其他依赖对象做准备
     * 若明明计算过本单元但再次计算时没有初始化该对象，则计算依赖出现问题无法定位与处理
     *
     * @param calculateInstanceNumber 计算流水号
     */
    @Override
    public void initResultContext(String calculateInstanceNumber) {
        // TODO  初始化数据？？
    }

    /**
     * 根据节点配置获取源节点；
     *
     * @return 所有源头节点
     */
    @Override
    public List<CalcUnit> getSourceCalcUnits() {
        List<IndexConfigModel> indexConfigModels = indexConfigService.selectIndexListByRuleNo(this.reqRule.getRuleNo());
        return indexConfigModels.stream()
                .map(item -> new IndexCalcUnit(item.getIndexNo(), item.getIndexName(), Map.of(), item)).collect(Collectors.toList());
    }

    /**
     * 计算之后的方法，可实现为空
     *
     * @param context
     */
    @Override
    public void afterCalc(Map<String, Object> context) {

    }

    /**
     * 计算之前，可实现空
     *
     * @param context
     */
    @Override
    public void beforeCalc(Map<String, Object> context) {

    }

    /**
     * 必须实现的主体计算内容
     *
     * @param thisResult              本计算单元的结果
     * @param calculateInstanceNumber 计算流水号
     * @param context                 节点计算参数清单
     * @param sourceResults           源头计算节点的结果
     */
    @Override
    public void calc(CalcResult<String, Object> thisResult,
                     String calculateInstanceNumber,
                     Map<String, Object> context,
                     Map<CalcUnit, CalcResult<String, Object>> sourceResults) {

        // 获取道规则的计算模板或脚本
        String ruleTemplate = this.reqRule.getRuleTemplate();

        // 模板或脚本需要的参数
        // TODO 根据实际情况获取
        Map<String, Object> initContext = this.getInitContext();

        // 执行脚本  获取结果
        Object res = ScriptUtil.executeScript(String.valueOf(System.currentTimeMillis()), ruleTemplate, initContext);

        // 填充结果
        // true 表示出发规则 所以执行规则结果
        // false 未触发  所以 无执行
        thisResult.put(this.getCalcCode(), res.equals(true) ? reqRule.getRuleResult():"none");


        // ******************************
        String ruleConclusionTemplate = this.reqRule.getRuleConclusionTemplate();
        if (StringUtil.isNotEmpty(ruleConclusionTemplate)) {
            String result = TemplateUtil.execute("tempNo" + System.currentTimeMillis(), ruleConclusionTemplate, Map.of("result", res));
            System.err.printf("%s-%s-结论：%s\n\r", this.getCalcCode(), this.getCalcName(), result);
        } else {
            System.err.printf("%s-%s-[没有结论模板]....\n\r", this.getCalcCode(), this.getCalcName());
        }
    }
}