3373 行
103 KiB
JavaScript
3373 行
103 KiB
JavaScript
const { z } = require("zod");
|
||
const { AppError } = require("../utils/AppError");
|
||
const { buildBusinessValidationError } = require("../utils/businessValidationError");
|
||
const { buildAuditLogData } = require("../utils/audit");
|
||
const { sendData } = require("../utils/reply");
|
||
const { hasPermission, ROLE_PERMISSIONS, resolveEntityPermission } = require("../constants/permissions");
|
||
const {
|
||
BUSINESS_APPROVAL_ROLE_CODES,
|
||
FINANCE_OWNER_APPROVAL_STEP_ID,
|
||
getWorkflowStepsSnapshot,
|
||
isBusinessApprovalRoleCode,
|
||
resolveActionableStep,
|
||
resolveWorkflowStepDisplayName,
|
||
toMoneyString,
|
||
} = require("../utils/workflow");
|
||
const { consumeReservedLeave, releaseReservedLeave, formatDateOnly } = require("../services/leave");
|
||
const { FEATURE_FLAG_KEYS, evaluateFeatureFlag } = require("../services/featureFlags");
|
||
const { confirmBudgetForEntity, releaseReservedBudgetIfAny } = require("../services/purchaseBudget");
|
||
const {
|
||
PROCUREMENT_ERP_TARGETS,
|
||
enqueuePurchaseCommitmentJournalExport,
|
||
loadPurchaseRequestErpContext,
|
||
} = require("../services/integrations/erpProcurement");
|
||
const {
|
||
createNotificationsWithRecords,
|
||
resolveRecipientsForAssignee,
|
||
} = require("../services/notifications");
|
||
const {
|
||
buildApprovedCopy,
|
||
buildOverdueTaskCopy,
|
||
buildPendingTaskCopy,
|
||
buildRejectedCopy,
|
||
buildRemindedTaskCopy,
|
||
buildReturnedCopy,
|
||
buildWorkflowEntityMeta,
|
||
normalizeWorkflowEntityType,
|
||
} = require("../services/notifications/workflowCopy");
|
||
const { sendNotificationEmailSafe } = require("../services/email");
|
||
const { NOTIFICATION_TYPES } = require("../constants/notificationTypes");
|
||
const { flushNotificationDispatchTasks } = require("../services/notificationDispatcher");
|
||
const {
|
||
findActiveDelegationForDelegate,
|
||
listActiveDelegationPrincipals,
|
||
} = require("../utils/delegation");
|
||
|
||
const TASK_ID_SCHEMA = z.string().uuid();
|
||
const REQUIRED_COMMENT_SCHEMA = z.object({
|
||
comment: z.string().trim().min(1).max(500),
|
||
});
|
||
const TRANSFER_BODY_SCHEMA = z.object({
|
||
toApproverId: z.string().uuid(),
|
||
reason: z.string().max(500),
|
||
});
|
||
const BATCH_APPROVE_BODY_SCHEMA = z.object({
|
||
taskIds: z.array(z.string().uuid()).min(1).max(50),
|
||
comment: z.string().trim().max(500).optional(),
|
||
});
|
||
const BATCH_REJECT_BODY_SCHEMA = z.object({
|
||
taskIds: z.array(z.string().uuid()).min(1).max(50),
|
||
comment: z.string().trim().min(1).max(500),
|
||
});
|
||
const REMIND_TASK_BODY_SCHEMA = z.object({
|
||
comment: z.string().trim().max(200).optional(),
|
||
});
|
||
|
||
const TASK_LIST_QUERY_SCHEMA = z.object({
|
||
status: z.enum(["pending", "completed", "rejected", "cancelled", "skipped"]).optional(),
|
||
entityType: z.enum(["reimbursement", "leave", "attendance_correction", "purchase_request", "travel_request"]).optional(),
|
||
page: z.coerce.number().int().min(1).optional(),
|
||
pageSize: z.coerce.number().int().min(1).max(100).optional(),
|
||
});
|
||
const TASK_SUMMARY_QUERY_SCHEMA = z.object({
|
||
scope: z.enum(["mine", "system"]).optional(),
|
||
});
|
||
|
||
const WORKFLOW_REMIND_ACTION = "remind";
|
||
const WORKFLOW_OVERDUE_ACTION = "overdue_remind";
|
||
const WORKFLOW_REMINDER_COOLDOWN_MS = 24 * 60 * 60 * 1000;
|
||
const WORKFLOW_DEFAULT_DUE_MS = 24 * 60 * 60 * 1000;
|
||
|
||
const REIMBURSEMENT_SNAPSHOT_CONTROL_MODES = new Set(["warn", "block"]);
|
||
|
||
function projectReimbursementSubmissionSnapshot(contextData) {
|
||
const source = contextData && typeof contextData === "object" && !Array.isArray(contextData)
|
||
? contextData
|
||
: {};
|
||
const standardViolationsPresent = Object.prototype.hasOwnProperty.call(source, "standardViolations");
|
||
const budgetCheckPresent = Object.prototype.hasOwnProperty.call(source, "budgetCheck") && source.budgetCheck != null;
|
||
const budgetCheckRecordedPresent = Object.prototype.hasOwnProperty.call(source, "budgetCheckRecorded");
|
||
const standardViolationsValid = Array.isArray(source.standardViolations) && source.standardViolations.every((item) => (
|
||
item &&
|
||
typeof item === "object" &&
|
||
typeof item.itemId === "string" &&
|
||
typeof item.expenseTypeId === "string" &&
|
||
typeof item.expenseTypeName === "string" &&
|
||
typeof item.amount === "string" &&
|
||
typeof item.standardId === "string" &&
|
||
typeof item.standardName === "string" &&
|
||
typeof item.maxAmount === "string" &&
|
||
["item", "day", "trip"].includes(item.perUnit) &&
|
||
REIMBURSEMENT_SNAPSHOT_CONTROL_MODES.has(item.controlMode) &&
|
||
["global", "department"].includes(item.scopeType) &&
|
||
(item.scopeKey == null || typeof item.scopeKey === "string") &&
|
||
typeof item.exceeded === "boolean" &&
|
||
typeof item.exceededAmount === "string"
|
||
));
|
||
const standardViolations = standardViolationsValid
|
||
? source.standardViolations.map((item) => ({
|
||
itemId: item.itemId,
|
||
expenseTypeId: item.expenseTypeId,
|
||
expenseTypeName: item.expenseTypeName,
|
||
amount: item.amount,
|
||
standardId: item.standardId,
|
||
standardName: item.standardName,
|
||
maxAmount: item.maxAmount,
|
||
perUnit: item.perUnit,
|
||
controlMode: item.controlMode,
|
||
scopeType: item.scopeType,
|
||
scopeKey: item.scopeKey,
|
||
exceeded: item.exceeded,
|
||
exceededAmount: item.exceededAmount,
|
||
}))
|
||
: [];
|
||
|
||
let budgetCheck = null;
|
||
if (budgetCheckPresent) {
|
||
const candidate = source.budgetCheck;
|
||
const usagePercent = Number(candidate?.usagePercent);
|
||
if (
|
||
candidate &&
|
||
typeof candidate === "object" &&
|
||
!Array.isArray(candidate) &&
|
||
typeof candidate.budgetId === "string" &&
|
||
typeof candidate.budgetCode === "string" &&
|
||
REIMBURSEMENT_SNAPSHOT_CONTROL_MODES.has(candidate.controlMode) &&
|
||
Number.isFinite(usagePercent) &&
|
||
typeof candidate.exceededThreshold === "boolean" &&
|
||
typeof candidate.exceededBudget === "boolean"
|
||
) {
|
||
budgetCheck = {
|
||
budgetId: candidate.budgetId,
|
||
budgetCode: candidate.budgetCode,
|
||
controlMode: candidate.controlMode,
|
||
usagePercent,
|
||
exceededThreshold: candidate.exceededThreshold,
|
||
exceededBudget: candidate.exceededBudget,
|
||
};
|
||
}
|
||
}
|
||
|
||
const parseStatus =
|
||
(standardViolationsPresent && !standardViolationsValid) ||
|
||
(budgetCheckPresent && !budgetCheck) ||
|
||
(budgetCheckRecordedPresent && source.budgetCheckRecorded !== true)
|
||
? "invalid"
|
||
: "ready";
|
||
|
||
return {
|
||
standardViolations,
|
||
budgetCheck,
|
||
budgetCheckStatus: budgetCheck
|
||
? "available"
|
||
: source.budgetCheckRecorded === true
|
||
? "not_applicable"
|
||
: "missing",
|
||
parseStatus,
|
||
};
|
||
}
|
||
|
||
const APPROVER_LIST_QUERY_SCHEMA = z.object({
|
||
keyword: z.string().trim().max(100).optional(),
|
||
page: z.coerce.number().int().min(1).optional(),
|
||
pageSize: z.coerce.number().int().min(1).max(100).optional(),
|
||
});
|
||
|
||
const APPROVER_ROLE_CODES = BUSINESS_APPROVAL_ROLE_CODES.filter((roleCode) =>
|
||
ROLE_PERMISSIONS[roleCode].some((permissionCode) => permissionCode.endsWith(".approve")),
|
||
);
|
||
|
||
function parseRequiredComment(body) {
|
||
const parsed = REQUIRED_COMMENT_SCHEMA.safeParse(body ?? {});
|
||
if (!parsed.success) {
|
||
throw new AppError({
|
||
code: "VALID_001",
|
||
message: "参数校验失败",
|
||
statusCode: 400,
|
||
details: parsed.error.flatten(),
|
||
});
|
||
}
|
||
|
||
return parsed.data.comment;
|
||
}
|
||
|
||
function parseTransferBody(body) {
|
||
const parsed = TRANSFER_BODY_SCHEMA.safeParse(body ?? {});
|
||
if (!parsed.success) {
|
||
throw new AppError({
|
||
code: "VALID_001",
|
||
message: "参数校验失败",
|
||
statusCode: 400,
|
||
details: parsed.error.flatten(),
|
||
});
|
||
}
|
||
|
||
const reason = parsed.data.reason.trim();
|
||
if (reason.length < 10) {
|
||
throw new AppError({
|
||
code: "VALID_002",
|
||
message: "转审原因不足 10 字",
|
||
statusCode: 400,
|
||
details: { reason: "too_short" },
|
||
});
|
||
}
|
||
|
||
return {
|
||
toApproverId: parsed.data.toApproverId,
|
||
reason,
|
||
};
|
||
}
|
||
|
||
function parseTaskId(taskId) {
|
||
const parsed = TASK_ID_SCHEMA.safeParse(taskId);
|
||
if (!parsed.success) {
|
||
throw new AppError({
|
||
code: "VALID_001",
|
||
message: "参数校验失败",
|
||
statusCode: 400,
|
||
details: { taskId: "invalid_uuid" },
|
||
});
|
||
}
|
||
|
||
return parsed.data;
|
||
}
|
||
|
||
function parseBatchApproveBody(body) {
|
||
const parsed = BATCH_APPROVE_BODY_SCHEMA.safeParse(body ?? {});
|
||
if (!parsed.success) {
|
||
throw new AppError({
|
||
code: "VALID_001",
|
||
message: "参数校验失败",
|
||
statusCode: 400,
|
||
details: parsed.error.flatten(),
|
||
});
|
||
}
|
||
|
||
return {
|
||
taskIds: Array.from(new Set(parsed.data.taskIds)),
|
||
comment: parsed.data.comment?.trim() || null,
|
||
};
|
||
}
|
||
|
||
function parseBatchRejectBody(body) {
|
||
const parsed = BATCH_REJECT_BODY_SCHEMA.safeParse(body ?? {});
|
||
if (!parsed.success) {
|
||
throw new AppError({
|
||
code: "VALID_001",
|
||
message: "参数校验失败",
|
||
statusCode: 400,
|
||
details: parsed.error.flatten(),
|
||
});
|
||
}
|
||
|
||
return {
|
||
taskIds: Array.from(new Set(parsed.data.taskIds)),
|
||
comment: parsed.data.comment.trim(),
|
||
};
|
||
}
|
||
|
||
function parseRemindTaskBody(body) {
|
||
const parsed = REMIND_TASK_BODY_SCHEMA.safeParse(body ?? {});
|
||
if (!parsed.success) {
|
||
throw new AppError({
|
||
code: "VALID_001",
|
||
message: "参数校验失败",
|
||
statusCode: 400,
|
||
details: parsed.error.flatten(),
|
||
});
|
||
}
|
||
|
||
return {
|
||
comment: parsed.data.comment?.trim() || null,
|
||
};
|
||
}
|
||
|
||
function parseTaskSummaryQuery(query) {
|
||
const parsed = TASK_SUMMARY_QUERY_SCHEMA.safeParse(query ?? {});
|
||
if (!parsed.success) {
|
||
throw new AppError({
|
||
code: "VALID_001",
|
||
message: "参数校验失败",
|
||
statusCode: 400,
|
||
details: parsed.error.flatten(),
|
||
});
|
||
}
|
||
|
||
return {
|
||
scope: parsed.data.scope ?? "mine",
|
||
};
|
||
}
|
||
|
||
async function handlePurchaseApprovalErpSync({
|
||
tx,
|
||
config,
|
||
request,
|
||
actorId,
|
||
purchaseRequestId,
|
||
loadContext = loadPurchaseRequestErpContext,
|
||
evaluateGate = evaluateFeatureFlag,
|
||
enqueueCommitment = enqueuePurchaseCommitmentJournalExport,
|
||
}) {
|
||
const context = await loadContext(tx, purchaseRequestId);
|
||
if (!context?.purchaseRequest) {
|
||
return { skipped: true, reason: 'purchase_request_not_found' };
|
||
}
|
||
|
||
const purchaseRequest = context.purchaseRequest;
|
||
const departmentId = purchaseRequest.department_id ?? request.employee.department_id ?? null;
|
||
const gate = await evaluateGate({
|
||
prisma: tx,
|
||
config,
|
||
flagKey: FEATURE_FLAG_KEYS.erpSync,
|
||
departmentId,
|
||
strictDepartment: true,
|
||
});
|
||
|
||
if (!gate.enabled) {
|
||
await tx.auditLog.create({
|
||
data: buildAuditLogData(request, {
|
||
actorId,
|
||
action: 'ERP_SYNC_SKIPPED_BY_FEATURE_FLAG',
|
||
targetType: 'purchase_request',
|
||
targetId: purchaseRequest.id,
|
||
extra: {
|
||
erpTarget: PROCUREMENT_ERP_TARGETS.commitmentJournal,
|
||
eventType: 'erp.journal.export',
|
||
purchaseRequestId: purchaseRequest.id,
|
||
purchaseOrderArchiveId: null,
|
||
gateReason: gate.reason,
|
||
featureFlag: FEATURE_FLAG_KEYS.erpSync,
|
||
departmentId,
|
||
},
|
||
}),
|
||
});
|
||
|
||
return { skipped: true, gate, purchaseRequest };
|
||
}
|
||
|
||
const enqueued = await enqueueCommitment(tx, config, {
|
||
purchaseRequest,
|
||
occurredAt: context.approvalOccurredAt ?? new Date(),
|
||
actorId,
|
||
requeueOnFailure: false,
|
||
});
|
||
|
||
await tx.auditLog.create({
|
||
data: buildAuditLogData(request, {
|
||
actorId,
|
||
action: 'ERP_SYNC_ENQUEUED',
|
||
targetType: 'purchase_request',
|
||
targetId: purchaseRequest.id,
|
||
extra: {
|
||
erpTarget: PROCUREMENT_ERP_TARGETS.commitmentJournal,
|
||
eventType: enqueued.eventType,
|
||
purchaseRequestId: purchaseRequest.id,
|
||
purchaseOrderArchiveId: null,
|
||
outboxId: enqueued.id,
|
||
duplicated: enqueued.duplicated,
|
||
requeued: enqueued.requeued,
|
||
gateReason: gate.reason,
|
||
featureFlag: FEATURE_FLAG_KEYS.erpSync,
|
||
departmentId,
|
||
},
|
||
}),
|
||
});
|
||
|
||
return {
|
||
skipped: false,
|
||
gate,
|
||
purchaseRequest,
|
||
enqueued,
|
||
};
|
||
}
|
||
|
||
function parseTaskListQuery(query) {
|
||
const parsed = TASK_LIST_QUERY_SCHEMA.safeParse(query ?? {});
|
||
if (!parsed.success) {
|
||
throw new AppError({
|
||
code: "VALID_001",
|
||
message: "参数校验失败",
|
||
statusCode: 400,
|
||
details: parsed.error.flatten(),
|
||
});
|
||
}
|
||
|
||
return {
|
||
status: parsed.data.status ?? "pending",
|
||
entityType: parsed.data.entityType ?? null,
|
||
page: parsed.data.page ?? 1,
|
||
pageSize: parsed.data.pageSize ?? 20,
|
||
};
|
||
}
|
||
|
||
function parseApproverListQuery(query) {
|
||
const parsed = APPROVER_LIST_QUERY_SCHEMA.safeParse(query ?? {});
|
||
if (!parsed.success) {
|
||
throw new AppError({
|
||
code: "VALID_001",
|
||
message: "参数校验失败",
|
||
statusCode: 400,
|
||
details: parsed.error.flatten(),
|
||
});
|
||
}
|
||
|
||
return {
|
||
keyword: parsed.data.keyword ?? "",
|
||
page: parsed.data.page ?? 1,
|
||
pageSize: parsed.data.pageSize ?? 20,
|
||
};
|
||
}
|
||
|
||
function isoOrNull(value) {
|
||
if (!value) {
|
||
return null;
|
||
}
|
||
|
||
return value.toISOString();
|
||
}
|
||
|
||
function mapTaskSummary(task, allowedActions = []) {
|
||
const businessSummary = buildTaskBusinessSummary(task);
|
||
const stepDisplayName = resolveWorkflowStepDisplayName(task);
|
||
const workflowInstance = task.workflow_instance
|
||
? {
|
||
entity_type: task.workflow_instance.entity_type,
|
||
entity_id: task.workflow_instance.entity_id,
|
||
current_status: task.workflow_instance.current_status,
|
||
}
|
||
: null;
|
||
|
||
return {
|
||
id: task.id,
|
||
instance_id: task.instance_id,
|
||
step_id: task.step_id,
|
||
step_name: stepDisplayName,
|
||
assignee_id: task.assignee_id,
|
||
assignee_role: task.assignee_role,
|
||
status: task.status,
|
||
outcome: task.outcome,
|
||
created_at: isoOrNull(task.created_at),
|
||
completed_at: isoOrNull(task.completed_at),
|
||
workflow_instance: workflowInstance,
|
||
|
||
instanceId: task.instance_id,
|
||
stepId: task.step_id,
|
||
stepName: stepDisplayName,
|
||
assigneeId: task.assignee_id,
|
||
assigneeRole: task.assignee_role,
|
||
createdAt: isoOrNull(task.created_at),
|
||
completedAt: isoOrNull(task.completed_at),
|
||
allowedActions,
|
||
workflowInstance: workflowInstance
|
||
? {
|
||
entityType: workflowInstance.entity_type,
|
||
entityId: workflowInstance.entity_id,
|
||
currentStatus: workflowInstance.current_status,
|
||
}
|
||
: null,
|
||
businessSummary,
|
||
};
|
||
}
|
||
|
||
function fallbackBusinessTitle(entityType) {
|
||
if (entityType === "reimbursement") return "报销单";
|
||
if (entityType === "leave") return "请假申请";
|
||
if (entityType === "attendance_correction") return "考勤修正";
|
||
if (entityType === "purchase_request") return "采购申请";
|
||
if (entityType === "travel_request") return "差旅申请";
|
||
return "业务单据";
|
||
}
|
||
|
||
function buildTaskBusinessSummary(task) {
|
||
const workflowInstance = task.workflow_instance;
|
||
if (!workflowInstance) {
|
||
return null;
|
||
}
|
||
|
||
const fallback = {
|
||
reference: workflowInstance.entity_id,
|
||
title: fallbackBusinessTitle(workflowInstance.entity_type),
|
||
applicantName: null,
|
||
amount: null,
|
||
duration: null,
|
||
businessStatus: workflowInstance.current_status ?? null,
|
||
};
|
||
|
||
if (workflowInstance.entity_type === "reimbursement" && workflowInstance.reimbursement_form) {
|
||
const form = workflowInstance.reimbursement_form;
|
||
return {
|
||
...fallback,
|
||
reference: form.form_number ?? workflowInstance.entity_id,
|
||
title: form.description ? `报销：${form.description}` : "报销单",
|
||
applicantName: form.submitter?.name ?? form.owner?.name ?? null,
|
||
amount: toMoneyString(form.total_amount),
|
||
businessStatus: form.status ?? fallback.businessStatus,
|
||
};
|
||
}
|
||
|
||
if (workflowInstance.entity_type === "leave" && workflowInstance.leave_request) {
|
||
const leaveRequest = workflowInstance.leave_request;
|
||
return {
|
||
...fallback,
|
||
title: leaveRequest.leave_type?.name
|
||
? `请假：${leaveRequest.leave_type.name}`
|
||
: "请假申请",
|
||
applicantName: leaveRequest.owner?.name ?? null,
|
||
duration:
|
||
leaveRequest.requested_days == null
|
||
? null
|
||
: `${Number(leaveRequest.requested_days)}天`,
|
||
businessStatus: leaveRequest.status ?? fallback.businessStatus,
|
||
};
|
||
}
|
||
|
||
if (workflowInstance.entity_type === "attendance_correction" && workflowInstance.attendance_correction) {
|
||
const correction = workflowInstance.attendance_correction;
|
||
const kindLabel =
|
||
correction.kind === "missed_punch"
|
||
? "补卡"
|
||
: correction.kind === "out"
|
||
? "外出"
|
||
: correction.kind === "overtime"
|
||
? "加班"
|
||
: "考勤修正";
|
||
return {
|
||
...fallback,
|
||
reference: correction.work_date?.toISOString?.().slice(0, 10) ?? workflowInstance.entity_id,
|
||
title: `${kindLabel}：${correction.reason ?? "考勤修正"}`,
|
||
applicantName: correction.owner?.name ?? null,
|
||
duration:
|
||
correction.start_at && correction.end_at
|
||
? `${correction.start_at.toISOString().slice(11, 16)}-${correction.end_at.toISOString().slice(11, 16)}`
|
||
: null,
|
||
businessStatus: correction.status ?? fallback.businessStatus,
|
||
};
|
||
}
|
||
|
||
if (workflowInstance.entity_type === "purchase_request" && workflowInstance.purchase_request) {
|
||
const purchaseRequest = workflowInstance.purchase_request;
|
||
const amount = toMoneyString(purchaseRequest.total_amount);
|
||
return {
|
||
...fallback,
|
||
reference: purchaseRequest.request_no ?? workflowInstance.entity_id,
|
||
title: purchaseRequest.title || "采购申请",
|
||
applicantName: purchaseRequest.applicant?.name ?? null,
|
||
amount: amount ? `${amount} ${purchaseRequest.currency_code}` : null,
|
||
businessStatus: purchaseRequest.status ?? fallback.businessStatus,
|
||
};
|
||
}
|
||
|
||
if (workflowInstance.entity_type === "travel_request" && workflowInstance.travel_request) {
|
||
const travelRequest = workflowInstance.travel_request;
|
||
return {
|
||
...fallback,
|
||
reference: travelRequest.request_no ?? workflowInstance.entity_id,
|
||
title: travelRequest.purpose ? `差旅：${travelRequest.purpose}` : "差旅申请",
|
||
applicantName: travelRequest.applicant?.name ?? null,
|
||
amount: toMoneyString(travelRequest.estimated_amount),
|
||
businessStatus: travelRequest.status ?? fallback.businessStatus,
|
||
};
|
||
}
|
||
|
||
return fallback;
|
||
}
|
||
|
||
function calculateWorkflowTaskDueAt(task, now = new Date()) {
|
||
if (task?.due_date) {
|
||
return new Date(task.due_date);
|
||
}
|
||
|
||
const createdAt = task?.created_at ? new Date(task.created_at) : now;
|
||
return new Date(createdAt.getTime() + WORKFLOW_DEFAULT_DUE_MS);
|
||
}
|
||
|
||
function isWorkflowTaskOverdue(task, now = new Date()) {
|
||
if (task?.status && task.status !== "pending") {
|
||
return false;
|
||
}
|
||
|
||
return calculateWorkflowTaskDueAt(task, now).getTime() <= now.getTime();
|
||
}
|
||
|
||
function incrementSummaryBucket(map, key, task, now) {
|
||
const normalizedKey = key || "未分配";
|
||
const current = map.get(normalizedKey) ?? {
|
||
key: normalizedKey,
|
||
pendingTotal: 0,
|
||
overdueTotal: 0,
|
||
};
|
||
current.pendingTotal += 1;
|
||
if (isWorkflowTaskOverdue(task, now)) {
|
||
current.overdueTotal += 1;
|
||
}
|
||
map.set(normalizedKey, current);
|
||
}
|
||
|
||
function buildWorkflowTaskSummaryPayload(tasks, scope = "mine", now = new Date()) {
|
||
const byEntityType = new Map();
|
||
const byStep = new Map();
|
||
const byAssigneeRole = new Map();
|
||
let earliestPendingAt = null;
|
||
let overdueTotal = 0;
|
||
let totalPendingAgeMs = 0;
|
||
|
||
for (const task of tasks ?? []) {
|
||
const createdAt = task.created_at ? new Date(task.created_at) : null;
|
||
if (createdAt && (!earliestPendingAt || createdAt < earliestPendingAt)) {
|
||
earliestPendingAt = createdAt;
|
||
}
|
||
if (createdAt) {
|
||
totalPendingAgeMs += Math.max(0, now.getTime() - createdAt.getTime());
|
||
}
|
||
if (isWorkflowTaskOverdue(task, now)) {
|
||
overdueTotal += 1;
|
||
}
|
||
|
||
incrementSummaryBucket(byEntityType, task.workflow_instance?.entity_type ?? "unknown", task, now);
|
||
incrementSummaryBucket(byStep, resolveWorkflowStepDisplayName(task) || task.step_id || "unknown", task, now);
|
||
incrementSummaryBucket(byAssigneeRole, task.assignee_role ?? (task.assignee_id ? "指定审批人" : "未分配"), task, now);
|
||
}
|
||
|
||
const pendingTotal = tasks?.length ?? 0;
|
||
return {
|
||
scope,
|
||
pendingTotal,
|
||
overdueTotal,
|
||
earliestPendingAt: isoOrNull(earliestPendingAt),
|
||
averagePendingAgeHours: pendingTotal
|
||
? Number((totalPendingAgeMs / pendingTotal / (60 * 60 * 1000)).toFixed(1))
|
||
: 0,
|
||
byEntityType: Array.from(byEntityType.values()),
|
||
byStep: Array.from(byStep.values()),
|
||
byAssigneeRole: Array.from(byAssigneeRole.values()),
|
||
};
|
||
}
|
||
|
||
async function buildTaskVisibilityFilters(tx, request) {
|
||
const roleFilters = request.employee.roleCodes.length
|
||
? [{ assignee_role: { in: request.employee.roleCodes } }]
|
||
: [];
|
||
const delegatedPrincipalIds = await listActiveDelegationPrincipals(tx, {
|
||
delegateEmployeeId: request.employee.id,
|
||
allowedScopes: ["all"],
|
||
});
|
||
|
||
const assigneeFilters = [{ assignee_id: request.employee.id }, ...roleFilters];
|
||
if (delegatedPrincipalIds.length) {
|
||
assigneeFilters.push({ assignee_id: { in: delegatedPrincipalIds } });
|
||
}
|
||
|
||
return assigneeFilters;
|
||
}
|
||
|
||
function canViewWorkflowEntityType(request, entityType) {
|
||
const normalizedEntityType = normalizeWorkflowEntityType(entityType);
|
||
if (normalizedEntityType === "travel_request") {
|
||
return hasPermission(request.employee.permissionCodes ?? [], "*")
|
||
|| hasPermission(request.employee.permissionCodes ?? [], "system.settings");
|
||
}
|
||
return true;
|
||
}
|
||
|
||
function buildWorkflowEntityVisibilityWhere(request, entityType = null) {
|
||
if (entityType) {
|
||
return canViewWorkflowEntityType(request, entityType)
|
||
? { entity_type: normalizeWorkflowEntityType(entityType) }
|
||
: { entity_type: "__forbidden__" };
|
||
}
|
||
|
||
const hiddenEntityTypes = [];
|
||
if (!canViewWorkflowEntityType(request, "travel_request")) {
|
||
hiddenEntityTypes.push("travel_request");
|
||
}
|
||
return hiddenEntityTypes.length ? { entity_type: { notIn: hiddenEntityTypes } } : {};
|
||
}
|
||
|
||
function listAllowedActionsForTask(request, task, actionable) {
|
||
if (task.status !== "pending" || !actionable) {
|
||
return [];
|
||
}
|
||
if (task.workflow_instance?.entity_type === "reimbursement"
|
||
&& task.step_id === FINANCE_OWNER_APPROVAL_STEP_ID
|
||
&& !request.employee.roleCodes.includes("ceo")) {
|
||
return [];
|
||
}
|
||
|
||
const actions = [];
|
||
const approvePermission = resolveEntityPermission(task.workflow_instance?.entity_type, "approve");
|
||
const canApprove = approvePermission && hasPermission(request.employee.permissionCodes, approvePermission);
|
||
if (canApprove) {
|
||
actions.push("approve");
|
||
if (task.workflow_instance?.entity_type !== "reimbursement") {
|
||
actions.push("reject");
|
||
}
|
||
if (task.workflow_instance?.entity_type !== "attendance_correction") {
|
||
actions.push("return");
|
||
}
|
||
}
|
||
|
||
if (canApprove && hasPermission(request.employee.permissionCodes, "expense.transfer")) {
|
||
actions.push("transfer");
|
||
}
|
||
|
||
return actions;
|
||
}
|
||
|
||
async function lockWorkflowTask(tx, taskId) {
|
||
const taskRows = await tx.$queryRaw`
|
||
SELECT id, instance_id, step_id, step_name, assignee_id, assignee_role, status
|
||
FROM "workflow_tasks"
|
||
WHERE id = ${taskId}::uuid
|
||
FOR UPDATE
|
||
`;
|
||
|
||
if (!Array.isArray(taskRows) || taskRows.length === 0) {
|
||
throw new AppError({
|
||
code: "SYS_404",
|
||
message: "Not Found",
|
||
statusCode: 404,
|
||
});
|
||
}
|
||
|
||
return taskRows[0];
|
||
}
|
||
|
||
function ensurePendingTask(task) {
|
||
if (task.status !== "pending") {
|
||
throw new AppError({
|
||
code: "VALID_001",
|
||
message: "参数校验失败",
|
||
statusCode: 409,
|
||
details: { task: "already_processed" },
|
||
});
|
||
}
|
||
}
|
||
|
||
async function ensureTaskAssignableToCurrentEmployee(tx, task, request) {
|
||
const matchesAssigneeId = Boolean(task.assignee_id && task.assignee_id === request.employee.id);
|
||
const matchesAssigneeRole = Boolean(
|
||
task.assignee_role && request.employee.roleCodes.includes(task.assignee_role),
|
||
);
|
||
const isUnassigned = !task.assignee_id && !task.assignee_role;
|
||
|
||
if (matchesAssigneeId || matchesAssigneeRole || isUnassigned) {
|
||
return {
|
||
delegated: false,
|
||
delegationId: null,
|
||
principalId: null,
|
||
};
|
||
}
|
||
|
||
if (task.assignee_id) {
|
||
const delegation = await findActiveDelegationForDelegate(tx, {
|
||
principalEmployeeId: task.assignee_id,
|
||
delegateEmployeeId: request.employee.id,
|
||
allowedScopes: ["all"],
|
||
});
|
||
|
||
if (delegation) {
|
||
return {
|
||
delegated: true,
|
||
delegationId: delegation.id,
|
||
principalId: delegation.principal_employee_id,
|
||
};
|
||
}
|
||
}
|
||
|
||
throw new AppError({
|
||
code: "PERM_002",
|
||
message: "不在审批范围/非当前处理人",
|
||
statusCode: 403,
|
||
});
|
||
}
|
||
|
||
function withDelegationPayload(payload, assignment, delegateId) {
|
||
const nextPayload = payload ? { ...payload } : {};
|
||
|
||
if (assignment?.delegated) {
|
||
nextPayload.delegation_id = assignment.delegationId;
|
||
nextPayload.principal_id = assignment.principalId;
|
||
nextPayload.delegate_id = delegateId;
|
||
}
|
||
|
||
return nextPayload;
|
||
}
|
||
|
||
async function loadWorkflowInstanceForTask(tx, instanceId) {
|
||
const workflowInstance = await tx.workflowInstance.findUnique({
|
||
where: { id: instanceId },
|
||
select: {
|
||
id: true,
|
||
entity_type: true,
|
||
entity_id: true,
|
||
submitter_id: true,
|
||
current_step_id: true,
|
||
context_data: true,
|
||
workflow_definition: {
|
||
select: {
|
||
definition_json: true,
|
||
},
|
||
},
|
||
},
|
||
});
|
||
|
||
if (!workflowInstance) {
|
||
throw new AppError({
|
||
code: "SYS_404",
|
||
message: "Not Found",
|
||
statusCode: 404,
|
||
});
|
||
}
|
||
|
||
return workflowInstance;
|
||
}
|
||
|
||
async function loadReimbursementNotifyContext(tx, reimbursementId) {
|
||
return tx.reimbursementForm.findUnique({
|
||
where: { id: reimbursementId },
|
||
select: {
|
||
id: true,
|
||
form_number: true,
|
||
total_amount: true,
|
||
owner_id: true,
|
||
submitter_id: true,
|
||
owner: {
|
||
select: {
|
||
id: true,
|
||
name: true,
|
||
},
|
||
},
|
||
},
|
||
});
|
||
}
|
||
|
||
function uniq(values) {
|
||
return Array.from(new Set((values ?? []).filter(Boolean)));
|
||
}
|
||
|
||
async function loadLeaveNotifyContext(tx, leaveRequestId) {
|
||
return tx.leaveRequest.findUnique({
|
||
where: { id: leaveRequestId },
|
||
select: {
|
||
id: true,
|
||
owner_id: true,
|
||
start_date: true,
|
||
end_date: true,
|
||
requested_days: true,
|
||
leave_type: {
|
||
select: {
|
||
id: true,
|
||
code: true,
|
||
name: true,
|
||
},
|
||
},
|
||
owner: {
|
||
select: {
|
||
id: true,
|
||
name: true,
|
||
},
|
||
},
|
||
},
|
||
});
|
||
}
|
||
|
||
async function loadAttendanceCorrectionNotifyContext(tx, correctionId) {
|
||
return tx.attendanceCorrection.findUnique({
|
||
where: { id: correctionId },
|
||
select: {
|
||
id: true,
|
||
owner_id: true,
|
||
kind: true,
|
||
status: true,
|
||
work_date: true,
|
||
start_at: true,
|
||
end_at: true,
|
||
reason: true,
|
||
owner: {
|
||
select: {
|
||
id: true,
|
||
name: true,
|
||
},
|
||
},
|
||
},
|
||
});
|
||
}
|
||
|
||
async function loadPurchaseNotifyContext(tx, purchaseRequestId) {
|
||
return tx.purchaseRequest.findUnique({
|
||
where: { id: purchaseRequestId },
|
||
select: {
|
||
id: true,
|
||
request_no: true,
|
||
total_amount: true,
|
||
applicant_id: true,
|
||
submitter_id: true,
|
||
applicant: {
|
||
select: {
|
||
id: true,
|
||
name: true,
|
||
},
|
||
},
|
||
},
|
||
});
|
||
}
|
||
|
||
async function loadTravelNotifyContext(tx, travelRequestId) {
|
||
return tx.travelRequest.findUnique({
|
||
where: { id: travelRequestId },
|
||
select: {
|
||
id: true,
|
||
request_no: true,
|
||
estimated_amount: true,
|
||
applicant_employee_id: true,
|
||
submitter_id: true,
|
||
applicant: {
|
||
select: {
|
||
id: true,
|
||
name: true,
|
||
},
|
||
},
|
||
},
|
||
});
|
||
}
|
||
|
||
async function loadWorkflowNotifyContext(tx, entityType, entityId) {
|
||
const normalizedEntityType = normalizeWorkflowEntityType(entityType);
|
||
|
||
if (normalizedEntityType === 'reimbursement') {
|
||
const record = await loadReimbursementNotifyContext(tx, entityId);
|
||
return {
|
||
record,
|
||
recipientEmployeeIds: uniq([record?.owner_id, record?.submitter_id]),
|
||
};
|
||
}
|
||
|
||
if (normalizedEntityType === 'leave') {
|
||
const record = await loadLeaveNotifyContext(tx, entityId);
|
||
return {
|
||
record,
|
||
recipientEmployeeIds: uniq([record?.owner_id]),
|
||
};
|
||
}
|
||
|
||
if (normalizedEntityType === 'attendance_correction') {
|
||
const record = await loadAttendanceCorrectionNotifyContext(tx, entityId);
|
||
return {
|
||
record,
|
||
recipientEmployeeIds: uniq([record?.owner_id]),
|
||
};
|
||
}
|
||
|
||
if (normalizedEntityType === 'purchase_request') {
|
||
const record = await loadPurchaseNotifyContext(tx, entityId);
|
||
return {
|
||
record,
|
||
recipientEmployeeIds: uniq([record?.applicant_id, record?.submitter_id]),
|
||
};
|
||
}
|
||
|
||
if (normalizedEntityType === 'travel_request') {
|
||
const record = await loadTravelNotifyContext(tx, entityId);
|
||
return {
|
||
record,
|
||
recipientEmployeeIds: uniq([record?.applicant_employee_id, record?.submitter_id]),
|
||
};
|
||
}
|
||
|
||
return {
|
||
record: null,
|
||
recipientEmployeeIds: [],
|
||
};
|
||
}
|
||
|
||
function resolveBusinessApprovePermission(entityType) {
|
||
return resolveEntityPermission(normalizeWorkflowEntityType(entityType), "approve");
|
||
}
|
||
|
||
function roleHasBusinessApprovePermission(roleCode, approvePermission) {
|
||
if (!isBusinessApprovalRoleCode(roleCode) || !approvePermission) {
|
||
return false;
|
||
}
|
||
|
||
return (ROLE_PERMISSIONS[roleCode] ?? []).includes(approvePermission);
|
||
}
|
||
|
||
function employeeHasBusinessApproveRole(employee, entityType) {
|
||
const approvePermission = resolveBusinessApprovePermission(entityType);
|
||
return Boolean(
|
||
approvePermission &&
|
||
(employee?.roleCodes ?? []).some((roleCode) =>
|
||
roleHasBusinessApprovePermission(roleCode, approvePermission),
|
||
),
|
||
);
|
||
}
|
||
|
||
function ensureBusinessApproveRole(employee, entityType) {
|
||
if (employeeHasBusinessApproveRole(employee, entityType)) {
|
||
return;
|
||
}
|
||
|
||
throw new AppError({
|
||
code: "PERM_002",
|
||
message: "不在审批范围/非当前处理人",
|
||
statusCode: 403,
|
||
details: { workflow: "business_approval_role_required" },
|
||
});
|
||
}
|
||
|
||
function collectWorkflowApplicantIds(workflowInstance, record) {
|
||
const entityType = normalizeWorkflowEntityType(workflowInstance.entity_type);
|
||
|
||
if (entityType === "reimbursement") {
|
||
return uniq([record?.owner_id, record?.submitter_id, workflowInstance.submitter_id]);
|
||
}
|
||
|
||
if (entityType === "leave") {
|
||
return uniq([record?.owner_id, workflowInstance.submitter_id]);
|
||
}
|
||
|
||
if (entityType === "attendance_correction") {
|
||
return uniq([record?.owner_id, workflowInstance.submitter_id]);
|
||
}
|
||
|
||
if (entityType === "purchase_request") {
|
||
return uniq([record?.applicant_id, record?.submitter_id, workflowInstance.submitter_id]);
|
||
}
|
||
|
||
if (entityType === "travel_request") {
|
||
return uniq([record?.applicant_employee_id, record?.submitter_id, workflowInstance.submitter_id]);
|
||
}
|
||
|
||
return uniq([workflowInstance.submitter_id]);
|
||
}
|
||
|
||
async function loadWorkflowApplicantIds(tx, workflowInstance) {
|
||
const { record } = await loadWorkflowNotifyContext(
|
||
tx,
|
||
workflowInstance.entity_type,
|
||
workflowInstance.entity_id,
|
||
);
|
||
|
||
if (!record) {
|
||
throw new AppError({
|
||
code: "VALID_001",
|
||
message: "参数校验失败",
|
||
statusCode: 409,
|
||
details: { workflow: "entity_not_processable" },
|
||
});
|
||
}
|
||
|
||
return collectWorkflowApplicantIds(workflowInstance, record);
|
||
}
|
||
|
||
function ensureNoSelfApproval(actorIds, applicantIds) {
|
||
if (!actorIds.some((actorId) => applicantIds.includes(actorId))) {
|
||
return;
|
||
}
|
||
|
||
throw new AppError({
|
||
code: "VALID_001",
|
||
message: "参数校验失败",
|
||
statusCode: 409,
|
||
details: { workflow: "self_approval_not_allowed" },
|
||
});
|
||
}
|
||
|
||
async function ensureFinanceOwnerCeoActors(tx, workflowInstance, actorIds) {
|
||
if (workflowInstance.entity_type !== "reimbursement"
|
||
|| workflowInstance.current_step_id !== FINANCE_OWNER_APPROVAL_STEP_ID) {
|
||
return;
|
||
}
|
||
const eligible = await tx.employeeRole.findMany({
|
||
where: {
|
||
employee_id: { in: actorIds },
|
||
role_code: "ceo",
|
||
employee: { status: "active", archived_at: null },
|
||
},
|
||
select: { employee_id: true },
|
||
});
|
||
if (actorIds.some((actorId) => !eligible.some((holder) => holder.employee_id === actorId))) {
|
||
throw buildBusinessValidationError("reimbursement.finance_owner_ceo_required", {
|
||
workflow: "finance_owner_ceo_required",
|
||
}, 403);
|
||
}
|
||
}
|
||
|
||
async function ensureWorkflowApprovalAllowed(tx, workflowInstance, request, assignment) {
|
||
ensureBusinessApproveRole(request.employee, workflowInstance.entity_type);
|
||
const applicantIds = await loadWorkflowApplicantIds(tx, workflowInstance);
|
||
const actorIds = uniq([request.employee.id, assignment?.principalId]);
|
||
ensureNoSelfApproval(actorIds, applicantIds);
|
||
await ensureFinanceOwnerCeoActors(tx, workflowInstance, actorIds);
|
||
return applicantIds;
|
||
}
|
||
|
||
function resolveWorkflowOutcomeNotificationType(entityType, outcome) {
|
||
const normalizedEntityType = normalizeWorkflowEntityType(entityType);
|
||
|
||
if (outcome === 'approved') {
|
||
if (normalizedEntityType === 'reimbursement') return NOTIFICATION_TYPES.reimbursementApproved;
|
||
if (normalizedEntityType === 'leave') return NOTIFICATION_TYPES.leaveApproved;
|
||
if (normalizedEntityType === 'attendance_correction') return NOTIFICATION_TYPES.attendanceCorrectionApproved;
|
||
if (normalizedEntityType === 'purchase_request') return NOTIFICATION_TYPES.purchaseRequestApproved;
|
||
if (normalizedEntityType === 'travel_request') return NOTIFICATION_TYPES.travelRequestApproved;
|
||
}
|
||
|
||
if (outcome === 'rejected') {
|
||
if (normalizedEntityType === 'reimbursement') return NOTIFICATION_TYPES.reimbursementRejected;
|
||
if (normalizedEntityType === 'leave') return NOTIFICATION_TYPES.leaveRejected;
|
||
if (normalizedEntityType === 'attendance_correction') return NOTIFICATION_TYPES.attendanceCorrectionRejected;
|
||
if (normalizedEntityType === 'purchase_request') return NOTIFICATION_TYPES.purchaseRequestRejected;
|
||
if (normalizedEntityType === 'travel_request') return NOTIFICATION_TYPES.travelRequestRejected;
|
||
}
|
||
|
||
if (outcome === 'returned') {
|
||
if (normalizedEntityType === 'reimbursement') return NOTIFICATION_TYPES.reimbursementReturned;
|
||
if (normalizedEntityType === 'leave') return NOTIFICATION_TYPES.leaveReturned;
|
||
if (normalizedEntityType === 'purchase_request') return NOTIFICATION_TYPES.purchaseRequestReturned;
|
||
if (normalizedEntityType === 'travel_request') return NOTIFICATION_TYPES.travelRequestReturned;
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
async function queueTaskAssignedNotifications({
|
||
tx,
|
||
actorId,
|
||
emailTasks,
|
||
dispatchTasks,
|
||
recipientEmployeeIds,
|
||
title,
|
||
body,
|
||
taskId,
|
||
entityType,
|
||
entityId,
|
||
}) {
|
||
const recipients = uniq(recipientEmployeeIds);
|
||
if (!recipients.length) {
|
||
return;
|
||
}
|
||
|
||
const notifications = await createNotificationsWithRecords(tx, {
|
||
recipientEmployeeIds: recipients,
|
||
type: NOTIFICATION_TYPES.workflowTaskAssigned,
|
||
title,
|
||
body,
|
||
targetType: 'workflow_task',
|
||
targetId: taskId,
|
||
});
|
||
dispatchTasks.push({
|
||
notifications,
|
||
type: NOTIFICATION_TYPES.workflowTaskAssigned,
|
||
title,
|
||
body,
|
||
targetType: 'workflow_task',
|
||
targetId: taskId,
|
||
targetPath: `/workflow/tasks/${taskId}`,
|
||
actorId,
|
||
});
|
||
|
||
emailTasks.push({
|
||
type: NOTIFICATION_TYPES.workflowTaskAssigned,
|
||
recipientEmployeeIds: recipients,
|
||
subject: title,
|
||
body,
|
||
targetPath: `/workflow/tasks/${taskId}`,
|
||
});
|
||
}
|
||
|
||
async function queueWorkflowTaskPromptNotifications({
|
||
tx,
|
||
actorId,
|
||
emailTasks,
|
||
dispatchTasks,
|
||
task,
|
||
workflowInstance,
|
||
notificationType,
|
||
copyBuilder,
|
||
excludeActor = true,
|
||
}) {
|
||
const recipientEmployeeIds = uniq(
|
||
await resolveRecipientsForAssignee(tx, {
|
||
assigneeId: task.assignee_id,
|
||
assigneeRole: task.assignee_role,
|
||
}),
|
||
).filter((employeeId) => !excludeActor || employeeId !== actorId);
|
||
if (!recipientEmployeeIds.length) {
|
||
return [];
|
||
}
|
||
|
||
const notificationContext = await loadWorkflowNotifyContext(
|
||
tx,
|
||
workflowInstance.entity_type,
|
||
workflowInstance.entity_id,
|
||
);
|
||
const entityMeta = buildWorkflowEntityMeta(
|
||
workflowInstance.entity_type,
|
||
notificationContext.record,
|
||
workflowInstance.entity_id,
|
||
);
|
||
const copy = copyBuilder(entityMeta);
|
||
const notifications = await createNotificationsWithRecords(tx, {
|
||
recipientEmployeeIds,
|
||
type: notificationType,
|
||
title: copy.title,
|
||
body: copy.body,
|
||
targetType: "workflow_task",
|
||
targetId: task.id,
|
||
});
|
||
|
||
dispatchTasks.push({
|
||
notifications,
|
||
type: notificationType,
|
||
title: copy.title,
|
||
body: copy.body,
|
||
targetType: "workflow_task",
|
||
targetId: task.id,
|
||
targetPath: `/mobile/approvals?taskId=${task.id}`,
|
||
actorId,
|
||
});
|
||
|
||
emailTasks.push({
|
||
type: notificationType,
|
||
recipientEmployeeIds,
|
||
subject: copy.title,
|
||
body: copy.body,
|
||
targetPath: `/workflow/tasks/${task.id}`,
|
||
});
|
||
|
||
return notifications;
|
||
}
|
||
|
||
async function queueWorkflowOutcomeNotifications({
|
||
tx,
|
||
actorId,
|
||
emailTasks,
|
||
dispatchTasks,
|
||
workflowInstance,
|
||
outcome,
|
||
comment = null,
|
||
}) {
|
||
const normalizedEntityType = normalizeWorkflowEntityType(workflowInstance.entity_type);
|
||
const notificationType = resolveWorkflowOutcomeNotificationType(normalizedEntityType, outcome);
|
||
if (!notificationType) {
|
||
return;
|
||
}
|
||
|
||
const context = await loadWorkflowNotifyContext(tx, normalizedEntityType, workflowInstance.entity_id);
|
||
const recipients = uniq(context.recipientEmployeeIds);
|
||
if (!recipients.length) {
|
||
return;
|
||
}
|
||
|
||
const entityMeta = buildWorkflowEntityMeta(normalizedEntityType, context.record, workflowInstance.entity_id);
|
||
const copy =
|
||
outcome === 'approved'
|
||
? buildApprovedCopy(entityMeta)
|
||
: outcome === 'rejected'
|
||
? buildRejectedCopy(entityMeta, comment)
|
||
: buildReturnedCopy(entityMeta, comment);
|
||
|
||
const notifications = await createNotificationsWithRecords(tx, {
|
||
recipientEmployeeIds: recipients,
|
||
type: notificationType,
|
||
title: copy.title,
|
||
body: copy.body,
|
||
targetType: entityMeta.targetType,
|
||
targetId: workflowInstance.entity_id,
|
||
});
|
||
dispatchTasks.push({
|
||
notifications,
|
||
type: notificationType,
|
||
title: copy.title,
|
||
body: copy.body,
|
||
targetType: entityMeta.targetType,
|
||
targetId: workflowInstance.entity_id,
|
||
targetPath: entityMeta.detailPath,
|
||
actorId,
|
||
});
|
||
|
||
emailTasks.push({
|
||
type: notificationType,
|
||
recipientEmployeeIds: recipients,
|
||
subject: copy.title,
|
||
body: copy.body,
|
||
targetPath: entityMeta.detailPath,
|
||
});
|
||
}
|
||
|
||
async function createSkipHistoryRecords(tx, workflowInstanceId, actorId, ownerId, skippedSteps) {
|
||
for (const skipped of skippedSteps) {
|
||
await tx.workflowHistory.create({
|
||
data: {
|
||
instance_id: workflowInstanceId,
|
||
actor_id: actorId,
|
||
action: "skip",
|
||
payload: {
|
||
step_id: skipped.step.id,
|
||
reason: skipped.reason,
|
||
owner_id: ownerId,
|
||
depth_checked: skipped.depthChecked,
|
||
},
|
||
},
|
||
});
|
||
}
|
||
}
|
||
|
||
async function cancelOtherPendingTasks(tx, workflowInstanceId, taskId, actorId) {
|
||
await tx.workflowTask.updateMany({
|
||
where: {
|
||
instance_id: workflowInstanceId,
|
||
status: "pending",
|
||
NOT: { id: taskId },
|
||
},
|
||
data: {
|
||
status: "cancelled",
|
||
completed_at: new Date(),
|
||
completed_by: actorId,
|
||
},
|
||
});
|
||
}
|
||
|
||
async function ensureTransferChainNotExceeded(tx, taskId) {
|
||
const transferCount = await tx.workflowHistory.count({
|
||
where: {
|
||
task_id: taskId,
|
||
action: "transfer",
|
||
},
|
||
});
|
||
|
||
if (transferCount >= 3) {
|
||
throw new AppError({
|
||
code: "WORKFLOW_003",
|
||
message: "已达转审上限",
|
||
statusCode: 409,
|
||
details: { transfer: "chain_limit_exceeded" },
|
||
});
|
||
}
|
||
|
||
return transferCount;
|
||
}
|
||
|
||
async function ensureTransferTargetEligible(tx, toApproverId, approvePermission) {
|
||
const target = await tx.employee.findUnique({
|
||
where: { id: toApproverId },
|
||
select: {
|
||
id: true,
|
||
status: true,
|
||
roles: {
|
||
select: {
|
||
role_code: true,
|
||
},
|
||
},
|
||
},
|
||
});
|
||
|
||
if (!target || target.status !== "active") {
|
||
throw new AppError({
|
||
code: "VALID_001",
|
||
message: "参数校验失败",
|
||
statusCode: 409,
|
||
details: { toApproverId: "invalid_target" },
|
||
});
|
||
}
|
||
|
||
const roleCodes = target.roles.map((item) => item.role_code);
|
||
if (!roleCodes.some((roleCode) => roleHasBusinessApprovePermission(roleCode, approvePermission))) {
|
||
throw new AppError({
|
||
code: "VALID_001",
|
||
message: "参数校验失败",
|
||
statusCode: 409,
|
||
details: { toApproverId: "target_not_approver" },
|
||
});
|
||
}
|
||
}
|
||
|
||
async function flushWorkflowSideEffects({ fastify, request, emailTasks, dispatchTasks }) {
|
||
for (const task of emailTasks) {
|
||
void sendNotificationEmailSafe({
|
||
prisma: fastify.prisma,
|
||
config: fastify.config,
|
||
logger: fastify.log,
|
||
requestId: request.id,
|
||
...task,
|
||
});
|
||
}
|
||
|
||
await flushNotificationDispatchTasks({
|
||
prisma: fastify.prisma,
|
||
config: fastify.config,
|
||
logger: fastify.log,
|
||
requestId: request.id,
|
||
tasks: dispatchTasks,
|
||
});
|
||
}
|
||
|
||
function ensureWorkflowEntityType(workflowInstance, entityType) {
|
||
if (!entityType || workflowInstance.entity_type === entityType) {
|
||
return;
|
||
}
|
||
|
||
throw new AppError({
|
||
code: "VALID_001",
|
||
message: "参数校验失败",
|
||
statusCode: 409,
|
||
details: {
|
||
task: "unsupported_entity_type",
|
||
entityType: workflowInstance.entity_type,
|
||
expectedEntityType: entityType,
|
||
},
|
||
});
|
||
}
|
||
|
||
async function ensureWorkflowReminderAllowed(tx, workflowInstance, task, request) {
|
||
const applicantIds = await loadWorkflowApplicantIds(tx, workflowInstance);
|
||
if (!applicantIds.includes(request.employee.id)) {
|
||
throw new AppError({
|
||
code: "PERM_002",
|
||
message: "无权催办该审批",
|
||
statusCode: 403,
|
||
details: { workflow: "remind_owner_required" },
|
||
});
|
||
}
|
||
|
||
const recipientEmployeeIds = await resolveRecipientsForAssignee(tx, {
|
||
assigneeId: task.assignee_id,
|
||
assigneeRole: task.assignee_role,
|
||
});
|
||
if (recipientEmployeeIds.includes(request.employee.id)) {
|
||
throw new AppError({
|
||
code: "VALID_001",
|
||
message: "参数校验失败",
|
||
statusCode: 409,
|
||
details: { workflow: "self_remind_not_allowed" },
|
||
});
|
||
}
|
||
|
||
return applicantIds;
|
||
}
|
||
|
||
async function ensureWorkflowReminderCooldown(tx, taskId, actorId, now) {
|
||
const since = new Date(now.getTime() - WORKFLOW_REMINDER_COOLDOWN_MS);
|
||
const existing = await tx.workflowHistory.findFirst({
|
||
where: {
|
||
task_id: taskId,
|
||
actor_id: actorId,
|
||
action: WORKFLOW_REMIND_ACTION,
|
||
created_at: { gte: since },
|
||
},
|
||
orderBy: { created_at: "desc" },
|
||
select: {
|
||
id: true,
|
||
created_at: true,
|
||
},
|
||
});
|
||
|
||
if (!existing) {
|
||
return null;
|
||
}
|
||
|
||
const nextAllowedAt = new Date(existing.created_at.getTime() + WORKFLOW_REMINDER_COOLDOWN_MS);
|
||
throw new AppError({
|
||
code: "VALID_001",
|
||
message: "催办过于频繁",
|
||
statusCode: 409,
|
||
details: {
|
||
workflow: "remind_too_frequent",
|
||
nextAllowedAt: nextAllowedAt.toISOString(),
|
||
},
|
||
});
|
||
}
|
||
|
||
async function executeRemindWorkflowTask({
|
||
fastify,
|
||
request,
|
||
taskId,
|
||
comment = null,
|
||
}) {
|
||
let result = null;
|
||
const emailTasks = [];
|
||
const dispatchTasks = [];
|
||
const now = new Date();
|
||
|
||
await fastify.prisma.$transaction(async (tx) => {
|
||
const lockedTask = await lockWorkflowTask(tx, taskId);
|
||
ensurePendingTask(lockedTask);
|
||
const workflowInstance = await loadWorkflowInstanceForTask(tx, lockedTask.instance_id);
|
||
await ensureWorkflowReminderAllowed(tx, workflowInstance, lockedTask, request);
|
||
await ensureWorkflowReminderCooldown(tx, taskId, request.employee.id, now);
|
||
|
||
const safeComment = comment || "申请人催办";
|
||
await tx.workflowHistory.create({
|
||
data: {
|
||
instance_id: workflowInstance.id,
|
||
task_id: taskId,
|
||
actor_id: request.employee.id,
|
||
action: WORKFLOW_REMIND_ACTION,
|
||
comment: safeComment,
|
||
payload: {
|
||
from_step_id: lockedTask.step_id,
|
||
assignee_id: lockedTask.assignee_id,
|
||
assignee_role: lockedTask.assignee_role,
|
||
reminder_window_hours: 24,
|
||
},
|
||
},
|
||
});
|
||
|
||
await tx.auditLog.create({
|
||
data: buildAuditLogData(request, {
|
||
actorId: request.employee.id,
|
||
action: "WORKFLOW_TASK_REMINDED",
|
||
targetType: "workflow_task",
|
||
targetId: taskId,
|
||
extra: {
|
||
workflowInstanceId: workflowInstance.id,
|
||
entityType: workflowInstance.entity_type,
|
||
entityId: workflowInstance.entity_id,
|
||
assigneeId: lockedTask.assignee_id,
|
||
assigneeRole: lockedTask.assignee_role,
|
||
reminderWindowHours: 24,
|
||
},
|
||
}),
|
||
});
|
||
|
||
let notificationCount = 0;
|
||
try {
|
||
const notifications = await queueWorkflowTaskPromptNotifications({
|
||
tx,
|
||
actorId: request.employee.id,
|
||
emailTasks,
|
||
dispatchTasks,
|
||
task: lockedTask,
|
||
workflowInstance,
|
||
notificationType: NOTIFICATION_TYPES.workflowTaskReminded,
|
||
copyBuilder: buildRemindedTaskCopy,
|
||
});
|
||
notificationCount = notifications.length;
|
||
} catch (error) {
|
||
fastify.log.error(
|
||
{ err: error, taskId, workflowInstanceId: workflowInstance.id },
|
||
"Failed to create workflow reminder notifications",
|
||
);
|
||
}
|
||
|
||
result = {
|
||
taskId,
|
||
outcome: "reminded",
|
||
workflowInstanceId: workflowInstance.id,
|
||
nextAllowedAt: new Date(now.getTime() + WORKFLOW_REMINDER_COOLDOWN_MS).toISOString(),
|
||
notificationCount,
|
||
};
|
||
});
|
||
|
||
await flushWorkflowSideEffects({ fastify, request, emailTasks, dispatchTasks });
|
||
return result;
|
||
}
|
||
|
||
async function executeApproveWorkflowTask({
|
||
fastify,
|
||
request,
|
||
taskId,
|
||
allowedEntityType = null,
|
||
}) {
|
||
let result = null;
|
||
const emailTasks = [];
|
||
const dispatchTasks = [];
|
||
|
||
await fastify.prisma.$transaction(async (tx) => {
|
||
const task = await lockWorkflowTask(tx, taskId);
|
||
ensurePendingTask(task);
|
||
const assignment = await ensureTaskAssignableToCurrentEmployee(tx, task, request);
|
||
|
||
const workflowInstance = await loadWorkflowInstanceForTask(tx, task.instance_id);
|
||
ensureWorkflowEntityType(workflowInstance, allowedEntityType);
|
||
fastify.assertEntityPermission(request.employee, workflowInstance.entity_type, "approve");
|
||
await ensureWorkflowApprovalAllowed(tx, workflowInstance, request, assignment);
|
||
const steps = getWorkflowStepsSnapshot(workflowInstance);
|
||
const currentStepIndex = steps.findIndex((step) => step.id === workflowInstance.current_step_id);
|
||
if (currentStepIndex < 0) {
|
||
throw new AppError({
|
||
code: "VALID_001",
|
||
message: "参数校验失败",
|
||
statusCode: 409,
|
||
details: { workflow: "current_step_not_found" },
|
||
});
|
||
}
|
||
|
||
const now = new Date();
|
||
await tx.workflowTask.update({
|
||
where: { id: taskId },
|
||
data: {
|
||
status: "completed",
|
||
outcome: "approved",
|
||
completed_at: now,
|
||
completed_by: request.employee.id,
|
||
},
|
||
});
|
||
|
||
const { actionable, skipped } = await resolveActionableStep({
|
||
tx,
|
||
steps,
|
||
startIndex: currentStepIndex + 1,
|
||
ownerId: workflowInstance.context_data?.owner_id,
|
||
logger: fastify.log,
|
||
});
|
||
|
||
await createSkipHistoryRecords(
|
||
tx,
|
||
workflowInstance.id,
|
||
request.employee.id,
|
||
workflowInstance.context_data?.owner_id,
|
||
skipped,
|
||
);
|
||
|
||
if (actionable) {
|
||
const nextTask = await tx.workflowTask.create({
|
||
data: {
|
||
instance_id: workflowInstance.id,
|
||
step_id: actionable.step.id,
|
||
step_name: actionable.step.name ?? actionable.step.id,
|
||
assignee_id: actionable.assigneeId,
|
||
assignee_role: actionable.assigneeRole,
|
||
},
|
||
select: { id: true },
|
||
});
|
||
|
||
await tx.workflowInstance.update({
|
||
where: { id: workflowInstance.id },
|
||
data: {
|
||
current_step_id: actionable.step.id,
|
||
current_status: "pending",
|
||
updated_by: request.employee.id,
|
||
},
|
||
});
|
||
|
||
await tx.workflowHistory.create({
|
||
data: {
|
||
instance_id: workflowInstance.id,
|
||
task_id: taskId,
|
||
actor_id: request.employee.id,
|
||
action: "approve",
|
||
payload: withDelegationPayload(
|
||
{
|
||
from_step_id: task.step_id,
|
||
to_step_id: actionable.step.id,
|
||
},
|
||
assignment,
|
||
request.employee.id,
|
||
),
|
||
},
|
||
});
|
||
|
||
try {
|
||
const notificationContext = await loadWorkflowNotifyContext(
|
||
tx,
|
||
workflowInstance.entity_type,
|
||
workflowInstance.entity_id,
|
||
);
|
||
const entityMeta = buildWorkflowEntityMeta(
|
||
workflowInstance.entity_type,
|
||
notificationContext.record,
|
||
workflowInstance.entity_id,
|
||
);
|
||
const pendingCopy = buildPendingTaskCopy(entityMeta);
|
||
const recipients = await resolveRecipientsForAssignee(tx, {
|
||
assigneeId: actionable.assigneeId,
|
||
assigneeRole: actionable.assigneeRole,
|
||
});
|
||
|
||
await queueTaskAssignedNotifications({
|
||
tx,
|
||
actorId: request.employee.id,
|
||
emailTasks,
|
||
dispatchTasks,
|
||
recipientEmployeeIds: recipients,
|
||
title: pendingCopy.title,
|
||
body: pendingCopy.body,
|
||
taskId: nextTask.id,
|
||
entityType: workflowInstance.entity_type,
|
||
entityId: workflowInstance.entity_id,
|
||
});
|
||
} catch (error) {
|
||
fastify.log.error(
|
||
{ err: error, taskId: nextTask.id },
|
||
"Failed to create task assigned notifications",
|
||
);
|
||
}
|
||
|
||
result = {
|
||
taskId,
|
||
outcome: "approved",
|
||
workflowInstanceId: workflowInstance.id,
|
||
nextTaskId: nextTask.id,
|
||
reimbursementStatus: workflowInstance.entity_type === "reimbursement" ? "reviewing" : null,
|
||
};
|
||
return;
|
||
}
|
||
|
||
await tx.workflowInstance.update({
|
||
where: { id: workflowInstance.id },
|
||
data: {
|
||
current_status: "approved",
|
||
completed_at: now,
|
||
updated_by: request.employee.id,
|
||
},
|
||
});
|
||
|
||
if (workflowInstance.entity_type === "reimbursement") {
|
||
await tx.reimbursementForm.update({
|
||
where: { id: workflowInstance.entity_id },
|
||
data: {
|
||
status: "approved",
|
||
updated_by: request.employee.id,
|
||
},
|
||
});
|
||
} else if (workflowInstance.entity_type === "leave") {
|
||
const leaveRequest = await tx.leaveRequest.findUnique({
|
||
where: { id: workflowInstance.entity_id },
|
||
select: {
|
||
id: true,
|
||
owner_id: true,
|
||
leave_type_id: true,
|
||
requested_days: true,
|
||
},
|
||
});
|
||
const reserveAnchor = await tx.leaveLedger.findFirst({
|
||
where: {
|
||
leave_request_id: workflowInstance.entity_id,
|
||
entry_type: "reserve",
|
||
},
|
||
orderBy: { created_at: "desc" },
|
||
select: {
|
||
leave_policy_id: true,
|
||
period_start: true,
|
||
period_end: true,
|
||
},
|
||
});
|
||
|
||
await tx.leaveRequest.update({
|
||
where: { id: workflowInstance.entity_id },
|
||
data: {
|
||
status: "approved",
|
||
updated_by: request.employee.id,
|
||
},
|
||
});
|
||
|
||
if (leaveRequest) {
|
||
await consumeReservedLeave(tx, {
|
||
leaveRequestId: workflowInstance.entity_id,
|
||
employeeId: leaveRequest.owner_id,
|
||
leaveTypeId: leaveRequest.leave_type_id,
|
||
leavePolicyId: reserveAnchor?.leave_policy_id ?? null,
|
||
periodStart: reserveAnchor?.period_start ?? null,
|
||
periodEnd: reserveAnchor?.period_end ?? null,
|
||
requestedDays: leaveRequest.requested_days,
|
||
createdBy: request.employee.id,
|
||
});
|
||
}
|
||
} else if (workflowInstance.entity_type === "attendance_correction") {
|
||
await tx.attendanceCorrection.update({
|
||
where: { id: workflowInstance.entity_id },
|
||
data: {
|
||
status: "approved",
|
||
updated_by: request.employee.id,
|
||
},
|
||
});
|
||
} else if (workflowInstance.entity_type === "purchase_request") {
|
||
await tx.purchaseRequest.update({
|
||
where: { id: workflowInstance.entity_id },
|
||
data: {
|
||
status: "approved",
|
||
updated_by: request.employee.id,
|
||
},
|
||
});
|
||
|
||
await confirmBudgetForEntity(tx, {
|
||
entityType: "purchase_request",
|
||
entityId: workflowInstance.entity_id,
|
||
actorId: request.employee.id,
|
||
note: "approved_confirm_purchase_budget",
|
||
});
|
||
|
||
try {
|
||
await handlePurchaseApprovalErpSync({
|
||
tx,
|
||
config: fastify.config,
|
||
request,
|
||
actorId: request.employee.id,
|
||
purchaseRequestId: workflowInstance.entity_id,
|
||
});
|
||
} catch (error) {
|
||
fastify.log.error(
|
||
{ err: error, purchaseRequestId: workflowInstance.entity_id },
|
||
"Failed to enqueue purchase approval ERP events",
|
||
);
|
||
}
|
||
} else if (workflowInstance.entity_type === "travel_request") {
|
||
await tx.travelRequest.update({
|
||
where: { id: workflowInstance.entity_id },
|
||
data: {
|
||
status: "approved",
|
||
updated_by: request.employee.id,
|
||
},
|
||
});
|
||
|
||
await confirmBudgetForEntity(tx, {
|
||
entityType: "travel_request",
|
||
entityId: workflowInstance.entity_id,
|
||
actorId: request.employee.id,
|
||
note: "approved_confirm_travel_budget",
|
||
});
|
||
}
|
||
|
||
await tx.workflowHistory.create({
|
||
data: {
|
||
instance_id: workflowInstance.id,
|
||
task_id: taskId,
|
||
actor_id: request.employee.id,
|
||
action: "approve",
|
||
payload: withDelegationPayload(
|
||
{
|
||
from_step_id: task.step_id,
|
||
terminal: true,
|
||
},
|
||
assignment,
|
||
request.employee.id,
|
||
),
|
||
},
|
||
});
|
||
|
||
try {
|
||
await queueWorkflowOutcomeNotifications({
|
||
tx,
|
||
actorId: request.employee.id,
|
||
emailTasks,
|
||
dispatchTasks,
|
||
workflowInstance,
|
||
outcome: "approved",
|
||
});
|
||
} catch (error) {
|
||
fastify.log.error(
|
||
{ err: error, taskId, entityType: workflowInstance.entity_type, entityId: workflowInstance.entity_id },
|
||
"Failed to create approval outcome notifications",
|
||
);
|
||
}
|
||
|
||
result = {
|
||
taskId,
|
||
outcome: "approved",
|
||
workflowInstanceId: workflowInstance.id,
|
||
nextTaskId: null,
|
||
reimbursementStatus: workflowInstance.entity_type === "reimbursement" ? "approved" : null,
|
||
attendanceCorrectionStatus: workflowInstance.entity_type === "attendance_correction" ? "approved" : null,
|
||
purchaseRequestStatus: workflowInstance.entity_type === "purchase_request" ? "approved" : null,
|
||
travelRequestStatus: workflowInstance.entity_type === "travel_request" ? "approved" : null,
|
||
};
|
||
});
|
||
|
||
return { result, emailTasks, dispatchTasks };
|
||
}
|
||
|
||
async function executeRejectWorkflowTask({
|
||
fastify,
|
||
request,
|
||
taskId,
|
||
comment,
|
||
allowedEntityType = null,
|
||
}) {
|
||
let result = null;
|
||
const emailTasks = [];
|
||
const dispatchTasks = [];
|
||
|
||
await fastify.prisma.$transaction(async (tx) => {
|
||
const task = await lockWorkflowTask(tx, taskId);
|
||
ensurePendingTask(task);
|
||
const assignment = await ensureTaskAssignableToCurrentEmployee(tx, task, request);
|
||
|
||
const workflowInstance = await loadWorkflowInstanceForTask(tx, task.instance_id);
|
||
ensureWorkflowEntityType(workflowInstance, allowedEntityType);
|
||
fastify.assertEntityPermission(request.employee, workflowInstance.entity_type, "approve");
|
||
await ensureWorkflowApprovalAllowed(tx, workflowInstance, request, assignment);
|
||
const now = new Date();
|
||
|
||
await tx.workflowTask.update({
|
||
where: { id: taskId },
|
||
data: {
|
||
status: "rejected",
|
||
outcome: "rejected",
|
||
comment,
|
||
completed_at: now,
|
||
completed_by: request.employee.id,
|
||
},
|
||
});
|
||
|
||
await cancelOtherPendingTasks(tx, workflowInstance.id, taskId, request.employee.id);
|
||
|
||
await tx.workflowInstance.update({
|
||
where: { id: workflowInstance.id },
|
||
data: {
|
||
current_status: "rejected",
|
||
completed_at: now,
|
||
updated_by: request.employee.id,
|
||
},
|
||
});
|
||
|
||
if (workflowInstance.entity_type === "reimbursement") {
|
||
await tx.reimbursementForm.update({
|
||
where: { id: workflowInstance.entity_id },
|
||
data: {
|
||
status: "rejected",
|
||
updated_by: request.employee.id,
|
||
},
|
||
});
|
||
} else if (workflowInstance.entity_type === "leave") {
|
||
const leaveRequest = await tx.leaveRequest.findUnique({
|
||
where: { id: workflowInstance.entity_id },
|
||
select: {
|
||
id: true,
|
||
owner_id: true,
|
||
leave_type_id: true,
|
||
},
|
||
});
|
||
const reserveAnchor = await tx.leaveLedger.findFirst({
|
||
where: {
|
||
leave_request_id: workflowInstance.entity_id,
|
||
entry_type: "reserve",
|
||
},
|
||
orderBy: { created_at: "desc" },
|
||
select: {
|
||
leave_policy_id: true,
|
||
period_start: true,
|
||
period_end: true,
|
||
},
|
||
});
|
||
|
||
await tx.leaveRequest.update({
|
||
where: { id: workflowInstance.entity_id },
|
||
data: {
|
||
status: "rejected",
|
||
updated_by: request.employee.id,
|
||
},
|
||
});
|
||
|
||
if (leaveRequest) {
|
||
await releaseReservedLeave(tx, {
|
||
leaveRequestId: workflowInstance.entity_id,
|
||
employeeId: leaveRequest.owner_id,
|
||
leaveTypeId: leaveRequest.leave_type_id,
|
||
leavePolicyId: reserveAnchor?.leave_policy_id ?? null,
|
||
periodStart: reserveAnchor?.period_start ?? null,
|
||
periodEnd: reserveAnchor?.period_end ?? null,
|
||
note: "rejected_release_leave",
|
||
payload: { source: "workflow_reject" },
|
||
createdBy: request.employee.id,
|
||
});
|
||
}
|
||
} else if (workflowInstance.entity_type === "attendance_correction") {
|
||
await tx.attendanceCorrection.update({
|
||
where: { id: workflowInstance.entity_id },
|
||
data: {
|
||
status: "rejected",
|
||
updated_by: request.employee.id,
|
||
},
|
||
});
|
||
} else if (workflowInstance.entity_type === "purchase_request") {
|
||
await tx.purchaseRequest.update({
|
||
where: { id: workflowInstance.entity_id },
|
||
data: {
|
||
status: "rejected",
|
||
updated_by: request.employee.id,
|
||
},
|
||
});
|
||
|
||
await releaseReservedBudgetIfAny(tx, {
|
||
entityType: "purchase_request",
|
||
entityId: workflowInstance.entity_id,
|
||
actorId: request.employee.id,
|
||
note: "rejected_release_purchase_budget",
|
||
});
|
||
} else if (workflowInstance.entity_type === "travel_request") {
|
||
await tx.travelRequest.update({
|
||
where: { id: workflowInstance.entity_id },
|
||
data: {
|
||
status: "rejected",
|
||
updated_by: request.employee.id,
|
||
},
|
||
});
|
||
|
||
await releaseReservedBudgetIfAny(tx, {
|
||
entityType: "travel_request",
|
||
entityId: workflowInstance.entity_id,
|
||
actorId: request.employee.id,
|
||
note: "rejected_release_travel_budget",
|
||
});
|
||
}
|
||
|
||
await tx.workflowHistory.create({
|
||
data: {
|
||
instance_id: workflowInstance.id,
|
||
task_id: taskId,
|
||
actor_id: request.employee.id,
|
||
action: "reject",
|
||
comment,
|
||
payload: withDelegationPayload(
|
||
{
|
||
from_step_id: task.step_id,
|
||
},
|
||
assignment,
|
||
request.employee.id,
|
||
),
|
||
},
|
||
});
|
||
|
||
try {
|
||
await queueWorkflowOutcomeNotifications({
|
||
tx,
|
||
actorId: request.employee.id,
|
||
emailTasks,
|
||
dispatchTasks,
|
||
workflowInstance,
|
||
outcome: "rejected",
|
||
comment,
|
||
});
|
||
} catch (error) {
|
||
fastify.log.error(
|
||
{ err: error, taskId, entityType: workflowInstance.entity_type, entityId: workflowInstance.entity_id },
|
||
"Failed to create rejection outcome notifications",
|
||
);
|
||
}
|
||
|
||
result = {
|
||
taskId,
|
||
outcome: "rejected",
|
||
workflowInstanceId: workflowInstance.id,
|
||
reimbursementStatus: workflowInstance.entity_type === "reimbursement" ? "rejected" : null,
|
||
attendanceCorrectionStatus: workflowInstance.entity_type === "attendance_correction" ? "rejected" : null,
|
||
purchaseRequestStatus: workflowInstance.entity_type === "purchase_request" ? "rejected" : null,
|
||
travelRequestStatus: workflowInstance.entity_type === "travel_request" ? "rejected" : null,
|
||
};
|
||
});
|
||
|
||
return { result, emailTasks, dispatchTasks };
|
||
}
|
||
|
||
function mapBatchTaskError(taskId, error) {
|
||
if (
|
||
error instanceof AppError &&
|
||
error.code === "VALID_001" &&
|
||
error.statusCode === 409 &&
|
||
error.details?.task === "already_processed"
|
||
) {
|
||
return {
|
||
taskId,
|
||
outcome: "skipped",
|
||
reason: "already_processed",
|
||
};
|
||
}
|
||
|
||
if (error instanceof AppError && error.details?.workflow === "self_approval_not_allowed") {
|
||
return {
|
||
taskId,
|
||
outcome: "error",
|
||
reason: "self_approval_not_allowed",
|
||
};
|
||
}
|
||
|
||
if (error instanceof AppError) {
|
||
return {
|
||
taskId,
|
||
outcome: "error",
|
||
reason: `${error.code}: ${error.message}`,
|
||
};
|
||
}
|
||
|
||
return {
|
||
taskId,
|
||
outcome: "error",
|
||
reason: error instanceof Error ? error.message : "unknown_error",
|
||
};
|
||
}
|
||
|
||
async function workflowRoutes(fastify) {
|
||
fastify.get(
|
||
"/workflow/tasks/summary",
|
||
{
|
||
schema: { tags: ["Workflow"], summary: "Workflow Task Summary" },
|
||
preHandler: fastify.authenticate,
|
||
},
|
||
async (request, reply) => {
|
||
const query = parseTaskSummaryQuery(request.query);
|
||
|
||
if (query.scope === "system" && !hasPermission(request.employee.permissionCodes ?? [], "system.audit.view")) {
|
||
throw new AppError({
|
||
code: "PERM_001",
|
||
message: "无权限",
|
||
statusCode: 403,
|
||
details: { permission: "system.audit.view" },
|
||
});
|
||
}
|
||
|
||
const visibilityFilters =
|
||
query.scope === "system" ? null : await buildTaskVisibilityFilters(fastify.prisma, request);
|
||
const where = {
|
||
status: "pending",
|
||
...(visibilityFilters ? { OR: visibilityFilters } : {}),
|
||
workflow_instance: { is: buildWorkflowEntityVisibilityWhere(request) },
|
||
};
|
||
|
||
const tasks = await fastify.prisma.workflowTask.findMany({
|
||
where,
|
||
orderBy: { created_at: "asc" },
|
||
select: {
|
||
id: true,
|
||
step_id: true,
|
||
step_name: true,
|
||
assignee_id: true,
|
||
assignee_role: true,
|
||
status: true,
|
||
created_at: true,
|
||
due_date: true,
|
||
workflow_instance: {
|
||
select: {
|
||
entity_type: true,
|
||
},
|
||
},
|
||
},
|
||
});
|
||
|
||
return sendData(reply, request, buildWorkflowTaskSummaryPayload(tasks, query.scope));
|
||
},
|
||
);
|
||
|
||
fastify.get(
|
||
"/workflow/tasks",
|
||
{
|
||
schema: { tags: ["Workflow"], summary: "List Workflow Tasks" },
|
||
preHandler: fastify.authenticate,
|
||
},
|
||
async (request, reply) => {
|
||
const query = parseTaskListQuery(request.query);
|
||
const skip = (query.page - 1) * query.pageSize;
|
||
|
||
const assigneeFilters = await buildTaskVisibilityFilters(fastify.prisma, request);
|
||
|
||
const where = {
|
||
status: query.status,
|
||
OR: assigneeFilters,
|
||
workflow_instance: { is: buildWorkflowEntityVisibilityWhere(request, query.entityType ?? null) },
|
||
};
|
||
|
||
const [tasks, total] = await Promise.all([
|
||
fastify.prisma.workflowTask.findMany({
|
||
where,
|
||
orderBy: { created_at: "desc" },
|
||
skip,
|
||
take: query.pageSize,
|
||
select: {
|
||
id: true,
|
||
instance_id: true,
|
||
step_id: true,
|
||
step_name: true,
|
||
assignee_id: true,
|
||
assignee_role: true,
|
||
status: true,
|
||
outcome: true,
|
||
created_at: true,
|
||
completed_at: true,
|
||
workflow_instance: {
|
||
select: {
|
||
entity_type: true,
|
||
entity_id: true,
|
||
current_status: true,
|
||
reimbursement_form: {
|
||
select: {
|
||
form_number: true,
|
||
status: true,
|
||
total_amount: true,
|
||
description: true,
|
||
owner: {
|
||
select: {
|
||
name: true,
|
||
},
|
||
},
|
||
submitter: {
|
||
select: {
|
||
name: true,
|
||
},
|
||
},
|
||
},
|
||
},
|
||
leave_request: {
|
||
select: {
|
||
status: true,
|
||
requested_days: true,
|
||
leave_type: {
|
||
select: {
|
||
name: true,
|
||
},
|
||
},
|
||
owner: {
|
||
select: {
|
||
name: true,
|
||
},
|
||
},
|
||
},
|
||
},
|
||
attendance_correction: {
|
||
select: {
|
||
status: true,
|
||
kind: true,
|
||
work_date: true,
|
||
start_at: true,
|
||
end_at: true,
|
||
reason: true,
|
||
owner: {
|
||
select: {
|
||
name: true,
|
||
},
|
||
},
|
||
},
|
||
},
|
||
purchase_request: {
|
||
select: {
|
||
request_no: true,
|
||
status: true,
|
||
title: true,
|
||
total_amount: true,
|
||
currency_code: true,
|
||
applicant: {
|
||
select: {
|
||
name: true,
|
||
},
|
||
},
|
||
},
|
||
},
|
||
travel_request: {
|
||
select: {
|
||
request_no: true,
|
||
status: true,
|
||
purpose: true,
|
||
estimated_amount: true,
|
||
applicant: {
|
||
select: {
|
||
name: true,
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
}),
|
||
fastify.prisma.workflowTask.count({ where }),
|
||
]);
|
||
|
||
const taskSummaries = await Promise.all(
|
||
tasks.map(async (task) => {
|
||
let actionable = false;
|
||
if (task.status === "pending") {
|
||
try {
|
||
await ensureTaskAssignableToCurrentEmployee(fastify.prisma, task, request);
|
||
actionable = true;
|
||
} catch (error) {
|
||
if (error instanceof AppError && error.code === "PERM_002") {
|
||
actionable = false;
|
||
} else {
|
||
throw error;
|
||
}
|
||
}
|
||
}
|
||
|
||
return mapTaskSummary(task, listAllowedActionsForTask(request, task, actionable));
|
||
}),
|
||
);
|
||
|
||
return sendData(reply, request, {
|
||
page: query.page,
|
||
pageSize: query.pageSize,
|
||
total,
|
||
items: taskSummaries,
|
||
});
|
||
},
|
||
);
|
||
|
||
fastify.get(
|
||
"/workflow/tasks/:taskId",
|
||
{
|
||
schema: { tags: ["Workflow"], summary: "Get Workflow Task Detail" },
|
||
preHandler: fastify.authenticate,
|
||
},
|
||
async (request, reply) => {
|
||
const taskId = parseTaskId(request.params?.taskId);
|
||
const assigneeFilters = await buildTaskVisibilityFilters(fastify.prisma, request);
|
||
|
||
const task = await fastify.prisma.workflowTask.findFirst({
|
||
where: {
|
||
id: taskId,
|
||
OR: assigneeFilters,
|
||
workflow_instance: { is: buildWorkflowEntityVisibilityWhere(request) },
|
||
},
|
||
select: {
|
||
id: true,
|
||
instance_id: true,
|
||
step_id: true,
|
||
step_name: true,
|
||
assignee_id: true,
|
||
assignee_role: true,
|
||
status: true,
|
||
outcome: true,
|
||
comment: true,
|
||
created_at: true,
|
||
completed_at: true,
|
||
workflow_instance: {
|
||
select: {
|
||
id: true,
|
||
entity_type: true,
|
||
entity_id: true,
|
||
current_status: true,
|
||
current_step_id: true,
|
||
context_data: true,
|
||
started_at: true,
|
||
completed_at: true,
|
||
reimbursement_form: {
|
||
select: {
|
||
id: true,
|
||
form_number: true,
|
||
status: true,
|
||
total_amount: true,
|
||
reimbursement_date: true,
|
||
description: true,
|
||
owner: {
|
||
select: {
|
||
id: true,
|
||
employee_no: true,
|
||
name: true,
|
||
},
|
||
},
|
||
submitter: {
|
||
select: {
|
||
id: true,
|
||
employee_no: true,
|
||
name: true,
|
||
},
|
||
},
|
||
},
|
||
},
|
||
leave_request: {
|
||
select: {
|
||
id: true,
|
||
status: true,
|
||
start_date: true,
|
||
end_date: true,
|
||
start_session: true,
|
||
end_session: true,
|
||
requested_days: true,
|
||
reason: true,
|
||
attachment_original_name: true,
|
||
attachment_mime_type: true,
|
||
leave_type: {
|
||
select: {
|
||
id: true,
|
||
code: true,
|
||
name: true,
|
||
},
|
||
},
|
||
owner: {
|
||
select: {
|
||
id: true,
|
||
employee_no: true,
|
||
name: true,
|
||
},
|
||
},
|
||
},
|
||
},
|
||
attendance_correction: {
|
||
select: {
|
||
id: true,
|
||
status: true,
|
||
kind: true,
|
||
work_date: true,
|
||
missed_punch_at: true,
|
||
start_at: true,
|
||
end_at: true,
|
||
reason: true,
|
||
location_summary: true,
|
||
compensation_policy: true,
|
||
owner: {
|
||
select: {
|
||
id: true,
|
||
employee_no: true,
|
||
name: true,
|
||
},
|
||
},
|
||
},
|
||
},
|
||
purchase_request: {
|
||
select: {
|
||
id: true,
|
||
request_no: true,
|
||
status: true,
|
||
title: true,
|
||
reason: true,
|
||
currency_code: true,
|
||
total_amount: true,
|
||
expected_delivery_date: true,
|
||
applicant: {
|
||
select: {
|
||
id: true,
|
||
employee_no: true,
|
||
name: true,
|
||
},
|
||
},
|
||
supplier: {
|
||
select: {
|
||
id: true,
|
||
code: true,
|
||
name: true,
|
||
},
|
||
},
|
||
legal_entity: {
|
||
select: {
|
||
id: true,
|
||
code: true,
|
||
name: true,
|
||
},
|
||
},
|
||
cost_center: {
|
||
select: {
|
||
id: true,
|
||
code: true,
|
||
name: true,
|
||
},
|
||
},
|
||
document_category: {
|
||
select: {
|
||
id: true,
|
||
code: true,
|
||
name: true,
|
||
},
|
||
},
|
||
},
|
||
},
|
||
travel_request: {
|
||
select: {
|
||
id: true,
|
||
request_no: true,
|
||
status: true,
|
||
purpose: true,
|
||
trip_type: true,
|
||
start_date: true,
|
||
end_date: true,
|
||
estimated_amount: true,
|
||
applicant: {
|
||
select: {
|
||
id: true,
|
||
employee_no: true,
|
||
name: true,
|
||
},
|
||
},
|
||
legal_entity: {
|
||
select: {
|
||
id: true,
|
||
code: true,
|
||
name: true,
|
||
},
|
||
},
|
||
cost_center: {
|
||
select: {
|
||
id: true,
|
||
code: true,
|
||
name: true,
|
||
},
|
||
},
|
||
segments: {
|
||
orderBy: [{ sort_order: "asc" }, { created_at: "asc" }],
|
||
select: {
|
||
id: true,
|
||
sort_order: true,
|
||
segment_role: true,
|
||
transport_type: true,
|
||
from_city: true,
|
||
to_city: true,
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
});
|
||
|
||
if (!task) {
|
||
const existing = await fastify.prisma.workflowTask.findUnique({
|
||
where: { id: taskId },
|
||
select: { id: true },
|
||
});
|
||
|
||
if (existing) {
|
||
throw new AppError({
|
||
code: "PERM_002",
|
||
message: "不在审批范围/非当前处理人",
|
||
statusCode: 403,
|
||
});
|
||
}
|
||
|
||
throw new AppError({
|
||
code: "SYS_404",
|
||
message: "Not Found",
|
||
statusCode: 404,
|
||
});
|
||
}
|
||
|
||
let actionable = false;
|
||
if (task.status === "pending") {
|
||
try {
|
||
await ensureTaskAssignableToCurrentEmployee(fastify.prisma, task, request);
|
||
actionable = true;
|
||
} catch (error) {
|
||
if (error instanceof AppError && error.code === "PERM_002") {
|
||
actionable = false;
|
||
} else {
|
||
throw error;
|
||
}
|
||
}
|
||
}
|
||
|
||
const historyItems = await fastify.prisma.workflowHistory.findMany({
|
||
where: { instance_id: task.instance_id },
|
||
orderBy: { created_at: "asc" },
|
||
select: {
|
||
id: true,
|
||
task_id: true,
|
||
actor_id: true,
|
||
action: true,
|
||
comment: true,
|
||
payload: true,
|
||
created_at: true,
|
||
actor: {
|
||
select: {
|
||
id: true,
|
||
name: true,
|
||
employee_no: true,
|
||
},
|
||
},
|
||
},
|
||
});
|
||
const reimbursementSubmissionSnapshot = task.workflow_instance?.entity_type === "reimbursement"
|
||
? projectReimbursementSubmissionSnapshot(task.workflow_instance.context_data)
|
||
: null;
|
||
|
||
return sendData(reply, request, {
|
||
task: {
|
||
id: task.id,
|
||
instanceId: task.instance_id,
|
||
stepId: task.step_id,
|
||
stepName: resolveWorkflowStepDisplayName(task),
|
||
assigneeId: task.assignee_id,
|
||
assigneeRole: task.assignee_role,
|
||
status: task.status,
|
||
outcome: task.outcome,
|
||
comment: task.comment,
|
||
createdAt: isoOrNull(task.created_at),
|
||
completedAt: isoOrNull(task.completed_at),
|
||
},
|
||
workflowInstance: task.workflow_instance
|
||
? {
|
||
id: task.workflow_instance.id,
|
||
entityType: task.workflow_instance.entity_type,
|
||
currentStatus: task.workflow_instance.current_status,
|
||
currentStepId: task.workflow_instance.current_step_id,
|
||
contextData: {
|
||
standardViolations: reimbursementSubmissionSnapshot?.standardViolations ?? [],
|
||
budgetCheck: reimbursementSubmissionSnapshot?.budgetCheck ?? null,
|
||
budgetCheckStatus: reimbursementSubmissionSnapshot?.budgetCheckStatus ?? "missing",
|
||
parseStatus: reimbursementSubmissionSnapshot?.parseStatus ?? "ready",
|
||
},
|
||
startedAt: isoOrNull(task.workflow_instance.started_at),
|
||
completedAt: isoOrNull(task.workflow_instance.completed_at),
|
||
}
|
||
: null,
|
||
reimbursement: task.workflow_instance?.reimbursement_form
|
||
? {
|
||
id: task.workflow_instance.reimbursement_form.id,
|
||
formNumber: task.workflow_instance.reimbursement_form.form_number,
|
||
status: task.workflow_instance.reimbursement_form.status,
|
||
reimbursementDate:
|
||
task.workflow_instance.reimbursement_form.reimbursement_date
|
||
?.toISOString?.()
|
||
?.slice(0, 10) ?? null,
|
||
totalAmount: toMoneyString(task.workflow_instance.reimbursement_form.total_amount),
|
||
description: task.workflow_instance.reimbursement_form.description,
|
||
owner: task.workflow_instance.reimbursement_form.owner
|
||
? {
|
||
id: task.workflow_instance.reimbursement_form.owner.id,
|
||
employeeNo: task.workflow_instance.reimbursement_form.owner.employee_no,
|
||
name: task.workflow_instance.reimbursement_form.owner.name,
|
||
}
|
||
: null,
|
||
submitter: task.workflow_instance.reimbursement_form.submitter
|
||
? {
|
||
id: task.workflow_instance.reimbursement_form.submitter.id,
|
||
employeeNo: task.workflow_instance.reimbursement_form.submitter.employee_no,
|
||
name: task.workflow_instance.reimbursement_form.submitter.name,
|
||
}
|
||
: null,
|
||
}
|
||
: null,
|
||
leaveRequest: task.workflow_instance?.leave_request
|
||
? {
|
||
id: task.workflow_instance.leave_request.id,
|
||
status: task.workflow_instance.leave_request.status,
|
||
startDate: formatDateOnly(task.workflow_instance.leave_request.start_date),
|
||
endDate: formatDateOnly(task.workflow_instance.leave_request.end_date),
|
||
startSession: task.workflow_instance.leave_request.start_session,
|
||
endSession: task.workflow_instance.leave_request.end_session,
|
||
requestedDays: Number(task.workflow_instance.leave_request.requested_days),
|
||
reason: task.workflow_instance.leave_request.reason ?? null,
|
||
attachment:
|
||
task.workflow_instance.leave_request.attachment_original_name ||
|
||
task.workflow_instance.leave_request.attachment_mime_type
|
||
? {
|
||
originalName: task.workflow_instance.leave_request.attachment_original_name ?? null,
|
||
mimeType: task.workflow_instance.leave_request.attachment_mime_type ?? null,
|
||
}
|
||
: null,
|
||
leaveType: task.workflow_instance.leave_request.leave_type
|
||
? {
|
||
id: task.workflow_instance.leave_request.leave_type.id,
|
||
code: task.workflow_instance.leave_request.leave_type.code,
|
||
name: task.workflow_instance.leave_request.leave_type.name,
|
||
}
|
||
: null,
|
||
owner: task.workflow_instance.leave_request.owner
|
||
? {
|
||
id: task.workflow_instance.leave_request.owner.id,
|
||
employeeNo: task.workflow_instance.leave_request.owner.employee_no,
|
||
name: task.workflow_instance.leave_request.owner.name,
|
||
}
|
||
: null,
|
||
}
|
||
: null,
|
||
attendanceCorrection: task.workflow_instance?.attendance_correction
|
||
? {
|
||
id: task.workflow_instance.attendance_correction.id,
|
||
status: task.workflow_instance.attendance_correction.status,
|
||
kind: task.workflow_instance.attendance_correction.kind,
|
||
workDate: formatDateOnly(task.workflow_instance.attendance_correction.work_date),
|
||
missedPunchAt:
|
||
task.workflow_instance.attendance_correction.missed_punch_at?.toISOString?.() ?? null,
|
||
startAt: task.workflow_instance.attendance_correction.start_at?.toISOString?.() ?? null,
|
||
endAt: task.workflow_instance.attendance_correction.end_at?.toISOString?.() ?? null,
|
||
reason: task.workflow_instance.attendance_correction.reason ?? null,
|
||
locationSummary: task.workflow_instance.attendance_correction.location_summary ?? null,
|
||
compensationPolicy:
|
||
task.workflow_instance.attendance_correction.compensation_policy ?? null,
|
||
owner: task.workflow_instance.attendance_correction.owner
|
||
? {
|
||
id: task.workflow_instance.attendance_correction.owner.id,
|
||
employeeNo: task.workflow_instance.attendance_correction.owner.employee_no,
|
||
name: task.workflow_instance.attendance_correction.owner.name,
|
||
}
|
||
: null,
|
||
}
|
||
: null,
|
||
purchaseRequest: task.workflow_instance?.purchase_request
|
||
? {
|
||
id: task.workflow_instance.purchase_request.id,
|
||
requestNo: task.workflow_instance.purchase_request.request_no ?? null,
|
||
status: task.workflow_instance.purchase_request.status,
|
||
title: task.workflow_instance.purchase_request.title,
|
||
reason: task.workflow_instance.purchase_request.reason ?? null,
|
||
currencyCode: task.workflow_instance.purchase_request.currency_code,
|
||
totalAmount: toMoneyString(task.workflow_instance.purchase_request.total_amount),
|
||
expectedDeliveryDate: formatDateOnly(task.workflow_instance.purchase_request.expected_delivery_date),
|
||
applicant: task.workflow_instance.purchase_request.applicant
|
||
? {
|
||
id: task.workflow_instance.purchase_request.applicant.id,
|
||
employeeNo: task.workflow_instance.purchase_request.applicant.employee_no,
|
||
name: task.workflow_instance.purchase_request.applicant.name,
|
||
}
|
||
: null,
|
||
supplier: task.workflow_instance.purchase_request.supplier
|
||
? {
|
||
id: task.workflow_instance.purchase_request.supplier.id,
|
||
code: task.workflow_instance.purchase_request.supplier.code,
|
||
name: task.workflow_instance.purchase_request.supplier.name,
|
||
}
|
||
: null,
|
||
legalEntity: task.workflow_instance.purchase_request.legal_entity
|
||
? {
|
||
id: task.workflow_instance.purchase_request.legal_entity.id,
|
||
code: task.workflow_instance.purchase_request.legal_entity.code,
|
||
name: task.workflow_instance.purchase_request.legal_entity.name,
|
||
}
|
||
: null,
|
||
costCenter: task.workflow_instance.purchase_request.cost_center
|
||
? {
|
||
id: task.workflow_instance.purchase_request.cost_center.id,
|
||
code: task.workflow_instance.purchase_request.cost_center.code,
|
||
name: task.workflow_instance.purchase_request.cost_center.name,
|
||
}
|
||
: null,
|
||
documentCategory: task.workflow_instance.purchase_request.document_category
|
||
? {
|
||
id: task.workflow_instance.purchase_request.document_category.id,
|
||
code: task.workflow_instance.purchase_request.document_category.code,
|
||
name: task.workflow_instance.purchase_request.document_category.name,
|
||
}
|
||
: null,
|
||
}
|
||
: null,
|
||
travelRequest: task.workflow_instance?.travel_request
|
||
? {
|
||
id: task.workflow_instance.travel_request.id,
|
||
requestNo: task.workflow_instance.travel_request.request_no ?? null,
|
||
status: task.workflow_instance.travel_request.status,
|
||
purpose: task.workflow_instance.travel_request.purpose,
|
||
tripType: task.workflow_instance.travel_request.trip_type,
|
||
startDate: formatDateOnly(task.workflow_instance.travel_request.start_date),
|
||
endDate: formatDateOnly(task.workflow_instance.travel_request.end_date),
|
||
estimatedAmount: toMoneyString(task.workflow_instance.travel_request.estimated_amount),
|
||
applicant: task.workflow_instance.travel_request.applicant
|
||
? {
|
||
id: task.workflow_instance.travel_request.applicant.id,
|
||
employeeNo: task.workflow_instance.travel_request.applicant.employee_no,
|
||
name: task.workflow_instance.travel_request.applicant.name,
|
||
}
|
||
: null,
|
||
legalEntity: task.workflow_instance.travel_request.legal_entity
|
||
? {
|
||
id: task.workflow_instance.travel_request.legal_entity.id,
|
||
code: task.workflow_instance.travel_request.legal_entity.code,
|
||
name: task.workflow_instance.travel_request.legal_entity.name,
|
||
}
|
||
: null,
|
||
costCenter: task.workflow_instance.travel_request.cost_center
|
||
? {
|
||
id: task.workflow_instance.travel_request.cost_center.id,
|
||
code: task.workflow_instance.travel_request.cost_center.code,
|
||
name: task.workflow_instance.travel_request.cost_center.name,
|
||
}
|
||
: null,
|
||
segments: task.workflow_instance.travel_request.segments.map((item) => ({
|
||
id: item.id,
|
||
sortOrder: item.sort_order,
|
||
segmentRole: item.segment_role,
|
||
transportType: item.transport_type,
|
||
fromCity: item.from_city,
|
||
toCity: item.to_city,
|
||
})),
|
||
}
|
||
: null,
|
||
allowedActions: listAllowedActionsForTask(request, task, actionable),
|
||
history: historyItems.map((item) => ({
|
||
id: item.id,
|
||
taskId: item.task_id,
|
||
actorId: item.actor_id,
|
||
actorName: item.actor?.name ?? "",
|
||
actorEmployeeNo: item.actor?.employee_no ?? "",
|
||
action: item.action,
|
||
comment: item.comment,
|
||
payload: item.payload,
|
||
createdAt: isoOrNull(item.created_at),
|
||
})),
|
||
});
|
||
},
|
||
);
|
||
|
||
fastify.get(
|
||
"/workflow/approvers",
|
||
{
|
||
preHandler: fastify.requirePermission("expense.transfer"),
|
||
},
|
||
async (request, reply) => {
|
||
const query = parseApproverListQuery(request.query);
|
||
const skip = (query.page - 1) * query.pageSize;
|
||
|
||
const where = {
|
||
status: "active",
|
||
id: { not: request.employee.id },
|
||
roles: {
|
||
some: {
|
||
role_code: { in: APPROVER_ROLE_CODES },
|
||
},
|
||
},
|
||
...(query.keyword
|
||
? {
|
||
OR: [
|
||
{ name: { contains: query.keyword, mode: "insensitive" } },
|
||
{ email: { contains: query.keyword, mode: "insensitive" } },
|
||
{ employee_no: { contains: query.keyword, mode: "insensitive" } },
|
||
],
|
||
}
|
||
: {}),
|
||
};
|
||
|
||
const [items, total] = await Promise.all([
|
||
fastify.prisma.employee.findMany({
|
||
where,
|
||
orderBy: { name: "asc" },
|
||
skip,
|
||
take: query.pageSize,
|
||
select: {
|
||
id: true,
|
||
employee_no: true,
|
||
name: true,
|
||
email: true,
|
||
roles: {
|
||
select: {
|
||
role_code: true,
|
||
},
|
||
},
|
||
},
|
||
}),
|
||
fastify.prisma.employee.count({ where }),
|
||
]);
|
||
|
||
return sendData(reply, request, {
|
||
page: query.page,
|
||
pageSize: query.pageSize,
|
||
total,
|
||
items: items.map((item) => ({
|
||
id: item.id,
|
||
employeeNo: item.employee_no,
|
||
name: item.name,
|
||
email: item.email,
|
||
roleCodes: item.roles.map((role) => role.role_code),
|
||
})),
|
||
});
|
||
},
|
||
);
|
||
|
||
fastify.post(
|
||
"/workflow/tasks/:taskId/remind",
|
||
{
|
||
preHandler: fastify.authenticate,
|
||
},
|
||
async (request, reply) => {
|
||
const taskId = parseTaskId(request.params?.taskId);
|
||
const body = parseRemindTaskBody(request.body);
|
||
const result = await executeRemindWorkflowTask({
|
||
fastify,
|
||
request,
|
||
taskId,
|
||
comment: body.comment,
|
||
});
|
||
return sendData(reply, request, result);
|
||
},
|
||
);
|
||
|
||
fastify.post(
|
||
"/workflow/tasks/:taskId/approve",
|
||
{
|
||
preHandler: fastify.authenticate,
|
||
},
|
||
async (request, reply) => {
|
||
const taskId = parseTaskId(request.params?.taskId);
|
||
const { result, emailTasks, dispatchTasks } = await executeApproveWorkflowTask({
|
||
fastify,
|
||
request,
|
||
taskId,
|
||
});
|
||
|
||
await flushWorkflowSideEffects({ fastify, request, emailTasks, dispatchTasks });
|
||
return sendData(reply, request, result);
|
||
},
|
||
);
|
||
|
||
fastify.post(
|
||
"/workflow/tasks/:taskId/reject",
|
||
{
|
||
preHandler: fastify.authenticate,
|
||
},
|
||
async (request, reply) => {
|
||
const taskId = parseTaskId(request.params?.taskId);
|
||
const comment = parseRequiredComment(request.body);
|
||
const { result, emailTasks, dispatchTasks } = await executeRejectWorkflowTask({
|
||
fastify,
|
||
request,
|
||
taskId,
|
||
comment,
|
||
});
|
||
|
||
await flushWorkflowSideEffects({ fastify, request, emailTasks, dispatchTasks });
|
||
return sendData(reply, request, result);
|
||
},
|
||
);
|
||
|
||
fastify.post(
|
||
"/workflow/batch-approve",
|
||
{
|
||
preHandler: fastify.requirePermission("expense.approve"),
|
||
},
|
||
async (request, reply) => {
|
||
const body = parseBatchApproveBody(request.body);
|
||
const results = [];
|
||
const summary = {
|
||
approved: 0,
|
||
rejected: 0,
|
||
skipped: 0,
|
||
errored: 0,
|
||
};
|
||
|
||
for (const taskId of body.taskIds) {
|
||
try {
|
||
const { result, emailTasks, dispatchTasks } = await executeApproveWorkflowTask({
|
||
fastify,
|
||
request,
|
||
taskId,
|
||
allowedEntityType: "reimbursement",
|
||
});
|
||
try {
|
||
await flushWorkflowSideEffects({ fastify, request, emailTasks, dispatchTasks });
|
||
} catch (error) {
|
||
fastify.log.error({ err: error, taskId }, "Failed to flush batch approve side effects");
|
||
}
|
||
|
||
results.push({
|
||
taskId,
|
||
outcome: result.outcome,
|
||
});
|
||
summary.approved += 1;
|
||
} catch (error) {
|
||
const mapped = mapBatchTaskError(taskId, error);
|
||
results.push(mapped);
|
||
if (mapped.outcome === "skipped") {
|
||
summary.skipped += 1;
|
||
} else {
|
||
summary.errored += 1;
|
||
}
|
||
}
|
||
}
|
||
|
||
return sendData(reply, request, {
|
||
results,
|
||
summary,
|
||
});
|
||
},
|
||
);
|
||
|
||
fastify.post(
|
||
"/workflow/batch-reject",
|
||
{
|
||
preHandler: fastify.requirePermission("expense.approve"),
|
||
},
|
||
async (request, reply) => {
|
||
const body = parseBatchRejectBody(request.body);
|
||
const results = [];
|
||
const summary = {
|
||
approved: 0,
|
||
rejected: 0,
|
||
skipped: 0,
|
||
errored: 0,
|
||
};
|
||
|
||
for (const taskId of body.taskIds) {
|
||
try {
|
||
const { result, emailTasks, dispatchTasks } = await executeRejectWorkflowTask({
|
||
fastify,
|
||
request,
|
||
taskId,
|
||
comment: body.comment,
|
||
allowedEntityType: "reimbursement",
|
||
});
|
||
try {
|
||
await flushWorkflowSideEffects({ fastify, request, emailTasks, dispatchTasks });
|
||
} catch (error) {
|
||
fastify.log.error({ err: error, taskId }, "Failed to flush batch reject side effects");
|
||
}
|
||
|
||
results.push({
|
||
taskId,
|
||
outcome: result.outcome,
|
||
});
|
||
summary.rejected += 1;
|
||
} catch (error) {
|
||
const mapped = mapBatchTaskError(taskId, error);
|
||
results.push(mapped);
|
||
if (mapped.outcome === "skipped") {
|
||
summary.skipped += 1;
|
||
} else {
|
||
summary.errored += 1;
|
||
}
|
||
}
|
||
}
|
||
|
||
return sendData(reply, request, {
|
||
results,
|
||
summary,
|
||
});
|
||
},
|
||
);
|
||
|
||
fastify.post(
|
||
"/workflow/tasks/:taskId/return",
|
||
{
|
||
preHandler: fastify.authenticate,
|
||
},
|
||
async (request, reply) => {
|
||
const taskId = parseTaskId(request.params?.taskId);
|
||
const comment = parseRequiredComment(request.body);
|
||
let result = null;
|
||
const emailTasks = [];
|
||
const dispatchTasks = [];
|
||
|
||
await fastify.prisma.$transaction(async (tx) => {
|
||
const task = await lockWorkflowTask(tx, taskId);
|
||
ensurePendingTask(task);
|
||
const assignment = await ensureTaskAssignableToCurrentEmployee(tx, task, request);
|
||
|
||
const workflowInstance = await loadWorkflowInstanceForTask(tx, task.instance_id);
|
||
fastify.assertEntityPermission(request.employee, workflowInstance.entity_type, "approve");
|
||
await ensureWorkflowApprovalAllowed(tx, workflowInstance, request, assignment);
|
||
const now = new Date();
|
||
|
||
await tx.workflowTask.update({
|
||
where: { id: taskId },
|
||
data: {
|
||
status: "completed",
|
||
outcome: "returned",
|
||
comment,
|
||
completed_at: now,
|
||
completed_by: request.employee.id,
|
||
},
|
||
});
|
||
|
||
await cancelOtherPendingTasks(tx, workflowInstance.id, taskId, request.employee.id);
|
||
|
||
await tx.workflowInstance.update({
|
||
where: { id: workflowInstance.id },
|
||
data: {
|
||
current_status: "terminated",
|
||
completed_at: now,
|
||
updated_by: request.employee.id,
|
||
},
|
||
});
|
||
|
||
if (workflowInstance.entity_type === "reimbursement") {
|
||
await tx.reimbursementForm.update({
|
||
where: { id: workflowInstance.entity_id },
|
||
data: {
|
||
status: "draft",
|
||
updated_by: request.employee.id,
|
||
},
|
||
});
|
||
} else if (workflowInstance.entity_type === "leave") {
|
||
const leaveRequest = await tx.leaveRequest.findUnique({
|
||
where: { id: workflowInstance.entity_id },
|
||
select: {
|
||
id: true,
|
||
owner_id: true,
|
||
leave_type_id: true,
|
||
},
|
||
});
|
||
const reserveAnchor = await tx.leaveLedger.findFirst({
|
||
where: {
|
||
leave_request_id: workflowInstance.entity_id,
|
||
entry_type: "reserve",
|
||
},
|
||
orderBy: { created_at: "desc" },
|
||
select: {
|
||
leave_policy_id: true,
|
||
period_start: true,
|
||
period_end: true,
|
||
},
|
||
});
|
||
|
||
await tx.leaveRequest.update({
|
||
where: { id: workflowInstance.entity_id },
|
||
data: {
|
||
status: "draft",
|
||
updated_by: request.employee.id,
|
||
},
|
||
});
|
||
|
||
if (leaveRequest) {
|
||
await releaseReservedLeave(tx, {
|
||
leaveRequestId: workflowInstance.entity_id,
|
||
employeeId: leaveRequest.owner_id,
|
||
leaveTypeId: leaveRequest.leave_type_id,
|
||
leavePolicyId: reserveAnchor?.leave_policy_id ?? null,
|
||
periodStart: reserveAnchor?.period_start ?? null,
|
||
periodEnd: reserveAnchor?.period_end ?? null,
|
||
note: "returned_release_leave",
|
||
payload: { source: "workflow_return" },
|
||
createdBy: request.employee.id,
|
||
});
|
||
}
|
||
} else if (workflowInstance.entity_type === "purchase_request") {
|
||
await tx.purchaseRequest.update({
|
||
where: { id: workflowInstance.entity_id },
|
||
data: {
|
||
status: "draft",
|
||
updated_by: request.employee.id,
|
||
},
|
||
});
|
||
|
||
await releaseReservedBudgetIfAny(tx, {
|
||
entityType: "purchase_request",
|
||
entityId: workflowInstance.entity_id,
|
||
actorId: request.employee.id,
|
||
note: "returned_release_purchase_budget",
|
||
});
|
||
} else if (workflowInstance.entity_type === "travel_request") {
|
||
await tx.travelRequest.update({
|
||
where: { id: workflowInstance.entity_id },
|
||
data: {
|
||
status: "draft",
|
||
updated_by: request.employee.id,
|
||
},
|
||
});
|
||
|
||
await releaseReservedBudgetIfAny(tx, {
|
||
entityType: "travel_request",
|
||
entityId: workflowInstance.entity_id,
|
||
actorId: request.employee.id,
|
||
note: "returned_release_travel_budget",
|
||
});
|
||
}
|
||
|
||
await tx.workflowHistory.create({
|
||
data: {
|
||
instance_id: workflowInstance.id,
|
||
task_id: taskId,
|
||
actor_id: request.employee.id,
|
||
action: "return",
|
||
comment,
|
||
payload: withDelegationPayload(
|
||
{
|
||
from_step_id: task.step_id,
|
||
},
|
||
assignment,
|
||
request.employee.id,
|
||
),
|
||
},
|
||
});
|
||
|
||
try {
|
||
await queueWorkflowOutcomeNotifications({
|
||
tx,
|
||
actorId: request.employee.id,
|
||
emailTasks,
|
||
dispatchTasks,
|
||
workflowInstance,
|
||
outcome: 'returned',
|
||
comment,
|
||
});
|
||
} catch (error) {
|
||
fastify.log.error(
|
||
{ err: error, taskId, entityType: workflowInstance.entity_type, entityId: workflowInstance.entity_id },
|
||
"Failed to create return outcome notifications",
|
||
);
|
||
}
|
||
|
||
result = {
|
||
taskId,
|
||
outcome: "returned",
|
||
workflowInstanceId: workflowInstance.id,
|
||
reimbursementStatus: workflowInstance.entity_type === "reimbursement" ? "draft" : null,
|
||
purchaseRequestStatus: workflowInstance.entity_type === "purchase_request" ? "draft" : null,
|
||
travelRequestStatus: workflowInstance.entity_type === "travel_request" ? "draft" : null,
|
||
};
|
||
});
|
||
|
||
for (const task of emailTasks) {
|
||
void sendNotificationEmailSafe({
|
||
prisma: fastify.prisma,
|
||
config: fastify.config,
|
||
logger: fastify.log,
|
||
requestId: request.id,
|
||
...task,
|
||
});
|
||
}
|
||
await flushNotificationDispatchTasks({
|
||
prisma: fastify.prisma,
|
||
config: fastify.config,
|
||
logger: fastify.log,
|
||
requestId: request.id,
|
||
tasks: dispatchTasks,
|
||
});
|
||
|
||
return sendData(reply, request, result);
|
||
},
|
||
);
|
||
|
||
fastify.post(
|
||
"/workflow/tasks/:taskId/transfer",
|
||
{
|
||
preHandler: fastify.requirePermission("expense.transfer"),
|
||
},
|
||
async (request, reply) => {
|
||
const taskId = parseTaskId(request.params?.taskId);
|
||
const { toApproverId, reason } = parseTransferBody(request.body);
|
||
let result = null;
|
||
const emailTasks = [];
|
||
const dispatchTasks = [];
|
||
|
||
await fastify.prisma.$transaction(async (tx) => {
|
||
const task = await lockWorkflowTask(tx, taskId);
|
||
ensurePendingTask(task);
|
||
const assignment = await ensureTaskAssignableToCurrentEmployee(tx, task, request);
|
||
|
||
const workflowInstance = await loadWorkflowInstanceForTask(tx, task.instance_id);
|
||
const approvePermission = resolveEntityPermission(
|
||
workflowInstance.entity_type,
|
||
"approve",
|
||
);
|
||
if (!approvePermission) {
|
||
throw new AppError({
|
||
code: "VALID_001",
|
||
message: "参数校验失败",
|
||
statusCode: 409,
|
||
details: { transfer: "unsupported_entity_type" },
|
||
});
|
||
}
|
||
const applicantIds = await ensureWorkflowApprovalAllowed(tx, workflowInstance, request, assignment);
|
||
const transferCount = await ensureTransferChainNotExceeded(tx, taskId);
|
||
await ensureTransferTargetEligible(tx, toApproverId, approvePermission);
|
||
ensureNoSelfApproval([toApproverId], applicantIds);
|
||
await ensureFinanceOwnerCeoActors(tx, workflowInstance, [toApproverId]);
|
||
|
||
if (toApproverId === request.employee.id) {
|
||
throw new AppError({
|
||
code: "VALID_001",
|
||
message: "参数校验失败",
|
||
statusCode: 409,
|
||
details: { transfer: "same_assignee_not_allowed" },
|
||
});
|
||
}
|
||
|
||
await tx.workflowTask.update({
|
||
where: { id: taskId },
|
||
data: {
|
||
assignee_id: toApproverId,
|
||
assignee_role: null,
|
||
},
|
||
});
|
||
|
||
let transferId = null;
|
||
if (workflowInstance.entity_type === "reimbursement") {
|
||
const transfer = await tx.approvalTransfer.create({
|
||
data: {
|
||
reimbursement_id: workflowInstance.entity_id,
|
||
from_approver_id: request.employee.id,
|
||
to_approver_id: toApproverId,
|
||
reason,
|
||
status: "active",
|
||
created_by: request.employee.id,
|
||
},
|
||
select: {
|
||
id: true,
|
||
},
|
||
});
|
||
transferId = transfer.id;
|
||
}
|
||
|
||
await tx.workflowHistory.create({
|
||
data: {
|
||
instance_id: workflowInstance.id,
|
||
task_id: taskId,
|
||
actor_id: request.employee.id,
|
||
action: "transfer",
|
||
comment: reason,
|
||
payload: withDelegationPayload(
|
||
{
|
||
from_approver_id: request.employee.id,
|
||
to_approver_id: toApproverId,
|
||
reason,
|
||
transfer_count: transferCount + 1,
|
||
},
|
||
assignment,
|
||
request.employee.id,
|
||
),
|
||
},
|
||
});
|
||
|
||
try {
|
||
const notificationContext = await loadWorkflowNotifyContext(
|
||
tx,
|
||
workflowInstance.entity_type,
|
||
workflowInstance.entity_id,
|
||
);
|
||
const entityMeta = buildWorkflowEntityMeta(
|
||
workflowInstance.entity_type,
|
||
notificationContext.record,
|
||
workflowInstance.entity_id,
|
||
);
|
||
const pendingCopy = buildPendingTaskCopy(entityMeta, { transfer: true });
|
||
await queueTaskAssignedNotifications({
|
||
tx,
|
||
actorId: request.employee.id,
|
||
emailTasks,
|
||
dispatchTasks,
|
||
recipientEmployeeIds: [toApproverId],
|
||
title: pendingCopy.title,
|
||
body: pendingCopy.body,
|
||
taskId,
|
||
entityType: workflowInstance.entity_type,
|
||
entityId: workflowInstance.entity_id,
|
||
});
|
||
} catch (error) {
|
||
fastify.log.error(
|
||
{ err: error, taskId, toApproverId },
|
||
"Failed to create task transferred notifications",
|
||
);
|
||
}
|
||
|
||
result = {
|
||
taskId,
|
||
outcome: "transferred",
|
||
workflowInstanceId: workflowInstance.id,
|
||
reimbursementStatus: workflowInstance.entity_type === "reimbursement" ? "reviewing" : null,
|
||
transferId,
|
||
fromApproverId: request.employee.id,
|
||
toApproverId,
|
||
transferCount: transferCount + 1,
|
||
};
|
||
});
|
||
|
||
for (const task of emailTasks) {
|
||
void sendNotificationEmailSafe({
|
||
prisma: fastify.prisma,
|
||
config: fastify.config,
|
||
logger: fastify.log,
|
||
requestId: request.id,
|
||
...task,
|
||
});
|
||
}
|
||
await flushNotificationDispatchTasks({
|
||
prisma: fastify.prisma,
|
||
config: fastify.config,
|
||
logger: fastify.log,
|
||
requestId: request.id,
|
||
tasks: dispatchTasks,
|
||
});
|
||
|
||
return sendData(reply, request, result);
|
||
},
|
||
);
|
||
}
|
||
|
||
module.exports = workflowRoutes;
|
||
|
||
module.exports.__testables = {
|
||
buildApprovedCopy,
|
||
buildOverdueTaskCopy,
|
||
buildPendingTaskCopy,
|
||
buildRejectedCopy,
|
||
buildRemindedTaskCopy,
|
||
buildReturnedCopy,
|
||
buildWorkflowTaskSummaryPayload,
|
||
buildWorkflowEntityMeta,
|
||
buildWorkflowEntityVisibilityWhere,
|
||
calculateWorkflowTaskDueAt,
|
||
canViewWorkflowEntityType,
|
||
employeeHasBusinessApproveRole,
|
||
handlePurchaseApprovalErpSync,
|
||
isWorkflowTaskOverdue,
|
||
listAllowedActionsForTask,
|
||
parseTaskListQuery,
|
||
queueWorkflowOutcomeNotifications,
|
||
resolveWorkflowOutcomeNotificationType,
|
||
};
|