fjhx-cloud/hx-service-api/service-flow-api/src/main/java/com/fjhx/utils/FlowConstructor.java

package com.fjhx.utils;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.extra.spring.SpringUtil;
import com.alibaba.fastjson.JSONObject;
import com.fjhx.constants.FlowConstant;
import com.fjhx.constants.FlowExplainConstant;
import com.fjhx.constants.StatusConstant;
import com.fjhx.entity.example.ExampleDetails;
import com.fjhx.entity.example.ExampleInfo;
import com.fjhx.entity.process.ProcessNodeButton;
import com.fjhx.entity.process.ProcessTenant;
import com.fjhx.enums.ButtonNameEnum;
import com.fjhx.feign.IFlowClient;
import com.fjhx.params.ExampleInfoEx;
import com.fjhx.params.FlowInfo;
import com.fjhx.params.GetNodeButtonVo;
import org.springblade.core.tool.api.R;

public class FlowConstructor {

    private static final IFlowClient flowClient = SpringUtil.getBean(IFlowClient.class);

    private ExampleAbstract exampleAbstract;

    private FlowConstructor() {

    }

    /**
     * 初始化
     */
    public static FlowConstructor init(ExampleAbstract exampleAbstract) {
        FlowConstructor flowConstructor = new FlowConstructor();
        flowConstructor.exampleAbstract = exampleAbstract;
        return flowConstructor;
    }

    /**
     * 创建流程
     *
     * @param flowLinkNo 流程关联编号
     * @return 流程实例对象
     */
    public ExampleInfo create(Long flowLinkNo, String remarks) {

        // 获取流程编码
        String code = exampleAbstract.getCode();
        Assert.notEmpty(code, FlowExplainConstant.CODE_EMPTY);

        // 获取租户流程
        R<FlowInfo> r = flowClient.getProcessTenant(flowLinkNo, code);
        Assert.eqTrue(r.isSuccess(), r.getMsg());
        FlowInfo flowInfo = r.getData();

        // 创建流程实例
        ExampleInfoEx exampleInfo = new ExampleInfoEx();
        exampleInfo.setProcessInfoId(flowInfo.getId());
        exampleInfo.setFlowLinkNo(flowLinkNo);
        if (ObjectUtil.isNotEmpty(exampleAbstract.cacheData)) {
            exampleInfo.setCacheData(JSONObject.toJSONString(exampleAbstract.cacheData));
        }

        ExampleDetails startExampleDetails = new ExampleDetails();
        startExampleDetails.setRemarks(remarks);

        // 如果租户流程为空,直接完成流程
        ProcessTenant processTenant = flowInfo.processTenantEntity();
        if (ObjectUtil.isEmpty(processTenant)) {
            exampleInfo.setProcessNodeId(FlowConstant.OVER_PROCESS_FLAG);
            exampleInfo.setComplete(StatusConstant.YES);
            exampleInfo.setProcessNodeCode(FlowConstant.END_CODE);

            startExampleDetails.setNameType(ButtonNameEnum.START.getType());
            // 执行流程结束方法
            exampleAbstract.end();
        }
        // 租户流程不为空，走租户流程
        else {
            Long processTenantId = processTenant.getId();

            // 赋值租户流程id
            exampleInfo.setProcessTenantId(processTenantId);

            // 调用方法查看是否有指定跳转节点,没有则正常流转
            String circulation = exampleAbstract.circulation(FlowConstant.START_CODE);

            GetNodeButtonVo getNodeButtonVo = new GetNodeButtonVo();
            getNodeButtonVo.setProcessTenantId(processTenantId);
            getNodeButtonVo.setNodeCode(ObjectUtil.isEmpty(circulation) ? FlowConstant.START_CODE : circulation);

            R<ProcessNodeButton> nodeButtonResult = flowClient.getNodeButton(getNodeButtonVo);
            Assert.eqTrue(nodeButtonResult.isSuccess(), nodeButtonResult.getMsg());

            ProcessNodeButton processNodeButton = nodeButtonResult.getData();
            startExampleDetails.setProcessNodeId(processNodeButton.getProcessNodeId());
            startExampleDetails.setProcessNodeButtonId(processNodeButton.getId());
            startExampleDetails.setNameType(processNodeButton.getNameType());

            // 流转节点
            Long jumpNodeId = processNodeButton.getJumpNodeId();

            // 流程结束
            if (jumpNodeId.equals(FlowConstant.OVER_PROCESS_FLAG)) {
                exampleInfo.setComplete(StatusConstant.YES);
                exampleInfo.setProcessNodeCode(FlowConstant.END_CODE);
                exampleAbstract.end();
            }
            // 正常流转到下一节点
            else {
                exampleInfo.setComplete(StatusConstant.No);
            }

            // 赋值跳转节点id
            exampleInfo.setProcessNodeId(jumpNodeId);
            exampleInfo.setProcessNodeCode(processNodeButton.getProcessNodeCode());
        }
        exampleInfo.setExampleDetails(startExampleDetails);

        // 保存流程实例
        R<ExampleInfo> exampleInfoSaveResult = flowClient.exampleInfoSave(exampleInfo);
        Assert.eqTrue(exampleInfoSaveResult.isSuccess(), exampleInfoSaveResult.getMsg());

        return exampleInfoSaveResult.getData();
    }

