import type { Ref } from 'vue';
|
|
import type {
|
ConditionGroup,
|
HttpRequestParam,
|
SimpleFlowNode,
|
} from './consts';
|
|
import type { BpmUserGroupApi } from '#/api/bpm/userGroup';
|
import type { SystemDeptApi } from '#/api/system/dept';
|
import type { SystemPostApi } from '#/api/system/post';
|
import type { SystemRoleApi } from '#/api/system/role';
|
import type { SystemUserApi } from '#/api/system/user';
|
|
import { inject, nextTick, ref, toRaw, unref, watch } from 'vue';
|
|
import {
|
BpmNodeTypeEnum,
|
BpmTaskStatusEnum,
|
ProcessVariableEnum,
|
} from '@vben/constants';
|
|
import { parseFormFields } from '#/components/form-create';
|
|
import {
|
ApproveMethodType,
|
AssignEmptyHandlerType,
|
AssignStartUserHandlerType,
|
CandidateStrategy,
|
COMPARISON_OPERATORS,
|
ConditionType,
|
FieldPermissionType,
|
NODE_DEFAULT_NAME,
|
RejectHandlerType,
|
} from './consts';
|
|
export function useWatchNode(props: {
|
flowNode: SimpleFlowNode;
|
}): Ref<SimpleFlowNode> {
|
const node = ref<SimpleFlowNode>(props.flowNode);
|
watch(
|
() => props.flowNode,
|
(newValue) => {
|
node.value = newValue;
|
},
|
);
|
return node;
|
}
|
|
// 解析 formCreate 所有表单字段, 并返回
|
function parseFormCreateFields(formFields?: string[]) {
|
const result: Array<Record<string, any>> = [];
|
if (formFields) {
|
formFields.forEach((fieldStr: string) => {
|
parseFormFields(JSON.parse(fieldStr), result);
|
});
|
}
|
return result;
|
}
|
|
/**
|
* @description 表单数据权限配置，用于发起人节点 、审批节点、抄送节点
|
*/
|
export function useFormFieldsPermission(
|
defaultPermission: FieldPermissionType,
|
) {
|
// 字段权限配置. 需要有 field, title, permissioin 属性
|
const fieldsPermissionConfig = ref<Array<Record<string, any>>>([]);
|
|
const formType = inject<Ref<number | undefined>>('formType', ref()); // 表单类型
|
|
const formFields = inject<Ref<string[]>>('formFields', ref([])); // 流程表单字段
|
|
function getNodeConfigFormFields(
|
nodeFormFields?: Array<Record<string, string>>,
|
) {
|
nodeFormFields = toRaw(nodeFormFields);
|
fieldsPermissionConfig.value =
|
!nodeFormFields || nodeFormFields.length === 0
|
? getDefaultFieldsPermission(unref(formFields))
|
: mergeFieldsPermission(nodeFormFields, unref(formFields));
|
}
|
// 合并已经设置的表单字段权限，当前流程表单字段 (可能新增，或删除了字段)
|
function mergeFieldsPermission(
|
formFieldsPermisson: Array<Record<string, string>>,
|
formFields?: string[],
|
) {
|
let mergedFieldsPermission: Array<Record<string, any>> = [];
|
if (formFields) {
|
mergedFieldsPermission = parseFormCreateFields(formFields).map((item) => {
|
const found = formFieldsPermisson.find(
|
(fieldPermission) => fieldPermission.field === item.field,
|
);
|
return {
|
field: item.field,
|
title: item.title,
|
permission: found ? found.permission : defaultPermission,
|
};
|
});
|
}
|
return mergedFieldsPermission;
|
}
|
|
// 默认的表单权限： 获取表单的所有字段，设置字段默认权限为只读
|
function getDefaultFieldsPermission(formFields?: string[]) {
|
let defaultFieldsPermission: Array<Record<string, any>> = [];
|
if (formFields) {
|
defaultFieldsPermission = parseFormCreateFields(formFields).map(
|
(item) => {
|
return {
|
field: item.field,
|
title: item.title,
|
permission: defaultPermission,
|
};
|
},
|
);
|
}
|
return defaultFieldsPermission;
|
}
|
|
// 获取表单的所有字段，作为下拉框选项
|
const formFieldOptions = parseFormCreateFields(unref(formFields));
|
|
return {
|
formType,
|
fieldsPermissionConfig,
|
formFieldOptions,
|
getNodeConfigFormFields,
|
};
|
}
|
|
/**
|
* @description 获取流程表单的字段
|
*/
|
export function useFormFields() {
|
const formFields = inject<Ref<string[]>>('formFields', ref([])); // 流程表单字段
|
return parseFormCreateFields(unref(formFields));
|
}
|
|
// TODO @芋艿：后续需要把各种类似 useFormFieldsPermission 的逻辑，抽成一个通用方法。
|
/**
|
* @description 获取流程表单的字段和发起人字段
|
*/
|
export function useFormFieldsAndStartUser() {
|
const injectFormFields = inject<Ref<string[]>>('formFields', ref([])); // 流程表单字段
|
const formFields = parseFormCreateFields(unref(injectFormFields));
|
// 添加发起人
|
formFields.unshift({
|
field: ProcessVariableEnum.START_USER_ID,
|
title: '发起人',
|
required: true,
|
});
|
return formFields;
|
}
|
|
export type UserTaskFormType = {
|
approveMethod: ApproveMethodType;
|
approveRatio?: number;
|
assignEmptyHandlerType?: AssignEmptyHandlerType;
|
assignEmptyHandlerUserIds?: number[];
|
assignStartUserHandlerType?: AssignStartUserHandlerType;
|
buttonsSetting: any[];
|
candidateStrategy: CandidateStrategy;
|
deptIds?: number[]; // 部门
|
deptLevel?: number; // 部门层级
|
expression?: string; // 流程表达式
|
formDept?: string; // 表单内部门字段
|
formUser?: string; // 表单内用户字段
|
maxRemindCount?: number;
|
postIds?: number[]; // 岗位
|
reasonRequire: boolean;
|
rejectHandlerType?: RejectHandlerType;
|
returnNodeId?: string;
|
roleIds?: number[]; // 角色
|
signEnable: boolean;
|
skipExpression?: string; // 跳过表达式
|
taskAssignListener?: {
|
body: HttpRequestParam[];
|
header: HttpRequestParam[];
|
};
|
taskAssignListenerEnable?: boolean;
|
taskAssignListenerPath?: string;
|
taskCompleteListener?: {
|
body: HttpRequestParam[];
|
header: HttpRequestParam[];
|
};
|
taskCompleteListenerEnable?: boolean;
|
taskCompleteListenerPath?: string;
|
taskCreateListener?: {
|
body: HttpRequestParam[];
|
header: HttpRequestParam[];
|
};
|
taskCreateListenerEnable?: boolean;
|
taskCreateListenerPath?: string;
|
timeDuration?: number;
|
timeoutHandlerEnable?: boolean;
|
timeoutHandlerType?: number;
|
userGroups?: number[]; // 用户组
|
userIds?: number[]; // 用户
|
};
|
|
export type CopyTaskFormType = {
|
candidateStrategy: CandidateStrategy;
|
deptIds?: number[]; // 部门
|
deptLevel?: number; // 部门层级
|
expression?: string; // 流程表达式
|
formDept?: string; // 表单内部门字段
|
formUser?: string; // 表单内用户字段
|
postIds?: number[]; // 岗位
|
roleIds?: number[]; // 角色
|
userGroups?: number[]; // 用户组
|
userIds?: number[]; // 用户
|
};
|
|
/**
|
* @description 节点表单数据。 用于审批节点、抄送节点
|
*/
|
export function useNodeForm(nodeType: BpmNodeTypeEnum) {
|
const roleOptions = inject<Ref<SystemRoleApi.Role[]>>('roleList', ref([])); // 角色列表
|
const postOptions = inject<Ref<SystemPostApi.Post[]>>('postList', ref([])); // 岗位列表
|
const userOptions = inject<Ref<SystemUserApi.User[]>>('userList', ref([])); // 用户列表
|
const deptOptions = inject<Ref<SystemDeptApi.Dept[]>>('deptList', ref([])); // 部门列表
|
const userGroupOptions = inject<Ref<BpmUserGroupApi.UserGroup[]>>(
|
'userGroupList',
|
ref([]),
|
); // 用户组列表
|
const deptTreeOptions = inject<Ref<SystemDeptApi.Dept[]>>(
|
'deptTree',
|
ref([]),
|
); // 部门树
|
const formFields = inject<Ref<string[]>>('formFields', ref([])); // 流程表单字段
|
const configForm = ref<any | CopyTaskFormType | UserTaskFormType>();
|
|
if (
|
nodeType === BpmNodeTypeEnum.USER_TASK_NODE ||
|
nodeType === BpmNodeTypeEnum.TRANSACTOR_NODE
|
) {
|
configForm.value = {
|
candidateStrategy: CandidateStrategy.USER,
|
approveMethod: ApproveMethodType.SEQUENTIAL_APPROVE,
|
approveRatio: 100,
|
rejectHandlerType: RejectHandlerType.FINISH_PROCESS,
|
assignStartUserHandlerType: AssignStartUserHandlerType.START_USER_AUDIT,
|
returnNodeId: '',
|
timeoutHandlerEnable: false,
|
timeoutHandlerType: 1,
|
timeDuration: 6, // 默认 6小时
|
maxRemindCount: 1, // 默认 提醒 1次
|
buttonsSetting: [],
|
};
|
}
|
configForm.value = {
|
candidateStrategy: CandidateStrategy.USER,
|
};
|
|
function getShowText(): string {
|
let showText = '';
|
// 指定成员
|
if (
|
configForm.value?.candidateStrategy === CandidateStrategy.USER &&
|
configForm.value?.userIds?.length > 0
|
) {
|
const candidateNames: string[] = [];
|
userOptions?.value.forEach((item: any) => {
|
if (configForm.value?.userIds?.includes(item.id)) {
|
candidateNames.push(item.nickname);
|
}
|
});
|
showText = `指定成员：${candidateNames.join(',')}`;
|
}
|
// 指定角色
|
if (
|
configForm.value?.candidateStrategy === CandidateStrategy.ROLE &&
|
configForm.value.roleIds?.length > 0
|
) {
|
const candidateNames: string[] = [];
|
roleOptions?.value.forEach((item: any) => {
|
if (configForm.value?.roleIds?.includes(item.id)) {
|
candidateNames.push(item.name);
|
}
|
});
|
showText = `指定角色：${candidateNames.join(',')}`;
|
}
|
// 指定部门
|
if (
|
(configForm.value?.candidateStrategy === CandidateStrategy.DEPT_MEMBER ||
|
configForm.value?.candidateStrategy === CandidateStrategy.DEPT_LEADER ||
|
configForm.value?.candidateStrategy ===
|
CandidateStrategy.MULTI_LEVEL_DEPT_LEADER) &&
|
configForm.value?.deptIds?.length > 0
|
) {
|
const candidateNames: string[] = [];
|
deptOptions?.value.forEach((item) => {
|
if (configForm.value?.deptIds?.includes(item.id)) {
|
candidateNames.push(item.name);
|
}
|
});
|
if (
|
configForm.value.candidateStrategy === CandidateStrategy.DEPT_MEMBER
|
) {
|
showText = `部门成员：${candidateNames.join(',')}`;
|
} else if (
|
configForm.value.candidateStrategy === CandidateStrategy.DEPT_LEADER
|
) {
|
showText = `部门的负责人：${candidateNames.join(',')}`;
|
} else {
|
showText = `多级部门的负责人：${candidateNames.join(',')}`;
|
}
|
}
|
|
// 指定岗位
|
if (
|
configForm.value?.candidateStrategy === CandidateStrategy.POST &&
|
configForm.value.postIds?.length > 0
|
) {
|
const candidateNames: string[] = [];
|
postOptions?.value.forEach((item) => {
|
if (configForm.value?.postIds?.includes(item.id)) {
|
candidateNames.push(item.name);
|
}
|
});
|
showText = `指定岗位: ${candidateNames.join(',')}`;
|
}
|
// 指定用户组
|
if (
|
configForm.value?.candidateStrategy === CandidateStrategy.USER_GROUP &&
|
configForm.value?.userGroups?.length > 0
|
) {
|
const candidateNames: string[] = [];
|
userGroupOptions?.value.forEach((item) => {
|
if (configForm.value?.userGroups?.includes(item.id)) {
|
candidateNames.push(item.name);
|
}
|
});
|
showText = `指定用户组: ${candidateNames.join(',')}`;
|
}
|
|
// 表单内用户字段
|
if (configForm.value?.candidateStrategy === CandidateStrategy.FORM_USER) {
|
const formFieldOptions = parseFormCreateFields(unref(formFields));
|
const item = formFieldOptions.find(
|
(item) => item.field === configForm.value?.formUser,
|
);
|
showText = `表单用户：${item?.title}`;
|
}
|
|
// 表单内部门负责人
|
if (
|
configForm.value?.candidateStrategy === CandidateStrategy.FORM_DEPT_LEADER
|
) {
|
showText = `表单内部门负责人`;
|
}
|
|
// 审批人自选
|
if (
|
configForm.value?.candidateStrategy ===
|
CandidateStrategy.APPROVE_USER_SELECT
|
) {
|
showText = `审批人自选`;
|
}
|
|
// 发起人自选
|
if (
|
configForm.value?.candidateStrategy ===
|
CandidateStrategy.START_USER_SELECT
|
) {
|
showText = `发起人自选`;
|
}
|
// 发起人自己
|
if (configForm.value?.candidateStrategy === CandidateStrategy.START_USER) {
|
showText = `发起人自己`;
|
}
|
// 发起人的部门负责人
|
if (
|
configForm.value?.candidateStrategy ===
|
CandidateStrategy.START_USER_DEPT_LEADER
|
) {
|
showText = `发起人的部门负责人`;
|
}
|
// 发起人的部门负责人
|
if (
|
configForm.value?.candidateStrategy ===
|
CandidateStrategy.START_USER_MULTI_LEVEL_DEPT_LEADER
|
) {
|
showText = `发起人连续部门负责人`;
|
}
|
// 流程表达式
|
if (configForm.value?.candidateStrategy === CandidateStrategy.EXPRESSION) {
|
showText = `流程表达式：${configForm.value.expression}`;
|
}
|
return showText;
|
}
|
|
/**
|
* 处理候选人参数的赋值
|
*/
|
function handleCandidateParam() {
|
let candidateParam: string | undefined;
|
if (!configForm.value) {
|
return candidateParam;
|
}
|
switch (configForm.value.candidateStrategy) {
|
case CandidateStrategy.DEPT_LEADER:
|
case CandidateStrategy.DEPT_MEMBER: {
|
candidateParam = configForm.value.deptIds?.join(',');
|
break;
|
}
|
case CandidateStrategy.EXPRESSION: {
|
candidateParam = configForm.value.expression;
|
break;
|
}
|
// 表单内部门的负责人
|
case CandidateStrategy.FORM_DEPT_LEADER: {
|
// 候选人参数格式: | 分隔 。左边为表单内部门字段。 右边为部门层级
|
const deptFieldOnForm = configForm.value.formDept;
|
candidateParam = deptFieldOnForm?.concat(
|
`|${configForm.value.deptLevel}`,
|
);
|
break;
|
}
|
case CandidateStrategy.FORM_USER: {
|
candidateParam = configForm.value?.formUser;
|
break;
|
}
|
// 指定连续多级部门的负责人
|
case CandidateStrategy.MULTI_LEVEL_DEPT_LEADER: {
|
// 候选人参数格式: | 分隔 。左边为部门（多个部门用 , 分隔）。 右边为部门层级
|
const deptIds = configForm.value.deptIds?.join(',');
|
candidateParam = deptIds?.concat(`|${configForm.value.deptLevel}`);
|
break;
|
}
|
case CandidateStrategy.POST: {
|
candidateParam = configForm.value.postIds?.join(',');
|
break;
|
}
|
case CandidateStrategy.ROLE: {
|
candidateParam = configForm.value.roleIds?.join(',');
|
break;
|
}
|
// 发起人部门负责人
|
case CandidateStrategy.START_USER_DEPT_LEADER:
|
case CandidateStrategy.START_USER_MULTI_LEVEL_DEPT_LEADER: {
|
candidateParam = `${configForm.value.deptLevel}`;
|
break;
|
}
|
case CandidateStrategy.USER: {
|
candidateParam = configForm.value.userIds?.join(',');
|
break;
|
}
|
case CandidateStrategy.USER_GROUP: {
|
candidateParam = configForm.value.userGroups?.join(',');
|
break;
|
}
|
default: {
|
break;
|
}
|
}
|
return candidateParam;
|
}
|
/**
|
* 解析候选人参数
|
*/
|
function parseCandidateParam(
|
candidateStrategy: CandidateStrategy,
|
candidateParam: string | undefined,
|
) {
|
if (!configForm.value || !candidateParam) {
|
return;
|
}
|
switch (candidateStrategy) {
|
case CandidateStrategy.DEPT_LEADER:
|
case CandidateStrategy.DEPT_MEMBER: {
|
configForm.value.deptIds = candidateParam
|
.split(',')
|
.map((item) => +item);
|
break;
|
}
|
case CandidateStrategy.EXPRESSION: {
|
configForm.value.expression = candidateParam;
|
break;
|
}
|
// 表单内的部门负责人
|
case CandidateStrategy.FORM_DEPT_LEADER: {
|
// 候选人参数格式: | 分隔 。左边为表单内的部门字段。 右边为部门层级
|
const paramArray = candidateParam.split('|');
|
if (paramArray.length > 1) {
|
configForm.value.formDept = paramArray[0];
|
if (paramArray[1]) configForm.value.deptLevel = +paramArray[1];
|
}
|
break;
|
}
|
case CandidateStrategy.FORM_USER: {
|
configForm.value.formUser = candidateParam;
|
break;
|
}
|
// 指定连续多级部门的负责人
|
case CandidateStrategy.MULTI_LEVEL_DEPT_LEADER: {
|
// 候选人参数格式: | 分隔 。左边为部门（多个部门用 , 分隔）。 右边为部门层级
|
const paramArray = candidateParam.split('|') as string[];
|
if (paramArray.length > 1) {
|
configForm.value.deptIds = paramArray[0]
|
?.split(',')
|
.map((item) => +item);
|
if (paramArray[1]) configForm.value.deptLevel = +paramArray[1];
|
}
|
break;
|
}
|
case CandidateStrategy.POST: {
|
configForm.value.postIds = candidateParam
|
.split(',')
|
.map((item) => +item);
|
break;
|
}
|
case CandidateStrategy.ROLE: {
|
configForm.value.roleIds = candidateParam
|
.split(',')
|
.map((item) => +item);
|
break;
|
}
|
// 发起人部门负责人
|
case CandidateStrategy.START_USER_DEPT_LEADER:
|
case CandidateStrategy.START_USER_MULTI_LEVEL_DEPT_LEADER: {
|
configForm.value.deptLevel = +candidateParam;
|
break;
|
}
|
case CandidateStrategy.USER: {
|
configForm.value.userIds = candidateParam
|
.split(',')
|
.map((item) => +item);
|
break;
|
}
|
case CandidateStrategy.USER_GROUP: {
|
configForm.value.userGroups = candidateParam
|
.split(',')
|
.map((item) => +item);
|
break;
|
}
|
default: {
|
break;
|
}
|
}
|
}
|
return {
|
configForm,
|
roleOptions,
|
postOptions,
|
userOptions,
|
userGroupOptions,
|
deptTreeOptions,
|
handleCandidateParam,
|
parseCandidateParam,
|
getShowText,
|
};
|
}
|
|
/**
|
* @description 抽屉配置
|
*/
|
export function useDrawer() {
|
// 抽屉配置是否可见
|
const settingVisible = ref(false);
|
// 关闭配置抽屉
|
function closeDrawer() {
|
settingVisible.value = false;
|
}
|
// 打开配置抽屉
|
function openDrawer() {
|
settingVisible.value = true;
|
}
|
return {
|
settingVisible,
|
closeDrawer,
|
openDrawer,
|
};
|
}
|
|
/**
|
* @description 节点名称配置
|
*/
|
export function useNodeName(nodeType: BpmNodeTypeEnum) {
|
// 节点名称
|
const nodeName = ref<string>();
|
// 节点名称输入框
|
const showInput = ref(false);
|
// 输入框的引用
|
const inputRef = ref<HTMLInputElement | null>(null);
|
// 点击节点名称编辑图标
|
function clickIcon() {
|
showInput.value = true;
|
}
|
// 修改节点名称
|
function changeNodeName() {
|
showInput.value = false;
|
nodeName.value =
|
nodeName.value || (NODE_DEFAULT_NAME.get(nodeType) as string);
|
}
|
// 监听 showInput 的变化，当变为 true 时自动聚焦
|
watch(showInput, (value) => {
|
if (value) {
|
nextTick(() => {
|
inputRef.value?.focus();
|
});
|
}
|
});
|
|
return {
|
nodeName,
|
showInput,
|
inputRef,
|
clickIcon,
|
changeNodeName,
|
};
|
}
|
|
export function useNodeName2(
|
node: Ref<SimpleFlowNode>,
|
nodeType: BpmNodeTypeEnum,
|
) {
|
// 显示节点名称输入框
|
const showInput = ref(false);
|
// 输入框的引用
|
const inputRef = ref<HTMLInputElement | null>(null);
|
|
// 监听 showInput 的变化，当变为 true 时自动聚焦
|
watch(showInput, (value) => {
|
if (value) {
|
nextTick(() => {
|
inputRef.value?.focus();
|
});
|
}
|
});
|
|
// 修改节点名称
|
function changeNodeName() {
|
showInput.value = false;
|
node.value.name =
|
node.value.name || (NODE_DEFAULT_NAME.get(nodeType) as string);
|
console.warn('node.value.name===>', node.value.name);
|
}
|
// 点击节点标题进行输入
|
function clickTitle() {
|
showInput.value = true;
|
}
|
return {
|
showInput,
|
inputRef,
|
clickTitle,
|
changeNodeName,
|
};
|
}
|
|
/**
|
* @description 根据节点任务状态，获取节点任务状态样式
|
*/
|
export function useTaskStatusClass(
|
taskStatus: BpmTaskStatusEnum | undefined,
|
): string {
|
if (!taskStatus) {
|
return '';
|
}
|
if (taskStatus === BpmTaskStatusEnum.APPROVE) {
|
return 'status-pass';
|
}
|
if (taskStatus === BpmTaskStatusEnum.RUNNING) {
|
return 'status-running';
|
}
|
if (taskStatus === BpmTaskStatusEnum.REJECT) {
|
return 'status-reject';
|
}
|
if (taskStatus === BpmTaskStatusEnum.CANCEL) {
|
return 'status-cancel';
|
}
|
return '';
|
}
|
|
/** 条件组件文字展示 */
|
export function getConditionShowText(
|
conditionType: ConditionType | undefined,
|
conditionExpression: string | undefined,
|
conditionGroups: ConditionGroup | undefined,
|
fieldOptions: Array<Record<string, any>>,
|
) {
|
let showText: string | undefined;
|
if (conditionType === ConditionType.EXPRESSION && conditionExpression) {
|
showText = `表达式：${conditionExpression}`;
|
}
|
if (conditionType === ConditionType.RULE) {
|
// 条件组是否为与关系
|
const groupAnd = conditionGroups?.and;
|
let warningMessage: string | undefined;
|
const conditionGroup = conditionGroups?.conditions.map((item) => {
|
return `(${item.rules
|
.map((rule) => {
|
if (rule.leftSide && rule.rightSide) {
|
return `${getFormFieldTitle(
|
fieldOptions,
|
rule.leftSide,
|
)} ${getOpName(rule.opCode)} ${rule.rightSide}`;
|
} else {
|
// 有一条规则不完善。提示错误
|
warningMessage = '请完善条件规则';
|
return '';
|
}
|
})
|
.join(item.and ? ' 且 ' : ' 或 ')} ) `;
|
});
|
showText = warningMessage
|
? ''
|
: conditionGroup?.join(groupAnd ? ' 且 ' : ' 或 ');
|
}
|
return showText;
|
}
|
|
/** 获取表单字段名称*/
|
function getFormFieldTitle(
|
fieldOptions: Array<Record<string, any>>,
|
field: string,
|
) {
|
const item = fieldOptions.find((item) => item.field === field);
|
return item?.title;
|
}
|
|
/** 获取操作符名称 */
|
function getOpName(opCode: string): string | undefined {
|
const opName = COMPARISON_OPERATORS.find(
|
(item: any) => item.value === opCode,
|
);
|
return opName?.label;
|
}
|
|
/** 获取条件节点默认的名称 */
|
export function getDefaultConditionNodeName(
|
index: number,
|
defaultFlow: boolean | undefined,
|
): string {
|
if (defaultFlow) {
|
return '其它情况';
|
}
|
return `条件${index + 1}`;
|
}
|
|
/** 获取包容分支条件节点默认的名称 */
|
export function getDefaultInclusiveConditionNodeName(
|
index: number,
|
defaultFlow: boolean | undefined,
|
): string {
|
if (defaultFlow) {
|
return '其它情况';
|
}
|
return `包容条件${index + 1}`;
|
}
|
