LaiTool/src/main/Service/ServiceBasic/bookServiceBasic.ts

257 lines
8.8 KiB
TypeScript
Raw Normal View History

2024-08-18 16:22:19 +08:00
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";
/**
*
* 便
*/
export class BookServiceBasic {
bookService: BookService
bookTaskService: BookTaskService;
taskScheduler: TaskScheduler
bookTaskDetailService: BookTaskDetailService
bookBackTaskListService: BookBackTaskListService
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()
}
}
// 主动返回前端的消息
sendReturnMessage(data: GeneralResponse.MessageResponse, message_name = DEFINE_STRING.BOOK.GET_COPYWRITING_RETURN) {
global.newWindow[0].win.webContents.send(message_name, data)
}
//#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)
}
//#endregion
//#region 小说批次任务相关的基础服务
/**
* ID获取小说批次任务数据
* @param bookTaskId ID
* @returns
*/
async GetBookTaskDataId(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 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 DeleteBookTaskData(bookTaskId: string): Promise<void> {
await this.InitService();
this.bookTaskService.DeleteBookTask(bookTaskId)
}
//#endregion
//#region 小说批次任务对应的分镜的相关的基础服务
/**
* 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
*/
async GetBookTaskDetailData(condition: Book.QueryBookTaskDetailCondition): Promise<Book.SelectBookTaskDetail[]> {
await this.InitService();
let bookTaskDetails = this.bookTaskDetailService.GetBookTaskData(condition)
if (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)
}
//#endregion
//#region 小说后台任务相关操作
/**
*
* @param bookId ID
* @param taskType
* @param executeType
* @param bookTaskId ID
* @param bookTaskDetailId ID
*/
async AddBookBackTask(bookId: string,
taskType: BookBackTaskType,
executeType = TaskExecuteType.AUTO,
bookTaskId = null,
bookTaskDetailId = null): Promise<TaskModal.Task> {
await this.InitService();
let res = this.bookBackTaskListService.AddBookBackTask(bookId, taskType, executeType, bookTaskId, bookTaskDetailId)
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 }
}
}