657 行
20 KiB
JavaScript
657 行
20 KiB
JavaScript
const { z } = require("zod");
|
|
|
|
const { FEATURE_FLAG_KEYS, evaluateFeatureFlag } = require("../services/featureFlags");
|
|
const { currentDateString } = require("../utils/date");
|
|
const { AppError } = require("../utils/AppError");
|
|
const { sendData } = require("../utils/reply");
|
|
const { buildAuditLogData } = require("../utils/audit");
|
|
|
|
const UUID_SCHEMA = z.string().uuid();
|
|
const DATE_SCHEMA = z.string().regex(/^\d{4}-\d{2}-\d{2}$/);
|
|
const CYCLE_TYPE_SCHEMA = z.enum(["monthly", "quarterly", "semi_annual", "annual"]);
|
|
const CYCLE_STATUS_SCHEMA = z.enum(["draft", "active", "completed"]);
|
|
const DIMENSION_TYPE_SCHEMA = z.enum([
|
|
"work_quality",
|
|
"work_efficiency",
|
|
"teamwork",
|
|
"initiative",
|
|
"professional_skill",
|
|
]);
|
|
|
|
const SCORE_SCHEMA = z
|
|
.number()
|
|
.min(1)
|
|
.max(5)
|
|
.refine((value) => Number.isFinite(value) && Math.abs(value * 2 - Math.round(value * 2)) < 1e-9, {
|
|
message: "invalid_score_step",
|
|
});
|
|
const PERFORMANCE_MANAGE_PERMISSION = "system.settings";
|
|
|
|
const CYCLE_CREATE_SCHEMA = z
|
|
.object({
|
|
name: z.string().trim().min(1).max(200),
|
|
cycleType: CYCLE_TYPE_SCHEMA,
|
|
startDate: DATE_SCHEMA,
|
|
endDate: DATE_SCHEMA,
|
|
})
|
|
.strict();
|
|
|
|
const CYCLE_PATCH_SCHEMA = z
|
|
.object({
|
|
name: z.string().trim().min(1).max(200).optional(),
|
|
cycleType: CYCLE_TYPE_SCHEMA.optional(),
|
|
startDate: DATE_SCHEMA.optional(),
|
|
endDate: DATE_SCHEMA.optional(),
|
|
status: CYCLE_STATUS_SCHEMA.optional(),
|
|
})
|
|
.strict()
|
|
.refine((value) => Object.keys(value).length > 0, { message: "empty_patch" });
|
|
|
|
const REVIEW_UPSERT_SCHEMA = z
|
|
.object({
|
|
overallScore: SCORE_SCHEMA,
|
|
comment: z.string().trim().max(3000).nullable().optional(),
|
|
dimensions: z
|
|
.array(
|
|
z
|
|
.object({
|
|
dimensionType: DIMENSION_TYPE_SCHEMA,
|
|
score: SCORE_SCHEMA,
|
|
})
|
|
.strict(),
|
|
)
|
|
.max(5)
|
|
.optional()
|
|
.default([]),
|
|
})
|
|
.strict()
|
|
.superRefine((value, ctx) => {
|
|
const seen = new Set();
|
|
value.dimensions.forEach((item, index) => {
|
|
if (seen.has(item.dimensionType)) {
|
|
ctx.addIssue({
|
|
code: z.ZodIssueCode.custom,
|
|
path: ["dimensions", index, "dimensionType"],
|
|
message: "duplicate_dimension",
|
|
});
|
|
return;
|
|
}
|
|
seen.add(item.dimensionType);
|
|
});
|
|
});
|
|
|
|
const EMPLOYEE_SUMMARY_SELECT = {
|
|
id: true,
|
|
employee_no: true,
|
|
name: true,
|
|
title: true,
|
|
status: true,
|
|
direct_manager_id: true,
|
|
avatar_path: true,
|
|
department: { select: { id: true, name: true } },
|
|
};
|
|
|
|
const REVIEW_DETAIL_INCLUDE = {
|
|
dimensions: true,
|
|
reviewer_employee: {
|
|
select: {
|
|
id: true,
|
|
employee_no: true,
|
|
name: true,
|
|
},
|
|
},
|
|
};
|
|
|
|
const DIMENSION_ORDER = ["work_quality", "work_efficiency", "teamwork", "initiative", "professional_skill"];
|
|
|
|
function buildValidationError(details, statusCode = 400) {
|
|
return new AppError({ code: "VALID_001", message: "参数校验失败", statusCode, details });
|
|
}
|
|
|
|
function parseId(value) {
|
|
const parsed = UUID_SCHEMA.safeParse(value);
|
|
if (!parsed.success) {
|
|
throw buildValidationError({ id: "invalid_uuid" });
|
|
}
|
|
return parsed.data;
|
|
}
|
|
|
|
function parseBody(schema, body) {
|
|
const parsed = schema.safeParse(body ?? {});
|
|
if (!parsed.success) {
|
|
throw buildValidationError(parsed.error.flatten());
|
|
}
|
|
return parsed.data;
|
|
}
|
|
|
|
function parseDateOnly(value) {
|
|
return value ? new Date(`${value}T00:00:00.000Z`) : null;
|
|
}
|
|
|
|
function buildAvatarUrl(employeeId, avatarPath) {
|
|
return avatarPath ? `/api/avatars/${employeeId}` : null;
|
|
}
|
|
|
|
function toNumber(value) {
|
|
return value == null ? null : Number(value);
|
|
}
|
|
|
|
function validateCycleDates(startDate, endDate) {
|
|
if (startDate && endDate && startDate > endDate) {
|
|
throw buildValidationError({ endDate: "must_be_after_or_equal_startDate" });
|
|
}
|
|
}
|
|
|
|
async function ensureFeatureEnabled(fastify, request) {
|
|
const gate = await evaluateFeatureFlag({
|
|
prisma: fastify.prisma,
|
|
config: fastify.config,
|
|
flagKey: FEATURE_FLAG_KEYS.employeeLifecycle,
|
|
departmentId: request.employee.department_id ?? null,
|
|
strictDepartment: false,
|
|
});
|
|
if (!gate.enabled) {
|
|
throw buildValidationError({ featureFlag: "employee_lifecycle_v1_disabled", reason: gate.reason }, 409);
|
|
}
|
|
}
|
|
|
|
function mapEmployeeSummary(employee) {
|
|
return {
|
|
id: employee.id,
|
|
employeeNo: employee.employee_no,
|
|
name: employee.name,
|
|
title: employee.title,
|
|
status: employee.status,
|
|
avatarUrl: buildAvatarUrl(employee.id, employee.avatar_path),
|
|
department: employee.department ? { id: employee.department.id, name: employee.department.name } : null,
|
|
};
|
|
}
|
|
|
|
function mapCycle(cycle) {
|
|
return {
|
|
id: cycle.id,
|
|
name: cycle.name,
|
|
cycleType: cycle.cycle_type,
|
|
status: cycle.status,
|
|
startDate: cycle.start_date?.toISOString?.()?.slice(0, 10) ?? null,
|
|
endDate: cycle.end_date?.toISOString?.()?.slice(0, 10) ?? null,
|
|
activatedAt: cycle.activated_at?.toISOString?.() ?? null,
|
|
completedAt: cycle.completed_at?.toISOString?.() ?? null,
|
|
createdAt: cycle.created_at?.toISOString?.() ?? null,
|
|
createdBy: cycle.created_by ?? null,
|
|
updatedAt: cycle.updated_at?.toISOString?.() ?? null,
|
|
updatedBy: cycle.updated_by ?? null,
|
|
};
|
|
}
|
|
|
|
function mapReview(review) {
|
|
return {
|
|
id: review.id,
|
|
cycleId: review.cycle_id,
|
|
employeeId: review.employee_id,
|
|
reviewerEmployeeId: review.reviewer_employee_id,
|
|
overallScore: toNumber(review.overall_score),
|
|
comment: review.comment ?? null,
|
|
reviewer: review.reviewer_employee
|
|
? {
|
|
id: review.reviewer_employee.id,
|
|
employeeNo: review.reviewer_employee.employee_no,
|
|
name: review.reviewer_employee.name,
|
|
}
|
|
: null,
|
|
dimensions: [...(review.dimensions ?? [])]
|
|
.sort((left, right) => DIMENSION_ORDER.indexOf(left.dimension_type) - DIMENSION_ORDER.indexOf(right.dimension_type))
|
|
.map((item) => ({
|
|
dimensionType: item.dimension_type,
|
|
score: toNumber(item.score),
|
|
})),
|
|
createdAt: review.created_at?.toISOString?.() ?? null,
|
|
createdBy: review.created_by ?? null,
|
|
updatedAt: review.updated_at?.toISOString?.() ?? null,
|
|
updatedBy: review.updated_by ?? null,
|
|
};
|
|
}
|
|
|
|
function resolveViewerRole(fastify, request, employee) {
|
|
if (fastify.hasPermission(request.employee, PERFORMANCE_MANAGE_PERMISSION)) {
|
|
return "admin";
|
|
}
|
|
return null;
|
|
}
|
|
|
|
async function ensureCycleExists(prisma, cycleId) {
|
|
const cycle = await prisma.performanceReviewCycle.findUnique({ where: { id: cycleId } });
|
|
if (!cycle) {
|
|
throw new AppError({ code: "SYS_404", message: "Not Found", statusCode: 404 });
|
|
}
|
|
return cycle;
|
|
}
|
|
|
|
async function ensureEmployeeExists(prisma, employeeId) {
|
|
const employee = await prisma.employee.findUnique({
|
|
where: { id: employeeId },
|
|
select: EMPLOYEE_SUMMARY_SELECT,
|
|
});
|
|
if (!employee) {
|
|
throw new AppError({ code: "SYS_404", message: "Not Found", statusCode: 404 });
|
|
}
|
|
return employee;
|
|
}
|
|
|
|
async function ensureNoOtherActiveCycle(prisma, excludedCycleId = null) {
|
|
const existing = await prisma.performanceReviewCycle.findFirst({
|
|
where: {
|
|
status: "active",
|
|
...(excludedCycleId ? { id: { not: excludedCycleId } } : {}),
|
|
},
|
|
});
|
|
if (existing) {
|
|
throw buildValidationError({ cycle: "active_cycle_exists", activeCycleId: existing.id }, 409);
|
|
}
|
|
}
|
|
|
|
async function lockCycleForUpdate(prisma, cycleId) {
|
|
if (typeof prisma.$queryRaw === "function") {
|
|
const rows = await prisma.$queryRaw`
|
|
SELECT "id", "status"
|
|
FROM "performance_review_cycles"
|
|
WHERE "id" = ${cycleId}::uuid
|
|
FOR UPDATE
|
|
`;
|
|
if (!rows.length) {
|
|
throw new AppError({ code: "SYS_404", message: "Not Found", statusCode: 404 });
|
|
}
|
|
return rows[0];
|
|
}
|
|
|
|
return ensureCycleExists(prisma, cycleId);
|
|
}
|
|
|
|
function isPrismaUniqueConstraintError(error) {
|
|
return Boolean(error && typeof error === "object" && "code" in error && error.code === "P2002");
|
|
}
|
|
|
|
function sortCycles(items) {
|
|
const rank = { active: 0, draft: 1, completed: 2 };
|
|
return [...items].sort((left, right) => {
|
|
const rankDiff = (rank[left.status] ?? 9) - (rank[right.status] ?? 9);
|
|
if (rankDiff !== 0) return rankDiff;
|
|
const leftDate = left.endDate ?? left.startDate ?? "";
|
|
const rightDate = right.endDate ?? right.startDate ?? "";
|
|
return rightDate.localeCompare(leftDate) || String(right.name ?? "").localeCompare(String(left.name ?? ""));
|
|
});
|
|
}
|
|
|
|
function sortEmployeeItems(items) {
|
|
return [...items].sort((left, right) => {
|
|
const leftDepartment = left.employee.department?.name ?? "";
|
|
const rightDepartment = right.employee.department?.name ?? "";
|
|
return (
|
|
leftDepartment.localeCompare(rightDepartment) ||
|
|
left.employee.employeeNo.localeCompare(right.employee.employeeNo) ||
|
|
left.employee.name.localeCompare(right.employee.name)
|
|
);
|
|
});
|
|
}
|
|
|
|
async function buildCycleOverview(prisma, cycle) {
|
|
const reviews = await prisma.performanceReview.findMany({
|
|
where: { cycle_id: cycle.id },
|
|
include: {
|
|
...REVIEW_DETAIL_INCLUDE,
|
|
employee: {
|
|
select: EMPLOYEE_SUMMARY_SELECT,
|
|
},
|
|
},
|
|
});
|
|
|
|
const reviewByEmployeeId = new Map(reviews.map((item) => [item.employee_id, item]));
|
|
|
|
if (cycle.status === "completed") {
|
|
return sortEmployeeItems(
|
|
reviews.map((item) => ({
|
|
employee: mapEmployeeSummary(item.employee),
|
|
review: mapReview(item),
|
|
})),
|
|
);
|
|
}
|
|
|
|
const activeEmployees = await prisma.employee.findMany({
|
|
where: { status: "active" },
|
|
select: EMPLOYEE_SUMMARY_SELECT,
|
|
});
|
|
|
|
const items = activeEmployees.map((employee) => ({
|
|
employee: mapEmployeeSummary(employee),
|
|
review: reviewByEmployeeId.has(employee.id) ? mapReview(reviewByEmployeeId.get(employee.id)) : null,
|
|
}));
|
|
|
|
for (const review of reviews) {
|
|
if (!items.some((item) => item.employee.id === review.employee_id)) {
|
|
items.push({
|
|
employee: mapEmployeeSummary(review.employee),
|
|
review: mapReview(review),
|
|
});
|
|
}
|
|
}
|
|
|
|
return sortEmployeeItems(items);
|
|
}
|
|
|
|
async function buildEmployeeTimeline(prisma, employeeId, viewerRole) {
|
|
const cycles = await prisma.performanceReviewCycle.findMany({
|
|
where:
|
|
viewerRole === "self"
|
|
? {
|
|
status: "completed",
|
|
}
|
|
: {
|
|
status: {
|
|
in: ["active", "completed"],
|
|
},
|
|
},
|
|
});
|
|
|
|
if (!cycles.length) {
|
|
return [];
|
|
}
|
|
|
|
const reviews = await prisma.performanceReview.findMany({
|
|
where: {
|
|
employee_id: employeeId,
|
|
cycle_id: { in: cycles.map((item) => item.id) },
|
|
},
|
|
include: REVIEW_DETAIL_INCLUDE,
|
|
});
|
|
|
|
const reviewByCycleId = new Map(reviews.map((item) => [item.cycle_id, item]));
|
|
const items = cycles
|
|
.map((cycle) => ({
|
|
cycle: mapCycle(cycle),
|
|
review: reviewByCycleId.has(cycle.id) ? mapReview(reviewByCycleId.get(cycle.id)) : null,
|
|
canEdit: viewerRole !== "self" && cycle.status === "active",
|
|
}))
|
|
.filter((item) => (viewerRole === "self" ? Boolean(item.review) : true));
|
|
|
|
return sortCycles(items.map((item) => ({ ...item, status: item.cycle.status, endDate: item.cycle.endDate, startDate: item.cycle.startDate }))).map(
|
|
({ status, endDate, startDate, ...item }) => item,
|
|
);
|
|
}
|
|
|
|
async function performanceRoutes(fastify) {
|
|
fastify.get("/performance/cycles", { preHandler: fastify.authenticate }, async (request, reply) => {
|
|
await ensureFeatureEnabled(fastify, request);
|
|
if (!fastify.hasPermission(request.employee, PERFORMANCE_MANAGE_PERMISSION)) {
|
|
throw new AppError({ code: "PERM_001", message: "无权限", statusCode: 403, details: { permission: PERFORMANCE_MANAGE_PERMISSION } });
|
|
}
|
|
|
|
const cycles = await fastify.prisma.performanceReviewCycle.findMany();
|
|
return sendData(reply, request, {
|
|
items: sortCycles(cycles.map(mapCycle)),
|
|
});
|
|
});
|
|
|
|
fastify.post("/performance/cycles", { preHandler: fastify.authenticate }, async (request, reply) => {
|
|
await ensureFeatureEnabled(fastify, request);
|
|
if (!fastify.hasPermission(request.employee, PERFORMANCE_MANAGE_PERMISSION)) {
|
|
throw new AppError({ code: "PERM_001", message: "无权限", statusCode: 403, details: { permission: PERFORMANCE_MANAGE_PERMISSION } });
|
|
}
|
|
|
|
const body = parseBody(CYCLE_CREATE_SCHEMA, request.body);
|
|
validateCycleDates(body.startDate, body.endDate);
|
|
|
|
const cycle = await fastify.prisma.performanceReviewCycle.create({
|
|
data: {
|
|
name: body.name,
|
|
cycle_type: body.cycleType,
|
|
start_date: parseDateOnly(body.startDate),
|
|
end_date: parseDateOnly(body.endDate),
|
|
created_by: request.employee.id,
|
|
updated_by: request.employee.id,
|
|
},
|
|
});
|
|
|
|
await fastify.prisma.auditLog.create({
|
|
data: buildAuditLogData(request, {
|
|
actorId: request.employee.id,
|
|
action: "PERFORMANCE_REVIEW_CYCLE_CREATED",
|
|
targetType: "performance_review_cycle",
|
|
targetId: cycle.id,
|
|
extra: { status: cycle.status },
|
|
}),
|
|
});
|
|
|
|
return sendData(reply, request, mapCycle(cycle));
|
|
});
|
|
|
|
fastify.patch("/performance/cycles/:cycleId", { preHandler: fastify.authenticate }, async (request, reply) => {
|
|
await ensureFeatureEnabled(fastify, request);
|
|
if (!fastify.hasPermission(request.employee, PERFORMANCE_MANAGE_PERMISSION)) {
|
|
throw new AppError({ code: "PERM_001", message: "无权限", statusCode: 403, details: { permission: PERFORMANCE_MANAGE_PERMISSION } });
|
|
}
|
|
|
|
const cycleId = parseId(request.params?.cycleId);
|
|
const body = parseBody(CYCLE_PATCH_SCHEMA, request.body);
|
|
const current = await ensureCycleExists(fastify.prisma, cycleId);
|
|
const nextStartDate = body.startDate ?? current.start_date?.toISOString?.()?.slice(0, 10) ?? null;
|
|
const nextEndDate = body.endDate ?? current.end_date?.toISOString?.()?.slice(0, 10) ?? null;
|
|
validateCycleDates(nextStartDate, nextEndDate);
|
|
|
|
if (current.status === "completed") {
|
|
throw buildValidationError({ cycle: "completed_cycle_locked" }, 409);
|
|
}
|
|
|
|
let action = "PERFORMANCE_REVIEW_CYCLE_UPDATED";
|
|
let data;
|
|
|
|
if (current.status === "active") {
|
|
const invalidKeys = Object.keys(body).filter((key) => key !== "status");
|
|
if (invalidKeys.length > 0 || body.status !== "completed") {
|
|
throw buildValidationError({ cycle: "active_cycle_only_supports_complete" }, 409);
|
|
}
|
|
action = "PERFORMANCE_REVIEW_CYCLE_COMPLETED";
|
|
data = {
|
|
status: "completed",
|
|
completed_at: new Date(),
|
|
updated_by: request.employee.id,
|
|
};
|
|
} else {
|
|
if (body.status === "completed") {
|
|
throw buildValidationError({ cycle: "draft_cycle_cannot_complete_directly" }, 409);
|
|
}
|
|
if (body.status === "active") {
|
|
await ensureNoOtherActiveCycle(fastify.prisma, cycleId);
|
|
action = "PERFORMANCE_REVIEW_CYCLE_ACTIVATED";
|
|
}
|
|
|
|
data = {
|
|
...(body.name !== undefined ? { name: body.name } : {}),
|
|
...(body.cycleType !== undefined ? { cycle_type: body.cycleType } : {}),
|
|
...(body.startDate !== undefined ? { start_date: parseDateOnly(body.startDate) } : {}),
|
|
...(body.endDate !== undefined ? { end_date: parseDateOnly(body.endDate) } : {}),
|
|
...(body.status !== undefined ? { status: body.status } : {}),
|
|
...(body.status === "active" ? { activated_at: new Date() } : {}),
|
|
updated_by: request.employee.id,
|
|
};
|
|
}
|
|
|
|
let cycle;
|
|
try {
|
|
cycle = await fastify.prisma.performanceReviewCycle.update({
|
|
where: { id: cycleId },
|
|
data,
|
|
});
|
|
} catch (error) {
|
|
if (body.status === "active" && isPrismaUniqueConstraintError(error)) {
|
|
throw buildValidationError({ cycle: "active_cycle_exists" }, 409);
|
|
}
|
|
throw error;
|
|
}
|
|
|
|
await fastify.prisma.auditLog.create({
|
|
data: buildAuditLogData(request, {
|
|
actorId: request.employee.id,
|
|
action,
|
|
targetType: "performance_review_cycle",
|
|
targetId: cycle.id,
|
|
extra: { status: cycle.status },
|
|
}),
|
|
});
|
|
|
|
return sendData(reply, request, mapCycle(cycle));
|
|
});
|
|
|
|
fastify.get("/performance/cycles/:cycleId/reviews", { preHandler: fastify.authenticate }, async (request, reply) => {
|
|
await ensureFeatureEnabled(fastify, request);
|
|
if (!fastify.hasPermission(request.employee, PERFORMANCE_MANAGE_PERMISSION)) {
|
|
throw new AppError({ code: "PERM_001", message: "无权限", statusCode: 403, details: { permission: PERFORMANCE_MANAGE_PERMISSION } });
|
|
}
|
|
|
|
const cycleId = parseId(request.params?.cycleId);
|
|
const cycle = await ensureCycleExists(fastify.prisma, cycleId);
|
|
const items = await buildCycleOverview(fastify.prisma, cycle);
|
|
|
|
return sendData(reply, request, {
|
|
cycle: mapCycle(cycle),
|
|
items,
|
|
});
|
|
});
|
|
|
|
fastify.get("/performance/employees/:employeeId/reviews", { preHandler: fastify.authenticate }, async (request, reply) => {
|
|
await ensureFeatureEnabled(fastify, request);
|
|
const employeeId = parseId(request.params?.employeeId);
|
|
const employee = await ensureEmployeeExists(fastify.prisma, employeeId);
|
|
const viewerRole = resolveViewerRole(fastify, request, employee);
|
|
|
|
if (!viewerRole) {
|
|
throw new AppError({
|
|
code: "PERM_001",
|
|
message: "无权限",
|
|
statusCode: 403,
|
|
details: { permission: "performance.review.view" },
|
|
});
|
|
}
|
|
|
|
const items = await buildEmployeeTimeline(fastify.prisma, employeeId, viewerRole);
|
|
|
|
return sendData(reply, request, {
|
|
employee: mapEmployeeSummary(employee),
|
|
viewerRole,
|
|
items,
|
|
});
|
|
});
|
|
|
|
fastify.put("/performance/cycles/:cycleId/reviews/:employeeId", { preHandler: fastify.authenticate }, async (request, reply) => {
|
|
await ensureFeatureEnabled(fastify, request);
|
|
const cycleId = parseId(request.params?.cycleId);
|
|
const employeeId = parseId(request.params?.employeeId);
|
|
const body = parseBody(REVIEW_UPSERT_SCHEMA, request.body);
|
|
const employee = await ensureEmployeeExists(fastify.prisma, employeeId);
|
|
const viewerRole = resolveViewerRole(fastify, request, employee);
|
|
|
|
if (viewerRole !== "admin" && viewerRole !== "manager") {
|
|
throw new AppError({
|
|
code: "PERM_001",
|
|
message: "无权限",
|
|
statusCode: 403,
|
|
details: { permission: "performance.review.write" },
|
|
});
|
|
}
|
|
|
|
if (employee.status !== "active") {
|
|
throw buildValidationError({ employee: "inactive_employee_not_reviewable" }, 409);
|
|
}
|
|
|
|
await ensureCycleExists(fastify.prisma, cycleId);
|
|
|
|
const savedReview = await fastify.prisma.$transaction(async (tx) => {
|
|
const lockedCycle = await lockCycleForUpdate(tx, cycleId);
|
|
if (lockedCycle.status !== "active") {
|
|
throw buildValidationError({ cycle: "active_cycle_required" }, 409);
|
|
}
|
|
|
|
const existing = await tx.performanceReview.findFirst({
|
|
where: {
|
|
cycle_id: cycleId,
|
|
employee_id: employeeId,
|
|
},
|
|
include: REVIEW_DETAIL_INCLUDE,
|
|
});
|
|
|
|
const payload = {
|
|
reviewer_employee_id: request.employee.id,
|
|
overall_score: body.overallScore,
|
|
comment: body.comment?.trim() ? body.comment.trim() : null,
|
|
updated_by: request.employee.id,
|
|
};
|
|
|
|
let reviewId = existing?.id ?? null;
|
|
|
|
if (existing) {
|
|
await tx.performanceReview.update({
|
|
where: { id: existing.id },
|
|
data: payload,
|
|
});
|
|
} else {
|
|
const created = await tx.performanceReview.create({
|
|
data: {
|
|
cycle_id: cycleId,
|
|
employee_id: employeeId,
|
|
...payload,
|
|
created_by: request.employee.id,
|
|
},
|
|
});
|
|
reviewId = created.id;
|
|
}
|
|
|
|
await tx.performanceReviewDimension.deleteMany({
|
|
where: { review_id: reviewId },
|
|
});
|
|
|
|
if (body.dimensions.length > 0) {
|
|
await tx.performanceReviewDimension.createMany({
|
|
data: body.dimensions.map((item) => ({
|
|
review_id: reviewId,
|
|
dimension_type: item.dimensionType,
|
|
score: item.score,
|
|
})),
|
|
});
|
|
}
|
|
|
|
return tx.performanceReview.findUnique({
|
|
where: { id: reviewId },
|
|
include: REVIEW_DETAIL_INCLUDE,
|
|
});
|
|
});
|
|
|
|
await fastify.prisma.auditLog.create({
|
|
data: buildAuditLogData(request, {
|
|
actorId: request.employee.id,
|
|
action: "PERFORMANCE_REVIEW_UPSERTED",
|
|
targetType: "performance_review",
|
|
targetId: savedReview.id,
|
|
extra: {
|
|
cycleId,
|
|
employeeId,
|
|
reviewerRole: viewerRole,
|
|
},
|
|
}),
|
|
});
|
|
|
|
return sendData(reply, request, mapReview(savedReview));
|
|
});
|
|
}
|
|
|
|
module.exports = performanceRoutes;
|
|
|
|
module.exports.__testables = {
|
|
buildCycleOverview,
|
|
buildEmployeeTimeline,
|
|
buildValidationError,
|
|
mapCycle,
|
|
mapEmployeeSummary,
|
|
mapReview,
|
|
resolveViewerRole,
|
|
sortCycles,
|
|
};
|