mirror of
https://github.com/xiaoyiweb/YiAi.git
synced 2025-09-25 12:46:39 +08:00
1065 lines
43 KiB
TypeScript
1065 lines
43 KiB
TypeScript
import { UserEntity } from '../user/user.entity';
|
||
import { HttpException, HttpStatus, Inject, Injectable, Logger, Req } from '@nestjs/common';
|
||
import { InjectRepository } from '@nestjs/typeorm';
|
||
import { MidjourneyEntity } from './midjourney.entity';
|
||
import { In, Repository } from 'typeorm';
|
||
import axios from 'axios';
|
||
import { GlobalConfigService } from '../globalConfig/globalConfig.service';
|
||
import { MidjourneyActionEnum, MidjourneyStatusEnum } from '@/common/constants/midjourney.constant';
|
||
import { UploadService } from '../upload/upload.service';
|
||
import { BadwordsService } from '../badwords/badwords.service';
|
||
import { Request } from 'express';
|
||
import { UserBalanceService } from '../userBalance/userBalance.service';
|
||
import { GetListDto } from './dto/getList.dto';
|
||
import { formatCreateOrUpdateDate } from '@/common/utils';
|
||
import { RedisClientType } from 'redis';
|
||
import { RedisCacheService } from '../redisCache/redisCache.service';
|
||
import { mjPromptEntity } from './prompt.entity';
|
||
|
||
@Injectable()
|
||
export class MidjourneyService {
|
||
constructor(
|
||
@InjectRepository(MidjourneyEntity)
|
||
private readonly midjourneyEntity: Repository<MidjourneyEntity>,
|
||
@InjectRepository(UserEntity)
|
||
private readonly userEntity: Repository<UserEntity>,
|
||
@InjectRepository(mjPromptEntity)
|
||
private readonly mjPromptsEntity: Repository<mjPromptEntity>,
|
||
private readonly globalConfigService: GlobalConfigService,
|
||
private readonly uploadService: UploadService,
|
||
private readonly badwordsService: BadwordsService,
|
||
private readonly userBalanceService: UserBalanceService,
|
||
private redisCacheService: RedisCacheService,
|
||
) {}
|
||
|
||
private lockPrompt = [];
|
||
|
||
/* 睡眠 xs */
|
||
async sleep(time) {
|
||
return new Promise((resolve) => setTimeout(resolve, time));
|
||
}
|
||
|
||
async draw(jobData, jobId) {
|
||
const { id, action } = jobData;
|
||
const drawInfo = await this.midjourneyEntity.findOne({ where: { id } });
|
||
try {
|
||
/* 把任务ID绑定到DB去 */
|
||
await this.bindJobId(id, jobId);
|
||
/* 修改绘画记录状态为绘制中 */
|
||
await this.updateDrawStatus(id, MidjourneyStatusEnum.DRAWING);
|
||
|
||
/* 绘制图片 | 图生图 */
|
||
if (action === MidjourneyActionEnum.DRAW || action === MidjourneyActionEnum.GENERATE) {
|
||
await this.sendDrawCommand(drawInfo, jobData);
|
||
/* 开始执行检测逻辑 */
|
||
const drawRes = await this.pollComparisonResultDraw(drawInfo);
|
||
/* 把所有绘制记录存入 */
|
||
await this.updateDrawData(jobData, drawRes);
|
||
}
|
||
|
||
/* 放大图片 */
|
||
if (action === MidjourneyActionEnum.UPSCALE) {
|
||
const { message_id, custom_id } = drawInfo;
|
||
await this.sendSmInteractions({ message_id, custom_id }, jobData);
|
||
Logger.debug(`记录${id}已经成功发送了图片放大指令`, 'MidjourneyService');
|
||
/* 开始执行检测逻辑 */
|
||
const drawRes = await this.pollComparisonResultUpscale(drawInfo);
|
||
await this.updateDrawData(jobData, drawRes);
|
||
}
|
||
|
||
/* 变体图片 */
|
||
if (action === MidjourneyActionEnum.VARIATION) {
|
||
const { message_id, custom_id } = drawInfo;
|
||
await this.sendSmInteractions({ message_id, custom_id }, jobData);
|
||
Logger.debug(`记录${id}已经成功发送了图片变化指令`, 'MidjourneyService');
|
||
/* 开始执行检测逻辑 */
|
||
const drawRes = await this.pollComparisonResultVariation(drawInfo);
|
||
await this.updateDrawData(jobData, drawRes);
|
||
/* 存完解锁当前文件 */
|
||
this.lockPrompt = this.lockPrompt.filter((item) => item !== drawInfo.randomDrawId);
|
||
}
|
||
|
||
/* 重新绘制一次 */
|
||
if (action === MidjourneyActionEnum.REGENERATE) {
|
||
const { message_id, custom_id } = drawInfo;
|
||
await this.sendReGenerateInteractions({ message_id, custom_id }, jobData);
|
||
Logger.debug(`记录${id}已经成功发送了重新生成图片指令`, 'MidjourneyService');
|
||
const drawRes = await this.pollComparisonResultReGenerate(drawInfo);
|
||
await this.updateDrawData(jobData, drawRes);
|
||
/* 存完解锁当前文件 */
|
||
this.lockPrompt = this.lockPrompt.filter((item) => item !== drawInfo.randomDrawId);
|
||
}
|
||
|
||
/* 对图片增强 Vary */
|
||
if (action === MidjourneyActionEnum.VARY) {
|
||
const { message_id, custom_id } = drawInfo;
|
||
await this.sendVaryInteractions({ message_id, custom_id }, jobData);
|
||
Logger.debug(`记录${id}已经成功发送单张图片增强指令`, 'MidjourneyService');
|
||
const drawRes = await this.pollComparisonResultVary(drawInfo);
|
||
await this.updateDrawData(jobData, drawRes);
|
||
/* 存完解锁当前文件 */
|
||
this.lockPrompt = this.lockPrompt.filter((item) => item !== drawInfo.randomDrawId);
|
||
}
|
||
|
||
/* 对图片缩放 Zoom */
|
||
if (action === MidjourneyActionEnum.ZOOM) {
|
||
const { message_id, custom_id } = drawInfo;
|
||
await this.sendZoomInteractions({ message_id, custom_id }, jobData);
|
||
Logger.debug(`记录${id}已经成功发送单张图片缩放指令`, 'MidjourneyService');
|
||
const drawRes = await this.pollComparisonResultZoom(drawInfo);
|
||
await this.updateDrawData(jobData, drawRes);
|
||
/* 存完解锁当前文件 */
|
||
this.lockPrompt = this.lockPrompt.filter((item) => item !== drawInfo.randomDrawId);
|
||
|
||
/* 只有在画成功后才扣分*/
|
||
this.drawSuccess(jobData);
|
||
}
|
||
|
||
return true;
|
||
} catch (error) {
|
||
this.lockPrompt = this.lockPrompt.filter((item) => item !== drawInfo.randomDrawId);
|
||
await this.drawFailed(jobData);
|
||
console.log('error: ', error);
|
||
return true;
|
||
}
|
||
}
|
||
|
||
/* 绘制图片 */
|
||
/* 放大图片 */
|
||
/* 变体图片 */
|
||
|
||
/* 添加一条等待中的绘制任务 */
|
||
async addDrawQueue(params) {
|
||
const { prompt, imgUrl = '', extraParam = '', action = 1, userId, randomDrawId, orderId, custom_id, message_id } = params;
|
||
const fullPrompt = imgUrl ? `${imgUrl} ${prompt} ${extraParam}` : `${prompt} ${extraParam}`;
|
||
/* 敏感词检测 */
|
||
await this.badwordsService.checkBadWords(fullPrompt, userId);
|
||
const drawInfo = {
|
||
userId,
|
||
extraParam,
|
||
prompt,
|
||
imgUrl,
|
||
fullPrompt,
|
||
randomDrawId,
|
||
status: MidjourneyStatusEnum.WAITING,
|
||
action: action,
|
||
orderId,
|
||
custom_id,
|
||
message_id,
|
||
};
|
||
const res = await this.midjourneyEntity.save(drawInfo);
|
||
return res;
|
||
}
|
||
|
||
/* 修改绘制记录状态 */
|
||
async updateDrawStatus(id, status) {
|
||
await this.midjourneyEntity.update({ id }, { status });
|
||
}
|
||
|
||
/* 绘制完成后修改数据 */
|
||
async updateDrawData(jobData, drawRes) {
|
||
try {
|
||
const { id, content, channel_id, attachments = [], timestamp, durationSpent } = drawRes;
|
||
const { filename, url, proxy_url, width, height, size } = attachments[0];
|
||
/* 将图片存入cos */
|
||
const mjNotSaveImg = await this.globalConfigService.getConfigs(['mjNotSaveImg']);
|
||
let cosUrl = '';
|
||
if (!Number(mjNotSaveImg) || Number(mjNotSaveImg) === 0) {
|
||
Logger.debug(`------> 开始上传图片！！！`, 'MidjourneyService');
|
||
const startDate = new Date();
|
||
cosUrl = await this.uploadService.uploadFileFromUrl({ filename, url });
|
||
const endDate = new Date();
|
||
Logger.debug(`本次图片上传耗时为${(endDate.getTime() - startDate.getTime()) / 1000}秒`, 'MidjourneyService');
|
||
} else {
|
||
console.log('本次不存图片了');
|
||
}
|
||
/* 记录当前图片存储方式 方便后续对不同平台图片压缩 */
|
||
const cosType = await this.uploadService.getUploadType();
|
||
/* 整理信息 存入DB */
|
||
const drawInfo = {
|
||
status: MidjourneyStatusEnum.DRAWED,
|
||
message_id: id,
|
||
progress: 100,
|
||
fileInfo: JSON.stringify({ width, height, size, filename, cosUrl, cosType }),
|
||
extend: this.removeEmoji(JSON.stringify(drawRes)),
|
||
durationSpent,
|
||
isSaveImg: !Number(mjNotSaveImg) || Number(mjNotSaveImg) === 0,
|
||
};
|
||
await this.midjourneyEntity.update({ id: jobData.id }, drawInfo);
|
||
} catch (error) {
|
||
console.log('TODO->存储图片失败, ', jobData, error);
|
||
}
|
||
}
|
||
|
||
/* 获取到当前ID的历史已经存入的信息并且绘制完成的 防止已经存过的图又被存了 */
|
||
async getHistroyMessageIds(randomDrawId) {
|
||
const res = await this.midjourneyEntity.find({ where: { randomDrawId, status: MidjourneyStatusEnum.DRAWED } });
|
||
return res.map((item: any) => item.message_id);
|
||
}
|
||
|
||
/* 发送绘画指令 */
|
||
async sendDrawCommand(drawInfo, jobData) {
|
||
const { fullPrompt, randomDrawId, imgUrl } = drawInfo;
|
||
const prompt = imgUrl ? `[${randomDrawId}] ${imgUrl} ${fullPrompt}` : `[${randomDrawId}] ${fullPrompt}`;
|
||
Logger.debug(`本次绘图指令为${prompt}`, 'MidjourneyService');
|
||
|
||
const { application_id, guild_id, channel_id, session_id, version, id, authorization, mjProxy } = await this.getMjDefaultParams();
|
||
const payloadJson = {
|
||
type: 2,
|
||
application_id,
|
||
guild_id,
|
||
channel_id,
|
||
session_id,
|
||
data: { version, id, name: 'imagine', type: 1, options: [{ type: 3, name: 'prompt', value: prompt }], attachments: [] },
|
||
};
|
||
try {
|
||
const mjProxyUrl = (await this.globalConfigService.getConfigs(['mjProxyUrl'])) || 'http://172.247.48.137:8000';
|
||
const url = mjProxy == 1 ? `${mjProxyUrl}/mj/draw` : 'https://discord.com/api/v9/interactions';
|
||
const headers = { authorization };
|
||
const res = await axios.post(url, payloadJson, { headers });
|
||
return false;
|
||
} catch (error) {
|
||
Logger.error(`发送绘画指令失败`, 'MidjourneyService');
|
||
throw new HttpException('发送绘图指令失败、请联系管理员检测绘画配置！', HttpStatus.BAD_REQUEST);
|
||
}
|
||
}
|
||
|
||
/* 发送放大变幻指令 */
|
||
async sendSmInteractions(params, jobData) {
|
||
const { message_id, custom_id } = params;
|
||
const { application_id, guild_id, channel_id, session_id, version, id, authorization, mjProxy } = await this.getMjDefaultParams();
|
||
const mjProxyUrl = (await this.globalConfigService.getConfigs(['mjProxyUrl'])) || 'http://172.247.48.137:8000';
|
||
const url = mjProxy == 1 ? `${mjProxyUrl}/mj/draw` : 'https://discord.com/api/v9/interactions';
|
||
const headers = { authorization };
|
||
const body = {
|
||
type: 3,
|
||
guild_id,
|
||
channel_id,
|
||
message_flags: 0,
|
||
message_id,
|
||
application_id,
|
||
session_id,
|
||
data: {
|
||
component_type: 2,
|
||
custom_id,
|
||
},
|
||
};
|
||
try {
|
||
await axios.post(url, body, { headers });
|
||
} catch (error) {
|
||
console.log('发送放大变幻指令失败: ', error);
|
||
Logger.error(`发送放大变幻指令失败`, 'MidjourneyService');
|
||
throw new HttpException('对图片放大变幻失败...', HttpStatus.BAD_REQUEST);
|
||
}
|
||
}
|
||
|
||
/* 发送重新生成指令 很多类似 暂时分开处理 防止改动 */
|
||
async sendReGenerateInteractions(params, jobData) {
|
||
const { message_id, custom_id } = params;
|
||
const { application_id, guild_id, channel_id, session_id, version, id, authorization, mjProxy } = await this.getMjDefaultParams();
|
||
const mjProxyUrl = (await this.globalConfigService.getConfigs(['mjProxyUrl'])) || 'http://172.247.48.137:8000';
|
||
const url = mjProxy == 1 ? `${mjProxyUrl}/mj/draw` : 'https://discord.com/api/v9/interactions';
|
||
const headers = { authorization };
|
||
const body = {
|
||
type: 3,
|
||
guild_id,
|
||
channel_id,
|
||
message_id,
|
||
application_id,
|
||
session_id,
|
||
data: {
|
||
component_type: 2,
|
||
custom_id,
|
||
},
|
||
};
|
||
try {
|
||
await axios.post(url, body, { headers });
|
||
} catch (error) {
|
||
console.log('发送重新生成指令失败: ', error);
|
||
Logger.error(`发送放大变幻指令失败`, 'MidjourneyService');
|
||
throw new HttpException('对图片放大变幻失败...', HttpStatus.BAD_REQUEST);
|
||
}
|
||
}
|
||
|
||
/* 发送图片增强指令 */
|
||
async sendVaryInteractions(params, jobData) {
|
||
const { message_id, custom_id } = params;
|
||
const { application_id, guild_id, channel_id, session_id, version, id, authorization, mjProxy } = await this.getMjDefaultParams();
|
||
const mjProxyUrl = (await this.globalConfigService.getConfigs(['mjProxyUrl'])) || 'http://172.247.48.137:8000';
|
||
const url = mjProxy == 1 ? `${mjProxyUrl}/mj/draw` : 'https://discord.com/api/v9/interactions';
|
||
const headers = { authorization };
|
||
const body = {
|
||
type: 3,
|
||
guild_id,
|
||
channel_id,
|
||
message_id,
|
||
application_id,
|
||
session_id,
|
||
data: {
|
||
component_type: 2,
|
||
custom_id,
|
||
},
|
||
};
|
||
try {
|
||
await axios.post(url, body, { headers });
|
||
} catch (error) {
|
||
console.log('发送对单张图片增强指令失败: ', error);
|
||
Logger.error(`发送单张图片增强指令失败`, 'MidjourneyService');
|
||
throw new HttpException('对图片单张增强失败...', HttpStatus.BAD_REQUEST);
|
||
}
|
||
}
|
||
|
||
/* 发送单张图片缩放指令 */
|
||
async sendZoomInteractions(params, jobData) {
|
||
const { message_id, custom_id } = params;
|
||
const { application_id, guild_id, channel_id, session_id, version, id, authorization, mjProxy } = await this.getMjDefaultParams();
|
||
const mjProxyUrl = (await this.globalConfigService.getConfigs(['mjProxyUrl'])) || 'http://172.247.48.137:8000';
|
||
const url = mjProxy == 1 ? `${mjProxyUrl}/mj/draw` : 'https://discord.com/api/v9/interactions';
|
||
const headers = { authorization };
|
||
const body = {
|
||
type: 3,
|
||
guild_id,
|
||
channel_id,
|
||
message_id,
|
||
application_id,
|
||
session_id,
|
||
data: {
|
||
component_type: 2,
|
||
custom_id,
|
||
},
|
||
};
|
||
try {
|
||
await axios.post(url, body, { headers });
|
||
} catch (error) {
|
||
console.log('发送对单张图片增强指令失败: ', error);
|
||
Logger.error(`发送单张图片增强指令失败`, 'MidjourneyService');
|
||
throw new HttpException('对图片单张增强失败...', HttpStatus.BAD_REQUEST);
|
||
}
|
||
}
|
||
|
||
/* 轮询比对绘画结果 */
|
||
async pollComparisonResultDraw(drawInfo) {
|
||
Logger.debug(`开始查询绘画结果`, 'MidjourneyService');
|
||
const startTime = Date.now();
|
||
const INTERVAL_BEFORE_90S = 10000; // 0s-90s之间每十秒查一次
|
||
const INTERVAL_AFTER_90S = 30000; // 90s之后每30秒查一次
|
||
const timeout = (await this.globalConfigService.getConfigs(['mjTimeoutMs'])) || 150000; // 超时时间 150秒
|
||
const TIMEOUT = timeout;
|
||
let pollingCount = 0; // 记录轮询次数
|
||
let drawRes = null;
|
||
let isMatchSuccessful = false;
|
||
try {
|
||
while (!isMatchSuccessful && Date.now() - startTime < TIMEOUT) {
|
||
let interval;
|
||
if (Date.now() - startTime < 90000) {
|
||
interval = INTERVAL_BEFORE_90S;
|
||
} else {
|
||
interval = INTERVAL_AFTER_90S;
|
||
}
|
||
await this.sleep(interval);
|
||
Logger.debug(`【绘制图片】第 ${pollingCount + 1} 次开始查询`, 'MidjourneyService');
|
||
drawRes = await this.findCurrentPromptResult(drawInfo.randomDrawId);
|
||
if (drawRes) {
|
||
const { content } = drawRes;
|
||
const progress = await this.parseProgress(content);
|
||
Logger.debug(`【绘制图片】第 ${pollingCount + 1} 次、 当前绘画进度为${progress}%`, 'MidjourneyService');
|
||
/* TODO 实时去改变db记录当前解结果 更多信息是否存储 待考虑 */
|
||
await this.midjourneyEntity.update({ id: drawInfo.id }, { progress: progress ?? 100 });
|
||
}
|
||
/* 比对是否绘制完成 */
|
||
isMatchSuccessful = drawRes && !drawRes.edited_timestamp;
|
||
pollingCount++;
|
||
}
|
||
if (!drawRes) {
|
||
await this.updateDrawStatus(drawInfo.id, MidjourneyStatusEnum.DRAWTIMEOUT);
|
||
throw new HttpException('绘画超时，请稍后再试！', HttpStatus.BAD_REQUEST);
|
||
}
|
||
|
||
const endTime = Date.now();
|
||
return { ...drawRes, durationSpent: Math.floor((endTime - startTime) / 1000) };
|
||
} catch (error) {
|
||
console.log('获取图片列表结果失败: ', error);
|
||
}
|
||
}
|
||
|
||
/* 轮询比对拿到放大图片 */
|
||
async pollComparisonResultUpscale(drawInfo) {
|
||
Logger.debug(`开始查询放大图片信息`, 'MidjourneyService');
|
||
const startTime = Date.now();
|
||
const { message_id, custom_id, randomDrawId, orderId } = drawInfo;
|
||
let enlargeImgDetail = null;
|
||
let pollingCount = 0;
|
||
while (!enlargeImgDetail && pollingCount < 10) {
|
||
Logger.debug(`开始比对放大图片第${pollingCount + 1}次`, 'MidjourneyService');
|
||
enlargeImgDetail = await this.findCurrentEnlargeImgResult(randomDrawId, orderId);
|
||
await new Promise((resolve) => setTimeout(resolve, Math.floor(Math.random() * (5000 - 3000 + 1)) + 3000));
|
||
pollingCount++;
|
||
}
|
||
|
||
if (!enlargeImgDetail) {
|
||
await this.updateDrawStatus(drawInfo.id, MidjourneyStatusEnum.DRAWTIMEOUT);
|
||
throw new HttpException('放大图片超时，请稍后再试！', HttpStatus.BAD_REQUEST);
|
||
}
|
||
const endTime = Date.now();
|
||
return { ...enlargeImgDetail, durationSpent: Math.floor((endTime - startTime) / 1000) };
|
||
}
|
||
|
||
/* 轮询比对拿到重新绘制的那张图 */
|
||
async pollComparisonResultReGenerate(drawInfo) {
|
||
Logger.debug(`开始查询重复绘制的图片信息`, 'MidjourneyService');
|
||
const TIMEOUT = (await this.globalConfigService.getConfigs(['mjTimeoutMs'])) || 150000; // 超时时间 150秒
|
||
const startTime = Date.now();
|
||
const { message_id, custom_id, randomDrawId, orderId } = drawInfo;
|
||
let reGenerateImgDetail = null;
|
||
let pollingTime = 0;
|
||
let count = 0;
|
||
while (!reGenerateImgDetail && pollingTime < TIMEOUT) {
|
||
Logger.debug(`开始比对重新绘制图片第${count + 1}次`, 'MidjourneyService');
|
||
reGenerateImgDetail = await this.findCurrentReGenerateImgResult(randomDrawId, message_id);
|
||
const t = Math.floor(Math.random() * (5000 - 3000 + 1)) + 8000;
|
||
await new Promise((resolve) => setTimeout(resolve, t));
|
||
pollingTime += t;
|
||
count++;
|
||
}
|
||
|
||
if (!reGenerateImgDetail) {
|
||
await this.updateDrawStatus(drawInfo.id, MidjourneyStatusEnum.DRAWTIMEOUT);
|
||
throw new HttpException('重新绘制图片超时，请稍后再试！', HttpStatus.BAD_REQUEST);
|
||
}
|
||
const endTime = Date.now();
|
||
return { ...reGenerateImgDetail, durationSpent: Math.floor((endTime - startTime) / 1000) };
|
||
}
|
||
|
||
/* 对单张图片增强 */
|
||
async pollComparisonResultVary(drawInfo) {
|
||
Logger.debug(`开始查询单张图片增强的图片信息`, 'MidjourneyService');
|
||
const TIMEOUT = (await this.globalConfigService.getConfigs(['mjTimeoutMs'])) || 150000; // 超时时间 150秒
|
||
const startTime = Date.now();
|
||
const { message_id, custom_id, randomDrawId, orderId } = drawInfo;
|
||
let varyImgDetail = null;
|
||
let pollingTime = 0;
|
||
let count = 0;
|
||
while (!varyImgDetail && pollingTime < TIMEOUT) {
|
||
Logger.debug(`开始单张图片增强第${count + 1}次`, 'MidjourneyService');
|
||
varyImgDetail = await this.findCurrentVaryImgResult(randomDrawId, message_id);
|
||
const t = Math.floor(Math.random() * (5000 - 3000 + 1)) + 8000;
|
||
await new Promise((resolve) => setTimeout(resolve, t));
|
||
pollingTime += t;
|
||
count++;
|
||
}
|
||
|
||
if (!varyImgDetail) {
|
||
await this.updateDrawStatus(drawInfo.id, MidjourneyStatusEnum.DRAWTIMEOUT);
|
||
throw new HttpException('单张图片增强超时，请稍后再试！', HttpStatus.BAD_REQUEST);
|
||
}
|
||
const endTime = Date.now();
|
||
return { ...varyImgDetail, durationSpent: Math.floor((endTime - startTime) / 1000) };
|
||
}
|
||
|
||
/* 对单张图片缩放 */
|
||
async pollComparisonResultZoom(drawInfo) {
|
||
Logger.debug(`开始查询单张图片缩放的图片信息`, 'MidjourneyService');
|
||
const TIMEOUT = (await this.globalConfigService.getConfigs(['mjTimeoutMs'])) || 150000; // 超时时间 150秒
|
||
const startTime = Date.now();
|
||
const { message_id, custom_id, randomDrawId, orderId } = drawInfo;
|
||
let zoomImgDetail = null;
|
||
let pollingTime = 0;
|
||
let count = 0;
|
||
while (!zoomImgDetail && pollingTime < TIMEOUT) {
|
||
Logger.debug(`开始单张图片缩放第${count + 1}次`, 'MidjourneyService');
|
||
zoomImgDetail = await this.findCurrentZoomImgResult(randomDrawId, message_id);
|
||
const t = Math.floor(Math.random() * (5000 - 3000 + 1)) + 8000;
|
||
await new Promise((resolve) => setTimeout(resolve, t));
|
||
pollingTime += t;
|
||
count++;
|
||
}
|
||
|
||
if (!zoomImgDetail) {
|
||
await this.updateDrawStatus(drawInfo.id, MidjourneyStatusEnum.DRAWTIMEOUT);
|
||
throw new HttpException('单张图片缩放超时，请稍后再试！', HttpStatus.BAD_REQUEST);
|
||
}
|
||
const endTime = Date.now();
|
||
return { ...zoomImgDetail, durationSpent: Math.floor((endTime - startTime) / 1000) };
|
||
}
|
||
|
||
/* 轮询比对拿到变体图片 */
|
||
async pollComparisonResultVariation(drawInfo) {
|
||
Logger.debug(`开始轮询单张变换图片结果`, 'MidjourneyService');
|
||
let variationImgDetail = null;
|
||
const startTime = Date.now();
|
||
while (!variationImgDetail) {
|
||
Logger.debug(`变换图片获取中------>`, 'MidjourneyService');
|
||
variationImgDetail = await this.findCurrentVariationImgResult(drawInfo.randomDrawId);
|
||
const nextPollingDelay = 10000; // 每10秒轮询一次
|
||
await this.sleep(nextPollingDelay);
|
||
|
||
const endTime = Date.now();
|
||
const durationSpent = Math.floor(endTime - startTime);
|
||
const timeout = (await this.globalConfigService.getConfigs(['mjTimeoutMs'])) || 150000; // 超时时间 150秒
|
||
const TIMEOUT = timeout;
|
||
|
||
if (durationSpent >= TIMEOUT) {
|
||
await this.updateDrawStatus(drawInfo.id, MidjourneyStatusEnum.DRAWTIMEOUT);
|
||
throw new HttpException('变换当前图片超时！', HttpStatus.BAD_REQUEST);
|
||
}
|
||
}
|
||
return { ...variationImgDetail, durationSpent: Math.floor(Date.now() - startTime) };
|
||
}
|
||
|
||
/* 比对找到放大图片的地址作为返回结果 */
|
||
async findCurrentEnlargeImgResult(randomDrawId, orderId) {
|
||
const messageList = await this.getMessageList();
|
||
const histroyMessageIds = await this.getHistroyMessageIds(randomDrawId);
|
||
const enlargeImgDetail = messageList.find((item) => {
|
||
const { content } = item;
|
||
if (!this.extractContent(content)) return false;
|
||
const { prompt, order } = this.extractContent(content);
|
||
return content.includes(randomDrawId) && orderId === order && !histroyMessageIds.includes(item.id);
|
||
});
|
||
return enlargeImgDetail;
|
||
}
|
||
|
||
/* 比对拿到变体图片 */
|
||
async findCurrentVariationImgResult(randomDrawId) {
|
||
const messageList = await this.getMessageList();
|
||
const histroyMessageIds = await this.getHistroyMessageIds(randomDrawId);
|
||
const variationImgDetail = messageList.find((item) => {
|
||
const { content } = item;
|
||
return content.includes(randomDrawId) && !histroyMessageIds.includes(item.id) && this.isVariationsImage(content);
|
||
});
|
||
|
||
/* 如果有一个人拿到 那么进入锁定模式 当前的图片变体别人不能再拿 等我存完 你再进来匹配 */
|
||
if (variationImgDetail) {
|
||
if (this.lockPrompt.includes(randomDrawId)) {
|
||
Logger.debug(`【变体图片】当前图片已经被锁定，等待同任务完成`, 'MidjourneyService');
|
||
return null;
|
||
} else {
|
||
this.lockPrompt.push(randomDrawId);
|
||
}
|
||
}
|
||
return variationImgDetail;
|
||
}
|
||
|
||
/* 匹配拿到重新生成的图片, 重新生成的图 message_id 变了 所以对比需要排除message_id */
|
||
async findCurrentReGenerateImgResult(randomDrawId, message_id) {
|
||
const messageList = await this.getMessageList();
|
||
const histroyMessageIds = await this.getHistroyMessageIds(randomDrawId);
|
||
const reGenerateImgDetail = messageList.find((item) => {
|
||
const { content } = item;
|
||
// message_reference 重新绘制的多一个字段 这个就是原始图片的message_id
|
||
return content.includes(randomDrawId) && !histroyMessageIds.includes(item.id) && item.id !== message_id && this.isReGenerateImage(content);
|
||
});
|
||
|
||
/* 如果有一个人拿到 那么进入锁定模式 当前的图片变体别人不能再拿 等我存完 你再进来匹配 */
|
||
if (reGenerateImgDetail) {
|
||
if (this.lockPrompt.includes(randomDrawId)) {
|
||
Logger.debug(`【重新生成图片】当前图片已经被锁定，等待同任务完成`, 'MidjourneyService');
|
||
return null;
|
||
} else {
|
||
this.lockPrompt.push(randomDrawId);
|
||
}
|
||
}
|
||
return reGenerateImgDetail;
|
||
}
|
||
|
||
/* 匹配缩放图 */
|
||
async findCurrentZoomImgResult(randomDrawId, message_id) {
|
||
const messageList = await this.getMessageList();
|
||
const histroyMessageIds = await this.getHistroyMessageIds(randomDrawId);
|
||
const reGenerateImgDetail = messageList.find((item) => {
|
||
const { content } = item;
|
||
// message_reference 重新绘制的多一个字段 这个就是原始图片的message_id
|
||
return content.includes(randomDrawId) && !histroyMessageIds.includes(item.id) && item.id !== message_id && this.isZoomImage(content);
|
||
});
|
||
|
||
/* 如果有一个人拿到 那么进入锁定模式 当前的图片变体别人不能再拿 等我存完 你再进来匹配 */
|
||
if (reGenerateImgDetail) {
|
||
if (this.lockPrompt.includes(randomDrawId)) {
|
||
Logger.debug(`【重新生成图片】当前图片已经被锁定，等待同任务完成`, 'MidjourneyService');
|
||
return null;
|
||
} else {
|
||
this.lockPrompt.push(randomDrawId);
|
||
}
|
||
}
|
||
return reGenerateImgDetail;
|
||
}
|
||
|
||
/* 匹配拿图 单张生成图 */
|
||
async findCurrentVaryImgResult(randomDrawId, message_id) {
|
||
const messageList = await this.getMessageList();
|
||
const histroyMessageIds = await this.getHistroyMessageIds(randomDrawId);
|
||
const varyImgDetail = messageList.find((item) => {
|
||
const { content } = item;
|
||
// message_reference 重新绘制的多一个字段 这个就是原始图片的message_id
|
||
return content.includes(randomDrawId) && !histroyMessageIds.includes(item.id) && item.id !== message_id && this.isVaryImage(content);
|
||
});
|
||
|
||
/* 如果有一个人拿到 那么进入锁定模式 当前的图片变体别人不能再拿 等我存完 你再进来匹配 */
|
||
if (varyImgDetail) {
|
||
if (this.lockPrompt.includes(randomDrawId)) {
|
||
Logger.debug(`【单张图片增强】当前图片已经被锁定，等待同任务完成`, 'MidjourneyService');
|
||
return null;
|
||
} else {
|
||
this.lockPrompt.push(randomDrawId);
|
||
}
|
||
}
|
||
return varyImgDetail;
|
||
}
|
||
|
||
/* 匹配放大的单张图片的操作 */
|
||
extractContent(str: string): { prompt: string; order: number } | null {
|
||
const promptMatch = str.match(/\*\*(.+?)\*\*/);
|
||
const orderMatch = str.match(/- Image #(\d+)/);
|
||
if (!promptMatch || !orderMatch) {
|
||
return null;
|
||
}
|
||
const prompt = promptMatch[1];
|
||
const order = parseInt(orderMatch[1]);
|
||
return { prompt, order };
|
||
}
|
||
|
||
/* 比对当前列表中是否存在我们正在绘制的图片 histroyMessageIds是历史相同prompt生成的 有的话排除这些 */
|
||
async findCurrentPromptResult(randomDrawId) {
|
||
const histroyMessageIds = await this.getHistroyMessageIds(randomDrawId);
|
||
const messageList = await this.getMessageList();
|
||
if (!messageList || !messageList.length) return;
|
||
const matchingItem = messageList.find((item) => {
|
||
const { attachments = [], content, edited_timestamp } = item;
|
||
// 如果这个参数有值 edited_timestamp 就说明在绘画中 返回结果但是不算结束 其他比对逻辑： content绘画词包含我们的randomDrawId 并且attachments是有值的 其实包含的这个图是我们之前没存入db的
|
||
return content.includes(randomDrawId) && attachments.length > 0 && !histroyMessageIds.includes(item?.id);
|
||
});
|
||
return matchingItem || null;
|
||
}
|
||
|
||
/* 判断是否是变体图片 */
|
||
isVariationsImage(str) {
|
||
const regex = /- Variations/;
|
||
return regex.test(str);
|
||
}
|
||
|
||
/* 判读是否是单张图片从而 */
|
||
isSingleImage(str) {
|
||
const regex = /Image #\d+/;
|
||
return regex.test(str);
|
||
}
|
||
|
||
/* 判断是否不是变体或者放大、防止拿图的时候 重新生成匹配到了变体或者 放大 */
|
||
isReGenerateImage(str) {
|
||
return !this.isVariationsImage(str) && !this.isSingleImage(str);
|
||
}
|
||
|
||
/* 判断是不是增强的图 */
|
||
isVaryImage(str) {
|
||
const regex = /- Variations \(.*?\)/;
|
||
return regex.test(str);
|
||
}
|
||
|
||
/* 判断是不是缩放图 */
|
||
isZoomImage(str) {
|
||
const regex = /- Zoom Out/;
|
||
return regex.test(str);
|
||
}
|
||
|
||
/* 获取Mj参数 */
|
||
async getMjDefaultParams() {
|
||
const configs = await this.globalConfigService.getConfigs([
|
||
'mjId',
|
||
'mjApplicationId',
|
||
'mjGuildId',
|
||
'mjChannelId',
|
||
'mjSessionId',
|
||
'mjVersion',
|
||
'mjAuthorization',
|
||
'mjRateLimit',
|
||
'mjProxy',
|
||
]);
|
||
const params = {
|
||
application_id: configs.mjApplicationId,
|
||
guild_id: configs.mjGuildId,
|
||
channel_id: configs.mjChannelId,
|
||
session_id: configs.mjSessionId,
|
||
version: configs.mjVersion,
|
||
id: configs.mjId,
|
||
authorization: configs.mjAuthorization,
|
||
mjRateLimit: configs.mjRateLimit,
|
||
mjProxy: configs.mjProxy || 0,
|
||
};
|
||
return params;
|
||
}
|
||
|
||
/* 查询绘画的所有列表 */
|
||
async getMessageList() {
|
||
try {
|
||
const { application_id, guild_id, channel_id, session_id, version, id, authorization, mjProxy } = await this.getMjDefaultParams();
|
||
const mjProxyUrl = (await this.globalConfigService.getConfigs(['mjProxyUrl'])) || 'http://172.247.48.137:8000';
|
||
const url =
|
||
mjProxy == 1 ? `${mjProxyUrl}/mj/list?channel_id=${channel_id}` : `https://discord.com/api/v9/channels/${channel_id}/messages?limit=50`;
|
||
const headers = { authorization };
|
||
const response = await axios.get(url, { headers });
|
||
return response.data;
|
||
} catch (error) {
|
||
Logger.error('查询绘制结果失败: getMessageList', error, 'MidjourneyService');
|
||
return [];
|
||
}
|
||
}
|
||
|
||
/* 通过content拿到百分比进度 */
|
||
parseProgress(content) {
|
||
const regex = /\((\d+)%\)/;
|
||
const match = content.match(regex);
|
||
|
||
if (match) {
|
||
return parseInt(match[1], 10);
|
||
} else {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
/* 去除字符串表情 防止低版本数据库存入失败 */
|
||
removeEmoji(str) {
|
||
const regex = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
|
||
return str.replace(regex, '');
|
||
}
|
||
|
||
/* 绑定jobId到绘画记录 */
|
||
async bindJobId(id, jobId) {
|
||
await this.midjourneyEntity.update({ id }, { jobId });
|
||
}
|
||
|
||
/* 获取我的绘制列表 */
|
||
async getDrawList(req: Request, params) {
|
||
try {
|
||
const { page = 1, size = 30 } = params;
|
||
const [rows, count] = await this.midjourneyEntity.findAndCount({
|
||
where: { userId: req.user.id, isDelete: 0 },
|
||
order: { id: 'DESC' },
|
||
take: size,
|
||
skip: (page - 1) * size,
|
||
});
|
||
const mjProxyImgUrl = await this.globalConfigService.getConfigs(['mjProxyImgUrl']);
|
||
rows.forEach((item: any) => {
|
||
try {
|
||
const { extend, isSaveImg, fileInfo } = item;
|
||
const originUrl = JSON.parse(extend)?.attachments[0]?.url;
|
||
item.fileInfo = this.formatFileInfo(fileInfo, isSaveImg, mjProxyImgUrl, originUrl);
|
||
item.isGroup = JSON.parse(extend)?.components[0]?.components[0].label === 'U1';
|
||
item.originUrl = originUrl;
|
||
} catch (error) {}
|
||
});
|
||
const countQueue = await this.midjourneyEntity.count({ where: { isDelete: 0, status: In([1, 2]) } });
|
||
const data: any = { rows: formatCreateOrUpdateDate(rows), count, countQueue };
|
||
return data;
|
||
} catch (error) {
|
||
throw new HttpException('获取我得绘制列表失败', HttpStatus.BAD_REQUEST);
|
||
}
|
||
}
|
||
|
||
/* 格式化fileinfo 对于不同平台的图片进行压缩 */
|
||
formatFileInfo(fileInfo, isSaveImg, mjProxyImgUrl, originUrl) {
|
||
if (!fileInfo) return {};
|
||
let parseFileInfo: any = null;
|
||
try {
|
||
parseFileInfo = JSON.parse(fileInfo);
|
||
} catch (error) {
|
||
parseFileInfo = null;
|
||
}
|
||
if (!parseFileInfo) return;
|
||
const { url, filename, size, cosUrl, width, height } = parseFileInfo;
|
||
const targetSize = 310; // 目标宽度或高度
|
||
|
||
// TODO判断逻辑有误 腾讯云会导致也判断为 chevereto 更换判断规则
|
||
const imgType = cosUrl.includes('cos') ? 'tencent' : cosUrl.includes('oss') ? 'ali' : 'chevereto';
|
||
let compress;
|
||
let thumbImg;
|
||
if (imgType === 'tencent') {
|
||
const ratio = width / height;
|
||
const targetHeight = Math.round(targetSize / ratio); // 计算目标高度
|
||
thumbImg = cosUrl + `?imageView2/1/w/${targetSize}/h/${targetHeight}/q/55`;
|
||
}
|
||
if (imgType === 'ali') {
|
||
const ratio = height / width;
|
||
const targetWidth = Math.round(targetSize / ratio); // 计算目标宽度
|
||
thumbImg = cosUrl + `?x-oss-process=image/resize,w_${targetWidth}`;
|
||
}
|
||
if (imgType === 'chevereto') {
|
||
thumbImg = cosUrl.replace(/\.png$/, '.md.png');
|
||
}
|
||
parseFileInfo.thumbImg = thumbImg;
|
||
/* 如果配置了不存储图片 则 isSaceImg 为false的则需要使用反代地址拼接 */
|
||
if (!isSaveImg) {
|
||
const proxyImgUrl = `${mjProxyImgUrl}/mj/pipe?url=${originUrl}`;
|
||
parseFileInfo.thumbImg = proxyImgUrl;
|
||
parseFileInfo.cosUrl = proxyImgUrl;
|
||
}
|
||
return parseFileInfo;
|
||
}
|
||
|
||
/* 变体或者放大的时候去获取需要的信息 */
|
||
async getDrawActionDetail(action, drawId, orderId) {
|
||
const detailInfo = await this.midjourneyEntity.findOne({ where: { id: drawId } });
|
||
if (!detailInfo) throw new HttpException('当前绘画信息不存在！', HttpStatus.BAD_REQUEST);
|
||
const { extend, message_id, prompt, imgUrl, extraParam, randomDrawId } = detailInfo;
|
||
const historyDetailDrawInfo = JSON.parse(extend);
|
||
const { components = [] } = historyDetailDrawInfo;
|
||
if (!components.length) {
|
||
throw new HttpException('当前图片没有绘画信息、无法放大!', HttpStatus.BAD_REQUEST);
|
||
}
|
||
/* 对于四张图组图这种 components数组 第一项 有五个数据 分别对应1-4的图片所需参数和重新绘制参数 5对应重新绘制 第二项则是对应变换的四张图 */
|
||
let currentImgComponent: any = {};
|
||
if (action === MidjourneyActionEnum.UPSCALE) {
|
||
currentImgComponent = components[0]['components'][orderId - 1];
|
||
}
|
||
if (action === MidjourneyActionEnum.VARIATION) {
|
||
currentImgComponent = components[1]['components'][orderId - 1];
|
||
}
|
||
if (action === MidjourneyActionEnum.REGENERATE) {
|
||
currentImgComponent = components[0]['components'][orderId - 1];
|
||
}
|
||
/* 对于单张图来说 components数组 第一项 有两个 分别对应 Vary (Strong) Vary (Subtle) 第二项则是 Zoom Out 2x | Zoom Out 1.5x | custom */
|
||
if (action === MidjourneyActionEnum.VARY) {
|
||
currentImgComponent = components[0]['components'][orderId - 1];
|
||
}
|
||
if (action === MidjourneyActionEnum.ZOOM) {
|
||
currentImgComponent = components[1]['components'][orderId - 1];
|
||
}
|
||
const { custom_id } = currentImgComponent;
|
||
return { custom_id, message_id, prompt, imgUrl, extraParam, randomDrawId };
|
||
}
|
||
|
||
/* 检测当前图片是否已经放大过了 */
|
||
async checkIsUpscale(custom_id) {
|
||
// 查看count是不是大于0就行
|
||
const count = await this.midjourneyEntity.count({ where: { custom_id, status: MidjourneyStatusEnum.DRAWED } });
|
||
if (count > 0) {
|
||
throw new HttpException('当前图片已经放大过了！', HttpStatus.BAD_REQUEST);
|
||
}
|
||
}
|
||
|
||
/* 删除图片 */
|
||
async deleteDraw(id: number, req: Request) {
|
||
const d = await this.midjourneyEntity.findOne({ where: { id, userId: req.user.id, isDelete: 0 } });
|
||
if (!d) {
|
||
throw new HttpException('当前图片不存在！', HttpStatus.BAD_REQUEST);
|
||
}
|
||
if (d.status === 2) {
|
||
throw new HttpException('绘制中的图片任务、禁止删除！', HttpStatus.BAD_REQUEST);
|
||
}
|
||
const res = await this.midjourneyEntity.update({ id }, { isDelete: 1 });
|
||
if (res.affected > 0) {
|
||
return '删除成功！';
|
||
} else {
|
||
throw new HttpException('删除失败！', HttpStatus.BAD_REQUEST);
|
||
}
|
||
}
|
||
|
||
/* 限制同时最多两个任务进行中 */
|
||
async checkLimit(req: Request) {
|
||
const { role, id } = req.user;
|
||
// if (['super', 'admin'].includes(role)) {
|
||
// return;
|
||
// }
|
||
const count = await this.midjourneyEntity.count({ where: { userId: id, isDelete: 0, status: In([1, 2]) } });
|
||
const mjLimitCount = await this.globalConfigService.getConfigs(['mjLimitCount']);
|
||
const max = mjLimitCount ? Number(mjLimitCount) : 2;
|
||
if (count >= max) {
|
||
throw new HttpException(`当前管理员限制单用户同时最多能执行${max}个任务`, HttpStatus.BAD_REQUEST);
|
||
}
|
||
}
|
||
|
||
/* 队列回调绘图失败时候 */
|
||
async drawFailed(jobData) {
|
||
const { id, userId, action } = jobData;
|
||
/* 退还余额 放大图片（类型2）是1 其他都是4 */
|
||
// const amount = action === 2 ? 1 : 4;
|
||
// await this.userBalanceService.refundMjBalance(userId, amount);
|
||
await this.midjourneyEntity.update({ id }, { status: 4 });
|
||
}
|
||
|
||
/* 绘图成功扣费 */
|
||
async drawSuccess(jobData) {
|
||
const { id, userId, action } = jobData;
|
||
/* 扣除余额 放大图片（类型2）是1 其他都是4 */
|
||
const amount = action === 2 ? 1 : 4;
|
||
Logger.debug(`绘画完成，执行扣费，扣除费用:${amount}积分。`);
|
||
await this.userBalanceService.refundMjBalance(userId, -amount);
|
||
await this.midjourneyEntity.update({ id }, { status: 3 });
|
||
}
|
||
|
||
/* 获取绘画列表 */
|
||
async getList(params: GetListDto) {
|
||
const { page = 1, size = 20, rec, userId, status } = params;
|
||
|
||
/* 客户端查询走缓存 */
|
||
if (Number(size) === 999) {
|
||
const cache = await this.redisCacheService.get({ key: 'midjourney:getList' });
|
||
if (cache) {
|
||
try {
|
||
return JSON.parse(cache);
|
||
} catch (error) {
|
||
return [];
|
||
}
|
||
}
|
||
}
|
||
|
||
const where = { isDelete: 0 };
|
||
rec && Object.assign(where, { rec });
|
||
userId && Object.assign(where, { userId });
|
||
status && Object.assign(where, { status });
|
||
const [rows, count] = await this.midjourneyEntity.findAndCount({
|
||
where,
|
||
order: { id: 'DESC' },
|
||
take: size,
|
||
skip: (page - 1) * size,
|
||
select: ['fileInfo', 'extend', 'prompt', 'createdAt', 'id', 'extend', 'fullPrompt', 'rec', 'isSaveImg'],
|
||
});
|
||
const mjProxyImgUrl = await this.globalConfigService.getConfigs(['mjProxyImgUrl']);
|
||
rows.forEach((item: any) => {
|
||
try {
|
||
const { extend, isSaveImg, fileInfo } = item;
|
||
const originUrl = JSON.parse(extend)?.attachments[0]?.url;
|
||
item.fileInfo = this.formatFileInfo(fileInfo, isSaveImg, mjProxyImgUrl, originUrl);
|
||
item.isGroup = JSON.parse(extend)?.components[0]?.components[0].label === 'U1';
|
||
item.originUrl = originUrl;
|
||
} catch (error) {}
|
||
});
|
||
|
||
if (Number(size) === 999) {
|
||
const data = {
|
||
rows: rows.map((item: any) => {
|
||
const { fileInfo, prompt, createdAt, id, fullPrompt, rec, originUrl } = item;
|
||
return { fileInfo, prompt, createdAt, id, fullPrompt, rec, originUrl };
|
||
}),
|
||
count,
|
||
};
|
||
await this.redisCacheService.set({ key: 'midjourney:getList', val: JSON.stringify(data) }, 60 * 5);
|
||
return data;
|
||
}
|
||
const data = { rows, count };
|
||
return data;
|
||
}
|
||
|
||
/* */
|
||
async getFullPrompt(id: number) {
|
||
const m = await this.midjourneyEntity.findOne({ where: { id } });
|
||
if (!m) return '';
|
||
const { fullPrompt } = m;
|
||
return fullPrompt;
|
||
}
|
||
|
||
/* 管理端获取绘画列表 */
|
||
async getAdminDrawList(req: Request, params: GetListDto) {
|
||
try {
|
||
const { page = 1, size = 10, rec, userId, status } = params;
|
||
const where = { isDelete: 0 };
|
||
rec && Object.assign(where, { rec });
|
||
userId && Object.assign(where, { userId });
|
||
status && Object.assign(where, { status });
|
||
const [rows, count] = await this.midjourneyEntity.findAndCount({
|
||
where,
|
||
order: { id: 'DESC' },
|
||
take: size,
|
||
skip: (page - 1) * size,
|
||
});
|
||
|
||
const userIds = rows.map((item: any) => item.userId).filter((id) => id < 100000);
|
||
const userInfos = await this.userEntity.find({ where: { id: In(userIds) }, select: ['id', 'username', 'avatar', 'email'] });
|
||
rows.forEach((item: any) => {
|
||
item.userInfo = userInfos.find((user) => user.id === item.userId);
|
||
});
|
||
const mjProxyImgUrl = await this.globalConfigService.getConfigs(['mjProxyImgUrl']);
|
||
rows.forEach((item: any) => {
|
||
try {
|
||
const { extend, isSaveImg, fileInfo } = item;
|
||
const originUrl = JSON.parse(extend)?.attachments[0]?.url;
|
||
item.fileInfo = this.formatFileInfo(fileInfo, isSaveImg, mjProxyImgUrl, originUrl);
|
||
// item.isGroup = JSON.parse(extend)?.components[0]?.components.length === 5;
|
||
item.isGroup = JSON.parse(extend)?.components[0]?.components[0].label === 'U1';
|
||
item.originUrl = originUrl;
|
||
} catch (error) {}
|
||
});
|
||
if (req.user.role !== 'super') {
|
||
rows.forEach((item: any) => {
|
||
if (item.userInfo && item.userInfo.email) {
|
||
item.userInfo.email = item.userInfo.email.replace(/(.{2}).+(.{2}@.+)/, '$1****$2');
|
||
}
|
||
});
|
||
}
|
||
return { rows, count };
|
||
} catch (error) {
|
||
throw new HttpException('查询失败！', HttpStatus.BAD_REQUEST);
|
||
}
|
||
}
|
||
|
||
/* 推荐与取消推荐图片 */
|
||
async recDraw(params) {
|
||
const { id } = params;
|
||
const draw = await this.midjourneyEntity.findOne({ where: { id, status: 3, isDelete: 0 } });
|
||
if (!draw) {
|
||
throw new HttpException('当前图片不存在！', HttpStatus.BAD_REQUEST);
|
||
}
|
||
const { rec } = draw;
|
||
const res = await this.midjourneyEntity.update({ id }, { rec: rec === 1 ? 0 : 1 });
|
||
if (res.affected > 0) {
|
||
return '操作成功！';
|
||
}
|
||
}
|
||
|
||
/* 清空数据库的队列 */
|
||
async cleanQueue() {
|
||
try {
|
||
await this.midjourneyEntity.update({ status: 2 }, { status: 4 });
|
||
} catch (error) {
|
||
console.log('TODO->error: ', error);
|
||
}
|
||
}
|
||
|
||
/* 删除记录 */
|
||
async delLog(req: Request, body) {
|
||
const { id } = body;
|
||
if (!id) {
|
||
throw new HttpException('非法操作！', HttpStatus.BAD_REQUEST);
|
||
}
|
||
const res = await this.midjourneyEntity.delete({ id });
|
||
if (res.affected > 0) {
|
||
return '删除记录成功！';
|
||
} else {
|
||
throw new HttpException('删除记录失败！', HttpStatus.BAD_REQUEST);
|
||
}
|
||
}
|
||
|
||
async setPrompt(req: Request, body) {
|
||
try {
|
||
const { prompt, status, isCarryParams, title, order, id, aspect } = body;
|
||
if (id) {
|
||
return await this.mjPromptsEntity.update({ id }, { prompt, status, isCarryParams, order, aspect });
|
||
} else {
|
||
return await this.mjPromptsEntity.save({ prompt, status, isCarryParams, title, order, aspect });
|
||
}
|
||
} catch (error) {
|
||
console.log('error: ', error);
|
||
}
|
||
}
|
||
|
||
async delPrompt(req: Request, body) {
|
||
const { id } = body;
|
||
if (!id) {
|
||
throw new HttpException('非法操作！', HttpStatus.BAD_REQUEST);
|
||
}
|
||
return await this.mjPromptsEntity.delete({ id });
|
||
}
|
||
|
||
async queryPrompt() {
|
||
return await this.mjPromptsEntity.find({
|
||
order: { order: 'DESC' },
|
||
});
|
||
}
|
||
|
||
async proxyImg(params) {
|
||
const { url } = params;
|
||
if (!url) return;
|
||
const response = await axios.get(url, { responseType: 'arraybuffer' });
|
||
const base64 = Buffer.from(response.data).toString('base64');
|
||
return base64;
|
||
}
|
||
}
|