NodeStrategyManager.java

package com.codingapi.flow.manager;

import com.codingapi.flow.error.ErrorThrow;
import com.codingapi.flow.form.FlowForm;
import com.codingapi.flow.form.permission.FormFieldPermission;
import com.codingapi.flow.operator.IFlowOperator;
import com.codingapi.flow.session.FlowSession;
import com.codingapi.flow.strategy.node.*;
import lombok.Getter;

import java.util.ArrayList;
import java.util.List;

/**
 * 节点策略管理
 */
public class NodeStrategyManager {

    @Getter
    private final List<INodeStrategy> strategies;

    public NodeStrategyManager(List<INodeStrategy> strategies) {
        this.strategies = strategies;
    }

    /**
     * 获取超时时间
     */
    public long getTimeoutTime() {
        List<INodeStrategy> strategies = this.strategies;
        for (INodeStrategy strategy : strategies) {
            if (strategy instanceof TimeoutStrategy) {
                return System.currentTimeMillis() + ((TimeoutStrategy) strategy).getTimeoutTime();
            }
        }
        return 0;
    }

    /**
     * 是否可合并
     */
    public boolean isEnableMergeable() {
        List<INodeStrategy> strategies = this.strategies;
        for (INodeStrategy strategy : strategies) {
            if (strategy instanceof RecordMergeStrategy) {
                return ((RecordMergeStrategy) strategy).isEnable();
            }
        }
        return false;
    }

    /**
     * 合并审批类型
     */
    public RecordMergeStrategy.MergeType getMergeType() {
        List<INodeStrategy> strategies = this.strategies;
        for (INodeStrategy strategy : strategies) {
            if (strategy instanceof RecordMergeStrategy) {
                return ((RecordMergeStrategy) strategy).getMergeType();
            }
        }
        return RecordMergeStrategy.MergeType.APPROVER;
    }

    /**
     * 是否支持撤回
     */
    public boolean isEnableRevoke(){
        List<INodeStrategy> strategies = this.strategies;
        for (INodeStrategy strategy : strategies) {
            if (strategy instanceof RevokeStrategy) {
                return ((RevokeStrategy) strategy).isEnable();
            }
        }
        return false;
    }

    /**
     * 是否按顺序执行的审批策略
     */
    public boolean isSequenceMultiOperatorType() {
        List<INodeStrategy> strategies = this.strategies;
        for (INodeStrategy strategy : strategies) {
            if (strategy instanceof MultiOperatorAuditStrategy multiOperatorAuditStrategy) {
                return multiOperatorAuditStrategy.getType() == MultiOperatorAuditStrategy.Type.SEQUENCE;
            }
        }
        return false;
    }


    /**
     * 审批意见是否必填
     * <p>隐藏审批意见时必填不生效，避免用户无法填写意见导致流程卡死
     */
    public boolean isAdviceRequired() {
        List<INodeStrategy> strategies = this.strategies;
        for (INodeStrategy strategy : strategies) {
            if (strategy instanceof AdviceStrategy) {
                return ((AdviceStrategy) strategy).isAdviceRequired()
                        && !((AdviceStrategy) strategy).isAdviceHidden();
            }
        }
        return false;
    }

    /**
     * 是否隐藏审批意见
     */
    public boolean isAdviceHidden() {
        List<INodeStrategy> strategies = this.strategies;
        for (INodeStrategy strategy : strategies) {
            if (strategy instanceof AdviceStrategy) {
                return ((AdviceStrategy) strategy).isAdviceHidden();
            }
        }
        return false;
    }

    /**
     * 签名是否必填
     */
    public boolean isSignRequired() {
        List<INodeStrategy> strategies = this.strategies;
        for (INodeStrategy strategy : strategies) {
            if (strategy instanceof AdviceStrategy) {
                return ((AdviceStrategy) strategy).isSignRequired();
            }
        }
        return false;
    }


    /**
     * 是否恢复到退回节点
     */
    public boolean isResume() {
        List<INodeStrategy> strategies = this.strategies;
        for (INodeStrategy strategy : strategies) {
            if (strategy instanceof ResubmitStrategy) {
                return ((ResubmitStrategy) strategy).isResume();
            }
        }
        return false;
    }


    /**
     * 多操作者审批类型
     */
    public MultiOperatorAuditStrategy.Type getMultiOperatorAuditStrategyType() {
        List<INodeStrategy> strategies = this.strategies;
        for (INodeStrategy strategy : strategies) {
            if (strategy instanceof MultiOperatorAuditStrategy) {
                return ((MultiOperatorAuditStrategy) strategy).getType();
            }
        }
        return null;
    }

