LaiTool/src/main/Public/Translate.js

import { DEFINE_STRING } from '../../define/define_string'
const tencentcloud = require('tencentcloud-sdk-nodejs')
import { define } from '../../define/define'
import { MD5 } from 'crypto-js'
import axios from 'axios'
import path from 'path'
import { Tools } from '../tools'
const alimt20181012 = require('@alicloud/alimt20181012')
const OpenApi = require('@alicloud/openapi-client')
const Util = require('@alicloud/tea-util')
let fspromises = require('fs').promises
import { SoftwareService } from '../../define/db/service/SoftWare/softwareService'
import { isEmpty } from 'lodash'
import { ValidateJson } from '../../define/Tools/validate'
import { GetOpenAISuccessResponse } from '../../define/response/openAIResponse'
import { successMessage } from './generalTools'
import { RetryWithBackoff } from '../../define/Tools/common'

let { Signer } = require('@volcengine/openapi')

export class Translate {
  constructor(global) {
    this.global = global
    this.tools = new Tools()
  }

  /**
   * 初始化翻译设置
   */
  async InitTranslate() {
    if (!this.softwareService) {
      this.softwareService = await SoftwareService.getInstance()
    }
    // 获取翻译设置
    let translateSetting = this.softwareService.GetSoftWarePropertyData('translationSetting')
    if (isEmpty(translateSetting)) {
      throw new Error('翻译设置为空，请先设置')
    }
    let tryParse = ValidateJson(translateSetting)
    if (!tryParse) {
      throw new Error('翻译设置的格式错误，请重置后重新添加')
    }
    let translateSettingData = JSON.parse(translateSetting)
    let selectModel = translateSettingData.selectModel
    let translateIndex = translateSettingData.translates.findIndex(
      (item) => item.name == selectModel
    )
    if (translateIndex < 0) {
      throw new Error('没有找到对应的翻译API设置')
    }
    let translateData = translateSettingData.translates[translateIndex]
    for (const key in translateData) {
      if (!translateData[key]) {
        throw new Error(`翻译设置中的 ${key} 不能为空`)
      }
    }
    this.translationBusiness = translateData.translation_business
    this.translationAppId = translateData.translation_app_id
    this.translationSecret = translateData.translation_secret
  }

  /**
   * 将当前的翻译任务添加到队列中
   * @param {*} value
   * 0 第 0 个参数是要翻译的数据（数组）
   * 1 第 1 个参数是源语言
   * 2 第 2 个参数是目标语言
   * 3 第 3 个参数是否分割（默认不分割false）
   * 4 第 4 个参数是要不要全局弹窗提示
   * @returns
   */
  async TranslateReturnNowTask(value) {
    try {
      await this.InitTranslate()
      value = JSON.parse(value)
      let data = value[0]
      let to = value[2]
      let batch = DEFINE_STRING.QUEUE_BATCH.TRANSLATE_RETURN_NOW_TASK
      for (let i = 0; i < data.length; i++) {
        const element = data[i]
        // 添加任务到队列
        this.global.requestQuene.enqueue(
          async () => {
            try {
              let res = await this.TranslateReturnNow([
                element.gpt_prompt,
                value[1],
                to,
                value[3],
                value[4]
              ])
              if (res.code != 1) {
                throw new Error(res.message)
              }
              let res_p = null

              if (!value[3]) {
                if (to == 'zh') {
                  res_p = res.data.map((item) => item.dst).join(',')
                } else {
                  res_p = res.data.map((item) => item.src).join(',')
                }
              } else {
                res_p = res.data
              }

              // 修改chinese_prompt
              this.global.fileQueue.enqueue(async () => {
                let json_path = path.join(
                  this.global.config.project_path,
                  `tmp/input_crop/${element.name}.json`
                )
                let prompt_json = JSON.parse(await fspromises.readFile(json_path, 'utf-8'))
                if (!value[3]) {
                  prompt_json.gpt_prompt = res_p
                } else {
                  prompt_json.chinese_prompt = res_p
                }
                await fspromises.writeFile(json_path, JSON.stringify(prompt_json))
              })

              this.global.newWindow[0].win.webContents.send(
                DEFINE_STRING.TRANSLATE_RETURN_REFRESH,
                {
                  code: 1,
                  to: to,
                  rowId: element.id,
                  data: res_p
                }
              )
            } catch (error) {
              throw error
            }
          },
          `${batch}_${element.name}`,
          batch
        )
      }
      // 监听总批次完成
      this.global.requestQuene.setBatchCompletionCallback(batch, (failedTasks) => {
        if (failedTasks.length > 0) {
          let message = `
                翻译任务都已完成。
                但是以下任务执行失败：
                `
          failedTasks.forEach(({ taskId, error }) => {
            message += `${taskId}-, \n 错误信息: ${error}` + '\n'
          })

          this.global.newWindow[0].win.webContents.send(DEFINE_STRING.SHOW_MESSAGE_DIALOG, {
            code: 0,
            message: message
          })
        } else {
          if (value[4]) {
            this.global.newWindow[0].win.webContents.send(DEFINE_STRING.SHOW_MESSAGE_DIALOG, {
              code: 1,
              message: '翻译任务完成'
            })
          }
        }
      })
      return {
        code: 1,
        message: '翻译任务已加入队列任务中'
      }
    } catch (error) {
      return {
        code: 0,
        message: '翻译任务出错，错误信息： ' + error.toString()
      }
    }
  }

