Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

15.6 KB
Raw Blame
import type { UploadConfig } from '@dify/contracts/api/console/files/types.gen'
import type { ClipboardEvent } from 'react'
import type { FileEntity } from './types'
import type { FileUpload } from '@/app/components/base/features/types'
import { useMutation } from '@tanstack/react-query'
import { noop } from 'es-toolkit/function'
import { produce } from 'immer'
import { useCallback, useState } from 'react'
import { useTranslation } from 'react-i18next'
import { v4 as uuid4 } from 'uuid'
import {
  AUDIO_SIZE_LIMIT,
  FILE_SIZE_LIMIT,
  IMG_SIZE_LIMIT,
  MAX_FILE_UPLOAD_LIMIT,
  SKILL_FILE_SIZE_LIMIT,
  VIDEO_SIZE_LIMIT,
} from '@/app/components/base/file-uploader/constants'
import { SupportUploadFileTypes } from '@/app/components/workflow/types'
import { toast } from '@/app/notifications'
import { isAppAccessError } from '@/features/app-access-error/state'
import { useParams } from '@/next/navigation'
import { uploadPublicRemoteFileInfo } from '@/service/common'
import { consoleQuery } from '@/service/console'
import { TransferMethod } from '@/types/app'
import { getErrorMessage } from '@/utils/error-message'
import { formatFileSize } from '@/utils/format'
import { isAbortError } from '@/utils/is-abort-error'
import { useFileStore } from './store'
import { useFileUploadContext } from './upload-context'
import {
  fileUpload,
  getFileUploadErrorMessage,
  getSupportFileType,
  isAllowedFileExtension,
} from './utils'

export const getFileSizeLimit = (fileUploadConfig?: UploadConfig) => {
  const imgSizeLimit =
    Number(fileUploadConfig?.image_file_size_limit) * 1024 * 1024 || IMG_SIZE_LIMIT
  const docSizeLimit = Number(fileUploadConfig?.file_size_limit) * 1024 * 1024 || FILE_SIZE_LIMIT
  const audioSizeLimit =
    Number(fileUploadConfig?.audio_file_size_limit) * 1024 * 1024 || AUDIO_SIZE_LIMIT
  const videoSizeLimit =
    Number(fileUploadConfig?.video_file_size_limit) * 1024 * 1024 || VIDEO_SIZE_LIMIT
  const skillSizeLimit =
    Number(fileUploadConfig?.skill_file_size_limit) * 1024 * 1024 || SKILL_FILE_SIZE_LIMIT
  const maxFileUploadLimit =
    Number(fileUploadConfig?.workflow_file_upload_limit) || MAX_FILE_UPLOAD_LIMIT

  return {
    imgSizeLimit,
    docSizeLimit,
    audioSizeLimit,
    videoSizeLimit,
    skillSizeLimit,
    maxFileUploadLimit,
  }
}

