const NODE_TYPE_META = {
|
EXECUTE: { text: '执行节点', type: 'primary' },
|
CHECK: { text: '检查点', type: 'warning' },
|
DECISION: { text: '决策点', type: 'success' }
|
}
|
|
const BOOLEAN_META = {
|
1: { text: '是', type: 'success', bool: true },
|
0: { text: '否', type: 'info', bool: false }
|
}
|
|
export const TASK_PATH_TEMPLATE_NODE_REPORT_TITLE = '任务路径模板节点报表'
|
export const TASK_PATH_TEMPLATE_NODE_REPORT_STYLE = {
|
titleAlign: 'center',
|
titleLevel: 'strong',
|
orientation: 'portrait',
|
density: 'compact',
|
showSequence: true
|
}
|
|
function normalizeText(value) {
|
return String(value ?? '').trim()
|
}
|
|
function normalizeNumber(value, fallback = void 0) {
|
if (value === '' || value === null || value === undefined) {
|
return fallback
|
}
|
const numberValue = Number(value)
|
return Number.isNaN(numberValue) ? fallback : numberValue
|
}
|
|
function normalizeMaybeNumber(value, fallback = void 0) {
|
if (value === '' || value === null || value === undefined) {
|
return fallback
|
}
|
const numberValue = Number(value)
|
return Number.isNaN(numberValue) ? fallback : numberValue
|
}
|
|
function normalizeMaybeText(value) {
|
return normalizeText(value)
|
}
|
|
function normalizeMaybeBooleanNumber(value, fallback = void 0) {
|
if (value === '' || value === null || value === undefined) {
|
return fallback
|
}
|
const numberValue = Number(value)
|
return Number.isNaN(numberValue) ? fallback : numberValue
|
}
|
|
export function createTaskPathTemplateNodeSearchState() {
|
return {
|
condition: '',
|
templateId: void 0,
|
templateCode: '',
|
nodeOrder: void 0,
|
nodeCode: '',
|
nodeName: '',
|
nodeType: '',
|
systemCode: '',
|
systemName: '',
|
executeParams: '',
|
resultSchema: '',
|
timeoutMinutes: void 0,
|
mandatory: '',
|
parallelExecutable: '',
|
preCondition: '',
|
postCondition: '',
|
nextNodeRules: '',
|
timeStart: '',
|
timeEnd: ''
|
}
|
}
|
|
export function createTaskPathTemplateNodeFormState() {
|
return {
|
id: void 0,
|
templateId: void 0,
|
templateCode: '',
|
nodeOrder: 1,
|
nodeCode: '',
|
nodeName: '',
|
nodeType: 'EXECUTE',
|
systemCode: '',
|
systemName: '',
|
executeParams: '',
|
resultSchema: '',
|
timeoutMinutes: void 0,
|
mandatory: 1,
|
parallelExecutable: 0,
|
preCondition: '',
|
postCondition: '',
|
nextNodeRules: ''
|
}
|
}
|
|
export function getTaskPathTemplateNodePaginationKey() {
|
return {
|
current: 'current',
|
size: 'pageSize'
|
}
|
}
|
|
export function getTaskPathTemplateNodeTypeOptions() {
|
return [
|
{ label: '执行节点', value: 'EXECUTE' },
|
{ label: '检查点', value: 'CHECK' },
|
{ label: '决策点', value: 'DECISION' }
|
]
|
}
|
|
export function getTaskPathTemplateNodeBooleanOptions() {
|
return [
|
{ label: '否', value: 0 },
|
{ label: '是', value: 1 }
|
]
|
}
|
|
export function getTaskPathTemplateNodeTypeMeta(nodeType) {
|
const normalized = normalizeMaybeText(nodeType).toUpperCase()
|
if (normalized in NODE_TYPE_META) {
|
return NODE_TYPE_META[normalized]
|
}
|
return { text: normalized || '未知', type: 'info' }
|
}
|
|
export function getTaskPathTemplateNodeBooleanMeta(value) {
|
if (value === true || Number(value) === 1) {
|
return BOOLEAN_META[1]
|
}
|
if (value === false || Number(value) === 0) {
|
return BOOLEAN_META[0]
|
}
|
return { text: '未知', type: 'info', bool: false }
|
}
|
|
export function buildTaskPathTemplateNodeSearchParams(params = {}) {
|
const searchParams = {
|
condition: normalizeMaybeText(params.condition),
|
templateId: normalizeMaybeNumber(params.templateId),
|
templateCode: normalizeMaybeText(params.templateCode),
|
nodeOrder: normalizeMaybeNumber(params.nodeOrder),
|
nodeCode: normalizeMaybeText(params.nodeCode),
|
nodeName: normalizeMaybeText(params.nodeName),
|
nodeType: normalizeMaybeText(params.nodeType),
|
systemCode: normalizeMaybeText(params.systemCode),
|
systemName: normalizeMaybeText(params.systemName),
|
executeParams: normalizeMaybeText(params.executeParams),
|
resultSchema: normalizeMaybeText(params.resultSchema),
|
timeoutMinutes: normalizeMaybeNumber(params.timeoutMinutes),
|
mandatory: normalizeMaybeNumber(params.mandatory),
|
parallelExecutable: normalizeMaybeNumber(params.parallelExecutable),
|
preCondition: normalizeMaybeText(params.preCondition),
|
postCondition: normalizeMaybeText(params.postCondition),
|
nextNodeRules: normalizeMaybeText(params.nextNodeRules),
|
timeStart: normalizeMaybeText(params.timeStart),
|
timeEnd: normalizeMaybeText(params.timeEnd)
|
}
|
|
return Object.fromEntries(
|
Object.entries(searchParams).filter(([, value]) => value !== '' && value !== void 0 && value !== null)
|
)
|
}
|
|
export function buildTaskPathTemplateNodePageQueryParams(params = {}) {
|
return {
|
current: params.current || 1,
|
pageSize: params.pageSize || params.size || 20,
|
...buildTaskPathTemplateNodeSearchParams(params)
|
}
|
}
|
|
export function buildTaskPathTemplateNodeSavePayload(formData = {}) {
|
return {
|
...(formData.id !== void 0 && formData.id !== null && formData.id !== ''
|
? { id: Number(formData.id) }
|
: {}),
|
...(formData.templateId !== void 0 && formData.templateId !== null && formData.templateId !== ''
|
? { templateId: Number(formData.templateId) }
|
: {}),
|
templateCode: normalizeMaybeText(formData.templateCode) || '',
|
...(formData.nodeOrder !== void 0 && formData.nodeOrder !== null && formData.nodeOrder !== ''
|
? { nodeOrder: Number(formData.nodeOrder) }
|
: { nodeOrder: 1 }),
|
nodeCode: normalizeMaybeText(formData.nodeCode) || '',
|
nodeName: normalizeMaybeText(formData.nodeName) || '',
|
nodeType: normalizeMaybeText(formData.nodeType) || 'EXECUTE',
|
systemCode: normalizeMaybeText(formData.systemCode) || '',
|
systemName: normalizeMaybeText(formData.systemName) || '',
|
executeParams: normalizeMaybeText(formData.executeParams) || '',
|
resultSchema: normalizeMaybeText(formData.resultSchema) || '',
|
...(formData.timeoutMinutes !== void 0 && formData.timeoutMinutes !== null && formData.timeoutMinutes !== ''
|
? { timeoutMinutes: Number(formData.timeoutMinutes) }
|
: {}),
|
...(formData.mandatory !== void 0 && formData.mandatory !== null && formData.mandatory !== ''
|
? { mandatory: Number(formData.mandatory) }
|
: { mandatory: 1 }),
|
...(formData.parallelExecutable !== void 0 &&
|
formData.parallelExecutable !== null &&
|
formData.parallelExecutable !== ''
|
? { parallelExecutable: Number(formData.parallelExecutable) }
|
: { parallelExecutable: 0 }),
|
preCondition: normalizeMaybeText(formData.preCondition) || '',
|
postCondition: normalizeMaybeText(formData.postCondition) || '',
|
nextNodeRules: normalizeMaybeText(formData.nextNodeRules) || ''
|
}
|
}
|
|
export function buildTaskPathTemplateNodeDialogModel(record = {}) {
|
return {
|
...createTaskPathTemplateNodeFormState(),
|
...(record.id !== void 0 && record.id !== null && record.id !== '' ? { id: Number(record.id) } : {}),
|
...(record.templateId !== void 0 && record.templateId !== null && record.templateId !== ''
|
? { templateId: Number(record.templateId) }
|
: {}),
|
templateCode: normalizeMaybeText(record.templateCode || ''),
|
nodeOrder:
|
record.nodeOrder !== void 0 && record.nodeOrder !== null && record.nodeOrder !== ''
|
? Number(record.nodeOrder)
|
: 1,
|
nodeCode: normalizeMaybeText(record.nodeCode || ''),
|
nodeName: normalizeMaybeText(record.nodeName || ''),
|
nodeType: normalizeMaybeText(record.nodeType || '') || 'EXECUTE',
|
systemCode: normalizeMaybeText(record.systemCode || ''),
|
systemName: normalizeMaybeText(record.systemName || ''),
|
executeParams: normalizeMaybeText(record.executeParams || ''),
|
resultSchema: normalizeMaybeText(record.resultSchema || ''),
|
timeoutMinutes: normalizeMaybeNumber(record.timeoutMinutes, void 0),
|
mandatory:
|
record.mandatory !== void 0 && record.mandatory !== null && record.mandatory !== ''
|
? Number(record.mandatory)
|
: 1,
|
parallelExecutable:
|
record.parallelExecutable !== void 0 && record.parallelExecutable !== null && record.parallelExecutable !== ''
|
? Number(record.parallelExecutable)
|
: 0,
|
preCondition: normalizeMaybeText(record.preCondition || ''),
|
postCondition: normalizeMaybeText(record.postCondition || ''),
|
nextNodeRules: normalizeMaybeText(record.nextNodeRules || '')
|
}
|
}
|
|
export function normalizeTaskPathTemplateNodeDetailRecord(record = {}) {
|
const nodeTypeMeta = getTaskPathTemplateNodeTypeMeta(record.nodeType)
|
const mandatoryMeta = getTaskPathTemplateNodeBooleanMeta(record.mandatory)
|
const parallelMeta = getTaskPathTemplateNodeBooleanMeta(record.parallelExecutable)
|
|
return {
|
...record,
|
templateId: normalizeMaybeNumber(record.templateId, void 0),
|
templateCode: normalizeMaybeText(record.templateCode || ''),
|
nodeOrder: normalizeMaybeNumber(record.nodeOrder, void 0),
|
nodeCode: normalizeMaybeText(record.nodeCode || ''),
|
nodeName: normalizeMaybeText(record.nodeName || ''),
|
nodeType: normalizeMaybeText(record.nodeType || ''),
|
nodeTypeText: nodeTypeMeta.text,
|
nodeTypeType: nodeTypeMeta.type,
|
systemCode: normalizeMaybeText(record.systemCode || ''),
|
systemName: normalizeMaybeText(record.systemName || ''),
|
executeParams: normalizeMaybeText(record.executeParams || ''),
|
resultSchema: normalizeMaybeText(record.resultSchema || ''),
|
timeoutMinutes: normalizeMaybeNumber(record.timeoutMinutes, void 0),
|
mandatory: normalizeMaybeNumber(record.mandatory, void 0),
|
mandatoryText: mandatoryMeta.text,
|
mandatoryType: mandatoryMeta.type,
|
mandatoryBool: record.mandatoryBool !== void 0 ? Boolean(record.mandatoryBool) : mandatoryMeta.bool,
|
parallelExecutable: normalizeMaybeNumber(record.parallelExecutable, void 0),
|
parallelExecutableText: parallelMeta.text,
|
parallelExecutableType: parallelMeta.type,
|
parallelExecutableBool:
|
record.parallelExecutableBool !== void 0 ? Boolean(record.parallelExecutableBool) : parallelMeta.bool,
|
preCondition: normalizeMaybeText(record.preCondition || ''),
|
postCondition: normalizeMaybeText(record.postCondition || ''),
|
nextNodeRules: normalizeMaybeText(record.nextNodeRules || ''),
|
createByText: normalizeMaybeText(record.createBy$ || record.createByText || ''),
|
updateByText: normalizeMaybeText(record.updateBy$ || record.updateByText || ''),
|
createTimeText: normalizeMaybeText(record.createTime$ || record.createTime || ''),
|
updateTimeText: normalizeMaybeText(record.updateTime$ || record.updateTime || '')
|
}
|
}
|
|
export function normalizeTaskPathTemplateNodeListRow(record = {}) {
|
return normalizeTaskPathTemplateNodeDetailRecord(record)
|
}
|
|
export function buildTaskPathTemplateNodePrintRows(records = []) {
|
if (!Array.isArray(records)) {
|
return []
|
}
|
return records.map((record) => normalizeTaskPathTemplateNodeListRow(record))
|
}
|
|
export function buildTaskPathTemplateNodeReportMeta({
|
previewMeta = {},
|
count = 0,
|
orientation = TASK_PATH_TEMPLATE_NODE_REPORT_STYLE.orientation
|
} = {}) {
|
return {
|
reportTitle: TASK_PATH_TEMPLATE_NODE_REPORT_TITLE,
|
reportDate: previewMeta.reportDate,
|
printedAt: previewMeta.printedAt,
|
operator: previewMeta.operator,
|
count,
|
reportStyle: {
|
...TASK_PATH_TEMPLATE_NODE_REPORT_STYLE,
|
orientation
|
}
|
}
|
}
|
