提交

2026-06-15 11:43:16 +08:00
1 parent 427bcb1551
commit 31b04575e2
@@ -0,0 +1,245 @@
+import type { QcWorkOrder } from '@/api/qc-work-order'
+import { fetchQcWorkOrderDetail } from '@/api/qc-work-order'
+import { fetchMyQcTaskList, type QcTask } from '@/api/qc-task'
+import { groupInboundQcWorkOrders } from '@/utils/qc-work-order-groups'
+
+export type QcWorkOrderTypeTab = 'inbound' | 'temporary' | 'outbound' | 'all'
+
+export type QcTaskMineFilters = {
+  keyword?: string
+  taskType?: string
+  taskStatus?: string
+  qcBizType?: string
+}
+
+export type MineWorkOrderSearchFilters = {
+  keyword?: string
+  workOrderStatus?: string
+  bizType?: string
+  triggerSource?: string
+  createTimeStart?: string
+  createTimeEnd?: string
+  infusionTimeStart?: string
+  infusionTimeEnd?: string
+  activeTypeTab: QcWorkOrderTypeTab
+}
+
+export type MineWorkOrderEntry = {
+  workOrderId: string
+  workOrder: QcWorkOrder
+  activeTypeTab: QcWorkOrderTypeTab
+  tasks: QcTask[]
+}
+
+const MINE_TASK_FETCH_PAGE_SIZE = 100
+
+function dateInRange(value: string | undefined, start?: string, end?: string): boolean {
+  const v = (value || '').trim().slice(0, 10)
+  if (!v) return !start && !end
+  if (start && v < start) return false
+  if (end && v > end) return false
+  return true
+}
+
+function keywordMatchesWorkOrder(row: QcWorkOrder, keyword: string, tab: QcWorkOrderTypeTab): boolean {
+  const kw = keyword.trim().toLowerCase()
+  if (!kw) return true
+  const fields =
+    tab === 'temporary'
+      ? [row.workOrderNo]
+      : tab === 'outbound'
+        ? [row.workOrderNo, row.applicationNo, row.applicationName]
+        : [row.workOrderNo, row.sampleCode, row.labStorageCode]
+  return fields.some((f) => (f || '').toLowerCase().includes(kw))
+}
+
+export function filterMineEntriesByWorkOrderSearch(
+  entries: MineWorkOrderEntry[],
+  filters: MineWorkOrderSearchFilters
+): MineWorkOrderEntry[] {
+  const tab = filters.activeTypeTab
+  return entries.filter((entry) => {
+    const row = entry.workOrder
+    if (filters.workOrderStatus && row.workOrderStatus !== filters.workOrderStatus) return false
+    if (tab === 'inbound' && filters.triggerSource && row.triggerSource !== filters.triggerSource) {
+      return false
+    }
+    if (tab === 'outbound' && filters.bizType && row.bizType !== filters.bizType) return false
+    if (!keywordMatchesWorkOrder(row, filters.keyword || '', tab)) return false
+    if (tab === 'outbound') {
+      if (!dateInRange(row.infusionTime, filters.infusionTimeStart, filters.infusionTimeEnd)) {
+        return false
+      }
+    } else if (!dateInRange(row.createTime, filters.createTimeStart, filters.createTimeEnd)) {
+      return false
+    }
+    return true
+  })
+}
+
+export async function fetchAllMineTasks(filters: QcTaskMineFilters): Promise<QcTask[]> {
+  const pageSize = MINE_TASK_FETCH_PAGE_SIZE
+  let page = 1
+  const all: QcTask[] = []
+  let total = 0
+  while (true) {
+    const res = await fetchMyQcTaskList({
+      page,
+      pageSize,
+      keyword: filters.keyword || undefined,
+      taskType: filters.taskType || undefined,
+      taskStatus: filters.taskStatus || undefined,
+      qcBizType: filters.qcBizType || undefined
+    })
+    const list = res.list || []
+    all.push(...list)
+    total = res.total || 0
+    if (!list.length || all.length >= total) break
+    page += 1
+  }
+  return all
+}
+
+export async function enrichMineEntriesWithWorkOrders(
+  entries: MineWorkOrderEntry[]
+): Promise<MineWorkOrderEntry[]> {
+  const cache = new Map<string, QcWorkOrder>()
+  const uniqueIds = [...new Set(entries.map((entry) => entry.workOrderId))]
+  await Promise.all(
+    uniqueIds.map(async (id) => {
+      try {
+        const detail = await fetchQcWorkOrderDetail(id)
+        cache.set(id, detail)
+      } catch {
+        // 保留任务聚合的工单摘要
+      }
+    })
+  )
+  return entries.map((entry) => {
+    const detail = cache.get(entry.workOrderId)
+    if (!detail) return entry
+    return {
+      ...entry,
+      workOrder: {
+        ...detail,
+        hasLab: detail.hasLab ?? entry.workOrder.hasLab,
+        hasThirdParty: detail.hasThirdParty ?? entry.workOrder.hasThirdParty
+      }
+    }
+  })
+}
+
+export function paginateMineEntries<T>(items: T[], page: number, pageSize: number) {
+  const safePage = Math.max(1, page)
+  const safeSize = Math.max(1, pageSize)
+  const start = (safePage - 1) * safeSize
+  return {
+    total: items.length,
+    items: items.slice(start, start + safeSize)
+  }
+}
+
+export function buildMineTableRows(pageEntries: MineWorkOrderEntry[]): {
+  rows: QcWorkOrder[]
+  presetTasksByWorkOrderId: Record<string, QcTask[]>
+} {
+  return {
+    rows: pageEntries.map((e) => e.workOrder),
+    presetTasksByWorkOrderId: buildPresetTasksMap(pageEntries)
+  }
+}
+
+export function resolveWorkOrderTypeTab(task: QcTask): QcWorkOrderTypeTab {
+  const t = (task.qcBizType || task.orderSource || 'inbound').trim()
+  if (t === 'outbound' || t === 'temporary' || t === 'inbound') return t
+  return 'inbound'
+}
+
+export function buildWorkOrderFromTasks(tasks: QcTask[]): QcWorkOrder {
+  const t = tasks[0]
+  const woType = resolveWorkOrderTypeTab(t)
+  return {
+    id: t.workOrderId,
+    workOrderNo: t.workOrderNo || '—',
+    workOrderType: woType,
+    workOrderStatus: t.workOrderStatus || '',
+    receptionId: '',
+    protocolSampleId: '',
+    collectionProtocolId: '',
+    protocolNo: t.protocolNo || '',
+    sampleCode: t.sampleCode || '',
+    receptionSource: t.receptionSource,
+    receptionSourceLabel: t.receptionSourceLabel,
+    qcBizType: t.qcBizType || woType,
+    qcBizTypeLabel: t.qcBizTypeLabel,
+    cellProductId: t.cellProductId,
+    cellProductCode: t.cellProductCode,
+    cellProductName: t.cellProductName,
+    cellProductTypeName: t.cellProductTypeName,
+    cellProductPassage: t.cellProductPassage,
+    cellProductSpecName: t.cellProductSpecName,
+    sampleTypeName: t.sampleTypeName,
+    receptionTime: t.receptionTime,
+    handlerName: t.handlerName,
+    hasLab: tasks.some((x) => x.taskType === 'sysz'),
+    hasThirdParty: tasks.some((x) => x.taskType === 'dsfjc'),
+    createTime: t.createTime || '',
+    bizType: woType === 'outbound' ? t.receptionSource : undefined,
+    bizTypeLabel: woType === 'outbound' ? t.receptionSourceLabel : undefined,
+    protocolStatus: t.protocolStatus,
+    protocolStatusLabel: t.protocolStatusLabel
+  }
+}
+
+/** 按工单聚合任务，保持 API 返回顺序 */
+export function groupMineTasksByWorkOrder(tasks: QcTask[]): MineWorkOrderEntry[] {
+  const map = new Map<string, QcTask[]>()
+  const order: string[] = []
+  for (const row of tasks) {
+    const key = row.workOrderId || row.workOrderNo || row.id
+    if (!map.has(key)) {
+      map.set(key, [])
+      order.push(key)
+    }
+    map.get(key)!.push(row)
+  }
+  return order.map((workOrderId) => {
+    const groupTasks = map.get(workOrderId)!
+    return {
+      workOrderId,
+      workOrder: buildWorkOrderFromTasks(groupTasks),
+      activeTypeTab: resolveWorkOrderTypeTab(groupTasks[0]),
+      tasks: groupTasks
+    }
+  })
+}
+
+export function buildPresetTasksMap(entries: MineWorkOrderEntry[]): Record<string, QcTask[]> {
+  const map: Record<string, QcTask[]> = {}
+  for (const entry of entries) {
+    map[entry.workOrder.id] = entry.tasks
+  }
+  return map
+}
+
+export type MineCardListModel = {
+  inboundGroups: ReturnType<typeof groupInboundQcWorkOrders>
+  standaloneEntries: MineWorkOrderEntry[]
+  presetTasksByWorkOrderId: Record<string, QcTask[]>
+  hasItems: boolean
+}
+
+/** 入库走 SampleGroup，出库/临时走 SingleCard standalone */
+export function buildMineCardListModel(tasks: QcTask[]): MineCardListModel {
+  const entries = groupMineTasksByWorkOrder(tasks)
+  const presetTasksByWorkOrderId = buildPresetTasksMap(entries)
+  const inboundEntries = entries.filter((e) => e.activeTypeTab === 'inbound')
+  const standaloneEntries = entries.filter((e) => e.activeTypeTab !== 'inbound')
+  const inboundGroups = groupInboundQcWorkOrders(inboundEntries.map((e) => e.workOrder))
+  return {
+    inboundGroups,
+    standaloneEntries,
+    presetTasksByWorkOrderId,
+    hasItems: entries.length > 0
+  }
+}