LaiTool V3.0.3

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "laitool",
-  "version": "3.0.2",
+  "version": "3.0.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "laitool",
-      "version": "3.0.2",
+      "version": "3.0.3",
       "hasInstallScript": true,
       "dependencies": {
         "@alicloud/alimt20181012": "^1.2.0",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "laitool",
-  "version": "3.0.2",
+  "version": "3.0.3",
   "description": "An AI tool for image processing, video processing, and other functions.",
   "main": "./out/main/index.js",
   "author": "laitool.cn",

src/define/db/service/Book/bookTaskDetailService.ts

@@ -294,4 +294,24 @@ export class BookTaskDetailService extends BaseRealmService {
       }
     })
   }
+
+  /**
+   * 删除MJ中生成图片的所有的信息，包括 outImagePath subImagePath mjMessage (mjMessage是另一张表，要单独生成)
+   * @param bookTaskDetailId 
+   */
+  DeleteBoookTaskDetailGenerateImage(bookTaskDetailId: string): void {
+    this.transaction(() => {
+      let bookTaskDetail = this.realm.objectForPrimaryKey<BookTaskDetailModel>('BookTaskDetail', bookTaskDetailId)
+      if (bookTaskDetail == null) {
+        throw new Error("没有找到要删除的分镜信息")
+      }
+      if (bookTaskDetail.mjMessage) {
+        this.realm.delete(bookTaskDetail.mjMessage)
+      }
+      bookTaskDetail.mjMessage = undefined
+      bookTaskDetail.outImagePath = undefined;
+      bookTaskDetail.subImagePath = []
+    })
+
+  }
 }

src/define/define_string.ts