  /**
   *
   * @param {*} value 0：当前要翻译的字符串
   * 1：源语言
   * 2：目标语言
   * 3：是否拆分（以逗号拆分）
   * [tags,'zh','en',false]
   */
  async TranslateReturnNow(value) {
    try {
      await this.InitTranslate()
      // 百度翻译
      if (this.translationBusiness.includes('baidu')) {
        return await this.TranslateReturnNowBaidu(value)
      } else if (this.translationBusiness.includes('volcengine')) {
        // 火山引擎
        return await this.TranslateReturnNowVolcengine(value)
      } else if (this.translationBusiness.includes('tencent')) {
        // 腾讯翻译
        return await this.TranslateReturnNowTencent(value)
      } else if (this.translationBusiness.includes('aliyun')) {
        return await this.TranslateReturnNowAliyun(value)
      } else if (this.translationBusiness.includes('laitool')) {
        return await this.TranslateReturnNowGPT(value)
      } else {
        throw new Error('未知的翻译API，请检查设置')
      }
    } catch (error) {
      return {
        code: 0,
        message: error.toString()
      }
    }
  }

  /**
   * 添加翻译任务到队列中
   * @param {
   * translateData ：要翻译的数据
   * from : 源语言
   * to : 目标语言
   * window.id : 显示的窗体的ID
   * isShow : 是不是提示
   * [translateData, from, to, window.id,isShow]
   * } value
   */
  async TranslatePrompt(value) {
    try {
      await this.InitTranslate()
      value[0] = JSON.parse(value[0])
      // baidu翻译
      if (this.translationBusiness.includes('baidu')) {
        return await this.TranslatePromptBaidu(value)
      } else if (this.translationBusiness.includes('volcengine')) {
        // 火山引擎
        return await this.TranslatePromptVolcengine(value)
      } else if (this.translationBusiness.includes('tencent')) {
        // 腾讯翻译
        return await this.TranslatePromptTencent(value)
      } else if (this.translationBusiness.includes('aliyun')) {
        // 阿里云翻译
        return await this.TranslatePromptAliyun(value)
      } else {
        throw new Error('反推这边不支持GPT翻译，请选择其他的翻译API')
      }
    } catch (error) {
      return {
        code: 0,
        message: error.toString()
      }
    }
  }

  //#region LaiTool GPT翻译

