1. 修改用户机器码管理（所有用户需要重新注册，激活）

2. 重构软件鉴权，添加自动判断机器码，可以不在手动点击确定
3. 新增软件启动时，提示用户是不是还存在等待中的任务，还有的话，由用户判断是不是丢弃，丢弃，会将所有的等待中的任务设置为失败
4. 聚合推文 提示词合并，人物、风格和场景 添加判无，修复部分情况无法合并
5. 新增 预设（人物，场景，风格）对提示词相关的提示
6. 修复 文案处理，流式输出内容重复问题，删除豆包（请求格式不兼容）
7. 新增 文案处理 输出内容一键格式化（注意：由于GPT输出的格式化有太多的不确定，不一定可以完全格式化，需要手动检查）
8. 聚合推文原创，新增时默认设置 修脸参数，初始和SD设置中的一致
9. 修复聚合推文选图覆盖 bug

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

@@ -131,6 +131,17 @@ export class BookBackTaskListService extends BaseRealmService {
     }
   }
 
+  /**
+   * 获取指定状态的任务数量
+   */
+  GetAllStatusTaskCount(status: BookBackTaskStatus[]): number {
+    let taskLength = this.realm
+      .objects<BookBackTaskList>('BookBackTaskList').filtered(
+        'status == $0', status
+      ).length;
+    return taskLength;
+  }
+
   /**
    * 新增一个小说相关的后台任务队列
    * @param bookBackTask 要添加的小说数据

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

@@ -144,7 +144,10 @@ export class BookTaskDetailService extends BaseRealmService {
       bookTaskDetail.imageLock = false
       bookTaskDetail.createTime = new Date()
       bookTaskDetail.updateTime = new Date()
-      bookTaskDetail.adetailer = false // 先写死false
+
+      if (!bookTaskDetail.hasOwnProperty('adetailer')) {
+        bookTaskDetail.adetailer = false; // 设置默认值
+      }
       // 开始添加
       this.transaction(() => {
         this.realm.create('BookTaskDetail', bookTaskDetail)

src/define/define.js

@@ -12,11 +12,11 @@ if (!app.isPackaged) {
     tag_setting: path.join(__dirname, '../../resources/config/tag_setting.json'),
     img_base: path.join(__dirname, '../../resources/config/img_base.json'),
     video_config: path.join(__dirname, '../../resources/config/video_config.json'),
+    system_config: path.join(__dirname, '../../resources/config/system_config.json'),
     scripts_path: path.join(__dirname, '../../resources/scripts'),
     db_path: path.join(__dirname, '../../resources/scripts/db'),
     project_path: path.join(__dirname, '../../project'),
     tts_path: path.join(__dirname, '../../tts'),
-
     logger_path: path.join(__dirname, '../../resources/logger'),
     package_path: path.join(__dirname, '../../resources/package'),
     image_path: path.join(__dirname, '../../resources/image'),
@@ -80,6 +80,7 @@ if (!app.isPackaged) {
     dynamic_setting: path.join(__dirname, '../../../resources/config/dynamic_setting.json'),
     tag_setting: path.join(__dirname, '../../../resources/config/tag_setting.json'),
     video_config: path.join(__dirname, '../../../resources/config/video_config.json'),
+    system_config: path.join(__dirname, '../../../resources/config/system_config.json'),
     img_base: path.join(__dirname, '../../../resources/config/img_base.json'),
     scripts_path: path.join(__dirname, '../../../resources/scripts'),
     db_path: path.join(__dirname, '../../../resources/scripts/db'),

src/define/define_string/index.ts

@@ -1,4 +1,9 @@
+import { SYSTEM } from "./systemDefineString"
+import TASK from "./taskDefineString"
+
 export const DEFINE_STRING = {
+  SYSTEM: SYSTEM,
+  TASK: TASK,
   SHOW_GLOBAL_MESSAGE: "SHOW_GLOBAL_MESSAGE",
   SHOW_GLOBAL_MAIN_NOTIFICATION: 'SHOW_GLOBAL_MAIN_NOTIFICATION',
   OPEN_DEV_TOOLS_PASSWORD: 'OPEN_DEV_TOOLS_PASSWORD',
@@ -81,7 +86,6 @@ export const DEFINE_STRING = {
   GET_ADETAILER_LIST: 'GET_ADETAILER_LIST',
   SAVE_DETAILER_CONFIG: 'SAVE_DETAILER_CONFIG',
   OPEN_URL: 'OPEN_URL',
-  GET_VERSION: 'GET_VERSION',
   GET_FRAME_RETUN: 'GET_FRAME_RETUN',
   DOWNLOAD_MODEL: 'DOWNLOAD_MODEL',
   START_STORY_BOARDING: 'START_STORY_BOARDING',
@@ -357,10 +361,6 @@ export const DEFINE_STRING = {
     //#endregion
 
   },
-  SYSTEM: {
-    OPEN_FILE: 'OPEN_FILE',
-    RETURN_LOGGER: 'RETURN_LOGGER'
-  },
   SETTING: {
     GET_DATA_BY_TYPE_AND_PROPERTY: 'GET_DATA_BY_TYPE_AND_PROPERTY',
     SAVE_DATA_BY_TYPE_AND_PROPERTY: 'SAVE_DATA_BY_TYPE_AND_PROPERTY',
@@ -420,19 +420,5 @@ export const DEFINE_STRING = {
     UPDATE_BOOK_TASK_DETAIL_DATA: "UPDATE_BOOK_TASK_DETAIL_DATA",
     UPDATE_BOOK_DATA: "UPDATE_BOOK_DATA",
     UPDATE_SOFTWARE_SETTING: "UPDATE_SOFTWARE_SETTING"
-  },
-  /**
-   * 后台任务相关
-   */
-  TASK: {
-    /**
-     * 添加单个后台任务
-     */
-    ADD_BOOK_BACK_TASK: "ADD_BOOK_BACK_TASK",
-
-    /**
-     * 添加多个后台任务
-     */
-    ADD_MULTI_BOOK_BACK_TASK: 'ADD_MULTI_BOOK_BACK_TASK'
   }
 }

src/define/define_string/systemDefineString.ts

@@ -0,0 +1,12 @@
+export const SYSTEM = {
+  /** 打开文件夹 */
+  OPEN_FILE: 'OPEN_FILE',
+  /** 返回日志写出 */
+  RETURN_LOGGER: 'RETURN_LOGGER',
+  /** 获取版本信息和显卡信息 */
+  GET_VISION_AND_GPU_MESSAGE: 'GET_VISION_AND_GPU_MESSAGE',
+  /** 获取机器码 */
+  GET_MACHINE_ID: "GET_MACHINE_ID",
+  /** 检查机器码状态 */
+  CHECK_MACHINE_STATUS : "CHECK_MACHINE_STATUS"
+}

src/define/define_string/taskDefineString.ts

@@ -0,0 +1,14 @@
+
+const TASK = {
+  /** 启动后台任务 */
+  START_BACK_TASK: "START_BACK_TASK",
+  /** 添加单个后台任务  */
+  ADD_BOOK_BACK_TASK: "ADD_BOOK_BACK_TASK",
+  /** 添加多个后台任务   */
+  ADD_MULTI_BOOK_BACK_TASK: 'ADD_MULTI_BOOK_BACK_TASK',
+  /** 获取等待中的任务 */
+  GET_ALL_STATUS_TASK_COUNT: "GET_ALL_STATUS_TASK_COUNT",
+
+};
+
+export default TASK;

src/main/IPCEvent/index.js

@@ -11,7 +11,7 @@ import { SdIpc } from './sdIpc.js'
 import { MainIpc } from './mainIpc.js'
 import { GlobalIpc } from './globalIpc.js'
 import { ImageIpc } from './imageIpc.js'
-import { SystemIpc } from './systemIpc.js'
+import { SystemIpc } from './systemIpc'
 import { BookIpc } from './bookIpc'
 import { TTSIpc } from './ttsIpc.js'
 import { DBIpc } from './dbIpc'

src/main/IPCEvent/systemIpc.js

@@ -1,39 +0,0 @@
-import { ipcMain } from 'electron'
-import { DEFINE_STRING } from '../../define/define_string'
-import { CheckFileOrDirExist } from '../../define/Tools/file'
-import { errorMessage, successMessage } from '../Public/generalTools'
-import path from 'path'
-const { shell } = require('electron')
-
-function SystemIpc() {
-  // 打开指定的文件
-  ipcMain.on(DEFINE_STRING.SYSTEM.OPEN_FILE, async (event, value) => {
-    await shell.openPath(value)
-  })
-
-  // 试用文件资源打开指定的文件夹
-  ipcMain.handle(DEFINE_STRING.OPEN_FOLDER, async (event, value) => {
-    try {
-      let openFolder = null
-      if (value.baseProject) {
-        openFolder = path.join(global.config.project_path, value.folderPath)
-      }
-      if (value.dirFloder) {
-        openFolder = path.dirname(value.folderPath)
-      }
-      if (!openFolder) {
-        openFolder = value.folderPath
-      }
-      // 判断文件夹是不是存在
-      let isExist = await CheckFileOrDirExist(openFolder)
-      if (!isExist) {
-        throw new Error('文件夹不存在，请检查')
-      }
-      shell.openPath(openFolder)
-      return successMessage(null, '打开成功')
-    } catch (error) {
-      return errorMessage('打开文件夹错误，错误信息如下：' + error.message, 'SystemIpc_OPEN_FOLDER')
-    }
-  })
-}
-export { SystemIpc }

src/main/IPCEvent/systemIpc.ts

@@ -0,0 +1,30 @@
+import { ipcMain } from 'electron'
+import { DEFINE_STRING } from '../../define/define_string'
+import { CheckFileOrDirExist } from '../../define/Tools/file'
+import { errorMessage, successMessage } from '../Public/generalTools'
+import path from 'path'
+import { shell } from 'electron'
+import SystemInfo from '../Service/system/systeminfo'
+import ElectronInterface, { OpenFolderParams } from '../Service/system/electronInterface'
+
+const systemInfo = new SystemInfo();
+const electronInterface = new ElectronInterface()
+
+function SystemIpc() {
+  /**打开指定的文件 */
+  ipcMain.on(DEFINE_STRING.SYSTEM.OPEN_FILE, async (event, value) => {
+    await shell.openPath(value)
+  })
+  /**试用文件资源打开指定的文件夹 */
+  ipcMain.handle(DEFINE_STRING.OPEN_FOLDER, async (event, value: OpenFolderParams) => await electronInterface.OpenFolder(value))
+  /**
+   * 获取指定的版本好电脑的CPU
+   * 判断获取时间是不是超过一天，如果超过一天就重新获取
+   */
+  ipcMain.handle(DEFINE_STRING.SYSTEM.GET_VISION_AND_GPU_MESSAGE, async (event) => await systemInfo.GetViosionAndGpuMessage())
+  /**获取系统的机器码 */
+  ipcMain.handle(DEFINE_STRING.SYSTEM.GET_MACHINE_ID, async (event) => await systemInfo.GetMachineId())
+  /** 检查机器码状态 */
+  ipcMain.handle(DEFINE_STRING.SYSTEM.CHECK_MACHINE_STATUS, async (event, value: string) => await systemInfo.CheckMachineStatus(value))
+}
+export { SystemIpc }

src/main/IPCEvent/taskIpc.ts

@@ -2,12 +2,16 @@ import { ipcMain } from "electron"
 import { BookServiceBasic } from "../Service/ServiceBasic/bookServiceBasic"
 import { DEFINE_STRING } from "../../define/define_string";
 import { errorMessage, successMessage } from "../Public/generalTools";
-import { BookBackTaskType, TaskExecuteType } from "../../define/enum/bookEnum";
+import { BookBackTaskStatus, BookBackTaskType, TaskExecuteType } from "../../define/enum/bookEnum";
 
 let bookServiceBasic = new BookServiceBasic();
+import BackTaskService from '../Service/task/backTaskService'
+const backTaskService = new BackTaskService()
 
 function TaskIpc() {
 
+  ipcMain.handle(DEFINE_STRING.TASK.START_BACK_TASK, async (event, isGiveUp: boolean) => await backTaskService.StartBackTask(isGiveUp))
+
   /**
    * 添加后台任务，单个
    */
@@ -34,6 +38,8 @@ function TaskIpc() {
       return errorMessage(`添加多个任务失败，错误信息如下：${error.toString()} `, 'TaskIpc_AddMultiBookBackTask')
     }
   })
+  /** 获取指定状态的任务数量 */
+  ipcMain.handle(DEFINE_STRING.TASK.GET_ALL_STATUS_TASK_COUNT, async (event, value: BookBackTaskStatus[]) => await backTaskService.GetAllStatusTaskCount(value))
 }
 
 export { TaskIpc }

src/main/Service/Book/ReverseBook.ts

@@ -8,7 +8,7 @@ import { DEFINE_STRING } from "../../../define/define_string";
 import path from 'path'
 import { BasicReverse } from './basicReverse'
 import { BookTaskDetailService } from '../../../define/db/service/Book/bookTaskDetailService'
-import { TaskScheduler } from "../../Service/taskScheduler"
+import { TaskScheduler } from "../task/taskScheduler"
 import { Book } from '../../../model/book'
 import { LoggerStatus, OtherData, ResponseMessageType } from '../../../define/enum/softwareEnum'
 import { GeneralResponse } from '../../../model/generalResponse'

src/main/Service/Book/basicReverse.ts

@@ -5,7 +5,7 @@ const { exec } = require('child_process')
 const execAsync = util.promisify(exec)
 import { define } from '../../../define/define'
 import { BookService } from '../../../define/db/service/Book/bookService'
-import { TaskScheduler } from '../taskScheduler'
+import { TaskScheduler } from '../task/taskScheduler'
 import { LoggerStatus, LoggerType, OtherData } from '../../../define/enum/softwareEnum'
 import { errorMessage, successMessage } from '../../Public/generalTools'
 import { CheckFileOrDirExist, CheckFolderExistsOrCreate } from '../../../define/Tools/file'

src/main/Service/Book/bookFrame.ts

@@ -7,7 +7,7 @@ import { FfmpegOptions } from "../ffmpegOptions";
 import { CheckFileOrDirExist, CopyFileOrFolder, DeleteFolderAllFile } from "../../../define/Tools/file";
 import fs from 'fs';
 import { Book } from "../../../model/book";
-import { TaskScheduler } from '../taskScheduler';
+import { TaskScheduler } from '../task/taskScheduler';
 import { BookBasic } from "./BooKBasic";
 import { LoggerStatus, OtherData } from "../../../define/enum/softwareEnum";
 import { BasicReverse } from "./basicReverse";

src/main/Service/Book/bookTask.ts

@@ -155,9 +155,6 @@ export class BookTask {
     return newBookTask
   }
 
