806 lines
25 KiB
Go
806 lines
25 KiB
Go
package handler
|
||
|
||
import (
|
||
"dianshang/internal/model"
|
||
"dianshang/internal/service"
|
||
"dianshang/pkg/response"
|
||
"dianshang/pkg/utils"
|
||
"fmt"
|
||
"log"
|
||
|
||
"github.com/gin-gonic/gin"
|
||
)
|
||
|
||
// OrderHandler 订单处理器
|
||
type OrderHandler struct {
|
||
orderService *service.OrderService
|
||
wechatPayService *service.WeChatPayService
|
||
}
|
||
|
||
// NewOrderHandler 创建订单处理器
|
||
func NewOrderHandler(orderService *service.OrderService, wechatPayService *service.WeChatPayService) *OrderHandler {
|
||
return &OrderHandler{
|
||
orderService: orderService,
|
||
wechatPayService: wechatPayService,
|
||
}
|
||
}
|
||
|
||
// CreateOrder 创建订单
|
||
func (h *OrderHandler) CreateOrder(c *gin.Context) {
|
||
userID, exists := c.Get("user_id")
|
||
if !exists {
|
||
response.Unauthorized(c)
|
||
return
|
||
}
|
||
|
||
var req service.CreateOrderRequest
|
||
if err := c.ShouldBindJSON(&req); err != nil {
|
||
fmt.Printf("DEBUG: 订单创建请求绑定失败: %v\n", err)
|
||
fmt.Printf("DEBUG: 请求体内容: %s\n", c.Request.Body)
|
||
response.BadRequest(c, "鍙傛暟閿欒: "+err.Error())
|
||
return
|
||
}
|
||
|
||
fmt.Printf("DEBUG: 成功绑定的订单请求: AddressID=%d, Items=%+v, Remark=%s\n", req.AddressID, req.Items, req.Remark)
|
||
|
||
order, err := h.orderService.CreateOrder(userID.(uint), &req)
|
||
if err != nil {
|
||
response.ErrorWithMessage(c, response.ERROR, err.Error())
|
||
return
|
||
}
|
||
|
||
response.Success(c, order)
|
||
}
|
||
|
||
// GetUserOrders 获取用户订单列表
|
||
func (h *OrderHandler) GetUserOrders(c *gin.Context) {
|
||
userID, exists := c.Get("user_id")
|
||
if !exists {
|
||
response.Unauthorized(c)
|
||
return
|
||
}
|
||
|
||
page := utils.StringToInt(c.DefaultQuery("page", "1"))
|
||
pageSize := utils.StringToInt(c.DefaultQuery("page_size", "20"))
|
||
statusStr := c.Query("status")
|
||
status := 0
|
||
if statusStr != "" {
|
||
frontendStatus := utils.StringToInt(statusStr)
|
||
// 前端和数据库状态保持一致：
|
||
// 1=未付款, 2=已付款/待发货, 3=待发货, 4=已发货, 5=待收货, 6=已完成, 7=已取消, 8=退货中, 9=已退款
|
||
status = frontendStatus
|
||
}
|
||
|
||
orders, pagination, err := h.orderService.GetUserOrders(userID.(uint), status, page, pageSize)
|
||
if err != nil {
|
||
response.ErrorWithMessage(c, response.ERROR, err.Error())
|
||
return
|
||
}
|
||
|
||
// 格式化订单列表数据
|
||
formattedOrders := h.formatOrderList(orders)
|
||
|
||
response.Page(c, formattedOrders, pagination.Total, pagination.Page, pagination.PageSize)
|
||
}
|
||
|
||
// OrderListResponse 订单列表响应结构
|
||
type OrderListResponse struct {
|
||
ID string `json:"id"`
|
||
OrderNo string `json:"order_no"`
|
||
StoreID uint `json:"store_id"`
|
||
StoreName string `json:"store_name"`
|
||
Status int `json:"status"`
|
||
StatusName string `json:"status_name"`
|
||
TotalAmount float64 `json:"total_amount"`
|
||
PayAmount float64 `json:"pay_amount"`
|
||
PayStatus int `json:"pay_status"`
|
||
ReceiverName string `json:"receiver_name"`
|
||
ReceiverPhone string `json:"receiver_phone"`
|
||
ReceiverAddress string `json:"receiver_address"`
|
||
ExpressCompany string `json:"express_company"`
|
||
ExpressNo string `json:"express_no"`
|
||
CreatedAt string `json:"created_at"`
|
||
Items []OrderItemResponse `json:"items"`
|
||
}
|
||
|
||
// formatOrderList 格式化订单列表响应
|
||
func (h *OrderHandler) formatOrderList(orders []model.Order) []OrderListResponse {
|
||
result := make([]OrderListResponse, len(orders))
|
||
|
||
for i, order := range orders {
|
||
// 获取状态描述 - 使用统一状态机
|
||
statusName := "未知状态"
|
||
switch order.Status {
|
||
case 1:
|
||
statusName = "未付款"
|
||
case 2:
|
||
statusName = "待发货" // 统一为待发货
|
||
case 3:
|
||
statusName = "待发货" // 统一为待发货
|
||
case 4:
|
||
statusName = "已发货"
|
||
case 5:
|
||
statusName = "待收货"
|
||
case 6:
|
||
statusName = "已完成"
|
||
case 7:
|
||
statusName = "已取消"
|
||
case 8:
|
||
statusName = "退货中"
|
||
case 9:
|
||
statusName = "已退款"
|
||
}
|
||
|
||
// 格式化订单项
|
||
items := make([]OrderItemResponse, len(order.OrderItems))
|
||
for j, item := range order.OrderItems {
|
||
items[j] = OrderItemResponse{
|
||
ID: fmt.Sprintf("%d", item.ID),
|
||
OrderID: fmt.Sprintf("%d", item.OrderID),
|
||
ProductID: item.ProductID,
|
||
SpecID: item.SpecID,
|
||
SKUID: item.SKUID,
|
||
Quantity: item.Quantity,
|
||
Price: item.Price,
|
||
TotalPrice: item.TotalPrice,
|
||
ProductName: item.ProductName,
|
||
ProductImage: item.ProductImage, // 这里包含了商品图片
|
||
SpecName: item.SpecName,
|
||
SpecValue: item.SpecValue,
|
||
SpecInfo: item.SpecInfo,
|
||
}
|
||
}
|
||
|
||
// 获取店铺名称
|
||
storeName := "默认店铺"
|
||
if order.Store.Name != "" {
|
||
storeName = order.Store.Name
|
||
}
|
||
|
||
result[i] = OrderListResponse{
|
||
ID: fmt.Sprintf("%d", order.ID),
|
||
OrderNo: order.OrderNo,
|
||
StoreID: order.StoreID,
|
||
StoreName: storeName,
|
||
Status: order.Status,
|
||
StatusName: statusName,
|
||
TotalAmount: order.TotalAmount,
|
||
PayAmount: order.PayAmount,
|
||
PayStatus: order.PayStatus,
|
||
ReceiverName: order.ReceiverName,
|
||
ReceiverPhone: order.ReceiverPhone,
|
||
ReceiverAddress: order.ReceiverAddress,
|
||
ExpressCompany: order.LogisticsCompany,
|
||
ExpressNo: order.LogisticsNo,
|
||
CreatedAt: order.CreatedAt.Format("2006-01-02 15:04:05"),
|
||
Items: items,
|
||
}
|
||
}
|
||
|
||
return result
|
||
}
|
||
|
||
// OrderDetailResponse 订单详情响应结构 - 匹配前端期望格式
|
||
type OrderDetailResponse struct {
|
||
OrderID string `json:"orderId"`
|
||
OrderNo string `json:"orderNo"`
|
||
ParentOrderNo string `json:"parentOrderNo"`
|
||
StoreID uint `json:"storeId"`
|
||
StoreName string `json:"storeName"`
|
||
OrderStatus int `json:"orderStatus"`
|
||
OrderStatusName string `json:"orderStatusName"`
|
||
PaymentAmount int64 `json:"paymentAmount"`
|
||
GoodsAmountApp int64 `json:"goodsAmountApp"`
|
||
TotalAmount int64 `json:"totalAmount"`
|
||
PayAmount int64 `json:"payAmount"`
|
||
CouponAmount int64 `json:"couponAmount"`
|
||
Status int `json:"status"`
|
||
PayStatus int `json:"payStatus"`
|
||
CreatedAt string `json:"createdAt"`
|
||
LogisticsVO *LogisticsVOResponse `json:"logisticsVO"`
|
||
OrderItemVOs []OrderItemVOResponse `json:"orderItemVOs"`
|
||
ButtonVOs []OrderButtonVO `json:"buttonVOs"`
|
||
}
|
||
|
||
// OrderButtonVO 订单按钮响应结构
|
||
type OrderButtonVO struct {
|
||
Primary bool `json:"is_primary"`
|
||
Type int `json:"type"`
|
||
Name string `json:"text"`
|
||
}
|
||
|
||
// LogisticsVOResponse 物流信息响应结构
|
||
type LogisticsVOResponse struct {
|
||
LogisticsNo string `json:"logisticsNo"`
|
||
ReceiverProvince string `json:"receiverProvince"`
|
||
ReceiverCity string `json:"receiverCity"`
|
||
ReceiverCountry string `json:"receiverCountry"` // 区县
|
||
ReceiverAddress string `json:"receiverAddress"`
|
||
ReceiverName string `json:"receiverName"`
|
||
ReceiverPhone string `json:"receiverPhone"`
|
||
}
|
||
|
||
// OrderItemVOResponse 订单项响应结构
|
||
type OrderItemVOResponse struct {
|
||
ID string `json:"id"`
|
||
GoodsName string `json:"goodsName"`
|
||
GoodsPictureUrl string `json:"goodsPictureUrl"`
|
||
ActualPrice int64 `json:"actualPrice"`
|
||
OriginPrice int64 `json:"originPrice"`
|
||
BuyQuantity int `json:"buyQuantity"`
|
||
SkuID uint `json:"skuId"`
|
||
SpuID uint `json:"spuId"`
|
||
Specifications []SpecificationResponse `json:"specifications"`
|
||
ButtonVOs []interface{} `json:"buttonVOs"`
|
||
}
|
||
|
||
// SpecificationResponse 规格响应结构
|
||
type SpecificationResponse struct {
|
||
SpecTitle string `json:"specTitle"`
|
||
SpecValue string `json:"specValue"`
|
||
}
|
||
|
||
// AddressResponse 地址响应结构
|
||
type AddressResponse struct {
|
||
Name string `json:"name"`
|
||
Phone string `json:"phone"`
|
||
Province string `json:"province"`
|
||
City string `json:"city"`
|
||
District string `json:"district"`
|
||
Detail string `json:"detail"`
|
||
FullAddress string `json:"full_address"`
|
||
}
|
||
|
||
// OrderItemResponse 订单项响应结构
|
||
type OrderItemResponse struct {
|
||
ID string `json:"id"`
|
||
OrderID string `json:"order_id"`
|
||
ProductID uint `json:"product_id"`
|
||
SpecID *uint `json:"spec_id"`
|
||
SKUID *uint `json:"sku_id"`
|
||
Quantity int `json:"quantity"`
|
||
Price float64 `json:"price"`
|
||
TotalPrice float64 `json:"total_price"`
|
||
ProductName string `json:"product_name"`
|
||
ProductImage string `json:"product_image"`
|
||
SpecName string `json:"spec_name"`
|
||
SpecValue string `json:"spec_value"`
|
||
SpecInfo map[string]interface{} `json:"spec_info"`
|
||
Product *ProductResponse `json:"product,omitempty"`
|
||
SKU *SKUResponse `json:"sku,omitempty"`
|
||
}
|
||
|
||
// ProductResponse 商品响应结构
|
||
type ProductResponse struct {
|
||
ID uint `json:"id"`
|
||
Name string `json:"name"`
|
||
MainImage string `json:"main_image"`
|
||
}
|
||
|
||
// SKUResponse SKU响应结构
|
||
type SKUResponse struct {
|
||
ID uint `json:"id"`
|
||
Name string `json:"name"`
|
||
Value string `json:"value"`
|
||
}
|
||
|
||
// StoreResponse 店铺响应结构
|
||
type StoreResponse struct {
|
||
ID uint `json:"id"`
|
||
Name string `json:"name"`
|
||
}
|
||
|
||
// GetOrderDetail 获取订单详情（支持订单ID、订单号、微信订单号）
|
||
// 参数 id 可以是：
|
||
// 1. 订单ID（纯数字）
|
||
// 2. 订单号（如：WX20251111134319259VLQCPCC1）
|
||
// 3. 微信支付订单号（如：wx1234567890abcdef）
|
||
func (h *OrderHandler) GetOrderDetail(c *gin.Context) {
|
||
userID, exists := c.Get("user_id")
|
||
if !exists {
|
||
response.Unauthorized(c)
|
||
return
|
||
}
|
||
|
||
idStr := c.Param("id")
|
||
|
||
// 尝试解析为uint，如果失败则当作订单号或微信订单号处理
|
||
orderID := utils.StringToUint(idStr)
|
||
if orderID == 0 {
|
||
// 当作订单号或微信订单号处理（service层会自动判断）
|
||
order, err := h.orderService.GetOrderDetailByOrderNo(userID.(uint), idStr)
|
||
if err != nil {
|
||
response.ErrorWithMessage(c, response.ERROR_ORDER_NOT_FOUND, err.Error())
|
||
return
|
||
}
|
||
response.Success(c, h.formatOrderDetail(order))
|
||
return
|
||
}
|
||
|
||
// 当作订单ID处理
|
||
order, err := h.orderService.GetOrderDetail(userID.(uint), orderID)
|
||
if err != nil {
|
||
response.ErrorWithMessage(c, response.ERROR_ORDER_NOT_FOUND, err.Error())
|
||
return
|
||
}
|
||
|
||
response.Success(c, h.formatOrderDetail(order))
|
||
}
|
||
|
||
// formatOrderDetail 格式化订单详情响应
|
||
func (h *OrderHandler) formatOrderDetail(order *model.Order) *OrderDetailResponse {
|
||
// 构建物流信息对象
|
||
logisticsVO := &LogisticsVOResponse{
|
||
LogisticsNo: order.LogisticsNo,
|
||
ReceiverProvince: "", // 省份，如果有的话
|
||
ReceiverCity: "", // 城市，如果有的话
|
||
ReceiverCountry: "", // 区县，如果有的话
|
||
ReceiverAddress: order.ReceiverAddress,
|
||
ReceiverName: order.ReceiverName,
|
||
ReceiverPhone: order.ReceiverPhone,
|
||
}
|
||
|
||
// 构建订单项列表
|
||
orderItemVOs := make([]OrderItemVOResponse, len(order.OrderItems))
|
||
for i, item := range order.OrderItems {
|
||
// 构建规格信息数组
|
||
specifications := []SpecificationResponse{}
|
||
if item.SpecInfo != nil {
|
||
// JSONMap 就是 map[string]interface{}
|
||
for key, value := range item.SpecInfo {
|
||
if value != nil {
|
||
specifications = append(specifications, SpecificationResponse{
|
||
SpecTitle: key,
|
||
SpecValue: fmt.Sprintf("%v", value),
|
||
})
|
||
}
|
||
}
|
||
}
|
||
|
||
var skuID uint
|
||
if item.SKUID != nil {
|
||
skuID = *item.SKUID
|
||
}
|
||
|
||
orderItemVOs[i] = OrderItemVOResponse{
|
||
ID: fmt.Sprintf("%d", item.ID),
|
||
GoodsName: item.ProductName,
|
||
GoodsPictureUrl: item.ProductImage,
|
||
ActualPrice: int64(item.Price), // 数据库已存储元为单位，无需乘100
|
||
OriginPrice: int64(item.Price), // 数据库已存储元为单位，无需乘100
|
||
BuyQuantity: item.Quantity,
|
||
SkuID: skuID,
|
||
SpuID: item.ProductID,
|
||
Specifications: specifications,
|
||
ButtonVOs: []interface{}{}, // 空数组
|
||
}
|
||
}
|
||
|
||
// 获取状态描述 - 使用统一状态机
|
||
statusName := "未知状态"
|
||
switch order.Status {
|
||
case 1:
|
||
statusName = "未付款"
|
||
case 2:
|
||
statusName = "待发货" // 统一为待发货
|
||
case 3:
|
||
statusName = "待发货" // 统一为待发货
|
||
case 4:
|
||
statusName = "已发货"
|
||
case 5:
|
||
statusName = "待收货"
|
||
case 6:
|
||
statusName = "已完成"
|
||
case 7:
|
||
statusName = "已取消"
|
||
case 8:
|
||
statusName = "退货中"
|
||
case 9:
|
||
statusName = "已退款"
|
||
}
|
||
|
||
// 生成订单操作按钮
|
||
buttonVOs := generateOrderButtons(order.Status, order)
|
||
|
||
return &OrderDetailResponse{
|
||
OrderID: fmt.Sprintf("%d", order.ID),
|
||
OrderNo: order.OrderNo,
|
||
ParentOrderNo: order.OrderNo, // 如果没有父订单号，使用订单号
|
||
StoreID: order.StoreID,
|
||
StoreName: order.Store.Name,
|
||
OrderStatus: order.Status,
|
||
OrderStatusName: statusName,
|
||
PaymentAmount: int64(order.PayAmount), // 数据库已存储元为单位，无需乘100
|
||
GoodsAmountApp: int64(order.TotalAmount), // 数据库已存储元为单位，无需乘100
|
||
TotalAmount: int64(order.TotalAmount), // 数据库已存储元为单位，无需乘100
|
||
PayAmount: int64(order.PayAmount), // 数据库已存储元为单位，无需乘100
|
||
CouponAmount: int64(order.CouponAmount), // 直接返回数据库数据
|
||
Status: order.Status,
|
||
PayStatus: order.PayStatus,
|
||
CreatedAt: order.CreatedAt.Format("2006-01-02 15:04:05"),
|
||
LogisticsVO: logisticsVO,
|
||
OrderItemVOs: orderItemVOs,
|
||
ButtonVOs: buttonVOs,
|
||
}
|
||
}
|
||
|
||
// PayOrder 支付订单
|
||
func (h *OrderHandler) PayOrder(c *gin.Context) {
|
||
userID, exists := c.Get("user_id")
|
||
if !exists {
|
||
response.Unauthorized(c)
|
||
return
|
||
}
|
||
|
||
// 从URL路径参数获取订单号
|
||
orderNo := c.Param("id")
|
||
if orderNo == "" {
|
||
response.BadRequest(c, "订单号不能为空")
|
||
return
|
||
}
|
||
|
||
// 解析请求体获取支付方式
|
||
var req struct {
|
||
PaymentMethod string `json:"payment_method"`
|
||
}
|
||
if err := c.ShouldBindJSON(&req); err != nil {
|
||
// 如果没有提供支付方式，默认使用微信支付
|
||
req.PaymentMethod = "wechat"
|
||
}
|
||
|
||
// 获取订单详情
|
||
order, err := h.orderService.GetOrderByOrderNo(orderNo)
|
||
if err != nil {
|
||
response.ErrorWithMessage(c, response.ERROR, "订单不存在")
|
||
return
|
||
}
|
||
|
||
// 验证订单归属
|
||
if order.UserID != userID.(uint) {
|
||
response.ErrorWithMessage(c, response.ERROR, "无权限操作此订单")
|
||
return
|
||
}
|
||
|
||
// 验证订单状态
|
||
if order.Status != 1 { // 1 = 待付款
|
||
response.ErrorWithMessage(c, response.ERROR, "订单状态不允许支付")
|
||
return
|
||
}
|
||
|
||
// 如果是微信支付，返回支付二维码
|
||
if req.PaymentMethod == "wechat" {
|
||
// 调用微信Native扫码支付
|
||
if h.wechatPayService != nil {
|
||
paymentResp, err := h.wechatPayService.CreateNativeOrder(c.Request.Context(), order)
|
||
if err != nil {
|
||
response.ErrorWithMessage(c, response.ERROR, err.Error())
|
||
return
|
||
}
|
||
|
||
response.Success(c, paymentResp.Data)
|
||
return
|
||
} else {
|
||
// 如果没有微信支付服务，返回模拟数据
|
||
response.Success(c, gin.H{
|
||
"qrcode_url": "https://api.example.com/qrcode/" + orderNo,
|
||
"order_no": orderNo,
|
||
"amount": order.TotalAmount,
|
||
"sandbox": true,
|
||
})
|
||
return
|
||
}
|
||
}
|
||
|
||
// 其他支付方式，直接标记为已支付
|
||
if err := h.orderService.PayOrder(userID.(uint), orderNo); err != nil {
|
||
response.ErrorWithMessage(c, response.ERROR, err.Error())
|
||
return
|
||
}
|
||
|
||
response.Success(c, nil)
|
||
}
|
||
|
||
// CancelOrder 取消订单
|
||
func (h *OrderHandler) CancelOrder(c *gin.Context) {
|
||
userID, exists := c.Get("user_id")
|
||
if !exists {
|
||
response.Unauthorized(c)
|
||
return
|
||
}
|
||
|
||
var req struct {
|
||
OrderNo string `json:"order_no" binding:"required"`
|
||
}
|
||
if err := c.ShouldBindJSON(&req); err != nil {
|
||
response.BadRequest(c, "鍙傛暟閿欒: "+err.Error())
|
||
return
|
||
}
|
||
|
||
if err := h.orderService.CancelOrder(userID.(uint), req.OrderNo); err != nil {
|
||
response.ErrorWithMessage(c, response.ERROR, err.Error())
|
||
return
|
||
}
|
||
|
||
response.Success(c, nil)
|
||
}
|
||
|
||
// RemindShip 提醒发货
|
||
func (h *OrderHandler) RemindShip(c *gin.Context) {
|
||
log.Printf("[后端处理] ===== 提醒发货请求开始 =====")
|
||
|
||
userID, exists := c.Get("user_id")
|
||
if !exists {
|
||
log.Printf("[后端处理] 提醒发货失败: 用户未认证")
|
||
response.Unauthorized(c)
|
||
return
|
||
}
|
||
|
||
// 从URL路径参数获取订单号
|
||
orderNo := c.Param("id")
|
||
log.Printf("[后端处理] 提醒发货请求参数: userID=%v, orderNo=%s", userID, orderNo)
|
||
|
||
if orderNo == "" {
|
||
log.Printf("[后端处理] 提醒发货失败: 订单号为空")
|
||
response.BadRequest(c, "订单号不能为空")
|
||
return
|
||
}
|
||
|
||
log.Printf("[后端处理] 调用服务层提醒发货方法...")
|
||
if err := h.orderService.RemindShip(userID.(uint), orderNo); err != nil {
|
||
log.Printf("[后端处理] 提醒发货失败: %v", err)
|
||
response.ErrorWithMessage(c, response.ERROR, err.Error())
|
||
return
|
||
}
|
||
|
||
log.Printf("[后端处理] 提醒发货成功")
|
||
response.Success(c, gin.H{"message": "提醒发货成功"})
|
||
}
|
||
|
||
// ConfirmReceive方法前的注释
|
||
func (h *OrderHandler) RefundOrder(c *gin.Context) {
|
||
log.Printf("[后端处理] ===== 退款申请请求开始 =====")
|
||
|
||
userID, exists := c.Get("user_id")
|
||
if !exists {
|
||
log.Printf("[后端处理] 退款申请失败: 用户未认证")
|
||
response.Unauthorized(c)
|
||
return
|
||
}
|
||
|
||
// 从URL路径参数获取订单号
|
||
orderNo := c.Param("id")
|
||
log.Printf("[后端处理] 退款申请请求参数: userID=%v, orderNo=%s", userID, orderNo)
|
||
|
||
if orderNo == "" {
|
||
log.Printf("[后端处理] 退款申请失败: 订单号为空")
|
||
response.BadRequest(c, "订单号不能为空")
|
||
return
|
||
}
|
||
|
||
log.Printf("[后端处理] 调用服务层退款申请方法...")
|
||
// 调用服务层的退款方法
|
||
if err := h.orderService.RefundOrderDuplicate(userID.(uint), orderNo); err != nil {
|
||
log.Printf("[后端处理] 退款申请失败: %v", err)
|
||
response.ErrorWithMessage(c, response.ERROR, err.Error())
|
||
return
|
||
}
|
||
|
||
log.Printf("[后端处理] 退款申请成功")
|
||
response.Success(c, gin.H{"message": "退款申请已提交"})
|
||
}
|
||
|
||
// ConfirmReceive 确认收货
|
||
func (h *OrderHandler) ConfirmReceive(c *gin.Context) {
|
||
userID, exists := c.Get("user_id")
|
||
if !exists {
|
||
response.Unauthorized(c)
|
||
return
|
||
}
|
||
|
||
var req struct {
|
||
OrderNo string `json:"order_no" binding:"required"`
|
||
}
|
||
if err := c.ShouldBindJSON(&req); err != nil {
|
||
response.BadRequest(c, "鍙傛暟閿欒: "+err.Error())
|
||
return
|
||
}
|
||
|
||
if err := h.orderService.ConfirmReceive(userID.(uint), req.OrderNo); err != nil {
|
||
response.ErrorWithMessage(c, response.ERROR, err.Error())
|
||
return
|
||
}
|
||
|
||
response.Success(c, nil)
|
||
}
|
||
|
||
// GetOrderList 获取订单列表（支持条件查询）
|
||
func (h *OrderHandler) GetOrderList(c *gin.Context) {
|
||
page := utils.StringToInt(c.DefaultQuery("page", "1"))
|
||
pageSize := utils.StringToInt(c.DefaultQuery("page_size", "20"))
|
||
|
||
conditions := make(map[string]interface{})
|
||
if status := c.Query("status"); status != "" {
|
||
conditions["status"] = utils.StringToInt(status)
|
||
}
|
||
if userID := c.Query("user_id"); userID != "" {
|
||
conditions["user_id"] = utils.StringToUint(userID)
|
||
}
|
||
if orderNo := c.Query("order_no"); orderNo != "" {
|
||
conditions["order_no"] = orderNo
|
||
}
|
||
if startDate := c.Query("start_date"); startDate != "" {
|
||
conditions["start_date"] = startDate
|
||
}
|
||
if endDate := c.Query("end_date"); endDate != "" {
|
||
conditions["end_date"] = endDate
|
||
}
|
||
|
||
orders, pagination, err := h.orderService.GetOrderList(page, pageSize, conditions)
|
||
if err != nil {
|
||
response.ErrorWithMessage(c, response.ERROR, err.Error())
|
||
return
|
||
}
|
||
|
||
response.Page(c, orders, pagination.Total, pagination.Page, pagination.PageSize)
|
||
}
|
||
|
||
// ShipOrder 发货
|
||
func (h *OrderHandler) ShipOrder(c *gin.Context) {
|
||
var req struct {
|
||
OrderNo string `json:"order_no" binding:"required"`
|
||
LogisticsCompany string `json:"logistics_company" binding:"required"`
|
||
LogisticsNo string `json:"logistics_no" binding:"required"`
|
||
}
|
||
if err := c.ShouldBindJSON(&req); err != nil {
|
||
response.BadRequest(c, "鍙傛暟閿欒: "+err.Error())
|
||
return
|
||
}
|
||
|
||
if err := h.orderService.ShipOrder(req.OrderNo, req.LogisticsCompany, req.LogisticsNo); err != nil {
|
||
response.ErrorWithMessage(c, response.ERROR, err.Error())
|
||
return
|
||
}
|
||
|
||
response.Success(c, nil)
|
||
}
|
||
|
||
// GetOrderStatistics 获取订单统计
|
||
func (h *OrderHandler) GetOrderStatistics(c *gin.Context) {
|
||
statistics, err := h.orderService.GetOrderStatistics()
|
||
if err != nil {
|
||
response.ErrorWithMessage(c, response.ERROR, err.Error())
|
||
return
|
||
}
|
||
|
||
response.Success(c, statistics)
|
||
}
|
||
|
||
// GetDailyOrderStatistics 获取每日订单统计
|
||
func (h *OrderHandler) GetDailyOrderStatistics(c *gin.Context) {
|
||
days := utils.StringToInt(c.DefaultQuery("days", "30"))
|
||
|
||
statistics, err := h.orderService.GetDailyOrderStatistics(days)
|
||
if err != nil {
|
||
response.ErrorWithMessage(c, response.ERROR, err.Error())
|
||
return
|
||
}
|
||
|
||
response.Success(c, statistics)
|
||
}
|
||
|
||
// MergeOrders 合并订单
|
||
func (h *OrderHandler) MergeOrders(c *gin.Context) {
|
||
userID, exists := c.Get("user_id")
|
||
if !exists {
|
||
response.Unauthorized(c)
|
||
return
|
||
}
|
||
|
||
var req service.MergeOrdersRequest
|
||
if err := c.ShouldBindJSON(&req); err != nil {
|
||
response.BadRequest(c, "参数错误: "+err.Error())
|
||
return
|
||
}
|
||
|
||
// 验证订单数量
|
||
if len(req.OrderIDs) < 2 {
|
||
response.BadRequest(c, "至少需要选择2个订单进行合并")
|
||
return
|
||
}
|
||
|
||
mergedOrder, err := h.orderService.MergeOrders(userID.(uint), &req)
|
||
if err != nil {
|
||
response.ErrorWithMessage(c, response.ERROR, err.Error())
|
||
return
|
||
}
|
||
|
||
response.Success(c, gin.H{
|
||
"message": "订单合并成功",
|
||
"order": mergedOrder,
|
||
})
|
||
}
|
||
|
||
// generateOrderButtons 根据订单状态生成操作按钮
|
||
func generateOrderButtons(status int, order *model.Order) []OrderButtonVO {
|
||
log.Printf("[后端按钮生成] ===== 开始生成按钮 =====")
|
||
log.Printf("[后端按钮生成] 输入状态: %d", status)
|
||
|
||
var buttons []OrderButtonVO
|
||
|
||
switch status {
|
||
case 1: // 待付款
|
||
log.Printf("[后端按钮生成] 状态1-待付款: 生成取消订单(type=1)和立即付款(type=2)按钮")
|
||
buttons = []OrderButtonVO{
|
||
{Primary: false, Type: 1, Name: "取消订单"},
|
||
{Primary: true, Type: 2, Name: "立即付款"},
|
||
}
|
||
case 2: // 已付款/待发货
|
||
log.Printf("[后端按钮生成] 状态2-已付款/待发货: 生成申请退款(type=7)和提醒发货(type=3)按钮")
|
||
buttons = []OrderButtonVO{
|
||
{Primary: false, Type: 7, Name: "申请退款"},
|
||
{Primary: true, Type: 3, Name: "提醒发货"},
|
||
}
|
||
case 3: // 待发货
|
||
log.Printf("[后端按钮生成] 状态3-待发货: 生成申请退款(type=7)和提醒发货(type=3)按钮")
|
||
buttons = []OrderButtonVO{
|
||
{Primary: false, Type: 7, Name: "申请退款"},
|
||
{Primary: true, Type: 3, Name: "提醒发货"},
|
||
}
|
||
case 4: // 已发货/待收货
|
||
log.Printf("[后端按钮生成] 状态4-已发货/待收货: 生成确认收货(type=4)按钮")
|
||
buttons = []OrderButtonVO{
|
||
{Primary: true, Type: 4, Name: "确认收货"},
|
||
}
|
||
case 5: // 待收货
|
||
log.Printf("[后端按钮生成] 状态5-待收货: 生成确认收货(type=4)按钮")
|
||
buttons = []OrderButtonVO{
|
||
{Primary: true, Type: 4, Name: "确认收货"},
|
||
}
|
||
case 6: // 已完成
|
||
log.Printf("[后端按钮生成] 状态6-已完成: 检查是否有未评价的订单项")
|
||
|
||
// 检查是否有未评价的订单项
|
||
hasUncommentedItems := false
|
||
for _, item := range order.OrderItems {
|
||
if !item.IsCommented {
|
||
hasUncommentedItems = true
|
||
log.Printf("[后端按钮生成] 发现未评价的订单项: ID=%d, ProductID=%d", item.ID, item.ProductID)
|
||
break
|
||
}
|
||
}
|
||
|
||
if hasUncommentedItems {
|
||
log.Printf("[后端按钮生成] 状态6-已完成: 有未评价订单项，生成申请售后(type=5)和评价(type=6)按钮")
|
||
buttons = []OrderButtonVO{
|
||
{Primary: false, Type: 5, Name: "申请售后"},
|
||
{Primary: true, Type: 6, Name: "评价"},
|
||
}
|
||
} else {
|
||
log.Printf("[后端按钮生成] 状态6-已完成: 所有订单项已评价，只生成申请售后(type=5)按钮")
|
||
buttons = []OrderButtonVO{
|
||
{Primary: false, Type: 5, Name: "申请售后"},
|
||
}
|
||
}
|
||
case 7: // 已取消
|
||
log.Printf("[后端按钮生成] 状态7-已取消: 不生成任何按钮")
|
||
buttons = []OrderButtonVO{}
|
||
case 8: // 退货中
|
||
log.Printf("[后端按钮生成] 状态8-退货中: 不生成任何按钮")
|
||
buttons = []OrderButtonVO{}
|
||
case 9: // 已退款
|
||
log.Printf("[后端按钮生成] 状态9-已退款: 不生成任何按钮")
|
||
buttons = []OrderButtonVO{}
|
||
default:
|
||
log.Printf("[后端按钮生成] 未知状态%d: 不生成任何按钮", status)
|
||
buttons = []OrderButtonVO{}
|
||
}
|
||
|
||
log.Printf("[后端按钮生成] ===== 按钮生成完成 =====")
|
||
log.Printf("[后端按钮生成] 生成的按钮数量: %d", len(buttons))
|
||
for i, btn := range buttons {
|
||
log.Printf("[后端按钮生成] 按钮%d: type=%d, name=%s, primary=%t", i, btn.Type, btn.Name, btn.Primary)
|
||
}
|
||
|
||
return buttons
|
||
}
|