444 lines
15 KiB
TypeScript
444 lines
15 KiB
TypeScript
import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
|
|
import { Prisma } from '@prisma/client';
|
|
import { PrismaService } from '../../common/prisma/prisma.module';
|
|
import { BenefitService } from '../benefit/benefit.service';
|
|
import { TradeService } from '../trade/trade.service';
|
|
import { TicketService } from '../common/ticket.service';
|
|
import { serializeBigInt } from '../../common/decorators/current-user.decorator';
|
|
import { PartnerCityService } from '../city-scope/partner-city.service';
|
|
import type { TicketListQueryDto } from '../common/dto/common-query.dto';
|
|
|
|
export type CollabPhase = 'AWAITING_PICKUP' | 'AWAITING_RESHIP' | 'HQ_DIRECT';
|
|
|
|
export type TicketCollabExtra = {
|
|
evidenceUrls?: string[];
|
|
warehouseId?: string;
|
|
warehouseName?: string;
|
|
warehousePartnerAccountId?: string;
|
|
storePartnerAccountId?: string;
|
|
collabPhase?: CollabPhase;
|
|
collabLogs?: { at: string; actorType: string; actorId: string; action: string }[];
|
|
};
|
|
|
|
const COLLAB_TYPES = ['RESHIPMENT', 'DAMAGE_RETURN', 'RETURN_REFUND'] as const;
|
|
|
|
@Injectable()
|
|
export class AdminTicketsService {
|
|
constructor(
|
|
private readonly prisma: PrismaService,
|
|
private readonly ticketService: TicketService,
|
|
private readonly tradeService: TradeService,
|
|
private readonly benefitService: BenefitService,
|
|
private readonly partnerCityService: PartnerCityService,
|
|
) {}
|
|
|
|
list(query: TicketListQueryDto) {
|
|
return this.ticketService.list(query);
|
|
}
|
|
|
|
detail(id: bigint) {
|
|
return this.ticketService.detail(id);
|
|
}
|
|
|
|
async createByHq(body: {
|
|
ticketType: string;
|
|
orderNo: string;
|
|
remark?: string;
|
|
evidenceUrls?: string[];
|
|
}) {
|
|
const orderNo = body.orderNo?.trim();
|
|
if (!orderNo) throw new BadRequestException('请填写订单号');
|
|
const order = await this.prisma.order.findFirst({ where: { orderNo } });
|
|
if (!order) throw new NotFoundException('订单不存在');
|
|
if (order.status === 'PENDING_PAY' || order.status === 'CANCELLED') {
|
|
throw new BadRequestException('当前订单不可创建工单');
|
|
}
|
|
if (['REFUNDING', 'REFUNDED'].includes(order.status) && body.ticketType !== 'ALERT') {
|
|
throw new BadRequestException('订单已在退款流程中');
|
|
}
|
|
|
|
const pending = await this.prisma.commonTicket.findFirst({
|
|
where: {
|
|
ticketType: body.ticketType as never,
|
|
refType: 'ORDER',
|
|
refId: order.id,
|
|
status: { in: ['PENDING', 'OPEN'] },
|
|
},
|
|
});
|
|
if (pending) throw new BadRequestException('该类型工单已在处理中');
|
|
|
|
const evidenceUrls = (body.evidenceUrls ?? []).filter((u) => typeof u === 'string' && u.trim());
|
|
return this.ticketService.create({
|
|
ticketType: body.ticketType,
|
|
refType: 'ORDER',
|
|
refId: order.id.toString(),
|
|
remark: body.remark ?? '',
|
|
extraJson: evidenceUrls.length ? { evidenceUrls } : undefined,
|
|
});
|
|
}
|
|
|
|
private parseExtra(raw: unknown): TicketCollabExtra {
|
|
if (!raw || typeof raw !== 'object') return {};
|
|
return raw as TicketCollabExtra;
|
|
}
|
|
|
|
private appendLog(
|
|
extra: TicketCollabExtra,
|
|
actorType: string,
|
|
actorId: string,
|
|
action: string,
|
|
): TicketCollabExtra {
|
|
const logs = [...(extra.collabLogs ?? [])];
|
|
logs.push({ at: new Date().toISOString(), actorType, actorId, action });
|
|
return { ...extra, collabLogs: logs };
|
|
}
|
|
|
|
/** 解析订单负责仓：优先履约仓，否则城内首个 ACTIVE 仓 */
|
|
async resolveWarehouseForOrder(orderId: bigint) {
|
|
const order = await this.prisma.order.findUnique({
|
|
where: { id: orderId },
|
|
select: {
|
|
id: true,
|
|
cityId: true,
|
|
fulfillmentWarehouseId: true,
|
|
partnerAccountIdAtPay: true,
|
|
orderNo: true,
|
|
receiverAddress: true,
|
|
receiverName: true,
|
|
receiverPhone: true,
|
|
productName: true,
|
|
},
|
|
});
|
|
if (!order) throw new NotFoundException('关联订单不存在');
|
|
|
|
let warehouse = order.fulfillmentWarehouseId
|
|
? await this.prisma.cityWarehouse.findUnique({ where: { id: order.fulfillmentWarehouseId } })
|
|
: null;
|
|
if (!warehouse) {
|
|
warehouse = await this.prisma.cityWarehouse.findFirst({
|
|
where: { cityId: order.cityId, status: 'ACTIVE' },
|
|
orderBy: { id: 'asc' },
|
|
});
|
|
}
|
|
return { order, warehouse };
|
|
}
|
|
|
|
private async executeRefund(orderId: bigint, remark: string) {
|
|
await this.prisma.order.update({
|
|
where: { id: orderId },
|
|
data: { status: 'REFUNDED', payStatus: 'REFUNDED' },
|
|
});
|
|
await this.benefitService.voidCouponsOnRefund(orderId);
|
|
await this.prisma.logThirdParty.create({
|
|
data: {
|
|
provider: 'WECHAT_REFUND',
|
|
scene: 'ORDER_REFUND',
|
|
refType: 'ORDER',
|
|
refId: orderId,
|
|
status: 'SUCCESS',
|
|
amount: 0,
|
|
},
|
|
});
|
|
await this.prisma.commonEvent.create({
|
|
data: {
|
|
eventType: 'ORDER_STATUS',
|
|
refType: 'ORDER',
|
|
refId: orderId,
|
|
actorType: 'HQ',
|
|
status: 'REFUNDED',
|
|
remark,
|
|
},
|
|
});
|
|
}
|
|
|
|
private async executeReship(orderId: bigint) {
|
|
await this.tradeService.applyStatusTransition(orderId, 'PENDING_SHIP', 'PENDING_SHIP', 'HQ');
|
|
}
|
|
|
|
async approve(id: bigint, remark?: string, actorId = '0') {
|
|
const ticket = await this.prisma.commonTicket.findUnique({ where: { id } });
|
|
if (!ticket) throw new NotFoundException('工单不存在');
|
|
if (ticket.status !== 'PENDING' && ticket.status !== 'OPEN') {
|
|
throw new BadRequestException('工单状态不可审批');
|
|
}
|
|
if (ticket.refType !== 'ORDER') {
|
|
throw new BadRequestException('仅支持订单售后工单');
|
|
}
|
|
|
|
const existingExtra = this.parseExtra(ticket.extraJson);
|
|
|
|
// 仅退款：立即退款
|
|
if (ticket.ticketType === 'REFUND') {
|
|
await this.executeRefund(ticket.refId, remark ?? '仅退款工单审批通过');
|
|
return this.ticketService.updateExtraJson(
|
|
id,
|
|
this.appendLog(existingExtra, 'HQ', actorId, 'APPROVE_REFUND'),
|
|
'RESOLVED',
|
|
remark ?? '审批通过',
|
|
);
|
|
}
|
|
|
|
if (!(COLLAB_TYPES as readonly string[]).includes(ticket.ticketType)) {
|
|
return this.ticketService.updateStatus(id, {
|
|
status: 'RESOLVED',
|
|
remark: remark ?? '审批通过',
|
|
});
|
|
}
|
|
|
|
const { order, warehouse } = await this.resolveWarehouseForOrder(ticket.refId);
|
|
const warehousePartnerAccountId =
|
|
warehouse?.partnerAccountId?.toString() ||
|
|
(warehouse
|
|
? (
|
|
await this.prisma.partnerAccount.findFirst({
|
|
where: { managedWarehouseId: warehouse.id },
|
|
select: { id: true },
|
|
})
|
|
)?.id.toString()
|
|
: undefined);
|
|
|
|
let collabPhase: CollabPhase = warehousePartnerAccountId ? 'AWAITING_PICKUP' : 'HQ_DIRECT';
|
|
if (ticket.ticketType === 'RESHIPMENT' && warehousePartnerAccountId) {
|
|
collabPhase = 'AWAITING_RESHIP';
|
|
}
|
|
if (!warehouse) {
|
|
collabPhase = 'HQ_DIRECT';
|
|
}
|
|
|
|
const storePartnerAccountId =
|
|
ticket.ticketType === 'RETURN_REFUND' && order.partnerAccountIdAtPay
|
|
? order.partnerAccountIdAtPay.toString()
|
|
: undefined;
|
|
|
|
let extra: TicketCollabExtra = {
|
|
...existingExtra,
|
|
warehouseId: warehouse?.id.toString(),
|
|
warehouseName: warehouse?.name,
|
|
warehousePartnerAccountId,
|
|
storePartnerAccountId,
|
|
collabPhase,
|
|
};
|
|
extra = this.appendLog(extra, 'HQ', actorId, `APPROVE_COLLAB:${collabPhase}`);
|
|
|
|
await this.prisma.commonEvent.create({
|
|
data: {
|
|
eventType: 'TICKET_COLLAB',
|
|
refType: 'TICKET',
|
|
refId: id,
|
|
actorType: 'HQ',
|
|
status: 'COLLABORATING',
|
|
remark: remark ?? `工单进入协同 ${collabPhase}`,
|
|
},
|
|
});
|
|
|
|
return this.ticketService.updateExtraJson(id, extra as Record<string, unknown>, 'COLLABORATING', remark ?? '审批通过，待协同');
|
|
}
|
|
|
|
reject(id: bigint, remark?: string) {
|
|
return this.ticketService.updateStatus(id, {
|
|
status: 'REJECTED',
|
|
remark: remark ?? '审批驳回',
|
|
});
|
|
}
|
|
|
|
/** 完成协同：取回确认（退货类）或补发确认 */
|
|
async completeCollab(
|
|
id: bigint,
|
|
opts: {
|
|
actorType: 'HQ' | 'PARTNER';
|
|
actorId: string;
|
|
mode: 'pickup' | 'reship' | 'auto';
|
|
},
|
|
) {
|
|
const ticket = await this.prisma.commonTicket.findUnique({ where: { id } });
|
|
if (!ticket) throw new NotFoundException('工单不存在');
|
|
if (ticket.status !== 'COLLABORATING') {
|
|
throw new BadRequestException('工单不在协同中');
|
|
}
|
|
if (ticket.refType !== 'ORDER') throw new BadRequestException('仅支持订单售后工单');
|
|
|
|
let extra = this.parseExtra(ticket.extraJson);
|
|
const phase = extra.collabPhase ?? 'HQ_DIRECT';
|
|
|
|
if (opts.actorType === 'PARTNER') {
|
|
// 仅管仓合伙人可操作协同节点；归属合伙人只读
|
|
if (extra.warehousePartnerAccountId !== opts.actorId) {
|
|
throw new BadRequestException('无权操作此工单');
|
|
}
|
|
}
|
|
|
|
const mode =
|
|
opts.mode === 'auto'
|
|
? ticket.ticketType === 'RESHIPMENT'
|
|
? 'reship'
|
|
: 'pickup'
|
|
: opts.mode;
|
|
|
|
if (mode === 'reship' && ticket.ticketType !== 'RESHIPMENT') {
|
|
throw new BadRequestException('当前工单不是补发类型');
|
|
}
|
|
if (mode === 'pickup' && !['DAMAGE_RETURN', 'RETURN_REFUND'].includes(ticket.ticketType)) {
|
|
throw new BadRequestException('当前工单不需要取回确认');
|
|
}
|
|
|
|
if (ticket.ticketType === 'RESHIPMENT') {
|
|
await this.executeReship(ticket.refId);
|
|
extra = this.appendLog(extra, opts.actorType, opts.actorId, 'CONFIRM_RESHIP');
|
|
} else if (ticket.ticketType === 'DAMAGE_RETURN' || ticket.ticketType === 'RETURN_REFUND') {
|
|
await this.executeRefund(ticket.refId, `${ticket.ticketType} 协同取回后完成退款`);
|
|
extra = this.appendLog(extra, opts.actorType, opts.actorId, 'CONFIRM_PICKUP_REFUND');
|
|
} else {
|
|
throw new BadRequestException('工单类型不支持协同完成');
|
|
}
|
|
|
|
extra = { ...extra, collabPhase: undefined };
|
|
|
|
await this.prisma.commonEvent.create({
|
|
data: {
|
|
eventType: 'TICKET_COLLAB',
|
|
refType: 'TICKET',
|
|
refId: id,
|
|
actorType: opts.actorType,
|
|
status: 'RESOLVED',
|
|
remark: `协同完成 phaseWas=${phase} mode=${mode}`,
|
|
},
|
|
});
|
|
|
|
return this.ticketService.updateExtraJson(id, extra as Record<string, unknown>, 'RESOLVED', '协同完成');
|
|
}
|
|
|
|
async completeCollabByHq(id: bigint, actorId: string) {
|
|
return this.completeCollab(id, { actorType: 'HQ', actorId, mode: 'auto' });
|
|
}
|
|
|
|
async listPartnerTickets(partnerAccountId: bigint, page = 1, pageSize = 20) {
|
|
const primary = await this.partnerCityService.resolvePrimaryAccount(partnerAccountId);
|
|
const pid = primary.id.toString();
|
|
|
|
const warehouses = await this.prisma.cityWarehouse.findMany({
|
|
where: {
|
|
OR: [{ partnerAccountId: primary.id }, { managedBy: { id: primary.id } }],
|
|
},
|
|
select: { id: true },
|
|
});
|
|
const warehouseIds = new Set(warehouses.map((w) => w.id.toString()));
|
|
|
|
const tickets = await this.prisma.commonTicket.findMany({
|
|
where: {
|
|
status: 'COLLABORATING',
|
|
ticketType: { in: [...COLLAB_TYPES] },
|
|
refType: 'ORDER',
|
|
},
|
|
orderBy: { createdAt: 'desc' },
|
|
});
|
|
|
|
const filtered = tickets.filter((t) => {
|
|
const extra = this.parseExtra(t.extraJson);
|
|
if (extra.warehousePartnerAccountId === pid) return true;
|
|
if (extra.storePartnerAccountId === pid) return true;
|
|
if (extra.warehouseId && warehouseIds.has(extra.warehouseId)) return true;
|
|
return false;
|
|
});
|
|
|
|
const pageItems = filtered.slice((page - 1) * pageSize, page * pageSize);
|
|
const orderIds = pageItems.map((t) => t.refId);
|
|
const orders = await this.prisma.order.findMany({
|
|
where: { id: { in: orderIds } },
|
|
select: {
|
|
id: true,
|
|
orderNo: true,
|
|
productName: true,
|
|
receiverAddress: true,
|
|
receiverName: true,
|
|
receiverPhone: true,
|
|
payAmount: true,
|
|
},
|
|
});
|
|
const orderMap = new Map(orders.map((o) => [o.id.toString(), o]));
|
|
|
|
return serializeBigInt({
|
|
items: pageItems.map((t) => {
|
|
const order = orderMap.get(t.refId.toString());
|
|
const extra = this.parseExtra(t.extraJson);
|
|
return {
|
|
...t,
|
|
extraJson: extra,
|
|
orderNo: order?.orderNo,
|
|
productName: order?.productName,
|
|
receiverAddress: order?.receiverAddress,
|
|
receiverName: order?.receiverName,
|
|
receiverPhone: order?.receiverPhone,
|
|
payAmount: order?.payAmount,
|
|
};
|
|
}),
|
|
total: filtered.length,
|
|
page,
|
|
pageSize,
|
|
});
|
|
}
|
|
|
|
async getPartnerTicket(partnerAccountId: bigint, ticketId: bigint) {
|
|
const primary = await this.partnerCityService.resolvePrimaryAccount(partnerAccountId);
|
|
const pid = primary.id.toString();
|
|
const ticket = await this.prisma.commonTicket.findUnique({ where: { id: ticketId } });
|
|
if (!ticket || ticket.refType !== 'ORDER') throw new NotFoundException('工单不存在或无权查看');
|
|
const extra = this.parseExtra(ticket.extraJson);
|
|
const warehouses = await this.prisma.cityWarehouse.findMany({
|
|
where: {
|
|
OR: [{ partnerAccountId: primary.id }, { managedBy: { id: primary.id } }],
|
|
},
|
|
select: { id: true },
|
|
});
|
|
const warehouseIds = new Set(warehouses.map((w) => w.id.toString()));
|
|
const allowed =
|
|
extra.warehousePartnerAccountId === pid ||
|
|
extra.storePartnerAccountId === pid ||
|
|
(extra.warehouseId != null && warehouseIds.has(extra.warehouseId));
|
|
if (!allowed) throw new NotFoundException('工单不存在或无权查看');
|
|
|
|
const order = await this.prisma.order.findUnique({
|
|
where: { id: ticket.refId },
|
|
select: {
|
|
orderNo: true,
|
|
productName: true,
|
|
receiverAddress: true,
|
|
receiverName: true,
|
|
receiverPhone: true,
|
|
payAmount: true,
|
|
},
|
|
});
|
|
return serializeBigInt({
|
|
...ticket,
|
|
extraJson: extra,
|
|
orderNo: order?.orderNo,
|
|
productName: order?.productName,
|
|
receiverAddress: order?.receiverAddress,
|
|
receiverName: order?.receiverName,
|
|
receiverPhone: order?.receiverPhone,
|
|
payAmount: order?.payAmount,
|
|
});
|
|
}
|
|
|
|
async partnerConfirmPickup(partnerAccountId: bigint, ticketId: bigint) {
|
|
const primary = await this.partnerCityService.resolvePrimaryAccount(partnerAccountId);
|
|
return this.completeCollab(ticketId, {
|
|
actorType: 'PARTNER',
|
|
actorId: primary.id.toString(),
|
|
mode: 'pickup',
|
|
});
|
|
}
|
|
|
|
async partnerConfirmReship(partnerAccountId: bigint, ticketId: bigint) {
|
|
const primary = await this.partnerCityService.resolvePrimaryAccount(partnerAccountId);
|
|
return this.completeCollab(ticketId, {
|
|
actorType: 'PARTNER',
|
|
actorId: primary.id.toString(),
|
|
mode: 'reship',
|
|
});
|
|
}
|
|
|
|
async listPartnerReshipments(partnerAccountId: bigint) {
|
|
return this.listPartnerTickets(partnerAccountId, 1, 100);
|
|
}
|
|
}
|