-  CopyCopywrittingData() {
-
-  }
 
   /**
  * 添加一个小说批次任务

src/main/Service/Book/imageStyle.ts

@@ -34,7 +34,9 @@ export class ImageStyle {
         if (imageStyleRes.code == 0) {
           throw new Error(imageStyleRes.message)
         }
-        styleArr.push(...imageStyleRes.data);
+        if (imageStyleRes.data && imageStyleRes.data.length > 0) {
+          styleArr.push(...imageStyleRes.data);
+        }
       }
       // 获取自定义的风格
       if (customizeImageStyle && customizeImageStyle.length > 0) {
@@ -43,11 +45,13 @@ export class ImageStyle {
           throw new Error(customizeImageStyleRes.message)
         }
         let customizeImageStyleArr = customizeImageStyleRes.data
-        for (let i = 0; i < customizeImageStyle.length; i++) {
-          const element = customizeImageStyle[i];
-          let style = customizeImageStyleArr.find(x => x.key == element)
-          if (style) {
-            styleArr.push(style)
+        if (customizeImageStyleArr) {
+          for (let i = 0; i < customizeImageStyle.length; i++) {
+            const element = customizeImageStyle[i];
+            let style = customizeImageStyleArr.find(x => x.key == element)
+            if (style) {
+              styleArr.push(style)
+            }
           }
         }
       }

src/main/Service/MJ/mj.ts

@@ -13,7 +13,7 @@ import { MJSetting } from "../../../model/Setting/mjSetting";
 import { GeneralResponse } from "../../../model/generalResponse"
 import { LoggerStatus, ResponseMessageType } from "../../../define/enum/softwareEnum";
 import { ImageStyle } from "../Book/imageStyle";
-import { TaskScheduler } from "../taskScheduler";
+import { TaskScheduler } from "../task/taskScheduler";
 import { Tools } from "../../../main/tools"
 import { BookServiceBasic } from "../ServiceBasic/bookServiceBasic";
 import { PresetService } from "../presetService";
@@ -283,11 +283,12 @@ export class MJOpt {
     for (let i = 0; i < ids.length; i++) {
       const id = ids[i];
       let scene = await this.presetService.GetScenePresetDetailById(id)
-      if (scene.code == 1) {
+      if (scene.code == 0) {
+        throw new Error(scene.message)
+      }
+      if (scene.data) {
         // 这边开始拼接
         sceneString += scene.data.prompt + ', '
-      } else {
-        throw new Error(scene.message)
       }
     }
     return sceneString
@@ -306,16 +307,17 @@ export class MJOpt {
     for (let i = 0; i < ids.length; i++) {
       const element = ids[i];
       let character = await this.presetService.GetCharacterPresetDetailById(element)
-      if (character.code == 1) {
+      if (character.code == 0) {
+        throw new Error(character.message)
+      }
+
+      if (character.data) {
         characterString += character.data.prompt + ', '
         if (character.data.image_url && character.data.image_url != '' && character.data.cref_cw) {
           characterUrl += ` ${character.data.image_url} `
           crefCw = character.data.cref_cw
         }
       }
-      else {
-        throw new Error(character.message)
-      }
     }
 
     //这边坐下合并s
@@ -399,6 +401,7 @@ export class MJOpt {
         let characterString = '' // 人物
         let characterUrl = ''
         let sceneString = "" // 场景
+        
         // 获取当前的自定义风格的垫图字符串
         if (book.type == BookType.ORIGINAL) {
           let sceneIds = element.sceneTags ? element.sceneTags : []
@@ -594,7 +597,7 @@ export class MJOpt {
             let imagePath = path.join(book.bookFolderPath, `data\\MJOriginalImage\\${task_res.messageId}.png`);
             await CheckFolderExistsOrCreate(path.dirname(imagePath))
             await this.tools.downloadFileUrl(task_res.imageClick, imagePath)
-
+            debugger
             // 进行图片裁剪
             let imageRes = await ImageSplit(imagePath, bookTaskDetail.name, path.join(book.bookFolderPath, 'data\\MJOriginalImage'));
             if (imageRes && imageRes.length < 4) {
@@ -608,7 +611,7 @@ export class MJOpt {
             }
             let out_file = path.join(bookTask.imageFolder, `${bookTaskDetail.name}.png`)
             await CopyFileOrFolder(firstImage, out_file);
-            task_res.outImagePath = firstImage;
+            task_res.outImagePath = out_file;
             task_res.subImagePath = imageRes;
 
             task_res.id = task.bookTaskDetailId;

src/main/Service/ServiceBasic/bookBackTaskServiceBasic.ts

@@ -0,0 +1,78 @@
+import { BookBackTaskStatus, BookBackTaskType, TaskExecuteType } from "../../../define/enum/bookEnum";
+import { BookBackTaskListService } from "../../../define/db/service/Book/bookBackTaskListService";
+import { Book } from "../../../model/book";
+
+export default class BookBackTaskServiceBasic {
+  bookBackTaskListService: BookBackTaskListService
+  constructor() { }
+
+  private async InitService() {
+    if (!this.bookBackTaskListService) {
+      this.bookBackTaskListService = await BookBackTaskListService.getInstance()
+    }
+  }
+
+  /**
+   * 添加一个后台任务
+   * @param bookId 小说ID
+   * @param taskType 后台任务类型
+   * @param executeType 执行的类型，是不是自动执行
+   * @param bookTaskId 小说批次任务ID
+   * @param bookTaskDetailId  小说批次任务分镜ID
+   * @param responseMessageName 消息名称
+  */
+  async AddBookBackTask(bookId: string,
+    taskType: BookBackTaskType,
+    executeType = TaskExecuteType.AUTO,
+    bookTaskId = null,
+    bookTaskDetailId = null,
+    responseMessageName: string = null
+  ): Promise<TaskModal.Task> {
+    await this.InitService();
+    let res = this.bookBackTaskListService.AddBookBackTask(bookId, taskType, executeType, bookTaskId, bookTaskDetailId, responseMessageName)
+    if (res.code == 0) {
+      throw new Error(res.message)
+    }
+    return res.data as TaskModal.Task
+  }
+
+  /**
+   * 获取指定状态的任务数量
+   * @param status 
+   * @returns 
+   */
+  async GetAllStatusTaskCount(status: BookBackTaskStatus[]): Promise<number> {
+    await this.InitService();
+    let count = this.bookBackTaskListService.GetAllStatusTaskCount(status)
+    return count;
+
+  }
+
+  /**
+   * 修改后台队列的状态
+   * @param bookBackTask 要修改的数据
+   */
+  async UpdateTaskStatus(bookBackTask: Book.UpdateBookTaskListStatus) {
+    await this.InitService();
+    this.bookBackTaskListService.UpdateTaskStatus(bookBackTask)
+  }
+
+  /**
+   * 丢弃等待中和重新连接的任务
+   */
+  async GiveUpNotStartBackTask() {
+    await this.InitService();
+    let task = this.bookBackTaskListService.realm.objects('BookBackTaskList').filtered('status == $0 || status == $1', BookBackTaskStatus.WAIT, BookBackTaskStatus.RECONNECT);
+    let ids = task.map((item) => {
+      return item.id
+    })
+    // 讲所有的人物状态改为放弃，然后errmessage改为 此任务已丢弃
+    this.bookBackTaskListService.transaction(() => {
+      for (let i = 0; i < ids.length; i++) {
+        const element = this.bookBackTaskListService.realm.objectForPrimaryKey('BookBackTaskList', ids[i]);
+        element.status = BookBackTaskStatus.FAIL
+        element.errorMessage = '任务被丢弃'
+      }
+    })
+  }
+}

src/main/Service/ServiceBasic/bookBasic.ts

@@ -0,0 +1,57 @@
+import { BookService } from "../../../define/db/service/Book/bookService";
+import { Book } from "../../../model/book";
+
+export class BookBasic {
+  bookService: BookService
+  constructor() { }
+
+  async InitService() {
+    if (!this.bookService) {
+      this.bookService = await BookService.getInstance()
+    }
+  }
+
+  //#region 事务操作
+  async transaction(callback: (realm: any) => void) {
+    await this.InitService();
+    this.bookService.transaction(() => {
+      callback(this.bookService.realm)
+    })
+  }
+  //#endregion
+
+  /**
+   * 通过小说ID获取小说数据
+   * @param bookId 小说ID
+   * @returns
+   */
+  async GetBookDataById(bookId: string): Promise<Book.SelectBook> {
+    await this.InitService();
+    let book = this.bookService.GetBookDataById(bookId);
+    if (book == null) {
+      let msg = '未找到对应的小说数据，请检查'
+      throw new Error(msg);
+    }
+    return book
+  }
+
+  /**
+  * 更新小说指定ID的数据
+  * @param bookId 小说ID
+  * @param data 小说要更新的数据
+  */
+  async UpdateBookData(bookId: string, data: Book.SelectBook): Promise<Book.SelectBook> {
+    await this.InitService();
+    let res = this.bookService.UpdateBookData(bookId, data)
+    return res
+  }
+
+  /**
+   * 删除指定的小说数据
+   * @param bookId 需要删除的小说ID
+   */
+  async DeleteBookData(bookId: string): Promise<void> {
+    await this.InitService();
+    this.bookService.DeleteBookData(bookId)
+  }
+}

src/main/Service/ServiceBasic/bookServiceBasic.ts

@@ -2,39 +2,28 @@ import { DEFINE_STRING } from "../../../define/define_string";
 import { GeneralResponse } from "../../../model/generalResponse";
 import { BookService } from "../../../define/db/service/Book/bookService";
 import { Book } from "../../../model/book";
-import { BookTaskService } from "../../../define/db/service/Book/bookTaskService";
-import { TaskScheduler } from "../taskScheduler";
-import { LoggerStatus, OtherData } from "../../../define/enum/softwareEnum";
-import { BookTaskDetailService } from "../../../define/db/service/Book/bookTaskDetailService";
-import { BookBackTaskListService } from "../../../define/db/service/Book/bookBackTaskListService";
-import { BookBackTaskType, BookTaskStatus, TaskExecuteType } from "../../../define/enum/bookEnum";
+import { BookBackTaskStatus, BookBackTaskType, BookTaskStatus, TaskExecuteType } from "../../../define/enum/bookEnum";
+import BookBackTaskServiceBasic from "./bookBackTaskServiceBasic";
+import { BookBasic } from "./bookBasic";
+import BookTaskServiceBasic from "./bookTaskServiceBasic";
+import BookTaskDetailServiceBasic from "./bookTaskDetailServiceBasic";
 
 /**
  * 该类中封装了小说的基础服务，主要是检查每次引入对应的服务类
  * 这边进行一个统一的调用，方便后续的维护
  */
