106 lines
9.7 KiB
TypeScript
106 lines
9.7 KiB
TypeScript
import { prisma } from './prisma'
|
|
import { requireSalaryAccess } from './personnel-salary'
|
|
import { resolveSalaryMonth, previousSalaryMonth, getPositionSalaryTemplate } from './performance-salary-templates'
|
|
import { resolveSalarySourceMonth, roundSalaryScore } from './performance-salary-calculation'
|
|
import { collectSalarySurveyScores, createSalarySurveyPersonMatcher, surveyMatchMessages } from './salary-survey-scores'
|
|
import { readSalaryWorkflowMetrics } from './performance-salary-workflows'
|
|
import { readSalaryMarketIntent } from './salary-market-intent'
|
|
import { calculatePositionScore, resolvePersonnelPerformance, personnelPositions, performancePositions } from './salary-position-contract'
|
|
import { serializePosition } from './salary-positions'
|
|
import { calculateSalaryPay } from './performance-salary-pay'
|
|
import { buildSalaryDepartmentScopes, summarizeDepartmentDelivery, summarizeDepartmentMarketIntent } from './salary-department-metrics'
|
|
import { SALARY_DEPARTMENT_UNRESOLVED } from './salary-department-contract'
|
|
import type { SalaryDetails, SalaryDetailRow, SalaryCell } from './performance-salary-details-contract'
|
|
|
|
export async function getPerformanceSalaryDetails(userId: string, month: unknown): Promise<SalaryDetails> {
|
|
await requireSalaryAccess(userId)
|
|
const displayMonth = resolveSalaryMonth(month)
|
|
// One snapshot owns personnel, configuration revisions and submitted scores.
|
|
const { state, responses, people, bases, positions, units } = await prisma.$transaction(async db => {
|
|
const count = await db.performanceSurveyResponse.count({ where: { survey: { assessmentMonth: displayMonth, status: { notIn: ['draft', 'cancelled'] } }, assignment: { status: 'submitted' } } })
|
|
const state = resolveSalarySourceMonth(displayMonth, count, process.env.NODE_ENV, process.env.PERFORMANCE_SALARY_LOCAL_TEST_FALLBACK)
|
|
const [responses, people, bases, positions, units] = await Promise.all([
|
|
db.performanceSurveyResponse.findMany({ where: { survey: { assessmentMonth: state.sourceMonth, status: { notIn: ['draft', 'cancelled'] } }, assignment: { status: 'submitted' } }, select: { id: true, totalScore: true, createdAt: true, scores: true, assignment: { select: { workflowStageKey: true, reviewerSource: true, evaluatorSnapshot: true } }, target: { select: { employeeProfileId: true } }, survey: { select: { templateCode: true, templateSnapshot: true } } } }),
|
|
db.performanceSurveyEmployeeProfile.findMany({ include: { departmentMemberships: true } }),
|
|
db.personnelSalaryBase.findMany({ where: { deletedAt: null }, orderBy: [{ createdAt: 'asc' }, { id: 'asc' }] }),
|
|
db.salaryPositionConfig.findMany({ where: { deletedAt: null }, orderBy: [{ createdAt: 'asc' }, { id: 'asc' }] }),
|
|
db.organizationUnit.findMany({ where: { isActive: true }, select: { sourceDeptId: true, name: true, path: true } }),
|
|
])
|
|
return { state, responses, people, bases, positions, units }
|
|
}, { isolationLevel: 'RepeatableRead' })
|
|
const configuration = positions.map(serializePosition)
|
|
const matches = new Map(bases.map(base => [base.id, resolvePersonnelPerformance(base.positionId, base.jobGrade, configuration)]))
|
|
const marketPositionIds = new Set(configuration.filter(position => position.dimensions.some(dimension => dimension.metrics.some(metric => metric.source.kind === 'market-intent-top3'))).map(position => position.id))
|
|
const roots = personnelPositions(configuration)
|
|
const plannerPositionIds = new Set(roots.filter(position => position.salaryRole === 'ai-planning').map(position => position.id))
|
|
const managerPositionIds = new Set(roots.filter(position => position.salaryRole === 'management').map(position => position.id))
|
|
const managerBases = bases.filter(base => managerPositionIds.has(base.positionId ?? ''))
|
|
const departmentScopes = buildSalaryDepartmentScopes(managerBases.map(base => base.employeeProfileId), people, units,
|
|
new Set(bases.filter(base => plannerPositionIds.has(base.positionId ?? '')).map(base => base.employeeProfileId)))
|
|
const marketEmployeeIds = new Set(bases.filter(base => marketPositionIds.has(matches.get(base.id)?.id ?? '') && !managerPositionIds.has(base.positionId ?? '')).map(base => base.employeeProfileId))
|
|
for (const base of managerBases) if (marketPositionIds.has(matches.get(base.id)?.id ?? '')) {
|
|
for (const member of departmentScopes.get(base.employeeProfileId)!.planners) marketEmployeeIds.add(member.employeeProfileId)
|
|
}
|
|
// Market validation assesses last month's completed flows; other metrics keep their own source month.
|
|
const marketSourceMonth = previousSalaryMonth(displayMonth)
|
|
const [workflows, market] = await Promise.all([
|
|
readSalaryWorkflowMetrics(state.sourceMonth, people),
|
|
readSalaryMarketIntent(marketSourceMonth, people, Array.from(marketEmployeeIds)),
|
|
])
|
|
const scores = collectSalarySurveyScores(responses)
|
|
const matchSurveyPerson = createSalarySurveyPersonMatcher(people)
|
|
const surveyMatchIssues: NonNullable<SalaryDetails['surveyMatchIssues']> = []
|
|
const departmentMatchIssues: NonNullable<SalaryDetails['departmentMatchIssues']> = []
|
|
const roles: SalaryDetails['roles'] = { 'ai-planning': [], photography: [], 'spatial-visual': [], management: [], 'ai-technical': [] }
|
|
const unmatchedIds = new Set(bases.filter(base => !matches.get(base.id)).map(base => base.positionId))
|
|
const groupPositions = [...performancePositions(configuration).filter(position => !unmatchedIds.has(position.id)), ...roots.filter(position => unmatchedIds.has(position.id)).map(position => ({ ...position, dimensions: [] }))]
|
|
const positionGroups = groupPositions.map(position => {
|
|
return { position, template: getPositionSalaryTemplate(position, displayMonth), rows: [] as SalaryDetailRow[] }
|
|
})
|
|
const groupById = new Map(positionGroups.map(group => [group.position.id, group]))
|
|
for (const base of bases) {
|
|
const match = matches.get(base.id)
|
|
const group = groupById.get(match?.id ?? base.positionId ?? '')
|
|
if (!group) continue
|
|
const surveyPerson = matchSurveyPerson(base)
|
|
const raw = surveyPerson.employeeProfileId ? scores.get(surveyPerson.employeeProfileId) : undefined
|
|
if (surveyPerson.reason && group.position.dimensions.some(d => d.metrics.some(m => m.source.kind === 'survey'))) {
|
|
surveyMatchIssues.push({ employeeProfileId: base.employeeProfileId, employeeLabel: base.flowerName || base.name, salaryRole: group.position.salaryRole, reason: surveyPerson.reason, message: surveyMatchMessages[surveyPerson.reason] })
|
|
}
|
|
const metrics: Record<string, number | null> = {}
|
|
const scope = group.position.salaryRole === 'management' ? departmentScopes.get(base.employeeProfileId) : undefined
|
|
const hasMarket = group.position.dimensions.some(d => d.metrics.some(m => m.source.kind === 'market-intent-top3'))
|
|
const hasDelivery = group.position.dimensions.some(d => d.metrics.some(m => m.source.kind === 'on-time'))
|
|
const marketEvidence = scope && hasMarket ? summarizeDepartmentMarketIntent(marketSourceMonth, scope, market) : market.get(base.employeeProfileId)
|
|
const deliveryEvidence = scope && hasDelivery ? summarizeDepartmentDelivery(state.sourceMonth, scope, workflows.deliveryCounts) : undefined
|
|
if (scope && !scope.department && (hasMarket || hasDelivery)) departmentMatchIssues.push({ employeeProfileId: base.employeeProfileId, employeeLabel: base.flowerName || base.name, message: SALARY_DEPARTMENT_UNRESOLVED })
|
|
for (const dimension of group.position.dimensions) for (const metric of dimension.metrics) {
|
|
metrics[metric.id] = metric.source.kind === 'survey' ? raw?.get(metric.source.templateCode) ?? null
|
|
: metric.source.kind === 'on-time' ? (deliveryEvidence ? deliveryEvidence.rawScore : workflows.onTimeRates.get(base.employeeProfileId) ?? null)
|
|
: metric.source.kind === 'market-intent-top3' ? marketEvidence?.rawScore ?? null : null
|
|
}
|
|
const result = calculatePositionScore(group.position.dimensions, metrics)
|
|
const values: Record<string, SalaryCell> = {
|
|
name: base.name, nickname: base.flowerName, jobGrade: base.jobGrade, department: base.department, brand: base.brand,
|
|
baseSalary: base.baseSalary.toFixed(2), gradeSalary: base.gradeSalary.toFixed(2), performanceSalary: base.performanceSalary.toFixed(2),
|
|
baseSalaryBasis: base.baseSalary.toFixed(2), performanceSalaryBasis: base.performanceSalary.toFixed(2),
|
|
points: workflows.points.has(base.employeeProfileId) ? roundSalaryScore(workflows.points.get(base.employeeProfileId)!) : null,
|
|
performanceScore: result.totalScore,
|
|
...calculateSalaryPay(result.totalScore, base),
|
|
}
|
|
for (const key of Object.keys(metrics)) {
|
|
values[`${key}RawValue`] = metrics[key]
|
|
values[`${key}Score`] = result.contributions[key]
|
|
}
|
|
const metricEvidence: NonNullable<SalaryDetailRow['metricEvidence']> = {}
|
|
for (const dimension of group.position.dimensions) for (const metric of dimension.metrics) {
|
|
if (metric.source.kind === 'market-intent-top3' && marketEvidence) metricEvidence[metric.id] = marketEvidence
|
|
if (metric.source.kind === 'on-time' && deliveryEvidence) metricEvidence[metric.id] = deliveryEvidence
|
|
}
|
|
const row: SalaryDetailRow = { employeeProfileId: base.employeeProfileId, employeeLabel: base.flowerName || base.name, hasSalaryBase: true, positionGroupCode: `salary:${group.position.id}`, positionId: base.positionId ?? undefined, jobGrade: base.jobGrade, performancePositionId: match?.id ?? null, performanceMatch: match ? 'matched' : 'unmatched', metrics, metricEvidence, values, totalScore: result.totalScore }
|
|
group.rows.push(row); roles[group.position.salaryRole].push(row)
|
|
}
|
|
for (const group of positionGroups) { group.rows.sort((a, b) => String(a.values.name).localeCompare(String(b.values.name), 'zh-CN')); group.position.personnelCount = group.rows.length }
|
|
return { ...state, marketSourceMonth, roles, positionGroups, surveyMatchIssues, departmentMatchIssues }
|
|
}
|