in dolphinscheduler-ui/src/views/projects/task/components/node/fields/use-dependent.ts [41:560]
export function useDependent(model: { [field: string]: any }): IJsonItem[] {
const { t } = useI18n()
const router: Router = useRouter()
const nodeStore = useTaskNodeStore()
const dependentFailurePolicyOptions = computed(() => {
return [
{
label: t('project.node.dependent_failure_policy_failure'),
value: 'DEPENDENT_FAILURE_FAILURE'
},
{
label: t('project.node.dependent_failure_policy_waiting'),
value: 'DEPENDENT_FAILURE_WAITING'
}
]
})
const failureWaitingTimeSpan = computed(() =>
model.failurePolicy === 'DEPENDENT_FAILURE_WAITING' ? 12 : 0
)
const dependentResult = nodeStore.getDependentResult
const TasksStateConfig = tasksState(t)
const projectList = ref([] as IRenderOption[])
const workflowCache = {} as {
[key: number]: IRenderOption[]
}
const taskCache = {} as {
[key: number]: IRenderOption[]
}
const selectOptions = ref([] as IDependTaskOptions[])
const DependentTypeOptions = [
{
value: 'DEPENDENT_ON_WORKFLOW',
label: t('project.node.dependent_on_workflow')
},
{
value: 'DEPENDENT_ON_TASK',
label: t('project.node.dependent_on_task')
}
]
const CYCLE_LIST = [
{
value: 'day',
label: t('project.node.day')
},
{
value: 'hour',
label: t('project.node.hour')
},
{
value: 'week',
label: t('project.node.week')
},
{
value: 'month',
label: t('project.node.month')
}
]
const DATE_LIST = {
hour: [
{
value: 'currentHour',
label: t('project.node.current_hour')
},
{
value: 'last1Hour',
label: t('project.node.last_1_hour')
},
{
value: 'last2Hours',
label: t('project.node.last_2_hour')
},
{
value: 'last3Hours',
label: t('project.node.last_3_hour')
},
{
value: 'last24Hours',
label: t('project.node.last_24_hour')
}
],
day: [
{
value: 'today',
label: t('project.node.today')
},
{
value: 'last1Days',
label: t('project.node.last_1_days')
},
{
value: 'last2Days',
label: t('project.node.last_2_days')
},
{
value: 'last3Days',
label: t('project.node.last_3_days')
},
{
value: 'last7Days',
label: t('project.node.last_7_days')
}
],
week: [
{
value: 'thisWeek',
label: t('project.node.this_week')
},
{
value: 'lastWeek',
label: t('project.node.last_week')
},
{
value: 'lastMonday',
label: t('project.node.last_monday')
},
{
value: 'lastTuesday',
label: t('project.node.last_tuesday')
},
{
value: 'lastWednesday',
label: t('project.node.last_wednesday')
},
{
value: 'lastThursday',
label: t('project.node.last_thursday')
},
{
value: 'lastFriday',
label: t('project.node.last_friday')
},
{
value: 'lastSaturday',
label: t('project.node.last_saturday')
},
{
value: 'lastSunday',
label: t('project.node.last_sunday')
}
],
month: [
{
value: 'thisMonth',
label: t('project.node.this_month')
},
{
value: 'thisMonthBegin',
label: t('project.node.this_month_begin')
},
{
value: 'lastMonth',
label: t('project.node.last_month')
},
{
value: 'lastMonthBegin',
label: t('project.node.last_month_begin')
},
{
value: 'lastMonthEnd',
label: t('project.node.last_month_end')
}
]
} as { [key in IDateType]: { value: string; label: string }[] }
const getProjectList = async () => {
const result = await queryAllProjectListForDependent()
projectList.value = result.map((item: { code: number; name: string }) => ({
value: item.code,
label: () => h(NEllipsis, null, item.name),
filterLabel: item.name
}))
return projectList
}
const getWorkflowList = async (code: number) => {
if (workflowCache[code]) {
return workflowCache[code]
}
const result = await queryWorkflowDefinitionList(code)
const workflowList = result.map((item: { code: number; name: string }) => ({
value: item.code,
label: () => h(NEllipsis, null, item.name),
filterLabel: item.name
}))
workflowCache[code] = workflowList
return workflowList
}
const getTaskList = async (code: number, workflowCode: number) => {
if (taskCache[workflowCode]) {
return taskCache[workflowCode]
}
const result = await getTasksByDefinitionList(code, workflowCode)
const taskList = result.map((item: { code: number; name: string }) => ({
value: item.code,
label: () => h(NEllipsis, null, item.name),
filterLabel: item.name
}))
taskList.unshift({
value: -1,
label: 'ALL',
filterLabel: 'ALL'
})
taskCache[workflowCode] = taskList
return taskList
}
const renderState = (item: {
definitionCode: number
depTaskCode: number
projectCode: number
dateValue: string
}) => {
if (!item || router.currentRoute.value.name !== 'workflow-instance-detail')
return null
const key = `${item.projectCode}-${item.definitionCode}-${item.depTaskCode}-${item.dateValue}`
const state: ITaskState = dependentResult[key]
let icon: any
let color: string
if (state) {
icon = TasksStateConfig[state]?.icon
color = TasksStateConfig[state]?.color
} else {
icon = TasksStateConfig.RUNNING_EXECUTION.icon
color = TasksStateConfig.RUNNING_EXECUTION.color
}
return h(NIcon, { size: 24, color: color }, () => h(icon))
}
onMounted(() => {
getProjectList()
})
watch(
() => model.dependTaskList,
(value) => {
selectOptions.value = []
value.forEach((item: IDependTask, taskIndex: number) => {
if (!item.dependItemList?.length) return
const itemListOptions = ref([] as IDependentItemOptions[])
item.dependItemList?.forEach(
async (dependItem: IDependentItem, itemIndex: number) => {
itemListOptions.value[itemIndex] = {}
if (!dependItem.dependentType) {
if (dependItem.depTaskCode == 0)
dependItem.dependentType = 'DEPENDENT_ON_WORKFLOW'
else dependItem.dependentType = 'DEPENDENT_ON_TASK'
}
if (dependItem.projectCode) {
itemListOptions.value[itemIndex].definitionCodeOptions =
await getWorkflowList(dependItem.projectCode)
}
if (dependItem.projectCode && dependItem.definitionCode) {
itemListOptions.value[itemIndex].depTaskCodeOptions =
await getTaskList(
dependItem.projectCode,
dependItem.definitionCode
)
}
if (dependItem.cycle) {
itemListOptions.value[itemIndex].dateOptions =
DATE_LIST[dependItem.cycle]
}
}
)
selectOptions.value[taskIndex] = {} as IDependTaskOptions
selectOptions.value[taskIndex].dependItemList = itemListOptions.value
})
}
)
return [
...useDependentTimeout(model),
...useRelationCustomParams({
model,
children: (i = 0) => ({
type: 'custom-parameters',
field: 'dependItemList',
span: 18,
children: [
(j = 0) => ({
type: 'select',
field: 'dependentType',
name: t('project.node.dependent_type'),
span: 24,
props: {
onUpdateValue: (dependentType: string) => {
const item = model.dependTaskList[i].dependItemList[j]
if (item.definitionCode)
item.depTaskCode =
dependentType === 'DEPENDENT_ON_WORKFLOW' ? 0 : -1
}
},
options: DependentTypeOptions,
value: 'DEPENDENT_ON_WORKFLOW'
}),
(j = 0) => ({
type: 'select',
field: 'projectCode',
name: t('project.node.project_name'),
span: 24,
props: {
filterable: true,
filter: (query: string, option: IRenderOption) => {
return option.filterLabel
.toLowerCase()
.includes(query.toLowerCase())
},
onUpdateValue: async (projectCode: number) => {
const item = model.dependTaskList[i].dependItemList[j]
const options = selectOptions?.value[i] || {}
const itemListOptions = options?.dependItemList || []
const itemOptions = {} as IDependentItemOptions
itemOptions.definitionCodeOptions = await getWorkflowList(
projectCode
)
itemListOptions[j] = itemOptions
options.dependItemList = itemListOptions
selectOptions.value[i] = options
item.depTaskCode = null
item.definitionCode = null
item.parameterPassing = false
}
},
options: projectList,
path: `dependTaskList.${i}.dependItemList.${j}.projectCode`,
rule: {
required: true,
trigger: ['input', 'blur'],
validator(validate: any, value: string) {
if (!value) {
return Error(t('project.node.project_name_tips'))
}
}
}
}),
(j = 0) => ({
type: 'select',
field: 'definitionCode',
span: 24,
name: t('project.node.workflow_name'),
props: {
filterable: true,
filter: (query: string, option: IRenderOption) => {
return option.filterLabel
.toLowerCase()
.includes(query.toLowerCase())
},
onUpdateValue: async (workflowCode: number) => {
const item = model.dependTaskList[i].dependItemList[j]
selectOptions.value[i].dependItemList[j].depTaskCodeOptions =
await getTaskList(item.projectCode, workflowCode)
item.depTaskCode =
item.dependentType === 'DEPENDENT_ON_WORKFLOW' ? 0 : -1
}
},
options:
selectOptions.value[i]?.dependItemList[j]
?.definitionCodeOptions || [],
path: `dependTaskList.${i}.dependItemList.${j}.definitionCode`,
rule: {
required: true,
trigger: ['input', 'blur'],
validator(validate: any, value: string) {
if (!value) {
return Error(t('project.node.workflow_name_tips'))
}
}
}
}),
(j = 0) => ({
type: 'select',
field: 'depTaskCode',
span: computed(() => {
const item = model.dependTaskList[i].dependItemList[j]
return item.dependentType === 'DEPENDENT_ON_WORKFLOW' ? 0 : 24
}),
name: t('project.node.task_name'),
props: {
filterable: true,
filter: (query: string, option: IRenderOption) => {
return option.filterLabel
.toLowerCase()
.includes(query.toLowerCase())
}
},
options:
selectOptions.value[i]?.dependItemList[j]?.depTaskCodeOptions ||
[],
path: `dependTaskList.${i}.dependItemList.${j}.depTaskCode`,
rule: {
required: true,
trigger: ['input', 'blur'],
validator(validate: any, value: number) {
if (!value && value !== 0) {
return Error(t('project.node.task_name_tips'))
}
}
}
}),
(j = 0) => ({
type: 'select',
field: 'cycle',
span: 10,
name: t('project.node.cycle_time'),
props: {
onUpdateValue: (value: IDateType) => {
selectOptions.value[i].dependItemList[j].dateOptions =
DATE_LIST[value]
model.dependTaskList[i].dependItemList[j].dateValue = null
}
},
options: CYCLE_LIST,
value: CYCLE_LIST.length > 0 ? CYCLE_LIST[0].value : '',
path: `dependTaskList.${i}.dependItemList.${j}.cycle`,
rule: {
required: true,
trigger: ['input', 'blur'],
validator(validate: any, value: string) {
if (!value) {
return Error(t('project.node.cycle_time_tips'))
}
}
}
}),
(j = 0) => ({
type: 'select',
field: 'dateValue',
span: 10,
name: ' ',
options:
selectOptions.value[i]?.dependItemList[j]?.dateOptions ||
DATE_LIST.day,
value: DATE_LIST.day[0].value,
path: `dependTaskList.${i}.dependItemList.${j}.dateValue`,
rule: {
trigger: ['input', 'blur'],
validator(validate: any, value: string) {
if (!value) {
return Error(t('project.node.date_tips'))
}
}
}
}),
(j = 0) => ({
type: 'custom',
field: 'state',
span: 2,
name: ' ',
widget: renderState(model.dependTaskList[i]?.dependItemList[j])
}),
(j = 0) => ({
type: 'switch',
field: 'parameterPassing',
span: 20,
name: t('project.node.dependent_task_parameter_passing'),
path: `dependTaskList.${i}.dependItemList.${j}.parameterPassing`
})
]
}),
childrenField: 'dependItemList',
name: 'add_dependency'
}),
{
type: 'input-number',
field: 'checkInterval',
name: t('project.node.check_interval'),
span: 12,
props: {
max: Math.pow(9, 10) - 1
},
slots: {
suffix: () => t('project.node.second')
},
validate: {
trigger: ['input'],
validator(validate: any, value: number) {
if (!value && !/^[1-9]\d*$/.test(String(value))) {
return new Error(t('project.node.check_interval_tips'))
}
}
}
},
{
type: 'radio',
field: 'failurePolicy',
name: t('project.node.dependent_failure_policy'),
options: dependentFailurePolicyOptions,
span: 24
},
{
type: 'input-number',
field: 'failureWaitingTime',
name: t('project.node.dependent_failure_waiting_time'),
span: failureWaitingTimeSpan,
props: {
max: Math.pow(9, 10) - 1
},
slots: {
suffix: () => t('project.node.minute')
},
validate: {
trigger: ['input'],
required: true,
validator(validate: any, value: number) {
if (model.timeoutFlag && !/^[1-9]\d*$/.test(String(value))) {
return new Error(
t('project.node.dependent_failure_waiting_time_tips')
)
}
}
}
}
]
}