zengzy / rps · Files

import type {
  WorkOrder,
  WorkOrderListQuery,
  WorkOrderMutationResponse,
  WorkOrderPayload,
  WorkOrderStatus,
  WorkOrderTransitionAction,
  WorkOrderTransitionPayload
} from '../../app/types/work-order'
import { getMockSettingsMembers } from './mock-settings'

type MutationResult = WorkOrderMutationResponse & {
  item?: WorkOrder
}

const TRANSITION_TO_STATUS: Record<Exclude<WorkOrderTransitionAction, 'create' | 'edit_draft'>, WorkOrderStatus> = {
  dispatch: 'pending_dispatch',
  pause: 'paused',
  resume: 'running',
  close: 'closed'
}

const ALLOWED_TRANSITIONS: Record<WorkOrderStatus, WorkOrderTransitionAction[]> = {
  draft: ['edit_draft', 'dispatch'],
  pending_dispatch: ['pause', 'resume', 'close'],
  running: ['pause', 'close'],
  paused: ['resume', 'close'],
  pending_qc: ['close'],
  completed: ['close'],
  closed: []
}

let nextId = 4006

function now() {
  return new Date().toISOString()
}

function normalizeText(value: string | undefined) {
  if (!value) {
    return undefined
  }

  const trimmed = value.trim()
  return trimmed.length > 0 ? trimmed : undefined
}

function clone(item: WorkOrder): WorkOrder {
  return {
    ...item,
    progress: { ...item.progress },
    audit: { ...item.audit },
    events: item.events.map(event => ({ ...event }))
  }
}

function withMutation(base: WorkOrderMutationResponse, item?: WorkOrder): MutationResult {
  return {
    ...base,
    item: item ? clone(item) : undefined
  }
}

