如何实现一个轻量的断点续传个人网盘系统

const svgCaptcha = require('svg-captcha');
...
// 获取验证码
router.get('/captcha', async ctx => {
  const c = svgCaptcha.create({
    background: '#f5f5f7'
  })
  const captcha = 'data:image/svg+xml;base64,' + new Buffer.from(c.data).toString('base64')
  ctx.session.captcha = c.text.toLocaleLowerCase()
  ctx.body = r.successData({ captcha })
})

// 登录
router.post('/login', async ctx => {
  const { username, password, captcha } = ctx.request.body
  if (!username || !password || !captcha) {
    ctx.body = r.parameterError()
    return
  }
  if (captcha != ctx.session.captcha.toLocaleLowerCase()) {
    ctx.body = r.error(311, '验证码错误')
    return
  }
  try {
    const base64Decode = new Buffer.from(password, 'base64')
    const genPwd = base64Decode.toString()
    const result = await query(`select * from storage_user where username = ? and password = ?`, [username, genPwd])
    if (!result || result.length === 0) {
      ctx.body = r.error(311, '账号或密码错误')
      return
    }
    ctx.session.user = username
    logger('登入Storage')
    ctx.body = r.success()
  } catch (e) {
    ctx.body = r.error(310, '登录失败')
  }
})

// 获取当前目录下文件
router.get('/getFileList', async ctx => {
  const { currentPath = '$Root' } = ctx.query
  const storageURL = currentPath.replace('$Root', storageRootPath)
  const ls = fs.readdirSync(storageURL)
  const infoList = ls.map(item => {
    const info = fs.statSync(`${storageURL}/${item}`)
    return {
      fileName: item,
      fullPath: `${currentPath}/${item}`,
      isFolder: info.isDirectory(),
      size: info.size,
      updatedTime: DateFormat(new Date(info.mtime), 'yyyy-MM-dd HH:mm:ss')
    }
  })
  ctx.body = r.successData(infoList)
})

// 重命名
router.post('/rename', async ctx => {
  const { oldPath, newPath } = ctx.request.body
  if (!oldPath || !newPath) { ctx.body = r.parameterError(); return }
  const oldRealPath = oldPath.replace('$Root', storageRootPath)
  const newRealPath = newPath.replace('$Root', storageRootPath)
  try {
    await query(`update storage set fullPath = ? where fullPath = ?`, [newPath, oldPath])
    fs.renameSync(oldRealPath, newRealPath)
    ctx.body = r.success()
    logger('重命名', 1, `${oldPath} => ${newPath}`)
  } catch (e) {
    ctx.body = r.error(312, e)
    logger('重命名', 0, e)
  }
})

// 删除文件或文件夹
router.post('/delete', async ctx => {
  let { deleteList } = ctx.request.body
  if (!deleteList || deleteList.length === 0) { ctx.body = r.parameterError(); return }
  try {
    await Promise.all(
      deleteList.map(async item => {
        const { target, isFolder } = item
        const oldPath = target.replace('$Root', storageRootPath)
        // 空文件夹直接删除
        if (isFolder) {
          const ls = fs.readdirSync(oldPath)
          if (ls.length === 0) {
            fs.rmdirSync(oldPath)
            ctx.body = r.success()
            logger('删除文件或文件夹', 1, `${oldPath}(直接删除)`)
            return
          }
        }
        try {
          const time = DateFormat(new Date(), 'yyyyMMddHHmmss')
          const pathArr = target.split('/')
          const fileName = pathArr[pathArr.length - 1]
          let newFileName
          if (isFolder) {
            newFileName = `${fileName}-${time}`
          } else {
            const fileNameArr = fileName.split('.')
            const prefix = fileNameArr.length > 1 ? fileNameArr.slice(0, fileNameArr.length - 1).join('.') : fileNameArr[0]
            const suffix = fileNameArr.length > 1 ? fileNameArr[fileNameArr.length - 1] : ''
            const dbFileInfo = await query(`select * from storage where fullPath = ?`, target)
            if (dbFileInfo.length > 0) {
              newFileName = `${dbFileInfo[0].id}.${suffix}`
            } else {
              newFileName = `${prefix}-${time}.${suffix}`
            }
          }
          const newPathArr = pathArr.slice(0, pathArr.length - 1)
          newPathArr.push(newFileName)
          const newPath = newPathArr.join('/')
          // const newRealPath = newPath.replace('$Root', storageTrashPath)
          const afterStorageTrashPath = `${storageTrashPath}/${newFileName}`
          if (!fs.existsSync(storageTrashPath)) fs.mkdirSync(storageTrashPath)
          fs.renameSync(oldPath, afterStorageTrashPath)
          if (isFolder) {
            const now = DateFormat(new Date(), 'yyyy-MM-dd HH:mm:ss')
            const id = 'D' + RandomString(8)
            await query(`insert into trash_folder(id, folderName, fromPath, updatedTime) values(?, ?, ?, ?)`, [id, newFileName, target, now])
          } else {
            await query(`update storage set isDel = 1 where fullPath = ?`, target)
          }
          logger('删除文件或文件夹', 1, `${oldPath}`)
          return Promise.resolve(1)
        } catch (e) {
          logger('删除文件或文件夹', 0, e)
          return Promise.reject(e)
        }
      })
    )
    ctx.body = r.success()
  } catch (e) {
    ctx.body = r.error(308, '操作失败，未知错误')
  }
})