  /**
   *
   * @param value 使用laitool GPT翻译
   */
  async TranslateReturnNowGPT(value) {
    try {
      // 判断该当前的翻译API
      let translateData = value[0]
      let from = value[1]
      let to = value[2]
      if (value[3]) {
        throw new Error('使用GPT翻译不支持拆分')
      }
      let model = this.translationAppId
      let token = this.translationSecret

      let data = {
        model: model,
        messages: []
      }
      // 开始调用GPT进行翻译
      if (from == 'en' && to == 'zh') {
        data.messages.push({
          role: 'system',
          content:
            '我想让你充当英译中专家，用中文100%还原描述，不要加其他的联想，只翻译字面意思，请检查所有信息是否准确，并在回答时保持简活，不需要任何其他反馈。'
        })
        // 添加示例
        data.messages.push({
          role: 'user',
          content:
            'A woman in her twenties with messy hair and a look of shock and despair. She is wearing a simple white shirt and jeans. Her face shows mixed emotions. The background is a dim and quiet room. The historical background is modern. The screen content is a close-up of the woman’s face with tear marks.'
        })
        data.messages.push({
          role: 'assistant',
          content:
            '一位二十多岁的女人，头发凌乱，表情震惊和绝望。她穿着一件简单的白色衬衫和牛仔裤。她的脸上显示出复杂的情感。背景是一个昏暗安静的房间。历史背景是现代的。屏幕内容是女人脸部的特写，带有泪痕。'
        })
        data.messages.push({
          role: 'user',
          content:
            'A twenty-something woman with short curly hair, smiling, wearing a casual white shirt and jeans, sitting on a comfortable sofa with a cup of coffee in her hand. She is in a small and cozy living room with a few books on the bookshelf, modern interior design, and natural light pouring into the room in the late afternoon. Screen content: Part of the sofa cushions.'
        })
        data.messages.push({
          role: 'assistant',
          content:
            '一位二十多岁的女性，留着短卷发，面带微笑，穿着休闲的白色衬衫和牛仔裤，手拿一杯咖啡，坐在一个舒适的沙发上。她所在的是一个小而温馨的客厅，书架上有几本书，现代室内设计，下午晚些时候，自然光线洒进房间。屏幕内容：沙发垫的一部分。'
        })
        data.messages.push({
          role: 'user',
          content:
            "In a modern city, a streamlined car is parked on the street. A man in his thirties, with short brown hair combed back, a calm, confident look, tall and thin in a clean white shirt and black pants, sits in the car. The interior of the car is clean and modern, and the background is blurred to highlight the man's calm demeanor. The man's cell phone is ringing. The scene is set in the present."
        })
        data.messages.push({
          role: 'assistant',
          content:
            '在现代城市，一辆流线型轿车停在街上。一个三十多岁的男人，短短的棕色头发梳向后，神情冷静，自信，穿着干净的白衬衫和黑裤子，身材高挑瘦长，坐在车里。车内干净而现代，背景模糊，以突出男人平静的神态。男人的手机正在响。场景设定在现在。'
        })
      } else if (from == 'zh' && to == 'en') {
        data.messages.push({
          role: 'system',
          content:
            '我想让你充当中译英专家，用中文100%还原描述，不要加其他的联想，只翻译字面意思，请检查所有信息是否准确，并在回答时保持简活，不需要任何其他反馈。'
        })
        // 添加示例
        data.messages.push({
          role: 'user',
          content:
            '一位二十多岁的女人，头发凌乱，表情震惊和绝望。她穿着一件简单的白色衬衫和牛仔裤。她的脸上显示出复杂的情感。背景是一个昏暗安静的房间。历史背景是现代的。屏幕内容是女人脸部的特写，带有泪痕。'
        })
        data.messages.push({
          role: 'assistant',
          content:
            'A woman in her twenties with messy hair and a look of shock and despair. She is wearing a simple white shirt and jeans. Her face shows mixed emotions. The background is a dim and quiet room. The historical background is modern. The screen content is a close-up of the woman’s face with tear marks.'
        })
        data.messages.push({
          role: 'user',
          content:
            '一位二十多岁的女性，留着短卷发，面带微笑，穿着休闲的白色衬衫和牛仔裤，手拿一杯咖啡，坐在一个舒适的沙发上。她所在的是一个小而温馨的客厅，书架上有几本书，现代室内设计，下午晚些时候，自然光线洒进房间。屏幕内容：沙发垫的一部分。'
        })
        data.messages.push({
          role: 'assistant',
          content:
            'A twenty-something woman with short curly hair, smiling, wearing a casual white shirt and jeans, sitting on a comfortable sofa with a cup of coffee in her hand. She is in a small and cozy living room with a few books on the bookshelf, modern interior design, and natural light pouring into the room in the late afternoon. Screen content: Part of the sofa cushions.'
        })
        data.messages.push({
          role: 'user',
          content:
            '在现代城市，一辆流线型轿车停在街上。一个三十多岁的男人，短短的棕色头发梳向后，神情冷静，自信，穿着干净的白衬衫和黑裤子，身材高挑瘦长，坐在车里。车内干净而现代，背景模糊，以突出男人平静的神态。男人的手机正在响。场景设定在现在。'
        })
        data.messages.push({
          role: 'assistant',
          content:
            "In a modern city, a streamlined car is parked on the street. A man in his thirties, with short brown hair combed back, a calm, confident look, tall and thin in a clean white shirt and black pants, sits in the car. The interior of the car is clean and modern, and the background is blurred to highlight the man's calm demeanor. The man's cell phone is ringing. The scene is set in the present."
        })
      } else {
        throw new Error('GPT翻译只支持中英互译')
      }

      data.messages.push({
        role: 'user',
        content: translateData
      })

      let content = ''
      // 判断整体是不是需要LMS转发
      if (global.config.useTransfer) {
        let url = define.lms + '/lms/Forward/SimpleTransfer'
        let config = {
          method: 'post',
          url: url,
          maxBodyLength: Infinity,
          headers: {
            'Content-Type': 'application/json'
          },
          data: JSON.stringify({
            url: this.translationBusiness,
            apiKey: token,
            dataString: JSON.stringify(data)
          })
        }
        // 重试机制
        let res = await RetryWithBackoff(
          async () => {
            return await axios.request(config)
          },
          5,
          2000
        )

        if (res.data.code != 1) {
          throw new Error(res.data.message)
        }
        content = GetOpenAISuccessResponse(res.data.data)
      } else {
        let config = {
          method: 'post',
          maxBodyLength: Infinity,
          url: this.translationBusiness,
          headers: {
            'Content-Type': 'application/json',
            Authorization: `Bearer ${token}`
          },
          data: JSON.stringify(data)
        }
        let res = await RetryWithBackoff(
          async () => {
            return await axios.request(config)
          },
          5,
          2000
        )
        // 将返回的数据进行拼接数据处理
        content = GetOpenAISuccessResponse(res.data)
      }

      let res_data = []

      if (to == 'zh') {
        res_data.push({
          src: translateData,
          dst: content
        })
      } else if (to == 'en') {
        res_data.push({
          src: content,
          dst: translateData
        })
      }

      // 直接返回数据
      return {
        code: 1,
        to: to,
        data: res_data
      }
    } catch (error) {
      throw error
    }
  }

  //#endregion