@@ -236,6 +236,10 @@ export const DEFINE_STRING = {
     MERGE_PROMPT: "MERGE_PROMPT",
     RESET_BOOK_DATA: "RESET_BOOK_DATA",
     DELETE_BOOK_DATA: "DELETE_BOOK_DATA",
+    CLEAR_IMPORT_WORD: "CLEAR_IMPORT_WORD",
+    RESET_GPT_REVERSE_DATA: "RESET_GPT_REVERSE_DATA",
+    REMOVE_MERGE_PROMPT_DATA: "REMOVE_MERGE_PROMPT_DATA",
+    REMOVE_GENERATE_IMAGE: 'REMOVE_GENERATE_IMAGE',
 
     COMPUTE_STORYBOARD: 'COMPUTE_STORYBOARD',
 
@@ -253,7 +257,6 @@ export const DEFINE_STRING = {
     SPLI_TAUDIO_RETURN: 'SPLI_TAUDIO_RETURN',
 
     ADD_REVERSE_PROMPT: 'ADD_REVERSE_PROMPT',
-    REMOVE_REVERSE_DATA: 'REMOVE_REVERSE_DATA'
   },
   SYSTEM: {
     OPEN_FILE: 'OPEN_FILE',

src/main/IPCEvent/bookIpc.ts

@@ -12,6 +12,7 @@ import { BookVideo } from '../Service/Book/bookVideo'
 import { Watermark } from '../Service/watermark'
 import { SubtitleService } from '../Service/Subtitle/subtitleService'
 import { BookFrame } from '../Service/Book/bookFrame'
+import { BookPrompt } from '../Service/Book/bookPrompt'
 let reverseBook = new ReverseBook()
 let basicReverse = new BasicReverse()
 let subtitle = new Subtitle()
@@ -24,6 +25,7 @@ let bookVideo = new BookVideo()
 let watermark = new Watermark()
 let subtitleService = new SubtitleService()
 let bookFrame = new BookFrame()
+let bookPrompt = new BookPrompt();
 
 export function BookIpc() {
   // 获取样式图片的子列表
@@ -112,10 +114,28 @@ export function BookIpc() {
   // 合并提示词
   ipcMain.handle(DEFINE_STRING.BOOK.MERGE_PROMPT, async (event, id, type, operateBookType) => await reverseBook.MergePrompt(id, type, operateBookType))
 
+  // 将反推出来的提示词写入到GPT提示词里面
+  ipcMain.handle(
+    DEFINE_STRING.BOOK.REVERSE_PROMPT_TO_GPT_PROMPT,
+    async (event, bookId, bookTaskId, index) =>
+      await bookPrompt.ReversePromptToGptPrompt(bookId, bookTaskId, index)
+  )
+
+  // 删除所有的反推出来的提示词
+  ipcMain.handle(
+    DEFINE_STRING.BOOK.RESET_GPT_REVERSE_DATA,
+    async (event, id, operateBookType, type) => await bookPrompt.ResetGptReverseData(id, operateBookType, type)
+  )
+
+  // 删除所有的合并提示词
+  ipcMain.handle(
+    DEFINE_STRING.BOOK.REMOVE_MERGE_PROMPT_DATA,
+    async (event, id, operateBookType) => await bookPrompt.RemoveMergePromptData(id, operateBookType)
+  )
+
   //#endregion
 
-  //#region  一键反推的单个任务
+  //#region 文案相关
-
 
   // 开始执行获取小说文案的方法
   ipcMain.handle(
@@ -129,6 +149,15 @@ export function BookIpc() {
     async (event, bookTaskId) => await subtitleService.ExportCopywriting(bookTaskId)
   )
 
+  // 清除导入对齐的文案
+  ipcMain.handle(DEFINE_STRING.BOOK.CLEAR_IMPORT_WORD, async (event, bookTaskId) => await subtitleService.ClearImportWord(bookTaskId))
+
+  //#endregion
+
+  //#region  一键反推的单个任务
+
+
+
   // 执行去除水印
   ipcMain.handle(
     DEFINE_STRING.BOOK.REMOVE_WATERMARK,
@@ -142,13 +171,6 @@ export function BookIpc() {
       await reverseBook.AddReversePrompt(bookTaskDetailIds, operateBookType, type)
   )
 
-  // 将反推出来的提示词写入到GPT提示词里面
-  ipcMain.handle(
-    DEFINE_STRING.BOOK.REVERSE_PROMPT_TO_GPT_PROMPT,
-    async (event, bookId, bookTaskId, index) =>
-      await mjOpt.ReversePromptToGptPrompt(bookId, bookTaskId, index)
-  )
-
   // 重选单个反推提示词到输出种
   ipcMain.handle(
     DEFINE_STRING.BOOK.SINGLE_REVERSE_TO_GPT_PROMPT,
@@ -156,13 +178,10 @@ export function BookIpc() {
       await mjOpt.SingleReverseToGptPrompt(bookTaskDetailId, index)
   )
 
-  // 删除所有的反推出来的提示词
-  ipcMain.handle(
-    DEFINE_STRING.BOOK.REMOVE_REVERSE_DATA,
-    async (event, bookTaskDetailIds) => await reverseBook.RemoveReverseData(bookTaskDetailIds)
-  )
-
   //#endregion
+
+  //#region 图片相关
+
   // 对指定的小说任务的图片进行锁定和解锁
   ipcMain.handle(
     DEFINE_STRING.BOOK.IMAGE_LOCK_OPERATION,
@@ -177,6 +196,35 @@ export function BookIpc() {
       await bookImage.DownloadImageUrlAndSplit(bookTaskDetailId, imageUrl)
   )
 
+  // 一键生成当前批次的所有图片
+  ipcMain.handle(
+    DEFINE_STRING.BOOK.GENERATE_IMAGE_ALL,
+    async (event, bookTaskId, imageCategory) =>
+      await bookImage.GenerateImageAll(bookTaskId, imageCategory)
+  )
+
+  // 高清图片前检查，主要是检查图片大小
+  ipcMain.handle(
+    DEFINE_STRING.BOOK.CHECK_IMAGE_FILE_SIZE,
+    async (event, id, fileSize, operateBookType) =>
+      await bookImage.CheckImageFileSize(id, fileSize, operateBookType)
+  )
+
+  // 开始执行高清图片
+  ipcMain.handle(
+    DEFINE_STRING.BOOK.HD_IMAGE,
+    async (event, id, scale, operateBookType) => await bookImage.HDImage(id, scale, operateBookType)
+  )
+
+  // 删除所有的生成图片
+  ipcMain.handle(
+    DEFINE_STRING.BOOK.REMOVE_GENERATE_IMAGE,
+    async (event, id, operateBookType) => await bookImage.ResetGenerateImage(id, operateBookType)
+  )
+
+  //#endregion
+
+
   // 一拆四，将一个任务拆分成四个任务，并且复制对应的图片
   ipcMain.handle(
     DEFINE_STRING.BOOK.ONE_TO_FOUR_BOOK_TASK,
@@ -207,25 +255,6 @@ export function BookIpc() {
     async (event, bookTaskId) => await bookTask.DeleteBookTask(bookTaskId)
   )
 
-  // 一键生成当前批次的所有图片
-  ipcMain.handle(
-    DEFINE_STRING.BOOK.GENERATE_IMAGE_ALL,
-    async (event, bookTaskId, imageCategory) =>
-      await bookImage.GenerateImageAll(bookTaskId, imageCategory)
-  )
-
-  // 高清图片前检查，主要是检查图片大小
-  ipcMain.handle(
-    DEFINE_STRING.BOOK.CHECK_IMAGE_FILE_SIZE,
-    async (event, id, fileSize, operateBookType) =>
-      await bookImage.CheckImageFileSize(id, fileSize, operateBookType)
-  )
-
-  // 开始执行高清图片
-  ipcMain.handle(
-    DEFINE_STRING.BOOK.HD_IMAGE,
-    async (event, id, scale, operateBookType) => await bookImage.HDImage(id, scale, operateBookType)
-  )
 
   // 将小说视频相关的设置添加到小说任务批次
   ipcMain.handle(

src/main/Service/Book/ReverseBook.ts

@@ -400,29 +400,6 @@ export class ReverseBook {
       return errorMessage("单个反推失败，错误信息如下：" + error.message, "ReverseBook_SingleReversePrompt")
     }
   }
-
-  /**
-   * 删除指定的提示词数据
-   * @param bookTaskDetailIds 要删除的提示词ID 
-   */
-  async RemoveReverseData(bookTaskDetailIds: string[]) {
-    try {
-      // 开始删除
-      if (bookTaskDetailIds.length <= 0) {
-        throw new Error("没有传入要删除的数据")
-      }
-
-      for (let i = 0; i < bookTaskDetailIds.length; i++) {
-        const element = bookTaskDetailIds[i];
-        await this.bookServiceBasic.DeleteBookTaskDetailReversePromptById(element);
-      }
-
-      // 全部删除完毕
-      return successMessage(null, "删除反推数据成功", "ReverseBook_RemoveReverseData")
-    } catch (error) {
-      return errorMessage("删除反推数据失败，错误信息如下：" + error.message, "ReverseBook_RemoveReverseData")
-    }
-  }
   //#endregion
 
   //#region  提示词相关操作

src/main/Service/Book/bookImage.ts

@@ -1,9 +1,6 @@
 import { BookImageCategory, BookType, OperateBookType } from "../../../define/enum/bookEnum";
 import { GeneralResponse } from "../../../model/generalResponse";
 import { errorMessage, successMessage } from "../../Public/generalTools";
-import { BookTaskService } from "../../../define/db/service/Book/bookTaskService";
-import { BookTaskDetailService } from "../../../define/db/service/Book/bookTaskDetailService";
-import { BookService } from "../../../define/db/service/Book/bookService";
 import { Book } from "../../../model/book";
 import path from 'path'
 import { Tools } from "../../../main/tools"
@@ -14,6 +11,7 @@ import { MJOpt } from "../MJ/mj";
 import { isEmpty } from "lodash";
 import { DEFINE_STRING } from "../../../define/define_string";
 import { ResponseMessageType } from "../../../define/enum/softwareEnum";
+import { BookServiceBasic } from "../ServiceBasic/bookServiceBasic";
 import util from 'util'
 import { exec } from 'child_process'
 const execAsync = util.promisify(exec);
@@ -22,26 +20,13 @@ const execAsync = util.promisify(exec);
  * 小说图片执行的相关操作
  */
 export class BookImage {
-  bookTaskService: BookTaskService
+  bookServiceBasic: BookServiceBasic
-  bookTaskDetailService: BookTaskDetailService
-  bookService: BookService
   tools: Tools;
   mjOpt: MJOpt;
   constructor() {
     this.tools = new Tools()
     this.mjOpt = new MJOpt()
-  }
+    this.bookServiceBasic = new BookServiceBasic()
-
-  async InitService() {
-    if (!this.bookTaskService) {
-      this.bookTaskService = await BookTaskService.getInstance();
-    }
-    if (!this.bookTaskDetailService) {
-      this.bookTaskDetailService = await BookTaskDetailService.getInstance();
-    }
-    if (!this.bookService) {
-      this.bookService = await BookService.getInstance();
-    }
   }
 
   /**
@@ -52,6 +37,50 @@ export class BookImage {
     global.newWindow[0].win.webContents.send(message_name, data)
   }
 
+  //#region 删除生成的图片
+
+  /**
+   * 删除所有的图片数据（只删除数据库中的，不删除本地文件）
+   * @param id 
+   * @param operateBookType 
+   */
+  async ResetGenerateImage(id: string, operateBookType: OperateBookType): Promise<GeneralResponse.SuccessItem | GeneralResponse.ErrorItem> {
+    try {
+      let bookTaskDetails = undefined as Book.SelectBookTaskDetail[]
+      let bookTask = undefined as Book.SelectBookTask
+      if (operateBookType == OperateBookType.BOOKTASK) {
+        bookTaskDetails = await this.bookServiceBasic.GetBookTaskDetailData({
+          bookTaskId: id
+        })
+        bookTask = await this.bookServiceBasic.GetBookTaskDataById(id)
+      } else {
+        throw new Error('不支持的操作类型，请检查')
+      }
+      if (bookTaskDetails.length <= 0) {
+        throw new Error('没有要删除的分镜数据，请检查')
+      }
+
+
+      // 开始删除数据，要删除图片数据和出图的信息
+      for (let i = 0; i < bookTaskDetails.length; i++) {
+        const element = bookTaskDetails[i];
+        if (bookTask.imageCategory == BookImageCategory.MJ) {
+          await this.bookServiceBasic.DeleteBoookTaskDetailGenerateImage(element.id);
+        } else if (bookTask.imageCategory == BookImageCategory.D3) {
+          throw new Error('暂时不支持D3生成的图片删除')
+        } else if (bookTask.imageCategory == BookImageCategory.SD) {
+          throw new Error('暂时不支持SD生成的图片删除')
+        } else {
+          throw new Error('未知的小说类型，请检查')
+        }
+      }
+      return successMessage(bookTask.imageCategory, "删除所有的生图数据成功", "BookImage_ResetGenerateImage")
+    } catch (error) {
+      return errorMessage("删除所有的图片数据失败，失败信息如下：" + error.toString(), "BookImage_ResetGenerateImage")
+    }
+  }
+  //#endregion
+
   /**
    * 开始高清图片，当前默认是四倍，后续可以调整
    * @param id 要高清操作的ID
@@ -60,21 +89,20 @@ export class BookImage {
    */
   async HDImage(id: string, scale: number, operateBookType: OperateBookType): Promise<GeneralResponse.ErrorItem | GeneralResponse.SuccessItem> {
     try {
-      await this.InitService()
       if (scale <= 0 || scale > 4) {
         throw new Error('高清倍率只能是2，3，4')
       }
       let bookTasks = undefined as Book.SelectBookTask[]
       if (operateBookType == OperateBookType.BOOK) {
         // 获取所有的小说批次任务
-        bookTasks = this.bookTaskService.GetBookTaskData({
+        bookTasks = (await this.bookServiceBasic.GetBookTaskData({
           bookId: id
-        }).data.bookTasks
+        })).bookTasks
       } else if (operateBookType == OperateBookType.BOOKTASK) {
         // 获取当前的小说批次任务
-        bookTasks = this.bookTaskService.GetBookTaskData({
+        bookTasks = (await this.bookServiceBasic.GetBookTaskData({
           id: id
-        }).data.bookTasks
+        })).bookTasks
       } else {
         throw new Error("不支持的操作类型，请检查")
       }
@@ -155,18 +183,17 @@ export class BookImage {
    */
   async CheckImageFileSize(id: string, fileSize: number, operateBookType: OperateBookType) {
     try {
-      await this.InitService()
       let bookTasks = undefined as Book.SelectBookTask[]
       if (operateBookType == OperateBookType.BOOK) {
         // 获取所有的小说批次任务
-        bookTasks = this.bookTaskService.GetBookTaskData({
+        bookTasks = (await this.bookServiceBasic.GetBookTaskData({
           bookId: id
-        }).data.bookTasks
+        })).bookTasks
       } else if (operateBookType == OperateBookType.BOOKTASK) {
         // 获取当前的小说批次任务
-        bookTasks = this.bookTaskService.GetBookTaskData({
+        bookTasks = (await this.bookServiceBasic.GetBookTaskData({
           id: id
-        }).data.bookTasks
+        })).bookTasks
       } else {
         throw new Error("不支持的操作类型，请检查")
       }
@@ -177,9 +204,9 @@ export class BookImage {
       let result = []
       for (let i = 0; i < bookTasks.length; i++) {
         const element = bookTasks[i];
-        let bookTaskDetail = this.bookTaskDetailService.GetBookTaskData({
+        let bookTaskDetail = await this.bookServiceBasic.GetBookTaskDetailData({
           bookTaskId: element.id
-        }).data
+        })
         for (let i = 0; i < bookTaskDetail.length; i++) {
           const item = bookTaskDetail[i];
           if (isEmpty(item.outImagePath)) {
@@ -209,7 +236,6 @@ export class BookImage {
   async GenerateImageAll(bookTaskId: string, imageCategory: BookImageCategory): Promise<GeneralResponse.ErrorItem | GeneralResponse.SuccessItem> {
     try {
       console.log('开始生成所有的图片', bookTaskId)
-      await this.InitService()
       let res = undefined as GeneralResponse.ErrorItem | GeneralResponse.SuccessItem
       switch (imageCategory) {
         case BookImageCategory.SD:
@@ -236,14 +262,14 @@ export class BookImage {
    */
   async ImageLockOperation(id: string, type: string, operateBookType: OperateBookType): Promise<GeneralResponse.ErrorItem | GeneralResponse.SuccessItem> {
     try {
-      await this.InitService()
       let bookTaskDetail = undefined as Book.SelectBookTaskDetail[]
       if (operateBookType == OperateBookType.BOOKTASK) {
-        bookTaskDetail = this.bookTaskDetailService.GetBookTaskData({
+        bookTaskDetail = await this.bookServiceBasic.GetBookTaskDetailData({
           bookTaskId: id
-        }).data
+        })
       } else if (operateBookType == OperateBookType.BOOKTASKDETAIL) {
-        bookTaskDetail = [this.bookTaskDetailService.GetBookTaskDetailDataById(id)];
+        let tempBookTaskDetail = await this.bookServiceBasic.GetBookTaskDetailDataById(id);
+        bookTaskDetail = [tempBookTaskDetail];
       }
       else {
         throw new Error('操作的对象类型不正确')
@@ -263,7 +289,7 @@ export class BookImage {
       for (let i = 0; i < bookTaskDetail.length; i++) {
         const element = bookTaskDetail[i];
         let lock = type == "lock" ? true : false
-        this.bookTaskDetailService.UpdateBookTaskDetail(element.id, {
+        await this.bookServiceBasic.UpdateBookTaskDetail(element.id, {
           imageLock: lock
         })
 
@@ -287,16 +313,15 @@ export class BookImage {
    */
   async DownloadImageUrlAndSplit(bookTaskDetailId: string, imageUrl: string,) {
     try {
-      await this.InitService();
+      let bookTaskDetail = await this.bookServiceBasic.GetBookTaskDetailDataById(bookTaskDetailId)
-      let bookTaskDetail = this.bookTaskDetailService.GetBookTaskDetailDataById(bookTaskDetailId)
       if (bookTaskDetail == null) {
         throw new Error('获取到的数据分镜为空，无法执行操作')
       }
-      let book = this.bookService.GetBookDataById(bookTaskDetail.bookId)
+      let book = await this.bookServiceBasic.GetBookDataById(bookTaskDetail.bookId)
       if (book == null) {
         throw new Error('获取到的小说为空，无法执行操作')
       }
-      let bookTask = this.bookTaskService.GetBookTaskDataById(bookTaskDetail.bookTaskId)
+      let bookTask = await this.bookServiceBasic.GetBookTaskDataById(bookTaskDetail.bookTaskId)
       if (bookTask == null) {
         throw new Error('获取到的任务为空，无法执行操作')
       }
@@ -327,7 +352,7 @@ export class BookImage {
       await CopyFileOrFolder(firstImage, out_file);
 
       // 修改分镜的数据
-      this.bookTaskDetailService.UpdateBookTaskDetail(bookTaskDetailId, {
+      await this.bookServiceBasic.UpdateBookTaskDetail(bookTaskDetailId, {
         outImagePath: path.relative(define.project_path, out_file),
         subImagePath: imageRes.map((item) => path.relative(define.project_path, item))
       })

src/main/Service/Book/bookPrompt.ts

@@ -0,0 +1,153 @@
+import { isEmpty } from "lodash";
+import { BookType, OperateBookType } from "../../../define/enum/bookEnum";
+import { Book } from "../../../model/book";
+import { GeneralResponse } from "../../../model/generalResponse";
+import { errorMessage, successMessage } from "../../Public/generalTools";
+import { BookServiceBasic } from "../ServiceBasic/bookServiceBasic";
+
+export class BookPrompt {
+  bookServiceBasic: BookServiceBasic
+  constructor() {
+    this.bookServiceBasic = new BookServiceBasic()
+  }
+
+  /**
+   * 将MJ反推出来的数据，选择指定的写入到GPT提示词中
+   * @param bookId  小说的ID
+   * @param bookTaskId 小说的任务ID
+   * @param index  反推的数据的索引
+   * @returns 
+   */
+  async ReversePromptToGptPrompt(bookId: string, bookTaskId: string, index: number): Promise<GeneralResponse.ErrorItem | GeneralResponse.SuccessItem> {
+    try {
+      let bookTaskDetails = await this.bookServiceBasic.GetBookTaskDetailData({
+        bookId: bookId,
+        bookTaskId: bookTaskId
+      })
+
+      if (bookTaskDetails.length <= 0) {
+        throw new Error("没有找到对应的分镜数据")
+      }
+      let emptyName = []
+
+      // 开始修改数据
+      for (let i = 0; i < bookTaskDetails.length; i++) {
+        const element = bookTaskDetails[i];
+        let reversePrompts = element.reversePrompt
+        // 没有反推提示词跳过
+        if (!reversePrompts || reversePrompts.length <= 0) {
+          emptyName.push(element.name)
+          continue;
+        }
+        let reversePrompt = reversePrompts[index - 1] 
+        let gptPrompt = undefined
+        if (!isEmpty(reversePrompt.promptCN) && reversePrompt.promptCN != "") {
+          gptPrompt = reversePrompt.promptCN
+        }
+        if (!gptPrompt) {
+          gptPrompt = reversePrompt.prompt
+        }
+        // 开始修改
+        await this.bookServiceBasic.UpdateBookTaskDetail(element.id, {
+          gptPrompt: gptPrompt
+        })
+      }
+      // 全部修改完毕，将修改后的数据返回
+      let res = await this.bookServiceBasic.GetBookTaskDetailData({
+        bookTaskId: bookTaskId
+      });
+      let returnString = '选择的反推提示词数据写出成功'
+      if (emptyName.length > 0) {
+        returnString = '选择的反推提示词数据写出成功，但是以下分镜没有反推提示词：' + emptyName.join('，')
+      }
+      return successMessage(res, returnString, "ReverseBook_ReversePromptToGptPrompt")
+    } catch (error) {
+      return errorMessage("反推数据写出失败，错误信息如下：" + error.message, "ReverseBook_ReversePromptToGptPrompt")
+    }
+  }
+
+  /**
+   * 删除所有的提示词数据（反推和推理的）
+   * @param id 操作的ID
+   * @param operateBookType 操作的类型（小说批次任务还是小说分镜数据）
+   * @param type 类型
+   * @returns 
+   */
+  async ResetGptReverseData(id: string, operateBookType: OperateBookType, type: BookType): Promise<GeneralResponse.ErrorItem | GeneralResponse.SuccessItem> {
+    try {
+      console.log(id, operateBookType, type)
+      let bookTask = undefined as Book.SelectBookTask
+      let bookTaskDetails = undefined as Book.SelectBookTaskDetail[]
+      if (operateBookType == OperateBookType.BOOKTASK) {
+        bookTask = await this.bookServiceBasic.GetBookTaskDataById(id)
+        bookTaskDetails = await this.bookServiceBasic.GetBookTaskDetailData({
+          bookTaskId: id
+        })
+      } else if (operateBookType == OperateBookType.BOOKTASKDETAIL) {
+        let bookTaskDetail = await this.bookServiceBasic.GetBookTaskDetailDataById(id)
+        bookTaskDetails = [bookTaskDetail]
+      }
+      else {
+        throw new Error('未知的操作类型，请检查');
+      }
+      if (bookTaskDetails.length <= 0) {
+        throw new Error("没有传入要删除的数据")
+      }
+
+      // 开始执行不同的删除逻辑
+      if (type == BookType.MJ_REVERSE) {
+        // MJ 反推
+        for (let i = 0; i < bookTaskDetails.length; i++) {
+          const element = bookTaskDetails[i];
+          await this.bookServiceBasic.DeleteBookTaskDetailReversePromptById(element.id);
+        }
+      } else if (type == BookType.ORIGINAL) {
+        throw new Error("原创小说删除还不支持")
+      } else if (type == BookType.SD_REVERSE) { }
+      else {
+        throw new Error("SD反推删除还不支持")
+      }
+
+      // 全部删除完毕
+      return successMessage(null, "重置反推/GPT数据成功", "ReverseBook_ResetGptReverseData")
+    } catch (error) {
+      return errorMessage("删除反推数据失败，错误信息如下：" + error.message, "ReverseBook_ResetGptReverseData")
+    }
+  }
+
+  /**
+   * 删除指定小说批次数据的合并提示词数据
+   * @param id 要操作的ID
+   * @param operateBookType 操作的类型
+   * @returns 
+   */
+  async RemoveMergePromptData(id: string, operateBookType: OperateBookType): Promise<GeneralResponse.ErrorItem | GeneralResponse.SuccessItem> {
+    try {
+      let bookTaskDetails = undefined as Book.SelectBookTaskDetail[]
+      if (operateBookType == OperateBookType.BOOKTASK) {
+        bookTaskDetails = await this.bookServiceBasic.GetBookTaskDetailData({
+          bookTaskId: id
+        })
+      } else {
+        throw new Error('未知的操作类型，请检查');
+      }
+
+      if (bookTaskDetails.length <= 0) {
+        throw new Error("没有传入要删除的分镜数据")
+      }
+
+      // 开始删除合并提示词数据
+      for (let i = 0; i < bookTaskDetails.length; i++) {
+        const element = bookTaskDetails[i];
+        await this.bookServiceBasic.UpdateBookTaskDetail(element.id, {
+          prompt: undefined
+        })
+      }
+      return successMessage(null, "删除所有的合并提示词数据成功", "ReverseBook_RemoveMergePromptData")
+    } catch (error) {
+      return errorMessage("删除合并提示词数据失败，错误信息如下：" + error.message, "ReverseBook_RemoveMergePromptData")
+    }
+  }
+
+
+}

src/main/Service/MJ/mj.ts

@@ -81,53 +81,6 @@ export class MJOpt {
 
   //#region 选择反推的提示词相关
 
-  /**
-   * 将MJ反推出来的数据，选择指定的写入到GPT提示词中
-   * @param bookId  小说的ID
-   * @param bookTaskId 小说的任务ID
-   * @param index  反推的数据的索引
-   * @returns 
-   */
-  async ReversePromptToGptPrompt(bookId: string, bookTaskId: string, index: number): Promise<GeneralResponse.ErrorItem | GeneralResponse.SuccessItem> {
-    try {
-      await this.InitService();
-      let bookTaskDetails = this.bookTaskDetail.GetBookTaskData({
-        bookId: bookId,
-        bookTaskId: bookTaskId
-      }).data as Book.SelectBookTaskDetail[]
-
-      if (bookTaskDetails.length <= 0) {
-        throw new Error("没有找到对应的分镜数据")
-      }
-
-      // 开始修改数据
-      for (let i = 0; i < bookTaskDetails.length; i++) {
-        const element = bookTaskDetails[i];
-        let reversePrompts = element.reversePrompt
-        let reversePrompt = reversePrompts[index - 1]
-        let gptPrompt = undefined
-        if (!isEmpty(reversePrompt.promptCN) && reversePrompt.promptCN != "") {
-          gptPrompt = reversePrompt.promptCN
-        }
-        if (!gptPrompt) {
-          gptPrompt = reversePrompt.prompt
-        }
-        // 开始修改
-        this.bookTaskDetail.UpdateBookTaskDetail(element.id, {
-          gptPrompt: gptPrompt
-        })
-      }
-      // 全部修改完毕，将修改后的数据返回
-      let res = await this.reverseBook.GetBookTaskDetail(bookTaskId);
-      if (res.code == 0) {
-        throw new Error(res.message)
-      }
-      return successMessage(res.data, "反推数据写出成功", "ReverseBook_ReversePromptToGptPrompt")
-    } catch (error) {
-      return errorMessage("反推数据写出失败，错误信息如下：" + error.message, "ReverseBook_ReversePromptToGptPrompt")
-    }
-  }
-
   /**
    * MJ反推，将反推的数据写入到GPT中
    * @param bookTaskDetailId 
@@ -356,7 +309,7 @@ export class MJOpt {
           }
         }
         if (emptyName.length > 0) {
-          throw new Error("有空的提示词，请先推理")
+          throw new Error(`${emptyName.join('，')} 的提示词为空，请先推理`)
         }
       } else if (operateBookType == OperateBookType.BOOKTASKDETAIL) {
         let tempBookTaskDetail = await this.bookServiceBasic.GetBookTaskDetailDataById(id);

src/main/Service/SD/sd.ts

@@ -61,7 +61,7 @@ export class SDOpt {
           }
         }
         if (emptyName.length > 0) {
-          throw new Error("有空的提示词，请先推理")
+          throw new Error(`${emptyName.join('，')} 的提示词为空，请先推理`)
         }
       } else if (operateBookType == OperateBookType.BOOKTASKDETAIL) {
         let tempBookTaskDetail = await this.bookServiceBasic.GetBookTaskDetailDataById(id);

src/main/Service/ServiceBasic/bookServiceBasic.ts

@@ -88,7 +88,7 @@ export class BookServiceBasic {
    * @param bookTaskId 小说批次任务ID
    * @returns 
    */
-  async GetBookTaskDataId(bookTaskId: string): Promise<Book.SelectBookTask> {
+  async GetBookTaskDataById(bookTaskId: string): Promise<Book.SelectBookTask> {
     await this.InitService();
     let bookTask = this.bookTaskService.GetBookTaskDataById(bookTaskId);
     if (bookTask == null) {
@@ -195,6 +195,15 @@ export class BookServiceBasic {
     this.bookTaskDetailService.DeleteBookTaskDetailReversePromptById(bookTaskDetailId)
   }
 
+  /**
+   * 删除指定的小说分镜生成的图片
+   * @param bookTaskDetailId 
+   */
+  async DeleteBoookTaskDetailGenerateImage(bookTaskDetailId: string): Promise<void> {
+    await this.InitService()
+    this.bookTaskDetailService.DeleteBoookTaskDetailGenerateImage(bookTaskDetailId);
+  }
+
   //#endregion
 
   //#region 小说后台任务相关操作

src/main/Service/Subtitle/subtitleService.ts

@@ -14,6 +14,7 @@ import { Subtitle } from "./subtitle";
 import { TaskScheduler } from "../taskScheduler";
 import { OperateBookType } from "../../../define/enum/bookEnum";
 import { Book } from "../../../model/book";
+import { TimeStringToMilliseconds } from "../../../define/Tools/time";
 
 export class SubtitleService {
   softWareServiceBasic: SoftWareServiceBasic
@@ -197,7 +198,7 @@ export class SubtitleService {
    */
   async ExportCopywriting(bookTaskId: string): Promise<GeneralResponse.ErrorItem | GeneralResponse.SuccessItem> {
     try {
-      let bookTask = await this.bookServiceBasic.GetBookTaskDataId(bookTaskId)
+      let bookTask = await this.bookServiceBasic.GetBookTaskDataById(bookTaskId)
       let book = await this.bookServiceBasic.GetBookDataById(bookTask.bookId)
       let bookTaskDetails = await this.bookServiceBasic.GetBookTaskDetailData({
         bookId: book.id,
@@ -228,8 +229,64 @@ export class SubtitleService {
     } catch (error) {
       return errorMessage("导出文案失败，失败信息如下：" + error.message, 'ReverseBook_ExportCopywriting')
     }
+  }
 
+  //#region  文案相关的操作
+
+  /**
+   * 清除导入的对齐后的文案
+   * @param bookTaskId 小说批次任务ID
+   */
+  async ClearImportWord(bookTaskId: string): Promise<GeneralResponse.ErrorItem | GeneralResponse.SuccessItem> {
+    try {
+      let bookTaskDetails = await this.bookServiceBasic.GetBookTaskDetailData({
+        bookTaskId: bookTaskId
+      })
+      if (bookTaskDetails.length <= 0) {
+        throw new Error("没有找到对应小说批次任务的的分镜数据")
+      }
+      let book = await this.bookServiceBasic.GetBookDataById(bookTaskDetails[0].bookId)
+      let originalTimePath = path.join(book.bookFolderPath, `data/${book.id}.mp4.json`);
+      let originalTime = [] as any[];
+      if (await CheckFileOrDirExist(originalTimePath)) {
+        let originalTimeString = await fs.promises.readFile(originalTimePath, 'utf-8');
+        if (ValidateJson(originalTimeString)) {
+          originalTime = JSON.parse(originalTimeString)
+        }
+      }
+      // 判断分镜数据和批次数据是不是相同的
+      if (originalTime.length != bookTaskDetails.length) {
+        originalTime = []
+      }
+
+      // 开始删除，需要做的操作，删除 bookTaskDetail 众的subValue 数据，将时间数据复原
+      for (let i = 0; i < bookTaskDetails.length; i++) {
+        const element = bookTaskDetails[i];
+        let updateObj = {
+          subValue: undefined
+        } as Book.SelectBookTaskDetail
+
+        // 开始重置时间
+        if (originalTime[i]) {
+          let startTime = TimeStringToMilliseconds(originalTime[i][0])
+          let endTime = TimeStringToMilliseconds(originalTime[i][1])
+          updateObj.startTime = startTime;
+          updateObj.endTime = endTime;
+          updateObj.timeLimit = undefined
+        }
+        await this.bookServiceBasic.UpdateBookTaskDetail(element.id, updateObj);
+      }
+      let returnBookTaskDetail = await this.bookServiceBasic.GetBookTaskDetailData({
+        bookTaskId: bookTaskId
+      })
+      // 成功
+      return successMessage(returnBookTaskDetail, "重置导入文案对齐数据成功", "ReverseBook_ClearImportWord")
+    } catch (error) {
+      return errorMessage("清除导入的文案失败，失败信息如下：" + error.message, 'ReverseBook_ClearImportWord')
+    }
   }
 
   //#endregion
+
+  //#endregion
 }

src/preload/book.js

@@ -85,6 +85,10 @@ const book = {
   ExportCopywriting: async (bookTaskId) =>
     await ipcRenderer.invoke(DEFINE_STRING.BOOK.EXPORT_COPYWRITING, bookTaskId),
 
+  // 清除导入对齐的文案
+  ClearImportWord: async (bookTaskId) =>
+    await ipcRenderer.invoke(DEFINE_STRING.BOOK.CLEAR_IMPORT_WORD, bookTaskId),
+
   //#endregion
 
   //#region 水印
@@ -130,9 +134,18 @@ const book = {
       index
     ),
 
-  // 删除掉所有的反推数据
+  // 删除掉所有的反推和GPT提示词数据
-  RemoveReverseData: async (bookTaskDetailIds) =>
+  ResetGptReverseData: async (id, operateBookType, type) =>
-    await ipcRenderer.invoke(DEFINE_STRING.BOOK.REMOVE_REVERSE_DATA, bookTaskDetailIds),
+    await ipcRenderer.invoke(DEFINE_STRING.BOOK.RESET_GPT_REVERSE_DATA, id, operateBookType, type),
+
+  // 删除所有的合并提示词数据
+  ResetMergePromptData: async (id, operateBookType) =>
+    await ipcRenderer.invoke(DEFINE_STRING.BOOK.REMOVE_MERGE_PROMPT_DATA, id, operateBookType),
+
+  // 删除所有的生成图片
+  ResetGenerateImage: async (id, operateBookType) =>
+    await ipcRenderer.invoke(DEFINE_STRING.BOOK.REMOVE_GENERATE_IMAGE, id, operateBookType),
+
   //#endregion
 
   // 将小说任务的所有的图片进行锁定和解锁

src/renderer/src/components/Book/Components/DatatableAfterGpt.vue

@@ -1,5 +1,5 @@
 <template>
-  <div v-if="show">
+  <div v-if="data.subValue && data.subValue.length != 0">
     <div v-for="(item, index) in data.subValue">
       <n-input
         v-model:value="item.srt_value"
@@ -34,11 +34,6 @@ export default defineComponent({
     let data = ref(props.initData)
     console.log('subValue', data.value)
     onMounted(async () => {})
-    let show = computed(() => {
-      debugger
-      return data.value.subValue && data.value.subValue.length > 0
-    })
-
     let InputDebounced = debounce(handleInput, 1000)
 
     async function handleInput() {
@@ -52,7 +47,7 @@ export default defineComponent({
       }
     }
 
-    return { data, InputDebounced, show }
+    return { data, InputDebounced }
   }
 })
 </script>

src/renderer/src/components/Book/Components/DatatableGptPromptButton.vue

@@ -85,7 +85,11 @@ export default defineComponent({
       debugger
       switch (key) {
         case 'remove_reverse': // 删除反推提示词
-          let res = await window.book.RemoveReverseData([data.value.id])
+          let res = await window.book.ResetGptReverseData(
+            data.value.id,
+            OperateBookType.BOOKTASKDETAIL,
+            reverseManageStore.selectBook.type
+          )
           if (res.code == 0) {
             message.error(res.message)
           } else {

src/renderer/src/components/Book/Components/DatatableHeaderPrompt.vue

@@ -119,11 +119,11 @@ export default defineComponent({
         type,
         OperateBookType.BOOKTASK
       )
+      softwareStore.spin.spinning = false
 
       // 这边对返回的数据进行处理
       if (res.code == 0) {
-        message.error(res.message)
+        window.api.showGlobalMessageDialog(res)
-        softwareStore.spin.spinning = false
         return
       }
       for (let i = 0; i < res.data.length; i++) {

src/renderer/src/components/Book/Components/ManageBookDetailButton.vue

@@ -1,20 +1,28 @@
 <template>
   <div style="display: flex; justify-content: space-between; align-items: center">
     <div style="display: flex; align-items: center">
-      <n-button strong secondary @click="RetuenMain"> 返回 </n-button>
+      <n-button strong secondary @click="RetuenMain" size="small"> 返回 </n-button>
-      <n-dropdown trigger="hover" :options="AutoOptions" @select="SelectAutoAction">
+      <!-- <n-dropdown trigger="hover" :options="AutoOptions" @select="SelectAutoAction">
         <n-button :color="softwareStore.SoftColor.ORANGE" @click="Start" style="margin-left: 5px">
           自动开始
         </n-button>
-      </n-dropdown>
+      </n-dropdown> -->
       <n-divider vertical style="height: 30px" />
       <n-dropdown trigger="hover" :options="frameOptions" @select="handleSelect">
-        <n-button :color="softwareStore.SoftColor.ORANGE" @click="ActionFrame"> 开始分镜 </n-button>
+        <n-button
+          :color="softwareStore.SoftColor.ORANGE"
+          class="top-button"
+          size="small"
+          @click="ActionFrame"
+        >
+          开始分镜
+        </n-button>
       </n-dropdown>
       <n-dropdown trigger="hover" :options="copywritingOptions" @select="handleSelect">
         <n-button
           :color="softwareStore.SoftColor.ORANGE"
           style="margin-left: 5px"
+          size="small"
           @click="GetCopywriting('all')"
         >
           开始提取全部文案
@@ -25,24 +33,28 @@
         <n-button
           :color="softwareStore.SoftColor.ORANGE"
           style="margin-left: 5px"
+          size="small"
           @click="RemoveWatermark"
         >
           开始去除水印
         </n-button>
       </n-dropdown>
-
+      <n-dropdown trigger="hover" :options="importWordOptions" @select="handleSelect">
-      <n-button
+        <n-button
-        :color="softwareStore.SoftColor.ORANGE"
+          :color="softwareStore.SoftColor.ORANGE"
-        style="margin-left: 5px"
+          style="margin-left: 5px"
-        @click="ImportWordAndSrtFunc"
+          size="small"
-      >
+          @click="ImportWordAndSrtFunc"
-        导入文案/SRT
+        >
-      </n-button>
+          导入文案/SRT
+        </n-button>
+      </n-dropdown>
 
       <n-dropdown trigger="hover" :options="reverseOptions" @select="handleSelect">
         <n-button
           :color="softwareStore.SoftColor.ORANGE"
           style="margin-left: 5px"
+          size="small"
           @click="ImageReversePrompt(undefined)"
         >
           一键反推
@@ -53,6 +65,7 @@
         <n-button
           :color="softwareStore.SoftColor.ORANGE"
           style="margin-left: 5px"
+          size="small"
           @click="Translate(undefined)"
         >
           一键翻译
@@ -63,15 +76,28 @@
         <n-button
           :color="softwareStore.SoftColor.ORANGE"
           style="margin-left: 5px"
+          size="small"
           @click="GenerateImageAll"
         >
           一键生图
         </n-button>
       </n-dropdown>
 
+      <n-dropdown trigger="hover" :options="resetOptions" @select="handleSelect">
+        <n-button
+          :color="softwareStore.SoftColor.ORANGE"
+          style="margin-left: 5px"
+          size="small"
+          @click="ResetAllData"
+        >
+          重置
+        </n-button>
+      </n-dropdown>
+
       <n-button
         :color="softwareStore.SoftColor.ORANGE"
         style="margin-left: 5px"
+        size="small"
         @click="OpenSettingDialog"
       >
         设置
@@ -397,15 +423,15 @@ export default defineComponent({
         case 'watermark_position': // 水印位置设置
           await GetWatermarkPosition()
           break
+        case 'clear_import_word': // 清除导入文案
+          await ClearImportWord()
+          break
         case 'mj_reverse': // MJ反推
           await ImageReversePrompt(BookType.MJ_REVERSE)
           break
         case 'sd_reverse': // SD反推
           await ImageReversePrompt(BookType.SD_REVERSE)
           break
-        case 'remove_reverse':
-          await RemoveReverseData(undefined)
-          break
         case 'translate_chinese': // 英文翻译为中文
           await Translate('translate_chinese')
           break
@@ -416,11 +442,102 @@ export default defineComponent({
         case 'translate_setting': // 翻译设置
           await Translate('translate_setting')
           break
+        case 'reset_gpt_reverse_data': // 重置反推/GPT提示词
+          await ResetGptReverseData()
+          break
+        case 'reset_merge_prompt': // 重置合并提示词数据
+          await ResetMergePromptData()
+          break
+        case 'reset_Generate_Image': // 重置生成的图片
+          await ResetGenerateImage()
+          break
         default:
           message.error('未知的选项')
       }
     }
 
+    // 重置出的图片
+    async function ResetGenerateImage() {
+      dialog.warning({
+        title: '重置所有图片提示',
+        content:
+          '继续操作会重置所有的生成的图片，包括生成的主图和子图，但是并不会删除本地的图片文件，是否继续？',
+        positiveText: '继续',
+        negativeText: '取消',
+        onPositiveClick: async () => {
+          let res = await window.book.ResetGenerateImage(
+            reverseManageStore.selectBookTask.id,
+            OperateBookType.BOOKTASK
+          )
+          if (res.code == 0) {
+            message.error(res.message)
+          } else {
+            // 前端重置数据
+            for (let i = 0; i < reverseManageStore.selectBookTaskDetail.length; i++) {
+              reverseManageStore.selectBookTaskDetail[i].mjMessage = undefined
+              reverseManageStore.selectBookTaskDetail[i].outImagePath = undefined
+              reverseManageStore.selectBookTaskDetail[i].subImagePath = undefined
+            }
+            message.success('重置所有生成图片成功')
+          }
+        }
+      })
+    }
+
+    // 重置合并提示词数据
+    async function ResetMergePromptData() {
+      dialog.warning({
+        title: '重置合并提示词数据提示',
+        content: '继续操作会重置所有的合并提示词数据，请确认是不是继续？',
+        positiveText: '继续',
+        negativeText: '取消',
+        onPositiveClick: async () => {
+          let res = await window.book.ResetMergePromptData(
+            reverseManageStore.selectBookTask.id,
+            OperateBookType.BOOKTASK
+          )
+          if (res.code == 0) {
+            message.error(res.message)
+          } else {
+            // 前端做响应
+            for (let i = 0; i < reverseManageStore.selectBookTaskDetail.length; i++) {
+              reverseManageStore.selectBookTaskDetail[i].prompt = undefined
+            }
+            message.success('重置所有合并提示词数据成功')
+          }
+        }
+      })
+    }
+
+    /**
+     * 重置反推/GPT提示词，更具不同的小说类型进行不同的重置
+     */
+    async function ResetGptReverseData() {
+      dialog.warning({
+        title: '删除反推提示词警告提示',
+        content: '继续操作会移除所有的反推提示词数据，注意，是所有，请确认是不是继续？',
+        positiveText: '继续',
+        negativeText: '取消',
+        onPositiveClick: async () => {
+          let res = await window.book.ResetGptReverseData(
+            reverseManageStore.selectBookTask.id,
+            OperateBookType.BOOKTASK,
+            reverseManageStore.selectBook.type
+          )
+          if (res.code == 0) {
+            message.error(res.message)
+          } else {
+            // 这个做个前端删除
+            for (let i = 0; i < reverseManageStore.selectBookTaskDetail.length; i++) {
+              reverseManageStore.selectBookTaskDetail[i].reversePrompt = undefined
+              reverseManageStore.selectBookTaskDetail[i].gptPrompt = undefined
+            }
+            message.success('删除所有的反推/GPT提示词成功')
+          }
+        }
+      })
+    }
+
     /**
      * 打开设置对话框
      */
@@ -480,42 +597,6 @@ export default defineComponent({
       })
     }
 
-    /**
-     * 移除反推的数据
-     */
-    async function RemoveReverseData(id) {
-      let deleteIds = []
-      if (id == undefined) {
-        // 删除全部的
-        for (let i = 0; i < reverseManageStore.selectBookTaskDetail.length; i++) {
-          const element = reverseManageStore.selectBookTaskDetail[i]
-          if (element.reversePrompt && element.reversePrompt.length > 0) {
-            deleteIds.push(element.id)
-          }
-        }
-      } else {
-        deleteIds.push(id)
-      }
-
-      let res = await window.book.RemoveReverseData(deleteIds)
-      if (res.code == 0) {
-        message.error(res.message)
-      } else {
-        // 这个做个前端删除
-        for (let i = 0; i < deleteIds.length; i++) {
-          const element = deleteIds[i]
-          let index = reverseManageStore.selectBookTaskDetail.findIndex(
-            (item) => item.id == element
-          )
-          if (index >= 0) {
-            reverseManageStore.selectBookTaskDetail[index].reversePrompt = undefined
-          }
-        }
-
-        message.success('删除反推数据成功')
-      }
-    }
-
     /**
      * 翻译提示词
      * @param key 操作的值，进行分类
@@ -681,6 +762,44 @@ export default defineComponent({
       })
     }
 
+    /**
+     * 清除导入文案
+     */
+    async function ClearImportWord() {
+      let da = dialog.warning({
+        title: '清除导入文案提示',
+        content:
+          '继续执行该操作会将导入的对齐文案全部清除（包括文案的时间线），并且操作不可逆，是否继续？',
+        positiveText: '继续',
+        negativeText: '取消',
+        onPositiveClick: async () => {
+          da?.destroy()
+          softwareStore.spin.spinning = true
+          softwareStore.spin.tip = '正在清除导入数据。。。'
+          let res = await window.book.ClearImportWord(reverseManageStore.selectBookTask.id)
+          softwareStore.spin.spinning = false
+          if (res.code == 0) {
+            message.error(res.message)
+          } else {
+            // 这边重置下数据
+            for (let i = 0; i < res.data.length; i++) {
+              const element = res.data[i]
+              let index = reverseManageStore.selectBookTaskDetail.findIndex(
+                (item) => item.id == element.id
+              )
+              if (index != -1) {
+                reverseManageStore.selectBookTaskDetail[index].subValue = undefined
+                reverseManageStore.selectBookTaskDetail[index].startTime = element.startTime
+                reverseManageStore.selectBookTaskDetail[index].endTime = element.endTime
+                reverseManageStore.selectBookTaskDetail[index].timeLimit = element.timeLimit
+              }
+            }
+            message.success('清除导入文案成功')
+          }
+        }
+      })
+    }
+
     async function ActionFrame() {
       message.info('请使用下面菜单中的按钮进行对应的操作')
     }
@@ -689,6 +808,7 @@ export default defineComponent({
       RetuenMain,
       AutoAction,
       ImportWordAndSrtFunc,
+      ClearImportWord,
       reverseManageStore,
       softwareStore,
       ActionFrame,
@@ -698,7 +818,7 @@ export default defineComponent({
       GetCopywriting,
       RemoveWatermark,
       ImageReversePrompt,
-      RemoveReverseData,
+      ResetGptReverseData,
       Translate,
       TranslateService,
       GenerateImageAll,
@@ -758,10 +878,6 @@ export default defineComponent({
           key: 'sd_reverse',
           disabled: reverseManageStore.selectBook.type != BookType.SD_REVERSE
         },
-        {
-          label: '清除反推数据',
-          key: 'remove_reverse'
-        },
         {
           label: '停止反推',
           key: 'stop_reverse'
@@ -790,6 +906,26 @@ export default defineComponent({
           label: '停止生图',
           key: 'stop_image_generate'
         }
+      ],
+      importWordOptions: [
+        {
+          label: '清除导入文案',
+          key: 'clear_import_word'
+        }
+      ],
+      resetOptions: [
+        {
+          label: '重置反推/GPT提示词',
+          key: 'reset_gpt_reverse_data'
+        },
+        {
+          label: '重置合并提示词',
+          key: 'reset_merge_prompt'
+        },
+        {
+          label: '重置图片',
+          key: 'reset_Generate_Image'
+        }
       ]
     }
   }
@@ -801,4 +937,8 @@ export default defineComponent({
   display: flex;
   justify-content: flex-end;
 }
+
+.top-button {
+  margin-left: 5px;
+}
 </style>

src/renderer/src/components/Book/MJReverse/SelectMJReversePrompt.vue

@@ -44,11 +44,20 @@ export default defineComponent({
       if (res.code == 0) {
         message.error(res.message)
       } else {
-        reverseManageStore.selectBookTaskDetail = res.data
+        // 这边修改全部数据
-        message.success('保存成功')
+        for (let i = 0; i < res.data.length; i++) {
+          const element = res.data[i]
+          let index = reverseManageStore.selectBookTaskDetail.findIndex((x) => x.id == element.id)
+          if (index != -1) {
+            reverseManageStore.selectBookTaskDetail[index].gptPrompt = element.gptPrompt
+          }
+        }
+        window.api.showGlobalMessageDialog({
+          code: 1,
+          message: res.message
+        })
       }
       // 后端数据处理完毕，前端重新处理一遍数据
-      
     }
 
     return {

src/renderer/src/components/Book/ManageBook.vue

@@ -1,8 +1,8 @@
 <template>
-  <div style="margin-bottom: 10px">
+  <div style="margin-bottom: 5px">
     <ManageBookButton />
   </div>
-  <div style="margin-right: 10px">
+  <div style="margin-right: 5px">
     <n-data-table
       :columns="columns"
       :size="softwareStore.softWare.reverse_data_table_size"

src/renderer/src/components/Book/ManageBookDetail.vue

@@ -2,7 +2,7 @@
   <div style="height: 100%; display: flex; width: 100%; overflow: auto">
     <div v-if="true" class="left_container" style="flex: 10; min-width: 500px">
       <ManageBookDetailButton />
-      <ManageBookReverseTable style="margin-top: 10px" />
+      <ManageBookReverseTable style="margin-top: 5px" />
     </div>
     <div v-if="softwareStore.show_logger">
       <n-divider vertical style="height: 100%"></n-divider>