撞车订单新增「接待中」状态，支持后台接待标记

已支付订单可标记为接待中，避免重复跟进；完成/取消覆盖接待中状态，前后台同步展示与筛选。

backend/internal/modules/mohong/dto.go

@@ -151,6 +151,10 @@ type AdminCompleteOrderRequest struct {
 	Remark string `json:"remark"`
 }
 
+type AdminReceiveOrderRequest struct {
+	Remark string `json:"remark"`
+}
+
 type AdminCancelOrderRequest struct {
 	Reason string `json:"reason"`
 }

backend/internal/modules/mohong/errors.go

@@ -11,6 +11,7 @@ var (
 	ErrOrderNotFound         = errors.New("order not found")
 	ErrOrderCannotPay        = errors.New("order cannot pay")
 	ErrOrderCannotCancel     = errors.New("order cannot cancel")
+	ErrOrderCannotReceive    = errors.New("order cannot receive")
 	ErrOrderCannotComplete   = errors.New("order cannot complete")
 	ErrUnauthorized          = errors.New("unauthorized")
 )

backend/internal/modules/mohong/handler.go

@@ -292,6 +292,21 @@ func (h *Handler) AdminGetOrder(c *gin.Context) {
 	response.OK(c, item)
 }
 
+func (h *Handler) AdminReceiveOrder(c *gin.Context) {
+	id, ok := parseID(c)
+	if !ok {
+		return
+	}
+	var req AdminReceiveOrderRequest
+	_ = c.ShouldBindJSON(&req)
+	item, err := h.service.AdminReceiveOrder(c.Request.Context(), id, req.Remark)
+	if err != nil {
+		writeError(c, err)
+		return
+	}
+	response.OK(c, item)
+}
+
 func (h *Handler) AdminCompleteOrder(c *gin.Context) {
 	id, ok := parseID(c)
 	if !ok {
@@ -357,6 +372,8 @@ func writeError(c *gin.Context, err error) {
 		response.Error(c, 409, "order_cannot_pay", "订单无法支付")
 	case errors.Is(err, ErrOrderCannotCancel):
 		response.Error(c, 409, "order_cannot_cancel", "订单无法取消")
+	case errors.Is(err, ErrOrderCannotReceive):
+		response.Error(c, 409, "order_cannot_receive", "订单无法标记为接待中")
 	case errors.Is(err, ErrOrderCannotComplete):
 		response.Error(c, 409, "order_cannot_complete", "订单无法完成")
 	case errors.Is(err, ErrInvalidRequest):

backend/internal/modules/mohong/order_repo.go

@@ -266,13 +266,15 @@ func (r *Repository) AdminCancelOrder(ctx context.Context, orderID uint64, reaso
 			}
 			return err
 		}
-		if order.Status != model.MohongOrderStatusPendingPayment && order.Status != model.MohongOrderStatusPaid {
+		if order.Status != model.MohongOrderStatusPendingPayment &&
+			order.Status != model.MohongOrderStatusPaid &&
+			order.Status != model.MohongOrderStatusReceiving {
 			return ErrOrderCannotCancel
 		}
 		if order.Status == model.MohongOrderStatusPendingPayment {
 			return r.cancelPendingOrderTx(tx, &order, firstNonEmpty(reason, "后台取消"))
 		}
-		// 已支付：仅标记取消（退款后续可接支付退款）。
+		// 已支付/接待中：仅标记取消（退款后续可接支付退款）。
 		now := time.Now()
 		order.Status = model.MohongOrderStatusCancelled
 		order.CancelledAt = &now
@@ -285,6 +287,31 @@ func (r *Repository) AdminCancelOrder(ctx context.Context, orderID uint64, reaso
 	return r.AdminFindOrder(ctx, orderID)
 }
 
+// AdminReceiveOrder 标记订单为接待中（已支付 → 接待中）。
+func (r *Repository) AdminReceiveOrder(ctx context.Context, orderID uint64, remark string) (*OrderDTO, error) {
+	err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+		var order model.MohongOrder
+		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&order, orderID).Error; err != nil {
+			if err == gorm.ErrRecordNotFound {
+				return ErrOrderNotFound
+			}
+			return err
+		}
+		if order.Status != model.MohongOrderStatusPaid {
+			return ErrOrderCannotReceive
+		}
+		order.Status = model.MohongOrderStatusReceiving
+		if strings.TrimSpace(remark) != "" {
+			order.AdminRemark = strings.TrimSpace(remark)
+		}
+		return tx.Save(&order).Error
+	})
+	if err != nil {
+		return nil, err
+	}
+	return r.AdminFindOrder(ctx, orderID)
+}
+
 func (r *Repository) AdminCompleteOrder(ctx context.Context, orderID uint64, remark string) (*OrderDTO, error) {
 	err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
 		var order model.MohongOrder
@@ -294,7 +321,7 @@ func (r *Repository) AdminCompleteOrder(ctx context.Context, orderID uint64, rem
 			}
 			return err
 		}
-		if order.Status != model.MohongOrderStatusPaid {
+		if order.Status != model.MohongOrderStatusPaid && order.Status != model.MohongOrderStatusReceiving {
 			return ErrOrderCannotComplete
 		}
 		now := time.Now()
@@ -319,6 +346,7 @@ func (r *Repository) ConfirmPaidFromChannelTx(tx *gorm.DB, orderID uint64) (uint
 		return 0, err
 	}
 	if order.Status == model.MohongOrderStatusPaid ||
+		order.Status == model.MohongOrderStatusReceiving ||
 		order.Status == model.MohongOrderStatusCompleted {
 		return 0, nil
 	}

backend/internal/modules/mohong/service.go

@@ -136,6 +136,13 @@ func (s *Service) AdminFindOrder(ctx context.Context, orderID uint64) (*OrderDTO
 	return s.repo.AdminFindOrder(ctx, orderID)
 }
 
+func (s *Service) AdminReceiveOrder(ctx context.Context, orderID uint64, remark string) (*OrderDTO, error) {
+	if s.repo == nil {
+		return nil, ErrDependencyUnavailable
+	}
+	return s.repo.AdminReceiveOrder(ctx, orderID, remark)
+}
+
 func (s *Service) AdminCompleteOrder(ctx context.Context, orderID uint64, remark string) (*OrderDTO, error) {
 	if s.repo == nil {
 		return nil, ErrDependencyUnavailable