  /**
   * 阿里云翻译写入队列中
   * @param {*} value
   */
  async TranslatePromptAliyun(value) {
    try {
      let win = this.global.newWindow.filter((item) => item.id == value[3])[0]
      if (!win) {
        win = this.global.newWindow[0]
      }
      let translateData = value[0]
      let from = value[1]
      let to = value[2]
      let batch = DEFINE_STRING.QUEUE_BATCH.TRANSLATE_PROMPT

      for (let i = 0; i < translateData.length; i++) {
        const element = translateData[i]
        this.global.requestQuene.enqueue(
          async () => {
            if (translateData.length > 5) {
              await this.tools.delay(2000)
            }
            let arr_data = []
            if (to == 'zh') {
              let tmp_data = element.prompt
              arr_data = tmp_data.replaceAll('_', ' ').replaceAll('，', ',').split(',')
              arr_data = arr_data.filter((item) => item != '' && item != null)
            } else if (to == 'en') {
              for (let j = 0; j < element.chinese_prompt.length; j++) {
                const item = element.chinese_prompt[j]
                if (item != '' && item != null) {
                  arr_data.push(item.dst)
                }
              }
            }
            // 如果为空（直接返回）
            if (arr_data.length <= 0) {
              return
            }
            let req_data = {}
            for (let j = 0; j < arr_data.length; j++) {
              const element = arr_data[j]
              req_data[j.toString()] = element
            }

            let config = new OpenApi.Config({
              accessKeyId: this.translationAppId,
              accessKeySecret: this.translationSecret
            })
            config.endpoint = `mt.cn-hangzhou.aliyuncs.com`

            let client = new alimt20181012.default(config)

            let getBatchTranslateRequest = new alimt20181012.GetBatchTranslateRequest({
              apiType: 'translate_standard',
              scene: 'general',
              sourceLanguage: from,
              targetLanguage: to,
              formatType: 'text',
              sourceText: JSON.stringify(req_data)
            })
            let runtime = new Util.RuntimeOptions({})

            // 复制代码运行请自行打印 API 的返回值
            let res = await client.getBatchTranslateWithOptions(getBatchTranslateRequest, runtime)
            console.log(res)

            // 处理返回的数据
            // 检出返回的数据和输入的数据是不是一样的
            let translateList = res.body.translatedList
            if (translateList.length != arr_data.length) {
              throw new Error('请求的数据长度和返回的数据长度不一致。请重试')
            }

            let res_data = []
            // {
            //     "src": "blush",
            //     "dst": "脸红"
            // }
            if (to == 'zh') {
              for (let j = 0; j < arr_data.length; j++) {
                const item = arr_data[j]
                let res_tmp = translateList.find((item) => item.index == j)
                let obj = {
                  src: item,
                  dst: res_tmp.translated
                }
                res_data.push(obj)
              }
            } else if (to == 'en') {
              for (let j = 0; j < arr_data.length; j++) {
                const item = arr_data[j]
                // 获取指定的index的返回数据
                let res_tmp = translateList.find((item) => item.index == j)
                let obj = {
                  src: res_tmp.translated,
                  dst: item
                }
                res_data.push(obj)
              }
            }
            // 数据返回。写入本地配置文件
            // 修改chinese_prompt
            this.global.fileQueue.enqueue(async () => {
              let json_path = path.join(
                this.global.config.project_path,
                `tmp/input_crop/${element.name}.json`
              )
              let prompt_json = JSON.parse(await fspromises.readFile(json_path, 'utf-8'))
              prompt_json.chinese_prompt = res_data
              await fspromises.writeFile(json_path, JSON.stringify(prompt_json))
            })
            win.win.webContents.send(DEFINE_STRING.TRANSLATE_RETURN_REFRESH, {
              code: 1,
              to: to,
              rowId: element.id,
              data: res_data
            })
          },
          `${batch}_${element.name}`,
          batch
        )
      }
      // 监听总批次完成
      this.global.requestQuene.setBatchCompletionCallback(batch, (failedTasks) => {
        if (failedTasks.length > 0) {
          let message = `
               翻译任务都已完成。
               但是以下任务执行失败：
               `
          failedTasks.forEach(({ taskId, error }) => {
            message += `${taskId}-, \n 错误信息: ${error}` + '\n'
          })

          this.global.newWindow[0].win.webContents.send(DEFINE_STRING.SHOW_MESSAGE_DIALOG, {
            code: 0,
            message: message
          })
        } else {
          if (value[4]) {
            this.global.newWindow[0].win.webContents.send(DEFINE_STRING.SHOW_MESSAGE_DIALOG, {
              code: 1,
              message: '批次翻译任务完成'
            })
          }
        }
      })
      return {
        code: 1,
        message: '翻译任务已加入队列任务中'
      }
    } catch (error) {
      throw error
    }
  }