function buildEvent(
  action: WorkOrderTransitionAction,
  fromStatus: WorkOrderStatus | null,
  toStatus: WorkOrderStatus,
  operator: string,
  remark?: string
) {
  return {
    id: `evt-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
    action,
    fromStatus,
    toStatus,
    operator: operator.trim(),
    at: now(),
    remark: normalizeText(remark)
  }
}

function createSeed(
  input: {
    id: number
    orderNo: string
    deviceCode: string
    batchNo: string
    line: string
    ownerUsername: string
    ownerName: string
    plannedDate: string
    status: WorkOrderStatus
    completedSn: number
    totalSn: number
    createdBy: string
  }
): WorkOrder {
  const createdAt = now()
  const firstEvent = buildEvent('create', null, 'draft', input.createdBy, '初始化工单')
  const currentEvent = input.status === 'draft'
    ? firstEvent
    : buildEvent('dispatch', 'draft', input.status, input.createdBy, '初始状态同步')

  return {
    id: input.id,
    orderNo: input.orderNo,
    deviceCode: input.deviceCode,
    batchNo: input.batchNo,
    line: input.line,
    ownerUsername: input.ownerUsername,
    ownerName: input.ownerName,
    plannedDate: input.plannedDate,
    status: input.status,
    progress: {
      completedSn: input.completedSn,
      totalSn: input.totalSn
    },
    audit: {
      createdBy: input.createdBy,
      createdAt,
      updatedBy: input.createdBy,
      updatedAt: currentEvent.at,
      lastAction: currentEvent.action,
      lastActionAt: currentEvent.at,
      lastActionBy: input.createdBy
    },
    events: input.status === 'draft' ? [firstEvent] : [firstEvent, currentEvent]
  }
}

const mockWorkOrders: WorkOrder[] = [
  createSeed({
    id: 4001,
    orderNo: 'WO-202605-001',
    deviceCode: 'RPS-CB-500',
    batchNo: 'BATCH-202605-A',
    line: '装配一线',
    ownerUsername: 'danielroe',
    ownerName: 'Daniel Roe',
    plannedDate: '2026-05-20',
    status: 'draft',
    completedSn: 0,
    totalSn: 50,
    createdBy: '系统管理员'
  }),
  createSeed({
    id: 4002,
    orderNo: 'WO-202605-002',
    deviceCode: 'RPS-VM-220',
    batchNo: 'BATCH-202605-B',
    line: '装配二线',
    ownerUsername: 'antfu',
    ownerName: 'Anthony Fu',
    plannedDate: '2026-05-21',
    status: 'pending_dispatch',
    completedSn: 10,
    totalSn: 80,
    createdBy: '系统管理员'
  }),
  createSeed({
    id: 4003,
    orderNo: 'WO-202605-003',
    deviceCode: 'RPS-CH-920',
    batchNo: 'BATCH-202605-C',
    line: '测试一线',
    ownerUsername: 'larbish',
    ownerName: 'Baptiste Leproux',
    plannedDate: '2026-05-22',
    status: 'running',
    completedSn: 28,
    totalSn: 100,
    createdBy: '系统管理员'
  }),
  createSeed({
    id: 4004,
    orderNo: 'WO-202605-004',
    deviceCode: 'RPS-GW-110',
    batchNo: 'BATCH-202605-D',
    line: '质检线',
    ownerUsername: 'hugorcd',
    ownerName: 'Hugo Richard',
    plannedDate: '2026-05-18',
    status: 'pending_qc',
    completedSn: 40,
    totalSn: 40,
    createdBy: '质量经理'
  }),
  createSeed({
    id: 4005,
    orderNo: 'WO-202605-005',
    deviceCode: 'RPS-CB-500',
    batchNo: 'BATCH-202605-E',
    line: '装配三线',
    ownerUsername: 'benjamincanac',
    ownerName: 'Benjamin Canac',
    plannedDate: '2026-05-16',
    status: 'closed',
    completedSn: 60,
    totalSn: 60,
    createdBy: '系统管理员'
  })
]

function findById(id: number) {
  return mockWorkOrders.find(item => item.id === id)
}

function hasDuplicateOrderNo(orderNo: string, ignoreId?: number) {
  return mockWorkOrders.some((item) => {
    if (typeof ignoreId === 'number' && item.id === ignoreId) {
      return false
    }

    return item.orderNo.toLowerCase() === orderNo.toLowerCase()
  })
}

function parseDate(input: string) {
  const value = new Date(input)
  return Number.isNaN(value.getTime()) ? null : value
}

function matchesFilter(item: WorkOrder, query: WorkOrderListQuery) {
  const orderNo = normalizeText(query.orderNo)?.toLowerCase()
  const deviceCode = normalizeText(query.deviceCode)?.toLowerCase()
  const batchNo = normalizeText(query.batchNo)?.toLowerCase()
  const ownerUsername = normalizeText(query.ownerUsername)?.toLowerCase()

  if (orderNo && !item.orderNo.toLowerCase().includes(orderNo)) {
    return false
  }

  if (deviceCode && !item.deviceCode.toLowerCase().includes(deviceCode)) {
    return false
  }

  if (batchNo && !item.batchNo.toLowerCase().includes(batchNo)) {
    return false
  }

  if (ownerUsername && item.ownerUsername.toLowerCase() !== ownerUsername) {
    return false
  }

  if (query.status && item.status !== query.status) {
    return false
  }

  const planned = parseDate(item.plannedDate)
  const start = query.plannedStart ? parseDate(query.plannedStart) : null
  const end = query.plannedEnd ? parseDate(query.plannedEnd) : null

  if (!planned) {
    return false
  }

  if (start && planned < start) {
    return false
  }

  if (end && planned > end) {
    return false
  }

  return true
}

export function getMockWorkOrders(query: WorkOrderListQuery) {
  return mockWorkOrders
    .filter(item => matchesFilter(item, query))
    .sort((a, b) => b.audit.updatedAt.localeCompare(a.audit.updatedAt))
    .map(item => clone(item))
}

export function createMockWorkOrder(payload: WorkOrderPayload, operator: string): MutationResult {
  if (hasDuplicateOrderNo(payload.orderNo)) {
    return withMutation({
      success: false,
      errorCode: 'WORK_ORDER_EXISTS',
      message: '工单号已存在。'
    })
  }

  const createdAt = now()
  const event = buildEvent('create', null, 'draft', operator, '新建工单')
  const owner = getMockSettingsMembers().find(member => member.username === payload.ownerUsername.trim())

  if (!owner) {
    return withMutation({
      success: false,
      errorCode: 'WORK_ORDER_OWNER_NOT_FOUND',
      message: '责任人不存在，请选择有效成员。'
    })
  }

  const item: WorkOrder = {
    id: nextId++,
    orderNo: payload.orderNo.trim(),
    deviceCode: payload.deviceCode.trim(),
    batchNo: payload.batchNo.trim(),
    line: payload.line.trim(),
    ownerUsername: owner.username,
    ownerName: owner.name,
    plannedDate: payload.plannedDate,
    status: 'draft',
    progress: {
      completedSn: 0,
      totalSn: payload.totalSn
    },
    audit: {
      createdBy: operator,
      createdAt,
      updatedBy: operator,
      updatedAt: createdAt,
      lastAction: 'create',
      lastActionAt: event.at,
      lastActionBy: operator
    },
    events: [event]
  }

  mockWorkOrders.unshift(item)

  return withMutation({
    success: true,
    errorCode: null,
    message: '工单草稿已创建。'
  }, item)
}

export function updateMockDraftWorkOrder(id: number, payload: WorkOrderPayload, operator: string): MutationResult {
  const item = findById(id)
  if (!item) {
    return withMutation({
      success: false,
      errorCode: 'WORK_ORDER_NOT_FOUND',
      message: '工单不存在。'
    })
  }

  if (item.status !== 'draft') {
    return withMutation({
      success: false,
      errorCode: 'WORK_ORDER_NOT_DRAFT',
      message: '仅草稿状态允许编辑。'
    })
  }

  if (hasDuplicateOrderNo(payload.orderNo, id)) {
    return withMutation({
      success: false,
      errorCode: 'WORK_ORDER_EXISTS',
      message: '工单号已存在。'
    })
  }

  const owner = getMockSettingsMembers().find(member => member.username === payload.ownerUsername.trim())
  if (!owner) {
    return withMutation({
      success: false,
      errorCode: 'WORK_ORDER_OWNER_NOT_FOUND',
      message: '责任人不存在，请选择有效成员。'
    })
  }

  item.orderNo = payload.orderNo.trim()
  item.deviceCode = payload.deviceCode.trim()
  item.batchNo = payload.batchNo.trim()
  item.line = payload.line.trim()
  item.ownerUsername = owner.username
  item.ownerName = owner.name
  item.plannedDate = payload.plannedDate
  item.progress.totalSn = payload.totalSn
  item.progress.completedSn = Math.min(item.progress.completedSn, payload.totalSn)

  const event = buildEvent('edit_draft', 'draft', 'draft', operator, '编辑草稿')
  item.events.unshift(event)
  item.audit.updatedBy = operator
  item.audit.updatedAt = event.at
  item.audit.lastAction = 'edit_draft'
  item.audit.lastActionAt = event.at
  item.audit.lastActionBy = operator

  return withMutation({
    success: true,
    errorCode: null,
    message: '工单草稿已更新。'
  }, item)
}

export function transitionMockWorkOrder(
  id: number,
  action: Exclude<WorkOrderTransitionAction, 'create' | 'edit_draft'>,
  payload: WorkOrderTransitionPayload
): MutationResult {
  const item = findById(id)
  if (!item) {
    return withMutation({
      success: false,
      errorCode: 'WORK_ORDER_NOT_FOUND',
      message: '工单不存在。'
    })
  }

  const allowedActions = ALLOWED_TRANSITIONS[item.status] ?? []
  if (!allowedActions.includes(action)) {
    return withMutation({
      success: false,
      errorCode: 'INVALID_STATUS_TRANSITION',
      message: '当前状态不允许执行该操作。'
    })
  }

  const fromStatus = item.status
  const toStatus = TRANSITION_TO_STATUS[action]
  const operator = payload.operator.trim()
  const remark = normalizeText(payload.remark)

  item.status = toStatus

  const event = buildEvent(action, fromStatus, toStatus, operator, remark)
  item.events.unshift(event)
  item.audit.updatedBy = operator
  item.audit.updatedAt = event.at
  item.audit.lastAction = action
  item.audit.lastActionAt = event.at
  item.audit.lastActionBy = operator

  return withMutation({
    success: true,
    errorCode: null,
    message: '工单状态已更新。'
  }, item)
}