zetaloop
487 lines
16 KiB
TypeScript
487 lines
16 KiB
TypeScript
import type { Actor } from "@/lib/actor"
|
|
import {
|
|
ORDER_ACCEPT_TIMEOUT_MS,
|
|
ORDER_CLOSE_TIMEOUT_MS,
|
|
ORDER_REVIEW_TIMEOUT_MS,
|
|
} from "@/lib/config/demo-timers"
|
|
import { allow, deny } from "@/lib/decision"
|
|
import { evaluateOrderTransition, type OrderAction } from "@/lib/domain/order-machine"
|
|
import type { ApiDecision } from "@/lib/errors"
|
|
import { generateId } from "@/lib/id"
|
|
import type { Order, OrderStatus } from "@/lib/types"
|
|
import { useAuthStore } from "@/store/auth"
|
|
import { useChatStore } from "@/store/chat"
|
|
import { useNotificationStore } from "@/store/notifications"
|
|
import { usePlayerStore } from "@/store/players"
|
|
import { useServiceStore } from "@/store/services"
|
|
import { useShopStore } from "@/store/shops"
|
|
import { useWalletStore } from "@/store/wallet"
|
|
import { create } from "zustand"
|
|
|
|
interface CreateOrderInput {
|
|
playerId: string
|
|
serviceId: string
|
|
shopId?: string
|
|
quantity: number
|
|
note?: string
|
|
}
|
|
|
|
type CreatePaidOrderInput = CreateOrderInput
|
|
|
|
interface OrderMutationResult {
|
|
decision: ApiDecision
|
|
order?: Order
|
|
}
|
|
|
|
interface OrderState {
|
|
orders: Order[]
|
|
createOrder: (input: CreateOrderInput, actor: Actor) => OrderMutationResult
|
|
createPaidOrder: (input: CreatePaidOrderInput, actor: Actor) => OrderMutationResult
|
|
payOrder: (orderId: string, actor: Actor) => OrderMutationResult
|
|
acceptOrder: (orderId: string, actor: Actor) => OrderMutationResult
|
|
requestClose: (orderId: string, actor: Actor) => OrderMutationResult
|
|
confirmClose: (orderId: string, actor: Actor) => OrderMutationResult
|
|
cancelPreAccept: (orderId: string, actor: Actor) => OrderMutationResult
|
|
markDisputed: (orderId: string, actor: Actor) => OrderMutationResult
|
|
autoTimeoutPendingAccept: (orderId: string) => OrderMutationResult
|
|
autoTimeoutPendingClose: (orderId: string) => OrderMutationResult
|
|
autoTimeoutPendingReview: (orderId: string) => OrderMutationResult
|
|
resolveDispute: (orderId: string) => OrderMutationResult
|
|
}
|
|
|
|
const orderTimeouts = new Map<string, ReturnType<typeof setTimeout>>()
|
|
const pendingCreations = new Set<string>()
|
|
|
|
function clearOrderTimeout(orderId: string) {
|
|
const timer = orderTimeouts.get(orderId)
|
|
if (!timer) return
|
|
clearTimeout(timer)
|
|
orderTimeouts.delete(orderId)
|
|
}
|
|
|
|
function isParticipant(order: Order, userId: string) {
|
|
return order.consumerId === userId || order.playerId === userId
|
|
}
|
|
|
|
function isOrderOwnerActor(order: Order, actor: Actor) {
|
|
return actor.role === "owner" && Boolean(order.shopId) && actor.shopId === order.shopId
|
|
}
|
|
|
|
function validateActorForAction(order: Order, action: OrderAction, actor?: Actor): ApiDecision {
|
|
if (action.startsWith("AUTO_TIMEOUT_") || (action === "RESOLVE_DISPUTE" && !actor?.userId)) {
|
|
return allow()
|
|
}
|
|
|
|
if (!actor?.userId) {
|
|
return deny(401, "请先登录")
|
|
}
|
|
|
|
if (order.status === "disputed" && action !== "RESOLVE_DISPUTE") {
|
|
return deny(400, "争议处理中，暂不可执行此操作")
|
|
}
|
|
|
|
if (action === "PAY" || action === "CANCEL_PRE_ACCEPT" || action === "CONFIRM_CLOSE") {
|
|
return order.consumerId === actor.userId ? allow() : deny(403, "仅下单客户可执行该操作")
|
|
}
|
|
|
|
if (action === "ACCEPT") {
|
|
return order.playerId === actor.userId || isOrderOwnerActor(order, actor)
|
|
? allow()
|
|
: deny(403, "仅该订单打手或所属店主可执行接单")
|
|
}
|
|
|
|
if (action === "REQUEST_CLOSE" || action === "OPEN_DISPUTE" || action === "SUBMIT_REVIEW") {
|
|
return isParticipant(order, actor.userId) ? allow() : deny(403, "仅订单参与方可执行该操作")
|
|
}
|
|
|
|
if (action === "RESOLVE_DISPUTE") {
|
|
return isOrderOwnerActor(order, actor) ? allow() : deny(403, "仅订单所属店主可执行该操作")
|
|
}
|
|
|
|
return allow()
|
|
}
|
|
|
|
function applyStatus(order: Order, status: OrderStatus): Order {
|
|
const now = new Date().toISOString()
|
|
|
|
switch (status) {
|
|
case "in_progress":
|
|
return {
|
|
...order,
|
|
status,
|
|
acceptedAt: order.acceptedAt ?? now,
|
|
}
|
|
case "pending_close":
|
|
return {
|
|
...order,
|
|
status,
|
|
closedAt: order.closedAt ?? now,
|
|
}
|
|
case "pending_review":
|
|
return {
|
|
...order,
|
|
status,
|
|
closedAt: order.closedAt ?? now,
|
|
}
|
|
case "completed":
|
|
return {
|
|
...order,
|
|
status,
|
|
closedAt: order.closedAt ?? now,
|
|
completedAt: order.completedAt ?? now,
|
|
}
|
|
default:
|
|
return {
|
|
...order,
|
|
status,
|
|
}
|
|
}
|
|
}
|
|
|
|
function syncChatSession(order: Order, previousStatus: OrderStatus) {
|
|
const chatStore = useChatStore.getState()
|
|
if (order.status === "pending_payment") return
|
|
|
|
if (order.status === "cancelled") {
|
|
const sessionExists = chatStore.sessions.some(
|
|
(session) => session.type === "order" && session.orderId === order.id,
|
|
)
|
|
if (sessionExists) {
|
|
chatStore.ensureOrderSession(order)
|
|
}
|
|
return
|
|
}
|
|
|
|
if (previousStatus !== order.status) {
|
|
chatStore.ensureOrderSession(order)
|
|
}
|
|
}
|
|
|
|
function scheduleOrderTimeout(orderId: string, status: OrderStatus) {
|
|
clearOrderTimeout(orderId)
|
|
|
|
if (status !== "pending_accept" && status !== "pending_close" && status !== "pending_review") {
|
|
return
|
|
}
|
|
|
|
const timeoutMap: Record<"pending_accept" | "pending_close" | "pending_review", number> = {
|
|
pending_accept: ORDER_ACCEPT_TIMEOUT_MS,
|
|
pending_close: ORDER_CLOSE_TIMEOUT_MS,
|
|
pending_review: ORDER_REVIEW_TIMEOUT_MS,
|
|
}
|
|
const timeoutMs = timeoutMap[status]
|
|
|
|
const timer = setTimeout(() => {
|
|
const state = useOrderStore.getState()
|
|
const order = state.orders.find((item) => item.id === orderId)
|
|
if (!order || order.status !== status) {
|
|
orderTimeouts.delete(orderId)
|
|
return
|
|
}
|
|
|
|
if (status === "pending_accept") {
|
|
state.autoTimeoutPendingAccept(orderId)
|
|
} else if (status === "pending_close") {
|
|
state.autoTimeoutPendingClose(orderId)
|
|
} else if (status === "pending_review") {
|
|
state.autoTimeoutPendingReview(orderId)
|
|
}
|
|
|
|
orderTimeouts.delete(orderId)
|
|
}, timeoutMs)
|
|
|
|
orderTimeouts.set(orderId, timer)
|
|
}
|
|
|
|
function notifyOrderStatus(order: Order) {
|
|
if (!useAuthStore.getState().notificationPrefs.order) {
|
|
return
|
|
}
|
|
|
|
const mapping: Partial<Record<OrderStatus, { title: string; content: string }>> = {
|
|
pending_accept: {
|
|
title: "订单待接单",
|
|
content: `${order.service.title} 已支付，等待接单`,
|
|
},
|
|
in_progress: {
|
|
title: "订单已接单",
|
|
content: `${order.playerName} 已开始服务`,
|
|
},
|
|
pending_close: {
|
|
title: "订单发起结单",
|
|
content: `订单 ${order.id} 等待确认结单`,
|
|
},
|
|
pending_review: {
|
|
title: "订单待评价",
|
|
content: "服务已结束，可提交双向评价",
|
|
},
|
|
completed: {
|
|
title: "订单已完成",
|
|
content: `订单 ${order.id} 已完成`,
|
|
},
|
|
cancelled: {
|
|
title: "订单已取消",
|
|
content: `订单 ${order.id} 已取消`,
|
|
},
|
|
disputed: {
|
|
title: "订单进入争议",
|
|
content: "已发起争议，等待平台处理",
|
|
},
|
|
}
|
|
|
|
const payload = mapping[order.status]
|
|
if (!payload) {
|
|
return
|
|
}
|
|
|
|
useNotificationStore.getState().addNotification({
|
|
type: "order",
|
|
title: payload.title,
|
|
content: payload.content,
|
|
link: `/order/${order.id}`,
|
|
})
|
|
}
|
|
|
|
export const useOrderStore = create<OrderState>((set, get) => {
|
|
const applyTransition = (
|
|
orderId: string,
|
|
action: OrderAction,
|
|
actor?: Actor,
|
|
): OrderMutationResult => {
|
|
const order = get().orders.find((item) => item.id === orderId)
|
|
if (!order) return { decision: deny(404, "订单不存在") }
|
|
|
|
const actorDecision = validateActorForAction(order, action, actor)
|
|
if (!actorDecision.ok) return { decision: actorDecision }
|
|
|
|
const transition = evaluateOrderTransition({ actor, order, action })
|
|
if (!transition.decision.ok || !transition.nextStatus) {
|
|
return { decision: transition.decision }
|
|
}
|
|
const nextStatus = transition.nextStatus
|
|
|
|
let previousOrder: Order | undefined
|
|
let updatedOrder: Order | undefined
|
|
|
|
set((state) => ({
|
|
orders: state.orders.map((item) => {
|
|
if (item.id !== orderId) return item
|
|
previousOrder = item
|
|
updatedOrder = applyStatus(item, nextStatus)
|
|
return updatedOrder
|
|
}),
|
|
}))
|
|
|
|
if (!updatedOrder || !previousOrder) {
|
|
return { decision: deny(404, "订单不存在") }
|
|
}
|
|
|
|
if (previousOrder.status !== "completed" && updatedOrder.status === "completed") {
|
|
useWalletStore
|
|
.getState()
|
|
.addIncome(updatedOrder.id, updatedOrder.totalPrice, updatedOrder.shopId)
|
|
}
|
|
|
|
if (previousOrder.status !== updatedOrder.status) {
|
|
notifyOrderStatus(updatedOrder)
|
|
}
|
|
|
|
const shouldRefund =
|
|
previousOrder.status === "pending_accept" &&
|
|
updatedOrder.status === "cancelled" &&
|
|
(action === "CANCEL_PRE_ACCEPT" || action === "AUTO_TIMEOUT_PENDING_ACCEPT")
|
|
|
|
if (shouldRefund) {
|
|
useWalletStore.getState().refundPayment(updatedOrder.id, updatedOrder.totalPrice)
|
|
}
|
|
|
|
syncChatSession(updatedOrder, previousOrder.status)
|
|
return { decision: allow(), order: updatedOrder }
|
|
}
|
|
|
|
return {
|
|
orders: [],
|
|
createOrder: (input, actor) => {
|
|
if (actor.role !== "consumer") {
|
|
return { decision: deny(403, "仅客户可下单") }
|
|
}
|
|
|
|
const consumer = useAuthStore.getState().user
|
|
if (!consumer || consumer.id !== actor.userId) {
|
|
return { decision: deny(403, "仅本人可下单") }
|
|
}
|
|
|
|
const service = useServiceStore
|
|
.getState()
|
|
.services.find((item) => item.id === input.serviceId)
|
|
if (!service) {
|
|
return { decision: deny(404, "服务不存在") }
|
|
}
|
|
|
|
const player = usePlayerStore.getState().players.find((item) => item.id === input.playerId)
|
|
if (!player) {
|
|
return { decision: deny(404, "打手不存在") }
|
|
}
|
|
|
|
if (service.playerId !== player.id) {
|
|
return { decision: deny(400, "服务与打手不匹配") }
|
|
}
|
|
|
|
const resolvedShopId = input.shopId ?? player.shopId
|
|
if (input.shopId && player.shopId && input.shopId !== player.shopId) {
|
|
return { decision: deny(400, "店铺信息与打手不匹配") }
|
|
}
|
|
|
|
const resolvedShopName = resolvedShopId
|
|
? useShopStore.getState().shops.find((item) => item.id === resolvedShopId)?.name
|
|
: undefined
|
|
|
|
const quantity = Number.isFinite(input.quantity) ? Math.floor(input.quantity) : Number.NaN
|
|
if (!quantity || quantity < 1) {
|
|
return { decision: deny(400, "数量不合法") }
|
|
}
|
|
|
|
const totalPrice = service.price * quantity
|
|
const order: Order = {
|
|
id: generateId("ord"),
|
|
consumerId: consumer.id,
|
|
consumerName: consumer.nickname,
|
|
playerId: player.id,
|
|
playerName: player.user.nickname,
|
|
shopId: resolvedShopId,
|
|
shopName: resolvedShopName,
|
|
service,
|
|
status: "pending_payment",
|
|
totalPrice,
|
|
note: input.note?.trim() ? input.note.trim() : undefined,
|
|
createdAt: new Date().toISOString(),
|
|
}
|
|
|
|
set((state) => ({
|
|
orders: [order, ...state.orders],
|
|
}))
|
|
|
|
scheduleOrderTimeout(order.id, order.status)
|
|
return { decision: allow(), order }
|
|
},
|
|
createPaidOrder: (input, actor) => {
|
|
if (actor.role !== "consumer") {
|
|
return { decision: deny(403, "仅客户可下单支付") }
|
|
}
|
|
|
|
const consumer = useAuthStore.getState().user
|
|
if (!consumer || consumer.id !== actor.userId) {
|
|
return { decision: deny(403, "仅本人可下单支付") }
|
|
}
|
|
|
|
const service = useServiceStore
|
|
.getState()
|
|
.services.find((item) => item.id === input.serviceId)
|
|
if (!service) {
|
|
return { decision: deny(404, "服务不存在") }
|
|
}
|
|
|
|
const player = usePlayerStore.getState().players.find((item) => item.id === input.playerId)
|
|
if (!player) {
|
|
return { decision: deny(404, "打手不存在") }
|
|
}
|
|
|
|
if (service.playerId !== player.id) {
|
|
return { decision: deny(400, "服务与打手不匹配") }
|
|
}
|
|
|
|
const resolvedShopId = input.shopId ?? player.shopId
|
|
if (input.shopId && player.shopId && input.shopId !== player.shopId) {
|
|
return { decision: deny(400, "店铺信息与打手不匹配") }
|
|
}
|
|
|
|
const resolvedShopName = resolvedShopId
|
|
? useShopStore.getState().shops.find((item) => item.id === resolvedShopId)?.name
|
|
: undefined
|
|
|
|
const quantity = Number.isFinite(input.quantity) ? Math.floor(input.quantity) : Number.NaN
|
|
if (!quantity || quantity < 1) {
|
|
return { decision: deny(400, "数量不合法") }
|
|
}
|
|
|
|
const totalPrice = service.price * quantity
|
|
const dedupeKey = `${consumer.id}-${service.id}`
|
|
if (pendingCreations.has(dedupeKey)) {
|
|
return { decision: deny(400, "订单正在创建中，请勿重复提交") }
|
|
}
|
|
pendingCreations.add(dedupeKey)
|
|
const orderId = generateId("ord")
|
|
const paid = useWalletStore.getState().deductBalance(orderId, totalPrice)
|
|
if (!paid) {
|
|
pendingCreations.delete(dedupeKey)
|
|
return { decision: deny(400, "余额不足或订单已支付") }
|
|
}
|
|
|
|
const order: Order = {
|
|
id: orderId,
|
|
consumerId: consumer.id,
|
|
consumerName: consumer.nickname,
|
|
playerId: player.id,
|
|
playerName: player.user.nickname,
|
|
shopId: resolvedShopId,
|
|
shopName: resolvedShopName,
|
|
service,
|
|
status: "pending_accept",
|
|
totalPrice,
|
|
note: input.note?.trim() ? input.note.trim() : undefined,
|
|
createdAt: new Date().toISOString(),
|
|
}
|
|
|
|
set((state) => ({
|
|
orders: [order, ...state.orders],
|
|
}))
|
|
|
|
useChatStore.getState().ensureOrderSession(order)
|
|
notifyOrderStatus(order)
|
|
setTimeout(() => pendingCreations.delete(dedupeKey), 2000)
|
|
return { decision: allow(), order }
|
|
},
|
|
payOrder: (orderId, actor) => {
|
|
const order = get().orders.find((item) => item.id === orderId)
|
|
if (!order) return { decision: deny(404, "订单不存在") }
|
|
const paid = useWalletStore.getState().deductBalance(orderId, order.totalPrice)
|
|
if (!paid) return { decision: deny(400, "余额不足或订单已支付") }
|
|
return applyTransition(orderId, "PAY", actor)
|
|
},
|
|
acceptOrder: (orderId, actor) => applyTransition(orderId, "ACCEPT", actor),
|
|
requestClose: (orderId, actor) => applyTransition(orderId, "REQUEST_CLOSE", actor),
|
|
confirmClose: (orderId, actor) => applyTransition(orderId, "CONFIRM_CLOSE", actor),
|
|
cancelPreAccept: (orderId, actor) => applyTransition(orderId, "CANCEL_PRE_ACCEPT", actor),
|
|
markDisputed: (orderId, actor) => applyTransition(orderId, "OPEN_DISPUTE", actor),
|
|
autoTimeoutPendingAccept: (orderId) => applyTransition(orderId, "AUTO_TIMEOUT_PENDING_ACCEPT"),
|
|
autoTimeoutPendingClose: (orderId) => applyTransition(orderId, "AUTO_TIMEOUT_PENDING_CLOSE"),
|
|
autoTimeoutPendingReview: (orderId) => applyTransition(orderId, "AUTO_TIMEOUT_PENDING_REVIEW"),
|
|
resolveDispute: (orderId) => applyTransition(orderId, "RESOLVE_DISPUTE"),
|
|
}
|
|
})
|
|
|
|
useOrderStore.subscribe((state, prevState) => {
|
|
state.orders.forEach((order) => {
|
|
const prevOrder = prevState.orders.find((item) => item.id === order.id)
|
|
if (!prevOrder || prevOrder.status !== order.status) {
|
|
scheduleOrderTimeout(order.id, order.status)
|
|
if (order.status === "pending_accept" && order.shopId) {
|
|
const shop = useShopStore.getState().shops.find((s) => s.id === order.shopId)
|
|
if (shop?.dispatchMode === "auto") {
|
|
setTimeout(() => {
|
|
const current = useOrderStore.getState().orders.find((o) => o.id === order.id)
|
|
if (!current || current.status !== "pending_accept") return
|
|
const actor: Actor = { userId: order.playerId, role: "player", shopId: order.shopId }
|
|
useOrderStore.getState().acceptOrder(order.id, actor)
|
|
}, 3000)
|
|
}
|
|
}
|
|
}
|
|
})
|
|
prevState.orders.forEach((order) => {
|
|
if (!state.orders.some((item) => item.id === order.id)) {
|
|
clearOrderTimeout(order.id)
|
|
}
|
|
})
|
|
})
|