medical-mall/services/deliveryService.uts

import {
	acceptDeliveryOrderById,
	arriveOrderById,
	checkinOrderById,
	finishServiceById,
	getDeliveryDashboardByStaffId,
	getDeliveryOrderDetailById,
	getDeliveryOrdersByStaffId,
	getDeliveryProfileByUserId,
	loginDelivery as loginDeliveryApi,
	saveServiceProgressById,
	startDepartById,
	startServiceById
} from '@/api/delivery.uts'
import { saveServiceRecord as saveRealServiceRecord } from '@/services/serviceOrderService.uts'
import {
	acceptCareOrder,
	checkInCareOrder,
	completeCareOrder,
	getCareOrderDetail,
	getCareRecords,
	getDeliveryCareDashboard,
	getDeliveryCareProfile,
	getHistoryCareOrders,
	getPendingCareOrders,
	getTodayCareOrders,
	markCareOrderArrived,
	markCareOrderDeparted,
	rejectCareOrder,
	startCareService,
	submitCareAbnormalReport,
	submitCareServiceRecord,
	updateCareOrderStatus,
	updateDeliveryCareOnlineStatus
} from '@/mock/delivery-care.mock.uts'
import { requireDeliveryAuth } from '@/utils/deliveryAuth.uts'
import type {
	DeliveryAbnormalReportType,
	DeliveryCheckinPayloadType,
	DeliveryDashboardType,
	DeliveryExceptionPayloadType,
	DeliveryFinishPayloadType,
	DeliveryInfoType,
	DeliveryLocationType,
	DeliveryLoginPayloadType,
	DeliveryLoginResultType,
	DeliveryMessageType,
	DeliveryOrderQueryType,
	DeliveryOrderStatus,
	DeliveryOrderType,
	DeliveryProgressPayloadType,
	DeliveryRecordType,
	DeliveryServiceRecordType
} from '@/types/delivery.uts'

export async function loginDelivery(payload: DeliveryLoginPayloadType): Promise<DeliveryLoginResultType> {
	return await loginDeliveryApi(payload)
}

export async function getDeliveryProfile(): Promise<DeliveryInfoType | null> {
	const authResult = await requireDeliveryAuth({ redirectOnFail: false, toastOnFail: false })
	if (!authResult.ok) {
		return null
	}
	return authResult.deliveryInfo
}

export async function getDeliveryByUserId(userId: string): Promise<DeliveryInfoType | null> {
	return await getDeliveryProfileByUserId(userId)
}

export async function getCurrentDeliverer(): Promise<DeliveryInfoType | null> {
	return await getDeliveryProfile()
}

export async function checkDeliveryAccountByUserId(userId: string): Promise<DeliveryInfoType | null> {
	return await getDeliveryProfileByUserId(userId)
}

export async function checkDeliveryAuth(): Promise<boolean> {
	const result = await requireDeliveryAuth({ redirectOnFail: false, toastOnFail: false })
	return result.ok
}

async function getCurrentStaffId(): Promise<string> {
	const profile = await getDeliveryProfile()
	if (profile == null) {
		return ''
	}
	return profile.id
	}

function createEmptyLocation(): DeliveryLocationType {
	return {
		latitude: 0,
		longitude: 0,
		address: '',
		time: new Date().toISOString().replace('T', ' ').substring(0, 19)
	}
	}

export async function getDeliveryDashboard(): Promise<DeliveryDashboardType> {
	const staffId = await getCurrentStaffId()
	if (staffId != '') {
		return await getDeliveryDashboardByStaffId(staffId)
	}
	return getDeliveryCareDashboard()
}

export async function getDeliveryOrders(params: DeliveryOrderQueryType): Promise<Array<DeliveryOrderType>> {
	const staffId = await getCurrentStaffId()
	if (staffId != '') {
		return await getDeliveryOrdersByStaffId(staffId, params)
	}
	if (params.tab == 'pending' || params.tab == 'pending_assignment') {
		return getPendingCareOrders()
	}
	if (params.tab == 'history' || params.tab == 'completed' || params.tab == 'archive') {
		return getHistoryCareOrders()
	}
	return getTodayCareOrders()
}

export async function getDeliveryOrderDetail(id: string): Promise<DeliveryOrderType | null> {
	return await getDeliveryOrderDetailById(id)
}

export async function acceptDeliveryOrder(id: string): Promise<DeliveryOrderType | null> {
	return await acceptDeliveryOrderById(id)
}

export async function rejectDeliveryOrder(id: string, reason: string): Promise<DeliveryOrderType | null> {
	return rejectCareOrder(id, reason)
}

export async function startDepart(id: string, location: DeliveryLocationType): Promise<DeliveryOrderType | null> {
	return await startDepartById(id, location)
}

export async function arriveOrder(id: string, location: DeliveryLocationType): Promise<DeliveryOrderType | null> {
	return await arriveOrderById(id, location)
}

export async function checkinOrder(id: string, payload: DeliveryCheckinPayloadType): Promise<DeliveryOrderType | null> {
	return await checkinOrderById(id, payload)
}

export async function startService(id: string): Promise<DeliveryOrderType | null> {
	return await startServiceById(id)
}