-export class BookServiceBasic {
+class BookServiceBasic {
   bookService: BookService
-  bookTaskService: BookTaskService;
-  taskScheduler: TaskScheduler
-  bookTaskDetailService: BookTaskDetailService
-  bookBackTaskListService: BookBackTaskListService
+  private bookBasic: BookBasic
+  private bookTaskServiceBasic: BookTaskServiceBasic
+  private bookTaskDetailServiceBasic: BookTaskDetailServiceBasic
+  private bookBackTaskServiceBasic: BookBackTaskServiceBasic
+
   constructor() {
-    this.taskScheduler = new TaskScheduler()
-  }
-  async InitService() {
-    if (!this.bookService) {
-      this.bookService = await BookService.getInstance()
-    }
-    if (!this.bookTaskService) {
-      this.bookTaskService = await BookTaskService.getInstance()
-    }
-    if (!this.bookTaskDetailService) {
-      this.bookTaskDetailService = await BookTaskDetailService.getInstance()
-    }
-    if (!this.bookBackTaskListService) {
-      this.bookBackTaskListService = await BookBackTaskListService.getInstance()
-    }
+    this.bookBasic = new BookBasic();
+    this.bookTaskServiceBasic = new BookTaskServiceBasic();
+    this.bookTaskDetailServiceBasic = new BookTaskDetailServiceBasic();
+    this.bookBackTaskServiceBasic = new BookBackTaskServiceBasic();
   }
 
   // 主动返回前端的消息
@@ -42,298 +31,65 @@ export class BookServiceBasic {
     global.newWindow[0].win.webContents.send(message_name, data)
   }
 
-
-
   //#region 事务操作
-  transaction(callback: (realm: any) => void) {
-    this.bookService.transaction(() => {
-      callback(this.bookService.realm)
-    })
-  }
+  transaction = async (realm : any) => await this.bookBasic.transaction(realm);
+  
+  // (callback: (realm: any) => void) {
+  //   this.bookService.transaction(() => {
+  //     callback(this.bookService.realm)
+  //   })
+  // }
+  //#endregion
+
+
+  //#region 小说任务
+
+  GetBookDataById = async (bookId: string) => await this.bookBasic.GetBookDataById(bookId);
+  UpdateBookData = async (bookId: string, data: Book.SelectBook) => await this.bookBasic.UpdateBookData(bookId, data);
+  DeleteBookData = async (bookId: string) => await this.bookBasic.DeleteBookData(bookId);
 
   //#endregion
 
-  //#region 小说相关的基础服务
+  //#region 批次任务任务
 
-  /**
-   * 通过小说ID获取小说数据
-   * @param bookId 小说ID
-   * @returns
-   */
-  async GetBookDataById(bookId: string): Promise<Book.SelectBook> {
-    await this.InitService();
-    let book = this.bookService.GetBookDataById(bookId);
-    if (book == null) {
-      let msg = '未找到对应的小说数据，请检查'
-      throw new Error(msg);
-    }
-    return book
-  }
-
-  /**
-  * 更新小说指定ID的数据
-  * @param bookId 小说ID
-  * @param data 小说要更新的数据
-  */
-  async UpdateBookData(bookId: string, data: Book.SelectBook): Promise<Book.SelectBook> {
-    await this.InitService();
-    let res = this.bookService.UpdateBookData(bookId, data)
-    return res
-  }
-
-  /**
-   * 删除指定的小说数据
-   * @param bookId 需要删除的小说ID
-   */
-  async DeleteBookData(bookId: string): Promise<void> {
-    await this.InitService();
-    this.bookService.DeleteBookData(bookId)
-  }
+  GetBookTaskDataById = async (bookTaskId: string) => await this.bookTaskServiceBasic.GetBookTaskDataById(bookTaskId);
+  GetBookTaskData = async (bookTaskCondition: Book.QueryBookTaskCondition) => await this.bookTaskServiceBasic.GetBookTaskData(bookTaskCondition);
+  GetMaxBookTaskNo = async (bookId: string) => await this.bookTaskServiceBasic.GetMaxBookTaskNo(bookId);
+  UpdetedBookTaskData = async (bookTaskId: string, data: Book.SelectBookTask) => await this.bookTaskServiceBasic.UpdetedBookTaskData(bookTaskId, data);
+  ResetBookTask = async (bookTaskId: string) => await this.bookTaskServiceBasic.ResetBookTask(bookTaskId);
+  DeleteBookTaskData = async (bookTaskId: string) => await this.bookTaskServiceBasic.DeleteBookTaskData(bookTaskId);
+  GetBookAndTask = async (bookId: string, bookTaskName: string) => await this.bookTaskServiceBasic.GetBookAndTask(bookId, bookTaskName);
 
   //#endregion
 
-  //#region 小说批次任务相关的基础服务
-
-  /**
-   * 通过小说ID获取小说批次任务数据
-   * @param bookTaskId 小说批次任务ID
-   * @returns
-   */
-  async GetBookTaskDataById(bookTaskId: string): Promise<Book.SelectBookTask> {
-    await this.InitService();
-    let bookTask = this.bookTaskService.GetBookTaskDataById(bookTaskId);
-    if (bookTask == null) {
-      let msg = '未找到对应的小说批次任务数据，请检查';
-      throw new Error(msg);
-    }
-    return bookTask
-  }
-
-  /**
-   * 通过查询条件获取小说批次任务数据
-   * @param bookTaskCondition 小说批次的查询条件
-   */
-  async GetBookTaskData(bookTaskCondition: Book.QueryBookTaskCondition): Promise<{ bookTasks: Book.SelectBookTask[], total: number }> {
-    await this.InitService();
-    let bookTasks = this.bookTaskService.GetBookTaskData(bookTaskCondition)
-    if (bookTasks.data.bookTasks.length <= 0 || bookTasks.data.total <= 0) {
-      throw new Error("未找到对应的小说批次任务数据，请检查")
-    }
-    return bookTasks.data
-  }
-
-  /**
-   * 获取最大的小说批次任务的编号
-   * @param bookId 小说ID
-   */
-  async GetMaxBookTaskNo(bookId: string): Promise<number> {
-    await this.InitService();
-    let maxNo = this.bookTaskService.realm
-      .objects('BookTask')
-      .filtered('bookId = $0', bookId)
-      .max('no')
-    let no = maxNo == null ? 1 : Number(maxNo) + 1
-    return no
-  }
-
-  /**
-   * 更新小说批次任务的数据
-   * @param bookTaskId 小说批次任务ID
-   * @param data
-   */
-  async UpdetedBookTaskData(bookTaskId: string, data: Book.SelectBookTask): Promise<void> {
-    await this.InitService();
-    this.bookTaskService.UpdetedBookTaskData(bookTaskId, data)
-  }
-
-  /**
-   * 重置小说批次任务的数据
-   * @param bookTaskId 指定的重置的小说批次任务的ID
-   */
-  async ResetBookTask(bookTaskId: string): Promise<void> {
-    await this.InitService();
-    this.bookTaskService.ResetBookTask(bookTaskId)
-  }
-
-  /**
-   * 删除指定的小说批次任务的数据
-   * @param bookTaskId 需要删除的指定的小说批次任务ID
-   */
-  async DeleteBookTaskData(bookTaskId: string): Promise<void> {
-    await this.InitService();
-    this.bookTaskService.DeleteBookTask(bookTaskId)
-  }
-  //#endregion
-
-  //#region 小说批次任务对应的分镜的相关的基础服务
-
-  async AddBookTaskDetail(bookTaskDetail: Book.SelectBookTaskDetail): Promise<void> {
-    await this.InitService();
-    this.bookTaskDetailService.AddBookTaskDetail(bookTaskDetail)
-  }
-
-  /**
-   * 获取指定的小说批次任务分镜数据，通过分镜ID
-   * @param bookTaskDetailId 小说批次任务分镜ID
-   * @returns
-   */
-  async GetBookTaskDetailDataById(bookTaskDetailId: string): Promise<Book.SelectBookTaskDetail> {
-    await this.InitService();
-    let bookTaskDetail = this.bookTaskDetailService.GetBookTaskDetailDataById(bookTaskDetailId)
-    if (bookTaskDetail == null) {
-      let msg = "未找到对应的小说批次任务分镜数据，请检查"
-      global.logger.error('BookServiceBasic_GetBookTaskDetailDataById', msg);
-      throw new Error("未找到对应的小说批次任务分镜数据，请检查")
-    }
-    return bookTaskDetail
-  }
-
-  /**
-   * 获取指定的小说批次任务分镜数据，通过查询条件
-   * @param condition
-   * @param returnEmpty 是否返回空数据，默认 false 不返回，如果返回空数据，会抛出异常
-   */
-  async GetBookTaskDetailData(condition: Book.QueryBookTaskDetailCondition, returnEmpty: boolean = false): Promise<Book.SelectBookTaskDetail[]> {
-    await this.InitService();
-    let bookTaskDetails = this.bookTaskDetailService.GetBookTaskData(condition)
-    if (!returnEmpty && bookTaskDetails.data.length <= 0) {
-      let msg = "未找到对应的小说批次任务分镜数据，请检查";
-      throw new Error(msg)
-    }
-    return bookTaskDetails.data
-  }
-
-  /**
-   * 修改小说的分镜详细数据，通过ID
-   * @param bookTaskDetailId 小说分镜的ID
-   * @param data 要修改的数据，是个对象，会修改全部
-   */
-  async UpdateBookTaskDetail(bookTaskDetailId: string, data: Book.SelectBookTaskDetail): Promise<Book.SelectBookTaskDetail> {
-    await this.InitService();
-    let res = this.bookTaskDetailService.UpdateBookTaskDetail(bookTaskDetailId, data)
-    return res
-  }
-
-  /**
-   * 更行小说批次的状态
-   * @param bookTaskId 小说批次的ID
-   * @param status 修改后的状态
-   * @param errorMsg 错误消息
-   */
-  async UpdateBookTaskStatus(bookTaskId: string, status: BookTaskStatus, errorMsg: string | null = null): Promise<void> {
-    await this.InitService();
-    this.bookTaskService.UpdateBookTaskStatus(bookTaskId, status, errorMsg);
-  }
+  //#region 分镜任务
 
 
-  /**
-   * 删除指定的小说分镜的反推提示词
-   * @param bookTaskDetail
-   */
-  async DeleteBookTaskDetailReversePromptById(bookTaskDetailId: string): Promise<void> {
-    await this.InitService();
-    this.bookTaskDetailService.DeleteBookTaskDetailReversePromptById(bookTaskDetailId)
-  }
-
-  /**
-   * 删除指定的小说分镜生成的图片
-   * @param bookTaskDetailId
-   */
-  async DeleteBoookTaskDetailGenerateImage(bookTaskDetailId: string): Promise<void> {
-    await this.InitService()
-    this.bookTaskDetailService.DeleteBoookTaskDetailGenerateImage(bookTaskDetailId);
-  }
-
-  /**
-   * 修改小说分镜数据的反推提示词
-   * @param bookTaskDetailId 小说分镜的ID
-   * @param reversePromptId 反推提示词的ID
-   * @param data 反推提示词数据
-   */
-  async UpdateBookTaskDetailReversePrompt(bookTaskDetailId: string, reversePromptId: string, data: Book.ReversePrompt): Promise<void> {
-    await this.InitService();
-    this.bookTaskDetailService.UpdateBookTaskDetailReversePrompt(bookTaskDetailId, reversePromptId, data)
-  }
-
-  /**
-   * 更行小说分镜的MJ消息，就是出图信息
-   * @param bookTaskDetailId 小说分镜的数据信息
-   * @param mjMessage 要保存到分镜信息
-   */
-  async UpdateBookTaskDetailMjMessage(bookTaskDetailId: string, mjMessage: Book.MJMessage) {
-    await this.InitService();
-    this.bookTaskDetailService.UpdateBookTaskDetailMjMessage(bookTaskDetailId, mjMessage)
-  }
-
+  AddBookTaskDetail = async (bookTaskDetail: Book.SelectBookTaskDetail) => await this.bookTaskDetailServiceBasic.AddBookTaskDetail(bookTaskDetail);
+  GetBookTaskDetailDataById = async (bookTaskDetailId: string) => await this.bookTaskDetailServiceBasic.GetBookTaskDetailDataById(bookTaskDetailId);
+  GetBookTaskDetailData = async (condition: Book.QueryBookTaskDetailCondition, returnEmpty: boolean = false) => await this.bookTaskDetailServiceBasic.GetBookTaskDetailData(condition, returnEmpty);
+  UpdateBookTaskDetail = async (bookTaskDetailId: string, data: Book.SelectBookTaskDetail) => await this.bookTaskDetailServiceBasic.UpdateBookTaskDetail(bookTaskDetailId, data);
+  UpdateBookTaskStatus = async (bookTaskDetailId: string, status: BookTaskStatus) => await this.bookTaskDetailServiceBasic.UpdateBookTaskStatus(bookTaskDetailId, status);
+  DeleteBookTaskDetailReversePromptById = async (bookTaskDetailId: string, reversePromptId: string) => await this.bookTaskDetailServiceBasic.DeleteBookTaskDetailReversePromptById(bookTaskDetailId);
+  DeleteBoookTaskDetailGenerateImage = async (bookTaskDetailId: string) => await this.bookTaskDetailServiceBasic.DeleteBoookTaskDetailGenerateImage(bookTaskDetailId);
+  UpdateBookTaskDetailReversePrompt = async (bookTaskDetailId: string, reversePromptId: string, data: Book.ReversePrompt) => await this.bookTaskDetailServiceBasic.UpdateBookTaskDetailReversePrompt(bookTaskDetailId, reversePromptId, data);
+  UpdateBookTaskDetailMjMessage = async (bookTaskDetailId: string, mjMessage: Book.MJMessage) => await this.bookTaskDetailServiceBasic.UpdateBookTaskDetailMjMessage(bookTaskDetailId, mjMessage);
 
   //#endregion
 
-  //#region 小说后台任务相关操作
+  //#region 后台任务
 
-  /**
-   * 添加一个后台任务
-   * @param bookId 小说ID
-   * @param taskType 后台任务类型
-   * @param executeType 执行的类型，是不是自动执行
-   * @param bookTaskId 小说批次任务ID
-   * @param bookTaskDetailId  小说批次任务分镜ID
-   * @param responseMessageName 消息名称
-   */
-  async AddBookBackTask(bookId: string,
+  AddBookBackTask = async (bookId: string,
     taskType: BookBackTaskType,
-    executeType = TaskExecuteType.AUTO,
-    bookTaskId = null,
-    bookTaskDetailId = null,
-    responseMessageName: string = null
-  ): Promise<TaskModal.Task> {
+    executeType: TaskExecuteType,
+    bookTaskId: string,
+    bookTaskDetailId: string,
+    responseMessageName: string) => await this.bookBackTaskServiceBasic.AddBookBackTask(bookId, taskType, executeType, bookTaskId, bookTaskDetailId, responseMessageName);
+
+  GetAllStatusTaskCount = async (status: BookBackTaskStatus[]) => await this.bookBackTaskServiceBasic.GetAllStatusTaskCount(status);
+  UpdateTaskStatus = async (bookBackTask: Book.UpdateBookTaskListStatus) => await this.bookBackTaskServiceBasic.UpdateTaskStatus(bookBackTask);
+  GiveUpNotStartBackTask = async () => await this.bookBackTaskServiceBasic.GiveUpNotStartBackTask();
 
-    await this.InitService();
-    let res = this.bookBackTaskListService.AddBookBackTask(bookId, taskType, executeType, bookTaskId, bookTaskDetailId, responseMessageName)
-    if (res.code == 0) {
-      throw new Error(res.message)
-    }
-    return res.data as TaskModal.Task
-  }
   //#endregion
-
-
-
-  /**
-  * 通过小说ID和小说批次任务ID获取小说和小说批次任务数据
-  * @param bookId 小说ID
-  * @param bookTaskName 小说批次的名字，或者是小说批次任务的ID
-  * @returns
-  */
-  async GetBookAndTask(bookId: string, bookTaskName: string) {
-    await this.InitService();
-    let book = this.bookService.GetBookDataById(bookId)
-    if (book == null) {
-      throw new Error("查找小说数据失败");
-    }
-    // 获取小说对应的批次任务数据，默认初始化为第一个
-    let condition = {
-      bookId: bookId
-    } as Book.QueryBookBackTaskCondition
-    if (bookTaskName == "output_00001") {
-      condition["name"] = bookTaskName
-    } else {
-      condition["id"] = bookTaskName
-    }
-    let bookTaskRes = this.bookTaskService.GetBookTaskData(condition)
-    if (bookTaskRes.data.bookTasks.length <= 0 || bookTaskRes.data.total <= 0) {
-      let msg = "没有找到对应的小说批次任务数据"
-      this.taskScheduler.AddLogToDB(bookId, book.type, msg, OtherData.DEFAULT, LoggerStatus.FAIL)
-      throw new Error(msg)
-    }
-    return { book: book as Book.SelectBook, bookTask: bookTaskRes.data.bookTasks[0] as Book.SelectBookTask }
-  }
-
-  /**
-   * 修改后台队列的状态
-   * @param bookBackTask 要修改的数据
-   */
-  async UpdateTaskStatus(bookBackTask: Book.UpdateBookTaskListStatus) {
-    await this.InitService();
-    this.bookBackTaskListService.UpdateTaskStatus(bookBackTask)
-  }
 }
+export { BookServiceBasic };

src/main/Service/ServiceBasic/bookTaskDetailServiceBasic.ts

@@ -0,0 +1,122 @@
+import { BookTaskDetailService } from "../../../define/db/service/Book/bookTaskDetailService";
+import { BookTaskStatus } from "../../../define/enum/bookEnum";
+import { Book } from "../../../model/book";
+import { BookTaskService } from "../../../define/db/service/Book/bookTaskService";
+
+export default class BookTaskDetailServiceBasic {
+  bookTaskDetailService: BookTaskDetailService
+  bookTaskService: BookTaskService
+  constructor() { }
+
+  private async InitService() {
+    if (!this.bookTaskDetailService) {
+      this.bookTaskDetailService = await BookTaskDetailService.getInstance()
+    }
+    if (!this.bookTaskService) {
+      this.bookTaskService = await BookTaskService.getInstance()
+    }
+  }
+
+  /**
+   * 添加小说任务详情数据
+   * @param bookTaskDetail 
+   */
+  async AddBookTaskDetail(bookTaskDetail: Book.SelectBookTaskDetail): Promise<void> {
+    await this.InitService();
+    this.bookTaskDetailService.AddBookTaskDetail(bookTaskDetail)
+  }
+
+  /**
+   * 获取指定的小说批次任务分镜数据，通过分镜ID
+   * @param bookTaskDetailId 小说批次任务分镜ID
+   * @returns
+   */
+  async GetBookTaskDetailDataById(bookTaskDetailId: string): Promise<Book.SelectBookTaskDetail> {
+    await this.InitService();
+    let bookTaskDetail = this.bookTaskDetailService.GetBookTaskDetailDataById(bookTaskDetailId)
+    if (bookTaskDetail == null) {
+      let msg = "未找到对应的小说批次任务分镜数据，请检查"
+      global.logger.error('BookServiceBasic_GetBookTaskDetailDataById', msg);
+      throw new Error("未找到对应的小说批次任务分镜数据，请检查")
+    }
+    return bookTaskDetail
+  }
+
+  /**
+   * 获取指定的小说批次任务分镜数据，通过查询条件
+   * @param condition
+   * @param returnEmpty 是否返回空数据，默认 false 不返回，如果返回空数据，会抛出异常
+   */
+  async GetBookTaskDetailData(condition: Book.QueryBookTaskDetailCondition, returnEmpty: boolean = false): Promise<Book.SelectBookTaskDetail[]> {
+    await this.InitService();
+    let bookTaskDetails = this.bookTaskDetailService.GetBookTaskData(condition)
+    if (!returnEmpty && bookTaskDetails.data.length <= 0) {
+      let msg = "未找到对应的小说批次任务分镜数据，请检查";
+      throw new Error(msg)
+    }
+    return bookTaskDetails.data
+  }
+
+  /**
+   * 修改小说的分镜详细数据，通过ID
+   * @param bookTaskDetailId 小说分镜的ID
+   * @param data 要修改的数据，是个对象，会修改全部
+   */
+  async UpdateBookTaskDetail(bookTaskDetailId: string, data: Book.SelectBookTaskDetail): Promise<Book.SelectBookTaskDetail> {
+    await this.InitService();
+    let res = this.bookTaskDetailService.UpdateBookTaskDetail(bookTaskDetailId, data)
+    return res
+  }
+
+  /**
+   * 更行小说批次的状态
+   * @param bookTaskId 小说批次的ID
+   * @param status 修改后的状态
+   * @param errorMsg 错误消息
+   */
+  async UpdateBookTaskStatus(bookTaskId: string, status: BookTaskStatus, errorMsg: string | null = null): Promise<void> {
+    await this.InitService();
+    this.bookTaskService.UpdateBookTaskStatus(bookTaskId, status, errorMsg);
+  }
+
+
+  /**
+   * 删除指定的小说分镜的反推提示词
+   * @param bookTaskDetail
+   */
+  async DeleteBookTaskDetailReversePromptById(bookTaskDetailId: string): Promise<void> {
+    await this.InitService();
+    this.bookTaskDetailService.DeleteBookTaskDetailReversePromptById(bookTaskDetailId)
+  }
+
+  /**
+   * 删除指定的小说分镜生成的图片
+   * @param bookTaskDetailId
+   */
+  async DeleteBoookTaskDetailGenerateImage(bookTaskDetailId: string): Promise<void> {
+    await this.InitService()
+    this.bookTaskDetailService.DeleteBoookTaskDetailGenerateImage(bookTaskDetailId);
+  }
+
+  /**
+   * 修改小说分镜数据的反推提示词
+   * @param bookTaskDetailId 小说分镜的ID
+   * @param reversePromptId 反推提示词的ID
+   * @param data 反推提示词数据
+   */
+  async UpdateBookTaskDetailReversePrompt(bookTaskDetailId: string, reversePromptId: string, data: Book.ReversePrompt): Promise<void> {
+    await this.InitService();
+    this.bookTaskDetailService.UpdateBookTaskDetailReversePrompt(bookTaskDetailId, reversePromptId, data)
+  }
+
+  /**
+   * 更行小说分镜的MJ消息，就是出图信息
+   * @param bookTaskDetailId 小说分镜的数据信息
+   * @param mjMessage 要保存到分镜信息
+   */
+  async UpdateBookTaskDetailMjMessage(bookTaskDetailId: string, mjMessage: Book.MJMessage) {
+    await this.InitService();
+    this.bookTaskDetailService.UpdateBookTaskDetailMjMessage(bookTaskDetailId, mjMessage)
+  }
+
+}

src/main/Service/ServiceBasic/bookTaskServiceBasic.ts

@@ -0,0 +1,118 @@
+import { BookTaskService } from "../../../define/db/service/Book/bookTaskService";
+import { Book } from "../../../model/book";
+import { BookService } from "../../../define/db/service/Book/bookService";
+
+export default class BookTaskServiceBasic {
+  bookTaskService: BookTaskService
+  bookService: BookService
+  constructor() { }
+
+  private async InitService() {
+    if (!this.bookTaskService) {
+      this.bookTaskService = await BookTaskService.getInstance()
+    }
+    if (!this.bookService) {
+      this.bookService = await BookService.getInstance()
+    }
+  }
+
+  /**
+   * 通过小说ID获取小说批次任务数据
+   * @param bookTaskId 小说批次任务ID
+   * @returns
+   */
+  async GetBookTaskDataById(bookTaskId: string): Promise<Book.SelectBookTask> {
+    await this.InitService();
+    let bookTask = this.bookTaskService.GetBookTaskDataById(bookTaskId);
+    if (bookTask == null) {
+      let msg = '未找到对应的小说批次任务数据，请检查';
+      throw new Error(msg);
+    }
+    return bookTask
+  }
+
+  /**
+   * 通过查询条件获取小说批次任务数据
+   * @param bookTaskCondition 小说批次的查询条件
+   */
+  async GetBookTaskData(bookTaskCondition: Book.QueryBookTaskCondition): Promise<{ bookTasks: Book.SelectBookTask[], total: number }> {
+    
+    await this.InitService();
+    let bookTasks = this.bookTaskService.GetBookTaskData(bookTaskCondition)
+    if (bookTasks.data.bookTasks.length <= 0 || bookTasks.data.total <= 0) {
+      throw new Error("未找到对应的小说批次任务数据，请检查")
+    }
+    return bookTasks.data
+  }
+
+  /**
+   * 获取最大的小说批次任务的编号
+   * @param bookId 小说ID
+   */
+  async GetMaxBookTaskNo(bookId: string): Promise<number> {
+    await this.InitService();
+    let maxNo = this.bookTaskService.realm
+      .objects('BookTask')
+      .filtered('bookId = $0', bookId)
+      .max('no')
+    let no = maxNo == null ? 1 : Number(maxNo) + 1
+    return no
+  }
+
+  /**
+   * 更新小说批次任务的数据
+   * @param bookTaskId 小说批次任务ID
+   * @param data
+   */
+  async UpdetedBookTaskData(bookTaskId: string, data: Book.SelectBookTask): Promise<void> {
+    await this.InitService();
+    this.bookTaskService.UpdetedBookTaskData(bookTaskId, data)
+  }
+
+  /**
+   * 重置小说批次任务的数据
+   * @param bookTaskId 指定的重置的小说批次任务的ID
+   */
+  async ResetBookTask(bookTaskId: string): Promise<void> {
+    await this.InitService();
+    this.bookTaskService.ResetBookTask(bookTaskId)
+  }
+
+  /**
+   * 删除指定的小说批次任务的数据
+   * @param bookTaskId 需要删除的指定的小说批次任务ID
+   */
+  async DeleteBookTaskData(bookTaskId: string): Promise<void> {
+    await this.InitService();
+    this.bookTaskService.DeleteBookTask(bookTaskId)
+  }
+
+  /**
+  * 通过小说ID和小说批次任务ID获取小说和小说批次任务数据
+  * @param bookId 小说ID
+  * @param bookTaskName 小说批次的名字，或者是小说批次任务的ID
+  * @returns
+  */
+  async GetBookAndTask(bookId: string, bookTaskName: string) {
+    await this.InitService();
+    let book = this.bookService.GetBookDataById(bookId)
+    if (book == null) {
+      throw new Error("查找小说数据失败");
+    }
+    // 获取小说对应的批次任务数据，默认初始化为第一个
+    let condition = {
+      bookId: bookId
+    } as Book.QueryBookBackTaskCondition
+    if (bookTaskName == "output_00001") {
+      condition["name"] = bookTaskName
+    } else {
+      condition["id"] = bookTaskName
+    }
+    let bookTaskRes = this.bookTaskService.GetBookTaskData(condition)
+    if (bookTaskRes.data.bookTasks.length <= 0 || bookTaskRes.data.total <= 0) {
+      let msg = "没有找到对应的小说批次任务数据"
+      throw new Error(msg)
+    }
+    return { book: book as Book.SelectBook, bookTask: bookTaskRes.data.bookTasks[0] as Book.SelectBookTask }
+  }
+}

src/main/Service/Subtitle/subtitle.ts

@@ -16,7 +16,7 @@ import fs from 'fs'
 import { GeneralResponse } from '../../../model/generalResponse'
 import { BookServiceBasic } from '../ServiceBasic/bookServiceBasic'
 import { LoggerStatus, OtherData, ResponseMessageType } from '../../../define/enum/softwareEnum'
-import { TaskScheduler } from '../taskScheduler'
+import { TaskScheduler } from '../task/taskScheduler'
 import { SubtitleModel } from '../../../model/subtitle'
 import { BookTaskStatus, OperateBookType } from '../../../define/enum/bookEnum'
 import axios from 'axios'

src/main/Service/Subtitle/subtitleService.ts

@@ -11,7 +11,7 @@ import fs from 'fs'
 import { CheckFileOrDirExist } from "../../../define/Tools/file";
 import { BookServiceBasic } from "../ServiceBasic/bookServiceBasic";
 import { Subtitle } from "./subtitle";
-import { TaskScheduler } from "../taskScheduler";
+import { TaskScheduler } from "../task/taskScheduler";
 import { BookTaskStatus, BookType, OperateBookType } from "../../../define/enum/bookEnum";
 import { Book } from "../../../model/book";
 import { TimeStringToMilliseconds } from "../../../define/Tools/time";
@@ -354,6 +354,15 @@ export class SubtitleService {
         bookTaskId: bookTaskId
       }, true)
 
