618 行
18 KiB
JavaScript
618 行
18 KiB
JavaScript
const { z } = require("zod");
|
|
|
|
const { AppError } = require("../utils/AppError");
|
|
const { buildAuditLogData } = require("../utils/audit");
|
|
const { sendData } = require("../utils/reply");
|
|
|
|
const UUID_SCHEMA = z.string().uuid();
|
|
const MONEY_SCHEMA = z.string().trim().regex(/^\d+(\.\d{1,2})?$/);
|
|
const PER_UNIT_VALUES = ["item", "day", "trip"];
|
|
const CONTROL_MODE_VALUES = ["warn", "block"];
|
|
const SCOPE_TYPE_VALUES = ["global", "department"];
|
|
|
|
const LIST_QUERY_SCHEMA = z
|
|
.object({
|
|
expenseTypeId: UUID_SCHEMA.optional(),
|
|
expense_type_id: UUID_SCHEMA.optional(),
|
|
scopeType: z.enum(SCOPE_TYPE_VALUES).optional(),
|
|
scope_type: z.enum(SCOPE_TYPE_VALUES).optional(),
|
|
enabled: z.enum(["true", "false", "1", "0"]).optional(),
|
|
})
|
|
.strict();
|
|
|
|
const CREATE_BODY_SCHEMA = z
|
|
.object({
|
|
expenseTypeId: UUID_SCHEMA,
|
|
name: z.string().trim().min(1).max(100),
|
|
maxAmount: MONEY_SCHEMA,
|
|
perUnit: z.enum(PER_UNIT_VALUES).optional(),
|
|
controlMode: z.enum(CONTROL_MODE_VALUES).optional(),
|
|
scopeType: z.enum(SCOPE_TYPE_VALUES).optional(),
|
|
scopeKey: UUID_SCHEMA.nullish(),
|
|
enabled: z.boolean().optional(),
|
|
note: z.string().trim().max(500).nullable().optional(),
|
|
})
|
|
.strict();
|
|
|
|
const UPDATE_BODY_SCHEMA = z
|
|
.object({
|
|
name: z.string().trim().min(1).max(100).optional(),
|
|
maxAmount: MONEY_SCHEMA.optional(),
|
|
perUnit: z.enum(PER_UNIT_VALUES).optional(),
|
|
controlMode: z.enum(CONTROL_MODE_VALUES).optional(),
|
|
scopeType: z.enum(SCOPE_TYPE_VALUES).optional(),
|
|
scopeKey: UUID_SCHEMA.nullish().optional(),
|
|
enabled: z.boolean().optional(),
|
|
note: z.string().trim().max(500).nullable().optional(),
|
|
})
|
|
.strict();
|
|
|
|
function buildValidationError(details, statusCode = 400) {
|
|
return new AppError({
|
|
code: "VALID_001",
|
|
message: "参数校验失败",
|
|
statusCode,
|
|
details,
|
|
});
|
|
}
|
|
|
|
function toMoneyString(value) {
|
|
const numeric = Number(value ?? 0);
|
|
if (!Number.isFinite(numeric)) {
|
|
return "0.00";
|
|
}
|
|
return numeric.toFixed(2);
|
|
}
|
|
|
|
function parseExpenseStandardId(params) {
|
|
const parsed = UUID_SCHEMA.safeParse(params?.id);
|
|
if (!parsed.success) {
|
|
throw buildValidationError({ id: "invalid_uuid" });
|
|
}
|
|
return parsed.data;
|
|
}
|
|
|
|
function parseListQuery(query) {
|
|
const parsed = LIST_QUERY_SCHEMA.safeParse(query ?? {});
|
|
if (!parsed.success) {
|
|
throw buildValidationError(parsed.error.flatten());
|
|
}
|
|
|
|
const enabledRaw = parsed.data.enabled;
|
|
const enabled =
|
|
enabledRaw == null
|
|
? null
|
|
: ["true", "1"].includes(enabledRaw)
|
|
? true
|
|
: false;
|
|
|
|
return {
|
|
expenseTypeId: parsed.data.expenseTypeId ?? parsed.data.expense_type_id ?? null,
|
|
scopeType: parsed.data.scopeType ?? parsed.data.scope_type ?? null,
|
|
enabled,
|
|
};
|
|
}
|
|
|
|
function parseBody(schema, body) {
|
|
const parsed = schema.safeParse(body ?? {});
|
|
if (!parsed.success) {
|
|
throw buildValidationError(parsed.error.flatten());
|
|
}
|
|
|
|
const data = parsed.data;
|
|
if ("maxAmount" in data && data.maxAmount != null && Number(data.maxAmount) <= 0) {
|
|
throw buildValidationError({ maxAmount: "must_be_positive" });
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
async function ensureExpenseTypeExists(tx, expenseTypeId) {
|
|
const expenseType = await tx.expenseType.findUnique({
|
|
where: { id: expenseTypeId },
|
|
select: {
|
|
id: true,
|
|
code: true,
|
|
name: true,
|
|
},
|
|
});
|
|
|
|
if (!expenseType) {
|
|
throw new AppError({
|
|
code: "VALID_001",
|
|
message: "参数校验失败",
|
|
statusCode: 409,
|
|
details: { expenseTypeId: "not_found" },
|
|
});
|
|
}
|
|
|
|
return expenseType;
|
|
}
|
|
|
|
async function ensureScopeKeyValid(tx, scopeType, scopeKey) {
|
|
if (scopeType === "global") {
|
|
return null;
|
|
}
|
|
|
|
if (!scopeKey) {
|
|
throw buildValidationError({ scopeKey: "required_for_department_scope" });
|
|
}
|
|
|
|
const department = await tx.department.findUnique({
|
|
where: { id: scopeKey },
|
|
select: {
|
|
id: true,
|
|
name: true,
|
|
archived_at: true,
|
|
},
|
|
});
|
|
|
|
if (!department || department.archived_at) {
|
|
throw new AppError({
|
|
code: "VALID_001",
|
|
message: "参数校验失败",
|
|
statusCode: 409,
|
|
details: { scopeKey: "invalid_department" },
|
|
});
|
|
}
|
|
|
|
return department;
|
|
}
|
|
|
|
function buildStandardPayload(body, actorId) {
|
|
const scopeType = body.scopeType ?? "global";
|
|
return {
|
|
...(typeof body.name === "string" ? { name: body.name } : {}),
|
|
...(typeof body.maxAmount === "string" ? { max_amount: body.maxAmount } : {}),
|
|
...(typeof body.perUnit === "string" ? { per_unit: body.perUnit } : {}),
|
|
...(typeof body.controlMode === "string" ? { control_mode: body.controlMode } : {}),
|
|
scope_type: scopeType,
|
|
scope_key: scopeType === "department" ? body.scopeKey ?? null : null,
|
|
...(typeof body.enabled === "boolean" ? { enabled: body.enabled } : {}),
|
|
...(Object.prototype.hasOwnProperty.call(body, "note") ? { note: body.note?.trim?.() || null } : {}),
|
|
updated_by: actorId,
|
|
};
|
|
}
|
|
|
|
function buildScopeLabel(item, departmentMap) {
|
|
if (item.scope_type === "global") {
|
|
return "全局";
|
|
}
|
|
return departmentMap.get(item.scope_key) ?? item.scope_key ?? "指定部门";
|
|
}
|
|
|
|
function mapExpenseStandard(item, departmentMap) {
|
|
return {
|
|
id: item.id,
|
|
expenseTypeId: item.expense_type_id,
|
|
expenseTypeName: item.expense_type?.name ?? null,
|
|
name: item.name,
|
|
maxAmount: toMoneyString(item.max_amount),
|
|
perUnit: item.per_unit,
|
|
controlMode: item.control_mode,
|
|
scopeType: item.scope_type,
|
|
scopeKey: item.scope_key ?? null,
|
|
scopeLabel: buildScopeLabel(item, departmentMap),
|
|
enabled: item.enabled,
|
|
note: item.note ?? null,
|
|
createdAt: item.created_at?.toISOString?.() ?? null,
|
|
updatedAt: item.updated_at?.toISOString?.() ?? null,
|
|
};
|
|
}
|
|
|
|
function normalizeRecordSnapshot(item) {
|
|
if (!item) {
|
|
return null;
|
|
}
|
|
|
|
return {
|
|
id: item.id,
|
|
expenseTypeId: item.expense_type_id,
|
|
name: item.name,
|
|
maxAmount: toMoneyString(item.max_amount),
|
|
perUnit: item.per_unit,
|
|
controlMode: item.control_mode,
|
|
scopeType: item.scope_type,
|
|
scopeKey: item.scope_key ?? null,
|
|
enabled: item.enabled,
|
|
note: item.note ?? null,
|
|
};
|
|
}
|
|
|
|
async function buildDepartmentMap(prisma, items) {
|
|
const departmentIds = Array.from(
|
|
new Set(
|
|
items
|
|
.filter((item) => item.scope_type === "department" && item.scope_key)
|
|
.map((item) => item.scope_key),
|
|
),
|
|
);
|
|
|
|
if (!departmentIds.length) {
|
|
return new Map();
|
|
}
|
|
|
|
const departments = await prisma.department.findMany({
|
|
where: {
|
|
id: { in: departmentIds },
|
|
},
|
|
select: {
|
|
id: true,
|
|
name: true,
|
|
},
|
|
});
|
|
|
|
return new Map(departments.map((item) => [item.id, item.name]));
|
|
}
|
|
|
|
async function expenseStandardsRoutes(fastify) {
|
|
fastify.get(
|
|
"/expense-standards",
|
|
{
|
|
preHandler: fastify.authenticate,
|
|
},
|
|
async (request, reply) => {
|
|
const query = parseListQuery(request.query);
|
|
const canManage = fastify.hasPermission(request.employee, "system.settings");
|
|
|
|
if (!canManage && (!query.expenseTypeId || query.enabled !== true)) {
|
|
throw new AppError({
|
|
code: "PERM_001",
|
|
message: "无权限",
|
|
statusCode: 403,
|
|
});
|
|
}
|
|
|
|
const items = await fastify.prisma.expenseStandard.findMany({
|
|
where: {
|
|
...(query.expenseTypeId ? { expense_type_id: query.expenseTypeId } : {}),
|
|
...(query.scopeType ? { scope_type: query.scopeType } : {}),
|
|
...(query.enabled == null ? {} : { enabled: query.enabled }),
|
|
},
|
|
orderBy: [
|
|
{ expense_type: { sort_order: "asc" } },
|
|
{ expense_type: { code: "asc" } },
|
|
{ scope_type: "asc" },
|
|
{ name: "asc" },
|
|
{ created_at: "asc" },
|
|
],
|
|
select: {
|
|
id: true,
|
|
expense_type_id: true,
|
|
name: true,
|
|
max_amount: true,
|
|
per_unit: true,
|
|
control_mode: true,
|
|
scope_type: true,
|
|
scope_key: true,
|
|
enabled: true,
|
|
note: true,
|
|
created_at: true,
|
|
updated_at: true,
|
|
expense_type: {
|
|
select: {
|
|
id: true,
|
|
name: true,
|
|
code: true,
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
const departmentMap = await buildDepartmentMap(fastify.prisma, items);
|
|
return sendData(reply, request, {
|
|
expenseTypeId: query.expenseTypeId,
|
|
scopeType: query.scopeType,
|
|
enabled: query.enabled,
|
|
items: items.map((item) => mapExpenseStandard(item, departmentMap)),
|
|
});
|
|
},
|
|
);
|
|
|
|
fastify.post(
|
|
"/expense-standards",
|
|
{
|
|
preHandler: fastify.requirePermission("system.settings"),
|
|
},
|
|
async (request, reply) => {
|
|
const body = parseBody(CREATE_BODY_SCHEMA, request.body);
|
|
const now = new Date();
|
|
|
|
let created = null;
|
|
try {
|
|
created = await fastify.prisma.$transaction(async (tx) => {
|
|
const expenseType = await ensureExpenseTypeExists(tx, body.expenseTypeId);
|
|
const scopeType = body.scopeType ?? "global";
|
|
const department = await ensureScopeKeyValid(tx, scopeType, body.scopeKey ?? null);
|
|
|
|
const record = await tx.expenseStandard.create({
|
|
data: {
|
|
expense_type_id: body.expenseTypeId,
|
|
name: body.name,
|
|
max_amount: body.maxAmount,
|
|
per_unit: body.perUnit ?? "item",
|
|
control_mode: body.controlMode ?? "warn",
|
|
scope_type: scopeType,
|
|
scope_key: scopeType === "department" ? department?.id ?? body.scopeKey ?? null : null,
|
|
enabled: body.enabled ?? true,
|
|
note: body.note?.trim?.() || null,
|
|
created_at: now,
|
|
created_by: request.employee.id,
|
|
updated_at: now,
|
|
updated_by: request.employee.id,
|
|
},
|
|
select: {
|
|
id: true,
|
|
expense_type_id: true,
|
|
name: true,
|
|
max_amount: true,
|
|
per_unit: true,
|
|
control_mode: true,
|
|
scope_type: true,
|
|
scope_key: true,
|
|
enabled: true,
|
|
note: true,
|
|
created_at: true,
|
|
updated_at: true,
|
|
expense_type: {
|
|
select: {
|
|
id: true,
|
|
name: true,
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
await tx.auditLog.create({
|
|
data: buildAuditLogData(request, {
|
|
actorId: request.employee.id,
|
|
action: "EXPENSE_STANDARD_CREATED",
|
|
targetType: "expense_standard",
|
|
targetId: record.id,
|
|
extra: {
|
|
expenseTypeId: expenseType.id,
|
|
expenseTypeName: expenseType.name,
|
|
scopeType: record.scope_type,
|
|
scopeKey: record.scope_key,
|
|
controlMode: record.control_mode,
|
|
maxAmount: toMoneyString(record.max_amount),
|
|
after: normalizeRecordSnapshot(record),
|
|
},
|
|
}),
|
|
});
|
|
|
|
return record;
|
|
});
|
|
} catch (error) {
|
|
if (error?.code === "P2002") {
|
|
throw new AppError({
|
|
code: "VALID_001",
|
|
message: "参数校验失败",
|
|
statusCode: 409,
|
|
details: { duplicate: "expense_type_scope_conflict" },
|
|
});
|
|
}
|
|
throw error;
|
|
}
|
|
|
|
const departmentMap = await buildDepartmentMap(fastify.prisma, [created]);
|
|
return sendData(reply, request, mapExpenseStandard(created, departmentMap));
|
|
},
|
|
);
|
|
|
|
fastify.patch(
|
|
"/expense-standards/:id",
|
|
{
|
|
preHandler: fastify.requirePermission("system.settings"),
|
|
},
|
|
async (request, reply) => {
|
|
const standardId = parseExpenseStandardId(request.params);
|
|
const body = parseBody(UPDATE_BODY_SCHEMA, request.body);
|
|
if (!Object.keys(body).length) {
|
|
throw buildValidationError({ body: "empty" });
|
|
}
|
|
|
|
const now = new Date();
|
|
let updated = null;
|
|
try {
|
|
updated = await fastify.prisma.$transaction(async (tx) => {
|
|
const current = await tx.expenseStandard.findUnique({
|
|
where: { id: standardId },
|
|
select: {
|
|
id: true,
|
|
expense_type_id: true,
|
|
name: true,
|
|
max_amount: true,
|
|
per_unit: true,
|
|
control_mode: true,
|
|
scope_type: true,
|
|
scope_key: true,
|
|
enabled: true,
|
|
note: true,
|
|
},
|
|
});
|
|
|
|
if (!current) {
|
|
throw new AppError({
|
|
code: "SYS_404",
|
|
message: "Not Found",
|
|
statusCode: 404,
|
|
});
|
|
}
|
|
|
|
const mergedBody = {
|
|
...body,
|
|
scopeType: body.scopeType ?? current.scope_type,
|
|
scopeKey:
|
|
Object.prototype.hasOwnProperty.call(body, "scopeKey")
|
|
? body.scopeKey ?? null
|
|
: current.scope_key ?? null,
|
|
};
|
|
|
|
await ensureScopeKeyValid(tx, mergedBody.scopeType, mergedBody.scopeKey);
|
|
|
|
const record = await tx.expenseStandard.update({
|
|
where: { id: standardId },
|
|
data: {
|
|
...buildStandardPayload(mergedBody, request.employee.id),
|
|
updated_at: now,
|
|
},
|
|
select: {
|
|
id: true,
|
|
expense_type_id: true,
|
|
name: true,
|
|
max_amount: true,
|
|
per_unit: true,
|
|
control_mode: true,
|
|
scope_type: true,
|
|
scope_key: true,
|
|
enabled: true,
|
|
note: true,
|
|
created_at: true,
|
|
updated_at: true,
|
|
expense_type: {
|
|
select: {
|
|
id: true,
|
|
name: true,
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
await tx.auditLog.create({
|
|
data: buildAuditLogData(request, {
|
|
actorId: request.employee.id,
|
|
action: "EXPENSE_STANDARD_UPDATED",
|
|
targetType: "expense_standard",
|
|
targetId: standardId,
|
|
extra: {
|
|
expenseTypeId: record.expense_type_id,
|
|
scopeType: record.scope_type,
|
|
scopeKey: record.scope_key,
|
|
controlMode: record.control_mode,
|
|
maxAmount: toMoneyString(record.max_amount),
|
|
before: normalizeRecordSnapshot(current),
|
|
after: normalizeRecordSnapshot(record),
|
|
},
|
|
}),
|
|
});
|
|
|
|
return record;
|
|
});
|
|
} catch (error) {
|
|
if (error?.code === "P2002") {
|
|
throw new AppError({
|
|
code: "VALID_001",
|
|
message: "参数校验失败",
|
|
statusCode: 409,
|
|
details: { duplicate: "expense_type_scope_conflict" },
|
|
});
|
|
}
|
|
throw error;
|
|
}
|
|
|
|
const departmentMap = await buildDepartmentMap(fastify.prisma, [updated]);
|
|
return sendData(reply, request, mapExpenseStandard(updated, departmentMap));
|
|
},
|
|
);
|
|
|
|
fastify.delete(
|
|
"/expense-standards/:id",
|
|
{
|
|
preHandler: fastify.requirePermission("system.settings"),
|
|
},
|
|
async (request, reply) => {
|
|
const standardId = parseExpenseStandardId(request.params);
|
|
const now = new Date();
|
|
|
|
const deleted = await fastify.prisma.$transaction(async (tx) => {
|
|
const current = await tx.expenseStandard.findUnique({
|
|
where: { id: standardId },
|
|
select: {
|
|
id: true,
|
|
expense_type_id: true,
|
|
name: true,
|
|
max_amount: true,
|
|
per_unit: true,
|
|
control_mode: true,
|
|
scope_type: true,
|
|
scope_key: true,
|
|
enabled: true,
|
|
note: true,
|
|
created_at: true,
|
|
updated_at: true,
|
|
expense_type: {
|
|
select: {
|
|
id: true,
|
|
name: true,
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
if (!current) {
|
|
throw new AppError({
|
|
code: "SYS_404",
|
|
message: "Not Found",
|
|
statusCode: 404,
|
|
});
|
|
}
|
|
|
|
const record = await tx.expenseStandard.update({
|
|
where: { id: standardId },
|
|
data: {
|
|
enabled: false,
|
|
updated_at: now,
|
|
updated_by: request.employee.id,
|
|
},
|
|
select: {
|
|
id: true,
|
|
expense_type_id: true,
|
|
name: true,
|
|
max_amount: true,
|
|
per_unit: true,
|
|
control_mode: true,
|
|
scope_type: true,
|
|
scope_key: true,
|
|
enabled: true,
|
|
note: true,
|
|
created_at: true,
|
|
updated_at: true,
|
|
expense_type: {
|
|
select: {
|
|
id: true,
|
|
name: true,
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
await tx.auditLog.create({
|
|
data: buildAuditLogData(request, {
|
|
actorId: request.employee.id,
|
|
action: "EXPENSE_STANDARD_DELETED",
|
|
targetType: "expense_standard",
|
|
targetId: standardId,
|
|
extra: {
|
|
expenseTypeId: record.expense_type_id,
|
|
scopeType: record.scope_type,
|
|
scopeKey: record.scope_key,
|
|
controlMode: record.control_mode,
|
|
maxAmount: toMoneyString(record.max_amount),
|
|
before: normalizeRecordSnapshot(current),
|
|
after: normalizeRecordSnapshot(record),
|
|
},
|
|
}),
|
|
});
|
|
|
|
return record;
|
|
});
|
|
|
|
const departmentMap = await buildDepartmentMap(fastify.prisma, [deleted]);
|
|
return sendData(reply, request, mapExpenseStandard(deleted, departmentMap));
|
|
},
|
|
);
|
|
}
|
|
|
|
module.exports = expenseStandardsRoutes;
|