shangbangbang/internal/handlers/user_order_message_handler.go

package handlers

import (
	"awesomeProject/internal/common"
	"awesomeProject/internal/models"
	"net/http"
	"strconv"

	"github.com/gin-gonic/gin"
	"gorm.io/gorm"
)

// UserOrderMessageHandler 用户端订单留言处理器
type UserOrderMessageHandler struct{}

// GetOrderMessages 获取订单留言列表
func (h *UserOrderMessageHandler) GetOrderMessages(c *gin.Context) {

	orderID, err := strconv.ParseUint(c.Param("order_id"), 10, 32)
	if err != nil {
		c.JSON(http.StatusOK, common.Error(400, "订单ID无效"))
		return
	}

	orderType := c.Query("type") // purchase 或 sales
	if orderType == "" {
		c.JSON(http.StatusOK, common.Error(400, "订单类型无效"))
		return
	}

	// 分页参数
	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
	pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "20"))
	if page < 1 {
		page = 1
	}
	if pageSize < 1 || pageSize > 50 {
		pageSize = 20
	}

	db := common.GetDB()
	var messages []models.OrderMessage
	var total int64

	// 如果是买单，需要同时查询买单和对应卖单的留言
	var query *gorm.DB
	if orderType == "purchase" {
		// 查找是否有对应的卖单
		var salesOrder models.SalesOrder
		err := db.Where("purchase_order_id = ?", orderID).First(&salesOrder).Error
		if err == nil {
			// 有对应卖单，查询两个订单的留言
			query = db.Model(&models.OrderMessage{}).
				Where("(order_id = ? AND order_type = ?) OR (order_id = ? AND order_type = ?)",
					orderID, "purchase", salesOrder.ID, "sales")
		} else {
			// 没有对应卖单，只查询买单留言
			query = db.Model(&models.OrderMessage{}).
				Where("order_id = ? AND order_type = ?", orderID, "purchase")
		}
	} else {
		// 卖单，查询卖单和对应买单的留言
		var salesOrder models.SalesOrder
		err := db.Where("id = ?", orderID).First(&salesOrder).Error
		if err != nil {
			c.JSON(http.StatusOK, common.Error(404, "订单不存在"))
			return
		}

		query = db.Model(&models.OrderMessage{}).
			Where("(order_id = ? AND order_type = ?) OR (order_id = ? AND order_type = ?)",
				salesOrder.ID, "sales", salesOrder.PurchaseOrderID, "purchase")
	}

	query = query.Preload("User", func(db *gorm.DB) *gorm.DB {
		return db.Select("id, customer_name, real_name, phone, system_role")
	})

	// 获取总数
	query.Count(&total)

	// 分页查询
	offset := (page - 1) * pageSize
	err = query.Order("created_at ASC").Offset(offset).Limit(pageSize).Find(&messages).Error
	if err != nil {
		c.JSON(http.StatusOK, common.Error(500, "查询留言列表失败"))
		return
	}

	// 构建返回数据
	result := map[string]interface{}{
		"list":      messages,
		"total":     total,
		"page":      page,
		"page_size": pageSize,
	}

	c.JSON(http.StatusOK, common.Success(result))
}

// CreateOrderMessage 创建订单留言
func (h *UserOrderMessageHandler) CreateOrderMessage(c *gin.Context) {
	orderID, err := strconv.ParseUint(c.Param("order_id"), 10, 32)
	if err != nil {
		c.JSON(http.StatusOK, common.Error(400, "订单ID无效"))
		return
	}

	currentUser, _ := c.Get("current_user")
	user := currentUser.(models.User)

	// 验证用户是否有权限给此订单留言
	orderType := h.getUserOrderType(uint(orderID), user.ID)
	if orderType == "" {
		c.JSON(http.StatusOK, common.Error(403, "权限不足"))
		return
	}

	var req struct {
		Content string `json:"content" binding:"required"`
		Images  string `json:"images"`
	}

	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusOK, common.Error(400, "请求参数错误"))
		return
	}

	// 验证留言内容
	if len(req.Content) > 500 {
		c.JSON(http.StatusOK, common.Error(400, "留言内容不能超过500字"))
		return
	}

	// 创建留言记录
	message := models.OrderMessage{
		OrderID:   uint(orderID),
		OrderType: orderType,
		UserID:    user.ID,
		Content:   req.Content,
		Images:    req.Images,
	}

	db := common.GetDB()
	if err := db.Create(&message).Error; err != nil {
		c.JSON(http.StatusOK, common.Error(500, "创建留言失败"))
		return
	}

	// 预加载用户信息
	db.Preload("User", func(db *gorm.DB) *gorm.DB {
		return db.Select("id, customer_name, real_name, phone")
	}).First(&message, message.ID)

	c.JSON(http.StatusOK, common.Success(message))
}

// checkOrderPermission 检查用户是否有权限访问订单留言
func (h *UserOrderMessageHandler) checkOrderPermission(orderID uint, userID uint) bool {
	db := common.GetDB()

	// 检查买单权限
	var purchaseCount int64
	db.Model(&models.PurchaseOrder{}).Where("id = ? AND buyer_id = ?", orderID, userID).Count(&purchaseCount)
	if purchaseCount > 0 {
		return true
	}

	// 检查卖单权限
	var salesCount int64
	db.Model(&models.SalesOrder{}).Where("id = ? AND seller_id = ?", orderID, userID).Count(&salesCount)
	if salesCount > 0 {
		return true
	}

	// 检查是否为买单的卖家（二级商品订单）
	var purchaseOrder models.PurchaseOrder
	if err := db.Where("id = ? AND product_type = 2", orderID).First(&purchaseOrder).Error; err == nil {
		// 查找对应的二级商品是否属于当前用户
		var secondaryCount int64
		db.Model(&models.SecondaryProduct{}).Where("id = ? AND seller_id = ?", purchaseOrder.ProductID, userID).Count(&secondaryCount)
		if secondaryCount > 0 {
			return true
		}
	}

	return false
}

// getUserOrderType 获取用户在订单中的角色类型
func (h *UserOrderMessageHandler) getUserOrderType(orderID uint, userID uint) string {
	db := common.GetDB()

	// 检查是否为买单的买家
	var purchaseCount int64
	db.Model(&models.PurchaseOrder{}).Where("id = ? AND buyer_id = ?", orderID, userID).Count(&purchaseCount)
	if purchaseCount > 0 {
		return "purchase"
	}

	// 检查是否为卖单的卖家
	var salesCount int64
	db.Model(&models.SalesOrder{}).Where("id = ? AND (seller_id = ?)", orderID, userID).Count(&salesCount)
	if salesCount > 0 || userID == 1 {
		return "sales"
	}

	// 检查是否为买单的卖家（二级商品订单）
	var purchaseOrder models.PurchaseOrder
	if err := db.Where("id = ? AND product_type = 2", orderID).First(&purchaseOrder).Error; err == nil {
		// 查找对应的二级商品是否属于当前用户
		var secondaryCount int64
		db.Model(&models.SecondaryProduct{}).Where("id = ? AND seller_id = ?", purchaseOrder.ProductID, userID).Count(&secondaryCount)
		if secondaryCount > 0 {
			return "purchase" // 对于买单的卖家，也归类为purchase类型
		}
	}

	return ""
}