// 移动或复制
router.post('/move', async ctx => {
  const { moveFrom, moveTo, moveType = 0 } = ctx.request.body
  if (!moveTo || !moveFrom || moveFrom.length === 0) {
    ctx.body = r.parameterError()
    return
  }
  // try {
  let sql = ``
  let paramsArr = []
  const moveToRealPath = moveTo.replace('$Root', storageRootPath)
  moveFrom.map(item => {
    const moveFromRealPath = item.replace('$Root', storageRootPath)
    const arr = item.split('/')
    const fileName = arr[arr.length - 1]
    if (moveFromRealPath !== `${moveToRealPath}/${fileName}`) {
      if (moveType === 0) {
        fs.renameSync(moveFromRealPath, `${moveToRealPath}/${fileName}`)
        sql += `update storage set fullPath = ? where fullPath = ?;`
        paramsArr.push(`${moveTo}/${fileName}`, item)
      } else {
        const now = DateFormat(new Date(), 'yyyy-MM-dd HH:mm:ss')
        const id = 'F' + RandomString(8)
        fs.copyFileSync(moveFromRealPath, `${moveToRealPath}/${fileName}`)
        sql += `insert into storage(id, md5, fullPath, isComplete, isDel, updatedTime) 
                  values(?, (select md5 from storage a where fullPath = ?), ?, 1, 0, ?)`
        paramsArr.push(id, item, moveTo, now)
      }
    }
  })
  if (sql) {
    await transactionQuery(sql, paramsArr)
  }
  ctx.body = r.success()
  logger(moveType === 0 ? '移动文件' : '复制文件', 1, `MoveFrom: ${moveFrom.join(', ')} => MoveTo: ${moveTo}`)
})

// 新建文件夹
router.post('/createFolder', async ctx => {
  const { folderName } = ctx.request.body
  if (!folderName) { ctx.body = r.parameterError(); return }
  let newPath = folderName.replace('$Root', storageRootPath)
  try {
    fs.mkdirSync(newPath)
    ctx.body = r.success()
    logger('新建文件夹', 1, `${newPath}`)
  } catch (e) {
    ctx.body = r.error(312, e)
    logger('新建文件夹', 0, e)
  }
})