+      debugger
+      // 获取SD设置
+      let sdConifg = JSON.parse(await fs.promises.readFile(define.sd_setting, 'utf-8'));
+      let adetailer = false;
+      if (sdConifg && sdConifg?.webui?.adetailer) {
+        adetailer = true;
+      }
+
+
       if (bookTaskDetails.length == 0) {
         // 新增
         for (let i = 0; i < copywritingData.length; i++) {
@@ -367,7 +376,9 @@ export class SubtitleService {
             word: element.word,
             afterGpt: element.after_gpt,
             subValue: JSON.stringify(element.subValue),
-            timeLimit: element.timeLimit
+            timeLimit: element.timeLimit,
+            // 新增修脸跟随
+            adetailer: adetailer
           })
         }
       } else {

src/main/Service/system/electronInterface.ts

@@ -0,0 +1,60 @@
+import { shell } from "electron";
+import { CheckFileOrDirExist } from "../../../define/Tools/file";
+import { errorMessage, successMessage } from "../../Public/generalTools";
+import path from 'path';
+
+
+/** 打开指定的文件夹的方法 */
+export type OpenFolderParams = {
+  /** 是不是基于项目文件，是的话，会在项目文件夹的基础上进行拼接 */
+  baseProject: boolean;
+  /** 判断是不是打开父文件夹 */
+  dirFloder: boolean;
+  /** 文件路径，baseProject 为false，需要设置完整的文件路径 */
+  folderPath: string;
+}
+
+/** 一些对electron接口的封装，配合业务逻辑 */
+export default class ElectronInterface {
+  constructor() { }
+
+  /**
+   * 打开指定的文件，试用默认的打开方式
+   * @param value 
+   * @returns 
+   */
+  public async OpenFile(value: string) {
+    if (await CheckFileOrDirExist(value)) {
+      return errorMessage('文件不存在', 'SystemIpc_OPEN_FILE')
+    }
+    await shell.openPath(value)
+  }
+  /**
+   * 打开对应的文件夹
+   * @param params 
+   * @returns 
+   */
+  public async OpenFolder(params: OpenFolderParams) {
+    try {
+      let openFolder = null
+      if (params.baseProject) {
+        openFolder = path.join(global.config.project_path, params.folderPath)
+      }
+      if (params.dirFloder) {
+        openFolder = path.dirname(params.folderPath)
+      }
+      if (!openFolder) {
+        openFolder = params.folderPath
+      }
+      // 判断文件夹是不是存在
+      let isExist = await CheckFileOrDirExist(openFolder)
+      if (!isExist) {
+        throw new Error('文件夹不存在，请检查')
+      }
+      shell.openPath(openFolder)
+      return successMessage(null, '打开成功')
+    } catch (error) {
+      return errorMessage('打开文件夹错误，错误信息如下：' + error.message, 'SystemIpc_OPEN_FOLDER')
+    }
+  }
+}

src/main/Service/system/systeminfo.ts

@@ -0,0 +1,113 @@
+import { define } from '../../../define/define';
+import { CheckFileOrDirExist } from '../../../define/Tools/file';
+import fs from "fs";
+import { errorMessage, successMessage } from '../../Public/generalTools';
+import { version } from '../../../../package.json';
+import { graphics } from 'systeminformation';
+import { machineId } from 'node-machine-id';
+import axios from 'axios';
+import { TaskManager } from '../task/taskManage';
+
+export default class SystemInfo {
+  constructor() { }
+  /**
+   * 获取系统的版本信息和显卡信息
+   * @returns 
+   */
+  public async GetViosionAndGpuMessage() {
+    try {
+      // 判断是不是又配置文件
+      let systemConfigPath = define.system_config;
+      if (!await CheckFileOrDirExist(systemConfigPath)) {
+        // 如果没有配置文件就创建一个
+        let systemConfig = {};
+        // 写入配置文件
+        await fs.promises.writeFile(systemConfigPath, JSON.stringify(systemConfig));
+      }
+      // 读取配置文件
+      let systemConfig = JSON.parse(await fs.promises.readFile(systemConfigPath, 'utf-8')) as SystemConfig.SystemConfig;
+      
+      if (systemConfig && systemConfig.gpu && systemConfig.gpu.name && systemConfig.gpu.updateTime) {
+        const currentDate = new Date(systemConfig.gpu.updateTime);
+        const nextDate = new Date(currentDate);
+        nextDate.setDate(currentDate.getDate() + 1);
+        if (systemConfig && systemConfig.gpu && nextDate > new Date()) {
+          global.gpu = systemConfig.gpu
+          return successMessage(version + ' ' + (global.gpu?.name ? global.gpu.name : ''), '获取成功')
+        }
+      }
+      
+      // 获取当前电脑的显卡信息
+      let da = await graphics()
+      for (let i = 0; i < da.controllers.length; i++) {
+        // 获取第一个英伟达或者是AMD的显卡信息
+        const element = da.controllers[i]
+        if (element.vendor.startsWith('NVIDIA')) {
+          global.gpu = element
+          global.gpu.type = 'NVIDIA'
+          break
+        } else if (element.vendor.startsWith('AMD') || element.vendor.startsWith('Advanced')) {
+          global.gpu = element
+          global.gpu.type = 'AMD'
+          break
+        } else {
+          global.gpu = {
+            name: 'OTHER'
+          }
+          global.gpu.type = 'OTHER'
+        }
+      }
+      // 更新配置文件
+      systemConfig.gpu = global.gpu
+      systemConfig.gpu.updateTime = new Date()
+      await fs.promises.writeFile(systemConfigPath, JSON.stringify(systemConfig));
+      return successMessage(version + '  ' + (global.gpu?.name ? global.gpu.name : ''), '获取成功')
+    } catch (error) {
+      return errorMessage('获取版本信息和显卡信息错误，错误信息如下：' + error.message, 'SystemIpc_GET_VISION_AND_GPU_MESSAGE')
+    }
+  }
+
+  /**
+   * 获取系统的机器码
+   */
+  public async GetMachineId() {
+    try {
+      let id = await machineId(true);
+      global.machineId = id;
+      return successMessage(id, '获取机器码成功')
+    } catch (error) {
+      return errorMessage('获取机器码错误，错误信息如下：' + error.message, 'SystemIpc_GET_MACHINE_ID')
+    }
+  }
+
+  /**
+   * 检查机器码的状态
+   * @param {*} value
+   * @returns
+ */
+  public async CheckMachineStatus(value: string) {
+    try {
+      // 判断机器码是不是存在
+      // let res = await axios.post('http://api.yu-zhile.com/GetMachineStatus', {
+      //   machineId: value
+      // })
+      // /lms/Machine/GetMachineStatus/{machineId}
+      // 
+      let res = await axios.get('https://lms.laitool.cn/lms/Machine/GetMachineStatus/' + value);
+      if (res.status != 200) {
+        throw new Error('请求错误')
+      }
+      if (res.data.code != 1) {
+        throw new Error(res.data.message)
+      }
+
+      global.endTime = res.data.endTime
+      global.permissions = res.data.permissions
+      global.CheckMachineId = true
+      return successMessage(res.data, '获取机器码状态成功')
+    } catch (error) {
+      return errorMessage('获取机器码状态错误，错误信息如下：' + error.message, 'SystemIpc_CHECK_MACHINE_STATUS')
+    }
+  }
+
+}

src/main/Service/task/backTaskService.ts

@@ -0,0 +1,47 @@
+import { BookBackTaskStatus } from "../../../define/enum/bookEnum";
+import { GeneralResponse } from "../../../model/generalResponse";
+import { errorMessage, successMessage } from "../../Public/generalTools";
+import { BookServiceBasic } from "../ServiceBasic/bookServiceBasic";
+import { TaskManager } from "./taskManage";
+
+export default class BackTaskService {
+  bookServiceBasic: BookServiceBasic
+  constructor() {
+    this.bookServiceBasic = new BookServiceBasic()
+  }
+
+  /**
+   * 获取指定状态的后台任务数量
+  */
+  public async GetAllStatusTaskCount(status: BookBackTaskStatus[]): Promise<GeneralResponse.ErrorItem | GeneralResponse.SuccessItem> {
+    try {
+
+      let res = await this.bookServiceBasic.GetAllStatusTaskCount(status)
+      return successMessage(res, '获取任务数量成功', 'BackTaskService_GetAllStatusTaskCount')
+    } catch (error) {
+      return errorMessage('获取任务数量失败，失败信息如下：' + error.toString(), 'BackTaskService_GetAllStatusTaskCount')
+    }
+  }
+
+  /**
+   * 启动后台任务，判断是不是丢弃，要是丢弃的话，先将等待任务全部丢弃
+   * @param isGiveUp 
+   */
+  public async StartBackTask(isGiveUp: boolean): Promise<GeneralResponse.ErrorItem | GeneralResponse.SuccessItem> {
+    try {
+      if (isGiveUp) {
+        await this.bookServiceBasic.GiveUpNotStartBackTask()
+      }
+
+      // 启动后台任务
+      // 这边初始化任务队列
+      if (!global.taskManager) {
+        global.taskManager = new TaskManager()
+        global.taskManager.InitListeners() // 启动监听
+      }
+      return successMessage(null, '启动后台任务成功', 'BackTaskService_StartBackTask')
+    } catch (error) {
+      return errorMessage('启动后台任务失败', 'BackTaskService_StartBackTask')
+    }
+  }
+}

src/main/Service/task/taskManage.ts

@@ -1,18 +1,18 @@
-import { BookBackTaskListService } from '../../define/db/service/Book/bookBackTaskListService'
-import { BookBackTaskStatus, BookBackTaskType, TaskExecuteType } from '../../define/enum/bookEnum'
-import { SoftwareService } from '../../define/db/service/SoftWare/softwareService'
-import { errorMessage, successMessage } from '../Public/generalTools'
-import { BasicReverse } from './Book/basicReverse'
-import { ReverseBook } from './Book/ReverseBook'
-import { GeneralResponse } from '../../model/generalResponse'
-import { DEFINE_STRING } from '../../define/define_string'
-import { MJOpt } from './MJ/mj'
-import { SDOpt } from './SD/sd'
-import { D3Opt } from './d3'
-import { FluxOpt } from './Flux/flux'
-import { AsyncQueue } from '../../main/quene'
-import { SoftWareServiceBasic } from './ServiceBasic/softwareServiceBasic'
-import { MJSetting } from '../../model/Setting/mjSetting'
+import { BookBackTaskListService } from '../../../define/db/service/Book/bookBackTaskListService'
+import { BookBackTaskStatus, BookBackTaskType, TaskExecuteType } from '../../../define/enum/bookEnum'
+import { SoftwareService } from '../../../define/db/service/SoftWare/softwareService'
+import { errorMessage, successMessage } from '../../Public/generalTools'
+import { BasicReverse } from '../Book/basicReverse'
+import { ReverseBook } from '../Book/ReverseBook'
+import { GeneralResponse } from '../../../model/generalResponse'
+import { DEFINE_STRING } from '../../../define/define_string'
+import { MJOpt } from '../MJ/mj'
+import { SDOpt } from '../SD/sd'
+import { D3Opt } from '../d3'
+import { FluxOpt } from '../Flux/flux'
+import { AsyncQueue } from '../../quene'
+import { SoftWareServiceBasic } from '../ServiceBasic/softwareServiceBasic'
+import { MJSetting } from '../../../model/Setting/mjSetting'
 
 export class TaskManager {
   isExecuting: boolean = false;
@@ -61,24 +61,6 @@ export class TaskManager {
     }
   }
 
-  async GetGlobalConfig() {
-    try {
-      await this.InitService();
-      let softData = this.softwareService.GetSoftwareData();
-      if (softData.data.length <= 0) {
-        throw new Error('获取软件数据失败');
-      }
-      let config = softData.data[0];
-      global.config = JSON.parse(config.globalSetting);
-      this.globalConfig = global.config;
-      return successMessage(global.config, '获取全局配置完成', 'TaskManager_GetGlobalConfig');
-    } catch (error) {
-      console.error('GetGlobalConfig Error:', error);
-      return errorMessage(`获取全局配置失败，失败信息如下：${error.message}`, 'TaskManager_GetGlobalConfig');
-    }
-  }
-
-
   // 初始化事件监听方法
   InitListeners() {
     if (this.isListening) return; // 如果已经在监听，直接返回
@@ -363,24 +345,5 @@ export class TaskManager {
       return errorMessage(`处理 ${task.type} 类型任务 ${task.name} 失败，失败信息如下：${error.message}`, 'TaskManager_handleTask');
     }
   }
-
-
   //#endregion
-
-  async AddTaskHandle(task: TaskModal.Task, isAdd = false) {
-    if (!isAdd) {
-      return;
-    }
-    if (task.type == BookBackTaskType.STORYBOARD) {
-      await this.basicReverse.AddCutVideoDataTask(task.bookId);
-    } else if (task.type == BookBackTaskType.SPLIT) {
-      await this.basicReverse.AddSplitAudioDataTask(task.bookId, task.bookTaskId);
-    } else if (task.type == BookBackTaskType.AUDIO) {
-      await this.basicReverse.AddGetFrameTask(task.bookId, task.bookTaskId);
-    } else if (task.type == BookBackTaskType.FRAME) {
-      await this.basicReverse.AddExtractSubtitlesDataTask(task.bookId, task.bookTaskId);
-    } else {
-      throw new Error('不支持的任务类型');
-    }
-  }
 }