  /**
   * 阿里云翻译实时返回
   * @param {*} value
   */
  async TranslateReturnNowAliyun(value) {
    try {
      // 判断该当前的翻译API
      let from = value[1]
      let to = value[2]
      let ts_d = value[0].replaceAll('_', ' ').replaceAll('，', ',')
      let req_data = {}
      let req_count = 0
      let req_arr = []
      if (value[3]) {
        let tmp_arr = ts_d.split(',')
        for (let i = 0; i < tmp_arr.length; i++) {
          const element = tmp_arr[i]
          if (element != '' && element != null) {
            req_data[i.toString()] = element
            req_arr.push(element)
          }
          req_count += 1
        }
      } else {
        req_data['0'] = ts_d
        req_count = 1
        req_arr.push(ts_d)
      }
      if (req_count <= 0) {
        throw new Error('没有传入数据')
      }

      let config = new OpenApi.Config({
        accessKeyId: this.translationAppId,
        accessKeySecret: this.translationSecret
      })
      config.endpoint = `mt.cn-hangzhou.aliyuncs.com`

      let client = new alimt20181012.default(config)

      let getBatchTranslateRequest = new alimt20181012.GetBatchTranslateRequest({
        apiType: 'translate_standard',
        scene: 'general',
        sourceLanguage: from,
        targetLanguage: to,
        formatType: 'text',
        sourceText: JSON.stringify(req_data)
      })
      let runtime = new Util.RuntimeOptions({})

      // 复制代码运行请自行打印 API 的返回值
      let res = await client.getBatchTranslateWithOptions(getBatchTranslateRequest, runtime)
      console.log(res)

      // 处理返回的数据
      // 检出返回的数据和输入的数据是不是一样的
      let translateList = res.body.translatedList
      if (translateList.length != req_count) {
        throw new Error('请求的数据长度和返回的数据长度不一致。请重试')
      }
      // {
      //     "src": "blush",
      //     "dst": "脸红"
      // }
      // 数据处理
      let res_data = []
      for (let j = 0; j < req_arr.length; j++) {
        const item = req_arr[j]
        let res_tmp = translateList.find((item) => item.index == j)
        if (to == 'zh') {
          let obj = {
            src: item,
            dst: res_tmp.translated
          }
          res_data.push(obj)
        } else if (to == 'en') {
          let obj = {
            src: res_tmp.translated,
            dst: item
          }
          res_data.push(obj)
        }
      }

      // 直接返回数据
      return {
        code: 1,
        to: to,
        data: res_data
      }
    } catch (error) {
      throw error
    }
  }

  /**
   * 腾讯翻译实时返回
   * @param {*} value
   */
  async TranslateReturnNowTencent(value) {
    try {
      // 判断该当前的翻译API
      let from = value[1]
      let to = value[2]
      let ts_d = value[0].replaceAll('_', ' ').replaceAll('，', ',')
      let req_data = []
      if (value[3]) {
        req_data = ts_d.split(',')
      } else {
        req_data.push(ts_d)
      }
      req_data = req_data.filter((item) => item != '' && item != null)
      if (req_data.length <= 0) {
        throw new Error('没有传入数据')
      }
      const CvmClient = tencentcloud.tmt.v20180321.Client
      const client = new CvmClient({
        credential: {
          secretId: this.translationAppId,
          secretKey: this.translationSecret
        },
        // 产品地域
        region: 'ap-shanghai',
        // 可选配置实例
        profile: {
          signMethod: 'TC3-HMAC-SHA256', // 签名方法
          httpProfile: {
            reqMethod: 'POST', // 请求方法
            reqTimeout: 30 // 请求超时时间，默认60s
          }
        }
      })

      let res = await client.TextTranslateBatch({
        SourceTextList: req_data,
        Source: from,
        Target: to,
        ProjectId: 0
      })
      console.log(res)

      // 处理返回的数据
      // 检出返回的数据和输入的数据是不是一样的
      let translateList = res.TargetTextList
      if (translateList.length != req_data.length) {
        throw new Error('请求的数据长度和返回的数据长度不一致。请重试')
      }
      // {
      //     "src": "blush",
      //     "dst": "脸红"
      // }
      // 数据处理
      let res_data = []
      for (let j = 0; j < req_data.length; j++) {
        const item = req_data[j]
        if (to == 'zh') {
          let obj = {
            src: item,
            dst: translateList[j]
          }
          res_data.push(obj)
        } else if (to == 'en') {
          let obj = {
            src: translateList[j],
            dst: item
          }
          res_data.push(obj)
        }
      }

      // 直接返回数据
      return {
        code: 1,
        to: to,
        data: res_data
      }
    } catch (error) {
      throw error
    }
  }