router.get('/testUpload', async ctx => {
  const { identifier, filename, targetPath = '$Root', totalChunks } = ctx.query
  const chunkFolderURL = `${storageChunkPath}/${identifier}`
  try {
    const checkExistResult = await query(`select * from storage where md5 = ? and isComplete = 1 and isDel = 0`, identifier)
    // 检查是否已经完整上传过该文件
    if (checkExistResult.length > 0) {
      let { fullPath } = checkExistResult[0]
      let realPath = fullPath.replace('$Root', storageRootPath)
      /*
      // 检查当前DB信息是否与物理存储相符
      if (fs.existsSync(realPath)) {
        // 检查目标位置是否与之前上传的位置一样，不一致则复制过去
        let targetFilePath = `${targetPath}/${filename}`
        if (fullPath !== targetFilePath) {
          targetFilePath = targetFilePath.replace('$Root', storageRootPath)
          fs.copyFileSync(realPath, targetFilePath)
        }
      }
      */
      let targetFilePath = `${targetPath}/${filename}`
      if (fullPath !== targetFilePath) {
        targetFilePath = targetFilePath.replace('$Root', storageRootPath)
        fs.copyFileSync(realPath, targetFilePath)
      }
      if (!fs.existsSync(realPath)) {
        const now = DateFormat(new Date(), 'yyyy-MM-dd HH:mm:ss')
        const id = 'F' + RandomString(8)
        const sql = `insert into storage(id, md5, fullPath, updatedTime, isComplete, isDel) values(?, ?, ?, ?, 1, 0)`
        await query(sql, [id, identifier, targetFilePath, now])
      }
      ctx.body = r.successData(Array.from({ length: totalChunks }, (item, index) => ~~index + 1))
      return
    }
    if (!fs.existsSync(chunkFolderURL)) {
      fs.mkdirSync(chunkFolderURL, { recursive: true })
      const now = DateFormat(new Date(), 'yyyy-MM-dd HH:mm:ss')
      const id = 'F' + RandomString(8)
      const sql = `insert into storage(id, md5, fullPath, updatedTime, isComplete, isDel) values(?, ?, ?, ?, 0, 0)`
      await query(sql, [id, identifier, `${targetPath}/${filename}`, now])
      ctx.body = r.successData([])
    } else {
      const ls = fs.readdirSync(chunkFolderURL)
      ctx.body = r.successData(ls)
    }
  } catch (e) {
    ctx.status = 501
    ctx.body = r.error(306, e)
  }
})

router.post('/upload', async ctx => {
  const { chunkNumber, identifier, filename, totalChunks, targetPath = '$Root' } = ctx.request.body
  const { file } = ctx.request.files
  const chunkFolderURL = `./public/storage-chunk/${identifier}`
  const chunkFileURL = `${chunkFolderURL}/${chunkNumber}`
  if (chunkNumber !== totalChunks) {
    const reader = fs.createReadStream(file.path)
    const upStream = fs.createWriteStream(chunkFileURL)
    reader.pipe(upStream)
    ctx.body = r.success()
  } else {
    const targetFile = `${targetPath}/${filename}`.replace('$Root', storageRootPath)
    fs.writeFileSync(targetFile, '')
    try {
      for (let i = 1; i <= totalChunks; i++) {
        const url = i == totalChunks ? file.path : `${chunkFolderURL}/${i}`
        const buffer = fs.readFileSync(url)
        fs.appendFileSync(targetFile, buffer)
      }
      const now = DateFormat(new Date(), 'yyyy-MM-dd HH:mm:ss')
      const sql = `update storage set isComplete = 1, updatedTime = ? where md5 = ?`
      await query(sql, [now, identifier])
      ctx.body = r.success()
      deleteFolder(chunkFolderURL)
      logger('文件上传成功', 1, `targetFile: ${targetFile}, MD5:${identifier}, 切片源删除成功`)
    } catch (e) {
      ctx.status = 501
      ctx.body = r.error(501, e)
      logger('文件合并失败', 0, `分片丢失 => ${e}`)
      fs.unlinkSync(targetFile)
    }
  }
})