src/main/Service/task/taskScheduler.ts

@@ -1,8 +1,8 @@
-import { LoggerService } from '../../define/db/service/SoftWare/loggerService'
-import { DEFINE_STRING } from '../../define/define_string'
-import { LoggerStatus, OtherData } from '../../define/enum/softwareEnum'
-import { successMessage, errorMessage } from '../Public/generalTools'
-import { GeneralResponse } from '../../model/generalResponse'
+import { LoggerService } from '../../../define/db/service/SoftWare/loggerService'
+import { DEFINE_STRING } from '../../../define/define_string'
+import { LoggerStatus, OtherData } from '../../../define/enum/softwareEnum'
+import { successMessage, errorMessage } from '../../Public/generalTools'
+import { GeneralResponse } from '../../../model/generalResponse'
 
 export class TaskScheduler {
   constructor() { }

src/main/Service/watermark.ts

@@ -13,7 +13,7 @@ import { define } from '../../define/define'
 import { LOGGER_DEFINE } from '../../define/logger_define'
 import axios from 'axios'
 import { Base64ToFile, GetImageBase64 } from '../../define/Tools/image'
-import { TaskScheduler } from './taskScheduler';
+import { TaskScheduler } from './task/taskScheduler';
 import { LoggerStatus, OtherData, ResponseMessageType } from '../../define/enum/softwareEnum';
 import { basicApi } from '../../api/apiBasic';
 import { FfmpegOptions } from './ffmpegOptions';

src/main/Service/writing.ts

@@ -92,6 +92,7 @@ export class Writing extends ServiceBase {
       apiKey: aiData.api_key,
       word: word
     }
+
     var myHeaders = new Headers();
     myHeaders.append("User-Agent", "Apifox/1.0.0 (https://apifox.com)");
     myHeaders.append("Content-Type", "application/json");
@@ -102,7 +103,7 @@ export class Writing extends ServiceBase {
       body: JSON.stringify(body),
     };
 
-    let resData = oldData;
+    let resData = '\n\n';
     return new Promise((resolve, reject) => {
       fetch(define.serverUrl + "/api/Forward/ForwardWordStream", requestOptions)
         .then(response => {
@@ -126,7 +127,7 @@ export class Writing extends ServiceBase {
                   const text = new TextDecoder().decode(value);
                   resData += text
                   // 将数据返回前端
-                  global.newWindow[0].win.webContents.send(DEFINE_STRING.GPT.GPT_STREAM_RETURN, resData)
+                  global.newWindow[0].win.webContents.send(DEFINE_STRING.GPT.GPT_STREAM_RETURN, oldData + resData)
                   controller.enqueue(value); // 可选：将数据块放入流中
                   push();
                 }).catch(err => {
@@ -182,7 +183,7 @@ export class Writing extends ServiceBase {
   async ActionStart(setting, word) {
     try {
       await this.InitService()
-      console.log(setting, word)
+      // console.log(setting, word)
       if (isEmpty(setting.gptType)) {
         throw new Error('请选择GPT类型')
       }
@@ -217,7 +218,6 @@ export class Writing extends ServiceBase {
       if (setting.isSplit) {
         // 这边拆分文案
         let spiltWord = await this.SplitWord(word, setting.splitNumber)
-        console.log(spiltWord)
         for (let i = 0; i < spiltWord.length; i++) {
           const element = spiltWord[i];
           if (setting.isStream) {
@@ -243,6 +243,7 @@ export class Writing extends ServiceBase {
       }
       // let tasks =
 
+      // console.log("ActionStart", result);
       // ExecuteConcurrently
       return successMessage(result, "执行文案相关任务成功", 'Writing_ActionStart');
     } catch (error) {

src/main/func.js

@@ -9,7 +9,6 @@ const { v4: uuidv4 } = require('uuid'); // 引入UUID库来生成唯一标识符
 const EventEmitter = require('events');
 import { define } from "../define/define";
 import axios from "axios";
-const { machineId } = require('node-machine-id')
 import { DEFINE_STRING } from "../define/define_string";
 import { ClipDraft } from "./Public/clipDraft";
 import { Tools } from "./tools";
@@ -882,25 +881,6 @@ async function DeleteImageTaskList(value) {
 
 }
 
-/**
- * 获取指定的机械码
- */
-async function GetMachineId() {
-    try {
-        let id = await machineId(true);
-        global.machineId = id;
-        return {
-            code: 1,
-            value: id
-        }
-    } catch (error) {
-        return {
-            code: 0,
-            message: error.toString()
-        }
-    }
-}
-
 
 /**
  * 获取不想要的提示词
@@ -1127,7 +1107,6 @@ export const func = {
     DeleteVideoConfig,
     AddImageTask,
     DeleteImageTaskList,
-    GetMachineId,
     GetBadPrompt,
     SaveBadPrompt,
     DeleteBadPrompt,

src/main/index.js

@@ -1,7 +1,5 @@
 import fspromises from 'fs/promises'
 import { v4 as uuidv4 } from 'uuid'
-import { version } from '../../package.json'
-import { graphics } from 'systeminformation'
 
 import { app, shell, BrowserWindow, ipcMain, dialog, nativeTheme, session } from 'electron'
 import path, { join } from 'path'
@@ -16,7 +14,7 @@ import { ImageGenerate } from './ReverseManage/imageGenerate.js'
 import { Setting } from './setting/setting.js'
 import { has, isEmpty } from 'lodash'
 import { AutoSync } from './setting/autoSync.js'
-import { TaskManager } from './Service/taskManage'
+import { TaskManager } from './Service/task/taskManage'
 import { SoftWareServiceBasic } from './Service/ServiceBasic/softwareServiceBasic'
 
 // ipc
@@ -301,32 +299,6 @@ ipcMain.handle(DEFINE_STRING.ADD_DRAFT, async (event, value) => {
   return res
 })
 
-// 获取当前版本
-ipcMain.handle(DEFINE_STRING.GET_VERSION, async (event) => {
-  // 获取当前电脑的显卡信息
-  let da = await graphics()
-  for (let i = 0; i < da.controllers.length; i++) {
-    // 获取第一个英伟达或者是AMD的显卡信息
-    const element = da.controllers[i]
-    if (element.vendor.startsWith('NVIDIA')) {
-      global.gpu = element
-      global.gpu.type = 'NVIDIA'
-      break
-    } else if (element.vendor.startsWith('AMD') || element.vendor.startsWith('Advanced')) {
-      global.gpu = element
-      global.gpu.type = 'AMD'
-      break
-    } else {
-      global.gpu = {
-        name: 'OTHER'
-      }
-      global.gpu.type = 'OTHER'
-    }
-  }
-
-  return version + '  ' + (global.gpu?.name ? global.gpu.name : '')
-})
-
 // 监听保存SD配置
 ipcMain.handle(DEFINE_STRING.SAVE_SD_CONFIG, async (event, value) => await func.SaveSDConfig(value))
 
@@ -372,9 +344,6 @@ ipcMain.handle(
   async (event, value) => await func.DeleteImageTaskList(value)
 )
 
-// 监听获取加密的机械码任务
-ipcMain.handle(DEFINE_STRING.GET_MACHINE_ID, async (event, value) => await func.GetMachineId())
-
 // 监听获取不想要的提示词任务
 ipcMain.handle(DEFINE_STRING.GET_BAD_PROMPT, async (event) => await func.GetBadPrompt())
 

src/main/setting/setting.js

@@ -9,7 +9,7 @@ import { ImageSetting } from '../../define/setting/imageSetting'
 import { DEFINE_STRING } from '../../define/define_string'
 import { TagDefine } from '../../define/tagDefine'
 import { errorMessage } from '../Public/generalTools'
-import { TaskManager } from '../Service/taskManage'
+import { TaskManager } from '../Service/task/taskManage'
 import { SoftWareServiceBasic } from '../Service/ServiceBasic/softwareServiceBasic'
 import { FLxuAPIImageType } from '../../define/enum/image'
 
@@ -270,45 +270,6 @@ export class Setting {
     }
   }
 
-  /**
-   * 检查机器码是不是存在
-   * @param {*} value
-   * @returns
-   */
-  async CheckMachineId(value) {
-    try {
-      // 判断机器码是不是存在
-      let res = await axios.post('http://api.yu-zhile.com/GetMachineStatus', {
-        machineId: value
-      })
-
-      // let res = await axios.get('http://lapi.laitool.cn/api/Machine/GetMachineStatus?machineId=' + value);
-      if (res.status != 200) {
-        throw new Error('请求错误')
-      }
-      if (res.data.code == 0) {
-        throw new Error(res.data.message)
-      }
-
-      this.global.endTime = res.data.endTime
-      this.global.permissions = res.data.permissions
-      this.global.CheckMachineId = true
-      // 这边初始化任务队列
-      if (!global.taskManager) {
-        global.taskManager = new TaskManager()
-        global.taskManager.InitListeners() // 启动监听
-      }
-      return {
-        code: 1
-      }
-    } catch (error) {
-      return {
-        code: 0,
-        message: error.toString()
-      }
-    }
-  }
-
   /**
    * 获取选择角色场景模式的options
    * @returns

src/model/Setting/systemConfig.d.ts

@@ -0,0 +1,16 @@
+declare namespace SystemConfig {
+
+  /** 软件读取的系统信息，都是存储在这边 */
+  type SystemConfig = {
+    gpu: GpuMessage
+  }
+
+  /** GPU信息 */
+  type GpuMessage = {
+    name?: string;
+    type?: string;
+    vender?: string;
+    updateTime?: Date;
+  }
+
+}

src/model/system.d.ts

@@ -0,0 +1,6 @@
+
+declare namespace SystemModel {
+
+
+
+}

src/preload/index.js

@@ -5,7 +5,7 @@ import { discord } from './discord.js'
 import { mj } from './mj.js'
 import { sd } from './sd'
 import { img } from './img.js'
-import { system } from './system.js'
+import { system } from './system'
 import { setting } from './setting.js'
 import { prompt } from './prompt.js'
 import { book } from './book'
@@ -21,8 +21,6 @@ import { task } from './task'
 let events = []
 const api = {
   //#region 基础状态
-  // 获取版本信息
-  GetVersion: async (callback) => callback(await ipcRenderer.invoke(DEFINE_STRING.GET_VERSION)),
   //#endregion
   // 保存通用设置
   ModifySampleSetting: async (value, callback) =>
@@ -231,12 +229,6 @@ const api = {
     ipcRenderer.send(DEFINE_STRING.SHOW_NEW_WINDOW, value)
   },
 
-  // 获取机械码
-  GetMachineId: async (callback) => {
-    let res = await ipcRenderer.invoke(DEFINE_STRING.GET_MACHINE_ID)
-    callback(res)
-  },
-
   // 获取ADetalier配置列表
   GetADetailerList: async (callback) => {
     let res = await ipcRenderer.invoke(DEFINE_STRING.GET_ADETAILER_LIST)

src/preload/system.js

@@ -1,14 +0,0 @@
-import { ipcRenderer } from "electron"
-import { DEFINE_STRING } from "../define/define_string"
-
-
-const system = {
-    // 打开指定的文件
-    OpenFile: async (value, callback) => callback(ipcRenderer.send(DEFINE_STRING.SYSTEM.OPEN_FILE, value)),
-
-    // 打开指定的文件夹
-    OpenFolder: (value) => ipcRenderer.invoke(DEFINE_STRING.OPEN_FOLDER, value),
-}
-export {
-    system
-}

src/preload/system.ts

@@ -0,0 +1,19 @@
+import { ipcRenderer } from 'electron'
+import { DEFINE_STRING } from '../define/define_string'
+
+const system = {
+  /**打开指定的文件 */
+  OpenFile: async (value, callback) =>
+    callback(ipcRenderer.send(DEFINE_STRING.SYSTEM.OPEN_FILE, value)),
+  /** 打开指定的文件夹 */
+  OpenFolder: (value) => ipcRenderer.invoke(DEFINE_STRING.OPEN_FOLDER, value),
+  /** 获取软件的版本信息，和电脑的GPU信息，24小时只获取一次 */
+  GetViosionAndGpuMessage: () => ipcRenderer.invoke(DEFINE_STRING.SYSTEM.GET_VISION_AND_GPU_MESSAGE),
+  /** 获取系统的机器码 */
+  GetMachineId: () => ipcRenderer.invoke(DEFINE_STRING.SYSTEM.GET_MACHINE_ID),
+  /** 检查机器码状态 */
+  CheckMachineStatus: (value: string) => ipcRenderer.invoke(DEFINE_STRING.SYSTEM.CHECK_MACHINE_STATUS, value)
+
+  
+}
+export { system }

src/preload/task.ts

@@ -1,8 +1,15 @@
 import { ipcRenderer } from 'electron'
 import { DEFINE_STRING } from '../define/define_string'
-import { BookBackTaskType, TaskExecuteType } from '../define/enum/bookEnum'
+import { BookBackTaskStatus, BookBackTaskType, TaskExecuteType } from '../define/enum/bookEnum'
 
 const task = {
+
+  /**
+   * 启动后台任务，判断是不是丢弃，要是丢弃的话，先将等待任务全部丢弃
+   * @param isGiveUp 
+   * @returns 
+   */
+  StartBackTask: async (isGiveUp: boolean) => await ipcRenderer.invoke(DEFINE_STRING.TASK.START_BACK_TASK, isGiveUp),
   /**
    * 添加单个任务
    * @param bookId 小说ID
@@ -20,12 +27,14 @@ const task = {
     responseMessageName: string = null) =>
     await ipcRenderer.invoke(DEFINE_STRING.TASK.ADD_BOOK_BACK_TASK, bookId, taskType, executeType, bookTaskId, bookTaskDetailId, responseMessageName),
 
-
   /**
-   * 同时太你家多个任务
+   * 同时添加多个任务
    * @param task 
    */
   AddMultiBookBackTask: async (task: TaskModal.Task[]) =>
     await ipcRenderer.invoke(DEFINE_STRING.TASK.ADD_MULTI_BOOK_BACK_TASK, task),
+
+  /** 获取等待中的任务 */
+  GetAllStatusTaskCount: async (value: BookBackTaskStatus[]) => await ipcRenderer.invoke(DEFINE_STRING.TASK.GET_ALL_STATUS_TASK_COUNT, value),
 }
 export { task }

src/renderer/src/App.vue

@@ -44,7 +44,7 @@ export default defineComponent({
     let softwareStore = useSoftwareStore()
 
     onMounted(async () => {
-      debugger
+      
       softwareStore.SoftColor = SoftColor
       window.api.getSettingDafultData(async (value) => {
         await window.darkMode.toggle(value.theme)

src/renderer/src/components/APIService/ApiService.vue

@@ -18,9 +18,9 @@ export default defineComponent({
     onMounted(() => {
       const webview = document.getElementById('lai-api')
       if (webview) {
-        debugger
+        
         const handleNewWindow = (event) => {
-          debugger
+          
           event.preventDefault()
           alert(123)
           const protocol = new URL(event.url).protocol

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

@@ -250,7 +250,7 @@ async function imageDragOver(e) {
 }
 
 async function ModifyLock() {
-  debugger
+  
   if (!data.value.imageLock) {
     // 锁定之前，判断是不是有
     if (!outImagePath.value) {

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

@@ -83,7 +83,6 @@ export default defineComponent({
      * 提示词菜单下拉操作
      */
     async function ReverseSelect(key) {
-      debugger
       switch (key) {
         case 'remove_reverse': // 删除反推提示词
           let res = await window.book.ResetGptReverseData(
@@ -162,7 +161,6 @@ export default defineComponent({
 
     // 处理批次的翻译
     function TranslateBatchParams(from, to) {
-      debugger
       let translateData = []
       for (let i = index.value; i < reverseManageStore.selectBookTaskDetail.length; i++) {
         const element = reverseManageStore.selectBookTaskDetail[i]
@@ -208,7 +206,6 @@ export default defineComponent({
 
     // 单句翻译
     async function TranslateOne(key) {
-      debugger
       let translateData = []
       switch (key) {
         case 'translate_english':
@@ -243,7 +240,6 @@ export default defineComponent({
      * 重选反推提示词
      */
     async function SelectReversePrompt() {
-      debugger
       // 判断当前是不是又反推提示词
       if (!data.value.reversePrompt || data.value.reversePrompt.length <= 0) {
         message.error('当前没有反推提示词')

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

@@ -114,7 +114,7 @@ export default defineComponent({
         style: `width : ${dialogWidth}px; height : ${dialogHeight}px`,
         maskClosable: false,
         onClose: async () => {
-          debugger
+          
           console.log(selectStyleRef)
           // 将数据保存到当前的数据中
           // reverseManageStore.selectBookTask.styleList = toRaw(selectStyleRef.value.selectStyle)

src/renderer/src/components/Book/Components/ImportWord/ImportWordAndSrt.vue

@@ -61,7 +61,7 @@ export default defineComponent({
   setup(props) {
     let hh = props.height
     let maxHeight = props.height - 80
-    debugger
+    
     let data = ref(JSON.parse(JSON.stringify(props.initData)))
     const message = useMessage()
     let dialog = useDialog()
@@ -210,7 +210,7 @@ export default defineComponent({
         style: `width : ${dialogWidth}px; min-height : ${dialogHeight}px`,
         maskClosable: false,
         onClose: async () => {
-          debugger
+          
           console.log(wenkeRef.value.word)
           let word = wenkeRef.value.data
           if (word == null || word == '') {
@@ -565,7 +565,7 @@ export default defineComponent({
           })
         }
       } else if (type.value == 'mj_reverse' || type.value == 'sd_reverse') {
-        debugger
+        
         if (data.value.length != reverseManageStore.selectBookTaskDetail.length) {
           message.error('检测到导入的字幕数据和分镜对不上，请先对齐')
           return

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

@@ -188,7 +188,7 @@ export default defineComponent({
 
       // 选择MP4文件夹
       await window.api.SelectFile(ext, (value) => {
-        debugger
+        
         if (value.code == 0) {
           message.error(value.message)
           return
@@ -227,7 +227,7 @@ export default defineComponent({
       oldVideoPath: {
         required: true,
         validator(rule, value) {
-          debugger
+          
           if (isEmpty(value)) {
             // 判断是不是原创，原创不能选择视频文件，反推必选
             if (
@@ -253,7 +253,7 @@ export default defineComponent({
           message.error('请检查必填字段')
           return
         }
-        debugger
+        
         loading.value = true
         let res = await reverseManageStore.SaveSelectBook(cloneDeep(reverseManageStore.selectBook))
         loading.value = false
@@ -286,7 +286,7 @@ export default defineComponent({
      */
     async function OpenFolder(param) {
       let res = null
-      debugger
+      
       if (param == 'imageFolder') {
         res = await window.system.OpenFolder({
           folderPath: reverseManageStore.selectBook.imageFolder,

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

@@ -108,7 +108,7 @@ async function DeleteBookData(e) {
     negativeText: '取消',
     onPositiveClick: async () => {
       da?.destroy()
-      debugger
+      
       softwareStore.spin.spinning = true
       softwareStore.spin.tip = '正在删除小说数据。。。'
       let res = await window.book.DeleteBookData(book.value.id)
@@ -117,7 +117,7 @@ async function DeleteBookData(e) {
         message.error(res.message)
         return
       }
-      debugger
+      
       // 这边直接把数据删除了就行
       reverseManageStore.bookData = reverseManageStore.bookData.filter(
         (item) => item.id != book.value.id

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

@@ -48,7 +48,7 @@ export default defineComponent({
 
   props: ['bookTask'],
   setup(props) {
-    debugger
+    
     let message = useMessage()
     let dialog = useDialog()
     let bookTask = ref(props.bookTask)
@@ -63,7 +63,7 @@ export default defineComponent({
      * @param e
      */
     async function ReSetBookTaskDetail(e) {
-      debugger
+      
       e.stopPropagation()
       dialog.warning({
         title: '重置小说任务',
@@ -171,7 +171,7 @@ export default defineComponent({
      */
     async function ClipDraft(e) {
       e.stopPropagation()
-      debugger
+      
       dialog.info({
         closeOnEsc: false,
         title: '生成草稿前检查',

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

@@ -103,7 +103,7 @@ export default defineComponent({
      */
     async function DataTableStripedUpdate() {
       // 修改数据
-      debugger
+      
       // 直接提交修改
       let res = await softwareStore.SaveSoftware()
       console.log(res)
@@ -115,7 +115,7 @@ export default defineComponent({
 
     // 选择下拉菜单
     async function SelectDropdown(key) {
-      debugger
+      
       console.log(key)
       softwareStore.softWare.reverse_data_table_size = key
       // 直接提交修改

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

@@ -16,7 +16,7 @@ import { ref, onMounted, defineComponent, onUnmounted, toRaw, nextTick, watchEff
 import { useMessage, NLog } from 'naive-ui'
 import Artplayer from '../../../Components/Artplayer.vue'
 import { useReverseManageStore } from '../../../../../../stores/reverseManage.ts'
-import { DEFINE_STRING } from '../../../../../../define/define_string.ts'
+import { DEFINE_STRING } from '../../../../../../define/define_string'
 
 export default defineComponent({
   components: { Artplayer, NLog },
@@ -47,7 +47,7 @@ export default defineComponent({
     onMounted(async () => {
       // 监听返回的日志数据
       window.api.setEventListen([DEFINE_STRING.SYSTEM.RETURN_LOGGER], (value) => {
-        debugger
+        debuger
         if (value.code == 0) {
           message.error('添加日志输出失败，但是不影响使用')
           logger.value += value.message + '\n'

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

@@ -73,7 +73,7 @@ export default defineComponent({
   props: ['bookTask', 'type'],
   setup(props) {
     let bookTask = ref(props.bookTask)
-    debugger
+    
     let type = ref(props.type)
     let backgroundMusicOptions = ref([])
     let message = useMessage()
@@ -133,7 +133,7 @@ export default defineComponent({
         bookTask.value.id,
         OperateBookType.BOOKTASK
       )
-      debugger
+      
       if (res.code == 0) {
         message.error(res.message)
       } else {

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

@@ -657,7 +657,7 @@ export default defineComponent({
      * @param to 目标语言
      */
     async function TranslateService(from, to) {
-      debugger
+      
       let translateData = []
       for (let i = 0; i < reverseManageStore.selectBookTaskDetail.length; i++) {
         const element = reverseManageStore.selectBookTaskDetail[i]
@@ -743,7 +743,7 @@ export default defineComponent({
 
       let tempData = []
       for (let i = 0; i < reverseManageStore.selectBookTaskDetail.length; i++) {
-        debugger
+        
         const element = reverseManageStore.selectBookTaskDetail[i]
         tempData.push({
           no: element.no,

src/renderer/src/components/Book/Components/PresetLibrary/AddCharacterTag.vue

@@ -50,6 +50,7 @@
             >
           </div>
         </n-form-item>
+        <div style="color: red;">注意：人物提示词（英文）才是实际合并的提示词数据，请和出图的提示词语言保持一致（中文或英文）</div>
         <n-form-item label="人物提示词（英文）" path="prompt">
           <n-input
             type="textarea"

src/renderer/src/components/Book/Components/PresetLibrary/AddSceneTags.vue

@@ -27,6 +27,7 @@
           >翻译提示词</n-button
         >
       </n-form-item>
+      <div style="color: red;">注意：场景提示词描述（英文） 才是实际合并的提示词数据，请和出图的提示词语言保持一致（中文或英文）</div>
       <n-form-item label="场景提示词描述（英文）" path="prompt">
         <n-input
           type="textarea"

src/renderer/src/components/Book/Components/PresetLibrary/AddStyleTags.vue

@@ -36,6 +36,7 @@
           </n-tooltip>
         </div>
       </n-form-item>
+      <div style="color: red;">注意：风格提示词描述（英文） 才是实际合并的提示词数据，请和出图的提示词语言保持一致（中文或英文）</div>
       <n-form-item label="风格提示词描述（英文）" path="prompt">
         <n-input
           type="textarea"
@@ -247,7 +248,7 @@ export default defineComponent({
       }
       imageLoading.value = true
       await window.sd.txt2img(JSON.stringify([d]), async (value) => {
-        debugger
+        
         if (value.code == 0) {
           message.error(value.message)
           imageLoading.value = false

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

@@ -51,7 +51,7 @@ export default defineComponent({
 
     // 做个计算属性
     let showReversePrompt = computed(() => {
-      debugger
+      
       let res = []
       for (let i = 0; i < data.value.reversePrompt?.length; i++) {
         let item = data.value.reversePrompt[i]

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

@@ -133,7 +133,7 @@ export default defineComponent({
     ]
 
     onMounted(async () => {
-      debugger
+      
       calcHeight()
 
       setTimeout(() => {
@@ -155,7 +155,7 @@ export default defineComponent({
     })
 
     function calcHeight() {
-      debugger
+      
       // 视口的高度
       let height = window.innerHeight
       maxHeight.value = height - 120

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

@@ -82,7 +82,7 @@ export default defineComponent({
         }
         pagination.value.pageCount = res_count
 
-        debugger
+        
         // 开始获取批次任务
         let bookTask = await reverseManageStore.GetBookTaskDataFromDB({
           bookId: reverseManageStore.selectBook.id
@@ -99,7 +99,7 @@ export default defineComponent({
     async function InitData() {
       try {
         // 初始化数据
-        debugger
+        
         await GetBookByCondition()
       } catch (error) {
         message.error(error.message)

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

@@ -43,7 +43,7 @@ export default defineComponent({
   },
 
   setup() {
-    debugger
+    
     let message = useMessage()
     let softwareStore = useSoftwareStore()
     let reverseManageStore = useReverseManageStore()

src/renderer/src/components/Book/ManageBookTask.vue

@@ -105,7 +105,7 @@ export default defineComponent({
           width: 215,
           fixed: 'right',
           render(row, index) {
-            debugger
+            
             return h(BookTaskListAction, {
               bookTask: row
             })

src/renderer/src/components/Book/Original/ODataTableCharacterAndScene.vue

@@ -132,7 +132,7 @@ onMounted(() => {})
 let UpdateCharacterTagsDebounced = debounce(UpdateCharacterTags, 500)
 
 async function UpdateCharacterTags(character, index) {
-  debugger
+  
   // 开始保存，获取所有的选中的人物
   let checkedCharacterTags = characterTags.value
     .filter((item) => item.checked)
@@ -154,7 +154,7 @@ async function UpdateCharacterTags(character, index) {
 
 let UpdateSceneTagsDebounced = debounce(UpdateSceneTags, 500)
 async function UpdateSceneTags(scene, index) {
-  debugger
+  
   console.log('1233', scene, index)
   // 开始保存，获取所有的选中的场景
   let checkedSceneTags = sceneTags.value.filter((item) => item.checked).map((item) => item.id)

src/renderer/src/components/Book/Original/ODataTableHeaderGptPrompt.vue

@@ -288,7 +288,7 @@ async function SelectStyle() {
     style: `width : ${dialogWidth}px; height : ${dialogHeight}px`,
     maskClosable: false,
     onClose: async () => {
-      debugger
+      
       console.log(selectStyleRef)
       // 将数据保存到当前的数据中
       // reverseManageStore.selectBookTask.styleList = toRaw(selectStyleRef.value.selectStyle)

src/renderer/src/components/Book/Original/ODatatablePrompt.vue

@@ -178,7 +178,7 @@ async function SingleGenerateImage() {
 
 // 下生图
 async function NextGenerateImage() {
-  debugger
+  
   let res = undefined
   let bookTaskDetails = reverseManageStore.selectBookTaskDetail.filter(
     (item, index) => index >= props.index && !item.imageLock

src/renderer/src/components/Book/Original/OriginalMainButton.vue

@@ -165,7 +165,7 @@ async function CharacterLibrary() {
   let dialogWidth = window.innerWidth * 0.6
   let dialogHeight = window.innerHeight * 0.9
   let word = '' // 这边要拼接一下word
-  debugger
+  
   let temp_arr = []
   for (let i = 0; i < reverseManageStore.selectBookTaskDetail.length; i++) {
     const element = reverseManageStore.selectBookTaskDetail[i]
@@ -235,7 +235,7 @@ async function ResetGPTPrompt() {
     onPositiveClick: async () => {
       da?.destroy()
       softwareStore.spin.spinning = true
-      debugger
+      
       softwareStore.spin.tip = '正在重置推理提示词，请稍后。。。'
       let res = await window.book.ResetGptReverseData(
         reverseManageStore.selectBookTask.id,
@@ -373,7 +373,7 @@ async function GetPromptAll() {
  * @param {Boolean} cover - 是否覆盖现有图像
  */
 async function AddFluxImageAll(type, cover) {
-  debugger
+  
   let messageName = DEFINE_STRING.BOOK.FLUX_API_IMAGE_GENERATE_RETURN
   let taskType = BookBackTaskType.FLUX_API_IMAGE
   if (type == BookImageCategory.FLUX_FORGE) {

src/renderer/src/components/Book/Original/OriginalMainDatatable.vue

@@ -96,7 +96,6 @@ const createColumns = ({}) => {
       className: 'empty-margin',
       fixed: 'left',
       render(row, index) {
-        console.log('row', row, index)
         return h(DatatableAfterGpt, { initData: row, index: index })
       }
     },

src/renderer/src/components/Book/ReverseManage.vue

@@ -31,7 +31,7 @@ export default defineComponent({
     onMounted(() => {})
 
     onUnmounted(() => {
-      debugger
+      
       reverseManageStore.selectBookTaskDetail = undefined
     })
 

src/renderer/src/components/Components/CheckMachineId.vue

@@ -2,7 +2,12 @@
   <div style="height: 200px">
     <div style="height: 40px"></div>
     <div style="display: flex">
-      <n-input :disabled="true" v-model:value="machineId" type="text" placeholder="唯一码" />
+      <n-input
+        :disabled="true"
+        v-model:value="systemStore.machineId"
+        type="text"
+        placeholder="唯一码"
+      />
       <n-popover trigger="click">
         <template #trigger>
           <n-button text style="width: 24px; font-size: 24px; color: skyblue; display: flex; heigh">
@@ -14,7 +19,23 @@
         <span>VX：xiangbie88</span>
       </n-popover>
     </div>
-    <div style="color: red; margin: 10px">
+    <div style="margin: 10px">
+      <strong>怎么激活？ --> </strong>
+      <strong
+        style="color: #e18a3b; margin-left: 10px"
+        @click="OpenTeach('activate')"
+        class="url_class"
+        >软件激活教程 -->
+      </strong>
+      <strong
+        style="margin-left: 10px; color: #ea5514"
+        @click="OpenTeach('lms')"
+        class="url_class"
+      >
+        后台入口
+      </strong>
+    </div>
+    <!-- <div style="margin: 10px; color: red">
       如未激活，将上面的码给管理员激活
       <n-popover trigger="hover" raw :show-arrow="false">
         <template #trigger>
@@ -26,7 +47,7 @@
           preview-disabled
         />
       </n-popover>
-    </div>
+    </div> -->
     <div style="margin: 10px; font-size: large; color: red">
       教程视频：<span class="url_class" @click="OpenTeach('video')">向北-LAITool</span>
     </div>
@@ -39,62 +60,46 @@
   </div>
 </template>
 
-<script>
+<script setup>
 import { defineComponent, ref, h, onMounted, toRaw } from 'vue'
 import { useMessage, NInput, NButton, NIcon, NPopover, NImage, NTag } from 'naive-ui'
 import { InformationCircle } from '@vicons/ionicons5'
+import { useSystemStore } from '../../../../stores/system'
 
-export default defineComponent({
-  components: {
-    NInput,
-    NButton,
-    NIcon,
-    InformationCircle,
-    NPopover,
-    NImage,
-    NTag
-  },
-  setup() {
-    let machineId = ref('')
-    let message = useMessage()
+let machineId = ref('')
+let message = useMessage()
+const systemStore = useSystemStore()
 
-    onMounted(async () => {
-      // 获取机械码
-      await window.api.GetMachineId((value) => {
-        if (value.code == 0) {
-          message.error(value.message)
-          return
-        }
-        machineId.value = value.value
-      })
-    })
+onMounted(async () => {})
 
-    function OpenTeach(type) {
-      switch (type) {
-        case 'doc':
-          window.api.OpenUrl(
-            'https://rvgyir5wk1c.feishu.cn/docx/RZYCdG7ZpoKsIzxBEzccNEIFn8f?from=from_copylink'
-          )
-          break
-        case 'video':
-          window.api.OpenUrl('https://space.bilibili.com/110586931')
-        default:
-          break
-      }
-    }
-
-    function OpenQueDoc() {
+function OpenTeach(type) {
+  switch (type) {
+    case 'doc':
       window.api.OpenUrl(
-        'https://pvwu1oahp5m.feishu.cn/sheets/G5s3sX0KahH1XQtWDazcF70anUb?from=from_copylink'
+        'https://rvgyir5wk1c.feishu.cn/docx/RZYCdG7ZpoKsIzxBEzccNEIFn8f?from=from_copylink'
       )
-    }
-    return {
-      machineId,
-      OpenQueDoc,
-      OpenTeach
-    }
+      break
+    case 'video':
+      window.api.OpenUrl('https://space.bilibili.com/110586931')
+      break
+    case 'activate':
+      window.api.OpenUrl(
+        'https://rvgyir5wk1c.feishu.cn/docx/RNijdu3w4o4tRlxBhdccWhRpnfg?from=from_copylink'
+      )
+      break
+    case "lms" : 
+      window.api.OpenUrl('https://lms.laitool.cn')
+      break
+    default:
+      break
   }
-})
+}
+
+function OpenQueDoc() {
+  window.api.OpenUrl(
+    'https://pvwu1oahp5m.feishu.cn/sheets/G5s3sX0KahH1XQtWDazcF70anUb?from=from_copylink'
+  )
+}
 </script>
 
 <style>

src/renderer/src/components/Components/SelectImageStyle.vue

@@ -208,14 +208,14 @@ export default defineComponent({
 
     // 初始化选中的数据
     async function InitStyleData() {
-      debugger
+      
       if (!props.imageStyle || !props.customizeImageStyle) {
         return
       }
       selectStyle.value = []
       // 开始初始化
       await window.api.GetImageStyleInfomation(JSON.stringify(props.imageStyle), (value) => {
-        debugger
+        
         if (value.code == 0) {
           message.error(value.message)
           return
@@ -276,7 +276,7 @@ export default defineComponent({
     }
 
     async function closeTag(image) {
-      debugger
+      
       let index = selectStyle.value.findIndex((item) => item.id == image.id)
       if (index != -1) {
         selectStyle.value.splice(index, 1)

src/renderer/src/components/Components/ShowImageTag.vue

@@ -56,7 +56,7 @@ export default defineComponent({
     onMounted(async () => {})
 
     async function closeTag(image) {
-      debugger
+      
       let index = selectStyle.value.findIndex((item) => item.id == image.id)
       if (index != -1) {
         selectStyle.value.splice(index, 1)

src/renderer/src/components/CopyWriting/CopyWriting.vue

@@ -75,10 +75,16 @@
         />
       </div>
     </div>
+    <div style="display: flex; justify-content: flex-end; align-items: center; margin-right: 20px">
+      <n-button type="primary" @click="FormatOutput()"> 格式化 </n-button>
+      <div style="color: red; margin-left: 5px">
+        注意：由于GPT输出的格式化有太多的不确定，不一定可以完全格式，需要手动检查
+      </div>
+    </div>
   </div>
 </template>
 
-<script>
+<script setup>
 import { ref, onMounted, defineComponent, onUnmounted, toRaw, watch, h } from 'vue'
 import {
   useMessage,
@@ -98,192 +104,184 @@ import { useSoftwareStore } from '../../../../stores/software'
 import { isEmpty } from 'lodash'
 import { DEFINE_STRING } from '../../../../define/define_string'
 
-export default defineComponent({
-  components: {
-    NForm,
-    NFormItem,
-    NInput,
-    NSelect,
-    NButton,
-    NIcon,
-    SettingsOutline,
-    NCheckbox,
-    NInputNumber
-  },
-  setup() {
-    let message = useMessage()
-    let dialog = useDialog()
-    let formValue = ref({
-      gptType: undefined,
-      gptData: undefined,
-      gptAI: undefined,
-      isStream: true,
-      isSplit: false,
-      splitNumber: 1000
-    })
-    let oldWord = ref(undefined)
-    let newWord = ref(undefined)
-    let gptTypeOptions = ref([])
-    let gptDataOptions = ref([])
-    let gptAllData = undefined
-    let formRef = ref(null)
-    let gptOptions = ref([
-      { label: 'LAI API', value: 'laiapi' },
-      { label: 'KIMI', value: 'kimi' },
-      { label: 'DouBao', value: 'doubao' }
-    ])
-    let softwareStore = useSoftwareStore()
-    let allPromptDataOptions = ref([])
+let message = useMessage()
+let dialog = useDialog()
+let formValue = ref({
+  gptType: undefined,
+  gptData: undefined,
+  gptAI: undefined,
+  isStream: true,
+  isSplit: false,
+  splitNumber: 1000
+})
+let oldWord = ref('')
+let newWord = ref('')
+let gptTypeOptions = ref([])
+let gptDataOptions = ref([])
+let gptAllData = undefined
+let formRef = ref(null)
+let gptOptions = ref([
+  { label: 'LAI API', value: 'laiapi' },
+  { label: 'KIMI', value: 'kimi' }
+])
+let softwareStore = useSoftwareStore()
+let allPromptDataOptions = ref([])
 
-    // 加载服务端数据
-    async function InitServerGptOptions() {
-      let gptRes = await window.gpt.InitServerGptOptions()
-      if (gptRes.code == 0) {
-        message.error(gptRes.message)
-        return
-      }
-      gptAllData = gptRes.data
-      // 处理数据
-      gptTypeOptions.value = gptRes.data.promptType.map((item) => {
-        return { label: item.name, value: item.id }
-      })
+// 加载服务端数据
+async function InitServerGptOptions() {
+  let gptRes = await window.gpt.InitServerGptOptions()
+  if (gptRes.code == 0) {
+    message.error(gptRes.message)
+    return
+  }
+  gptAllData = gptRes.data
+  // 处理数据
+  gptTypeOptions.value = gptRes.data.promptType.map((item) => {
+    return { label: item.name, value: item.id }
+  })
 
-      gptDataOptions.value = gptRes.data.promptData.map((item) => {
-        return { label: item.name, value: item.id }
-      })
-      allPromptDataOptions.value = gptRes.data.promptData
-    }
+  gptDataOptions.value = gptRes.data.promptData.map((item) => {
+    return { label: item.name, value: item.id }
+  })
+  allPromptDataOptions.value = gptRes.data.promptData
+}
 
-    function debounce(func, wait) {
-      let timeoutId
-      let shouldExecute = true
+function debounce(func, wait) {
+  let timeoutId
+  let shouldExecute = true
 
-      return function (...args) {
-        const context = this
-        if (shouldExecute) {
-          func.apply(context, args)
-          shouldExecute = false
-          timeoutId = setTimeout(() => {
-            shouldExecute = true
-          }, wait)
-        } else {
-          clearTimeout(timeoutId)
-          timeoutId = setTimeout(() => {
-            shouldExecute = true
-          }, wait)
-        }
-      }
-    }
-
-    let UpdateWord = debounce((value) => {
-      newWord.value = value
-    }, 500)
-
-    onMounted(async () => {
-      await InitServerGptOptions()
-      // 这边监听流式返回数据
-      window.api.setEventListen([DEFINE_STRING.GPT.GPT_STREAM_RETURN], (value) => {
-        UpdateWord(value)
-      })
-    })
-
-    onUnmounted(() => {
-      window.api.removeEventListen(DEFINE_STRING.GPT.GPT_STREAM_RETURN)
-    })
-
-    let ruleObj = (errorMessage) => {
-      return [
-        {
-          required: true,
-          validator(rule, value) {
-            if (value == null || value == '') return new Error(errorMessage)
-            return true
-          },
-          trigger: ['input', 'blur', 'change']
-        }
-      ]
-    }
-
-    let rules = {
-      gptAI: ruleObj('必选提示词类型'),
-      gptData: ruleObj('必选提示词预设'),
-      gptType: ruleObj('必填提示词AI')
-    }
-
-    /**
-     * AI设置相关
-     */
-    async function AISetting() {
-      // 判断当前数据是不是存在
-      // 处理数据。获取当前的所有的数据
-      let dialogWidth = 800
-      let dialogHeight = 600
-      dialog.create({
-        title: 'AI设置',
-        showIcon: false,
-        closeOnEsc: false,
-        content: () => h(ManageAISetting, { type: formValue.value.gptAI }),
-        style: `width : ${dialogWidth}px; min-height : ${dialogHeight}px`,
-        maskClosable: false,
-        onClose: async () => {}
-      })
-    }
-
-    /**
-     * 开始执行GPT
-     */
-    async function ActionStart() {
-      // 检查是不是有数据
-      if (
-        isEmpty(formValue.value.gptType) ||
-        isEmpty(formValue.value.gptData) ||
-        isEmpty(formValue.value.gptAI)
-      ) {
-        message.error('请选择完整的数据')
-        return
-      }
-      softwareStore.spin.spinning = true
-      softwareStore.spin.tip = '生成中......'
-      let res = await window.write.ActionStart(toRaw(formValue.value), oldWord.value)
-      softwareStore.spin.spinning = false
-      if (res.code == 0) {
-        message.error(res.message)
-        softwareStore.spin.spinning = false
-        return
-      }
-      newWord.value = res.data
-    }
-
-    /**
-     * 选择的提示词类型发生变化时，删选提示词预设
-     * @param value
-     * @param options
-     */
-    async function UpdateSelectPromptType(value, options) {
-      gptDataOptions.value = allPromptDataOptions.value
-        .filter((item) => {
-          return item.promptTypeId == value
-        })
-        .map((item) => {
-          return { label: item.name, value: item.id }
-        })
-    }
-
-    return {
-      formValue,
-      gptTypeOptions,
-      gptDataOptions,
-      UpdateSelectPromptType,
-      oldWord,
-      newWord,
-      rules,
-      formRef,
-      AISetting,
-      gptOptions,
-      softwareStore,
-      ActionStart,
-      allPromptDataOptions
+  return function (...args) {
+    const context = this
+    if (shouldExecute) {
+      func.apply(context, args)
+      shouldExecute = false
+      timeoutId = setTimeout(() => {
+        shouldExecute = true
+      }, wait)
+    } else {
+      clearTimeout(timeoutId)
+      timeoutId = setTimeout(() => {
+        shouldExecute = true
+      }, wait)
     }
   }
+}
+
+let UpdateWord = debounce((value) => {
+  newWord.value = value
+}, 300)
+
+onMounted(async () => {
+  await InitServerGptOptions()
+  // 这边监听流式返回数据
+  window.api.setEventListen([DEFINE_STRING.GPT.GPT_STREAM_RETURN], (value) => {
+    UpdateWord(value)
+  })
 })
+
+onUnmounted(() => {
+  window.api.removeEventListen(DEFINE_STRING.GPT.GPT_STREAM_RETURN)
+})
+
+let ruleObj = (errorMessage) => {
+  return [
+    {
+      required: true,
+      validator(rule, value) {
+        if (value == null || value == '') return new Error(errorMessage)
+        return true
+      },
+      trigger: ['input', 'blur', 'change']
+    }
+  ]
+}
+
+async function FormatOutput() {
+  let splitData = newWord.value.split('\n').filter((item) => {
+    return !isEmpty(item)
+  })
+  let isNumberedFormat = (str) => {
+    return /^\d+\./.test(str)
+  }
+  let isTextFormat = (str) => {
+    return /^【文本】/.test(str)
+  }
+  let type = undefined
+
+  splitData = splitData.map((item) => {
+    if (isNumberedFormat(item)) {
+      type = 'startNumber'
+      return item.replace(/^\d+\./, '')
+    } else if (isTextFormat(item)) {
+      type = 'startText'
+      return item.replace('&【', '\n【')
+    } else {
+      return item
+    }
+  })
+  if (type == 'startNumber') {
+    newWord.value = splitData.join('\n')
+  } else {
+    newWord.value = splitData.join('\n\n')
+  }
+}
+
+/**
+ * AI设置相关
+ */
+async function AISetting() {
+  // 判断当前数据是不是存在
+  // 处理数据。获取当前的所有的数据
+  let dialogWidth = 800
+  let dialogHeight = 600
+  dialog.create({
+    title: 'AI设置',
+    showIcon: false,
+    closeOnEsc: false,
+    content: () => h(ManageAISetting, { type: formValue.value.gptAI }),
+    style: `width : ${dialogWidth}px; min-height : ${dialogHeight}px`,
+    maskClosable: false,
+    onClose: async () => {}
+  })
+}
+
+/**
+ * 开始执行GPT
+ */
+async function ActionStart() {
+  // 检查是不是有数据
+  if (
+    isEmpty(formValue.value.gptType) ||
+    isEmpty(formValue.value.gptData) ||
+    isEmpty(formValue.value.gptAI)
+  ) {
+    message.error('请选择完整的数据')
+    return
+  }
+  softwareStore.spin.spinning = true
+  softwareStore.spin.tip = '生成中......'
+  let res = await window.write.ActionStart(toRaw(formValue.value), oldWord.value)
+  softwareStore.spin.spinning = false
+  if (res.code == 0) {
+    message.error(res.message)
+    softwareStore.spin.spinning = false
+    return
+  }
+  newWord.value = res.data
+}
+
+/**
+ * 选择的提示词类型发生变化时，删选提示词预设
+ * @param value
+ * @param options
+ */
+async function UpdateSelectPromptType(value, options) {
+  gptDataOptions.value = allPromptDataOptions.value
+    .filter((item) => {
+      return item.promptTypeId == value
+    })
+    .map((item) => {
+      return { label: item.name, value: item.id }
+    })
+}
 </script>

src/renderer/src/components/CopyWriting/ManageAISetting.vue

@@ -17,7 +17,7 @@
         <n-input v-model:value="aiSetting.laiapi.model" type="text" placeholder="请输入Model" />
       </div>
     </n-card>
-    <n-card title="豆包设置">
+    <!-- <n-card title="豆包设置">
       <div style="display: flex">
         <n-input
           v-model:value="aiSetting.doubao.gpt_url"
@@ -37,7 +37,7 @@
           placeholder="请输入豆包的模型"
         />
       </div>
-    </n-card>
+    </n-card> -->
     <n-card title="KIMI设置">
       <div style="display: flex">
         <n-input
@@ -86,7 +86,7 @@ export default defineComponent({
     })
 
     onMounted(async () => {
-      debugger
+      
       // 获取AIsetting
       let res = await window.gpt.GetAISetting()
       if (res.code == 0) {

src/renderer/src/components/Home/Home.vue

@@ -1,33 +1,36 @@
 <template>
-  <n-space vertical>
-    <n-layout has-sider style="height: 100vh; position: relative">
-      <n-layout-sider
-        bordered
-        collapse-mode="width"
-        :collapsed-width="64"
-        :width="220"
-        :collapsed="collapsed"
-        show-trigger
-        @collapse="collapsed = true"
-        @expand="collapsed = false"
-        style="position: relative"
-      >
-        <n-menu
-          :collapsed="collapsed"
+  <n-spin :show="show">
+    <n-space vertical>
+      <n-layout has-sider style="height: 100vh; position: relative">
+        <n-layout-sider
+          bordered
+          collapse-mode="width"
           :collapsed-width="64"
-          :collapsed-icon-size="22"
-          :options="menuOptions"
-          :render-icon="renderMenuIcon"
-          :expand-icon="expandIcon"
+          :width="220"
+          :collapsed="collapsed"
+          show-trigger
+          @collapse="collapsed = true"
+          @expand="collapsed = false"
+          style="position: relative"
         >
-        </n-menu>
-      </n-layout-sider>
-      <n-layout-content content-style="padding: 5px 5px 5px 10px; height:100%">
-        <!-- <Setting></Setting> -->
-        <router-view></router-view>
-      </n-layout-content>
-    </n-layout>
-  </n-space>
+          <n-menu
+            :collapsed="collapsed"
+            :collapsed-width="64"
+            :collapsed-icon-size="22"
+            :options="menuOptions"
+            :render-icon="renderMenuIcon"
+            :expand-icon="expandIcon"
+          >
+          </n-menu>
+        </n-layout-sider>
+        <n-layout-content content-style="padding: 5px 5px 5px 10px; height:100%">
+          <!-- <Setting></Setting> -->
+          <router-view></router-view>
+        </n-layout-content>
+      </n-layout>
+    </n-space>
+    <template #description> 你不知道你有多幸运 </template>
+  </n-spin>
 </template>
 
 <script>
@@ -47,7 +50,8 @@ import {
   NSwitch,
   NButton,
   NFloatButton,
-  NBadge
+  NBadge,
+  NSpin
 } from 'naive-ui'
 
 import {
@@ -67,6 +71,9 @@ import InputDialogContent from '../Original/Components/InputDialogContent.vue'
 import APIIcon from '../Icon/APIIcon.vue'
 import BackTaskIcon from '../Icon/BackTaskIcon.vue'
 import BackTask from '../Components/BackTask/BackTask.vue'
+import { useSystemStore } from '../../../../stores/system'
+import { TimeDelay } from '../../../../define/Tools/time'
+import { BookBackTaskStatus } from '../../../../define/enum/bookEnum'
 
 export default defineComponent({
   components: {
@@ -82,7 +89,8 @@ export default defineComponent({
     APIIcon,
     NFloatButton,
     NBadge,
-    Layers
+    Layers,
+    NSpin
   },
   setup() {
     let collapsed = ref(false)
@@ -90,9 +98,12 @@ export default defineComponent({
     let machineRef = ref()
     let message = useMessage()
     let notification = useNotification()
+    let show = ref(true)
+    const systemStore = useSystemStore()
 
     let key_down_ref = ref(null)
 
+    // 菜单列表图标渲染
     function renderMenuIcon(option) {
       if (option.key === 'sheep-man') return true
       if (option.key === 'food') return null
@@ -115,12 +126,121 @@ export default defineComponent({
         )
       if (option.key == 'TTS_Services') return h(NIcon, null, { default: () => h(RadioOutline) })
     }
+    // 启动后台任务
+    async function StartBackTask(isGiveUp) {
+      let startRes = await window.task.StartBackTask(isGiveUp)
+      if (startRes.code == 0) {
+        message.error(startRes.message)
+      } else {
+        message.success(startRes.message)
+      }
+    }
+
+    /** 判断是不是还是后台任务，用户确认是不是丢弃 */
+    async function CheckWaitTask() {
+      await TimeDelay(1000)
+      let getWaitTaskCountRes = await window.task.GetAllStatusTaskCount([
+        BookBackTaskStatus.WAIT,
+        BookBackTaskStatus.RECONNECT
+      ])
+      // 报错，默认丢弃
+      if (getWaitTaskCountRes.code == 0) {
+        message.error(getWaitTaskCountRes.message)
+        await StartBackTask(true)
+        return
+      }
+      if (getWaitTaskCountRes.data && getWaitTaskCountRes.data > 0) {
+        // 这边提示用户是否丢弃
+        dialog.warning({
+          title: '后台任务',
+          content: `检测到后台未完成的任务，任务数量为 ${getWaitTaskCountRes.data}，请选择操作！`,
+          positiveText: '继续执行',
+          negativeText: '丢弃所有',
+          onPositiveClick: async () => {
+            // 启动任务
+            await StartBackTask(false)
+          },
+          onNegativeClick: async () => {
+            // 丢弃任务
+            await StartBackTask(true)
+          }
+        })
+      } else {
+        // 启动任务
+        await StartBackTask(true)
+      }
+    }
+
+    /** 校验机器码的逻辑 */
+    async function GetMachineStatus() {
+      try {
+        // 获取机械码
+        const machineRes = await window.system.GetMachineId()
+        if (machineRes.code == 0) {
+          message.error(machineRes.message)
+          return
+        }
+        systemStore.machineId = machineRes.data
+
+        const checkMachineSatatusRes = await window.system.CheckMachineStatus(machineRes.data)
+        if (checkMachineSatatusRes.code == 1) {
+          // 自动检测成功，不同在弹窗手动进入
+          message.success('自动检测机器码成功')
+          // 判断是不是又后台任务
+          await CheckWaitTask()
+          return
+        } else {
+          message.error('自动检测机器码失败，请手动确认')
+        }
+
+        // 这边是调用手动检测机器码
+        // 弹窗，获取机器码
+        const da = dialog.create({
+          showIcon: false,
+          content: () => h(CheckMachineId, { ref: machineRef }),
+          style: `width : 400px; height: 300px`,
+          maskClosable: false,
+          positiveText: '确定',
+          onClose: () => {
+            // 关闭程序
+            window.api.QuitApp()
+            return false
+          },
+          onEsc: () => {
+            // 关闭程序
+            window.api.QuitApp()
+            return false
+          },
+          onPositiveClick: async () => {
+            const checkMachineSatatusRes = await window.system.CheckMachineStatus(machineRes.data)
+            if (checkMachineSatatusRes.code == 1) {
+              // 自动检测成功，不同在弹窗手动进入
+              message.success('机器码校验成功')
+              da.destroy()
+              // 判断是不是又后台任务
+              await CheckWaitTask()
+            } else {
+              message.error(checkMachineSatatusRes.message)
+              return false
+            }
+          }
+        })
+      } catch (error) {
+        message.error('获取机器状态码失败，请联系管理员，错误信息如下：' + error.toString())
+      } finally {
+        show.value = false
+      }
+    }
 
     onMounted(async () => {
       // 加载版本
-      await window.api.GetVersion((value) => {
-        document.title = 'LAITool ' + value
-      })
+      let res = await window.system.GetViosionAndGpuMessage()
+      console.log(res)
+      if (res.code == 1) {
+        document.title = 'LAITool ' + res.data
+      } else {
+        message.success(res.message)
+      }
 
       // 添加监听事件，同时按下ctrl + alt + l 打开控制台
       window.addEventListener('keydown', (e) => {
@@ -215,36 +335,7 @@ export default defineComponent({
         }
       })
 
-      // 弹窗，获取机器码
-      dialog.create({
-        showIcon: false,
-        content: () => h(CheckMachineId, { ref: machineRef }),
-        style: `width : 400px; height: 300px`,
-        maskClosable: false,
-        positiveText: '确定',
-        onClose: () => {
-          // 关闭程序
-          window.api.QuitApp()
-          return false
-        },
-        onEsc: () => {
-          // 关闭程序
-          window.api.QuitApp()
-          return false
-        },
-        onPositiveClick: async () => {
-          await new Promise(async (resolve, reject) => {
-            await window.api.CheckMachineId(toRaw(machineRef.value.machineId), (value) => {
-              if (value.code == 0) {
-                message.error(value.message)
-                reject()
-              } else {
-                resolve()
-              }
-            })
-          })
-        }
-      })
+      await GetMachineStatus()
 
       window.api.getSettingDafultData(async (value) => {
         window.config = value
@@ -546,7 +637,9 @@ export default defineComponent({
       menuOptions,
       expandIcon,
       OpneBackTask,
-      collapsed
+      collapsed,
+      show,
+      systemStore
     }
   }
 })

src/renderer/src/components/Original/Components/AddStyleTags.vue

@@ -247,7 +247,7 @@ export default defineComponent({
       }
       imageLoading.value = true
       await window.sd.txt2img(JSON.stringify([d]), async (value) => {
-        debugger
+        
         if (value.code == 0) {
           message.error(value.message)
           imageLoading.value = false

src/renderer/src/components/Original/Components/DataTableShowGenerateImage.vue

@@ -386,7 +386,7 @@ export default defineComponent({
         negativeText: '取消',
         onPositiveClick: async () => {
           if (data.value.mj_message) {
-            debugger
+            
             // 加判断
             // 只要状态不是success 和 error ，其他的都重新获取
             if (data.value.mj_message.status == 'error') {

src/renderer/src/components/Original/Components/ImportWordAndSrt.vue

@@ -207,7 +207,7 @@ export default defineComponent({
         style: `width : ${dialogWidth}px; min-height : ${dialogHeight}px`,
         maskClosable: false,
         onClose: async () => {
-          debugger
+          
           console.log(wenkeRef.value.word)
           let word = wenkeRef.value.data
           if (word == null || word == '') {

src/renderer/src/components/Original/DataTable.vue

@@ -752,7 +752,7 @@ export default defineComponent({
      * @param {*} row
      */
     async function NextGenerateImage(row, ca = 'sd') {
-      debugger
+      
       let index = data.value.findIndex((item) => item.id == row.id)
       let tempData = []
       for (let i = index; i < data.value.length; i++) {
@@ -851,7 +851,7 @@ export default defineComponent({
      */
     async function TranslateAll(key, index = -1) {
       // 将中文翻译成英文
-      debugger
+      
       if (key == 'english') {
         let tmp_d = []
         for (let i = 0; i < data.value.length; i++) {

src/renderer/src/components/Original/MainPage.vue

@@ -146,11 +146,11 @@ export default defineComponent({
           message.error(value.message)
           return
         }
-        debugger
+        
         console.log(value.value)
         // 拿到提示词文件地址，然后还是获取
         await window.pmpt.OpenPromptFileTxt(value.value, (res) => {
-          debugger
+          
           console.log(res)
           if (res.code == 0) {
             message.error(res.message)
@@ -165,7 +165,7 @@ export default defineComponent({
               positiveText: '继续',
               negativeText: '取消',
               onPositiveClick: async () => {
-                debugger
+                
                 // 开始导入
                 for (let i = 0; i < data.value.length && i < res.data.length; i++) {
                   const element = res.data[i]

src/renderer/src/components/Original/MenuButton.vue

@@ -217,7 +217,7 @@ export default defineComponent({
      * 生成所有的图片
      */
     async function GenerateImageAll() {
-      debugger
+      
       let tmpData = cloneDeep(toRaw(data.value))
       tmpData = tmpData.filter((item) => {
         return item.imageLock == null || item.imageLock == false
@@ -363,11 +363,11 @@ export default defineComponent({
           message.error(value.message)
           return
         }
-        debugger
+        
         console.log(value.value)
         // 拿到提示词文件地址，然后还是获取
         await window.pmpt.OpenPromptFileTxt(value.value, (res) => {
-          debugger
+          
           console.log(res)
           if (res.code == 0) {
             message.error(res.message)
@@ -382,7 +382,7 @@ export default defineComponent({
               positiveText: '继续',
               negativeText: '取消',
               onPositiveClick: async () => {
-                debugger
+                
                 // 开始导入
                 for (let i = 0; i < data.value.length && i < res.data.length; i++) {
                   const element = res.data[i]

src/renderer/src/components/Setting/Components/ManageRemoteMjAccount.vue

@@ -118,13 +118,13 @@ export default defineComponent({
   },
   setup() {
     let message = useMessage()
-    debugger
+    
     let settingStore = useSettingStore()
     let addRef = ref(null)
     let loading = ref(false)
 
     onMounted(async () => {
-      debugger
+      
       console.log(settingStore)
     })
     let rules = {
@@ -137,7 +137,7 @@ export default defineComponent({
      * 创建账号
      */
     async function CreateAccount(e) {
-      debugger
+      
       e.preventDefault()
       addRef.value?.validate(async (errors) => {
         if (errors) {

src/renderer/src/components/Setting/MJSetting.vue

@@ -289,7 +289,7 @@ export default defineComponent({
 
     // 初始化现在设置的数据
     async function InitData() {
-      debugger
+      
       // 获取到的是当前的配置信息
       let res = await window.setting.GetMJSettingTreeData()
       if (res.code == 0) {
@@ -360,7 +360,7 @@ export default defineComponent({
     onMounted(async () => {
       // 监听浏览器设置的中信息
       window.api.setEventListen([DEFINE_STRING.DISCORD.OPERATE_REFRASH_DISCORD_URL], (value) => {
-        debugger
+        
         if (value.code == 0) {
           message.error(value.message)
           return
@@ -412,7 +412,7 @@ export default defineComponent({
      */
     async function SaveMjSetting(e) {
       // 在保存的时候要进行数据保存
-      debugger
+      
       e.preventDefault()
       sampleRef.value?.validate(async (errors) => {
         if (errors) {

src/renderer/src/components/Setting/TranslateSetting.vue

@@ -144,8 +144,8 @@ export default defineComponent({
      * 保存翻译设置
      */
     async function SaveTranslateSetting() {
-      debugger
-      // 判断当前选中的数据是不是设置完善
+      
+      //判断当前选中的数据是不是设置完善
       let selectModel = translateSetting.value.selectModel
       let settingIndex = translateSetting.value.translates.findIndex(
         (item) => item.name == selectModel

src/renderer/src/components/TTS/EdgeTTS.vue

@@ -73,7 +73,7 @@ export default defineComponent({
      * 切换角色的时候，修改角色的配置
      */
     function ChangeCharacter(value) {
-      debugger
+      
       let role = roleOptions.value.find(
         (item) => item.value === value
       )

src/renderer/src/components/TTS/TTSHistory.vue

@@ -73,7 +73,7 @@ async function handlePageChange(currentPage) {
 
 async function handleUpdateRow(row, index) {
   if (row == null) {
-    debugger
+    
     // data.value.splice(index, 1)
     // 直接重新加载吧
     await GetTTSHistoryData(pagination.page)

src/renderer/src/components/TTS/TTSHome.vue

@@ -140,7 +140,7 @@ export default defineComponent({
     let audioUrl = ref(null)
 
     onMounted(async () => {
-      debugger
+      
       ttsOptions.value = GetTTSSelect()
 
       // 加载服务端的TTS配置（目前的TTS配置是全局的）
@@ -276,7 +276,7 @@ export default defineComponent({
         message.error(generateRes.message)
         return
       }
-      debugger
+      
       audioUrl.value = generateRes.mp3Path
       softwareStore.spin.spinning = false
     }

src/renderer/src/components/VideoSubtitle/VideoCanvas.vue

@@ -366,7 +366,7 @@ export default defineComponent({
         })
         return
       }
-      debugger
+      
       GetCurrentFrameTextLodding.value = true
       if (
         type.value == SubtitleSavePositionType.MAIN_VIDEO ||

src/renderer/src/components/Watermark/GetWaterMaskRectangle.vue

@@ -341,7 +341,7 @@ export default defineComponent({
      * 回撤
      */
     async function undo() {
-      debugger
+      
       if (step <= 0) {
         // 如果没有可以撤销的步骤，就清空画布
         imageContext.value.clearRect(
@@ -411,7 +411,7 @@ export default defineComponent({
      * 查看效果
      */
     async function Check() {
-      debugger
+      
       // 判断当前是不是有蒙板
       if (canvasHistory.length == 0) {
         message.error('请先选择去水印的区域')
@@ -446,7 +446,7 @@ export default defineComponent({
     }
 
     async function SaveMask() {
-      debugger
+      
       // 判断当前是不是又蒙板
       if (canvasHistory.length <= 0) {
         message.error('请先选择去水印的区域')

src/renderer/src/components/Watermark/ImageFileSelect.vue

@@ -43,7 +43,7 @@ export default defineComponent({
     }
 
     async function selectImage(value) {
-      debugger
+      
       let img = await getBase64(value.file.file)
       props.modifyImage(img)
     }

src/stores/reverseManage.ts

@@ -65,7 +65,7 @@ export const useReverseManageStore = defineStore('reverseManage', {
      */
     async GetBookDataFromDB(condition) {
       try {
-        debugger
+        
         //@ts-ignore
         let res = await window.book.GetBookData(condition)
         if (res.code == 0) {
@@ -85,7 +85,7 @@ export const useReverseManageStore = defineStore('reverseManage', {
     // 获取小说任务数据
     async GetBookTaskDataFromDB(condition) {
       try {
-        debugger
+        
         this.bookTaskData = []
         //@ts-ignore
         let res = await window.book.GetBookTaskData(condition)
@@ -203,7 +203,7 @@ export const useReverseManageStore = defineStore('reverseManage', {
           //@ts-ignore
           save_res = await window.book.AddOrModifyBook({ ...book })
         }
-        debugger
+        
         if (save_res.code == 0) {
           throw new Error(save_res.message)
         }

src/stores/software.ts

@@ -60,7 +60,6 @@ export const useSoftwareStore = defineStore('software', {
 
     // 获取组件尺寸（判断当前是不是存在，不存在的话到主线程拿）
     async GetComponentSize() {
-      debugger
       if (this.componentSize.length == 0) {
         //@ts-ignore
         let res = await window.setting.GetComponentSize()

src/stores/system.ts

@@ -0,0 +1,15 @@
+import { defineStore } from "pinia";
+
+export type SystemStoreModel = {
+  machineId: string | undefined;
+}
+
+export const useSystemStore = defineStore('system', {
+  state: () => ({
+    machineId: undefined
+  } as SystemStoreModel),
+  getters: {
+  },
+  actions: {
+  }
+});