  /**
   * 腾讯翻译将翻译的消息写入到队列中
   * @param {*} value
   */
  async TranslatePromptTencent(value) {
    try {
      let win = this.global.newWindow.filter((item) => item.id == value[3])[0]
      if (!win) {
        win = this.global.newWindow[0]
      }
      let translateData = value[0]
      let from = value[1]
      let to = value[2]
      let batch = DEFINE_STRING.QUEUE_BATCH.TRANSLATE_PROMPT
      let secretId = this.translationAppId
      let secretKey = this.translationSecret
      const CvmClient = tencentcloud.tmt.v20180321.Client
      const client = new CvmClient({
        credential: {
          secretId: secretId,
          secretKey: secretKey
        },
        region: 'ap-shanghai',
        profile: {
          signMethod: 'TC3-HMAC-SHA256', // 签名方法
          httpProfile: {
            reqMethod: 'POST', // 请求方法
            reqTimeout: 30 // 请求超时时间，默认60s
          }
        }
      })

      for (let i = 0; i < translateData.length; i++) {
        const element = translateData[i]
        this.global.requestQuene.enqueue(
          async () => {
            if (translateData.length > 5) {
              await this.tools.delay(2000)
            }
            let arr_data = []
            if (to == 'zh') {
              let tmp_data = element.prompt
              arr_data = tmp_data.replaceAll('_', ' ').replaceAll('，', ',').split(',')
              arr_data = arr_data.filter((item) => item != '' && item != null)
            } else if (to == 'en') {
              for (let j = 0; j < element.chinese_prompt.length; j++) {
                const item = element.chinese_prompt[j]
                if (item != '' && item != null) {
                  arr_data.push(item.dst)
                }
              }
            }
            // 如果为空（直接返回）
            if (arr_data.length <= 0) {
              return
            }
            // 请求数据
            let req_data = {
              Source: from,
              Target: to,
              SourceTextList: arr_data,
              ProjectId: 0
            }

            let res = await client.TextTranslateBatch(req_data)
            console.log(res)

            // 处理返回的数据
            // 检出返回的数据和输入的数据是不是一样的
            let translateList = res.TargetTextList
            if (translateList.length != arr_data.length) {
              throw new Error('请求的数据长度和返回的数据长度不一致。请重试')
            }

            let res_data = []
            // {
            //     "src": "blush",
            //     "dst": "脸红"
            // }
            if (to == 'zh') {
              for (let j = 0; j < arr_data.length; j++) {
                const item = arr_data[j]
                let obj = {
                  src: item,
                  dst: translateList[j]
                }
                res_data.push(obj)
              }
            } else if (to == 'en') {
              for (let j = 0; j < arr_data.length; j++) {
                const item = arr_data[j]
                let obj = {
                  src: translateList[j],
                  dst: item
                }
                res_data.push(obj)
              }
            }
            // 数据返回。写入本地配置文件
            // 修改chinese_prompt
            this.global.fileQueue.enqueue(async () => {
              let json_path = path.join(
                this.global.config.project_path,
                `tmp/input_crop/${element.name}.json`
              )
              let prompt_json = JSON.parse(await fspromises.readFile(json_path, 'utf-8'))
              prompt_json.chinese_prompt = res_data
              await fspromises.writeFile(json_path, JSON.stringify(prompt_json))
            })
            win.win.webContents.send(DEFINE_STRING.TRANSLATE_RETURN_REFRESH, {
              code: 1,
              to: to,
              rowId: element.id,
              data: res_data
            })
          },
          `${batch}_${element.name}`,
          batch
        )
      }
      // 监听总批次完成
      this.global.requestQuene.setBatchCompletionCallback(batch, (failedTasks) => {
        if (failedTasks.length > 0) {
          let message = `
               翻译任务都已完成。
               但是以下任务执行失败：
               `
          failedTasks.forEach(({ taskId, error }) => {
            message += `${taskId}-, \n 错误信息: ${error}` + '\n'
          })

          this.global.newWindow[0].win.webContents.send(DEFINE_STRING.SHOW_MESSAGE_DIALOG, {
            code: 0,
            message: message
          })
        } else {
          if (value[4]) {
            this.global.newWindow[0].win.webContents.send(DEFINE_STRING.SHOW_MESSAGE_DIALOG, {
              code: 1,
              message: '批次翻译任务完成'
            })
          }
        }
      })
      return {
        code: 1,
        message: '翻译任务已加入队列任务中'
      }
    } catch (error) {
      throw error
    }
  }

  /**
   * 火山引擎翻译实时返回
   * @param {*} value
   */
  async TranslateReturnNowVolcengine(value) {
    try {
      // 判断该当前的翻译API
      let from = value[1]
      let to = value[2]
      let ts_d = value[0].replaceAll('_', ' ').replaceAll('，', ',')
      let req_data = []
      if (value[3]) {
        req_data = ts_d.split(',')
      } else {
        req_data.push(ts_d)
      }
      if (req_data.length <= 0) {
        throw new Error('没有传入数据')
      }
      let signer = await this.GetVolcengineSinger()

      let config = {
        method: 'post',
        maxBodyLength: Infinity,
        url: `${this.translationBusiness}${signer}`,
        headers: {
          'Content-Type': 'application/json'
        },
        data: JSON.stringify({
          SourceLanguage: from,
          TargetLanguage: to,
          TextList: req_data
        })
      }
      let res = await axios.request(config)
      if (res.status != 200) {
        throw new Error('请求错误。请检查网络')
      }
      // 判断是不是有返回错误
      if (res.data.ResponseMetadata && res.data.ResponseMetadata.Error) {
        let err = res.data.ResponseMetadata.Error
        throw new Error(
          `错误码： ${err.Code}  错误编号：${err.CodeN}  错误详细信息：${err.Message}`
        )
      }

      // 处理返回的数据
      // 检出返回的数据和输入的数据是不是一样的
      let translateList = res.data.TranslationList
      if (translateList.length != req_data.length) {
        throw new Error('请求的数据长度和返回的数据长度不一致。请重试')
      }
      // {
      //     "src": "blush",
      //     "dst": "脸红"
      // }
      // 数据处理
      let res_data = []
      for (let j = 0; j < req_data.length; j++) {
        const item = req_data[j]
        if (to == 'zh') {
          let obj = {
            src: item,
            dst: translateList[j].Translation
          }
          res_data.push(obj)
        } else if (to == 'en') {
          let obj = {
            src: translateList[j].Translation,
            dst: item
          }
          res_data.push(obj)
        }
      }

      // 直接返回数据
      return {
        code: 1,
        to: to,
        data: res_data
      }
    } catch (error) {
      throw error
    }
  }

