@electerm/electerm-react 1.38.65 → 1.38.80

package/client/components/sftp/transfer-conflict.jsx

@@ -1,323 +0,0 @@
-/**
- * pass transfer list from props
- * when list changes, do transfer and other op
- */
-
-import { useRef } from 'react'
-import { useDelta, useConditionalEffect } from 'react-delta'
-import { maxTransport, typeMap } from '../../common/constants'
-import {
-  getLocalFileInfo,
-  getRemoteFileInfo,
-  getFolderFromFilePath,
-  getFileExt,
-  checkFolderSize
-} from './file-read'
-import copy from 'json-deep-copy'
-import { findIndex, find } from 'lodash-es'
-import generate from '../../common/uid'
-import resolve from '../../common/resolve'
-import eq from 'fast-deep-equal'
-import { createTransferProps } from './transfer-common'
-
-export default (props) => {
-  const { transferList, sessionId } = props
-  const delta = useDelta(transferList)
-  const currentId = useRef('')
-  const timer = useRef(null)
-  const onConfirm = useRef(false)
-  const ref = {}
-
-  ref.localCheckExist = (path) => {
-    return getLocalFileInfo(path)
-  }
-
-  ref.remoteCheckExist = (path) => {
-    const { sftp } = props
-    return getRemoteFileInfo(sftp, path)
-      .then(r => r)
-      .catch(() => false)
-  }
-
-  const checkExist = (type, path) => {
-    return ref[type + 'CheckExist'](path)
-  }
-
-  function rename (tr, action, _renameId) {
-    const isRemote = tr.typeTo === typeMap.remote
-    const { path, name } = getFolderFromFilePath(tr.toPath, isRemote)
-    const { base, ext } = getFileExt(name)
-    const renameId = _renameId || generate()
-    const newName = ext
-      ? `${base}(rename-${renameId}).${ext}`
-      : `${base}(rename-${renameId})`
-    const res = {
-      ...tr,
-      renameId,
-      newName,
-      oldName: base,
-      toPath: resolve(path, newName)
-    }
-    if (action) {
-      res.action = action
-    }
-    return res
-  }
-
-  function updateTransferAction (data) {
-    const {
-      id,
-      action,
-      transfer
-    } = data
-    const {
-      fromFile
-    } = transfer
-    clear()
-    props.modifier((old) => {
-      let transferList = copy(old.transferList)
-      const index = findIndex(transferList, d => d.id === id)
-      if (index < 0) {
-        return {
-          transferList
-        }
-      }
-      transferList[index].fromFile = fromFile
-      transferList[index].action = action
-      if (action === 'skip') {
-        transferList.splice(index, 1)
-      } else if (action === 'cancel') {
-        transferList = transferList.slice(0, index)
-      }
-      if (action.includes('All')) {
-        transferList = transferList.map((t, i) => {
-          if (i < index) {
-            return t
-          }
-          return {
-            ...t,
-            action: action.replace('All', '')
-          }
-        })
-      }
-      if (action.includes('rename')) {
-        transferList[index] = rename(transferList[index])
-      } else if (action === 'skipAll') {
-        transferList.splice(index, 1)
-      }
-      window.store.setTransfers(transferList, sessionId)
-      return {
-        transferList
-      }
-    })
-  }
-
-  function tagTransferError (id, errorMsg) {
-    const tr = find(transferList, d => d.id === id)
-    window.store.addTransferHistory({
-      ...tr,
-      host: props.host,
-      error: errorMsg,
-      finishTime: Date.now()
-    })
-    props.modifier(old => {
-      const transferList = copy(old.transferList)
-      const index = findIndex(transferList, d => d.id === id)
-      if (index >= 0) {
-        transferList.splice(index, 1)
-      }
-      window.store.setTransfers(transferList, sessionId)
-      return {
-        transferList
-      }
-    })
-  }
-
-  function setConflict (tr) {
-    if (props.transferToConfirm) {
-      return
-    }
-    props.modifier({
-      transferToConfirm: tr
-    })
-  }
-
-  function onDecision (event) {
-    if (event && event.data && event.data.id === currentId.current) {
-      // const {
-      //   transferGroupId,
-      //   fileId,
-      //   id,
-      //   action
-      // } = event.data
-      currentId.current = ''
-      updateTransferAction(event.data)
-      onConfirm.current = false
-      window.removeEventListener('message', onDecision)
-    }
-  }
-
-  function waitForSignal () {
-    window.addEventListener('message', onDecision)
-  }
-
-  function setCanTransfer (fromFile, tr) {
-    clear()
-    props.modifier((old) => {
-      const transferList = copy(old.transferList)
-      const index = findIndex(transferList, t => {
-        return t.id === tr.id
-      })
-      if (index >= 0) {
-        const up = {
-          action: 'transfer',
-          fromFile
-        }
-        Object.assign(transferList[index], up)
-      }
-      window.store.setTransfers(transferList, sessionId)
-      return {
-        transferList
-      }
-    })
-  }
-
-  async function expand (fromFile, tr) {
-    let list = []
-    if (!tr.skipExpand) {
-      const { type } = fromFile
-      list = await props[type + 'List'](
-        true, tr.fromPath
-      )
-      list = list.map(t => {
-        return {
-          typeFrom: tr.typeFrom,
-          typeTo: tr.typeTo,
-          fromPath: resolve(t.path, t.name),
-          toPath: resolve(tr.toPath, t.name),
-          id: generate(),
-          ...createTransferProps(props),
-          parentId: tr.id
-        }
-      })
-    }
-    clear()
-    props.modifier((old) => {
-      const transferList = copy(old.transferList)
-      const index = findIndex(transferList, t => {
-        return t.id === tr.id
-      })
-      transferList.splice(index + 1, 0, ...list)
-      if (transferList[index]) {
-        transferList[index].expanded = true
-      }
-      window.store.setTransfers(transferList, sessionId)
-      return {
-        transferList
-      }
-    })
-  }
-
-  function clear () {
-    currentId.current = ''
-  }
-  async function watchFile () {
-    if (!transferList.length && currentId.current) {
-      return clear()
-    }
-    const tr = transferList
-      .filter(t => {
-        return (
-          !t.action ||
-          !t.fromFile ||
-          (t.fromFile.isDirectory && !t.expanded)
-        )
-      })[0]
-    if (!tr) {
-      onConfirm.current = false
-      return clear()
-    }
-    if (currentId.current) {
-      return null
-    }
-    currentId.current = tr.id
-    const {
-      typeFrom,
-      typeTo,
-      fromPath,
-      toPath,
-      id,
-      action,
-      expanded,
-      renameId,
-      parentId,
-      skipConfirm
-    } = tr
-    const fromFile = tr.fromFile
-      ? tr.fromFile
-      : await checkExist(typeFrom, fromPath)
-    if (!fromFile) {
-      currentId.current = ''
-      return tagTransferError(id, 'file not exist')
-    }
-    let toFile = false
-    if (renameId || parentId) {
-      toFile = false
-    } else if (fromPath === toPath && typeFrom === typeTo) {
-      toFile = true
-    } else {
-      toFile = await checkExist(typeTo, toPath)
-    }
-    if (fromFile.isDirectory) {
-      const skip = await checkFolderSize(props, fromFile)
-        .then(d => d && typeFrom !== typeTo)
-      tr.zip = skip
-      tr.skipExpand = skip
-    }
-    if (fromPath === toPath && typeFrom === typeTo) {
-      return updateTransferAction({
-        id,
-        action: 'rename',
-        transfer: {
-          ...tr,
-          operation: 'cp',
-          fromFile
-        }
-      })
-    } else if (toFile && !action && !skipConfirm) {
-      waitForSignal(id)
-      if (!onConfirm.current) {
-        onConfirm.current = true
-        return setConflict({
-          ...tr,
-          fromFile,
-          toFile
-        })
-      }
-    } else if (toFile && !tr.fromFile && action) {
-      return updateTransferAction({
-        id,
-        action,
-        transfer: {
-          ...tr,
-          fromFile
-        }
-      })
-    } else if (
-      fromFile.isDirectory &&
-      !expanded &&
-      typeFrom !== typeTo &&
-      transferList.filter(t => t.fromFile).length < maxTransport
-    ) {
-      return expand(fromFile, tr)
-    }
-    setCanTransfer(fromFile, tr)
-  }
-  useConditionalEffect(() => {
-    watchFile()
-    return () => {
-      clearTimeout(timer.current)
-    }
-  }, delta && delta.prev && !eq(delta.prev, delta.curr))
-  return null
-}