    /**
     * 多操作者审批并签比例
     */
    public float getMultiOperatorAuditMergePercent() {
        List<INodeStrategy> strategies = this.strategies;
        for (INodeStrategy strategy : strategies) {
            if (strategy instanceof MultiOperatorAuditStrategy) {
                return ((MultiOperatorAuditStrategy) strategy).getPercent();
            }
        }
        return 0;
    }

    /**
     * 提交人与审批人一致时是否自动审批
     *
     * <p>对应 {@link SameOperatorAuditStrategy.Type#AUTO_PASS}：
     * 当前节点的审批人为流程提交人本人时，自动通过该节点（无需本人审批，issue #224）。
     *
     * @return true 表示提交人与审批人相同时自动通过当前节点
     */
    public boolean isSameOperatorAutoPass() {
        SameOperatorAuditStrategy strategy = getStrategy(SameOperatorAuditStrategy.class);
        return strategy != null && strategy.getType() == SameOperatorAuditStrategy.Type.AUTO_PASS;
    }

    public void verifyNode(FlowForm form) {
        for (INodeStrategy strategy : strategies) {
            strategy.verifyNode(form);
        }
    }

    public String generateTitle(FlowSession session) {
        List<INodeStrategy> strategies = this.strategies;
        for (INodeStrategy strategy : strategies) {
            if (strategy instanceof NodeTitleStrategy) {
                return ((NodeTitleStrategy) strategy).generateTitle(session);
            }
        }
        return null;
    }

    /**
     * 获取操作人选择类型
     *
     * @return 操作人选择类型，若未配置则返回 null
     */
    public OperatorSelectType getOperatorSelectType() {
        for (INodeStrategy strategy : strategies) {
            if (strategy instanceof OperatorLoadStrategy) {
                return ((OperatorLoadStrategy) strategy).getSelectType();
            }
        }
        return null;
    }

    public OperatorManager loadOperators(FlowSession session) {
        List<INodeStrategy> strategies = this.strategies;
        for (INodeStrategy strategy : strategies) {
            if (strategy instanceof OperatorLoadStrategy) {
                return ((OperatorLoadStrategy) strategy).loadOperators(session);
            }
        }
        return new OperatorManager(new ArrayList<>());
    }

    /**
     * 计算节点的可选人员范围（发起人/审批人设定模式）
     *
     * @param session 目标节点会话
     * @return 可选人员范围，返回空表示不限范围（可选任意人）
     */
    public List<IFlowOperator> loadOperatorRange(FlowSession session) {
        OperatorLoadStrategy strategy = getStrategy(OperatorLoadStrategy.class);
        return strategy == null ? new ArrayList<>() : strategy.loadOperatorRange(session);
    }

    /**
     * 获取节点的最大可选人数
     *
     * @return 最大可选人数，-1 表示不限制；未配置 OperatorLoadStrategy 时返回 -1
     */
    public int getMaxOperatorCount() {
        OperatorLoadStrategy strategy = getStrategy(OperatorLoadStrategy.class);
        return strategy == null ? -1 : strategy.getMaxOperatorCount();
    }

    /**
     * 获取节点的字段权限配置
     */
    public List<FormFieldPermission> getFieldPermissions() {
        FormFieldPermissionStrategy formFieldPermissionStrategy = this.getStrategy(FormFieldPermissionStrategy.class);
        if(formFieldPermissionStrategy!=null){
            return formFieldPermissionStrategy.getFieldPermissions();
        }
        return new ArrayList<>();
    }

    public void verifySession(FlowSession session) {
        for (INodeStrategy strategy : strategies) {
            strategy.verifySession(session);
        }
    }

    @SuppressWarnings("unchecked")
    public <T extends INodeStrategy> T getStrategy(Class<T> clazz) {
        for (INodeStrategy strategy : strategies) {
            if (strategy.getClass() == clazz) {
                return (T) strategy;
            }
        }
        return null;
    }

    /**
     * 错误触发(没有匹配到人时执行的逻辑)
     *
     * @param session 触发会话
     * @return 错误触发
     */
    public ErrorThrow errorTrigger(FlowSession session) {
        List<INodeStrategy> strategies = this.strategies;
        for (INodeStrategy strategy : strategies) {
            if (strategy instanceof ErrorTriggerStrategy) {
                return ((ErrorTriggerStrategy) strategy).errorTrigger(session);
            }
        }
        return null;
    }


}