export const useFile = (fileConfig: FileUpload, noNeedToCheckEnable = true) => {
  const { t } = useTranslation(['common'])
  const fileStore = useFileStore()
  const params = useParams()
  const { localUploadUrl, trialAppId, uploadStrategy } = useFileUploadContext()
  const { mutateAsync: uploadConsoleRemoteFile } = useMutation(
    consoleQuery.remoteFiles.upload.post.mutationOptions({ context: { silent: true } }),
  )
  const { mutateAsync: uploadTrialRemoteFile } = useMutation(
    consoleQuery.trialApps.byAppId.remoteFiles.upload.post.mutationOptions({
      context: { silent: true },
    }),
  )
  const { imgSizeLimit, docSizeLimit, audioSizeLimit, videoSizeLimit } = getFileSizeLimit(
    fileConfig.fileUploadConfig,
  )

  const checkSizeLimit = useCallback(
    (fileType: string, fileSize: number) => {
      switch (fileType) {
        case SupportUploadFileTypes.image: {
          if (fileSize > imgSizeLimit) {
            toast.error(
              t(($) => $['fileUploader.uploadFromComputerLimit'], {
                ns: 'common',
                type: SupportUploadFileTypes.image,
                size: formatFileSize(imgSizeLimit),
              }),
            )
            return false
          }
          return true
        }
        case SupportUploadFileTypes.custom:
        case SupportUploadFileTypes.document: {
          if (fileSize > docSizeLimit) {
            toast.error(
              t(($) => $['fileUploader.uploadFromComputerLimit'], {
                ns: 'common',
                type: SupportUploadFileTypes.document,
                size: formatFileSize(docSizeLimit),
              }),
            )
            return false
          }
          return true
        }
        case SupportUploadFileTypes.audio: {
          if (fileSize > audioSizeLimit) {
            toast.error(
              t(($) => $['fileUploader.uploadFromComputerLimit'], {
                ns: 'common',
                type: SupportUploadFileTypes.audio,
                size: formatFileSize(audioSizeLimit),
              }),
            )
            return false
          }
          return true
        }
        case SupportUploadFileTypes.video: {
          if (fileSize > videoSizeLimit) {
            toast.error(
              t(($) => $['fileUploader.uploadFromComputerLimit'], {
                ns: 'common',
                type: SupportUploadFileTypes.video,
                size: formatFileSize(videoSizeLimit),
              }),
            )
            return false
          }
          return true
        }
        default: {
          return true
        }
      }
    },
    [audioSizeLimit, docSizeLimit, imgSizeLimit, t, videoSizeLimit],
  )

  const handleAddFile = useCallback(
    (newFile: FileEntity) => {
      const { files, setFiles } = fileStore.getState()

      const newFiles = produce(files, (draft) => {
        draft.push(newFile)
      })
      setFiles(newFiles)
    },
    [fileStore],
  )

  const handleUpdateFile = useCallback(
    (newFile: FileEntity) => {
      const { files, setFiles } = fileStore.getState()

      const newFiles = produce(files, (draft) => {
        const index = draft.findIndex((file) => file.id === newFile.id)

        if (index > -1) draft[index] = newFile
      })
      setFiles(newFiles)
    },
    [fileStore],
  )

  const handleRemoveFile = useCallback(
    (fileId: string) => {
      const { files, setFiles } = fileStore.getState()

      const newFiles = files.filter((file) => file.id !== fileId)
      setFiles(newFiles)
    },
    [fileStore],
  )

  const handleReUploadFile = useCallback(
    (fileId: string) => {
      const { files, setFiles } = fileStore.getState()
      const index = files.findIndex((file) => file.id === fileId)

      if (index > -1) {
        const uploadingFile = files[index]!
        const newFiles = produce(files, (draft) => {
          draft[index]!.progress = 0
        })
        setFiles(newFiles)
        const uploadParams: Parameters<typeof fileUpload>[0] = {
          file: uploadingFile!.originalFile!,
          onProgressCallback: (progress) => {
            handleUpdateFile({ ...uploadingFile, progress })
          },
          onSuccessCallback: (res) => {
            handleUpdateFile({ ...uploadingFile, uploadedId: res.id, progress: 100 })
          },
          onErrorCallback: (error?: unknown) => {
            if (!fileStore.getState().isActive) return
            const errorMessage = getFileUploadErrorMessage(
              error,
              t(($) => $['fileUploader.uploadFromComputerUploadError'], { ns: 'common' }),
              t,
            )
            if (!isAppAccessError(error) && !isAbortError(error)) toast.error(errorMessage)
            handleUpdateFile({ ...uploadingFile, progress: -1 })
          },
        }

        if (uploadStrategy) {
          uploadStrategy.uploadLocal(uploadParams)
        } else {
          fileUpload(uploadParams, !!params.token, localUploadUrl)
        }
      }
    },
    [fileStore, t, handleUpdateFile, uploadStrategy, params.token, localUploadUrl],
  )

  const startProgressTimer = useCallback(
    (fileId: string) => {
      const timer = setInterval(() => {
        if (!fileStore.getState().isActive) {
          clearInterval(timer)
          return
        }
        const files = fileStore.getState().files
        const file = files.find((file) => file.id === fileId)

        if (file && file.progress < 80 && file.progress >= 0)
          handleUpdateFile({ ...file, progress: file.progress + 20 })
        else clearTimeout(timer)
      }, 200)
    },
    [fileStore, handleUpdateFile],
  )
  const handleLoadFileFromLink = useCallback(
    (url: string) => {
      const allowedFileTypes = fileConfig.allowed_file_types

      const uploadingFile = {
        id: uuid4(),
        name: url,
        type: '',
        size: 0,
        progress: 0,
        transferMethod: TransferMethod.remote_url,
        supportFileType: '',
        url,
        isRemote: true,
      }
      handleAddFile(uploadingFile)
      startProgressTimer(uploadingFile.id)

      let remoteUpload
      if (uploadStrategy) remoteUpload = uploadStrategy.uploadRemote(url)
      else if (trialAppId)
        remoteUpload = uploadTrialRemoteFile({ params: { app_id: trialAppId }, body: { url } })
      else if (params.token) remoteUpload = uploadPublicRemoteFileInfo(url, { silent: true })
      else remoteUpload = uploadConsoleRemoteFile({ body: { url } })

      remoteUpload
        .then((res) => {
          if (!fileStore.getState().isActive) return
          const newFile = {
            ...uploadingFile,
            type: res.mime_type ?? '',
            size: res.size,
            progress: 100,
            supportFileType: getSupportFileType(
              res.name,
              res.mime_type ?? '',
              allowedFileTypes?.includes(SupportUploadFileTypes.custom),
            ),
            uploadedId: res.id,
            url: res.url ?? url,
          }
          if (
            !isAllowedFileExtension(
              res.name,
              res.mime_type ?? '',
              fileConfig.allowed_file_types || [],
              fileConfig.allowed_file_extensions || [],
            )
          ) {
            toast.error(
              `${t(($) => $['fileUploader.fileExtensionNotSupport'], { ns: 'common' })} ${newFile.type}`,
            )
            handleRemoveFile(uploadingFile.id)
          }
          if (!checkSizeLimit(newFile.supportFileType, newFile.size))
            handleRemoveFile(uploadingFile.id)
          else handleUpdateFile(newFile)
        })
        .catch((error: unknown) => {
          if (!fileStore.getState().isActive) return
          if (!isAppAccessError(error) && !isAbortError(error))
            toast.error(
              getFileUploadErrorMessage(
                error,
                getErrorMessage(error) ??
                  t(($) => $['fileUploader.pasteFileLinkInvalid'], { ns: 'common' }),
                t,
              ),
            )
          handleRemoveFile(uploadingFile.id)
        })
    },
    [
      checkSizeLimit,
      handleAddFile,
      handleUpdateFile,
      t,
      handleRemoveFile,
      fileConfig?.allowed_file_types,
      fileConfig.allowed_file_extensions,
      startProgressTimer,
      uploadStrategy,
      params.token,
      trialAppId,
      uploadConsoleRemoteFile,
      uploadTrialRemoteFile,
      fileStore,
    ],
  )

  const handleLoadFileFromLinkSuccess = useCallback(noop, [])

  const handleLoadFileFromLinkError = useCallback(noop, [])

  const handleClearFiles = useCallback(() => {
    const { setFiles } = fileStore.getState()
    setFiles([])
  }, [fileStore])

  const handleLocalFileUpload = useCallback(
    (file: File) => {
      // Check file upload enabled
      if (!noNeedToCheckEnable && !fileConfig.enabled) {
        toast.error(t(($) => $['fileUploader.uploadDisabled'], { ns: 'common' }))
        return
      }
      if (
        !isAllowedFileExtension(
          file.name,
          file.type,
          fileConfig.allowed_file_types || [],
          fileConfig.allowed_file_extensions || [],
        )
      ) {
        toast.error(
          `${t(($) => $['fileUploader.fileExtensionNotSupport'], { ns: 'common' })} ${file.type}`,
        )
        return
      }
      const allowedFileTypes = fileConfig.allowed_file_types
      const fileType = getSupportFileType(
        file.name,
        file.type,
        allowedFileTypes?.includes(SupportUploadFileTypes.custom),
      )
      if (!checkSizeLimit(fileType, file.size)) return

      const reader = new FileReader()
      const isImage = file.type.startsWith('image')

      reader.addEventListener(
        'load',
        () => {
          if (!fileStore.getState().isActive) return
          const uploadingFile = {
            id: uuid4(),
            name: file.name,
            type: file.type,
            size: file.size,
            progress: 0,
            transferMethod: TransferMethod.local_file,
            supportFileType: getSupportFileType(
              file.name,
              file.type,
              allowedFileTypes?.includes(SupportUploadFileTypes.custom),
            ),
            originalFile: file,
            base64Url: isImage ? (reader.result as string) : '',
          }
          handleAddFile(uploadingFile)
          const uploadParams: Parameters<typeof fileUpload>[0] = {
            file: uploadingFile.originalFile,
            onProgressCallback: (progress) => {
              handleUpdateFile({ ...uploadingFile, progress })
            },
            onSuccessCallback: (res) => {
              handleUpdateFile({ ...uploadingFile, uploadedId: res.id, progress: 100 })
            },
            onErrorCallback: (error?: unknown) => {
              if (!fileStore.getState().isActive) return
              const errorMessage = getFileUploadErrorMessage(
                error,
                t(($) => $['fileUploader.uploadFromComputerUploadError'], { ns: 'common' }),
                t,
              )
              if (!isAppAccessError(error) && !isAbortError(error)) toast.error(errorMessage)
              handleUpdateFile({ ...uploadingFile, progress: -1 })
            },
          }

          if (uploadStrategy) {
            uploadStrategy.uploadLocal(uploadParams)
          } else {
            fileUpload(uploadParams, !!params.token, localUploadUrl)
          }
        },
        false,
      )
      reader.addEventListener(
        'error',
        () => {
          if (!fileStore.getState().isActive) return
          toast.error(t(($) => $['fileUploader.uploadFromComputerReadError'], { ns: 'common' }))
        },
        false,
      )
      reader.readAsDataURL(file)
    },
    [
      noNeedToCheckEnable,
      checkSizeLimit,
      t,
      handleAddFile,
      handleUpdateFile,
      uploadStrategy,
      params.token,
      localUploadUrl,
      fileConfig?.allowed_file_types,
      fileConfig?.allowed_file_extensions,
      fileConfig?.enabled,
      fileStore,
    ],
  )

  const handleClipboardPasteFile = useCallback(
    (e: ClipboardEvent<HTMLTextAreaElement>) => {
      const file = e.clipboardData?.files[0]
      const text = e.clipboardData?.getData('text/plain')
      if (file && !text) {
        e.preventDefault()
        handleLocalFileUpload(file)
      }
    },
    [handleLocalFileUpload],
  )

  const [isDragActive, setIsDragActive] = useState(false)
  const handleDragFileEnter = useCallback((e: React.DragEvent<HTMLElement>) => {
    e.preventDefault()
    e.stopPropagation()
    setIsDragActive(true)
  }, [])

  const handleDragFileOver = useCallback((e: React.DragEvent<HTMLElement>) => {
    e.preventDefault()
    e.stopPropagation()
  }, [])

  const handleDragFileLeave = useCallback((e: React.DragEvent<HTMLElement>) => {
    e.preventDefault()
    e.stopPropagation()
    setIsDragActive(false)
  }, [])

  const handleDropFile = useCallback(
    (e: React.DragEvent<HTMLElement>) => {
      e.preventDefault()
      e.stopPropagation()
      setIsDragActive(false)

      const file = e.dataTransfer.files[0]

      if (file) handleLocalFileUpload(file)
    },
    [handleLocalFileUpload],
  )

  return {
    handleAddFile,
    handleUpdateFile,
    handleRemoveFile,
    handleReUploadFile,
    handleLoadFileFromLink,
    handleLoadFileFromLinkSuccess,
    handleLoadFileFromLinkError,
    handleClearFiles,
    handleLocalFileUpload,
    handleClipboardPasteFile,
    isDragActive,
    handleDragFileEnter,
    handleDragFileOver,
    handleDragFileLeave,
    handleDropFile,
  }
}