    /**
     * 流程跳转
     *
     * @param flowLinkNo 流程关联编号
     * @param buttonId   按钮id
     * @param remarks    审批意见
     */
    public void jump(Long flowLinkNo, Long buttonId, String remarks) {

        R<ExampleInfo> exampleInfoResult = flowClient.getExampleInfo(flowLinkNo);
        Assert.eqTrue(exampleInfoResult.isSuccess(), exampleInfoResult.getMsg());

        ExampleInfo exampleInfo = exampleInfoResult.getData();

        // 获取流程缓存
        exampleAbstract.cacheData = exampleInfo.getCacheData();

        // 赋值新缓存
        if (ObjectUtil.isNotEmpty(exampleAbstract.cacheData)) {
            exampleInfo.setCacheData(JSONObject.toJSONString(exampleAbstract.cacheData));
        }

        // 调用方法查看是否有指定跳转节点,没有则正常流转
        GetNodeButtonVo getNodeButtonVo = new GetNodeButtonVo();
        getNodeButtonVo.setProcessTenantId(exampleInfo.getProcessTenantId());
        getNodeButtonVo.setNodeCode(exampleAbstract.circulation(exampleInfo.getProcessNodeCode()));
        getNodeButtonVo.setButtonId(buttonId);

        R<ProcessNodeButton> nodeButtonResult = flowClient.getNodeButton(getNodeButtonVo);
        Assert.eqTrue(nodeButtonResult.isSuccess(), nodeButtonResult.getMsg());

        ProcessNodeButton processNodeButton = nodeButtonResult.getData();

        // 赋值跳转节点id
        exampleInfo.setProcessNodeId(processNodeButton.getJumpNodeId());
        exampleInfo.setProcessNodeCode(processNodeButton.getProcessNodeCode());

        // 流程正常结束
        if (processNodeButton.getJumpNodeId().equals(FlowConstant.OVER_PROCESS_FLAG)) {
            exampleInfo.setComplete(StatusConstant.YES);
            exampleInfo.setProcessNodeCode(FlowConstant.END_CODE);
            exampleAbstract.end();
        }
        // 驳回结束
        else if (ButtonNameEnum.REJECT.getType().equals(processNodeButton.getNameType())) {
            exampleInfo.setComplete(StatusConstant.YES);
            exampleInfo.setProcessNodeCode(FlowConstant.END_CODE);
            exampleAbstract.fail(processNodeButton.getProcessNodeCode());
        }
        // 正常流转到下一节点
        else {
            exampleInfo.setComplete(StatusConstant.No);
        }

        // 流程明细
        ExampleDetails startExampleDetails = new ExampleDetails();
        startExampleDetails.setRemarks(remarks);
        startExampleDetails.setProcessNodeId(processNodeButton.getProcessNodeId());
        startExampleDetails.setProcessNodeButtonId(processNodeButton.getId());
        startExampleDetails.setNameType(processNodeButton.getNameType());

        // 创建vo
        ExampleInfoEx exampleInfoEx = BeanUtil.toBean(exampleInfo, ExampleInfoEx.class);
        exampleInfoEx.setExampleDetails(startExampleDetails);

        // 保存流程实例
        R<ExampleInfo> exampleInfoSaveResult = flowClient.exampleInfoSave(exampleInfoEx);
        Assert.eqTrue(exampleInfoSaveResult.isSuccess(), exampleInfoSaveResult.getMsg());

    }

}