tools_batch_files 1.0.34 → 1.0.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tools_batch_files",
-  "version": "1.0.34",
+  "version": "1.0.36",
   "description": "批处理视频工具",
   "keywords": [
     "utils",
@@ -13,6 +13,7 @@
     "tbf": "./index.js",
     "tbfp": "./src/photoBatch.js",
     "tbfa": "./src/audioFn/audioBatch.js",
+    "tbfv": "./src/videoFn/videoBatch.js",
     "tbfb": "./src/photoBatchBack.js",
     "tbfre": "./src/removeFailVideo.js"
   },

package/src/audioFn/audioBatch.js

@@ -29,6 +29,12 @@ const queueCount = 10;
 //起始任务下标
 let taskIndex = 0;
 
+//已完成数量
+let completeCount = 0;
+
+//错误文件重试次数
+let retryError = 0;
+
 //执行目录
 const exeDir = __dirname;
 //当前工作目录
@@ -48,7 +54,13 @@ const ZIP_FILES_DIR = "zip";
 //拷贝 - 存放上传失败的文件
 const Error_Files_Dir = "failed_audio";
 //水印
-const watermarkAudioPath = path.join(__dirname, "..", "vocal_print", "mz.mp3");
+const watermarkAudioPath = path.join(
+  __dirname,
+  "..",
+  "..",
+  "vocal_print",
+  "mz.mp3"
+);
 const longWatermarkAudioPath = path.join(
   __dirname,
   "..",
@@ -77,7 +89,7 @@ const watermarkAudio = (indexFilePath, originFilePath, fileName, duration) => {
     `[1:a]atrim=0:duration=${duration},volume=1.5[a1]`, // 对声纹音频流进行截取操作，并设置音量，重命名为a1
     `[a0][a1]amix=inputs=2[a]`, // 合并两个音频流为一个输出流，重命名为a
     `[a]volume=3.0`, // 设置输出音频的音量
-  ].join(";");
+  ];
 
   if (duration <= 5) {
     //直接合并，放在末尾，下次补上
@@ -108,7 +120,7 @@ const watermarkAudio = (indexFilePath, originFilePath, fileName, duration) => {
       .input(originFilePath)
       .input(vocalPath) // 声纹音频文件
 
-      .complexFilter(complexFilter)
+      .complexFilter(complexFilter.join(";"))
       .output(outputFile)
       .on("error", (err) => {
         logger("添加声纹出错: " + err);
@@ -272,8 +284,8 @@ const postData = (dataParams, indexFilePath, index) => {
   logger(`第${index}条等待接口返回结果……`);
 
   // return axios.post("http://192.168.102.61:9999/upload/sound", formData, {
-  // return axios.post("http://127.0.0.1:9999/upload/sound", formData, {
-  return axios.post("http://192.168.101.149:9999/upload/sound", formData, {
+  // return axios.post("http://192.168.101.149:9999/upload/sound", formData, {
+  return axios.post("http://127.0.0.1:9999/upload/sound", formData, {
     headers: {
       "Content-Type": "multipart/form-data",
     },
@@ -289,7 +301,8 @@ async function postDataWithRetry(
   indexFilePath,
   index,
   fileName,
-  hash
+  hash,
+  type
 ) {
   let retryCount = 0; // 当前重试次数
 
@@ -300,7 +313,7 @@ async function postDataWithRetry(
         logger("请求成功！");
         logger(resData.data.code);
         // 文件名和索引值
-        successLogger(hash, index, fileName);
+        successLogger(hash, index, fileName, type);
         removeDirectory(indexFilePath);
         return;
       } else if (resData.data.code === 300) {
@@ -327,7 +340,7 @@ async function postDataWithRetry(
 /**
  * 任务
  */
-const task = async (row, index, hash) => {
+const task = async (row, index, hash, type) => {
   //index文件夹   output/0
   const indexFilePath = path.join(workDir, "output", index + "");
   let fileName = row.fileName;
@@ -393,7 +406,14 @@ const task = async (row, index, hash) => {
     await archiveZip(fileName, indexFilePath, originFilePath);
 
     // 重试机制
-    await postDataWithRetry(dataParams, indexFilePath, index, fileName, hash);
+    await postDataWithRetry(
+      dataParams,
+      indexFilePath,
+      index,
+      fileName,
+      hash,
+      type
+    );
 
     logger(
       `----------------------------------------第${index}条结束---------------------------------end`
@@ -414,35 +434,41 @@ const task = async (row, index, hash) => {
   }
 };
 
-const run = (index, data, hash) => {
+const run = (index, data, hash, type) => {
   try {
     logger(
       `run-------------------------------------第${index}条开始------------------------------------`
     );
     const row = data[index];
 
-    if (!row) {
+    if (completeCount >= data.length) {
       taskIndex = 0;
       logger(
         index +
           "=========================当前任务，最后一条已结束！========================="
       );
 
+      successLogger(hash, index, "done");
+
       // 是否存在错误列表？ 存在的话，继续遍历
-      const errorExcelPath = path.join(workDir, `error${hash}.xlsx`);
-      if (isExist(errorExcelPath)) {
-        const jsonData2 = readExcel(errorExcelPath);
-        queue(taskIndex, jsonData2, hash);
-      } else {
-        logger("跑干了！");
+      const status = runErrorList(taskIndex, hash);
+      if (!status) {
+        logger(
+          "》》》》》》》》》》音频批量任务任务结束《《《《《《《《《《" + hash
+        );
       }
 
       return;
     }
 
-    task(row, index, hash)
+    if (!row) {
+      return;
+    }
+
+    task(row, index, hash, type)
       .then(() => {
         taskIndex++;
+        completeCount++;
         run(taskIndex, data, hash);
       })
       .catch((err) => {
@@ -450,15 +476,52 @@ const run = (index, data, hash) => {
       });
   } catch (error) {
     logger("捕获错误！" + error);
+    completeCount++;
     taskIndex++;
     run(taskIndex, data, hash);
   }
 };
 
-const queue = (taskIndex, jsonData, hash) => {
-  for (let i = 0; i < queueCount; i++) {
-    run(i + taskIndex, jsonData, hash);
+const queue = (index, jsonData, hash, type) => {
+  const rest = jsonData.length - index;
+  const count = queueCount > rest ? rest : queueCount;
+  const queueList = [];
+  completeCount = index;
+
+  for (let i = 0; i < count; i++) {
+    queueList.push(run(i + index, jsonData, hash, type));
   }
+
+  taskIndex += count - 1;
+  return Promise.all(queueList);
+};
+
+//yunxing cuowu wenjian
+const runErrorList = (index, hash, parentHash) => {
+  const fileHash = parentHash || hash;
+  const errorExcelPath = path.join(workDir, `error${fileHash}.xlsx`);
+
+  if (retryError > 5) {
+    console.log("出现无法解析的错误");
+    return false;
+  }
+
+  taskIndex = index;
+  let taskHash = hash;
+  //新的运行任务-重新赋予新的任务id
+  if (index === 0) {
+    taskHash = generateUniqueHash().slice(0, 8);
+  }
+
+  if (isExist(errorExcelPath)) {
+    retryError++;
+
+    logger("开始运行错误列表");
+    jsonData = readExcel(errorExcelPath); //   数据来源于error excel
+    queue(index, jsonData, taskHash, fileHash);
+    return true;
+  }
+  return false;
 };
 
 const main = () => {
@@ -473,18 +536,31 @@ const main = () => {
 
   const successPath = path.join(workDir, "success.txt");
   if (isExist(successPath)) {
-    const { loghash, lastItemIndex } = readTxt(successPath);
-    const errorExcelPath = path.join(workDir, `error${loghash}.xlsx`);
-    logger("成功日志存在，异常中断或者跑完了。");
+    const { loghash, lastItemIndex, fileName, parentHash } =
+      readTxt(successPath);
 
     hash = loghash;
-    taskIndex = lastItemIndex + 1; // lastItemIndex为最后一项，所有要+1
-
-    if (isExist(errorExcelPath)) {
-      jsonData = readExcel(errorExcelPath); //   数据来源于error excel
-      queue(taskIndex, jsonData, hash);
+    taskIndex = parseInt(lastItemIndex) + 1; // lastItemIndex为最后一项，所有要+1
+
+    //当前任务已经结束
+    if (fileName === "done") {
+      //找寻是否存在未上传的错误文件列表
+      const status = runErrorList(0, hash);
+      if (!status) {
+        logger(
+          "》》》》》》》》》》音频批量任务任务结束《《《《《《《《《《" + hash
+        );
+      }
     } else {
-      logger("跑干了！");
+      //当前任务异常中断
+
+      //中断的任务类型为错误任务
+      if (parentHash) {
+        runErrorList(taskIndex, hash, parentHash);
+      } else {
+        jsonData = readExcel(excelDir);
+        queue(taskIndex, jsonData, hash);
+      }
     }
   } else {
     hash = generateUniqueHash().slice(0, 8);

package/src/videoFn/videoBatch.js

@@ -0,0 +1,696 @@
+#!/usr/bin/env node
+const generateUniqueHash = require("../../utils/index");
+const {
+  disposeError,
+  readExcel,
+  logger,
+  successLogger,
+} = require("../../utils/logger");
+
+const {
+  findFileInDir,
+  logFileSize,
+  ensureDirSync,
+  isExist,
+  readTxt,
+  removeDirectory,
+} = require("../../utils/settleFiles");
+const ffmpeg = require("fluent-ffmpeg");
+const fs = require("fs");
+const path = require("path");
+const fs_asnyc = require("fs").promises;
+const archiver = require("archiver");
+const axios = require("axios");
+const FormData = require("form-data");
+
+//并发数量
+const queueCount = 10;
+
+//起始任务下标
+let taskIndex = 0;
+
+//已完成数量
+let completeCount = 0;
+
+//错误文件重试次数
+let retryError = 0;
+
+//执行目录
+const exeDir = __dirname;
+//当前工作目录
+const workDir = process.cwd();
+
+//图片水印
+const watermarkImage = path.join(exeDir, "imgs", "miz-watermark.png");
+
+// 表格目录，从excel文件夹中查找
+const excelFiles = fs
+  .readdirSync(path.join(workDir, "excel"))
+  .find((file) => file.endsWith(".xlsx"));
+const excelDir = path.join(workDir, "excel", excelFiles);
+
+// 截图数量
+const SCREENSHOT_COUNT = 5;
+const ORIGIN_FILE_DIR = "files";
+const ZIP_FILES_DIR = "zip";
+const ZIP_VIDEO_DIR_400 = "small_video";
+const SCREENSHOT_DIR = "screenshots";
+const ZIP_SCREENSHOT_DIR = "screenshot_watermark";
+const ZIP_WATERMARK_VIDEO_DIR = "zip_watermark_video";
+const SOURCE_VIDEO_DIR = "source_video";
+const ZIP_VIDEO_DIR = "zip_video";
+
+const maxRetries = 1; // 最大重试次数
+
+/**
+ * 压缩视频
+ * @param {*} fileName 文件名
+ * @param {*} outputFileDir 产物文件夹
+ * @param {*} inputFilePath 源文件路径
+ * @returns Promise
+ */
+const compressVideo = (fileName, outputFileDir, inputFilePath) => {
+  const outputFilePath = path.join(
+    outputFileDir,
+    ZIP_VIDEO_DIR,
+    `zip-${fileName}`
+  );
+  const comand = ffmpeg(inputFilePath);
+
+  ensureDirSync(path.dirname(outputFilePath));
+  return new Promise((resolve, reject) => {
+    comand
+      .videoCodec("libx264")
+      .size("1280x?")
+      // .size("1280x720")
+
+      .output(outputFilePath)
+
+      .on("start", () => {
+        logger("视频开始压缩……");
+      })
+      .on("end", () => {
+        logger("视频压缩完成！");
+        resolve(outputFilePath);
+      })
+      .on("error", (err) => {
+        logger("视频压缩出错:" + err);
+        reject(err);
+      })
+      .run();
+  });
+};
+
+/**
+ * 压缩400p视频
+ */
+const compressVideo400p = (fileName, outputFileDir, inputFilePath) => {
+  const outputFilePath = path.join(
+    outputFileDir,
+    ZIP_VIDEO_DIR_400,
+    `zip-${fileName}`
+  );
+  const comand = ffmpeg(inputFilePath);
+
+  ensureDirSync(path.dirname(outputFilePath));
+  return new Promise((resolve, reject) => {
+    comand
+      .seekInput(0)
+      .inputOptions("-t 10")
+      .videoCodec("libx264")
+      .size("400x?")
+
+      .output(outputFilePath)
+
+      .on("start", () => {
+        logger("400p视频开始压缩……");
+      })
+      .on("end", () => {
+        logger("400p视频压缩完成！");
+        resolve(outputFilePath);
+      })
+      .on("error", (err) => {
+        logger("视频压缩出错:", err);
+        reject(err);
+      })
+      .run();
+  });
+};
+
+/**
+ * 生成5张截图
+ */
+const get5Screenshots = (fileName, outputFilePath, inputFilePath) => {
+  const folderPath = path.join(outputFilePath, SCREENSHOT_DIR); // 构建完整的目录路径
+
+  ensureDirSync(folderPath);
+  return new Promise((resolve, reject) => {
+    const screenshotsCommand = ffmpeg(inputFilePath);
+
+    screenshotsCommand
+      .on("start", () => {
+        logger("开始从视频中截图……");
+      })
+      .on("end", (stdout, stderr) => {
+        logger(inputFilePath + "截图完成!!!");
+        resolve();
+      })
+      .on("error", (err) => {
+        logger(inputFilePath + "截图出错:", err);
+        reject(err);
+      })
+
+      .screenshots({
+        timemarks: [0, "25%", "50%", "75%", "90%"],
+        folder: folderPath,
+        filename: `screenshots-%i.png`,
+        size: "840x?",
+      });
+  });
+};
+
+/**
+ * 视频打水印
+ */
+const watermarkVideo = (fileName, outputFileDir) => {
+  //用压缩后的视频作为输入源，增加效率
+  const inputFilePath = path.join(
+    outputFileDir,
+    ZIP_VIDEO_DIR,
+    `zip-${fileName}`
+  );
+  const outputFilePath = path.join(
+    outputFileDir,
+    ZIP_WATERMARK_VIDEO_DIR,
+    `zip-watermark-${fileName}`
+  );
+  const watermarkCommand = ffmpeg(inputFilePath);
+
+  ensureDirSync(path.dirname(outputFilePath));
+
+  return new Promise((resolve, reject) => {
+    watermarkCommand
+      .input(watermarkImage) // 添加水印图片作为第二个输入
+
+      .complexFilter([
+        "[0:v][1:v]overlay=(main_w-overlay_w)/2:(main_h-overlay_h)/2",
+      ])
+      .output(outputFilePath)
+      .on("start", () => {
+        logger("视频开始打水印……");
+      })
+      .on("end", () => {
+        logger("视频打水印完成！");
+        resolve(outputFilePath);
+      })
+      .on("error", (err) => {
+        logger("视频打水印出错:", err);
+        reject(err);
+      })
+      .run();
+  });
+};
+
+/**
+ * 截图水印，根据截图打水印
+ */
+const watermarkScreenshots = (indexFilePath) => {
+  //存放水印截图的文件夹
+  const inputDir = path.join(indexFilePath, SCREENSHOT_DIR);
+  const outputDir = path.join(indexFilePath, ZIP_SCREENSHOT_DIR);
+  ensureDirSync(outputDir);
+
+  return new Promise((resolve, reject) => {
+    fs.readdir(inputDir, (err, files) => {
+      if (err) {
+        logger("读取截图文件夹出错: " + err);
+        return;
+      } else {
+        files.forEach((file, index) => {
+          if (path.extname(file) === ".png") {
+            const inputFile = path.join(inputDir, file);
+            const outputFile = path.join(outputDir, file);
+
+            const watermarkScreenshotsComand = ffmpeg(inputFile);
+            watermarkScreenshotsComand
+              .input(watermarkImage)
+              .complexFilter([
+                "[0:v][1:v]overlay=(main_w-overlay_w)/2:(main_h-overlay_h)/2",
+              ])
+              .output(outputFile)
+              .on("error", (err) => {
+                logger("截图添加水印出错: ", err);
+                reject();
+              })
+              .on("end", () => {
+                logger("截图水印添加完成: " + outputFile);
+                if (index + 1 === SCREENSHOT_COUNT) {
+                  resolve();
+                }
+              })
+              .run();
+          } else {
+            logger("截图不是png文件，无法添加图片水印！");
+            reject();
+          }
+        });
+      }
+    });
+  });
+};
+
+/**
+ * 打包物料
+ */
+const archiveZip = (fileName, inputPath, originFilePath) => {
+  const zipDir = path.join(inputPath, "zip");
+  const timestamp = new Date().getTime();
+
+  ensureDirSync(zipDir);
+  // create a file to stream archive data to.
+  const zipStream = fs.createWriteStream(
+    path.join(zipDir, `package${timestamp}.zip`)
+  );
+  const archive = archiver("zip", {
+    zlib: { level: 9 }, // Sets the compression level.
+  });
+
+  return new Promise((resolve, reject) => {
+    // listen for all archive data to be written
+    // 'close' event is fired only when a file descriptor is involved
+    zipStream.on("close", function () {
+      logger("压缩数据：" + archive.pointer() + " total bytes");
+      logger(
+        "完成归档archiver has been finalized and the output file descriptor has closed."
+      );
+      resolve();
+    });
+
+    // good practice to catch warnings (ie stat failures and other non-blocking errors)
+    archive.on("warning", function (err) {
+      if (err.code === "ENOENT") {
+        logger("压缩-warning：" + err);
+      } else {
+        // throw error
+        throw err;
+      }
+    });
+
+    // good practice to catch this error explicitly
+    archive.on("error", function (err) {
+      logger("压缩失败！" + err);
+      reject();
+    });
+
+    archive.pipe(zipStream);
+
+    const directories = [
+      ZIP_VIDEO_DIR,
+      SCREENSHOT_DIR,
+      ZIP_WATERMARK_VIDEO_DIR,
+      ZIP_SCREENSHOT_DIR,
+      ZIP_VIDEO_DIR_400,
+    ];
+
+    directories.forEach((dir) => {
+      const dirPath = path.join(inputPath, dir);
+      archive.directory(dirPath, dir);
+    });
+
+    archive.file(originFilePath, {
+      name: path.join(SOURCE_VIDEO_DIR, fileName),
+    });
+    // 完成归档
+    archive.finalize();
+  });
+};
+
+/**
+ * 获取 元数据
+ */
+const getMetadata = async (
+  indexFilePath,
+  originFilePath,
+  { title, keyword, anotherId }
+) => {
+  //第一张截图
+  const photoInputPath = path.join(
+    indexFilePath,
+    SCREENSHOT_DIR,
+    "screenshots-1.png"
+  );
+
+  const videoMetadataComand = ffmpeg(originFilePath);
+  const photoMetadataComand = ffmpeg(photoInputPath);
+  const metaDataParams = {
+    userid: 10876358,
+    username: "樊建",
+    pixel_width: "",
+    pixel_height: "",
+    size: "",
+    duration: "",
+    video_id: anotherId,
+    title,
+    keyword,
+    pr: 0,
+    format: "mp4",
+    category_id: 4,
+    demand_kind: 23,
+    source_from: 74,
+    plate_id: 5,
+    tag_id: 158,
+    is_government: 0,
+    preview_width: "",
+    preview_height: "",
+  };
+  await new Promise((resolve, reject) => {
+    videoMetadataComand.ffprobe(function (err, metadata) {
+      const videoStream = metadata.streams.find(
+        (s) => s.codec_type === "video"
+      );
+      const formatStream = metadata.format;
+
+      metaDataParams.pixel_width = videoStream.width;
+      metaDataParams.pixel_height = videoStream.height;
+      metaDataParams.duration = videoStream.duration;
+      metaDataParams.size = formatStream.size;
+      resolve();
+    });
+  });
+
+  await new Promise((resolve, reject) => {
+    photoMetadataComand.ffprobe(function (err, metadata) {
+      const photoStream = metadata.streams.find(
+        (s) => s.codec_type === "video"
+      );
+
+      metaDataParams.preview_width = photoStream.width;
+      metaDataParams.preview_height = photoStream.height;
+      resolve();
+    });
+  });
+
+  return metaDataParams;
+};
+
+/**
+ * 接口
+ */
+const postData = (dataParams, indexFilePath, index) => {
+  const formData = new FormData();
+
+  const zipFiles = fs
+    .readdirSync(path.join(indexFilePath, ZIP_FILES_DIR))
+    .find((file) => file.endsWith(".zip"));
+
+  const packageZip = path.join(indexFilePath, ZIP_FILES_DIR, zipFiles);
+
+  formData.append("file", fs.createReadStream(packageZip));
+  for (const key in dataParams) {
+    if (Object.hasOwnProperty.call(dataParams, key)) {
+      const value = dataParams[key];
+      formData.append(key, value);
+    }
+  }
+
+  logger(`第${index}条等待接口返回结果……`);
+
+  // return axios.post("http://192.168.102.61:9999/upload/sound", formData, {
+  // return axios.post("http://192.168.101.149:9999/upload/sound", formData, {
+  return axios.post("http://127.0.0.1:9999/upload/video", formData, {
+    headers: {
+      "Content-Type": "multipart/form-data",
+    },
+    timeout: 300000,
+  });
+};
+
+/**
+ * 接口重试机制
+ */
+async function postDataWithRetry(
+  dataParams,
+  indexFilePath,
+  index,
+  fileName,
+  hash,
+  type
+) {
+  let retryCount = 0; // 当前重试次数
+
+  while (retryCount < maxRetries) {
+    try {
+      const resData = await postData(dataParams, indexFilePath, index);
+      if (resData.data.code === 200) {
+        logger("请求成功！");
+        logger(resData.data.code);
+        // 文件名和索引值
+        successLogger(hash, index, fileName, type);
+        removeDirectory(indexFilePath);
+        return;
+      } else if (resData.data.code === 300) {
+        // 重复上传，不捕获此错误
+        logger(resData.data.code);
+        logger(`第${index}条文件-${index}重复上传！`);
+        removeDirectory(indexFilePath);
+        return;
+      } else {
+        logger(`请求失败，重试中... (${retryCount + 1}/${maxRetries})`);
+        logger(`请求code！==200： ${resData.data.code}${resData.data.msg}`);
+        // 延时等待一段时间后再进行重试
+        await new Promise((resolve) => setTimeout(resolve, 100)); // 等待0.1秒
+        retryCount++;
+      }
+    } catch (error) {
+      throw new Error("重试机制错误！" + error);
+    }
+  }
+  // 如果达到最大重试次数仍然失败，则抛出异常
+  throw new Error("请求失败，重试次数已达到上限！");
+}
+
+/**
+ * 任务
+ */
+const task = async (row, index, hash, type) => {
+  //index文件夹   output/0
+  const indexFilePath = path.join(workDir, "output", index + "");
+  let fileName = row.fileName;
+  const rowFileName = row.fileName;
+  const title = row.title;
+  const keyword = row.keyword;
+  /**
+   * 唯一标识符id，仅错误excel中有 anotherI d 列
+   */
+  const anotherId = row.anotherId ? row.anotherId : row.fileName;
+
+  try {
+    logger(
+      "**************************" + row.fileName + "**************************"
+    );
+
+    // if (!fileName.includes(".")) {
+    //   fileName = row.fileName + ".mp44444";   //findFileInDir后期返回两个 文件路径和 文件名
+    // }
+
+    const getPathStartTime = new Date();
+    // 源音频文件夹路径
+    const originFilePath = await findFileInDir(
+      path.join(workDir, ORIGIN_FILE_DIR),
+      fileName
+    );
+
+    const getPathEndTime = new Date();
+    const timeInSeconds1 = ((getPathEndTime - getPathStartTime) / 1000).toFixed(
+      2
+    );
+
+    logger(`第${index}条Path路径搜索时间：${timeInSeconds1}秒`);
+    logger(`-------------------${new Date()}------------------`);
+
+    logger("原文件路径：" + originFilePath);
+    logger(`第${index}条原文件路径：${originFilePath}`);
+
+    if (!originFilePath) {
+      logger(`第${index}条音频文件 ${fileName} 不存在`);
+      return;
+    }
+
+    await fs_asnyc.access(originFilePath, fs_asnyc.constants.F_OK);
+    logFileSize(originFilePath, index);
+    await compressVideo(fileName, indexFilePath, originFilePath);
+    await compressVideo400p(fileName, indexFilePath, originFilePath);
+    await get5Screenshots(fileName, indexFilePath, originFilePath);
+    await watermarkVideo(fileName, indexFilePath);
+    await watermarkScreenshots(indexFilePath);
+    await archiveZip(fileName, indexFilePath, originFilePath);
+
+    const dataParams = await getMetadata(indexFilePath, originFilePath, {
+      title,
+      keyword,
+      anotherId,
+    });
+
+    // 重试机制
+    await postDataWithRetry(
+      dataParams,
+      indexFilePath,
+      index,
+      fileName,
+      hash,
+      type
+    );
+
+    logger(
+      `----------------------------------------第${index}条结束---------------------------------end`
+    );
+  } catch (error) {
+    // 可以约定code，来表示不同的错误信息
+    if (error.code === "ENOENT") {
+      logger(`音频文件 ${fileName} 不存在`);
+    } else {
+      logger("音频任务失败（最外层catch）：" + error);
+    }
+    removeDirectory(indexFilePath);
+    disposeError(hash, { fileName, keyword, title, anotherId });
+  }
+};
+
+const run = (index, data, hash, type) => {
+  try {
+    logger(
+      `run-------------------------------------第${index}条开始------------------------------------`
+    );
+    const row = data[index];
+
+    if (completeCount >= data.length) {
+      taskIndex = 0;
+      logger(
+        index +
+          "=========================当前任务，最后一条已结束！========================="
+      );
+
+      successLogger(hash, index, "done");
+
+      // 是否存在错误列表？ 存在的话，继续遍历
+      const status = runErrorList(taskIndex, hash);
+      if (!status) {
+        logger(
+          "》》》》》》》》》》音频批量任务任务结束《《《《《《《《《《" + hash
+        );
+      }
+
+      return;
+    }
+
+    if (!row) {
+      return;
+    }
+
+    task(row, index, hash, type)
+      .then(() => {
+        taskIndex++;
+        completeCount++;
+        run(taskIndex, data, hash);
+      })
+      .catch((err) => {
+        throw new Error("task失败：" + err);
+      });
+  } catch (error) {
+    logger("捕获错误！" + error);
+    completeCount++;
+    taskIndex++;
+    run(taskIndex, data, hash);
+  }
+};
+
+const queue = (index, jsonData, hash, type) => {
+  const rest = jsonData.length - index;
+  const count = queueCount > rest ? rest : queueCount;
+  const queueList = [];
+  completeCount = index;
+
+  for (let i = 0; i < count; i++) {
+    queueList.push(run(i + index, jsonData, hash, type));
+  }
+
+  taskIndex += count - 1;
+  return Promise.all(queueList);
+};
+
+//yunxing cuowu wenjian
+const runErrorList = (index, hash, parentHash) => {
+  const fileHash = parentHash || hash;
+  const errorExcelPath = path.join(workDir, `error${fileHash}.xlsx`);
+
+  if (retryError > 5) {
+    console.log("出现无法解析的错误");
+    return false;
+  }
+
+  taskIndex = index;
+  let taskHash = hash;
+  //新的运行任务-重新赋予新的任务id
+  if (index === 0) {
+    taskHash = generateUniqueHash().slice(0, 8);
+  }
+
+  if (isExist(errorExcelPath)) {
+    retryError++;
+
+    logger("开始运行错误列表");
+    jsonData = readExcel(errorExcelPath); //   数据来源于error excel
+    queue(index, jsonData, taskHash, fileHash);
+    return true;
+  }
+  return false;
+};
+
+const main = () => {
+  //当前任务hash
+  let hash = "";
+  let jsonData = [];
+  logger("》》》》》》》》》》视频批量任务任务开始《《《《《《《《《《" + hash);
+  logger("当前目录： " + workDir + "；工作目录： " + exeDir);
+
+  // 读取success.txt，判断是否是 异常中断，
+  // 并根据success日志获取最后一行的hash，找到对应的error_hash_excel
+
+  const successPath = path.join(workDir, "success.txt");
+  if (isExist(successPath)) {
+    const { loghash, lastItemIndex, fileName, parentHash } =
+      readTxt(successPath);
+
+    hash = loghash;
+    taskIndex = parseInt(lastItemIndex) + 1; // lastItemIndex为最后一项，所有要+1
+
+    //当前任务已经结束
+    if (fileName === "done") {
+      //找寻是否存在未上传的错误文件列表
+      const status = runErrorList(0, hash);
+      if (!status) {
+        logger(
+          "》》》》》》》》》》音频批量任务任务结束《《《《《《《《《《" + hash
+        );
+      }
+    } else {
+      //当前任务异常中断
+
+      //中断的任务类型为错误任务
+      if (parentHash) {
+        runErrorList(taskIndex, hash, parentHash);
+      } else {
+        jsonData = readExcel(excelDir);
+        queue(taskIndex, jsonData, hash);
+      }
+    }
+  } else {
+    hash = generateUniqueHash().slice(0, 8);
+    logger("成功日志不存在，开始新任务");
+
+    jsonData = readExcel(excelDir);
+    queue(taskIndex, jsonData, hash);
+  }
+};
+
+main();

package/utils/logger.js

@@ -17,11 +17,15 @@ const logger = (log) => {
  * 成功日志
  * @param {*}  日志内容 hash index fileName
  */
-const successLogger = (hash, index, fileName) => {
+const successLogger = (hash, index, fileName, type = "") => {
   console.log(fileName);
-  fs.writeFileSync("success.txt", hash + " " + index + " " + fileName + "\n", {
-    flag: "a",
-  });
+  fs.writeFileSync(
+    "success.txt",
+    hash + " " + index + " " + fileName + " " + type + "\n",
+    {
+      flag: "a",
+    }
+  );
 };
 
 //错误日志- xlsx

package/utils/settleFiles.js

@@ -86,9 +86,8 @@ function readTxt(path) {
 
     const lastItem = filteredArray[filteredArray.length - 1];
 
-    const loghash = lastItem.split(" ")[0];
-    const lastItemIndex = parseInt(lastItem.split(" ")[1]);
-    return { loghash, lastItemIndex };
+    const [loghash, lastItemIndex, fileName, parentHash] = lastItem.split(" ");
+    return { loghash, lastItemIndex, fileName, parentHash };
   } catch (error) {
     console.error("readErrorTxt函数出错：", error);
     return {};