// 获取回收站目录文件列表
router.get('/getTrashList', async ctx => {
  const weekAgo = new Date().setDate(new Date().getDate() - 8)
  const trashFileSql = `select id, md5, fullPath, DATE_FORMAT(updatedTime, '%Y-%m-%d %H:%i:%s') updatedTime from storage where isDel = 1 and updatedTime > ?`
  const trashFileList = await query(trashFileSql, weekAgo)
  const trashFolderSql = `select id, folderName, fromPath, DATE_FORMAT(updatedTime, '%Y-%m-%d %H:%i:%s') updatedTime from trash_folder where updatedTime > ?`
  const trashFolderList = await query(trashFolderSql, weekAgo)
  if (!trashFileList || !trashFolderList) {
    ctx.body = r.error()
    return
  }
  let trashListMap = {}
  trashFileList.map(item => {
    const pathArr = item.fullPath.split('/')
    const fileRealName = pathArr[pathArr.length - 1]
    const fileNameArr = fileRealName.split('.')
    const suffix = fileNameArr.length > 1 ? fileNameArr[fileNameArr.length - 1] : ''
    const fileName = `${item.id}.${suffix}`
    trashListMap[fileName] = {
      fileName,
      showFileName: fileRealName,
      fromPath: item.fullPath,
      updatedTime: item.updatedTime,
      isFolder: false
    }
  })
  trashFolderList.map(item => {
    const folderNameArr = item.folderName.split('/')
    const fileName = folderNameArr[folderNameArr.length - 1]
    trashListMap[fileName] = {
      fileName,
      fromPath: item.fromPath,
      updatedTime: item.updatedTime,
      isFolder: true
    }
  })
  const ls = fs.readdirSync(storageTrashPath)
  const result = ls.map(item => {
    if (trashListMap[item]) {
      return trashListMap[item]
    } else {
      const arr = item.split('.')
      const fileName = arr.length > 1 ? arr.slice(0, arr.length - 1).join('.') : arr[0]
      const a = fileName.substr(-14)
      return {
        fileName: item,
        updatedTime: `${a.substr(0, 4)}-${a.substr(4, 2)}-${a.substr(6, 2)} ${a.substr(8, 2)}:${a.substr(10, 2)}:${a.substr(12, 2)}`
      }
    }
  })
  ctx.body = r.successData(result)
})

router.post('/restore', async ctx => {
  let { restoreList } = ctx.request.body
  if (!restoreList || restoreList.length === 0) { ctx.body = r.parameterError(); return }
  try {
    let sql = ''
    let paramsArr = []
    await Promise.all(
      restoreList.map(item => {
        const oldPath = `${storageTrashPath}/${item.fileName}`
        const restorePath = item.fromPath.replace('$Root', storageRootPath)
        fs.renameSync(oldPath, restorePath)
        if (item.isFolder) {
          sql += `delete from trash_folder where folderName = ?;`
          paramsArr.push(item.fileName)
        } else {
          const id = item.fileName.split('.')[0]
          sql += `update storage set isDel = 0 where id = ?;`
          paramsArr.push(id)
        }
      })
    )
    await transactionQuery(sql, paramsArr)
    ctx.body = r.success()
    logger('还原文件', 1, `${restoreList.map(item => item.fileName).join(',')}`)
  } catch (e) {
    ctx.body = r.error(e)
    logger('还原文件', 0, e.toString())
  }
})

router.post('/permanentlyDelete', async ctx => {
  let { deleteList } = ctx.request.body
  if (!deleteList || deleteList.length === 0) { ctx.body = r.parameterError(); return }
  try {
    let sql = ''
    let paramsArr = []
    await Promise.all(
      deleteList.map(item => {
        const oldPath = `${storageTrashPath}/${item.fileName}`
        if (item.isFolder) {
          deleteFolder(oldPath)
        } else {
          fs.unlinkSync(oldPath)
        }
        if (item.isFolder) {
          sql += `delete from trash_folder where folderName = ?;`
          paramsArr.push(item.fileName)
        } else {
          const id = item.fileName.split('.')[0]
          sql += `delete from storage where id = ?;`
          paramsArr.push(id)
        }
      })
    )
    await transactionQuery(sql, paramsArr)
    ctx.body = r.success()
    logger('永久删除文件', 1, `${deleteList.map(item => item.fileName).join(',')}`)
  } catch (e) {
    ctx.body = r.error(e)
    logger('永久删除文件', 0, e.toString())
  }
})