  /**
   * 火山引擎翻译所有数据队列返回
   * @param {*} value
   */
  async TranslatePromptVolcengine(value) {
    try {
      let win = this.global.newWindow.filter((item) => item.id == value[3])[0]
      if (!win) {
        win = this.global.newWindow[0]
      }
      let signer = await this.GetVolcengineSinger()
      let translateData = value[0]
      let from = value[1]
      let to = value[2]
      let batch = DEFINE_STRING.QUEUE_BATCH.TRANSLATE_PROMPT
      for (let i = 0; i < translateData.length; i++) {
        const element = translateData[i]
        this.global.requestQuene.enqueue(
          async () => {
            if (translateData.length > 5) {
              await this.tools.delay(2000)
            }
            let arr_data = []
            if (to == 'zh') {
              let tmp_data = element.prompt
              arr_data = tmp_data.replaceAll('_', ' ').replaceAll('，', ',').split(',')
              arr_data = arr_data.filter((item) => item != '' && item != null)
            } else if (to == 'en') {
              for (let j = 0; j < element.chinese_prompt.length; j++) {
                const item = element.chinese_prompt[j]
                if (item != '' && item != null) {
                  arr_data.push(item.dst)
                }
              }
            }
            // 如果为空（直接返回）
            if (arr_data.length <= 0) {
              return
            }
            // 开始请求
            let req_data = JSON.stringify({
              SourceLanguage: from,
              TargetLanguage: to,
              TextList: arr_data
            })
            let config = {
              method: 'post',
              maxBodyLength: Infinity,
              url: `${this.translationBusiness}${signer}`,
              headers: {
                'Content-Type': 'application/json'
              },
              data: req_data
            }
            let res = await axios.request(config)
            console.log(res)
            if (res.status != 200) {
              throw new Error('请求状态码错误。请检查网络')
            }

            // 判断是不是有返回错误
            if (res.data.ResponseMetadata && res.data.ResponseMetadata.Error) {
              let err = res.data.ResponseMetadata.Error
              throw new Error(
                `错误码： ${err.Code}  错误编号：${err.CodeN}  错误详细信息：${err.Message}`
              )
            }

            // 处理返回的数据
            // 检出返回的数据和输入的数据是不是一样的
            let translateList = res.data.TranslationList
            if (translateList.length != arr_data.length) {
              throw new Error('请求的数据长度和返回的数据长度不一致。请重试')
            }

            let res_data = []
            // {
            //     "src": "blush",
            //     "dst": "脸红"
            // }
            if (to == 'zh') {
              for (let j = 0; j < arr_data.length; j++) {
                const item = arr_data[j]
                let obj = {
                  src: item,
                  dst: translateList[j].Translation
                }
                res_data.push(obj)
              }
            } else if (to == 'en') {
              for (let j = 0; j < arr_data.length; j++) {
                const item = arr_data[j]
                let obj = {
                  src: translateList[j].Translation,
                  dst: item
                }
                res_data.push(obj)
              }
            }
            // 数据返回。写入本地配置文件
            // 修改chinese_prompt
            this.global.fileQueue.enqueue(async () => {
              let json_path = path.join(
                this.global.config.project_path,
                `tmp/input_crop/${element.name}.json`
              )
              let prompt_json = JSON.parse(await fspromises.readFile(json_path, 'utf-8'))
              prompt_json.chinese_prompt = res_data
              await fspromises.writeFile(json_path, JSON.stringify(prompt_json))
            })
            win.win.webContents.send(DEFINE_STRING.TRANSLATE_RETURN_REFRESH, {
              code: 1,
              to: to,
              rowId: element.id,
              data: res_data
            })
          },
          `${batch}_${element.name}`,
          batch
        )
      }
      // 监听总批次完成
      this.global.requestQuene.setBatchCompletionCallback(batch, (failedTasks) => {
        if (failedTasks.length > 0) {
          let message = `
               翻译任务都已完成。
               但是以下任务执行失败：
               `
          failedTasks.forEach(({ taskId, error }) => {
            message += `${taskId}-, \n 错误信息: ${error}` + '\n'
          })

          this.global.newWindow[0].win.webContents.send(DEFINE_STRING.SHOW_MESSAGE_DIALOG, {
            code: 0,
            message: message
          })
        } else {
          if (value[4]) {
            this.global.newWindow[0].win.webContents.send(DEFINE_STRING.SHOW_MESSAGE_DIALOG, {
              code: 1,
              message: '批次翻译任务完成'
            })
          }
        }
      })
      return {
        code: 1,
        message: '翻译任务已加入队列任务中'
      }
    } catch (error) {
      throw error
    }
  }

  /**
   * 获取火山引擎请求的签名
   */
  async GetVolcengineSinger() {
    try {
      const openApiRequestData = {
        method: 'POST',
        region: 'cn-north-1',
        params: {
          Action: 'TranslateText',
          Version: '2020-06-01'
        },
        Service: 'translate'
      }

      const credentials = {
        accessKeyId: this.translationAppId,
        secretKey: this.translationSecret
      }

      const signer = new Signer(openApiRequestData, 'translate')

      // 最终经过加签的 HTTP Query Params
      const signedQueryString = signer.getSignUrl(credentials)
      console.log(signedQueryString)
      return signedQueryString
    } catch (error) {
      throw error
    }
  }