package/client/components/sftp/transport-action.jsx

@@ -1,412 +0,0 @@
-import { useEffect, useRef } from 'react'
-import { useDelta, useConditionalEffect } from 'react-delta'
-import copy from 'json-deep-copy'
-import { findIndex, isFunction, noop } from 'lodash-es'
-import generate from '../../common/uid'
-import { typeMap, transferTypeMap } from '../../common/constants'
-import fs from '../../common/fs'
-import { transportTypes } from './transport-types'
-import format, { computeLeftTime, computePassedTime } from './transfer-speed-format'
-import { getFolderFromFilePath } from './file-read'
-import resolve from '../../common/resolve'
-import delay from '../../common/wait'
-import { zipCmd, unzipCmd, rmCmd, mvCmd, mkdirCmd } from './zip'
-import './transfer.styl'
-
-export default function transportAction (props) {
-  const { transfer } = props
-  const inst = useRef({})
-  const unzipping = useRef(false)
-  const initRef = useDelta(transfer.inited)
-  const initRefExpand = useDelta(transfer.expaned)
-  function update (up) {
-    props.modifier((old) => {
-      const transferList = copy(old.transferList)
-      const index = findIndex(transferList, t => t.id === transfer.id)
-      if (index < 0) {
-        return {
-          transferList
-        }
-      }
-      window.store.editTransfer(
-        transferList[index].id,
-        up
-      )
-      Object.assign(transferList[index], up)
-      return {
-        transferList
-      }
-    })
-  }
-  function insert (insts) {
-    props.modifier((old) => {
-      const transferList = copy(old.transferList)
-      const index = findIndex(transferList, t => t.id === transfer.id)
-      transferList.splice(index, 1, ...insts)
-      window.store.setTransfers(transferList, transfer.sessionId)
-      return {
-        transferList
-      }
-    })
-  }
-  function onEnd (update = {}) {
-    if (inst.current.onCancel) {
-      return
-    }
-    const {
-      typeTo,
-      next
-    } = transfer
-    const cb = props[typeTo + 'List']
-    const finishTime = Date.now()
-    if (!props.config.disableTransferHistory) {
-      window.store.addTransferHistory(
-        {
-          ...transfer,
-          ...update,
-          finishTime,
-          startTime: inst.current.startTime,
-          size: transfer.fromFile.size,
-          speed: format(transfer.fromFile.size, inst.current.startTime),
-          host: props.tab.host
-        }
-      )
-    }
-    if (next) {
-      insert([copy(next)])
-    }
-    cancel(cb)
-  }
-  function onData (transferred) {
-    if (inst.current.onCancel) {
-      return
-    }
-    const up = {}
-    const total = transfer.fromFile.size
-    let percent = total === 0
-      ? 0
-      : Math.floor(100 * transferred / total)
-    percent = percent >= 100 ? 99 : percent
-    up.percent = percent
-    up.status = 'active'
-    up.transferred = transferred
-    up.startTime = inst.current.startTime
-    up.speed = format(transferred, up.startTime)
-    Object.assign(
-      up,
-      computeLeftTime(transferred, total, up.startTime)
-    )
-    up.passedTime = computePassedTime(up.startTime)
-    update(up)
-  }
-  function cancel (callback) {
-    if (inst.current.onCancel) {
-      return
-    }
-    inst.current.onCancel = true
-    const { id } = transfer
-    inst.current.transport && inst.current.transport.destroy()
-    props.modifier((old) => {
-      const oldTrans = copy(old.transferList)
-      const transferList = oldTrans.filter(t => {
-        return t.id !== id
-      })
-      window.store.setTransfers(transferList, transfer.sessionId)
-      return {
-        transferList
-      }
-    }, isFunction(callback) ? callback : noop)
-  }
-
-  function pause () {
-    inst.current.transport && inst.current.transport.pause()
-    update({
-      pausing: true
-    })
-  }
-
-  function resume () {
-    update({
-      pausing: false
-    })
-    inst.current.transport && inst.current.transport.resume()
-  }
-
-  function handlePauseOrResume () {
-    if (transfer.pausing) {
-      resume()
-    } else {
-      pause()
-    }
-  }
-
-  function onMessage (e) {
-    const action = e?.data?.action
-    const id = e?.data?.id
-    const ids = e?.data?.ids
-    if (id === transfer.id) {
-      switch (action) {
-        case transportTypes.cancelTransport:
-          cancel()
-          break
-        case transportTypes.pauseOrResumeTransfer:
-          handlePauseOrResume()
-          break
-        default:
-          break
-      }
-    }
-    if (
-      (ids && ids.includes(transfer.id)) ||
-      (ids && ids.length === 0)
-    ) {
-      if (
-        action === transportTypes.pauseTransport
-      ) {
-        pause()
-      } else if (action === transportTypes.resumeTransport) {
-        resume()
-      } else if (action === transportTypes.cancelTransport) {
-        cancel()
-      }
-    }
-  }
-  function initEvent () {
-    window.addEventListener('message', onMessage)
-  }
-  function onDestroy () {
-    window.removeEventListener('message', onMessage)
-  }
-  function mvOrCp () {
-    const {
-      fromPath,
-      toPath,
-      typeFrom,
-      operation // 'mv' or 'cp'
-    } = transfer
-    if (typeFrom === typeMap.local) {
-      return fs[operation](fromPath, toPath)
-        .then(onEnd)
-        .catch(e => {
-          onEnd()
-          onError(e)
-        })
-    }
-    return props.sftp[operation](fromPath, toPath)
-      .then(onEnd)
-      .catch(e => {
-        onEnd()
-        onError(e)
-      })
-  }
-  async function zipTransfer () {
-    const {
-      fromPath,
-      toPath,
-      typeFrom
-    } = transfer
-    let p
-    let isFromRemote
-    if (typeFrom === typeMap.local) {
-      isFromRemote = false
-      p = await fs.zipFolder(fromPath)
-    } else {
-      isFromRemote = true
-      p = await zipCmd(props.pid, props.sessionId, fromPath)
-    }
-    const { name } = getFolderFromFilePath(p, isFromRemote)
-    const { path } = getFolderFromFilePath(toPath, !isFromRemote)
-    const nTo = resolve(path, name)
-    const newTrans1 = {
-      ...copy(transfer),
-      toPathReal: transfer.toPath,
-      fromPathReal: transfer.fromPath,
-      toPath: nTo,
-      fromPath: p,
-      originalId: transfer.id,
-      id: generate()
-    }
-    delete newTrans1.fromFile
-    delete newTrans1.inited
-    delete newTrans1.zip
-    const newTrans2 = copy(newTrans1)
-    newTrans2.unzip = true
-    newTrans2.id = generate()
-    newTrans1.next = newTrans2
-    insert([newTrans1])
-  }
-
-  function buildUnzipPath (transfer) {
-    const {
-      newName,
-      toPath,
-      typeTo,
-      oldName
-    } = transfer
-    const isToRemote = typeTo === typeMap.remote
-    const { path } = getFolderFromFilePath(toPath, isToRemote)
-    const np = newName
-      ? resolve(path, 'temp-' + newName)
-      : path
-    return {
-      targetPath: path,
-      path: np,
-      name: oldName
-    }
-  }
-
-  async function unzipFile () {
-    if (unzipping.current) {
-      return false
-    }
-    unzipping.current = true
-    const {
-      fromPath,
-      toPath,
-      typeTo,
-      newName
-    } = transfer
-    const isToRemote = typeTo === typeMap.remote
-    const {
-      path,
-      name,
-      targetPath
-    } = buildUnzipPath(transfer)
-    if (isToRemote) {
-      if (newName) {
-        await mkdirCmd(props.pid, props.sessionId, path)
-        await delay(1000)
-      }
-      await unzipCmd(props.pid, props.sessionId, toPath, path)
-      if (newName) {
-        const mvFrom = resolve(path, name)
-        const mvTo = resolve(targetPath, newName)
-        await mvCmd(props.pid, props.sessionId, mvFrom, mvTo)
-      }
-    } else {
-      if (newName) {
-        await fs.mkdir(path)
-      }
-      await fs.unzipFile(toPath, path)
-      if (newName) {
-        const mvFrom = resolve(path, name)
-        const mvTo = resolve(targetPath, newName)
-        await fs.mv(mvFrom, mvTo)
-      }
-    }
-    await rmCmd(props.pid, props.sessionId, !isToRemote ? fromPath : toPath)
-    await fs.rmrf(!isToRemote ? toPath : fromPath)
-    if (newName) {
-      if (isToRemote) {
-        await rmCmd(props.pid, props.sessionId, path)
-      } else {
-        await fs.rmrf(path)
-      }
-    }
-    onEnd()
-  }
-
-  async function doTransfer () {
-    const {
-      fromPath,
-      toPath,
-      typeFrom,
-      fromFile: {
-        mode: fromMode
-      },
-      toFile = {}
-    } = transfer
-    const transferType = typeFrom === typeMap.local ? transferTypeMap.upload : transferTypeMap.download
-    const isDown = transferType === transferTypeMap.download
-    const localPath = isDown
-      ? toPath
-      : fromPath
-    const remotePath = isDown
-      ? fromPath
-      : toPath
-    const mode = toFile.mode || fromMode
-    inst.current.transport = await props.sftp[transferType]({
-      remotePath,
-      localPath,
-      options: { mode },
-      onData,
-      onError,
-      onEnd
-    })
-  }
-  function isTransferAction (action) {
-    return action.includes('rename') || action === 'transfer'
-  }
-  async function initTransfer () {
-    if (inst.current.started) {
-      return
-    }
-    const {
-      typeFrom,
-      typeTo,
-      fromFile: {
-        isDirectory
-      },
-      action,
-      expanded,
-      zip,
-      unzip,
-      inited
-    } = transfer
-    const t = Date.now()
-    update({
-      startTime: t
-    })
-    inst.current.startTime = t
-    inst.current.started = true
-    if (unzip && inited) {
-      unzipFile()
-    } else if (zip && inited) {
-      zipTransfer()
-    } else if (typeFrom === typeTo) {
-      return mvOrCp()
-    } else if (isDirectory && expanded && isTransferAction(action)) {
-      return mkdir()
-        .then(onEnd)
-        .catch(onError)
-    } else if (!isDirectory) {
-      doTransfer()
-    } else if (expanded && isDirectory && !isTransferAction(action)) {
-      cancel()
-    }
-  }
-  function onError (e) {
-    const up = {
-      status: 'exception',
-      error: e.message
-    }
-    onEnd(up)
-    window.store.onError(e)
-  }
-  async function mkdir () {
-    const {
-      typeTo,
-      toPath
-    } = transfer
-    if (typeTo === typeMap.local) {
-      return fs.mkdir(toPath)
-        .catch(onError)
-    }
-    return props.sftp.mkdir(toPath)
-      .catch(onError)
-  }
-  useEffect(() => {
-    initEvent()
-    if (props.transfer.inited) {
-      initTransfer()
-    }
-    return onDestroy
-  }, [])
-  useConditionalEffect(() => {
-    initTransfer()
-  }, initRef && initRef.prev !== initRef.curr && initRef.curr === true)
-  useConditionalEffect(() => {
-    initTransfer()
-  }, initRefExpand && initRefExpand.prev !== initRefExpand.curr && initRef.curr === true)
-  return null
-}