1581 lines
50 KiB
Go
1581 lines
50 KiB
Go
package service
|
||
|
||
import (
|
||
"dianshang/internal/model"
|
||
"dianshang/internal/repository"
|
||
"dianshang/pkg/utils"
|
||
"errors"
|
||
"fmt"
|
||
"log"
|
||
"time"
|
||
)
|
||
|
||
// OrderService 订单服务
|
||
type OrderService struct {
|
||
orderRepo *repository.OrderRepository
|
||
productRepo *repository.ProductRepository
|
||
userRepo *repository.UserRepository
|
||
couponRepo *repository.CouponRepository
|
||
}
|
||
|
||
// NewOrderService 创建订单服务
|
||
func NewOrderService(orderRepo *repository.OrderRepository, productRepo *repository.ProductRepository, userRepo *repository.UserRepository, couponRepo *repository.CouponRepository) *OrderService {
|
||
return &OrderService{
|
||
orderRepo: orderRepo,
|
||
productRepo: productRepo,
|
||
userRepo: userRepo,
|
||
couponRepo: couponRepo,
|
||
}
|
||
}
|
||
|
||
// CreateOrderRequest 创建订单请求
|
||
type CreateOrderRequest struct {
|
||
AddressID uint `json:"address_id" binding:"required"`
|
||
Items []CreateOrderItemRequest `json:"items" binding:"required,min=1"`
|
||
Remark string `json:"remark"`
|
||
CouponID *uint `json:"coupon_id,omitempty"`
|
||
}
|
||
|
||
// CreateOrderItemRequest 创建订单项请求
|
||
type CreateOrderItemRequest struct {
|
||
ProductID uint `json:"product_id" binding:"required"`
|
||
SpecID uint `json:"spec_id"`
|
||
SKUID uint `json:"sku_id"`
|
||
Quantity int `json:"quantity" binding:"required,min=1"`
|
||
SpecName string `json:"spec_name"`
|
||
SpecValue string `json:"spec_value"`
|
||
SpecInfo interface{} `json:"spec_info"` // 改为interface{}以支持数组和对象
|
||
}
|
||
|
||
// MergeOrdersRequest 合并订单请求
|
||
type MergeOrdersRequest struct {
|
||
OrderIDs []string `json:"order_ids" binding:"required,min=2"`
|
||
}
|
||
|
||
// CreateOrder 创建订单
|
||
func (s *OrderService) CreateOrder(userID uint, req *CreateOrderRequest) (*model.Order, error) {
|
||
// 检查用户是否存在
|
||
_, err := s.userRepo.GetByID(userID)
|
||
if err != nil {
|
||
return nil, errors.New("用户不存在")
|
||
}
|
||
|
||
// 检查收货地址是否存在
|
||
address, err := s.userRepo.GetAddressByID(req.AddressID)
|
||
if err != nil || address.UserID != userID {
|
||
return nil, errors.New("收货地址不存在")
|
||
}
|
||
|
||
// 创建订单
|
||
order := &model.Order{
|
||
OrderNo: utils.GenerateOrderNo(),
|
||
UserID: userID,
|
||
Status: 1, // 待付款
|
||
PayMethod: "wechat", // 微信支付
|
||
ReceiverAddress: address.ProvinceName + address.CityName + address.DistrictName + address.DetailAddress,
|
||
ReceiverName: address.Name,
|
||
ReceiverPhone: address.Phone,
|
||
Remark: req.Remark,
|
||
CreatedAt: time.Now(),
|
||
UpdatedAt: time.Now(),
|
||
}
|
||
|
||
var totalAmount float64
|
||
var orderItems []model.OrderItem
|
||
|
||
// 处理订单项
|
||
for _, item := range req.Items {
|
||
// 检查产品是否存在
|
||
product, err := s.productRepo.GetByID(item.ProductID)
|
||
if err != nil {
|
||
return nil, errors.New("产品不存在")
|
||
}
|
||
|
||
// 检查库存和获取价格（优先检查SKU库存和价格）
|
||
var actualPrice float64
|
||
if item.SKUID > 0 {
|
||
// 如果有SKU，检查SKU库存并使用SKU价格
|
||
sku, err := s.productRepo.GetSKUByID(item.SKUID)
|
||
if err != nil {
|
||
return nil, errors.New("SKU不存在")
|
||
}
|
||
if sku.Stock < item.Quantity {
|
||
return nil, errors.New("SKU库存不足: " + product.Name)
|
||
}
|
||
actualPrice = sku.Price
|
||
} else {
|
||
// 如果没有SKU，检查商品总库存并使用商品价格
|
||
if product.Stock < item.Quantity {
|
||
return nil, errors.New("产品库存不足: " + product.Name)
|
||
}
|
||
actualPrice = product.Price
|
||
}
|
||
|
||
// 计算金额
|
||
itemAmount := actualPrice * float64(item.Quantity)
|
||
totalAmount += itemAmount
|
||
|
||
// 创建订单项
|
||
var specID *uint
|
||
var skuID *uint
|
||
if item.SpecID > 0 {
|
||
specID = &item.SpecID
|
||
}
|
||
if item.SKUID > 0 {
|
||
skuID = &item.SKUID
|
||
}
|
||
|
||
// 处理SpecInfo类型转换
|
||
var specInfo model.JSONMap
|
||
if item.SpecInfo != nil {
|
||
switch v := item.SpecInfo.(type) {
|
||
case map[string]interface{}:
|
||
specInfo = model.JSONMap(v)
|
||
case []interface{}:
|
||
// 如果是数组，转换为map格式
|
||
specInfo = make(model.JSONMap)
|
||
for _, spec := range v {
|
||
if specObj, ok := spec.(map[string]interface{}); ok {
|
||
if title, hasTitle := specObj["specTitle"]; hasTitle {
|
||
if value, hasValue := specObj["specValue"]; hasValue {
|
||
if titleStr, ok := title.(string); ok {
|
||
specInfo[titleStr] = value
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
default:
|
||
specInfo = make(model.JSONMap)
|
||
}
|
||
}
|
||
|
||
orderItem := model.OrderItem{
|
||
ProductID: item.ProductID,
|
||
SpecID: specID,
|
||
SKUID: skuID,
|
||
Quantity: item.Quantity,
|
||
Price: actualPrice,
|
||
TotalPrice: itemAmount,
|
||
ProductName: product.Name,
|
||
ProductImage: product.MainImage,
|
||
SpecName: item.SpecName,
|
||
SpecValue: item.SpecValue,
|
||
SpecInfo: specInfo,
|
||
}
|
||
orderItems = append(orderItems, orderItem)
|
||
}
|
||
|
||
order.TotalAmount = totalAmount
|
||
order.ShippingFee = 0 // 免运费
|
||
|
||
// 处理优惠券
|
||
var couponAmount float64
|
||
if req.CouponID != nil && *req.CouponID > 0 {
|
||
log.Printf("🎫 [优惠券验证] 开始处理优惠券 - 用户ID: %d, 接收到的优惠券ID: %d, 订单总金额: %.2f", userID, *req.CouponID, totalAmount)
|
||
|
||
// 获取用户优惠券
|
||
userCoupon, err := s.couponRepo.GetUserCouponByID(*req.CouponID)
|
||
if err != nil {
|
||
log.Printf("❌ [优惠券验证] 获取用户优惠券失败 - 用户ID: %d, 优惠券ID: %d, 错误: %v", userID, *req.CouponID, err)
|
||
return nil, errors.New("用户优惠券不存在")
|
||
}
|
||
|
||
log.Printf("✅ [优惠券验证] 成功获取用户优惠券 - 用户优惠券ID: %d, 优惠券模板ID: %d, 优惠券名称: %s, 状态: %d, 用户ID: %d",
|
||
userCoupon.ID, userCoupon.CouponID, userCoupon.Coupon.Name, userCoupon.Status, userCoupon.UserID)
|
||
|
||
// 验证用户优惠券是否可用
|
||
if err := s.validateUserCoupon(userCoupon, userID, totalAmount); err != nil {
|
||
log.Printf("❌ [优惠券验证] 用户优惠券验证失败 - 用户ID: %d, 优惠券ID: %d, 错误: %v", userID, *req.CouponID, err)
|
||
return nil, err
|
||
}
|
||
|
||
// 计算优惠金额
|
||
couponAmount = s.calculateCouponDiscount(&userCoupon.Coupon, totalAmount)
|
||
log.Printf("💰 [优惠券验证] 优惠金额计算完成 - 原价: %.2f, 优惠金额: %.2f, 实付金额: %.2f", totalAmount, couponAmount, totalAmount-couponAmount)
|
||
|
||
order.CouponID = req.CouponID
|
||
order.CouponAmount = couponAmount
|
||
} else {
|
||
log.Printf("ℹ️ [优惠券验证] 未使用优惠券 - 用户ID: %d", userID)
|
||
}
|
||
|
||
order.PayAmount = totalAmount - couponAmount
|
||
|
||
// 保存订单
|
||
if err := s.orderRepo.Create(order); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 保存订单项
|
||
for i := range orderItems {
|
||
orderItems[i].OrderID = order.ID
|
||
if err := s.orderRepo.CreateOrderItem(&orderItems[i]); err != nil {
|
||
return nil, err
|
||
}
|
||
}
|
||
|
||
// 预扣库存（防止超卖）
|
||
for i, item := range req.Items {
|
||
var err error
|
||
if item.SKUID > 0 {
|
||
// 如果有SKU，同时扣减SKU库存和商品库存
|
||
err = s.productRepo.DeductStockWithSKU(item.ProductID, &item.SKUID, item.Quantity)
|
||
} else {
|
||
// 如果没有SKU，只扣减商品库存
|
||
err = s.productRepo.ReserveStock(item.ProductID, item.Quantity)
|
||
}
|
||
|
||
if err != nil {
|
||
// 如果预扣失败，需要恢复之前已预扣的库存
|
||
for j := 0; j < i; j++ {
|
||
prevItem := req.Items[j]
|
||
if prevItem.SKUID > 0 {
|
||
s.productRepo.RestoreStockWithSKU(prevItem.ProductID, &prevItem.SKUID, prevItem.Quantity)
|
||
} else {
|
||
s.productRepo.RestoreStock(prevItem.ProductID, prevItem.Quantity)
|
||
}
|
||
}
|
||
return nil, errors.New("库存预扣失败: " + err.Error())
|
||
}
|
||
}
|
||
|
||
// 清空购物车中的相关商品
|
||
for _, item := range req.Items {
|
||
s.orderRepo.RemoveFromCart(userID, item.ProductID)
|
||
}
|
||
|
||
// 如果使用了优惠券，标记为已使用
|
||
if req.CouponID != nil && *req.CouponID > 0 {
|
||
userCoupon, err := s.couponRepo.GetUserCouponByID(*req.CouponID)
|
||
if err != nil {
|
||
return nil, errors.New("用户优惠券不存在")
|
||
}
|
||
|
||
if err := s.couponRepo.UseCoupon(userCoupon.ID, order.ID); err != nil {
|
||
return nil, errors.New("使用优惠券失败")
|
||
}
|
||
}
|
||
|
||
return order, nil
|
||
}
|
||
|
||
// validateCoupon 验证优惠券是否可用
|
||
func (s *OrderService) validateCoupon(coupon *model.Coupon, userID uint, orderAmount float64) error {
|
||
// 检查优惠券状态
|
||
if coupon.Status != 1 {
|
||
return errors.New("优惠券不可用")
|
||
}
|
||
|
||
// 检查有效期
|
||
now := time.Now()
|
||
if coupon.StartTime.After(now) {
|
||
return errors.New("优惠券尚未生效")
|
||
}
|
||
if coupon.EndTime.Before(now) {
|
||
return errors.New("优惠券已过期")
|
||
}
|
||
|
||
// 检查最低消费金额 (MinAmount是分，需要转换为元)
|
||
minAmount := float64(coupon.MinAmount) / 100
|
||
if orderAmount < minAmount {
|
||
return fmt.Errorf("订单金额不满足优惠券使用条件，最低需要%.2f元", minAmount)
|
||
}
|
||
|
||
// 检查用户是否拥有此优惠券且未使用
|
||
userCoupon, err := s.couponRepo.GetUserCouponByID(coupon.ID)
|
||
if err != nil {
|
||
return errors.New("您没有此优惠券")
|
||
}
|
||
|
||
if userCoupon.Status != 0 {
|
||
return errors.New("优惠券已使用或已过期")
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// validateUserCoupon 验证用户优惠券是否可用
|
||
func (s *OrderService) validateUserCoupon(userCoupon *model.UserCoupon, userID uint, orderAmount float64) error {
|
||
log.Printf("🔍 [优惠券验证] 开始详细验证 - 用户ID: %d, 用户优惠券ID: %d", userID, userCoupon.ID)
|
||
|
||
// 首先检查优惠券是否属于当前用户
|
||
log.Printf("👤 [优惠券验证] 检查优惠券所有权 - 当前用户ID: %d, 优惠券所属用户ID: %d", userID, userCoupon.UserID)
|
||
if userCoupon.UserID != userID {
|
||
log.Printf("❌ [优惠券验证] 优惠券不属于当前用户 - 当前用户: %d, 优惠券所属用户: %d", userID, userCoupon.UserID)
|
||
return errors.New("无权使用该优惠券")
|
||
}
|
||
|
||
// 检查用户优惠券状态
|
||
log.Printf("📋 [优惠券验证] 检查用户优惠券状态 - 状态: %d (0=未使用, 1=已使用, 2=已过期)", userCoupon.Status)
|
||
if userCoupon.Status != 0 {
|
||
log.Printf("❌ [优惠券验证] 用户优惠券状态不可用 - 状态: %d", userCoupon.Status)
|
||
return errors.New("优惠券已使用或已过期")
|
||
}
|
||
|
||
// 检查优惠券状态
|
||
log.Printf("📋 [优惠券验证] 检查优惠券模板状态 - 状态: %d (1=可用)", userCoupon.Coupon.Status)
|
||
if userCoupon.Coupon.Status != 1 {
|
||
log.Printf("❌ [优惠券验证] 优惠券模板状态不可用 - 状态: %d", userCoupon.Coupon.Status)
|
||
return errors.New("优惠券不可用")
|
||
}
|
||
|
||
// 检查有效期
|
||
now := time.Now()
|
||
log.Printf("⏰ [优惠券验证] 检查有效期 - 当前时间: %s, 开始时间: %s, 结束时间: %s",
|
||
now.Format("2006-01-02 15:04:05"),
|
||
userCoupon.Coupon.StartTime.Format("2006-01-02 15:04:05"),
|
||
userCoupon.Coupon.EndTime.Format("2006-01-02 15:04:05"))
|
||
if userCoupon.Coupon.StartTime.After(now) {
|
||
log.Printf("❌ [优惠券验证] 优惠券尚未生效")
|
||
return errors.New("优惠券尚未生效")
|
||
}
|
||
if userCoupon.Coupon.EndTime.Before(now) {
|
||
log.Printf("❌ [优惠券验证] 优惠券已过期")
|
||
return errors.New("优惠券已过期")
|
||
}
|
||
|
||
// 检查最低消费金额 (MinAmount是分，需要转换为元)
|
||
minAmount := float64(userCoupon.Coupon.MinAmount) / 100
|
||
log.Printf("💰 [优惠券验证] 检查最低消费金额 - 订单金额: %.2f元, 最低要求: %.2f元", orderAmount, minAmount)
|
||
if orderAmount < minAmount {
|
||
log.Printf("❌ [优惠券验证] 订单金额不满足最低消费要求")
|
||
return fmt.Errorf("订单金额不满足优惠券使用条件，最低需要%.2f元", minAmount)
|
||
}
|
||
|
||
log.Printf("✅ [优惠券验证] 所有验证通过 - 用户ID: %d, 用户优惠券ID: %d", userID, userCoupon.ID)
|
||
return nil
|
||
}
|
||
|
||
// calculateCouponDiscount 计算优惠券折扣金额
|
||
func (s *OrderService) calculateCouponDiscount(coupon *model.Coupon, orderAmount float64) float64 {
|
||
switch coupon.Type {
|
||
case 1: // 固定金额 (Value是分，需要转换为元)
|
||
discountAmount := float64(coupon.Value)
|
||
if discountAmount > orderAmount {
|
||
return orderAmount
|
||
}
|
||
return discountAmount
|
||
case 2: // 百分比折扣 (Value是折扣，如85表示8.5折)
|
||
discountRate := float64(coupon.Value) / 100 // 85 -> 0.85
|
||
discount := orderAmount * (1 - discountRate) // 计算优惠金额
|
||
return discount
|
||
case 3: // 免运费
|
||
// 这里可以返回运费金额，目前运费为0，所以返回0
|
||
return 0
|
||
default:
|
||
return 0
|
||
}
|
||
}
|
||
|
||
// GetUserOrders 获取用户订单列表
|
||
func (s *OrderService) GetUserOrders(userID uint, status, page, pageSize int) ([]model.Order, *utils.Pagination, error) {
|
||
if page <= 0 {
|
||
page = 1
|
||
}
|
||
if pageSize <= 0 || pageSize > 100 {
|
||
pageSize = 20
|
||
}
|
||
|
||
offset := (page - 1) * pageSize
|
||
orders, total, err := s.orderRepo.GetUserOrders(userID, status, offset, pageSize)
|
||
if err != nil {
|
||
return nil, nil, err
|
||
}
|
||
|
||
pagination := utils.NewPagination(page, pageSize)
|
||
pagination.Total = total
|
||
return orders, pagination, nil
|
||
}
|
||
|
||
// GetUserOrderStatistics 获取用户订单统计
|
||
func (s *OrderService) GetUserOrderStatistics(userID uint) (map[string]interface{}, error) {
|
||
stats, err := s.orderRepo.GetUserOrderStatistics(userID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return stats, nil
|
||
}
|
||
|
||
// GetOrderDetail 获取订单详情
|
||
func (s *OrderService) GetOrderDetail(userID uint, orderID uint) (*model.Order, error) {
|
||
order, err := s.orderRepo.GetByID(orderID)
|
||
if err != nil {
|
||
return nil, errors.New("订单不存在")
|
||
}
|
||
|
||
// 检查订单是否属于当前用户
|
||
if order.UserID != userID {
|
||
return nil, errors.New("无权访问该订单")
|
||
}
|
||
|
||
return order, nil
|
||
}
|
||
|
||
// GetOrderDetailByOrderNo 通过订单号获取订单详情（支持订单号或微信订单号）
|
||
func (s *OrderService) GetOrderDetailByOrderNo(userID uint, orderNo string) (*model.Order, error) {
|
||
var order *model.Order
|
||
var err error
|
||
|
||
// 先尝试使用订单号查询
|
||
order, err = s.orderRepo.GetByOrderNo(orderNo)
|
||
if err != nil {
|
||
// 如果订单号查询失败，尝试使用微信订单号查询
|
||
order, err = s.orderRepo.GetOrderByWechatOutTradeNo(orderNo)
|
||
if err != nil {
|
||
return nil, errors.New("订单不存在")
|
||
}
|
||
}
|
||
|
||
// 检查订单是否属于当前用户
|
||
if order.UserID != userID {
|
||
return nil, errors.New("无权访问该订单")
|
||
}
|
||
|
||
return order, nil
|
||
}
|
||
|
||
// GetOrderByOrderNo 通过订单号获取订单信息（不验证用户权限，用于支付回调等场景）
|
||
func (s *OrderService) GetOrderByOrderNo(orderNo string) (*model.Order, error) {
|
||
order, err := s.orderRepo.GetByOrderNo(orderNo)
|
||
if err != nil {
|
||
return nil, errors.New("订单不存在")
|
||
}
|
||
return order, nil
|
||
}
|
||
|
||
// PayOrder 支付订单
|
||
func (s *OrderService) PayOrder(userID uint, orderNo string) error {
|
||
order, err := s.orderRepo.GetByOrderNo(orderNo)
|
||
if err != nil {
|
||
return errors.New("订单不存在")
|
||
}
|
||
|
||
// 检查订单是否属于当前用户
|
||
if order.UserID != userID {
|
||
return errors.New("无权操作该订单")
|
||
}
|
||
|
||
// 检查订单状态
|
||
if order.Status != 1 {
|
||
return errors.New("订单状态不正确")
|
||
}
|
||
|
||
// 库存已在订单创建时预扣，支付成功时无需再次扣减
|
||
fmt.Printf("💰 [PayOrder] 支付成功，库存已在订单创建时预扣 - 订单号: %s\n", orderNo)
|
||
|
||
// 获取订单项以更新销量
|
||
orderItems, err := s.orderRepo.GetOrderItems(order.ID)
|
||
if err != nil {
|
||
fmt.Printf("❌ [PayOrder] 获取订单项失败: %v\n", err)
|
||
return errors.New("获取订单项失败")
|
||
}
|
||
|
||
// 支付成功时更新销量
|
||
for _, item := range orderItems {
|
||
err := s.productRepo.UpdateSales(item.ProductID, item.Quantity)
|
||
if err != nil {
|
||
fmt.Printf("❌ [PayOrder] 更新销量失败 - 产品ID: %d, 数量: %d, 错误: %v\n", item.ProductID, item.Quantity, err)
|
||
// 销量更新失败不影响支付成功，只记录日志
|
||
} else {
|
||
fmt.Printf("✅ [PayOrder] 支付成功，更新销量 - 产品ID: %d, 数量: %d\n", item.ProductID, item.Quantity)
|
||
}
|
||
}
|
||
|
||
// 模拟支付成功，更新订单状态
|
||
updates := map[string]interface{}{
|
||
"status": 2, // 待发货
|
||
"pay_status": 1, // 已支付
|
||
"pay_time": time.Now(),
|
||
"updated_at": time.Now(),
|
||
}
|
||
|
||
// 添加调试日志
|
||
fmt.Printf("🔄 [PayOrder] 开始更新订单 %s，用户ID: %d\n", orderNo, userID)
|
||
fmt.Printf("🔄 [PayOrder] 更新数据: %+v\n", updates)
|
||
|
||
err = s.orderRepo.UpdateByOrderNo(orderNo, updates)
|
||
if err != nil {
|
||
fmt.Printf("❌ [PayOrder] 数据库更新失败: %v\n", err)
|
||
// 如果订单更新失败，库存已在创建时预扣，无需额外处理
|
||
return err
|
||
}
|
||
|
||
fmt.Printf("✅ [PayOrder] 数据库更新成功\n")
|
||
return nil
|
||
}
|
||
|
||
// GetPendingOrdersCount 获取待处理订单数量
|
||
func (s *OrderService) GetPendingOrdersCount() (int64, error) {
|
||
return s.orderRepo.GetPendingOrdersCount()
|
||
}
|
||
|
||
// GetRegionStatistics 获取地区统计
|
||
func (s *OrderService) GetRegionStatistics(startDate, endDate string) ([]map[string]interface{}, error) {
|
||
// 简化实现，返回基础地区统计数据
|
||
var results []map[string]interface{}
|
||
|
||
// 模拟地区数据
|
||
regions := []string{"北京", "上海", "广州", "深圳", "杭州", "南京", "成都", "武汉"}
|
||
for i, region := range regions {
|
||
results = append(results, map[string]interface{}{
|
||
"region": region,
|
||
"order_count": 100 - i*8,
|
||
"order_amount": float64(10000 - i*800),
|
||
})
|
||
}
|
||
|
||
return results, nil
|
||
}
|
||
|
||
// GetPaymentMethodStatistics 获取支付方式统计
|
||
func (s *OrderService) GetPaymentMethodStatistics(startDate, endDate string) ([]map[string]interface{}, error) {
|
||
// 简化实现，返回基础支付方式统计数据
|
||
var results []map[string]interface{}
|
||
|
||
// 模拟支付方式数据
|
||
paymentMethods := []map[string]interface{}{
|
||
{"method": "微信支付", "count": 150, "amount": 15000.0},
|
||
{"method": "支付宝", "count": 120, "amount": 12000.0},
|
||
{"method": "银行卡", "count": 80, "amount": 8000.0},
|
||
{"method": "余额支付", "count": 50, "amount": 5000.0},
|
||
}
|
||
|
||
results = paymentMethods
|
||
return results, nil
|
||
}
|
||
|
||
// GetRefundStatistics 获取退款统计
|
||
func (s *OrderService) GetRefundStatistics(startDate, endDate string) (map[string]interface{}, error) {
|
||
// 简化实现，返回基础退款统计数据
|
||
result := map[string]interface{}{
|
||
"total_refund_count": 25,
|
||
"total_refund_amount": 2500.0,
|
||
"refund_rate": 0.05, // 5%退款率
|
||
"avg_refund_amount": 100.0,
|
||
"refund_reasons": []map[string]interface{}{
|
||
{"reason": "商品质量问题", "count": 10},
|
||
{"reason": "不喜欢", "count": 8},
|
||
{"reason": "尺寸不合适", "count": 5},
|
||
{"reason": "其他", "count": 2},
|
||
},
|
||
}
|
||
|
||
return result, nil
|
||
}
|
||
|
||
// RefundOrderDuplicate 申请退款(重复方法，已移除)
|
||
func (s *OrderService) RefundOrderDuplicate(userID uint, orderNo string) error {
|
||
log.Printf("[服务层] 开始处理退款申请: userID=%d, orderNo=%s", userID, orderNo)
|
||
|
||
// 获取订单信息
|
||
order, err := s.orderRepo.GetByOrderNo(orderNo)
|
||
if err != nil {
|
||
log.Printf("[服务层] 退款申请失败: 订单不存在, orderNo=%s, error=%v", orderNo, err)
|
||
return errors.New("订单不存在")
|
||
}
|
||
|
||
log.Printf("[服务层] 找到订单: ID=%d, UserID=%d, Status=%d, CreatedAt=%v",
|
||
order.ID, order.UserID, order.Status, order.CreatedAt)
|
||
|
||
// 验证用户权限
|
||
if order.UserID != userID {
|
||
log.Printf("[服务层] 退款申请失败: 订单不属于当前用户, orderUserID=%d, requestUserID=%d", order.UserID, userID)
|
||
return errors.New("无权操作此订单")
|
||
}
|
||
|
||
// 验证订单状态是否允许退款（已付款状态）
|
||
if order.Status != 2 && order.Status != 3 && order.Status != 4 {
|
||
log.Printf("[服务层] 退款申请失败: 订单状态不允许退款, currentStatus=%d", order.Status)
|
||
return errors.New("订单状态不允许退款")
|
||
}
|
||
|
||
// 获取订单项以恢复库存和减少销量
|
||
orderItems, err := s.orderRepo.GetOrderItems(order.ID)
|
||
if err != nil {
|
||
log.Printf("[服务层] 获取订单项失败: %v", err)
|
||
return errors.New("获取订单项失败")
|
||
}
|
||
|
||
// 恢复库存
|
||
for _, item := range orderItems {
|
||
err := s.productRepo.RestoreStock(item.ProductID, item.Quantity)
|
||
if err != nil {
|
||
log.Printf("❌ [RefundOrder] 恢复库存失败 - 产品ID: %d, 数量: %d, 错误: %v", item.ProductID, item.Quantity, err)
|
||
} else {
|
||
log.Printf("✅ [RefundOrder] 成功恢复库存 - 产品ID: %d, 数量: %d", item.ProductID, item.Quantity)
|
||
}
|
||
}
|
||
|
||
// 如果订单已完成（状态为4），需要减少销量
|
||
if order.Status == 4 {
|
||
for _, item := range orderItems {
|
||
err := s.productRepo.UpdateSales(item.ProductID, -item.Quantity) // 负数表示减少
|
||
if err != nil {
|
||
log.Printf("❌ [RefundOrder] 减少销量失败 - 产品ID: %d, 数量: %d, 错误: %v", item.ProductID, item.Quantity, err)
|
||
} else {
|
||
log.Printf("✅ [RefundOrder] 成功减少销量 - 产品ID: %d, 数量: %d", item.ProductID, item.Quantity)
|
||
}
|
||
}
|
||
}
|
||
|
||
// 更新订单状态为退款中(8)
|
||
log.Printf("[服务层] 更新订单状态为退款中: 原状态=%d", order.Status)
|
||
|
||
updates := map[string]interface{}{
|
||
"status": 8, // 退款中状态
|
||
"refund_time": time.Now(),
|
||
"updated_at": time.Now(),
|
||
}
|
||
|
||
// 保存订单更新
|
||
if err := s.orderRepo.UpdateByOrderNo(orderNo, updates); err != nil {
|
||
log.Printf("[服务层] 更新订单状态失败: %v", err)
|
||
return err
|
||
}
|
||
|
||
log.Printf("[服务层] 退款申请处理成功: orderNo=%s", orderNo)
|
||
return nil
|
||
}
|
||
|
||
// CancelOrder 取消订单
|
||
func (s *OrderService) CancelOrder(userID uint, orderNo string) error {
|
||
order, err := s.orderRepo.GetByOrderNo(orderNo)
|
||
if err != nil {
|
||
return errors.New("订单不存在")
|
||
}
|
||
|
||
// 检查订单是否属于当前用户
|
||
if order.UserID != userID {
|
||
return errors.New("无权操作该订单")
|
||
}
|
||
|
||
// 检查订单状态（只有待付款的订单可以取消）
|
||
if order.Status != 1 {
|
||
return errors.New("订单状态不正确，无法取消")
|
||
}
|
||
|
||
// 恢复库存
|
||
items, err := s.orderRepo.GetOrderItems(order.ID)
|
||
if err == nil {
|
||
for _, item := range items {
|
||
var err error
|
||
if item.SKUID != nil && *item.SKUID > 0 {
|
||
// 如果有SKU，同时恢复SKU库存和商品库存
|
||
err = s.productRepo.RestoreStockWithSKU(item.ProductID, item.SKUID, item.Quantity)
|
||
} else {
|
||
// 如果没有SKU，只恢复商品库存
|
||
err = s.productRepo.RestoreStock(item.ProductID, item.Quantity)
|
||
}
|
||
|
||
if err != nil {
|
||
log.Printf("恢复库存失败 - 商品ID: %d, SKU ID: %v, 数量: %d, 错误: %v", item.ProductID, item.SKUID, item.Quantity, err)
|
||
}
|
||
}
|
||
|
||
// 取消订单时只需恢复库存，无需减少销量（因为只有待付款订单才能取消，销量尚未增加）
|
||
}
|
||
|
||
// 恢复优惠券（如果订单使用了优惠券）
|
||
if order.CouponID != nil && *order.CouponID > 0 {
|
||
// 根据订单ID查找对应的用户优惠券
|
||
userCoupon, err := s.couponRepo.GetUserCouponByOrderID(order.ID)
|
||
if err != nil {
|
||
log.Printf("查找用户优惠券失败: orderID=%d, couponID=%d, error=%v", order.ID, *order.CouponID, err)
|
||
} else {
|
||
if err := s.couponRepo.RestoreCoupon(userCoupon.ID); err != nil {
|
||
log.Printf("恢复优惠券失败: userCouponID=%d, orderID=%d, error=%v", userCoupon.ID, order.ID, err)
|
||
} else {
|
||
log.Printf("优惠券恢复成功: userCouponID=%d, orderID=%d", userCoupon.ID, order.ID)
|
||
}
|
||
}
|
||
// 不阻止订单取消，只记录日志
|
||
}
|
||
|
||
// 更新订单状态
|
||
updates := map[string]interface{}{
|
||
"status": 6, // 已取消
|
||
"updated_at": time.Now(),
|
||
}
|
||
|
||
return s.orderRepo.UpdateByOrderNo(orderNo, updates)
|
||
}
|
||
|
||
// RemindShip 提醒发货
|
||
func (s *OrderService) RemindShip(userID uint, orderNo string) error {
|
||
log.Printf("[服务层] ===== 提醒发货服务开始 =====")
|
||
log.Printf("[服务层] 提醒发货参数: userID=%d, orderNo=%s", userID, orderNo)
|
||
|
||
order, err := s.orderRepo.GetByOrderNo(orderNo)
|
||
if err != nil {
|
||
log.Printf("[服务层] 提醒发货失败: 订单不存在, orderNo=%s, error=%v", orderNo, err)
|
||
return errors.New("订单不存在")
|
||
}
|
||
|
||
log.Printf("[服务层] 找到订单: ID=%d, UserID=%d, Status=%d, CreatedAt=%v",
|
||
order.ID, order.UserID, order.Status, order.CreatedAt)
|
||
|
||
// 检查订单是否属于当前用户
|
||
if order.UserID != userID {
|
||
log.Printf("[服务层] 提醒发货失败: 订单不属于当前用户, orderUserID=%d, requestUserID=%d", order.UserID, userID)
|
||
return errors.New("无权操作该订单")
|
||
}
|
||
|
||
// 检查订单状态（只有已付款/待发货的订单可以提醒发货）
|
||
if order.Status != 2 && order.Status != 3 {
|
||
log.Printf("[服务层] 提醒发货失败: 订单状态不正确, currentStatus=%d, 期望状态=2或3", order.Status)
|
||
return errors.New("订单状态不正确，无法提醒发货")
|
||
}
|
||
|
||
// 检查订单创建时间，如果是刚创建的订单（10分钟内），提示用户稍后再试
|
||
if time.Since(order.CreatedAt) < 10*time.Minute {
|
||
log.Printf("[服务层] 提醒发货失败: 订单创建时间过短, 创建时间=%v, 当前时间=%v, 需等待=%v",
|
||
order.CreatedAt, time.Now(), 10*time.Minute-time.Since(order.CreatedAt))
|
||
return errors.New("订单刚创建，请10分钟后再提醒发货")
|
||
}
|
||
|
||
// 这里可以添加实际的提醒逻辑，比如发送通知给商家
|
||
// 1. 发送短信通知商家
|
||
// 2. 发送邮件通知商家
|
||
// 3. 在商家后台系统中创建提醒记录
|
||
// 4. 推送消息到商家APP
|
||
|
||
log.Printf("[服务层] 🔔 提醒发货成功: 用户 %d 提醒发货订单 %s", userID, orderNo)
|
||
log.Printf("[服务层] 📦 商家将收到发货提醒通知")
|
||
|
||
return nil
|
||
}
|
||
|
||
// RefundOrderLegacy 申请退款(旧方法)
|
||
func (s *OrderService) RefundOrderLegacy(userID uint, orderNo string) error {
|
||
// 此方法已被移除，使用上面的RefundOrder方法
|
||
return nil
|
||
|
||
// 获取订单信息
|
||
order, err := s.orderRepo.GetByOrderNo(orderNo)
|
||
if err != nil {
|
||
log.Printf("[服务层] 退款申请失败: 订单不存在, orderNo=%s, error=%v", orderNo, err)
|
||
return errors.New("订单不存在")
|
||
}
|
||
|
||
log.Printf("[服务层] 找到订单: ID=%d, UserID=%d, Status=%d, CreatedAt=%v",
|
||
order.ID, order.UserID, order.Status, order.CreatedAt)
|
||
|
||
// 验证用户权限
|
||
if order.UserID != userID {
|
||
log.Printf("[服务层] 退款申请失败: 订单不属于当前用户, orderUserID=%d, requestUserID=%d", order.UserID, userID)
|
||
return errors.New("无权操作此订单")
|
||
}
|
||
|
||
// 验证订单状态是否允许退款（已付款状态）
|
||
if order.Status != 2 && order.Status != 3 {
|
||
log.Printf("[服务层] 退款申请失败: 订单状态不允许退款, currentStatus=%d", order.Status)
|
||
return errors.New("订单状态不允许退款，只有已付款待发货的订单可以申请退款")
|
||
}
|
||
|
||
// 更新订单状态为已退款(9)
|
||
log.Printf("[服务层] 更新订单状态为已退款: 原状态=%d", order.Status)
|
||
|
||
updates := map[string]interface{}{
|
||
"status": 9, // 已退款状态
|
||
"refund_time": time.Now(),
|
||
"updated_at": time.Now(),
|
||
}
|
||
|
||
// 保存订单更新
|
||
if err := s.orderRepo.UpdateByOrderNo(orderNo, updates); err != nil {
|
||
log.Printf("[服务层] 更新订单状态失败: %v", err)
|
||
return err
|
||
}
|
||
|
||
log.Printf("[服务层] 退款申请处理成功: orderNo=%s", orderNo)
|
||
return nil
|
||
}
|
||
|
||
// ConfirmReceive 确认收货
|
||
func (s *OrderService) ConfirmReceive(userID uint, orderNo string) error {
|
||
order, err := s.orderRepo.GetByOrderNo(orderNo)
|
||
if err != nil {
|
||
return errors.New("订单不存在")
|
||
}
|
||
|
||
// 检查订单是否属于当前用户
|
||
if order.UserID != userID {
|
||
return errors.New("无权操作该订单")
|
||
}
|
||
|
||
// 检查订单状态（只有已发货(4)或待收货(5)的订单可以确认收货）
|
||
if order.Status != 4 && order.Status != 5 {
|
||
return errors.New("订单状态不正确")
|
||
}
|
||
|
||
fmt.Printf("✅ [ConfirmReceive] 确认收货成功 - 订单号: %s (销量已在支付时更新)\n", orderNo)
|
||
|
||
// 更新订单状态
|
||
updates := map[string]interface{}{
|
||
"status": 6, // 已完成
|
||
"receive_time": time.Now(),
|
||
"updated_at": time.Now(),
|
||
}
|
||
|
||
return s.orderRepo.UpdateByOrderNo(orderNo, updates)
|
||
}
|
||
|
||
// GetOrderList 获取订单列表（管理员）
|
||
func (s *OrderService) GetOrderList(page, pageSize int, conditions map[string]interface{}) ([]model.Order, *utils.Pagination, error) {
|
||
if page <= 0 {
|
||
page = 1
|
||
}
|
||
if pageSize <= 0 || pageSize > 100 {
|
||
pageSize = 20
|
||
}
|
||
|
||
offset := (page - 1) * pageSize
|
||
orders, total, err := s.orderRepo.GetList(offset, pageSize, conditions)
|
||
if err != nil {
|
||
return nil, nil, err
|
||
}
|
||
|
||
pagination := utils.NewPagination(page, pageSize)
|
||
pagination.Total = total
|
||
return orders, pagination, nil
|
||
}
|
||
|
||
// ShipOrder 发货（管理员）
|
||
func (s *OrderService) ShipOrder(orderNo, logisticsCompany, logisticsNo string) error {
|
||
order, err := s.orderRepo.GetByOrderNo(orderNo)
|
||
if err != nil {
|
||
return errors.New("订单不存在")
|
||
}
|
||
|
||
// 检查订单状态（只有待发货的订单可以发货）
|
||
if order.Status != 2 && order.Status != 3 {
|
||
return errors.New("订单状态不正确")
|
||
}
|
||
|
||
// 更新订单状态
|
||
updates := map[string]interface{}{
|
||
"status": 4, // 已发货
|
||
"logistics_company": logisticsCompany,
|
||
"logistics_no": logisticsNo,
|
||
"shipped_at": time.Now(),
|
||
"updated_at": time.Now(),
|
||
}
|
||
|
||
return s.orderRepo.UpdateByOrderNo(orderNo, updates)
|
||
}
|
||
|
||
// ShipOrderByID 通过订单ID发货
|
||
func (s *OrderService) ShipOrderByID(orderID uint, logisticsCompany, logisticsNo string) error {
|
||
order, err := s.orderRepo.GetByID(orderID)
|
||
if err != nil {
|
||
return errors.New("订单不存在")
|
||
}
|
||
|
||
// 检查订单状态（只有待发货的订单可以发货）
|
||
if order.Status != 2 && order.Status != 3 {
|
||
return errors.New("订单状态不正确")
|
||
}
|
||
|
||
// 更新订单状态
|
||
updates := map[string]interface{}{
|
||
"status": 4, // 已发货
|
||
"logistics_company": logisticsCompany,
|
||
"logistics_no": logisticsNo,
|
||
"shipped_at": time.Now(),
|
||
"updated_at": time.Now(),
|
||
}
|
||
|
||
return s.orderRepo.Update(orderID, updates)
|
||
}
|
||
|
||
|
||
|
||
// MergeOrders 合并订单
|
||
func (s *OrderService) MergeOrders(userID uint, req *MergeOrdersRequest) (*model.Order, error) {
|
||
// 1. 验证订单数量
|
||
if len(req.OrderIDs) < 2 {
|
||
return nil, errors.New("至少需要选择2个订单进行合并")
|
||
}
|
||
|
||
// 2. 获取所有要合并的订单
|
||
var orders []model.Order
|
||
var orderIDs []uint
|
||
|
||
for _, orderIDStr := range req.OrderIDs {
|
||
orderID := uint(0)
|
||
if _, err := fmt.Sscanf(orderIDStr, "%d", &orderID); err != nil {
|
||
return nil, errors.New("订单ID格式错误")
|
||
}
|
||
orderIDs = append(orderIDs, orderID)
|
||
}
|
||
|
||
// 获取订单详情
|
||
for _, orderID := range orderIDs {
|
||
order, err := s.orderRepo.GetByID(orderID)
|
||
if err != nil {
|
||
return nil, errors.New("订单不存在")
|
||
}
|
||
|
||
// 验证订单所有权
|
||
if order.UserID != userID {
|
||
return nil, errors.New("无权限操作此订单")
|
||
}
|
||
|
||
orders = append(orders, *order)
|
||
}
|
||
|
||
// 3. 验证订单合并条件
|
||
if err := s.validateOrdersForMerge(orders); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 4. 创建合并后的新订单
|
||
mergedOrder, err := s.createMergedOrder(orders)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 5. 删除原订单
|
||
for _, orderID := range orderIDs {
|
||
if err := s.orderRepo.Delete(orderID); err != nil {
|
||
// 如果删除失败，需要回滚新创建的订单
|
||
s.orderRepo.Delete(mergedOrder.ID)
|
||
return nil, errors.New("合并订单失败，请重试")
|
||
}
|
||
}
|
||
|
||
return mergedOrder, nil
|
||
}
|
||
|
||
// validateOrdersForMerge 验证订单是否可以合并
|
||
func (s *OrderService) validateOrdersForMerge(orders []model.Order) error {
|
||
if len(orders) < 2 {
|
||
return errors.New("至少需要2个订单才能合并")
|
||
}
|
||
|
||
firstOrder := orders[0]
|
||
|
||
for _, order := range orders {
|
||
// 检查订单状态：只能合并未支付的订单
|
||
if order.Status != 1 || order.PayStatus != 0 {
|
||
return errors.New("只能合并未支付的订单")
|
||
}
|
||
|
||
// 检查用户ID是否一致
|
||
if order.UserID != firstOrder.UserID {
|
||
return errors.New("只能合并同一用户的订单")
|
||
}
|
||
|
||
// 检查收货地址是否一致
|
||
if order.ReceiverName != firstOrder.ReceiverName ||
|
||
order.ReceiverPhone != firstOrder.ReceiverPhone ||
|
||
order.ReceiverAddress != firstOrder.ReceiverAddress {
|
||
return errors.New("只能合并相同收货地址的订单")
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// createMergedOrder 创建合并后的订单
|
||
func (s *OrderService) createMergedOrder(orders []model.Order) (*model.Order, error) {
|
||
firstOrder := orders[0]
|
||
|
||
// 创建新订单
|
||
mergedOrder := &model.Order{
|
||
OrderNo: utils.GenerateOrderNo(),
|
||
UserID: firstOrder.UserID,
|
||
StoreID: firstOrder.StoreID,
|
||
Status: 1, // 待付款
|
||
PayStatus: 0, // 未支付
|
||
ReceiverName: firstOrder.ReceiverName,
|
||
ReceiverPhone: firstOrder.ReceiverPhone,
|
||
ReceiverAddress: firstOrder.ReceiverAddress,
|
||
CreatedAt: time.Now(),
|
||
UpdatedAt: time.Now(),
|
||
}
|
||
|
||
// 合并所有订单项
|
||
var allOrderItems []model.OrderItem
|
||
var totalAmount float64
|
||
var totalDiscountAmount float64
|
||
var totalCouponAmount float64
|
||
var totalShippingFee float64
|
||
|
||
for _, order := range orders {
|
||
// 累加金额
|
||
totalAmount += order.TotalAmount
|
||
totalDiscountAmount += order.DiscountAmount
|
||
totalCouponAmount += order.CouponAmount
|
||
totalShippingFee += order.ShippingFee
|
||
|
||
// 收集订单项
|
||
for _, item := range order.OrderItems {
|
||
newItem := model.OrderItem{
|
||
OrderID: mergedOrder.ID,
|
||
ProductID: item.ProductID,
|
||
SKUID: item.SKUID,
|
||
Quantity: item.Quantity,
|
||
Price: item.Price,
|
||
TotalPrice: item.TotalPrice,
|
||
ProductName: item.ProductName,
|
||
ProductImage: item.ProductImage,
|
||
SpecInfo: item.SpecInfo,
|
||
CreatedAt: time.Now(),
|
||
UpdatedAt: time.Now(),
|
||
}
|
||
allOrderItems = append(allOrderItems, newItem)
|
||
}
|
||
}
|
||
|
||
// 设置合并后的金额
|
||
mergedOrder.TotalAmount = totalAmount
|
||
mergedOrder.PayAmount = totalAmount - totalDiscountAmount - totalCouponAmount + totalShippingFee
|
||
mergedOrder.DiscountAmount = totalDiscountAmount
|
||
mergedOrder.CouponAmount = totalCouponAmount
|
||
mergedOrder.ShippingFee = totalShippingFee
|
||
mergedOrder.OrderItems = allOrderItems
|
||
|
||
// 保存到数据库
|
||
if err := s.orderRepo.Create(mergedOrder); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return mergedOrder, nil
|
||
}
|
||
|
||
// GetOrderListForAdmin 获取订单列表（管理员专用）
|
||
func (s *OrderService) GetOrderListForAdmin(page, pageSize int, conditions map[string]interface{}) ([]model.Order, *utils.Pagination, error) {
|
||
return s.GetOrderList(page, pageSize, conditions)
|
||
}
|
||
|
||
// GetOrderDetailForAdmin 获取订单详情（管理员专用）
|
||
func (s *OrderService) GetOrderDetailForAdmin(orderID uint) (*model.Order, error) {
|
||
order, err := s.orderRepo.GetByID(orderID)
|
||
if err != nil {
|
||
return nil, errors.New("订单不存在")
|
||
}
|
||
return order, nil
|
||
}
|
||
|
||
// UpdateOrderStatusByAdmin 更新订单状态（管理员专用）
|
||
func (s *OrderService) UpdateOrderStatusByAdmin(orderID uint, status int, adminRemark string) error {
|
||
order, err := s.orderRepo.GetByID(orderID)
|
||
if err != nil {
|
||
return errors.New("订单不存在")
|
||
}
|
||
|
||
// 验证状态转换的合法性
|
||
if !s.isValidStatusTransition(order.Status, status) {
|
||
return errors.New("无效的状态转换")
|
||
}
|
||
|
||
updates := map[string]interface{}{
|
||
"status": status,
|
||
"admin_remark": adminRemark,
|
||
"updated_at": time.Now(),
|
||
}
|
||
|
||
// 根据状态设置相应的时间字段
|
||
switch status {
|
||
case 2: // 已付款
|
||
updates["pay_time"] = time.Now()
|
||
case 4: // 已发货
|
||
updates["ship_time"] = time.Now()
|
||
case 6: // 已完成
|
||
updates["receive_time"] = time.Now()
|
||
case 7: // 已取消
|
||
updates["cancel_time"] = time.Now()
|
||
}
|
||
|
||
return s.orderRepo.Update(orderID, updates)
|
||
}
|
||
|
||
// RefundOrder 退款订单（管理员专用）
|
||
func (s *OrderService) RefundOrder(orderID uint, refundAmount float64, refundReason string, adminID uint) error {
|
||
order, err := s.orderRepo.GetByID(orderID)
|
||
if err != nil {
|
||
return errors.New("订单不存在")
|
||
}
|
||
|
||
log.Printf("🔍 [RefundOrder] 订单状态检查 - 订单ID: %d, 当前状态: %d, 状态名称: %s", orderID, order.Status, s.getOrderStatusName(order.Status))
|
||
|
||
// 检查订单状态
|
||
if order.Status != 2 && order.Status != 3 && order.Status != 4 && order.Status != 5 {
|
||
log.Printf("❌ [RefundOrder] 订单状态不允许退款 - 订单ID: %d, 状态: %d", orderID, order.Status)
|
||
return errors.New("订单状态不允许退款")
|
||
}
|
||
|
||
log.Printf("✅ [RefundOrder] 订单状态检查通过 - 订单ID: %d, 状态: %d", orderID, order.Status)
|
||
|
||
// 检查退款金额
|
||
if refundAmount <= 0 || refundAmount > order.PayAmount {
|
||
return errors.New("退款金额无效")
|
||
}
|
||
|
||
// 获取订单商品项
|
||
orderItems, err := s.orderRepo.GetOrderItems(order.ID)
|
||
if err != nil {
|
||
log.Printf("获取订单商品项失败: %v", err)
|
||
return errors.New("获取订单商品项失败")
|
||
}
|
||
|
||
// 恢复库存
|
||
for _, item := range orderItems {
|
||
err := s.productRepo.RestoreStock(item.ProductID, item.Quantity)
|
||
if err != nil {
|
||
log.Printf("恢复库存失败 - 商品ID: %d, 数量: %d, 错误: %v", item.ProductID, item.Quantity, err)
|
||
}
|
||
}
|
||
|
||
// 如果订单已支付，需要减少销量（因为销量在支付时就增加了）
|
||
if order.Status >= 2 && order.PayStatus == 1 {
|
||
for _, item := range orderItems {
|
||
err := s.productRepo.UpdateSales(item.ProductID, -item.Quantity)
|
||
if err != nil {
|
||
log.Printf("❌ [RefundOrder] 减少销量失败 - 商品ID: %d, 数量: %d, 错误: %v", item.ProductID, item.Quantity, err)
|
||
} else {
|
||
log.Printf("✅ [RefundOrder] 退款成功，减少销量 - 商品ID: %d, 数量: %d", item.ProductID, item.Quantity)
|
||
}
|
||
}
|
||
}
|
||
|
||
updates := map[string]interface{}{
|
||
"status": 9, // 已退款
|
||
"refund_amount": refundAmount,
|
||
"refund_reason": refundReason,
|
||
"refund_time": time.Now(),
|
||
"updated_at": time.Now(),
|
||
}
|
||
|
||
log.Printf("🔄 [RefundOrder] 准备更新订单 - 订单ID: %d", orderID)
|
||
log.Printf("🔄 [RefundOrder] 更新字段: %+v", updates)
|
||
|
||
err = s.orderRepo.Update(orderID, updates)
|
||
if err != nil {
|
||
log.Printf("❌ [RefundOrder] 数据库更新失败 - 订单ID: %d, 错误: %v", orderID, err)
|
||
return err
|
||
}
|
||
|
||
log.Printf("✅ [RefundOrder] 数据库更新成功 - 订单ID: %d", orderID)
|
||
return nil
|
||
}
|
||
|
||
// CancelOrderByAdmin 取消订单（管理员专用）
|
||
func (s *OrderService) CancelOrderByAdmin(orderID uint, cancelReason string, adminID uint) error {
|
||
order, err := s.orderRepo.GetByID(orderID)
|
||
if err != nil {
|
||
return errors.New("订单不存在")
|
||
}
|
||
|
||
// 检查订单状态
|
||
if order.Status == 6 || order.Status == 7 || order.Status == 9 {
|
||
return errors.New("订单已完成、已取消或已退款，无法取消")
|
||
}
|
||
|
||
// 恢复库存
|
||
items, err := s.orderRepo.GetOrderItems(order.ID)
|
||
if err == nil {
|
||
for _, item := range items {
|
||
if item.SKUID != nil && *item.SKUID > 0 {
|
||
// 如果有SKU，同时恢复SKU库存和商品库存
|
||
err := s.productRepo.RestoreStockWithSKU(item.ProductID, item.SKUID, item.Quantity)
|
||
if err != nil {
|
||
log.Printf("管理员取消订单时恢复SKU库存失败 - 商品ID: %d, SKU ID: %d, 数量: %d, 错误: %v", item.ProductID, *item.SKUID, item.Quantity, err)
|
||
}
|
||
} else {
|
||
// 如果没有SKU，只恢复商品库存
|
||
s.productRepo.UpdateStock(item.ProductID, int(item.Quantity))
|
||
}
|
||
}
|
||
}
|
||
|
||
// 恢复优惠券（如果订单使用了优惠券）
|
||
if order.CouponID != nil && *order.CouponID > 0 {
|
||
if err := s.couponRepo.RestoreCoupon(*order.CouponID); err != nil {
|
||
log.Printf("管理员取消订单时恢复优惠券失败: orderID=%d, couponID=%d, error=%v", orderID, *order.CouponID, err)
|
||
// 不阻止订单取消，只记录日志
|
||
}
|
||
}
|
||
|
||
updates := map[string]interface{}{
|
||
"status": 7, // 已取消
|
||
"cancel_reason": cancelReason,
|
||
"cancel_time": time.Now(),
|
||
"updated_at": time.Now(),
|
||
}
|
||
|
||
return s.orderRepo.Update(orderID, updates)
|
||
}
|
||
|
||
// GetOrderStatisticsWithDateRange 获取订单统计（带日期范围）
|
||
func (s *OrderService) GetOrderStatisticsWithDateRange(startDate, endDate string) (map[string]interface{}, error) {
|
||
// 暂时使用基础统计方法，后续可以扩展支持日期范围
|
||
return s.orderRepo.GetOrderStatistics()
|
||
}
|
||
|
||
// GetDailyOrderStatisticsWithDateRange 获取每日订单统计（带日期范围）
|
||
func (s *OrderService) GetDailyOrderStatisticsWithDateRange(startDate, endDate string) ([]map[string]interface{}, error) {
|
||
// 解析日期范围，计算天数
|
||
start, err := time.Parse("2006-01-02", startDate)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("invalid start date format: %v", err)
|
||
}
|
||
|
||
end, err := time.Parse("2006-01-02", endDate)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("invalid end date format: %v", err)
|
||
}
|
||
|
||
// 计算天数差
|
||
days := int(end.Sub(start).Hours()/24) + 1
|
||
if days <= 0 {
|
||
days = 1
|
||
}
|
||
|
||
// 使用基础统计方法，但确保天数正确
|
||
return s.orderRepo.GetDailyOrderStatistics(days)
|
||
}
|
||
|
||
// isValidStatusTransition 检查状态转换是否合法
|
||
func (s *OrderService) isValidStatusTransition(currentStatus, newStatus int) bool {
|
||
// 定义合法的状态转换
|
||
validTransitions := map[int][]int{
|
||
1: {2, 7}, // 未付款 -> 已付款, 已取消
|
||
2: {3, 7, 8, 9}, // 已付款 -> 待发货, 已取消, 退货中, 已退款
|
||
3: {4, 7, 8, 9}, // 待发货 -> 已发货, 已取消, 退货中, 已退款
|
||
4: {5, 8, 9}, // 已发货 -> 待收货, 退货中, 已退款
|
||
5: {6, 8, 9}, // 待收货 -> 已完成, 退货中, 已退款
|
||
6: {8, 9}, // 已完成 -> 退货中, 已退款
|
||
7: {}, // 已取消 -> 无法转换到其他状态
|
||
8: {9}, // 退货中 -> 已退款
|
||
9: {}, // 已退款 -> 无法转换到其他状态
|
||
}
|
||
|
||
allowedStatuses, exists := validTransitions[currentStatus]
|
||
if !exists {
|
||
return false
|
||
}
|
||
|
||
for _, status := range allowedStatuses {
|
||
if status == newStatus {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
// GetLogisticsInfo 获取物流信息
|
||
func (s *OrderService) GetLogisticsInfo(orderNo string) (map[string]interface{}, error) {
|
||
order, err := s.orderRepo.GetByOrderNo(orderNo)
|
||
if err != nil {
|
||
return nil, errors.New("订单不存在")
|
||
}
|
||
|
||
if order.LogisticsCompany == "" || order.LogisticsNo == "" {
|
||
return nil, errors.New("订单尚未发货")
|
||
}
|
||
|
||
// 构建物流信息
|
||
logisticsInfo := map[string]interface{}{
|
||
"order_no": order.OrderNo,
|
||
"express_company": order.LogisticsCompany,
|
||
"express_no": order.LogisticsNo,
|
||
"receiver_name": order.ReceiverName,
|
||
"receiver_phone": order.ReceiverPhone,
|
||
"receiver_address": order.ReceiverAddress,
|
||
"ship_time": order.ShippedAt,
|
||
"status": order.Status,
|
||
"status_name": s.getOrderStatusName(order.Status),
|
||
}
|
||
|
||
// 这里可以集成第三方物流API获取实时物流信息
|
||
// 暂时返回基本信息
|
||
logisticsInfo["tracks"] = []map[string]interface{}{
|
||
{
|
||
"time": order.ShippedAt,
|
||
"description": "商品已发货",
|
||
"location": "发货地",
|
||
},
|
||
}
|
||
|
||
return logisticsInfo, nil
|
||
}
|
||
|
||
// UpdateOrderStatus 更新订单状态
|
||
func (s *OrderService) UpdateOrderStatus(orderID uint, status int, adminID uint) error {
|
||
order, err := s.orderRepo.GetByID(orderID)
|
||
if err != nil {
|
||
return errors.New("订单不存在")
|
||
}
|
||
|
||
// 验证状态转换的合法性
|
||
if !s.isValidStatusTransition(order.Status, status) {
|
||
return errors.New("无效的状态转换")
|
||
}
|
||
|
||
updates := map[string]interface{}{
|
||
"status": status,
|
||
"updated_at": time.Now(),
|
||
}
|
||
|
||
// 根据状态设置相应的时间字段
|
||
switch status {
|
||
case 2: // 已付款
|
||
updates["pay_time"] = time.Now()
|
||
updates["pay_status"] = 1
|
||
case 4: // 已发货
|
||
updates["shipped_at"] = time.Now()
|
||
case 6: // 已完成
|
||
updates["receive_time"] = time.Now()
|
||
case 7: // 已取消
|
||
updates["cancel_time"] = time.Now()
|
||
case 8: // 退货中
|
||
// 退货中状态不需要特殊的时间字段，由退款记录表管理
|
||
case 9: // 已退款
|
||
updates["refund_time"] = time.Now()
|
||
}
|
||
|
||
err = s.orderRepo.Update(orderID, updates)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
// 处理状态变更后的业务逻辑
|
||
return s.handleOrderStatusChange(order, status, adminID)
|
||
}
|
||
|
||
// handleOrderStatusChange 处理订单状态变更后的业务逻辑
|
||
func (s *OrderService) handleOrderStatusChange(order *model.Order, newStatus int, adminID uint) error {
|
||
switch newStatus {
|
||
case 8: // 退货中
|
||
// 当订单状态变为退货中时，可以在这里添加额外的业务逻辑
|
||
// 例如：通知相关人员、记录日志等
|
||
log.Printf("订单 %s 状态变更为退货中", order.OrderNo)
|
||
|
||
case 9: // 已退款
|
||
// 当订单状态变为已退款时，处理库存恢复等业务逻辑
|
||
log.Printf("订单 %s 状态变更为已退款，开始处理库存恢复", order.OrderNo)
|
||
|
||
// 获取订单项
|
||
orderItems, err := s.orderRepo.GetOrderItems(order.ID)
|
||
if err != nil {
|
||
log.Printf("获取订单项失败: %v", err)
|
||
return err
|
||
}
|
||
|
||
// 恢复库存（如果订单已支付）
|
||
if order.Status >= 2 && order.PayStatus == 1 {
|
||
for _, item := range orderItems {
|
||
// 恢复库存
|
||
err := s.productRepo.UpdateStock(item.ProductID, item.Quantity)
|
||
if err != nil {
|
||
log.Printf("恢复库存失败 - 商品ID: %d, 数量: %d, 错误: %v", item.ProductID, item.Quantity, err)
|
||
} else {
|
||
log.Printf("库存恢复成功 - 商品ID: %d, 数量: %d", item.ProductID, item.Quantity)
|
||
}
|
||
|
||
// 减少销量
|
||
err = s.productRepo.UpdateSales(item.ProductID, -item.Quantity)
|
||
if err != nil {
|
||
log.Printf("减少销量失败 - 商品ID: %d, 数量: %d, 错误: %v", item.ProductID, item.Quantity, err)
|
||
} else {
|
||
log.Printf("销量减少成功 - 商品ID: %d, 数量: %d", item.ProductID, item.Quantity)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// BatchUpdateOrderStatus 批量更新订单状态
|
||
func (s *OrderService) BatchUpdateOrderStatus(orderIDs []uint, status int, adminID uint) error {
|
||
for _, orderID := range orderIDs {
|
||
if err := s.UpdateOrderStatus(orderID, status, adminID); err != nil {
|
||
return fmt.Errorf("更新订单 %d 状态失败: %v", orderID, err)
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// ProcessRefund 处理退款
|
||
func (s *OrderService) ProcessRefund(orderID uint, refundAmount float64, refundReason string, adminID uint) error {
|
||
order, err := s.orderRepo.GetByID(orderID)
|
||
if err != nil {
|
||
return errors.New("订单不存在")
|
||
}
|
||
|
||
// 检查订单状态
|
||
if order.Status != 2 && order.Status != 3 && order.Status != 4 && order.Status != 5 {
|
||
return errors.New("订单状态不允许退款")
|
||
}
|
||
|
||
// 检查退款金额
|
||
if refundAmount <= 0 || refundAmount > order.PayAmount {
|
||
return errors.New("退款金额无效")
|
||
}
|
||
|
||
// 获取订单商品项
|
||
orderItems, err := s.orderRepo.GetOrderItems(order.ID)
|
||
if err != nil {
|
||
return errors.New("获取订单商品项失败")
|
||
}
|
||
|
||
// 恢复库存
|
||
for _, item := range orderItems {
|
||
if err := s.productRepo.RestoreStock(item.ProductID, item.Quantity); err != nil {
|
||
log.Printf("恢复库存失败 - 商品ID: %d, 数量: %d, 错误: %v", item.ProductID, item.Quantity, err)
|
||
}
|
||
}
|
||
|
||
// 减少销量
|
||
if order.Status >= 2 && order.PayStatus == 1 {
|
||
for _, item := range orderItems {
|
||
if err := s.productRepo.UpdateSales(item.ProductID, -item.Quantity); err != nil {
|
||
log.Printf("减少销量失败 - 商品ID: %d, 数量: %d, 错误: %v", item.ProductID, item.Quantity, err)
|
||
}
|
||
}
|
||
}
|
||
|
||
// 更新订单状态
|
||
updates := map[string]interface{}{
|
||
"status": 9, // 已退款
|
||
"refund_amount": refundAmount,
|
||
"refund_time": time.Now(),
|
||
"cancel_reason": refundReason,
|
||
"updated_at": time.Now(),
|
||
}
|
||
|
||
return s.orderRepo.Update(orderID, updates)
|
||
}
|
||
|
||
// GetOrderStatistics 获取订单统计
|
||
func (s *OrderService) GetOrderStatistics() (map[string]interface{}, error) {
|
||
return s.orderRepo.GetOrderStatistics()
|
||
}
|
||
|
||
// GetDailyOrderStatistics 获取每日订单统计
|
||
func (s *OrderService) GetDailyOrderStatistics(days int) ([]map[string]interface{}, error) {
|
||
return s.orderRepo.GetDailyOrderStatistics(days)
|
||
}
|
||
|
||
// GetOrdersByDateRange 根据日期范围获取订单
|
||
func (s *OrderService) GetOrdersByDateRange(startDate, endDate string, status int, offset, limit int) ([]model.Order, int64, error) {
|
||
conditions := make(map[string]interface{})
|
||
|
||
if startDate != "" {
|
||
conditions["start_date"] = startDate
|
||
}
|
||
if endDate != "" {
|
||
conditions["end_date"] = endDate
|
||
}
|
||
if status > 0 {
|
||
conditions["status"] = status
|
||
}
|
||
|
||
return s.orderRepo.GetList(offset, limit, conditions)
|
||
}
|
||
|
||
// ExportOrdersToExcel 导出订单到Excel
|
||
func (s *OrderService) ExportOrdersToExcel(conditions map[string]interface{}) ([]map[string]interface{}, error) {
|
||
// 获取所有符合条件的订单
|
||
orders, _, err := s.orderRepo.GetList(0, 10000, conditions) // 限制最大导出数量
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
var exportData []map[string]interface{}
|
||
for _, order := range orders {
|
||
data := map[string]interface{}{
|
||
"订单号": order.OrderNo,
|
||
"用户ID": order.UserID,
|
||
"店铺ID": order.StoreID,
|
||
"订单状态": s.getOrderStatusName(order.Status),
|
||
"订单金额": order.TotalAmount,
|
||
"实付金额": order.PayAmount,
|
||
"优惠金额": order.DiscountAmount,
|
||
"运费": order.ShippingFee,
|
||
"收货人": order.ReceiverName,
|
||
"收货电话": order.ReceiverPhone,
|
||
"收货地址": order.ReceiverAddress,
|
||
"快递公司": order.LogisticsCompany,
|
||
"快递单号": order.LogisticsNo,
|
||
"支付方式": order.PayMethod,
|
||
"支付时间": s.formatTime(order.PayTime),
|
||
"发货时间": s.formatTime(order.ShippedAt),
|
||
"收货时间": s.formatTime(order.ReceiveTime),
|
||
"取消时间": s.formatTime(order.CancelTime),
|
||
"取消原因": order.CancelReason,
|
||
"退款金额": order.RefundAmount,
|
||
"退款时间": s.formatTime(order.RefundTime),
|
||
"备注": order.Remark,
|
||
"创建时间": order.CreatedAt.Format("2006-01-02 15:04:05"),
|
||
"更新时间": order.UpdatedAt.Format("2006-01-02 15:04:05"),
|
||
}
|
||
exportData = append(exportData, data)
|
||
}
|
||
|
||
return exportData, nil
|
||
}
|
||
|
||
// GetOrderTrends 获取订单趋势
|
||
func (s *OrderService) GetOrderTrends(days int) (map[string]interface{}, error) {
|
||
dailyStats, err := s.GetDailyOrderStatistics(days)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
var dates []string
|
||
var orderCounts []int
|
||
var amounts []float64
|
||
|
||
for _, stat := range dailyStats {
|
||
if date, ok := stat["date"].(string); ok {
|
||
dates = append(dates, date)
|
||
}
|
||
if count, ok := stat["order_count"].(int64); ok {
|
||
orderCounts = append(orderCounts, int(count))
|
||
}
|
||
if amount, ok := stat["total_amount"].(float64); ok {
|
||
amounts = append(amounts, amount)
|
||
}
|
||
}
|
||
|
||
return map[string]interface{}{
|
||
"dates": dates,
|
||
"order_counts": orderCounts,
|
||
"amounts": amounts,
|
||
}, nil
|
||
}
|
||
|
||
|
||
|
||
// getOrderStatusName 获取订单状态名称
|
||
func (s *OrderService) getOrderStatusName(status int) string {
|
||
statusNames := map[int]string{
|
||
1: "未付款",
|
||
2: "待发货", // 统一为待发货
|
||
3: "待发货", // 统一为待发货
|
||
4: "已发货",
|
||
5: "待收货",
|
||
6: "已完成",
|
||
7: "已取消",
|
||
8: "退货中",
|
||
9: "已退款",
|
||
}
|
||
|
||
if name, exists := statusNames[status]; exists {
|
||
return name
|
||
}
|
||
return "未知状态"
|
||
}
|
||
|
||
// formatTime 格式化时间
|
||
func (s *OrderService) formatTime(t *time.Time) string {
|
||
if t == nil {
|
||
return ""
|
||
}
|
||
return t.Format("2006-01-02 15:04:05")
|
||
} |