solosw
632 lines
18 KiB
Go
632 lines
18 KiB
Go
package handlers
|
|
|
|
import (
|
|
"awesomeProject/internal/common"
|
|
"awesomeProject/internal/models"
|
|
"fmt"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"gorm.io/gorm"
|
|
"net/http"
|
|
)
|
|
|
|
// AdminOrderHandler 管理端订单处理器
|
|
type AdminOrderHandler struct{}
|
|
|
|
// GetPurchaseOrders 获取买单列表
|
|
func (h *AdminOrderHandler) GetPurchaseOrders(c *gin.Context) {
|
|
currentUser, _ := c.Get("current_user")
|
|
user := currentUser.(models.User)
|
|
|
|
// 分页参数
|
|
page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
|
|
pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "10"))
|
|
if page < 1 {
|
|
page = 1
|
|
}
|
|
if pageSize < 1 || pageSize > 100 {
|
|
pageSize = 10
|
|
}
|
|
|
|
// 搜索参数
|
|
orderNo := c.Query("order_no")
|
|
orderStatus := c.Query("order_status")
|
|
productType := c.Query("product_type")
|
|
sellerName := c.Query("seller_name")
|
|
buyerName := c.Query("buyer_name")
|
|
|
|
db := common.GetDB()
|
|
var orders []models.PurchaseOrder
|
|
var total int64
|
|
|
|
// 构建查询条件
|
|
query := db.Model(&models.PurchaseOrder{}).Preload("Buyer").Preload("Seller").Preload("Address")
|
|
|
|
// 如果是代理商，只能查看自己邀请的用户的订单
|
|
if user.SystemRole == 1 {
|
|
// 子查询：获取代理商邀请的用户ID列表
|
|
subQuery := db.Model(&models.User{}).Select("id").Where("referrer_identity_code = ?", user.IdentityCode)
|
|
query = query.Where("buyer_id IN (?)", subQuery)
|
|
}
|
|
|
|
// 添加搜索条件
|
|
if orderNo != "" {
|
|
query = query.Where("order_no LIKE ?", "%"+orderNo+"%")
|
|
}
|
|
if orderStatus != "" {
|
|
query = query.Where("order_status = ?", orderStatus)
|
|
}
|
|
if productType != "" {
|
|
query = query.Where("product_type = ?", productType)
|
|
}
|
|
if sellerName != "" {
|
|
query = query.Joins("LEFT JOIN users AS sellers ON purchase_orders.seller_id = sellers.id").
|
|
Where("sellers.real_name LIKE ? OR sellers.phone LIKE ?", "%"+sellerName+"%", "%"+sellerName+"%")
|
|
}
|
|
if buyerName != "" {
|
|
query = query.Joins("LEFT JOIN users AS buyers ON purchase_orders.buyer_id = buyers.id").
|
|
Where("buyers.real_name LIKE ? OR buyers.phone LIKE ?", "%"+buyerName+"%", "%"+buyerName+"%")
|
|
}
|
|
|
|
// 获取总数
|
|
query.Count(&total)
|
|
|
|
// 分页查询
|
|
offset := (page - 1) * pageSize
|
|
err := query.Offset(offset).Limit(pageSize).Order("created_at DESC").Find(&orders).Error
|
|
if err != nil {
|
|
c.JSON(http.StatusOK, common.Error(500, "查询买单列表失败"))
|
|
return
|
|
}
|
|
|
|
// 构建返回数据
|
|
result := map[string]interface{}{
|
|
"list": orders,
|
|
"total": total,
|
|
"page": page,
|
|
"page_size": pageSize,
|
|
}
|
|
|
|
c.JSON(http.StatusOK, common.Success(result))
|
|
}
|
|
|
|
// GetSalesOrders 获取卖单列表
|
|
func (h *AdminOrderHandler) GetSalesOrders(c *gin.Context) {
|
|
currentUser, _ := c.Get("current_user")
|
|
user := currentUser.(models.User)
|
|
|
|
// 分页参数
|
|
page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
|
|
pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "10"))
|
|
if page < 1 {
|
|
page = 1
|
|
}
|
|
if pageSize < 1 || pageSize > 100 {
|
|
pageSize = 10
|
|
}
|
|
|
|
// 搜索参数
|
|
orderNo := c.Query("order_no")
|
|
orderStatus := c.Query("order_status")
|
|
sellerName := c.Query("seller_name")
|
|
buyerName := c.Query("buyer_name")
|
|
|
|
db := common.GetDB()
|
|
var orders []models.SalesOrder
|
|
var total int64
|
|
|
|
// 构建查询条件
|
|
query := db.Model(&models.SalesOrder{}).Preload("Seller").Preload("Buyer").Preload("SecondaryProduct").Preload("Address")
|
|
|
|
// 如果是代理商，只能查看自己邀请的用户相关的订单
|
|
if user.SystemRole == 1 {
|
|
// 子查询：获取代理商邀请的用户ID列表
|
|
subQuery := db.Model(&models.User{}).Select("id").Where("referrer_identity_code = ?", user.IdentityCode)
|
|
query = query.Where("buyer_id IN (?) OR seller_id IN (?)", subQuery, subQuery)
|
|
}
|
|
|
|
// 添加搜索条件
|
|
if orderNo != "" {
|
|
query = query.Where("order_no LIKE ?", "%"+orderNo+"%")
|
|
}
|
|
if orderStatus != "" {
|
|
query = query.Where("order_status = ?", orderStatus)
|
|
}
|
|
if sellerName != "" {
|
|
query = query.Joins("LEFT JOIN users AS sellers ON sales_orders.seller_id = sellers.id").
|
|
Where("sellers.real_name LIKE ? OR sellers.phone LIKE ?", "%"+sellerName+"%", "%"+sellerName+"%")
|
|
}
|
|
if buyerName != "" {
|
|
query = query.Joins("LEFT JOIN users AS buyers ON sales_orders.buyer_id = buyers.id").
|
|
Where("buyers.real_name LIKE ? OR buyers.phone LIKE ?", "%"+buyerName+"%", "%"+buyerName+"%")
|
|
}
|
|
|
|
// 获取总数
|
|
query.Count(&total)
|
|
|
|
// 分页查询
|
|
offset := (page - 1) * pageSize
|
|
err := query.Offset(offset).Limit(pageSize).Order("created_at DESC").Find(&orders).Error
|
|
if err != nil {
|
|
c.JSON(http.StatusOK, common.Error(500, "查询卖单列表失败"))
|
|
return
|
|
}
|
|
|
|
// 构建返回数据
|
|
result := map[string]interface{}{
|
|
"list": orders,
|
|
"total": total,
|
|
"page": page,
|
|
"page_size": pageSize,
|
|
}
|
|
|
|
c.JSON(http.StatusOK, common.Success(result))
|
|
}
|
|
|
|
// GetPurchaseOrder 获取单个买单详情
|
|
func (h *AdminOrderHandler) GetPurchaseOrder(c *gin.Context) {
|
|
orderID, err := strconv.ParseUint(c.Param("id"), 10, 32)
|
|
if err != nil {
|
|
c.JSON(http.StatusOK, common.Error(400, "订单ID无效"))
|
|
return
|
|
}
|
|
|
|
currentUser, _ := c.Get("current_user")
|
|
user := currentUser.(models.User)
|
|
|
|
var order models.PurchaseOrder
|
|
query := common.GetDB().Preload("Buyer").Preload("Seller").Preload("Address")
|
|
|
|
err = query.First(&order, uint(orderID)).Error
|
|
if err != nil {
|
|
if err == gorm.ErrRecordNotFound {
|
|
c.JSON(http.StatusOK, common.Error(404, "订单不存在"))
|
|
} else {
|
|
c.JSON(http.StatusOK, common.Error(500, "查询订单详情失败"))
|
|
}
|
|
return
|
|
}
|
|
|
|
// 如果是代理商，检查权限
|
|
if user.SystemRole == 1 {
|
|
// 检查买家是否为代理商邀请的用户
|
|
if order.Buyer.ReferrerIdentityCode != user.IdentityCode {
|
|
c.JSON(http.StatusOK, common.Error(403, "权限不足"))
|
|
return
|
|
}
|
|
}
|
|
|
|
c.JSON(http.StatusOK, common.Success(order))
|
|
}
|
|
|
|
// GetSalesOrder 获取单个卖单详情
|
|
func (h *AdminOrderHandler) GetSalesOrder(c *gin.Context) {
|
|
orderID, err := strconv.ParseUint(c.Param("id"), 10, 32)
|
|
if err != nil {
|
|
c.JSON(http.StatusOK, common.Error(400, "订单ID无效"))
|
|
return
|
|
}
|
|
|
|
currentUser, _ := c.Get("current_user")
|
|
user := currentUser.(models.User)
|
|
|
|
var order models.SalesOrder
|
|
query := common.GetDB().Preload("Seller").Preload("Buyer").Preload("SecondaryProduct").Preload("Address")
|
|
|
|
err = query.First(&order, uint(orderID)).Error
|
|
if err != nil {
|
|
if err == gorm.ErrRecordNotFound {
|
|
c.JSON(http.StatusOK, common.Error(404, "订单不存在"))
|
|
} else {
|
|
c.JSON(http.StatusOK, common.Error(500, "查询订单详情失败"))
|
|
}
|
|
return
|
|
}
|
|
|
|
// 如果是代理商，检查权限
|
|
if user.SystemRole == 1 {
|
|
// 检查买家或卖家是否为代理商邀请的用户
|
|
if order.Buyer.ReferrerIdentityCode != user.IdentityCode && order.Seller.ReferrerIdentityCode != user.IdentityCode {
|
|
c.JSON(http.StatusOK, common.Error(403, "权限不足"))
|
|
return
|
|
}
|
|
}
|
|
|
|
c.JSON(http.StatusOK, common.Success(order))
|
|
}
|
|
|
|
// UpdatePurchaseOrderStatus 更新买单状态（仅管理员）
|
|
func (h *AdminOrderHandler) UpdatePurchaseOrderStatus(c *gin.Context) {
|
|
currentUser, _ := c.Get("current_user")
|
|
user := currentUser.(models.User)
|
|
|
|
// 只有管理员可以更新订单状态
|
|
if user.SystemRole != 0 {
|
|
c.JSON(http.StatusOK, common.Error(403, "权限不足"))
|
|
return
|
|
}
|
|
|
|
orderID, err := strconv.ParseUint(c.Param("id"), 10, 32)
|
|
if err != nil {
|
|
c.JSON(http.StatusOK, common.Error(400, "订单ID无效"))
|
|
return
|
|
}
|
|
|
|
var updateData struct {
|
|
OrderStatus uint8 `json:"order_status" binding:"required"`
|
|
Remark string `json:"remark"`
|
|
}
|
|
|
|
if err := c.ShouldBindJSON(&updateData); err != nil {
|
|
c.JSON(http.StatusOK, common.Error(400, "参数错误: "+err.Error()))
|
|
return
|
|
}
|
|
|
|
db := common.GetDB()
|
|
tx := db.Begin()
|
|
|
|
// 检查订单是否存在
|
|
var order models.PurchaseOrder
|
|
if err := tx.First(&order, uint(orderID)).Error; err != nil {
|
|
tx.Rollback()
|
|
c.JSON(http.StatusOK, common.Error(404, "订单不存在"))
|
|
return
|
|
}
|
|
|
|
// 更新订单状态
|
|
updateFields := map[string]interface{}{
|
|
"order_status": updateData.OrderStatus,
|
|
"remark": updateData.Remark,
|
|
}
|
|
|
|
// 如果状态为已完成，设置确认时间并将商品入库
|
|
if updateData.OrderStatus == 2 {
|
|
now := time.Now()
|
|
updateFields["confirm_time"] = &now
|
|
|
|
// 商品入库到买家仓库
|
|
if err := h.addToWarehouse(tx, order.BuyerID, &order); err != nil {
|
|
tx.Rollback()
|
|
c.JSON(http.StatusOK, common.Error(500, "商品入库失败"))
|
|
return
|
|
}
|
|
}
|
|
|
|
if err := tx.Model(&order).Updates(updateFields).Error; err != nil {
|
|
tx.Rollback()
|
|
c.JSON(http.StatusOK, common.Error(500, "更新订单状态失败"))
|
|
return
|
|
}
|
|
|
|
tx.Commit()
|
|
|
|
result := map[string]interface{}{
|
|
"message": "订单状态更新成功",
|
|
}
|
|
if updateData.OrderStatus == 2 {
|
|
result["message"] = "订单确认成功，商品已入库"
|
|
}
|
|
|
|
c.JSON(http.StatusOK, common.Success(result))
|
|
}
|
|
|
|
// UpdateSalesOrderStatus 更新卖单状态（仅管理员）
|
|
func (h *AdminOrderHandler) UpdateSalesOrderStatus(c *gin.Context) {
|
|
currentUser, _ := c.Get("current_user")
|
|
user := currentUser.(models.User)
|
|
|
|
// 只有管理员可以更新订单状态
|
|
if user.SystemRole != 0 {
|
|
c.JSON(http.StatusOK, common.Error(403, "权限不足"))
|
|
return
|
|
}
|
|
|
|
orderID, err := strconv.ParseUint(c.Param("id"), 10, 32)
|
|
if err != nil {
|
|
c.JSON(http.StatusOK, common.Error(400, "订单ID无效"))
|
|
return
|
|
}
|
|
|
|
var updateData struct {
|
|
OrderStatus uint8 `json:"order_status" binding:"required"`
|
|
Remark string `json:"remark"`
|
|
}
|
|
|
|
if err := c.ShouldBindJSON(&updateData); err != nil {
|
|
c.JSON(http.StatusOK, common.Error(400, "参数错误: "+err.Error()))
|
|
return
|
|
}
|
|
|
|
// 检查订单是否存在
|
|
var order models.SalesOrder
|
|
if err := common.GetDB().First(&order, uint(orderID)).Error; err != nil {
|
|
c.JSON(http.StatusOK, common.Error(404, "订单不存在"))
|
|
return
|
|
}
|
|
|
|
// 更新订单状态
|
|
updateFields := map[string]interface{}{
|
|
"order_status": updateData.OrderStatus,
|
|
"remark": updateData.Remark,
|
|
}
|
|
|
|
// 如果状态为确认完成，设置完成时间
|
|
if updateData.OrderStatus == 2 {
|
|
updateFields["complete_time"] = time.Now()
|
|
db := common.GetDB()
|
|
var purcharseOrder models.PurchaseOrder
|
|
db.Where("id=?", order.PurchaseOrderID).First(&purcharseOrder)
|
|
err := h.addToWarehouse(db, purcharseOrder.BuyerID, &purcharseOrder)
|
|
if err != nil {
|
|
c.JSON(http.StatusOK, common.Error(500, "确认失败"))
|
|
}
|
|
}
|
|
if updateData.OrderStatus == 3 {
|
|
canel(order.PurchaseOrderID, order.BuyerID)
|
|
}
|
|
if err := common.GetDB().Model(&order).Updates(updateFields).Error; err != nil {
|
|
c.JSON(http.StatusOK, common.Error(500, "更新订单状态失败"))
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, common.Success(nil))
|
|
}
|
|
|
|
// GetOrderStats 获取订单统计信息
|
|
func (h *AdminOrderHandler) GetOrderStats(c *gin.Context) {
|
|
currentUser, _ := c.Get("current_user")
|
|
user := currentUser.(models.User)
|
|
|
|
db := common.GetDB()
|
|
stats := make(map[string]interface{})
|
|
|
|
// 买单统计
|
|
purchaseQuery := db.Model(&models.PurchaseOrder{}).Where("order_status = ?", 2)
|
|
|
|
if user.SystemRole == 1 {
|
|
// 代理商只统计自己邀请的用户的订单
|
|
subQuery := db.Model(&models.User{}).Select("id").Where("referrer_identity_code = ?", user.IdentityCode)
|
|
purchaseQuery = purchaseQuery.Where("buyer_id IN (?)", subQuery)
|
|
}
|
|
|
|
var totalPurchaseOrders int64
|
|
var totalPurchaseAmount float64
|
|
purchaseQuery.Count(&totalPurchaseOrders)
|
|
purchaseQuery.Select("COALESCE(SUM(total_amount), 0)").Scan(&totalPurchaseAmount)
|
|
|
|
stats["total_purchase_orders"] = totalPurchaseOrders
|
|
stats["total_purchase_amount"] = totalPurchaseAmount
|
|
|
|
// 卖单统计
|
|
salesQuery := db.Model(&models.SalesOrder{})
|
|
if user.SystemRole == 1 {
|
|
// 代理商只统计自己邀请的用户相关的订单
|
|
subQuery := db.Model(&models.User{}).Select("id").Where("referrer_identity_code = ?", user.IdentityCode)
|
|
salesQuery = salesQuery.Where("buyer_id IN (?) OR seller_id IN (?)", subQuery, subQuery)
|
|
}
|
|
|
|
var totalSalesOrders int64
|
|
var totalSalesAmount float64
|
|
salesQuery.Count(&totalSalesOrders)
|
|
salesQuery.Select("COALESCE(SUM(total_amount), 0)").Scan(&totalSalesAmount)
|
|
|
|
stats["total_sales_orders"] = totalSalesOrders
|
|
stats["total_sales_amount"] = totalSalesAmount
|
|
|
|
// 今日订单统计
|
|
todayPurchaseQuery := purchaseQuery
|
|
if user.SystemRole == 1 {
|
|
subQuery := db.Model(&models.User{}).Select("id").Where("referrer_identity_code = ?", user.IdentityCode)
|
|
todayPurchaseQuery = todayPurchaseQuery.Where("buyer_id IN (?)", subQuery)
|
|
}
|
|
var todayPurchaseOrders int64
|
|
todayPurchaseQuery.Where("DATE(created_at) = CURDATE()").Count(&todayPurchaseOrders)
|
|
|
|
todaySalesQuery := salesQuery
|
|
if user.SystemRole == 1 {
|
|
subQuery := db.Model(&models.User{}).Select("id").Where("referrer_identity_code = ?", user.IdentityCode)
|
|
todaySalesQuery = todaySalesQuery.Where("buyer_id IN (?) OR seller_id IN (?)", subQuery, subQuery)
|
|
}
|
|
var todaySalesOrders int64
|
|
todaySalesQuery.Where("DATE(created_at) = CURDATE()").Count(&todaySalesOrders)
|
|
|
|
stats["today_purchase_orders"] = todayPurchaseOrders
|
|
stats["today_sales_orders"] = todaySalesOrders
|
|
|
|
c.JSON(http.StatusOK, common.Success(stats))
|
|
}
|
|
|
|
func canel(OrderID, UserID uint) {
|
|
db := common.GetDB()
|
|
tx := db.Begin()
|
|
|
|
// 查询订单
|
|
var order models.PurchaseOrder
|
|
if err := tx.Where("id = ? AND buyer_id = ?", OrderID, UserID).First(&order).Error; err != nil {
|
|
tx.Rollback()
|
|
return
|
|
}
|
|
|
|
// 检查订单状态（只有待付款和待确认的订单可以取消）
|
|
if order.OrderStatus != 0 && order.OrderStatus != 1 {
|
|
tx.Rollback()
|
|
|
|
return
|
|
}
|
|
|
|
// 更新订单状态为已取消
|
|
if err := tx.Model(&order).Update("order_status", 3).Error; err != nil {
|
|
tx.Rollback()
|
|
|
|
return
|
|
}
|
|
|
|
// 恢复商品库存
|
|
if order.ProductType == 1 { // 一级商品
|
|
if err := tx.Model(&models.PrimaryProduct{}).Where("id = ?", order.ProductID).
|
|
Update("stock_quantity", gorm.Expr("stock_quantity + ?", order.Quantity)).Error; err != nil {
|
|
tx.Rollback()
|
|
|
|
return
|
|
}
|
|
} else { // 二级商品
|
|
if err := tx.Model(&models.SecondaryProduct{}).Where("id = ?", order.ProductID).
|
|
Update("quantity", gorm.Expr("quantity + ?", order.Quantity)).Error; err != nil {
|
|
tx.Rollback()
|
|
|
|
return
|
|
}
|
|
}
|
|
|
|
tx.Commit()
|
|
}
|
|
|
|
// addToWarehouse 添加商品到买家仓库
|
|
func (h *AdminOrderHandler) addToWarehouse(tx *gorm.DB, buyerID uint, order *models.PurchaseOrder) error {
|
|
|
|
var config models.SystemConfig
|
|
// 计算入库价格（根据系统配置增值）
|
|
|
|
// 检查该订单是否已经入库（防止重复入库）
|
|
var existingByOrder models.UserWarehouse
|
|
err := tx.Where("user_id = ? AND source_order_id = ? and product_type=? and product_id=?",
|
|
buyerID, order.ID, order.ProductType, order.ProductID).First(&existingByOrder).Error
|
|
|
|
if err == nil {
|
|
// 该订单已经入库，直接返回
|
|
return nil
|
|
} else if err != gorm.ErrRecordNotFound {
|
|
// 查询出错
|
|
return err
|
|
}
|
|
|
|
// 检查仓库中是否已有相同商品（不同订单的相同商品）
|
|
var existingWarehouse models.UserWarehouse
|
|
//err = tx.Where("user_id = ? AND product_id = ? AND product_type = ?",
|
|
// buyerID, order.ProductID, order.ProductType).First(&existingWarehouse).Error
|
|
|
|
_ = tx.Where("config_key= ?", "warehouse_price_rate").First(&config).Error
|
|
value, _ := strconv.ParseFloat(config.ConfigValue, 64)
|
|
warehousePrice := order.UnitPrice + value
|
|
|
|
if err == gorm.ErrRecordNotFound {
|
|
// 创建新的仓库记录
|
|
warehouse := models.UserWarehouse{
|
|
UserID: buyerID,
|
|
ProductID: order.ProductID,
|
|
ProductType: order.ProductType,
|
|
ProductName: order.ProductName,
|
|
ProductImages: order.ProductImages,
|
|
PurchasePrice: order.UnitPrice,
|
|
WarehousePrice: warehousePrice,
|
|
Quantity: order.Quantity,
|
|
SourceOrderID: &order.ID,
|
|
Status: 1, // 库存中
|
|
}
|
|
|
|
return tx.Create(&warehouse).Error
|
|
} else if err != nil {
|
|
return err
|
|
} else {
|
|
// 更新现有仓库记录的数量（累加不同订单的相同商品）
|
|
return tx.Model(&existingWarehouse).Update("quantity", existingWarehouse.Quantity+order.Quantity).Error
|
|
}
|
|
}
|
|
|
|
func (h *AdminOrderHandler) GetOrderTrend(c *gin.Context) {
|
|
db := common.GetDB()
|
|
|
|
type DailyStats struct {
|
|
Date string `json:"date"`
|
|
Count int `json:"count"`
|
|
}
|
|
|
|
result := make([]DailyStats, 0, 7)
|
|
|
|
now := time.Now()
|
|
|
|
for i := 6; i >= 0; i-- {
|
|
// 当天 00:00:00
|
|
startOfDay := time.Date(now.Year(), now.Month(), now.Day()-i, 0, 0, 0, 0, now.Location())
|
|
// 次日 00:00:00
|
|
endOfDay := startOfDay.AddDate(0, 0, 1)
|
|
|
|
// 格式化显示用的 "01-02"
|
|
displayDateStr := startOfDay.Format("01-02")
|
|
|
|
var count int64
|
|
db.Model(&models.PurchaseOrder{}).
|
|
Where("created_at >= ? AND created_at < ?", startOfDay, endOfDay).
|
|
Count(&count)
|
|
|
|
result = append(result, DailyStats{
|
|
Date: displayDateStr,
|
|
Count: int(count),
|
|
})
|
|
}
|
|
|
|
c.JSON(http.StatusOK, common.Success(map[string]interface{}{
|
|
"trend": result,
|
|
}))
|
|
}
|
|
|
|
// GetRecentActivities 获取最近活动
|
|
func (h *AdminOrderHandler) GetRecentActivities(c *gin.Context) {
|
|
currentUser, _ := c.Get("current_user")
|
|
user := currentUser.(models.User)
|
|
|
|
db := common.GetDB()
|
|
|
|
// 准备返回数据结构
|
|
type Activity struct {
|
|
ID uint `json:"id"`
|
|
Description string `json:"description"`
|
|
Time time.Time `json:"time"`
|
|
}
|
|
|
|
var activities []Activity
|
|
|
|
// 获取最近的订单活动（最多10条）
|
|
var recentOrders []models.PurchaseOrder
|
|
orderQuery := db.Model(&models.PurchaseOrder{}).Preload("Buyer")
|
|
|
|
if user.SystemRole == 1 {
|
|
// 代理商只能看到自己邀请的用户的活动
|
|
subQuery := db.Model(&models.User{}).Select("id").Where("referrer_identity_code = ?", user.IdentityCode)
|
|
orderQuery = orderQuery.Where("buyer_id IN (?)", subQuery)
|
|
}
|
|
|
|
err := orderQuery.Order("created_at DESC").Limit(10).Find(&recentOrders).Error
|
|
if err != nil {
|
|
c.JSON(http.StatusOK, common.Error(500, "获取最近活动失败"))
|
|
return
|
|
}
|
|
|
|
// 将订单转换为活动
|
|
for _, order := range recentOrders {
|
|
var description string
|
|
switch order.OrderStatus {
|
|
case 0:
|
|
description = fmt.Sprintf("用户 %s 创建了新订单 %s", order.Buyer.Phone, order.OrderNo)
|
|
case 1:
|
|
description = fmt.Sprintf("用户 %s 提交了订单 %s 的付款凭证", order.Buyer.Phone, order.OrderNo)
|
|
case 2:
|
|
description = fmt.Sprintf("订单 %s 已完成", order.OrderNo)
|
|
case 3:
|
|
description = fmt.Sprintf("订单 %s 已取消", order.OrderNo)
|
|
}
|
|
|
|
activities = append(activities, Activity{
|
|
ID: order.ID,
|
|
Description: description,
|
|
Time: order.CreatedAt,
|
|
})
|
|
}
|
|
|
|
c.JSON(http.StatusOK, common.Success(map[string]interface{}{
|
|
"activities": activities,
|
|
}))
|
|
}
|