987 lines
30 KiB
TypeScript
987 lines
30 KiB
TypeScript
import { Injectable } from '@nestjs/common';
|
||
import { Prisma } from '@prisma/client';
|
||
import { Decimal } from '@prisma/client/runtime/library';
|
||
import { resolveTranslationFallback } from '@thebet365/shared';
|
||
import { PrismaService } from '../../shared/prisma/prisma.service';
|
||
import { FundsPostingService } from '../ledger/funds-posting.service';
|
||
import { AgentCreditService } from '../agent/agent-credit.service';
|
||
import { appBadRequest } from '../../shared/common/app-error';
|
||
import { deleteUploadFileByUrl } from '../../shared/uploads/delete-upload-file';
|
||
import { PlayerMessagesService } from '../player-messages/player-messages.service';
|
||
import { SystemConfigService } from '../../shared/config/system-config.service';
|
||
|
||
function generateOrderNo(): string {
|
||
const ts = Date.now().toString(36).toUpperCase();
|
||
const rand = Math.random().toString(36).substring(2, 8).toUpperCase();
|
||
return `DEP${ts}${rand}`;
|
||
}
|
||
|
||
/** 已通过充值订单允许撤回的时间窗口 */
|
||
const DEPOSIT_REVOKE_WINDOW_MS = 5 * 60 * 1000;
|
||
|
||
export type DepositOrderAuditAction =
|
||
| 'SUBMITTED'
|
||
| 'APPROVED'
|
||
| 'REJECTED'
|
||
| 'REVOKED'
|
||
| 'REOPENED'
|
||
| 'DELETED';
|
||
|
||
type AuditLogWriter = {
|
||
depositOrderAuditLog: {
|
||
create: (args: {
|
||
data: {
|
||
depositOrderId: bigint;
|
||
action: DepositOrderAuditAction;
|
||
actorId?: bigint | null;
|
||
actorType: string;
|
||
statusBefore?: string | null;
|
||
statusAfter: string;
|
||
amount?: Decimal | null;
|
||
approvedAmount?: Decimal | null;
|
||
remark?: string | null;
|
||
};
|
||
}) => Promise<{ id: bigint }>;
|
||
};
|
||
};
|
||
|
||
@Injectable()
|
||
export class DepositService {
|
||
constructor(
|
||
private prisma: PrismaService,
|
||
private funds: FundsPostingService,
|
||
private credit: AgentCreditService,
|
||
private playerMessages: PlayerMessagesService,
|
||
private systemConfig: SystemConfigService,
|
||
) {}
|
||
|
||
// ============ Payment Methods (Admin CRUD) ============
|
||
|
||
/** isActive 与 showOnPlayer 合并为同一开关，DB 两列保持同步以兼容旧数据。 */
|
||
private normalizePaymentMethodActive(data: {
|
||
isActive?: boolean;
|
||
showOnPlayer?: boolean;
|
||
}): { isActive?: boolean; showOnPlayer?: boolean } {
|
||
if (data.isActive !== undefined) {
|
||
return { isActive: data.isActive, showOnPlayer: data.isActive };
|
||
}
|
||
if (data.showOnPlayer !== undefined) {
|
||
return { isActive: data.showOnPlayer, showOnPlayer: data.showOnPlayer };
|
||
}
|
||
return {};
|
||
}
|
||
|
||
async createPaymentMethod(data: {
|
||
methodType: string;
|
||
bankName?: string;
|
||
accountHolder?: string;
|
||
accountNumber?: string;
|
||
usdtAddress?: string;
|
||
qrCodeUrl?: string;
|
||
displayName?: string;
|
||
sortOrder?: number;
|
||
isActive?: boolean;
|
||
showOnPlayer?: boolean;
|
||
createdBy?: bigint;
|
||
translations?: {
|
||
displayName?: Record<string, string>;
|
||
bankName?: Record<string, string>;
|
||
};
|
||
}) {
|
||
const active = data.isActive ?? data.showOnPlayer ?? true;
|
||
const method = await this.prisma.paymentMethod.create({
|
||
data: {
|
||
methodType: data.methodType,
|
||
bankName: data.bankName,
|
||
accountHolder: data.accountHolder,
|
||
accountNumber: data.accountNumber,
|
||
usdtAddress: data.usdtAddress,
|
||
qrCodeUrl: data.qrCodeUrl,
|
||
displayName: data.displayName,
|
||
sortOrder: data.sortOrder ?? 0,
|
||
isActive: active,
|
||
showOnPlayer: active,
|
||
createdBy: data.createdBy,
|
||
},
|
||
});
|
||
if (data.translations) {
|
||
await this.upsertPaymentMethodTranslations(method.id, data.translations);
|
||
}
|
||
return method;
|
||
}
|
||
|
||
async updatePaymentMethod(
|
||
id: bigint,
|
||
data: {
|
||
bankName?: string;
|
||
accountHolder?: string;
|
||
accountNumber?: string;
|
||
usdtAddress?: string;
|
||
qrCodeUrl?: string;
|
||
displayName?: string;
|
||
sortOrder?: number;
|
||
isActive?: boolean;
|
||
showOnPlayer?: boolean;
|
||
translations?: {
|
||
displayName?: Record<string, string>;
|
||
bankName?: Record<string, string>;
|
||
};
|
||
},
|
||
) {
|
||
const { translations, ...rest } = data;
|
||
const activePatch = this.normalizePaymentMethodActive(rest);
|
||
const method = await this.prisma.paymentMethod.update({
|
||
where: { id },
|
||
data: { ...rest, ...activePatch },
|
||
});
|
||
if (translations) {
|
||
await this.upsertPaymentMethodTranslations(id, translations);
|
||
}
|
||
return method;
|
||
}
|
||
|
||
async deletePaymentMethod(id: bigint) {
|
||
return this.prisma.paymentMethod.update({
|
||
where: { id },
|
||
data: { isActive: false, showOnPlayer: false },
|
||
});
|
||
}
|
||
|
||
async listPaymentMethods(filters?: { methodType?: string }) {
|
||
const where: Prisma.PaymentMethodWhereInput = {};
|
||
if (filters?.methodType) {
|
||
where.methodType = filters.methodType;
|
||
}
|
||
const items = await this.prisma.paymentMethod.findMany({
|
||
where,
|
||
orderBy: [{ sortOrder: 'asc' }, { createdAt: 'desc' }],
|
||
});
|
||
// Attach translations for admin editing
|
||
const ids = items.map((m) => m.id);
|
||
const translations = ids.length
|
||
? await this.prisma.entityTranslation.findMany({
|
||
where: { entityType: 'PAYMENT_METHOD', entityId: { in: ids } },
|
||
})
|
||
: [];
|
||
const tMap = new Map<string, Record<string, Record<string, string>>>();
|
||
for (const t of translations) {
|
||
const key = t.entityId.toString();
|
||
if (!tMap.has(key)) tMap.set(key, {});
|
||
const entityMap = tMap.get(key)!;
|
||
if (!entityMap[t.fieldName]) entityMap[t.fieldName] = {};
|
||
entityMap[t.fieldName][t.locale] = t.value;
|
||
}
|
||
return items.map((m) => ({
|
||
...m,
|
||
translations: tMap.get(m.id.toString()) ?? {},
|
||
}));
|
||
}
|
||
|
||
async listPlayerPaymentMethods(methodType?: string, locale?: string) {
|
||
const where: Prisma.PaymentMethodWhereInput = {
|
||
isActive: true,
|
||
};
|
||
if (methodType) {
|
||
where.methodType = methodType;
|
||
}
|
||
const items = await this.prisma.paymentMethod.findMany({
|
||
where,
|
||
orderBy: [{ sortOrder: 'asc' }, { createdAt: 'desc' }],
|
||
select: {
|
||
id: true,
|
||
methodType: true,
|
||
bankName: true,
|
||
accountHolder: true,
|
||
accountNumber: true,
|
||
usdtAddress: true,
|
||
qrCodeUrl: true,
|
||
displayName: true,
|
||
sortOrder: true,
|
||
},
|
||
});
|
||
// Resolve translations for player locale
|
||
if (locale && items.length) {
|
||
const ids = items.map((m) => m.id);
|
||
const translations = await this.prisma.entityTranslation.findMany({
|
||
where: { entityType: 'PAYMENT_METHOD', entityId: { in: ids } },
|
||
});
|
||
const tMap = new Map<string, Record<string, Record<string, string>>>();
|
||
for (const t of translations) {
|
||
const key = t.entityId.toString();
|
||
if (!tMap.has(key)) tMap.set(key, {});
|
||
const entityMap = tMap.get(key)!;
|
||
if (!entityMap[t.fieldName]) entityMap[t.fieldName] = {};
|
||
entityMap[t.fieldName][t.locale] = t.value;
|
||
}
|
||
return items.map((m) => {
|
||
const t = tMap.get(m.id.toString());
|
||
const resolvedDisplayName = t?.displayName
|
||
? resolveTranslationFallback(t.displayName, locale) || m.displayName
|
||
: m.displayName;
|
||
const resolvedBankName = t?.bankName
|
||
? resolveTranslationFallback(t.bankName, locale) || m.bankName
|
||
: m.bankName;
|
||
return { ...m, displayName: resolvedDisplayName, bankName: resolvedBankName };
|
||
});
|
||
}
|
||
return items;
|
||
}
|
||
|
||
// ============ Translation helpers ============
|
||
|
||
private async upsertPaymentMethodTranslations(
|
||
entityId: bigint,
|
||
translations: {
|
||
displayName?: Record<string, string>;
|
||
bankName?: Record<string, string>;
|
||
},
|
||
) {
|
||
for (const fieldName of ['displayName', 'bankName'] as const) {
|
||
const fieldTranslations = translations[fieldName];
|
||
if (!fieldTranslations) continue;
|
||
for (const [locale, value] of Object.entries(fieldTranslations)) {
|
||
await this.prisma.entityTranslation.upsert({
|
||
where: {
|
||
entityType_entityId_locale_fieldName: {
|
||
entityType: 'PAYMENT_METHOD',
|
||
entityId,
|
||
locale,
|
||
fieldName,
|
||
},
|
||
},
|
||
create: { entityType: 'PAYMENT_METHOD', entityId, locale, fieldName, value },
|
||
update: { value },
|
||
});
|
||
}
|
||
}
|
||
}
|
||
|
||
// ============ Deposit Orders ============
|
||
|
||
private async getPlayerLocale(playerId: bigint, tx: Prisma.TransactionClient | PrismaService = this.prisma) {
|
||
const user = await tx.user.findUnique({
|
||
where: { id: playerId },
|
||
select: { locale: true },
|
||
});
|
||
return user?.locale ?? 'en-US';
|
||
}
|
||
|
||
private async recordDepositAudit(
|
||
client: AuditLogWriter,
|
||
data: {
|
||
depositOrderId: bigint;
|
||
action: DepositOrderAuditAction;
|
||
actorId?: bigint | null;
|
||
actorType: 'PLAYER' | 'ADMIN';
|
||
statusBefore?: string | null;
|
||
statusAfter: string;
|
||
amount?: Decimal | null;
|
||
approvedAmount?: Decimal | null;
|
||
remark?: string | null;
|
||
},
|
||
) {
|
||
return client.depositOrderAuditLog.create({
|
||
data: {
|
||
depositOrderId: data.depositOrderId,
|
||
action: data.action,
|
||
actorId: data.actorId ?? null,
|
||
actorType: data.actorType,
|
||
statusBefore: data.statusBefore ?? null,
|
||
statusAfter: data.statusAfter,
|
||
amount: data.amount ?? null,
|
||
approvedAmount: data.approvedAmount ?? null,
|
||
remark: data.remark ?? null,
|
||
},
|
||
});
|
||
}
|
||
|
||
private mapAuditLogRow(
|
||
row: {
|
||
id: bigint;
|
||
action: string;
|
||
actorId: bigint | null;
|
||
actorType: string;
|
||
statusBefore: string | null;
|
||
statusAfter: string;
|
||
amount: Decimal | null;
|
||
approvedAmount: Decimal | null;
|
||
remark: string | null;
|
||
createdAt: Date;
|
||
},
|
||
actorUsername?: string | null,
|
||
) {
|
||
return {
|
||
id: row.id.toString(),
|
||
action: row.action,
|
||
actorId: row.actorId?.toString() ?? null,
|
||
actorType: row.actorType,
|
||
actorUsername: actorUsername ?? null,
|
||
statusBefore: row.statusBefore,
|
||
statusAfter: row.statusAfter,
|
||
amount: row.amount?.toString() ?? null,
|
||
approvedAmount: row.approvedAmount?.toString() ?? null,
|
||
remark: row.remark,
|
||
createdAt: row.createdAt.toISOString(),
|
||
};
|
||
}
|
||
|
||
async getDepositOrderAuditLogs(orderId: bigint) {
|
||
const order = await this.prisma.depositOrder.findUnique({
|
||
where: { id: orderId },
|
||
select: { id: true },
|
||
});
|
||
if (!order) throw appBadRequest('ORDER_NOT_FOUND');
|
||
|
||
const rows = await this.prisma.depositOrderAuditLog.findMany({
|
||
where: { depositOrderId: orderId },
|
||
orderBy: { createdAt: 'asc' },
|
||
});
|
||
|
||
const actorIds = [...new Set(rows.map((r) => r.actorId).filter((id): id is bigint => id != null))];
|
||
const actors =
|
||
actorIds.length > 0
|
||
? await this.prisma.user.findMany({
|
||
where: { id: { in: actorIds } },
|
||
select: { id: true, username: true },
|
||
})
|
||
: [];
|
||
const actorMap = new Map(actors.map((a) => [a.id.toString(), a.username]));
|
||
|
||
return rows.map((row) =>
|
||
this.mapAuditLogRow(
|
||
row,
|
||
row.actorId ? actorMap.get(row.actorId.toString()) ?? null : null,
|
||
),
|
||
);
|
||
}
|
||
|
||
async getPlayerDepositOrderAuditLogs(orderId: bigint, playerId: bigint) {
|
||
const order = await this.prisma.depositOrder.findFirst({
|
||
where: { id: orderId, playerId },
|
||
select: { id: true },
|
||
});
|
||
if (!order) throw appBadRequest('ORDER_NOT_FOUND');
|
||
|
||
const rows = await this.prisma.depositOrderAuditLog.findMany({
|
||
where: { depositOrderId: orderId },
|
||
orderBy: { createdAt: 'asc' },
|
||
});
|
||
|
||
return rows.map((row) => {
|
||
const mapped = this.mapAuditLogRow(row);
|
||
return {
|
||
id: mapped.id,
|
||
action: mapped.action,
|
||
actorType: mapped.actorType,
|
||
statusBefore: mapped.statusBefore,
|
||
statusAfter: mapped.statusAfter,
|
||
amount: mapped.amount,
|
||
approvedAmount: mapped.approvedAmount,
|
||
remark: mapped.remark,
|
||
createdAt: mapped.createdAt,
|
||
};
|
||
});
|
||
}
|
||
|
||
private async attachPlayerAuditLogs(
|
||
orders: Array<{ id: bigint }>,
|
||
) {
|
||
if (!orders.length) return new Map<string, ReturnType<typeof this.mapAuditLogRow>[]>();
|
||
|
||
const orderIds = orders.map((o) => o.id);
|
||
const rows = await this.prisma.depositOrderAuditLog.findMany({
|
||
where: { depositOrderId: { in: orderIds } },
|
||
orderBy: { createdAt: 'asc' },
|
||
});
|
||
|
||
const map = new Map<string, ReturnType<typeof this.mapAuditLogRow>[]>();
|
||
for (const row of rows) {
|
||
const key = row.depositOrderId.toString();
|
||
if (!map.has(key)) map.set(key, []);
|
||
const mapped = this.mapAuditLogRow(row);
|
||
map.get(key)!.push({
|
||
id: mapped.id,
|
||
action: mapped.action,
|
||
actorId: null,
|
||
actorType: mapped.actorType,
|
||
actorUsername: null,
|
||
statusBefore: mapped.statusBefore,
|
||
statusAfter: mapped.statusAfter,
|
||
amount: mapped.amount,
|
||
approvedAmount: mapped.approvedAmount,
|
||
remark: mapped.remark,
|
||
createdAt: mapped.createdAt,
|
||
});
|
||
}
|
||
return map;
|
||
}
|
||
|
||
async createDepositOrder(
|
||
playerId: bigint,
|
||
paymentMethodId: bigint,
|
||
amount: number,
|
||
screenshotUrl: string,
|
||
) {
|
||
const method = await this.prisma.paymentMethod.findUnique({
|
||
where: { id: paymentMethodId },
|
||
});
|
||
if (!method || !method.isActive) {
|
||
throw appBadRequest('PAYMENT_METHOD_NOT_FOUND');
|
||
}
|
||
|
||
const order = await this.prisma.depositOrder.create({
|
||
data: {
|
||
orderNo: generateOrderNo(),
|
||
playerId,
|
||
paymentMethodId,
|
||
methodType: method.methodType,
|
||
amount: new Decimal(amount),
|
||
screenshotUrl,
|
||
status: 'PENDING',
|
||
},
|
||
});
|
||
|
||
await this.recordDepositAudit(this.prisma, {
|
||
depositOrderId: order.id,
|
||
action: 'SUBMITTED',
|
||
actorId: playerId,
|
||
actorType: 'PLAYER',
|
||
statusBefore: null,
|
||
statusAfter: 'PENDING',
|
||
amount: order.amount,
|
||
remark: null,
|
||
});
|
||
|
||
return order;
|
||
}
|
||
|
||
/** 玩家对已拒绝订单重新提交：原订单号不变，状态恢复待审核，需新转账截图。 */
|
||
async reapplyDepositOrder(
|
||
playerId: bigint,
|
||
orderId: bigint,
|
||
screenshotUrl: string,
|
||
amount?: number,
|
||
paymentMethodId?: bigint,
|
||
) {
|
||
return this.prisma.$transaction(async (tx) => {
|
||
const order = await this.lockDepositOrder(tx, orderId);
|
||
if (order.playerId !== playerId) throw appBadRequest('ORDER_NOT_FOUND');
|
||
if (order.status !== 'REJECTED') throw appBadRequest('ORDER_NOT_REJECTED');
|
||
|
||
const otherPending = await tx.depositOrder.findFirst({
|
||
where: {
|
||
playerId,
|
||
status: 'PENDING',
|
||
id: { not: orderId },
|
||
},
|
||
select: { id: true },
|
||
});
|
||
if (otherPending) throw appBadRequest('DEPOSIT_PENDING_ORDER_EXISTS');
|
||
|
||
const targetMethodId = paymentMethodId ?? order.paymentMethodId;
|
||
const method = await tx.paymentMethod.findUnique({ where: { id: targetMethodId } });
|
||
if (!method || !method.isActive) {
|
||
throw appBadRequest('PAYMENT_METHOD_NOT_FOUND');
|
||
}
|
||
|
||
const creditAmount = amount != null ? new Decimal(amount) : order.amount;
|
||
if (creditAmount.lte(0)) throw appBadRequest('INVALID_AMOUNT');
|
||
|
||
const oldScreenshotUrl = order.screenshotUrl;
|
||
|
||
await tx.depositOrder.update({
|
||
where: { id: orderId },
|
||
data: {
|
||
status: 'PENDING',
|
||
screenshotUrl,
|
||
amount: creditAmount,
|
||
paymentMethodId: targetMethodId,
|
||
methodType: method.methodType,
|
||
approvedAmount: null,
|
||
reviewerId: null,
|
||
reviewedAt: null,
|
||
rejectReason: null,
|
||
remark: null,
|
||
},
|
||
});
|
||
|
||
await this.recordDepositAudit(tx, {
|
||
depositOrderId: orderId,
|
||
action: 'REOPENED',
|
||
actorId: playerId,
|
||
actorType: 'PLAYER',
|
||
statusBefore: order.status,
|
||
statusAfter: 'PENDING',
|
||
amount: creditAmount,
|
||
remark: null,
|
||
});
|
||
|
||
await deleteUploadFileByUrl(oldScreenshotUrl);
|
||
|
||
return tx.depositOrder.findUnique({ where: { id: orderId } });
|
||
});
|
||
}
|
||
|
||
async getPlayerDepositOrders(playerId: bigint, page = 1, pageSize = 20) {
|
||
const skip = (page - 1) * pageSize;
|
||
const where = { playerId };
|
||
|
||
const [items, total] = await Promise.all([
|
||
this.prisma.depositOrder.findMany({
|
||
where,
|
||
orderBy: { createdAt: 'desc' },
|
||
skip,
|
||
take: pageSize,
|
||
include: {
|
||
paymentMethod: {
|
||
select: { bankName: true, usdtAddress: true, displayName: true, methodType: true },
|
||
},
|
||
},
|
||
}),
|
||
this.prisma.depositOrder.count({ where }),
|
||
]);
|
||
const auditMap = await this.attachPlayerAuditLogs(items);
|
||
|
||
return {
|
||
items: items.map((o) => ({
|
||
id: o.id.toString(),
|
||
orderNo: o.orderNo,
|
||
paymentMethodId: o.paymentMethodId.toString(),
|
||
methodType: o.methodType,
|
||
amount: o.amount.toString(),
|
||
screenshotUrl: o.screenshotUrl,
|
||
status: o.status,
|
||
approvedAmount: o.approvedAmount?.toString() ?? null,
|
||
rejectReason: o.rejectReason,
|
||
remark: o.remark,
|
||
createdAt: o.createdAt,
|
||
reviewedAt: o.reviewedAt,
|
||
paymentMethodName: o.paymentMethod?.displayName ?? o.paymentMethod?.bankName ?? o.paymentMethod?.usdtAddress ?? null,
|
||
auditLogs: (auditMap.get(o.id.toString()) ?? []).map((log) => ({
|
||
id: log.id,
|
||
action: log.action,
|
||
actorType: log.actorType,
|
||
statusBefore: log.statusBefore,
|
||
statusAfter: log.statusAfter,
|
||
amount: log.amount,
|
||
approvedAmount: log.approvedAmount,
|
||
remark: log.remark,
|
||
createdAt: log.createdAt,
|
||
})),
|
||
})),
|
||
total,
|
||
page,
|
||
pageSize,
|
||
};
|
||
}
|
||
|
||
async listDepositOrders(params: {
|
||
page?: number;
|
||
pageSize?: number;
|
||
status?: string;
|
||
keyword?: string;
|
||
methodType?: string;
|
||
dateFrom?: Date;
|
||
dateTo?: Date;
|
||
}) {
|
||
const page = Math.max(1, params.page ?? 1);
|
||
const pageSize = Math.min(100, Math.max(1, params.pageSize ?? 20));
|
||
const skip = (page - 1) * pageSize;
|
||
|
||
const where: Prisma.DepositOrderWhereInput = {};
|
||
|
||
if (params.status) {
|
||
where.status = params.status;
|
||
}
|
||
|
||
if (params.methodType) {
|
||
where.methodType = params.methodType;
|
||
}
|
||
|
||
if (params.dateFrom || params.dateTo) {
|
||
where.createdAt = {};
|
||
if (params.dateFrom) where.createdAt.gte = params.dateFrom;
|
||
if (params.dateTo) where.createdAt.lte = params.dateTo;
|
||
}
|
||
|
||
if (params.keyword?.trim()) {
|
||
const players = await this.prisma.user.findMany({
|
||
where: {
|
||
userType: 'PLAYER',
|
||
deletedAt: null,
|
||
username: { contains: params.keyword.trim(), mode: 'insensitive' },
|
||
},
|
||
select: { id: true },
|
||
take: 100,
|
||
});
|
||
if (!players.length) {
|
||
return { items: [], total: 0, page, pageSize };
|
||
}
|
||
where.playerId = { in: players.map((p) => p.id) };
|
||
}
|
||
|
||
const [rows, total] = await Promise.all([
|
||
this.prisma.depositOrder.findMany({
|
||
where,
|
||
orderBy: { createdAt: 'desc' },
|
||
skip,
|
||
take: pageSize,
|
||
include: {
|
||
paymentMethod: {
|
||
select: { bankName: true, usdtAddress: true, displayName: true, methodType: true },
|
||
},
|
||
},
|
||
}),
|
||
this.prisma.depositOrder.count({ where }),
|
||
]);
|
||
|
||
// Enrich with player usernames and reviewer info
|
||
const playerIds = [...new Set(rows.map((r) => r.playerId))];
|
||
const reviewerIds = [...new Set(rows.map((r) => r.reviewerId).filter((id): id is bigint => id != null))];
|
||
|
||
const [players, reviewers] = await Promise.all([
|
||
playerIds.length
|
||
? this.prisma.user.findMany({
|
||
where: { id: { in: playerIds } },
|
||
select: { id: true, username: true },
|
||
})
|
||
: [],
|
||
reviewerIds.length
|
||
? this.prisma.user.findMany({
|
||
where: { id: { in: reviewerIds } },
|
||
select: { id: true, username: true },
|
||
})
|
||
: [],
|
||
]);
|
||
|
||
const playerMap = new Map(players.map((p) => [p.id.toString(), p.username]));
|
||
const reviewerMap = new Map(reviewers.map((r) => [r.id.toString(), r.username]));
|
||
|
||
return {
|
||
items: rows.map((o) => ({
|
||
id: o.id.toString(),
|
||
orderNo: o.orderNo,
|
||
playerId: o.playerId.toString(),
|
||
playerUsername: playerMap.get(o.playerId.toString()) ?? null,
|
||
methodType: o.methodType,
|
||
amount: o.amount.toString(),
|
||
screenshotUrl: o.screenshotUrl,
|
||
status: o.status,
|
||
approvedAmount: o.approvedAmount?.toString() ?? null,
|
||
reviewerId: o.reviewerId?.toString() ?? null,
|
||
reviewerUsername: o.reviewerId ? (reviewerMap.get(o.reviewerId.toString()) ?? null) : null,
|
||
rejectReason: o.rejectReason,
|
||
remark: o.remark,
|
||
createdAt: o.createdAt,
|
||
reviewedAt: o.reviewedAt,
|
||
paymentMethodName: o.paymentMethod?.displayName ?? o.paymentMethod?.bankName ?? o.paymentMethod?.usdtAddress ?? null,
|
||
})),
|
||
total,
|
||
page,
|
||
pageSize,
|
||
};
|
||
}
|
||
|
||
async countPendingDepositOrders(): Promise<number> {
|
||
return this.prisma.depositOrder.count({ where: { status: 'PENDING' } });
|
||
}
|
||
|
||
async approveDepositOrder(
|
||
orderId: bigint,
|
||
operatorId: bigint,
|
||
approvedAmount?: number,
|
||
remark?: string,
|
||
) {
|
||
return this.prisma.$transaction(async (tx) => {
|
||
const order = await tx.depositOrder.findUnique({ where: { id: orderId } });
|
||
if (!order) throw appBadRequest('ORDER_NOT_FOUND');
|
||
if (order.status !== 'PENDING') throw appBadRequest('ORDER_NOT_PENDING');
|
||
|
||
const creditAmount = approvedAmount != null ? new Decimal(approvedAmount) : order.amount;
|
||
const parentAgentId = await this.assertParentCreditForDeposit(tx, order.playerId, creditAmount);
|
||
|
||
await tx.depositOrder.update({
|
||
where: { id: orderId },
|
||
data: {
|
||
status: 'APPROVED',
|
||
approvedAmount: creditAmount,
|
||
reviewerId: operatorId,
|
||
reviewedAt: new Date(),
|
||
remark: remark ?? null,
|
||
},
|
||
});
|
||
|
||
const auditLog = await this.recordDepositAudit(tx, {
|
||
depositOrderId: orderId,
|
||
action: 'APPROVED',
|
||
actorId: operatorId,
|
||
actorType: 'ADMIN',
|
||
statusBefore: order.status,
|
||
statusAfter: 'APPROVED',
|
||
amount: order.amount,
|
||
approvedAmount: creditAmount,
|
||
remark: remark ?? null,
|
||
});
|
||
|
||
// Credit player wallet
|
||
await this.funds.deposit({
|
||
userId: order.playerId,
|
||
amount: creditAmount,
|
||
operatorId,
|
||
remark: remark ?? `Deposit order ${order.orderNo}`,
|
||
referenceId: order.orderNo,
|
||
transactionType: 'PLAYER_DEPOSIT',
|
||
tx,
|
||
businessKey: `deposit:${order.orderNo}:approve:${auditLog.id}`,
|
||
});
|
||
if (parentAgentId) {
|
||
await this.credit.recalculateUsedCredit(parentAgentId, tx);
|
||
}
|
||
|
||
const playerLocale = await this.getPlayerLocale(order.playerId, tx);
|
||
const inboxNotify = await this.systemConfig.getInboxNotifySettings();
|
||
if (inboxNotify.inboxEnabled && inboxNotify.deposit) {
|
||
await this.playerMessages.createDepositApprovedMessage(
|
||
order.playerId,
|
||
{
|
||
depositOrderId: orderId,
|
||
orderNo: order.orderNo,
|
||
amount: order.amount.toString(),
|
||
approvedAmount: creditAmount.toString(),
|
||
locale: playerLocale,
|
||
},
|
||
tx,
|
||
);
|
||
}
|
||
|
||
return { success: true };
|
||
});
|
||
}
|
||
|
||
async rejectDepositOrder(orderId: bigint, operatorId: bigint, reason: string) {
|
||
const order = await this.prisma.depositOrder.findUnique({ where: { id: orderId } });
|
||
if (!order) throw appBadRequest('ORDER_NOT_FOUND');
|
||
if (order.status !== 'PENDING') throw appBadRequest('ORDER_NOT_PENDING');
|
||
|
||
await this.prisma.depositOrder.update({
|
||
where: { id: orderId },
|
||
data: {
|
||
status: 'REJECTED',
|
||
reviewerId: operatorId,
|
||
reviewedAt: new Date(),
|
||
rejectReason: reason,
|
||
remark: reason,
|
||
},
|
||
});
|
||
|
||
await this.recordDepositAudit(this.prisma, {
|
||
depositOrderId: orderId,
|
||
action: 'REJECTED',
|
||
actorId: operatorId,
|
||
actorType: 'ADMIN',
|
||
statusBefore: order.status,
|
||
statusAfter: 'REJECTED',
|
||
amount: order.amount,
|
||
remark: reason,
|
||
});
|
||
|
||
const playerLocale = await this.getPlayerLocale(order.playerId);
|
||
const inboxNotify = await this.systemConfig.getInboxNotifySettings();
|
||
if (inboxNotify.inboxEnabled && inboxNotify.deposit) {
|
||
await this.playerMessages.createDepositRejectedMessage(order.playerId, {
|
||
depositOrderId: orderId,
|
||
orderNo: order.orderNo,
|
||
amount: order.amount.toString(),
|
||
rejectReason: reason,
|
||
locale: playerLocale,
|
||
});
|
||
}
|
||
|
||
return { success: true };
|
||
}
|
||
|
||
private async reverseApprovedDepositCredit(
|
||
order: {
|
||
playerId: bigint;
|
||
orderNo: string;
|
||
approvedAmount: Decimal | null;
|
||
amount: Decimal;
|
||
},
|
||
operatorId: bigint,
|
||
remark: string,
|
||
) {
|
||
const credit = order.approvedAmount ?? order.amount;
|
||
await this.funds.withdraw({
|
||
userId: order.playerId,
|
||
amount: credit,
|
||
operatorId,
|
||
remark,
|
||
referenceId: order.orderNo,
|
||
transactionType: 'PLAYER_DEPOSIT_REVERSAL',
|
||
businessKey: `deposit:${order.orderNo}:reverse`,
|
||
});
|
||
}
|
||
|
||
/** 已拒绝：恢复待审核；已通过（5 分钟内且未产生下注）：扣回入账并恢复待审核 */
|
||
async reopenDepositOrderForReview(orderId: bigint, operatorId: bigint) {
|
||
return this.prisma.$transaction(async (tx) => {
|
||
const order = await this.lockDepositOrder(tx, orderId);
|
||
if (order.status === 'PENDING') throw appBadRequest('ORDER_ALREADY_PENDING');
|
||
|
||
if (order.status === 'REJECTED') {
|
||
await tx.depositOrder.update({
|
||
where: { id: orderId },
|
||
data: {
|
||
status: 'PENDING',
|
||
approvedAmount: null,
|
||
reviewerId: null,
|
||
reviewedAt: null,
|
||
rejectReason: null,
|
||
remark: null,
|
||
},
|
||
});
|
||
await this.recordDepositAudit(tx, {
|
||
depositOrderId: orderId,
|
||
action: 'REOPENED',
|
||
actorId: operatorId,
|
||
actorType: 'ADMIN',
|
||
statusBefore: order.status,
|
||
statusAfter: 'PENDING',
|
||
amount: order.amount,
|
||
remark: null,
|
||
});
|
||
return { success: true };
|
||
}
|
||
|
||
if (order.status !== 'APPROVED') {
|
||
throw appBadRequest('ORDER_NOT_APPROVED');
|
||
}
|
||
|
||
if (!order.reviewedAt || Date.now() - order.reviewedAt.getTime() > DEPOSIT_REVOKE_WINDOW_MS) {
|
||
throw appBadRequest('DEPOSIT_REVOKE_WINDOW_EXPIRED');
|
||
}
|
||
|
||
await this.lockPlayerWallet(tx, order.playerId);
|
||
const reviewedAt = order.reviewedAt;
|
||
const betsAfterReview = await tx.bet.findMany({
|
||
where: {
|
||
userId: order.playerId,
|
||
placedAt: { gte: reviewedAt },
|
||
status: { not: 'VOID' },
|
||
},
|
||
select: { id: true },
|
||
});
|
||
|
||
if (betsAfterReview.length > 0) {
|
||
throw appBadRequest('DEPOSIT_REVOKE_SETTLED_BETS');
|
||
}
|
||
|
||
const credit = order.approvedAmount ?? order.amount;
|
||
const parentAgentId = await this.findPlayerParentAgentId(tx, order.playerId);
|
||
const approvalCycleKey = order.reviewedAt?.getTime();
|
||
await this.funds.withdraw({
|
||
userId: order.playerId,
|
||
amount: credit,
|
||
operatorId,
|
||
remark: `Revoke approved deposit ${order.orderNo}`,
|
||
referenceId: order.orderNo,
|
||
transactionType: 'PLAYER_DEPOSIT_REVERSAL',
|
||
referenceType: 'DEPOSIT',
|
||
tx,
|
||
businessKey: `deposit:${order.orderNo}:reopen-reverse:${approvalCycleKey}`,
|
||
});
|
||
if (parentAgentId) {
|
||
await this.credit.recalculateUsedCredit(parentAgentId, tx);
|
||
}
|
||
|
||
await tx.depositOrder.update({
|
||
where: { id: orderId },
|
||
data: {
|
||
status: 'PENDING',
|
||
approvedAmount: null,
|
||
reviewerId: null,
|
||
reviewedAt: null,
|
||
rejectReason: null,
|
||
remark: null,
|
||
},
|
||
});
|
||
|
||
await this.recordDepositAudit(tx, {
|
||
depositOrderId: orderId,
|
||
action: 'REVOKED',
|
||
actorId: operatorId,
|
||
actorType: 'ADMIN',
|
||
statusBefore: order.status,
|
||
statusAfter: 'PENDING',
|
||
amount: order.amount,
|
||
approvedAmount: credit,
|
||
remark: `Revoke approved deposit ${order.orderNo}`,
|
||
});
|
||
|
||
return { success: true, voidedBets: 0 };
|
||
});
|
||
}
|
||
|
||
/** 删除充值订单记录及截图，仅允许删除未资金化订单。 */
|
||
async deleteDepositOrder(orderId: bigint, _operatorId: bigint) {
|
||
const order = await this.prisma.depositOrder.findUnique({ where: { id: orderId } });
|
||
if (!order) throw appBadRequest('ORDER_NOT_FOUND');
|
||
if (order.status === 'APPROVED') {
|
||
throw appBadRequest('DEPOSIT_ORDER_FUNDED_DELETE_FORBIDDEN');
|
||
}
|
||
|
||
const screenshotUrl = order.screenshotUrl;
|
||
await this.prisma.depositOrder.delete({ where: { id: orderId } });
|
||
await deleteUploadFileByUrl(screenshotUrl);
|
||
|
||
return { success: true };
|
||
}
|
||
|
||
private async lockDepositOrder(tx: Prisma.TransactionClient, orderId: bigint) {
|
||
const rows = await tx.$queryRaw<Array<{ id: bigint }>>`
|
||
SELECT id FROM deposit_orders WHERE id = ${orderId} FOR UPDATE
|
||
`;
|
||
if (!rows.length) throw appBadRequest('ORDER_NOT_FOUND');
|
||
const order = await tx.depositOrder.findUnique({ where: { id: orderId } });
|
||
if (!order) throw appBadRequest('ORDER_NOT_FOUND');
|
||
return order;
|
||
}
|
||
|
||
private async lockPlayerWallet(tx: Prisma.TransactionClient, playerId: bigint) {
|
||
const rows = await tx.$queryRaw<Array<{ id: bigint }>>`
|
||
SELECT id FROM wallets WHERE user_id = ${playerId} FOR UPDATE
|
||
`;
|
||
if (!rows.length) throw appBadRequest('WALLET_NOT_FOUND');
|
||
}
|
||
|
||
private async findPlayerParentAgentId(tx: Prisma.TransactionClient, playerId: bigint) {
|
||
const player = await tx.user.findFirst({
|
||
where: { id: playerId, userType: 'PLAYER', deletedAt: null },
|
||
select: { parentId: true },
|
||
});
|
||
return player?.parentId ?? null;
|
||
}
|
||
|
||
private async assertParentCreditForDeposit(
|
||
tx: Prisma.TransactionClient,
|
||
playerId: bigint,
|
||
amount: Decimal,
|
||
) {
|
||
const parentAgentId = await this.findPlayerParentAgentId(tx, playerId);
|
||
if (!parentAgentId) return null;
|
||
|
||
await this.credit.recalculateUsedCredit(parentAgentId, tx);
|
||
const profile = await tx.agentProfile.findUnique({
|
||
where: { userId: parentAgentId },
|
||
select: { creditLimit: true, usedCredit: true },
|
||
});
|
||
if (!profile) throw appBadRequest('AGENT_PROFILE_NOT_FOUND');
|
||
|
||
const available = new Decimal(profile.creditLimit).sub(profile.usedCredit);
|
||
if (available.lt(amount)) {
|
||
throw appBadRequest('CREDIT_TOPUP_EXCEEDED');
|
||
}
|
||
return parentAgentId;
|
||
}
|
||
}
|