484 lines
15 KiB
TypeScript
484 lines
15 KiB
TypeScript
/**
|
|
* 报表分析的聚合逻辑：全部是纯函数，输入「任务明细 + 筛选条件」，输出页面直接渲染的结构。
|
|
*
|
|
* 为什么单独一份而不是写进各页面：同一个「按科室的完成率」在总览的汇总矩阵、
|
|
* 时效分析的分组条形榜、患者结构分析的院区分布里都要用；各页各写一遍，
|
|
* 迟早出现「同一个筛选条件，两个页面算出不同的数」——这种不一致在界面上
|
|
* 没有任何提示，只能靠人盯着两个页面比对才能发现。
|
|
*
|
|
* 纯函数还有个直接好处：不依赖 DOM 与 Vue，可以用 Node 直接跑断言（见验证脚本）。
|
|
*/
|
|
|
|
import type { ReportTaskRow } from '@/api/workbench/report-analytics'
|
|
import type { SigningMethod, SigningTaskStatus } from '@/api/workbench/types'
|
|
|
|
import type {
|
|
ReportBarItem,
|
|
ReportFilterForm,
|
|
ReportGroupRow,
|
|
ReportPatientStructure,
|
|
ReportStatusCounts,
|
|
ReportSummaryDimension,
|
|
ReportTimelinessMetrics,
|
|
ReportTrendPoint,
|
|
} from './types'
|
|
|
|
/** 超 24 小时（分钟）：时效分析的「24 小时内完成率」分界 */
|
|
export const WITHIN_24H_MINUTES = 1440
|
|
/** 超 48 小时（分钟）：超过签署链接有效期，算「超期完成」 */
|
|
export const OVERDUE_MINUTES = 2880
|
|
|
|
/** 趋势图最多画多少根柱子：自定义区间可能跨好几个月，画不下也没人看 */
|
|
const MAX_TREND_DAYS = 60
|
|
|
|
export const METHOD_LABELS: Record<SigningMethod, string> = {
|
|
pad: '手写板',
|
|
sms: '短信线上',
|
|
}
|
|
|
|
/**
|
|
* 状态文案。六种状态与后端枚举一一对应，不映射成原型里的「待科室确认」——
|
|
* 那个状态在后端枚举里不存在，硬映射会让报表与签署记录页对同一个任务给出不同说法。
|
|
*/
|
|
export const STATUS_LABELS: Record<SigningTaskStatus, string> = {
|
|
pending: '待签署',
|
|
signing: '签署中',
|
|
signed: '已签署',
|
|
expired: '已超时',
|
|
void: '已作废',
|
|
failed: '处理失败',
|
|
}
|
|
|
|
/** 汇总矩阵与统计块共用的列顺序：先「好」后「坏」，读起来符合预期 */
|
|
export const STATUS_COLUMNS: SigningTaskStatus[] = [
|
|
'signed',
|
|
'pending',
|
|
'signing',
|
|
'expired',
|
|
'void',
|
|
'failed',
|
|
]
|
|
|
|
export const SUMMARY_DIMENSION_LABELS: Record<ReportSummaryDimension, string> = {
|
|
department: '科室',
|
|
category: '文档类别',
|
|
method: '签署方式',
|
|
campus: '院区',
|
|
}
|
|
|
|
/** 年龄段分档：顺序固定，不按数量排 —— 年龄天然有序，重排反而看不出分布形状 */
|
|
const AGE_BUCKETS: { label: string; match: (age: number) => boolean }[] = [
|
|
{ label: '0-17 岁', match: (age) => age < 18 },
|
|
{ label: '18-40 岁', match: (age) => age >= 18 && age <= 40 },
|
|
{ label: '41-60 岁', match: (age) => age >= 41 && age <= 60 },
|
|
{ label: '61 岁以上', match: (age) => age > 60 },
|
|
]
|
|
|
|
function pad(value: number): string {
|
|
return String(value).padStart(2, '0')
|
|
}
|
|
|
|
/** 把 `YYYY-MM-DD HH:mm` 截成日期键 */
|
|
export function dateKeyOf(moment: string): string {
|
|
return moment.slice(0, 10)
|
|
}
|
|
|
|
function dateKeyOfDate(date: Date): string {
|
|
return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`
|
|
}
|
|
|
|
/** 日期键 → 坐标轴标签 `M/D` */
|
|
export function axisLabelOf(dateKey: string): string {
|
|
const [, month, day] = dateKey.split('-')
|
|
|
|
return `${Number(month)}/${Number(day)}`
|
|
}
|
|
|
|
/** 任务状态 → 六类计数里的字段名：状态枚举与计数字段一一对应，直接索引即可 */
|
|
export function emptyCounts(): ReportStatusCounts {
|
|
return { total: 0, signed: 0, pending: 0, signing: 0, expired: 0, void: 0, failed: 0 }
|
|
}
|
|
|
|
export function addToCounts(counts: ReportStatusCounts, status: ReportTaskRow['status']): void {
|
|
counts.total += 1
|
|
counts[status] += 1
|
|
}
|
|
|
|
/** 完成率：已签署 ÷ 发起。发起为 0 时按 0 计，不返回 NaN */
|
|
export function completionRateOf(counts: ReportStatusCounts): number {
|
|
return counts.total ? Math.round((counts.signed / counts.total) * 100) : 0
|
|
}
|
|
|
|
/**
|
|
* 解析筛选的时间窗口，返回闭区间 `{ from, to }`（都是 `YYYY-MM-DD`）。
|
|
*
|
|
* 返回 null 表示「不做时间过滤」：自定义区间只填了一头时属于「条件还没填完」，
|
|
* 这时既不该按半截条件筛，也不该悄悄套一个默认窗口 —— 由页面禁用查询按钮，
|
|
* 这里只是给出一个确定的行为。
|
|
*/
|
|
export function resolveDateWindow(
|
|
filter: ReportFilterForm,
|
|
today = new Date(),
|
|
): { from: string; to: string } | null {
|
|
const to = dateKeyOfDate(today)
|
|
|
|
if (filter.dateRange === 'custom') {
|
|
if (!filter.customFrom || !filter.customTo) {
|
|
return null
|
|
}
|
|
|
|
// 起点晚于终点时按用户填的两个端点反着理解，比返回空结果友好
|
|
return filter.customFrom <= filter.customTo
|
|
? { from: filter.customFrom, to: filter.customTo }
|
|
: { from: filter.customTo, to: filter.customFrom }
|
|
}
|
|
|
|
const from = new Date(today)
|
|
|
|
if (filter.dateRange === 'month') {
|
|
from.setDate(1)
|
|
} else {
|
|
const days = filter.dateRange === '7d' ? 7 : 14
|
|
from.setDate(from.getDate() - (days - 1))
|
|
}
|
|
|
|
from.setHours(0, 0, 0, 0)
|
|
|
|
return { from: dateKeyOfDate(from), to }
|
|
}
|
|
|
|
/** 按筛选条件过滤任务明细 */
|
|
export function filterReportTasks(
|
|
tasks: readonly ReportTaskRow[],
|
|
filter: ReportFilterForm,
|
|
today = new Date(),
|
|
): ReportTaskRow[] {
|
|
const window = resolveDateWindow(filter, today)
|
|
|
|
return tasks.filter((task) => {
|
|
const day = dateKeyOf(task.createdAt)
|
|
|
|
if (window && (day < window.from || day > window.to)) {
|
|
return false
|
|
}
|
|
|
|
if (filter.campus !== 'all' && task.campus !== filter.campus) {
|
|
return false
|
|
}
|
|
|
|
if (filter.department && task.department !== filter.department) {
|
|
return false
|
|
}
|
|
|
|
if (filter.category && task.category !== filter.category) {
|
|
return false
|
|
}
|
|
|
|
if (filter.method !== 'all' && task.method !== filter.method) {
|
|
return false
|
|
}
|
|
|
|
return true
|
|
})
|
|
}
|
|
|
|
export function countByStatus(tasks: readonly ReportTaskRow[]): ReportStatusCounts {
|
|
const counts = emptyCounts()
|
|
|
|
tasks.forEach((task) => addToCounts(counts, task.status))
|
|
|
|
return counts
|
|
}
|
|
|
|
/**
|
|
* 每日趋势：同一天分别统计发起量与完成量。
|
|
*
|
|
* 窗口天数由 `window` 决定，而不是「有数据的那几天」—— 中间没有任务的日期
|
|
* 也要占一根空柱，否则横轴会被压缩，趋势的疏密就看不出真实节奏了。
|
|
*/
|
|
export function buildTrend(
|
|
tasks: readonly ReportTaskRow[],
|
|
window: { from: string; to: string } | null,
|
|
): ReportTrendPoint[] {
|
|
const createdMap = new Map<string, number>()
|
|
const signedMap = new Map<string, number>()
|
|
|
|
tasks.forEach((task) => {
|
|
const created = dateKeyOf(task.createdAt)
|
|
createdMap.set(created, (createdMap.get(created) ?? 0) + 1)
|
|
|
|
if (task.signedAt) {
|
|
const signed = dateKeyOf(task.signedAt)
|
|
signedMap.set(signed, (signedMap.get(signed) ?? 0) + 1)
|
|
}
|
|
})
|
|
|
|
const keys = window ? enumerateDays(window.from, window.to) : [...createdMap.keys()].sort()
|
|
|
|
return keys.map((key) => ({
|
|
key,
|
|
label: axisLabelOf(key),
|
|
created: createdMap.get(key) ?? 0,
|
|
signed: signedMap.get(key) ?? 0,
|
|
}))
|
|
}
|
|
|
|
/** 枚举闭区间内的每一天，超过 MAX_TREND_DAYS 时只保留最后 N 天 */
|
|
function enumerateDays(from: string, to: string): string[] {
|
|
const keys: string[] = []
|
|
const cursor = new Date(`${from}T00:00:00`)
|
|
const end = new Date(`${to}T00:00:00`)
|
|
|
|
// 上限兜底：自定义区间传个跨年的范围时，别把浏览器画死
|
|
while (cursor <= end && keys.length < 400) {
|
|
keys.push(dateKeyOfDate(cursor))
|
|
cursor.setDate(cursor.getDate() + 1)
|
|
}
|
|
|
|
return keys.length > MAX_TREND_DAYS ? keys.slice(-MAX_TREND_DAYS) : keys
|
|
}
|
|
|
|
/** 分组键：四种维度共用一套取值口径 */
|
|
export function groupKeyOf(task: ReportTaskRow, dimension: ReportSummaryDimension): string {
|
|
if (dimension === 'category') {
|
|
return task.category || '其他'
|
|
}
|
|
|
|
if (dimension === 'method') {
|
|
return METHOD_LABELS[task.method]
|
|
}
|
|
|
|
if (dimension === 'campus') {
|
|
return task.campus || '其他'
|
|
}
|
|
|
|
return task.department || '其他'
|
|
}
|
|
|
|
/** 按维度分组统计，按发起量倒序（原型口径：最大的分组排最前） */
|
|
export function groupTasks(
|
|
tasks: readonly ReportTaskRow[],
|
|
dimension: ReportSummaryDimension,
|
|
): ReportGroupRow[] {
|
|
const buckets = new Map<string, ReportStatusCounts>()
|
|
|
|
tasks.forEach((task) => {
|
|
const key = groupKeyOf(task, dimension)
|
|
const counts = buckets.get(key) ?? emptyCounts()
|
|
|
|
addToCounts(counts, task.status)
|
|
buckets.set(key, counts)
|
|
})
|
|
|
|
return [...buckets.entries()]
|
|
.map(([key, counts]) => ({
|
|
key,
|
|
...counts,
|
|
completionRate: completionRateOf(counts),
|
|
}))
|
|
.sort((a, b) => b.total - a.total || a.key.localeCompare(b.key, 'zh-Hans-CN'))
|
|
}
|
|
|
|
/** 排行条形榜：按数量倒序，可截断（文档 TOP10） */
|
|
export function buildRanking(
|
|
tasks: readonly ReportTaskRow[],
|
|
keyOf: (task: ReportTaskRow) => string,
|
|
limit?: number,
|
|
): ReportBarItem[] {
|
|
const buckets = new Map<string, number>()
|
|
|
|
tasks.forEach((task) => {
|
|
const key = keyOf(task)
|
|
buckets.set(key, (buckets.get(key) ?? 0) + 1)
|
|
})
|
|
|
|
const items = [...buckets.entries()]
|
|
.map(([label, value]) => ({ label, value }))
|
|
.sort((a, b) => b.value - a.value || a.label.localeCompare(b.label, 'zh-Hans-CN'))
|
|
|
|
return limit === undefined ? items : items.slice(0, limit)
|
|
}
|
|
|
|
/**
|
|
* 时效指标。
|
|
*
|
|
* 样本口径：只有**已签署**的任务参与平均时长与两个比率的分母。
|
|
* 把未完成任务也算进去会把平均值稀释成一个没有意义的数 —— 它们不是「签得快」，
|
|
* 而是「还没签完」。所以样本为 0 时三个指标返回 null，页面显示「—」而不是 0。
|
|
*/
|
|
export function buildTimeliness(tasks: readonly ReportTaskRow[]): ReportTimelinessMetrics {
|
|
const signed = tasks.filter((task) => task.signMinutes !== undefined)
|
|
|
|
if (!signed.length) {
|
|
return {
|
|
averageMinutes: null,
|
|
within24hRate: null,
|
|
overdueRate: null,
|
|
expiredTaskCount: tasks.filter((task) => task.status === 'expired').length,
|
|
signedSampleCount: 0,
|
|
}
|
|
}
|
|
|
|
const total = signed.reduce((sum, task) => sum + (task.signMinutes ?? 0), 0)
|
|
const within24h = signed.filter((task) => (task.signMinutes ?? 0) <= WITHIN_24H_MINUTES).length
|
|
const overdue = signed.filter((task) => (task.signMinutes ?? 0) > OVERDUE_MINUTES).length
|
|
|
|
return {
|
|
averageMinutes: Math.round(total / signed.length),
|
|
within24hRate: Math.round((within24h / signed.length) * 100),
|
|
overdueRate: Math.round((overdue / signed.length) * 100),
|
|
expiredTaskCount: tasks.filter((task) => task.status === 'expired').length,
|
|
signedSampleCount: signed.length,
|
|
}
|
|
}
|
|
|
|
/** 各科室平均签署时长，按均值倒序；颜色按 24h / 48h 阈值分级 */
|
|
export function buildDurationByDepartment(tasks: readonly ReportTaskRow[]): ReportBarItem[] {
|
|
const sum = new Map<string, { total: number; count: number }>()
|
|
|
|
tasks.forEach((task) => {
|
|
if (task.signMinutes === undefined) {
|
|
return
|
|
}
|
|
|
|
const key = task.department || '其他'
|
|
const bucket = sum.get(key) ?? { total: 0, count: 0 }
|
|
|
|
bucket.total += task.signMinutes
|
|
bucket.count += 1
|
|
sum.set(key, bucket)
|
|
})
|
|
|
|
return [...sum.entries()]
|
|
.map(([label, bucket]) => {
|
|
const average = Math.round(bucket.total / bucket.count)
|
|
|
|
return {
|
|
label,
|
|
value: average,
|
|
display: formatDuration(average),
|
|
color: durationColor(average),
|
|
}
|
|
})
|
|
.sort((a, b) => b.value - a.value || a.label.localeCompare(b.label, 'zh-Hans-CN'))
|
|
}
|
|
|
|
/** 每日平均签署时长（分钟），按完成日期归集 */
|
|
export function buildDailyAverageDuration(
|
|
tasks: readonly ReportTaskRow[],
|
|
window: { from: string; to: string } | null,
|
|
): ReportBarItem[] {
|
|
const sum = new Map<string, { total: number; count: number }>()
|
|
|
|
tasks.forEach((task) => {
|
|
if (task.signMinutes === undefined || !task.signedAt) {
|
|
return
|
|
}
|
|
|
|
const key = dateKeyOf(task.signedAt)
|
|
const bucket = sum.get(key) ?? { total: 0, count: 0 }
|
|
|
|
bucket.total += task.signMinutes
|
|
bucket.count += 1
|
|
sum.set(key, bucket)
|
|
})
|
|
|
|
const keys = window ? enumerateDays(window.from, window.to) : [...sum.keys()].sort()
|
|
|
|
return keys.map((key) => {
|
|
const bucket = sum.get(key)
|
|
|
|
return {
|
|
label: axisLabelOf(key),
|
|
value: bucket ? Math.round(bucket.total / bucket.count) : 0,
|
|
}
|
|
})
|
|
}
|
|
|
|
/** 超期完成任务：完成用时超过 48 小时的已签署任务，用时长的排前面 */
|
|
export function buildOverdueTasks(tasks: readonly ReportTaskRow[]): ReportTaskRow[] {
|
|
return tasks
|
|
.filter((task) => (task.signMinutes ?? 0) > OVERDUE_MINUTES)
|
|
.sort((a, b) => (b.signMinutes ?? 0) - (a.signMinutes ?? 0))
|
|
}
|
|
|
|
/** 患者结构：年龄段固定顺序，其余按数量倒序（与原型一致） */
|
|
export function buildPatientStructure(tasks: readonly ReportTaskRow[]): ReportPatientStructure {
|
|
// 年龄段只扫一遍：四档各 filter 一次是 4 倍工作量，而且四档之间还容易写歪边界
|
|
const ageCounts = AGE_BUCKETS.map(() => 0)
|
|
|
|
tasks.forEach((task) => {
|
|
const index = AGE_BUCKETS.findIndex((bucket) => bucket.match(task.age))
|
|
|
|
if (index >= 0) {
|
|
ageCounts[index] += 1
|
|
}
|
|
})
|
|
|
|
const age = AGE_BUCKETS.map((bucket, index) => ({
|
|
label: bucket.label,
|
|
value: ageCounts[index] ?? 0,
|
|
display: `${ageCounts[index] ?? 0} 人次`,
|
|
}))
|
|
|
|
const total = tasks.length || 1
|
|
|
|
const sex = buildRanking(tasks, (task) => task.sex).map((item) => ({
|
|
...item,
|
|
display: `${item.value} 人次 · ${Math.round((item.value / total) * 100)}%`,
|
|
}))
|
|
|
|
const visitType = buildRanking(tasks, (task) => task.visitType).map((item) => ({
|
|
...item,
|
|
display: `${item.value} 人次`,
|
|
}))
|
|
|
|
const campus = buildRanking(tasks, (task) => task.campus || '其他').map((item) => ({
|
|
...item,
|
|
display: `${item.value} 人次`,
|
|
}))
|
|
|
|
return { age, sex, visitType, campus }
|
|
}
|
|
|
|
/** 时长展示：对齐原型口径（不足 1 小时用分钟，超过用小时且保留一位小数） */
|
|
export function formatDuration(minutes: number | null | undefined): string {
|
|
if (minutes === null || minutes === undefined || Number.isNaN(minutes)) {
|
|
return '—'
|
|
}
|
|
|
|
if (minutes < 60) {
|
|
return `${minutes} 分钟`
|
|
}
|
|
|
|
const hours = minutes / 60
|
|
|
|
return `${hours < 10 ? Math.round(hours * 10) / 10 : Math.round(hours)} 小时`
|
|
}
|
|
|
|
/** 时长分级配色：24 小时内绿、48 小时内橙、超过红 */
|
|
export function durationColor(minutes: number): string {
|
|
if (minutes <= WITHIN_24H_MINUTES) {
|
|
return '#0f9d6c'
|
|
}
|
|
|
|
return minutes <= OVERDUE_MINUTES ? '#d9821f' : '#d0534f'
|
|
}
|
|
|
|
/** 完成率配色：≥90% 绿、≥80% 橙、其余红（原型口径） */
|
|
export function completionRateColor(rate: number): string {
|
|
if (rate >= 90) {
|
|
return '#0f9d6c'
|
|
}
|
|
|
|
return rate >= 80 ? '#d9821f' : '#d0534f'
|
|
}
|
|
|
|
/** 条形榜调色板（与原型一致） */
|
|
export const BAR_PALETTE = ['#0e6e8c', '#18a0c0', '#0f9d6c', '#d9821f', '#7a4dbb', '#d0534f']
|
|
|
|
/** 取条形颜色：显式给了就用，否则按调色板轮换 */
|
|
export function barColorOf(item: ReportBarItem, index: number): string {
|
|
return item.color ?? BAR_PALETTE[index % BAR_PALETTE.length] ?? '#0e6e8c'
|
|
}
|