230 lines
8.5 KiB
TypeScript
230 lines
8.5 KiB
TypeScript
import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
|
|
import { Prisma } from '@prisma/client';
|
|
import type { HqAdminRoleValue } from '@dukang/shared-types';
|
|
import { PrismaService } from '../../common/prisma/prisma.module';
|
|
import { serializeBigInt } from '../../common/decorators/current-user.decorator';
|
|
import type { AdminHqAccountsQueryDto } from './dto/admin-query.dto';
|
|
import type { CreateHqAccountDto, UpdateHqAccountDto } from './dto/admin-mutate.dto';
|
|
import { hashPassword } from '../../common/crypto/password.util';
|
|
|
|
const HQ_ACCOUNT_SELECT = {
|
|
id: true,
|
|
phone: true,
|
|
loginName: true,
|
|
passwordHash: true,
|
|
name: true,
|
|
adminRole: true,
|
|
status: true,
|
|
lastLoginAt: true,
|
|
createdAt: true,
|
|
cities: { select: { cityId: true } },
|
|
} satisfies Prisma.HqAccountSelect;
|
|
|
|
function mapHqAccountRow(account: {
|
|
id: bigint;
|
|
phone: string;
|
|
loginName: string | null;
|
|
passwordHash: string | null;
|
|
name: string;
|
|
adminRole: string;
|
|
status: string;
|
|
lastLoginAt: Date | null;
|
|
createdAt: Date;
|
|
cities?: { cityId: bigint }[];
|
|
}) {
|
|
return {
|
|
id: account.id,
|
|
phone: account.phone,
|
|
loginName: account.loginName,
|
|
hasPassword: !!account.passwordHash,
|
|
name: account.name,
|
|
adminRole: account.adminRole,
|
|
status: account.status,
|
|
lastLoginAt: account.lastLoginAt,
|
|
createdAt: account.createdAt,
|
|
cityIds: (account.cities ?? []).map((c) => c.cityId.toString()),
|
|
};
|
|
}
|
|
|
|
@Injectable()
|
|
export class AdminHqAccountsService {
|
|
constructor(private readonly prisma: PrismaService) {}
|
|
|
|
private async assertCityIds(cityIds: string[]) {
|
|
const unique = [...new Set(cityIds.map((id) => id.trim()).filter(Boolean))];
|
|
if (!unique.length) return [] as bigint[];
|
|
const ids = unique.map((id) => BigInt(id));
|
|
const count = await this.prisma.commonCity.count({ where: { id: { in: ids } } });
|
|
if (count !== ids.length) {
|
|
throw new BadRequestException('存在无效城市');
|
|
}
|
|
return ids;
|
|
}
|
|
|
|
private assertCityRequirement(adminRole: string, cityIds: bigint[]) {
|
|
if (adminRole === 'CITY_STORE_SERVICE' && !cityIds.length) {
|
|
throw new BadRequestException('城市门店服务须至少勾选一个负责城市');
|
|
}
|
|
}
|
|
|
|
private async replaceCities(tx: Prisma.TransactionClient, hqAccountId: bigint, cityIds: bigint[]) {
|
|
await tx.hqAccountCity.deleteMany({ where: { hqAccountId } });
|
|
if (!cityIds.length) return;
|
|
await tx.hqAccountCity.createMany({
|
|
data: cityIds.map((cityId) => ({ hqAccountId, cityId })),
|
|
});
|
|
}
|
|
|
|
async list(query: AdminHqAccountsQueryDto) {
|
|
const page = query.page ?? 1;
|
|
const pageSize = query.pageSize ?? 20;
|
|
const where: Prisma.HqAccountWhereInput = {};
|
|
if (query.phone) where.phone = { contains: query.phone };
|
|
if (query.adminRole) where.adminRole = query.adminRole as Prisma.EnumHqAdminRoleFilter['equals'];
|
|
if (query.status) where.status = query.status as Prisma.EnumAccountStatusFilter['equals'];
|
|
|
|
const [items, total] = await Promise.all([
|
|
this.prisma.hqAccount.findMany({
|
|
where,
|
|
orderBy: { createdAt: 'desc' },
|
|
skip: (page - 1) * pageSize,
|
|
take: pageSize,
|
|
select: HQ_ACCOUNT_SELECT,
|
|
}),
|
|
this.prisma.hqAccount.count({ where }),
|
|
]);
|
|
return serializeBigInt({
|
|
items: items.map(mapHqAccountRow),
|
|
total,
|
|
page,
|
|
pageSize,
|
|
});
|
|
}
|
|
|
|
async detail(id: bigint) {
|
|
const account = await this.prisma.hqAccount.findUnique({
|
|
where: { id },
|
|
select: HQ_ACCOUNT_SELECT,
|
|
});
|
|
if (!account) throw new NotFoundException('HQ 账号不存在');
|
|
return serializeBigInt(mapHqAccountRow(account));
|
|
}
|
|
|
|
async create(dto: CreateHqAccountDto) {
|
|
const adminRole = (dto.adminRole ?? 'OPS') as HqAdminRoleValue;
|
|
const cityIds = await this.assertCityIds(dto.cityIds ?? []);
|
|
this.assertCityRequirement(adminRole, cityIds);
|
|
|
|
if (dto.credentialType === 'phone') {
|
|
if (!dto.phone?.trim()) throw new BadRequestException('请填写手机号');
|
|
const phone = dto.phone.trim();
|
|
const exists = await this.prisma.hqAccount.findUnique({ where: { phone } });
|
|
if (exists) throw new BadRequestException('手机号已存在');
|
|
const account = await this.prisma.$transaction(async (tx) => {
|
|
const created = await tx.hqAccount.create({
|
|
data: { phone, name: dto.name, adminRole },
|
|
select: HQ_ACCOUNT_SELECT,
|
|
});
|
|
await this.replaceCities(tx, created.id, cityIds);
|
|
return tx.hqAccount.findUniqueOrThrow({ where: { id: created.id }, select: HQ_ACCOUNT_SELECT });
|
|
});
|
|
return serializeBigInt(mapHqAccountRow(account));
|
|
}
|
|
|
|
if (!dto.loginName?.trim() || !dto.password) {
|
|
throw new BadRequestException('账号密码模式需填写用户名和密码');
|
|
}
|
|
const loginName = dto.loginName.trim();
|
|
const loginTaken = await this.prisma.hqAccount.findUnique({ where: { loginName } });
|
|
if (loginTaken) throw new BadRequestException('用户名已存在');
|
|
|
|
const phone = dto.phone?.trim() || (await this.generatePlaceholderPhone());
|
|
const phoneTaken = await this.prisma.hqAccount.findUnique({ where: { phone } });
|
|
if (phoneTaken) throw new BadRequestException('手机号已存在');
|
|
|
|
const account = await this.prisma.$transaction(async (tx) => {
|
|
const created = await tx.hqAccount.create({
|
|
data: {
|
|
phone,
|
|
loginName,
|
|
passwordHash: hashPassword(dto.password!),
|
|
name: dto.name,
|
|
adminRole,
|
|
},
|
|
select: HQ_ACCOUNT_SELECT,
|
|
});
|
|
await this.replaceCities(tx, created.id, cityIds);
|
|
return tx.hqAccount.findUniqueOrThrow({ where: { id: created.id }, select: HQ_ACCOUNT_SELECT });
|
|
});
|
|
return serializeBigInt(mapHqAccountRow(account));
|
|
}
|
|
|
|
async update(id: bigint, dto: UpdateHqAccountDto) {
|
|
const current = await this.prisma.hqAccount.findUnique({
|
|
where: { id },
|
|
include: { cities: { select: { cityId: true } } },
|
|
});
|
|
if (!current) throw new NotFoundException('HQ 账号不存在');
|
|
|
|
const loginNameInput = dto.loginName === undefined ? undefined : dto.loginName.trim();
|
|
if (loginNameInput) {
|
|
const conflict = await this.prisma.hqAccount.findFirst({
|
|
where: { loginName: loginNameInput, id: { not: id } },
|
|
});
|
|
if (conflict) throw new BadRequestException('用户名已存在');
|
|
}
|
|
|
|
if (dto.phone !== undefined) {
|
|
const phone = dto.phone.trim();
|
|
if (!/^1[3-9]\d{9}$/.test(phone)) {
|
|
throw new BadRequestException('请输入正确的手机号');
|
|
}
|
|
const phoneTaken = await this.prisma.hqAccount.findUnique({ where: { phone } });
|
|
if (phoneTaken && phoneTaken.id !== id) {
|
|
throw new BadRequestException('手机号已存在');
|
|
}
|
|
}
|
|
|
|
const nextRole = (dto.adminRole ?? current.adminRole) as HqAdminRoleValue;
|
|
const nextCityIds =
|
|
dto.cityIds !== undefined
|
|
? await this.assertCityIds(dto.cityIds)
|
|
: current.cities.map((c) => c.cityId);
|
|
this.assertCityRequirement(nextRole, nextCityIds);
|
|
|
|
const roleChanged = dto.adminRole !== undefined && dto.adminRole !== current.adminRole;
|
|
|
|
const account = await this.prisma.$transaction(async (tx) => {
|
|
await tx.hqAccount.update({
|
|
where: { id },
|
|
data: {
|
|
...(dto.name !== undefined ? { name: dto.name } : {}),
|
|
...(dto.phone !== undefined ? { phone: dto.phone.trim() } : {}),
|
|
...(loginNameInput ? { loginName: loginNameInput } : {}),
|
|
...(dto.password ? { passwordHash: hashPassword(dto.password) } : {}),
|
|
...(dto.adminRole !== undefined ? { adminRole: nextRole } : {}),
|
|
...(dto.status !== undefined ? { status: dto.status as 'ACTIVE' | 'DISABLED' } : {}),
|
|
},
|
|
});
|
|
if (dto.cityIds !== undefined) {
|
|
await this.replaceCities(tx, id, nextCityIds);
|
|
}
|
|
if (roleChanged) {
|
|
await tx.hqAccountPermission.deleteMany({ where: { hqAccountId: id } });
|
|
}
|
|
return tx.hqAccount.findUniqueOrThrow({ where: { id }, select: HQ_ACCOUNT_SELECT });
|
|
});
|
|
return serializeBigInt(mapHqAccountRow(account));
|
|
}
|
|
|
|
private async generatePlaceholderPhone(): Promise<string> {
|
|
for (let i = 0; i < 8; i += 1) {
|
|
const suffix = `${Date.now()}${Math.floor(Math.random() * 1000)}`.slice(-8);
|
|
const phone = `199${suffix}`;
|
|
const exists = await this.prisma.hqAccount.findUnique({ where: { phone } });
|
|
if (!exists) return phone;
|
|
}
|
|
throw new BadRequestException('无法生成占位手机号，请手动填写');
|
|
}
|
|
}
|