dify/web/app/components/workflow/update-dsl-modal.helpers.ts

import type { TFunction } from 'i18next'
import type { CommonNodeType, Node } from './types'
import type { DSLImportWarning } from '@/models/app'
import { FILE_EXTS } from '@/app/components/base/prompt-editor/constants'
import { DSLImportStatus } from '@/models/app'
import { AppModeEnum } from '@/types/app'
import { getDSLImportWarningDescription } from '@/utils/dsl-import-warning'
import { loadYaml } from '@/utils/yaml'
import { BlockEnum, SupportUploadFileTypes } from './types'

type ParsedDSL = {
  workflow?: {
    graph?: {
      nodes?: Array<Node<CommonNodeType>>
    }
  }
}

type WorkflowFileUploadFeatures = {
  enabled?: boolean
  allowed_file_types?: SupportUploadFileTypes[]
  allowed_file_extensions?: string[]
  allowed_file_upload_methods?: string[]
  number_limits?: number
  image?: {
    enabled?: boolean
    number_limits?: number
    transfer_methods?: string[]
  }
}

type WorkflowFeatures = {
  file_upload?: WorkflowFileUploadFeatures
  opening_statement?: string
  suggested_questions?: string[]
  suggested_questions_after_answer?: { enabled: boolean }
  speech_to_text?: { enabled: boolean }
  text_to_speech?: { enabled: boolean }
  retriever_resource?: { enabled: boolean }
  sensitive_word_avoidance?: { enabled: boolean }
}

type ImportNotificationPayload = {
  type: 'success' | 'warning'
  message: string
  children?: string
}

export const getInvalidNodeTypes = (mode?: AppModeEnum) => {
  if (mode === AppModeEnum.ADVANCED_CHAT) {
    return [
      BlockEnum.End,
      BlockEnum.TriggerWebhook,
      BlockEnum.TriggerSchedule,
      BlockEnum.TriggerPlugin,
    ]
  }

  return [BlockEnum.Answer]
}

export const validateDSLContent = (content: string, mode?: AppModeEnum) => {
  try {
    const data = loadYaml(content) as ParsedDSL | undefined
    const nodes = data?.workflow?.graph?.nodes ?? []
    const invalidNodes = getInvalidNodeTypes(mode)
    return !nodes.some((node: Node<CommonNodeType>) => invalidNodes.includes(node?.data?.type))
  } catch {
    return false
  }
}

export const isImportCompleted = (status: DSLImportStatus) => {
  return status === DSLImportStatus.COMPLETED || status === DSLImportStatus.COMPLETED_WITH_WARNINGS
}

export const getImportNotificationPayload = (
  status: DSLImportStatus,
  t: TFunction,
  warnings: DSLImportWarning[] = [],
): ImportNotificationPayload => {
  return {
    type: status === DSLImportStatus.COMPLETED ? 'success' : 'warning',
    message:
      status === DSLImportStatus.COMPLETED
        ? t(($) => $['common.importSuccess'], { ns: 'workflow' })
        : t(($) => $['common.importWarning'], { ns: 'workflow' }),
    children:
      status === DSLImportStatus.COMPLETED_WITH_WARNINGS
        ? getDSLImportWarningDescription(warnings) ||
          t(($) => $['common.importWarningDetails'], { ns: 'workflow' })
        : undefined,
  }
}

export const normalizeWorkflowFeatures = (features: WorkflowFeatures) => {
  return {
    file: {
      image: {
        enabled: !!features.file_upload?.image?.enabled,
        number_limits: features.file_upload?.image?.number_limits || 3,
        transfer_methods: features.file_upload?.image?.transfer_methods || [
          'local_file',
          'remote_url',
        ],
      },
      enabled: !!(features.file_upload?.enabled || features.file_upload?.image?.enabled),
      allowed_file_types: features.file_upload?.allowed_file_types || [
        SupportUploadFileTypes.image,
      ],
      allowed_file_extensions:
        features.file_upload?.allowed_file_extensions ||
        FILE_EXTS[SupportUploadFileTypes.image]!.map((ext) => `.${ext}`),
      allowed_file_upload_methods: features.file_upload?.allowed_file_upload_methods ||
        features.file_upload?.image?.transfer_methods || ['local_file', 'remote_url'],
      number_limits:
        features.file_upload?.number_limits || features.file_upload?.image?.number_limits || 3,
    },
    opening: {
      enabled: !!features.opening_statement,
      opening_statement: features.opening_statement,
      suggested_questions: features.suggested_questions,
    },
    suggested: features.suggested_questions_after_answer || { enabled: false },
    speech2text: features.speech_to_text || { enabled: false },
    text2speech: features.text_to_speech || { enabled: false },
    citation: features.retriever_resource || { enabled: false },
    moderation: features.sensitive_word_avoidance || { enabled: false },
  }
}