  /**
   * 百度引擎翻译翻译所有数据
   * @param {} value
   * @returns
   */
  async TranslatePromptBaidu(value) {
    try {
      let win = this.global.newWindow.filter((item) => item.id == value[3])[0]
      if (!win) {
        win = this.global.newWindow[0]
      }
      let translateData = value[0]
      let from = value[1]
      let to = value[2]
      let batch = DEFINE_STRING.QUEUE_BATCH.TRANSLATE_PROMPT
      let appId = this.translationAppId

      // 添加一个频次判断是不是演示

      for (let i = 0; i < translateData.length; i++) {
        const element = translateData[i]
        this.global.requestQuene.enqueue(
          async () => {
            try {
              if (translateData.length > 5) {
                await this.tools.delay(2000)
              }
              let ts_d = ''
              if (to == 'zh') {
                ts_d = element.prompt
                  .replaceAll('_', ' ')
                  .replaceAll('，', ',')
                  .replaceAll(',', '\n')
              } else if (to == 'en') {
                let tmp_arr = []
                // 中文转英文。重新拼接一下
                for (let j = 0; j < element.chinese_prompt.length; j++) {
                  const item = element.chinese_prompt[j]
                  tmp_arr.push(item.dst)
                }
                ts_d = tmp_arr.join('\n')
              }
              let salt = Date.now()
              let sign = MD5(
                `${this.translationAppId}${ts_d}${salt}${this.translationSecret}`
              ).toString()
              let res = await axios.get(this.translationBusiness, {
                params: {
                  q: ts_d,
                  appid: appId,
                  salt: salt,
                  from: from,
                  to: to,
                  sign: sign
                }
              })
              if (res.status != 200) {
                throw new Error('请求错误。请检查网络')
              }
              // 判断是不是有错误码
              if (res.data.error_code) {
                throw new Error(res.data.error_msg)
              }

              let res_data = []
              // 将所有的数据协会到本地（然后发送消息到前台界面）
              if (res.data.to == 'zh') {
                res_data = res.data.trans_result
              } else {
                // 直接在这边处理（前端不用处理）
                for (let i = 0; i < res.data.trans_result.length; i++) {
                  const element = res.data.trans_result[i]
                  let obj = {
                    src: element.dst,
                    dst: element.src
                  }
                  res_data.push(obj)
                }
              }

              // 修改chinese_prompt
              this.global.fileQueue.enqueue(async () => {
                let json_path = path.join(
                  this.global.config.project_path,
                  `tmp/input_crop/${element.name}.json`
                )
                let prompt_json = JSON.parse(await fspromises.readFile(json_path, 'utf-8'))
                prompt_json.chinese_prompt = res_data
                await fspromises.writeFile(json_path, JSON.stringify(prompt_json))
              })

              win.win.webContents.send(DEFINE_STRING.TRANSLATE_RETURN_REFRESH, {
                code: 1,
                to: to,
                rowId: element.id,
                data: res_data
              })
            } catch (error) {
              throw error
            }
          },
          `${batch}_${element.name}`,
          batch
        )
      }
      // 监听总批次完成
      this.global.requestQuene.setBatchCompletionCallback(batch, (failedTasks) => {
        if (failedTasks.length > 0) {
          let message = `
               翻译任务都已完成。
               但是以下任务执行失败：
               `
          failedTasks.forEach(({ taskId, error }) => {
            message += `${taskId}-, \n 错误信息: ${error}` + '\n'
          })

          this.global.newWindow[0].win.webContents.send(DEFINE_STRING.SHOW_MESSAGE_DIALOG, {
            code: 0,
            message: message
          })
        } else {
          if (value[4]) {
            this.global.newWindow[0].win.webContents.send(DEFINE_STRING.SHOW_MESSAGE_DIALOG, {
              code: 1,
              message: '批次翻译任务完成'
            })
          }
        }
      })
      return {
        code: 1,
        message: '翻译任务已加入队列任务中'
      }
    } catch (error) {
      throw error
    }
  }

  /**
   * 百度翻译引擎翻译单个数据。立即返回
   * @param {*} value
   * @returns
   */
  async TranslateReturnNowBaidu(value) {
    try {
      // 判断该当前的翻译API
      let from = value[1]
      let to = value[2]
      let appId = this.translationAppId
      let ts_d = value[0].replaceAll('_', ' ').replaceAll('，', ',')
      if (value[3]) {
        ts_d = ts_d.replaceAll(',', '\n')
      }
      let salt = Date.now()

      let sign = MD5(`${this.translationAppId}${ts_d}${salt}${this.translationSecret}`).toString()
      let res = await axios.get(this.translationBusiness, {
        params: {
          q: ts_d,
          appid: appId,
          salt: salt,
          from: from,
          to: to,
          sign: sign
        }
      })
      if (res.status != 200) {
        throw new Error('请求错误。请检查网络')
      }
      // 判断是不是有错误码
      if (res.data.error_code) {
        throw new Error(res.data.error_msg)
      }

      let res_data = []
      // 将所有的数据协会到本地（然后发送消息到前台界面）
      if (res.data.to == 'zh') {
        res_data = res.data.trans_result
      } else {
        // 直接在这边处理（前端不用处理）
        for (let i = 0; i < res.data.trans_result.length; i++) {
          const element = res.data.trans_result[i]
          let obj = {
            src: element.dst,
            dst: element.src
          }
          res_data.push(obj)
        }
      }

      // 直接返回数据
      return {
        code: 1,
        to: to,
        data: res_data
      }
    } catch (error) {
      throw error
    }
  }
}