638 lines
14 KiB
TypeScript
638 lines
14 KiB
TypeScript
import { TaskModal } from '@/define/model/task'
|
|
import { t } from '@/i18n'
|
|
|
|
//#region 小说类型
|
|
|
|
export enum BookType {
|
|
// 原创
|
|
ORIGINAL = 'original',
|
|
// 反推
|
|
SD_REVERSE = 'sd_reverse',
|
|
// MJ 反推
|
|
MJ_REVERSE = 'mj_reverse'
|
|
}
|
|
|
|
/**
|
|
* 根据小说类型返回小说类型的label
|
|
* @param type 小说类型
|
|
* @returns
|
|
*/
|
|
export function GetBookTypeLabel(type: BookType) {
|
|
switch (type) {
|
|
case BookType.ORIGINAL:
|
|
return t('原创')
|
|
case BookType.SD_REVERSE:
|
|
return t('SD反推')
|
|
case BookType.MJ_REVERSE:
|
|
return t('MJ反推')
|
|
default:
|
|
return t('未知类型')
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 获取小说类型的选项列表
|
|
* @returns
|
|
*/
|
|
export function GetBookTypeOptions() {
|
|
return [
|
|
{ label: t('原创'), value: BookType.ORIGINAL },
|
|
{ label: t('SD反推'), value: BookType.SD_REVERSE },
|
|
{ label: t('MJ反推'), value: BookType.MJ_REVERSE }
|
|
]
|
|
}
|
|
|
|
//#endregion
|
|
|
|
export enum AddBookTaskCopyData {
|
|
AFTER_GPT = 'after_gpt', // 文案
|
|
OLD_IMAGE = 'old_image', // 抽帧/视频
|
|
GPT_PROMPT = 'gpt_prompt', // 反推/GPT提示词
|
|
CHARACTER = 'character', // 角色
|
|
IMAGE_STYLE = 'image_style', // 风格
|
|
PROMPT = 'prompt', // 生图提示词
|
|
IMAGE = 'image' // 生图
|
|
}
|
|
|
|
export enum MJCategroy {
|
|
// 本地MJ
|
|
LOCAL_MJ = 'local_mj',
|
|
// 代理MJ
|
|
REMOTE_MJ = 'remote_mj',
|
|
// 浏览器模式
|
|
BROWSER_MJ = 'browser_mj',
|
|
// API模式
|
|
API_MJ = 'api_mj'
|
|
}
|
|
|
|
export enum MJAction {
|
|
// 生图
|
|
IMAGINE = 'IMAGINE',
|
|
|
|
// 反推describe
|
|
DESCRIBE = 'DESCRIBE'
|
|
}
|
|
|
|
export enum BookBackTaskType {
|
|
// 分镜计算
|
|
STORYBOARD = 'storyboard',
|
|
// 分割视频
|
|
SPLIT = 'split',
|
|
// 提取音频
|
|
AUDIO = 'audio',
|
|
// 识别字幕
|
|
RECOGNIZE = 'recognize',
|
|
// 抽帧
|
|
FRAME = 'frame',
|
|
// MJ反推
|
|
MJ_REVERSE = BookType.MJ_REVERSE,
|
|
// SD反推
|
|
SD_REVERSE = BookType.SD_REVERSE,
|
|
// MJ生成图片
|
|
MJ_IMAGE = 'mj_image',
|
|
// SD 生成图片
|
|
SD_IMAGE = 'sd_image',
|
|
// ComfyUI 生成图片
|
|
ComfyUI_IMAGE = 'comfyui_image',
|
|
// flux forge 生成图片
|
|
FLUX_FORGE_IMAGE = 'flux_forge_image',
|
|
// flux api 生成图片
|
|
FLUX_API_IMAGE = 'flux_api_image',
|
|
// D3 生成图片
|
|
D3_IMAGE = 'd3_image',
|
|
// 高清
|
|
HD = 'hd',
|
|
// 合成视频
|
|
COMPOSING = 'composing',
|
|
// 推理
|
|
INFERENCE = 'inference',
|
|
// 翻译
|
|
TRANSLATE = 'translate',
|
|
|
|
// ruanway 生成视频
|
|
RUNWAY_VIDEO = 'runway_video',
|
|
// luma 生成视频
|
|
LUMA_VIDEO = 'luma_video',
|
|
// kling 生成视频
|
|
KLING_VIDEO = 'kling_video',
|
|
// kling 视频拓展
|
|
KLING_VIDEO_EXTEND = 'kling_video_extend',
|
|
// MJ Video
|
|
MJ_VIDEO = 'mj_video',
|
|
// MJ VIDEO EXTEND 视频拓展
|
|
MJ_VIDEO_EXTEND = 'mj_video_extend',
|
|
// 海螺文生视频
|
|
HAILUO_TEXT_TO_VIDEO = 'hailuo_text_to_video',
|
|
// 海螺图生视频
|
|
HAILUO_IMAGE_TO_VIDEO = 'hailuo_image_to_video',
|
|
// 海螺视频首尾帧
|
|
HAILUO_FIRST_LAST_FRAME = 'hailuo_first_last_frame'
|
|
}
|
|
|
|
export enum BookBackTaskStatus {
|
|
// 等待
|
|
WAIT = 'wait',
|
|
// 运行中
|
|
RUNNING = 'running',
|
|
// 暂停
|
|
PAUSE = 'pause',
|
|
// 完成
|
|
DONE = 'done',
|
|
// 失败
|
|
FAIL = 'fail',
|
|
// 重连
|
|
RECONNECT = 'reconnect'
|
|
}
|
|
|
|
export enum TaskExecuteType {
|
|
// 自动
|
|
AUTO = 'auto',
|
|
|
|
// 手动
|
|
OPERATE = 'operate'
|
|
}
|
|
|
|
// 弹窗类型
|
|
export enum DialogType {
|
|
// 单独弹窗
|
|
DIALOG = 'dialog',
|
|
// 消息提示
|
|
MESSAGE = 'message',
|
|
// 右上角通知
|
|
NOTIFICATION = 'notification'
|
|
}
|
|
|
|
/**
|
|
* 小说任务状态
|
|
*/
|
|
export enum BookTaskStatus {
|
|
// 等待
|
|
WAIT = 'wait',
|
|
|
|
// 分镜中
|
|
STORYBOARD = 'storyboard',
|
|
|
|
// 分镜失败
|
|
STORYBOARD_FAIL = 'storyboard_fail',
|
|
|
|
// 分镜完成，等待分割视频
|
|
STORYBOARD_DONE = 'storyboard_done',
|
|
|
|
// 分割视频中
|
|
SPLIT = 'split',
|
|
|
|
// 分割视频失败
|
|
SPLIT_FAIL = 'split_fail',
|
|
|
|
// 分割视频完成，等待提取音频
|
|
SPLIT_DONE = 'split_done',
|
|
|
|
// 提取音频中
|
|
AUDIO = 'audio',
|
|
|
|
// 提取音频失败
|
|
AUDIO_FAIL = 'audio_fail',
|
|
|
|
// 提取音频完成，等待识别字幕
|
|
AUDIO_DONE = 'audio_done',
|
|
|
|
// 识别字幕中
|
|
RECOGNIZE = 'recognize',
|
|
|
|
// 识别字幕失败
|
|
RECOGNIZE_FAIL = 'recognize_fail',
|
|
|
|
// 识别字幕完成，等待抽帧
|
|
RECOGNIZE_DONE = 'recognize_done',
|
|
|
|
// 抽帧中
|
|
FRAME = 'frame',
|
|
|
|
// 抽帧完成，等待反推
|
|
FRAME_DONE = 'frame_done',
|
|
|
|
// 抽帧失败
|
|
FRAME_FAIL = 'frame_fail',
|
|
|
|
// 反推中
|
|
REVERSE = 'reverse',
|
|
|
|
// 反推失败
|
|
REVERSE_FAIL = 'reverse_fail',
|
|
|
|
// 反推完成，等待生成图片
|
|
REVERSE_DONE = 'reverse_done',
|
|
|
|
// 生成图片中
|
|
IMAGE = 'image',
|
|
|
|
// 图片生成完成，等待高清
|
|
IMAGE_DONE = 'image_done',
|
|
|
|
// 图片生成失败
|
|
IMAGE_FAIL = 'image_fail',
|
|
|
|
// 高清中
|
|
HD = 'hd',
|
|
|
|
// 高清失败
|
|
HD_FAIL = 'hd_fail',
|
|
|
|
// 高清完成，等待合成视频
|
|
HD_DONE = 'hd_done',
|
|
|
|
// 合成视频中
|
|
COMPOSING = 'composing',
|
|
|
|
// 合成视频完成
|
|
COMPOSING_DONE = 'composing_done',
|
|
|
|
// 合成视频失败
|
|
COMPOSING_FAIL = 'composing_fail',
|
|
/** 添加草稿完成 */
|
|
DRAFT_DONE = 'draft_done',
|
|
/** 添加草稿失败 */
|
|
DRAFT_FAIL = 'draft_fail',
|
|
|
|
/** 图转视频失败 */
|
|
IMAGE_TO_VIDEO_ERROR = 'image_to_video_error',
|
|
/** 图转视频成功 */
|
|
IMAGE_TO_VIDEO_SUCCESS = 'IMAGE_TO_VIDEO_SUCCESS'
|
|
}
|
|
|
|
export enum TagDefineType {
|
|
// 默认风格
|
|
DEFAULT_STYLE = 'default_style',
|
|
// 角色标签
|
|
CHARACTER_MAIN = 'character_main',
|
|
|
|
// 角色小标签
|
|
CHARACTER_SUB = 'min',
|
|
|
|
// 风格主标签
|
|
STYLE_MAIN = 'style_main',
|
|
|
|
// 场景主标签
|
|
SCENE_MAIN = 'scene_main'
|
|
}
|
|
|
|
export enum OperateBookType {
|
|
BOOK = 'book', // 这个小说的所有批次
|
|
BOOKTASK = 'bookTask', // 整个小说批次分镜合并
|
|
BOOKTASKDETAIL = 'bookTaskDetail', // 单个分镜合并
|
|
UNDERBOOKTASK = 'underBookTask', // 执行小说批次任务的指定ID以及后面的所有的东西
|
|
ASSIGNBOOKTASK = 'assignBookTask' // 指定小说批次任务
|
|
}
|
|
|
|
export enum CopyImageType {
|
|
// 所有，包括原图
|
|
ALL = 'all',
|
|
// 出原图外其他，一个个对应
|
|
ONE = 'one',
|
|
// 不包含图
|
|
NONE = 'none'
|
|
}
|
|
|
|
export enum PromptMergeType {
|
|
// mj 合并
|
|
MJ_MERGE = 'mj_merge',
|
|
|
|
// SD 合并
|
|
SD_MERGE = 'sd_merge',
|
|
|
|
// D3 合并
|
|
D3_MERGE = 'd3_merge'
|
|
}
|
|
|
|
/**
|
|
* 小说数据替换类型
|
|
*/
|
|
export enum BookRepalceDataType {
|
|
// 文案
|
|
AFTER_GPT = 'after_gpt',
|
|
// GPT提示词
|
|
GPT_PROMPT = 'gpt_prompt',
|
|
// 提示词
|
|
PROMPT = 'prompt'
|
|
}
|
|
|
|
/**
|
|
* 小说选择标签的方式类型，可以是下拉和标签
|
|
*/
|
|
export enum BookTagSelectType {
|
|
// 下拉
|
|
DROP = 'drop',
|
|
// 标签
|
|
TAG = 'tag'
|
|
}
|
|
|
|
/**
|
|
* 根据Key返回指定的后台任务类型的label
|
|
* @param key
|
|
* @returns
|
|
*/
|
|
export function GetBookBackTaskTypeLabel(key: string) {
|
|
switch (key) {
|
|
case BookBackTaskType.STORYBOARD:
|
|
return t('分镜计算')
|
|
case BookBackTaskType.SPLIT:
|
|
return t('分割视频')
|
|
case BookBackTaskType.AUDIO:
|
|
return t('提取音频')
|
|
case BookBackTaskType.RECOGNIZE:
|
|
return t('识别字幕')
|
|
case BookBackTaskType.FRAME:
|
|
return t('抽帧')
|
|
case BookBackTaskType.MJ_REVERSE:
|
|
return t('MJ反推')
|
|
case BookBackTaskType.SD_REVERSE:
|
|
return t('SD反推')
|
|
case BookBackTaskType.MJ_IMAGE:
|
|
return t('MJ生成图片')
|
|
case BookBackTaskType.SD_IMAGE:
|
|
return t('SD生成图片')
|
|
case BookBackTaskType.FLUX_FORGE_IMAGE:
|
|
return t('flux forge生成图片')
|
|
case BookBackTaskType.FLUX_API_IMAGE:
|
|
return t('flux api生成图片')
|
|
case BookBackTaskType.D3_IMAGE:
|
|
return t('D3生成图片')
|
|
case BookBackTaskType.HD:
|
|
return t('高清')
|
|
case BookBackTaskType.COMPOSING:
|
|
return t('合成视频')
|
|
case BookBackTaskType.INFERENCE:
|
|
return t('推理')
|
|
case BookBackTaskType.TRANSLATE:
|
|
return t('翻译')
|
|
case BookBackTaskType.RUNWAY_VIDEO:
|
|
return t('runway生成视频')
|
|
case BookBackTaskType.LUMA_VIDEO:
|
|
return t('luma生成视频')
|
|
case BookBackTaskType.KLING_VIDEO:
|
|
return t('kling生成视频')
|
|
default:
|
|
return key
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 根据Key返回指定的后台任务状态的label
|
|
* @param key
|
|
* @returns
|
|
*/
|
|
export function GetBookTaskDetailStatusLabel(key: string): TaskModal.TaskStatus {
|
|
switch (key) {
|
|
case BookTaskStatus.WAIT:
|
|
return {
|
|
status: BookTaskStatus.WAIT,
|
|
label: t('等待'),
|
|
type: 'warning'
|
|
}
|
|
case BookTaskStatus.STORYBOARD:
|
|
return {
|
|
status: BookTaskStatus.STORYBOARD,
|
|
label: t('分镜计算中'),
|
|
type: 'info'
|
|
}
|
|
case BookTaskStatus.STORYBOARD_FAIL:
|
|
return {
|
|
status: BookTaskStatus.STORYBOARD_FAIL,
|
|
label: t('分镜计算失败'),
|
|
type: 'error'
|
|
}
|
|
case BookTaskStatus.STORYBOARD_DONE:
|
|
return {
|
|
status: BookTaskStatus.STORYBOARD_DONE,
|
|
label: t('分镜计算完成'),
|
|
type: 'success'
|
|
}
|
|
case BookTaskStatus.SPLIT:
|
|
return {
|
|
status: BookTaskStatus.SPLIT,
|
|
label: t('分割视频中'),
|
|
type: 'info'
|
|
}
|
|
case BookTaskStatus.SPLIT_FAIL:
|
|
return {
|
|
status: BookTaskStatus.SPLIT_FAIL,
|
|
label: t('分割视频失败'),
|
|
type: 'error'
|
|
}
|
|
case BookTaskStatus.SPLIT_DONE:
|
|
return {
|
|
status: BookTaskStatus.SPLIT_DONE,
|
|
label: t('分割视频完成'),
|
|
type: 'success'
|
|
}
|
|
case BookTaskStatus.AUDIO:
|
|
return {
|
|
status: BookTaskStatus.AUDIO,
|
|
label: t('提取音频中'),
|
|
type: 'info'
|
|
}
|
|
case BookTaskStatus.AUDIO_FAIL:
|
|
return {
|
|
status: BookTaskStatus.AUDIO_FAIL,
|
|
label: t('提取音频失败'),
|
|
type: 'error'
|
|
}
|
|
case BookTaskStatus.AUDIO_DONE:
|
|
return {
|
|
status: BookTaskStatus.AUDIO_DONE,
|
|
label: t('提取音频完成'),
|
|
type: 'success'
|
|
}
|
|
case BookTaskStatus.RECOGNIZE:
|
|
return {
|
|
status: BookTaskStatus.RECOGNIZE,
|
|
label: t('识别字幕中'),
|
|
type: 'info'
|
|
}
|
|
case BookTaskStatus.RECOGNIZE_FAIL:
|
|
return {
|
|
status: BookTaskStatus.RECOGNIZE_FAIL,
|
|
label: t('识别字幕失败'),
|
|
type: 'error'
|
|
}
|
|
case BookTaskStatus.RECOGNIZE_DONE:
|
|
return {
|
|
status: BookTaskStatus.RECOGNIZE_DONE,
|
|
label: t('识别字幕完成'),
|
|
type: 'success'
|
|
}
|
|
case BookTaskStatus.FRAME:
|
|
return {
|
|
status: BookTaskStatus.FRAME,
|
|
label: t('抽帧中'),
|
|
type: 'info'
|
|
}
|
|
case BookTaskStatus.FRAME_FAIL:
|
|
return {
|
|
status: BookTaskStatus.FRAME_FAIL,
|
|
label: t('抽帧失败'),
|
|
type: 'error'
|
|
}
|
|
case BookTaskStatus.FRAME_DONE:
|
|
return {
|
|
status: BookTaskStatus.FRAME_DONE,
|
|
label: t('抽帧完成'),
|
|
type: 'success'
|
|
}
|
|
case BookTaskStatus.REVERSE:
|
|
return {
|
|
status: BookTaskStatus.REVERSE,
|
|
label: t('反推中'),
|
|
type: 'info'
|
|
}
|
|
case BookTaskStatus.REVERSE_FAIL:
|
|
return {
|
|
status: BookTaskStatus.REVERSE_FAIL,
|
|
label: t('反推失败'),
|
|
type: 'error'
|
|
}
|
|
case BookTaskStatus.REVERSE_DONE:
|
|
return {
|
|
status: BookTaskStatus.REVERSE_DONE,
|
|
label: t('反推完成'),
|
|
type: 'success'
|
|
}
|
|
case BookTaskStatus.IMAGE:
|
|
return {
|
|
status: BookTaskStatus.IMAGE,
|
|
label: t('生成图片中'),
|
|
type: 'info'
|
|
}
|
|
case BookTaskStatus.IMAGE_FAIL:
|
|
return {
|
|
status: BookTaskStatus.IMAGE_FAIL,
|
|
label: t('生成图片失败'),
|
|
type: 'error'
|
|
}
|
|
case BookTaskStatus.IMAGE_DONE:
|
|
return {
|
|
status: BookTaskStatus.IMAGE_DONE,
|
|
label: t('生成图片完成'),
|
|
type: 'success'
|
|
}
|
|
case BookTaskStatus.HD:
|
|
return {
|
|
status: BookTaskStatus.HD,
|
|
label: t('高清中'),
|
|
type: 'info'
|
|
}
|
|
case BookTaskStatus.HD_FAIL:
|
|
return {
|
|
status: BookTaskStatus.HD_FAIL,
|
|
label: t('高清失败'),
|
|
type: 'error'
|
|
}
|
|
case BookTaskStatus.HD_DONE:
|
|
return {
|
|
status: BookTaskStatus.HD_DONE,
|
|
label: t('高清完成'),
|
|
type: 'success'
|
|
}
|
|
case BookTaskStatus.COMPOSING:
|
|
return {
|
|
status: BookTaskStatus.COMPOSING,
|
|
label: t('合成视频中'),
|
|
type: 'info'
|
|
}
|
|
case BookTaskStatus.COMPOSING_FAIL:
|
|
return {
|
|
status: BookTaskStatus.COMPOSING_FAIL,
|
|
label: t('合成视频失败'),
|
|
type: 'error'
|
|
}
|
|
case BookTaskStatus.COMPOSING_DONE:
|
|
return {
|
|
status: BookTaskStatus.COMPOSING_DONE,
|
|
label: t('合成视频完成'),
|
|
type: 'success'
|
|
}
|
|
case BookTaskStatus.DRAFT_DONE:
|
|
return {
|
|
status: BookTaskStatus.DRAFT_DONE,
|
|
label: t('添加草稿完成'),
|
|
type: 'success'
|
|
}
|
|
case BookTaskStatus.DRAFT_FAIL:
|
|
return {
|
|
status: BookTaskStatus.DRAFT_FAIL,
|
|
label: t('添加草稿失败'),
|
|
type: 'error'
|
|
}
|
|
case BookTaskStatus.IMAGE_TO_VIDEO_ERROR:
|
|
return {
|
|
status: BookTaskStatus.IMAGE_TO_VIDEO_ERROR,
|
|
label: t('图转视频失败'),
|
|
type: 'error'
|
|
}
|
|
case BookTaskStatus.IMAGE_TO_VIDEO_SUCCESS:
|
|
return {
|
|
status: BookTaskStatus.IMAGE_TO_VIDEO_SUCCESS,
|
|
label: t('图转视频成功'),
|
|
type: 'success'
|
|
}
|
|
default:
|
|
return {
|
|
status: 'UNKNOWN',
|
|
label: t('未知'),
|
|
type: 'warning'
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 根据Key返回指定的后台任务状态的label
|
|
* @param key
|
|
* @returns
|
|
*/
|
|
export function GetBookBackTaskStatusLabel(key: string): TaskModal.TaskStatus {
|
|
switch (key) {
|
|
case BookBackTaskStatus.WAIT:
|
|
return {
|
|
status: BookBackTaskStatus.WAIT,
|
|
label: t('等待'),
|
|
type: 'warning'
|
|
}
|
|
case BookBackTaskStatus.RUNNING:
|
|
return {
|
|
status: BookBackTaskStatus.RUNNING,
|
|
label: t('运行中'),
|
|
type: 'info'
|
|
}
|
|
case BookBackTaskStatus.PAUSE:
|
|
return {
|
|
status: BookBackTaskStatus.PAUSE,
|
|
label: t('暂停'),
|
|
type: 'warning'
|
|
}
|
|
case BookBackTaskStatus.DONE:
|
|
return {
|
|
status: BookBackTaskStatus.DONE,
|
|
label: t('完成'),
|
|
type: 'success'
|
|
}
|
|
case BookBackTaskStatus.FAIL:
|
|
return {
|
|
status: BookBackTaskStatus.FAIL,
|
|
label: t('失败'),
|
|
type: 'error'
|
|
}
|
|
case BookBackTaskStatus.RECONNECT:
|
|
return {
|
|
status: BookBackTaskStatus.RECONNECT,
|
|
label: t('重连'),
|
|
type: 'warning'
|
|
}
|
|
default:
|
|
return {
|
|
status: 'UNKNOWN',
|
|
label: t('未知'),
|
|
type: 'warning'
|
|
}
|
|
}
|
|
}
|