export async function saveServiceProgress(id: string, payload: DeliveryProgressPayloadType): Promise<DeliveryOrderType | null> {
	return await saveServiceProgressById(id, payload)
}

export async function uploadEvidence(id: string, phase: string, files: Array<string>): Promise<Array<any>> {
	return files.map((item, index) => ({
		id: id + '-evidence-' + String(index + 1),
		orderId: id,
		phase,
		fileType: 'image',
		name: 'mock-image-' + String(index + 1),
		url: '',
		localPath: item,
		status: 'success',
		progress: 100,
		retryable: false,
		createdAt: new Date().toISOString().replace('T', ' ').substring(0, 19)
	})) as Array<any>
}

export async function retryUploadEvidence(id: string, evidenceId: string): Promise<any | null> {
	return {
		id: evidenceId,
		orderId: id,
		phase: 'service',
		fileType: 'image',
		name: 'mock-retry',
		url: '',
		localPath: '',
		status: 'success',
		progress: 100,
		retryable: false,
		createdAt: new Date().toISOString().replace('T', ' ').substring(0, 19)
	} as any
}

export async function submitException(id: string, payload: DeliveryExceptionPayloadType): Promise<DeliveryOrderType | null> {
	return submitCareAbnormalReport(id, payload)
}

export async function finishService(id: string, payload: DeliveryFinishPayloadType | null = null): Promise<DeliveryOrderType | null> {
	const finishPayload = payload != null ? payload : {
		serviceSummary: '',
		signatureName: '',
		confirmByFamily: false
	} as DeliveryFinishPayloadType
	return await finishServiceById(id, finishPayload)
}

export async function getDeliveryRecords(): Promise<Array<DeliveryRecordType>> {
	return getCareRecords()
}

export async function getDeliveryMessages(): Promise<Array<DeliveryMessageType>> {
	return [
		{
			id: 'delivery-msg-01',
			title: '今日待服务提醒',
			content: '请优先处理上午 9:00 的上门助浴订单。',
			type: 'workbench',
			createdAt: new Date().toISOString().replace('T', ' ').substring(0, 19),
			read: false,
			orderId: 'mock-care-001'
		} as DeliveryMessageType
	]
}

export async function updateDeliveryOnlineStatus(status: string): Promise<DeliveryInfoType | null> {
	if (status == 'online' || status == 'resting' || status == 'busy') {
		return updateDeliveryCareOnlineStatus(status)
	}
	return getDeliveryCareProfile()
}

export async function getDeliveryDashboardStats(): Promise<DeliveryDashboardType> {
	return await getDeliveryDashboard()
}

export async function getPendingServiceOrders(): Promise<Array<DeliveryOrderType>> {
	return await getDeliveryOrders({ tab: 'pending', keyword: '' } as DeliveryOrderQueryType)
}

export async function getTodayServiceOrders(): Promise<Array<DeliveryOrderType>> {
	return await getDeliveryOrders({ tab: 'today', keyword: '' } as DeliveryOrderQueryType)
}

export async function getHistoryServiceOrders(): Promise<Array<DeliveryOrderType>> {
	return await getDeliveryOrders({ tab: 'history', keyword: '' } as DeliveryOrderQueryType)
}

export async function getServiceOrderDetail(orderId: string): Promise<DeliveryOrderType | null> {
	return await getDeliveryOrderDetail(orderId)
}

export async function acceptServiceOrder(orderId: string): Promise<DeliveryOrderType | null> {
	return await acceptDeliveryOrder(orderId)
}

export async function rejectServiceOrder(orderId: string, reason: string): Promise<DeliveryOrderType | null> {
	return rejectCareOrder(orderId, reason)
}

export async function markDeparted(orderId: string): Promise<DeliveryOrderType | null> {
	return await startDepartById(orderId, createEmptyLocation())
}

export async function markArrived(orderId: string): Promise<DeliveryOrderType | null> {
	return await arriveOrderById(orderId, createEmptyLocation())
}

export async function checkInServiceOrder(orderId: string, note: string, location: DeliveryLocationType | null = null): Promise<DeliveryOrderType | null> {
	if (location == null) {
		return null
	}
	return await checkinOrderById(orderId, {
		location,
		note,
		photos: [] as Array<string>,
		checkinMode: 'gps'
	})
}

export async function startServiceOrder(orderId: string): Promise<DeliveryOrderType | null> {
	return await startServiceById(orderId)
}

export async function submitServiceRecord(orderId: string, record: DeliveryServiceRecordType): Promise<DeliveryOrderType | null> {
	return await saveRealServiceRecord(orderId, record)
}

export async function completeServiceOrder(orderId: string): Promise<DeliveryOrderType | null> {
	return await finishService(orderId)
}

export async function submitAbnormalReport(orderId: string, report: DeliveryExceptionPayloadType): Promise<DeliveryOrderType | null> {
	return submitCareAbnormalReport(orderId, report)
}

export async function updateOrderStatus(orderId: string, nextStatus: DeliveryOrderStatus, extraRemark: string = ''): Promise<DeliveryOrderType | null> {
	return updateCareOrderStatus(orderId, nextStatus, extraRemark)
}

export async function getAbnormalReport(orderId: string): Promise<DeliveryAbnormalReportType | null> {
	const order = getCareOrderDetail(orderId)
	return order != null ? order.abnormalReport : null
}