661 lines
16 KiB
Go
661 lines
16 KiB
Go
package service
|
||
|
||
import (
|
||
"dianshang/internal/model"
|
||
"dianshang/internal/repository"
|
||
"errors"
|
||
"fmt"
|
||
"time"
|
||
|
||
"gorm.io/gorm"
|
||
)
|
||
|
||
// CartService 购物车服务
|
||
type CartService struct {
|
||
orderRepo *repository.OrderRepository
|
||
productRepo *repository.ProductRepository
|
||
userRepo *repository.UserRepository
|
||
}
|
||
|
||
// NewCartService 创建购物车服务
|
||
func NewCartService(orderRepo *repository.OrderRepository, productRepo *repository.ProductRepository, userRepo *repository.UserRepository) *CartService {
|
||
return &CartService{
|
||
orderRepo: orderRepo,
|
||
productRepo: productRepo,
|
||
userRepo: userRepo,
|
||
}
|
||
}
|
||
|
||
// GetCart 获取购物车
|
||
func (s *CartService) GetCart(userID uint) ([]model.Cart, error) {
|
||
// 检查用户是否存在
|
||
_, err := s.userRepo.GetByID(userID)
|
||
if err != nil {
|
||
return nil, errors.New("用户不存在")
|
||
}
|
||
|
||
return s.orderRepo.GetCart(userID)
|
||
}
|
||
|
||
// AddToCart 添加到购物车
|
||
func (s *CartService) AddToCart(userID, productID uint, skuID uint, quantity int) error {
|
||
// 检查用户是否存在
|
||
_, err := s.userRepo.GetByID(userID)
|
||
if err != nil {
|
||
return errors.New("用户不存在")
|
||
}
|
||
|
||
// 检查产品是否存在
|
||
product, err := s.productRepo.GetByID(productID)
|
||
if err != nil {
|
||
return errors.New("产品不存在")
|
||
}
|
||
|
||
// 检查产品状态
|
||
if product.Status != 1 {
|
||
return errors.New("产品已下架")
|
||
}
|
||
|
||
// 检查库存
|
||
if product.Stock < quantity {
|
||
return errors.New("库存不足")
|
||
}
|
||
|
||
// 检查购物车中是否已存在该商品（包括SKU）
|
||
existingCart, err := s.orderRepo.GetCartItemBySKU(userID, productID, skuID)
|
||
if err == nil && existingCart != nil {
|
||
// 已存在，更新数量
|
||
newQuantity := existingCart.Quantity + quantity
|
||
if product.Stock < newQuantity {
|
||
return errors.New("库存不足")
|
||
}
|
||
return s.orderRepo.UpdateCartItem(existingCart.ID, newQuantity)
|
||
}
|
||
|
||
// 如果不是记录不存在的错误，返回错误
|
||
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
|
||
return err
|
||
}
|
||
|
||
// 不存在，添加新项
|
||
var skuPtr *uint
|
||
if skuID != 0 {
|
||
skuPtr = &skuID
|
||
}
|
||
cart := &model.Cart{
|
||
UserID: userID,
|
||
ProductID: productID,
|
||
SKUID: skuPtr,
|
||
Quantity: quantity,
|
||
Selected: true,
|
||
CreatedAt: time.Now(),
|
||
UpdatedAt: time.Now(),
|
||
}
|
||
|
||
return s.orderRepo.AddToCart(cart)
|
||
}
|
||
|
||
// UpdateCartItem 更新购物车项
|
||
func (s *CartService) UpdateCartItem(userID, productID uint, quantity int) error {
|
||
// 检查用户是否存在
|
||
_, err := s.userRepo.GetByID(userID)
|
||
if err != nil {
|
||
return errors.New("用户不存在")
|
||
}
|
||
|
||
// 获取该用户该产品的所有购物车项
|
||
cartItems, err := s.orderRepo.GetCart(userID)
|
||
if err != nil {
|
||
return errors.New("获取购物车失败")
|
||
}
|
||
|
||
// 查找匹配的购物车项
|
||
var targetCartItem *model.Cart
|
||
for _, item := range cartItems {
|
||
if item.ProductID == productID {
|
||
targetCartItem = &item
|
||
break
|
||
}
|
||
}
|
||
|
||
if targetCartItem == nil {
|
||
return errors.New("购物车项不存在")
|
||
}
|
||
|
||
if quantity == 0 {
|
||
// 数量为0，删除该项
|
||
return s.orderRepo.RemoveFromCart(userID, productID)
|
||
}
|
||
|
||
// 检查产品库存
|
||
product, err := s.productRepo.GetByID(productID)
|
||
if err != nil {
|
||
return errors.New("产品不存在")
|
||
}
|
||
|
||
if product.Stock < quantity {
|
||
return errors.New("库存不足")
|
||
}
|
||
|
||
return s.orderRepo.UpdateCartItem(targetCartItem.ID, quantity)
|
||
}
|
||
|
||
// UpdateCartItemBySKU 基于SKU更新购物车项
|
||
func (s *CartService) UpdateCartItemBySKU(userID, productID, skuID uint, quantity int) error {
|
||
// 检查用户是否存在
|
||
_, err := s.userRepo.GetByID(userID)
|
||
if err != nil {
|
||
return errors.New("用户不存在")
|
||
}
|
||
|
||
// 使用SKU查找购物车项
|
||
cartItem, err := s.orderRepo.GetCartItemBySKU(userID, productID, skuID)
|
||
if err != nil {
|
||
return errors.New("购物车项不存在")
|
||
}
|
||
|
||
if quantity == 0 {
|
||
// 数量为0，删除该项
|
||
return s.orderRepo.RemoveFromCartBySKU(userID, productID, skuID)
|
||
}
|
||
|
||
// 检查产品库存
|
||
product, err := s.productRepo.GetByID(productID)
|
||
if err != nil {
|
||
return errors.New("产品不存在")
|
||
}
|
||
|
||
if product.Stock < quantity {
|
||
return errors.New("库存不足")
|
||
}
|
||
|
||
return s.orderRepo.UpdateCartItem(cartItem.ID, quantity)
|
||
}
|
||
|
||
// RemoveFromCart 从购物车移除
|
||
func (s *CartService) RemoveFromCart(userID, productID uint) error {
|
||
// 检查用户是否存在
|
||
_, err := s.userRepo.GetByID(userID)
|
||
if err != nil {
|
||
return errors.New("用户不存在")
|
||
}
|
||
|
||
// 获取该用户该产品的所有购物车项
|
||
cartItems, err := s.orderRepo.GetCart(userID)
|
||
if err != nil {
|
||
return errors.New("获取购物车失败")
|
||
}
|
||
|
||
// 查找匹配的购物车项
|
||
var found bool
|
||
for _, item := range cartItems {
|
||
if item.ProductID == productID {
|
||
found = true
|
||
break
|
||
}
|
||
}
|
||
|
||
if !found {
|
||
return errors.New("购物车项不存在")
|
||
}
|
||
|
||
return s.orderRepo.RemoveFromCart(userID, productID)
|
||
}
|
||
|
||
// RemoveFromCartBySKU 基于SKU从购物车移除
|
||
func (s *CartService) RemoveFromCartBySKU(userID, productID, skuID uint) error {
|
||
// 检查用户是否存在
|
||
_, err := s.userRepo.GetByID(userID)
|
||
if err != nil {
|
||
return errors.New("用户不存在")
|
||
}
|
||
|
||
// 使用SKU查找购物车项
|
||
_, err = s.orderRepo.GetCartItemBySKU(userID, productID, skuID)
|
||
if err != nil {
|
||
return errors.New("购物车项不存在")
|
||
}
|
||
|
||
return s.orderRepo.RemoveFromCartBySKU(userID, productID, skuID)
|
||
}
|
||
|
||
// ClearCart 清空购物车
|
||
func (s *CartService) ClearCart(userID uint) error {
|
||
// 检查用户是否存在
|
||
_, err := s.userRepo.GetByID(userID)
|
||
if err != nil {
|
||
return errors.New("用户不存在")
|
||
}
|
||
|
||
return s.orderRepo.ClearCart(userID)
|
||
}
|
||
|
||
// GetCartCount 获取购物车商品数量
|
||
func (s *CartService) GetCartCount(userID uint) (int, error) {
|
||
cart, err := s.GetCart(userID)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
|
||
var count int
|
||
for _, item := range cart {
|
||
count += int(item.Quantity)
|
||
}
|
||
|
||
return count, nil
|
||
}
|
||
|
||
// GetCartTotal 获取购物车总金额
|
||
func (s *CartService) GetCartTotal(userID uint) (float64, error) {
|
||
cart, err := s.GetCart(userID)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
|
||
var total float64
|
||
for _, item := range cart {
|
||
if item.Product.ID != 0 {
|
||
// 将价格从分转换为元
|
||
total += (float64(item.Product.Price) / 100) * float64(item.Quantity)
|
||
}
|
||
}
|
||
|
||
return total, nil
|
||
}
|
||
|
||
// SelectCartItem 选择/取消选择购物车项
|
||
func (s *CartService) SelectCartItem(userID, cartID uint, selected bool) error {
|
||
// 检查用户是否存在
|
||
_, err := s.userRepo.GetByID(userID)
|
||
if err != nil {
|
||
return errors.New("用户不存在")
|
||
}
|
||
|
||
return s.orderRepo.SelectCartItem(userID, cartID, selected)
|
||
}
|
||
|
||
// SelectAllCartItems 全选/取消全选购物车
|
||
func (s *CartService) SelectAllCartItems(userID uint, selected bool) error {
|
||
// 检查用户是否存在
|
||
_, err := s.userRepo.GetByID(userID)
|
||
if err != nil {
|
||
return errors.New("用户不存在")
|
||
}
|
||
|
||
return s.orderRepo.SelectAllCartItems(userID, selected)
|
||
}
|
||
|
||
// BatchAddToCart 批量添加到购物车
|
||
func (s *CartService) BatchAddToCart(userID uint, items []struct {
|
||
ProductID uint `json:"product_id"`
|
||
SKUID uint `json:"sku_id"`
|
||
Quantity int `json:"quantity"`
|
||
}) error {
|
||
// 检查用户是否存在
|
||
_, err := s.userRepo.GetByID(userID)
|
||
if err != nil {
|
||
return errors.New("用户不存在")
|
||
}
|
||
|
||
// 验证所有商品
|
||
for _, item := range items {
|
||
product, err := s.productRepo.GetByID(item.ProductID)
|
||
if err != nil {
|
||
return errors.New("商品不存在: " + err.Error())
|
||
}
|
||
|
||
if product.Status != 1 {
|
||
return errors.New("商品已下架")
|
||
}
|
||
|
||
if product.Stock < item.Quantity {
|
||
return errors.New("商品库存不足")
|
||
}
|
||
}
|
||
|
||
// 批量添加
|
||
for _, item := range items {
|
||
err := s.AddToCart(userID, item.ProductID, item.SKUID, item.Quantity)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// BatchRemoveFromCart 批量从购物车移除
|
||
func (s *CartService) BatchRemoveFromCart(userID uint, cartIDs []uint) error {
|
||
// 检查用户是否存在
|
||
_, err := s.userRepo.GetByID(userID)
|
||
if err != nil {
|
||
return errors.New("用户不存在")
|
||
}
|
||
|
||
return s.orderRepo.BatchRemoveFromCart(userID, cartIDs)
|
||
}
|
||
|
||
// BatchUpdateCartItems 批量更新购物车项
|
||
func (s *CartService) BatchUpdateCartItems(userID uint, updates []struct {
|
||
CartID uint `json:"cart_id"`
|
||
Quantity int `json:"quantity"`
|
||
}) error {
|
||
// 检查用户是否存在
|
||
_, err := s.userRepo.GetByID(userID)
|
||
if err != nil {
|
||
return errors.New("用户不存在")
|
||
}
|
||
|
||
// 获取购物车项并验证
|
||
for _, update := range updates {
|
||
cartItem, err := s.orderRepo.GetCartItem(userID, update.CartID)
|
||
if err != nil {
|
||
return errors.New("购物车项不存在")
|
||
}
|
||
|
||
// 检查库存
|
||
product, err := s.productRepo.GetByID(cartItem.ProductID)
|
||
if err != nil {
|
||
return errors.New("商品不存在")
|
||
}
|
||
|
||
if product.Stock < update.Quantity {
|
||
return errors.New("商品库存不足")
|
||
}
|
||
|
||
// 更新数量
|
||
if update.Quantity == 0 {
|
||
err = s.orderRepo.RemoveCartItem(update.CartID)
|
||
} else {
|
||
err = s.orderRepo.UpdateCartItem(update.CartID, update.Quantity)
|
||
}
|
||
|
||
if err != nil {
|
||
return err
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// GetCartWithDetails 获取购物车详细信息（包含商品详情）
|
||
func (s *CartService) GetCartWithDetails(userID uint) (map[string]interface{}, error) {
|
||
// 检查用户是否存在
|
||
_, err := s.userRepo.GetByID(userID)
|
||
if err != nil {
|
||
return nil, errors.New("用户不存在")
|
||
}
|
||
|
||
cart, err := s.orderRepo.GetCart(userID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
var validItems []model.Cart
|
||
var invalidItems []model.Cart
|
||
var totalAmount float64
|
||
var totalQuantity int
|
||
var selectedAmount float64
|
||
var selectedQuantity int
|
||
|
||
for _, item := range cart {
|
||
// 检查商品是否有效
|
||
product, err := s.productRepo.GetByID(item.ProductID)
|
||
if err != nil || product.Status != 1 {
|
||
invalidItems = append(invalidItems, item)
|
||
continue
|
||
}
|
||
|
||
// 检查库存
|
||
if product.Stock < item.Quantity {
|
||
item.Product = *product
|
||
invalidItems = append(invalidItems, item)
|
||
continue
|
||
}
|
||
|
||
// 计算价格
|
||
item.Product = *product
|
||
itemPrice := float64(product.Price) / 100 * float64(item.Quantity)
|
||
totalAmount += itemPrice
|
||
totalQuantity += item.Quantity
|
||
|
||
if item.Selected {
|
||
selectedAmount += itemPrice
|
||
selectedQuantity += item.Quantity
|
||
}
|
||
|
||
validItems = append(validItems, item)
|
||
}
|
||
|
||
return map[string]interface{}{
|
||
"valid_items": validItems,
|
||
"invalid_items": invalidItems,
|
||
"total_amount": totalAmount,
|
||
"total_quantity": totalQuantity,
|
||
"selected_amount": selectedAmount,
|
||
"selected_quantity": selectedQuantity,
|
||
"valid_count": len(validItems),
|
||
"invalid_count": len(invalidItems),
|
||
}, nil
|
||
}
|
||
|
||
// ValidateCartItems 验证购物车商品有效性
|
||
func (s *CartService) ValidateCartItems(userID uint) (map[string]interface{}, error) {
|
||
// 检查用户是否存在
|
||
_, err := s.userRepo.GetByID(userID)
|
||
if err != nil {
|
||
return nil, errors.New("用户不存在")
|
||
}
|
||
|
||
cart, err := s.orderRepo.GetCart(userID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
var validItems []uint
|
||
var invalidItems []struct {
|
||
CartID uint `json:"cart_id"`
|
||
Reason string `json:"reason"`
|
||
}
|
||
|
||
for _, item := range cart {
|
||
// 检查商品是否存在
|
||
product, err := s.productRepo.GetByID(item.ProductID)
|
||
if err != nil {
|
||
invalidItems = append(invalidItems, struct {
|
||
CartID uint `json:"cart_id"`
|
||
Reason string `json:"reason"`
|
||
}{
|
||
CartID: item.ID,
|
||
Reason: "商品不存在",
|
||
})
|
||
continue
|
||
}
|
||
|
||
// 检查商品状态
|
||
if product.Status != 1 {
|
||
invalidItems = append(invalidItems, struct {
|
||
CartID uint `json:"cart_id"`
|
||
Reason string `json:"reason"`
|
||
}{
|
||
CartID: item.ID,
|
||
Reason: "商品已下架",
|
||
})
|
||
continue
|
||
}
|
||
|
||
// 检查库存
|
||
if product.Stock < item.Quantity {
|
||
invalidItems = append(invalidItems, struct {
|
||
CartID uint `json:"cart_id"`
|
||
Reason string `json:"reason"`
|
||
}{
|
||
CartID: item.ID,
|
||
Reason: "库存不足",
|
||
})
|
||
continue
|
||
}
|
||
|
||
validItems = append(validItems, item.ID)
|
||
}
|
||
|
||
return map[string]interface{}{
|
||
"valid_items": validItems,
|
||
"invalid_items": invalidItems,
|
||
"valid_count": len(validItems),
|
||
"invalid_count": len(invalidItems),
|
||
}, nil
|
||
}
|
||
|
||
// CleanInvalidCartItems 清理无效的购物车项
|
||
func (s *CartService) CleanInvalidCartItems(userID uint) error {
|
||
// 检查用户是否存在
|
||
_, err := s.userRepo.GetByID(userID)
|
||
if err != nil {
|
||
return errors.New("用户不存在")
|
||
}
|
||
|
||
validation, err := s.ValidateCartItems(userID)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
invalidItems := validation["invalid_items"].([]struct {
|
||
CartID uint `json:"cart_id"`
|
||
Reason string `json:"reason"`
|
||
})
|
||
|
||
if len(invalidItems) == 0 {
|
||
return nil
|
||
}
|
||
|
||
var cartIDs []uint
|
||
for _, item := range invalidItems {
|
||
cartIDs = append(cartIDs, item.CartID)
|
||
}
|
||
|
||
return s.orderRepo.BatchRemoveFromCart(userID, cartIDs)
|
||
}
|
||
|
||
// GetCartSummary 获取购物车摘要信息
|
||
func (s *CartService) GetCartSummary(userID uint) (map[string]interface{}, error) {
|
||
// 检查用户是否存在
|
||
_, err := s.userRepo.GetByID(userID)
|
||
if err != nil {
|
||
return nil, errors.New("用户不存在")
|
||
}
|
||
|
||
details, err := s.GetCartWithDetails(userID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return map[string]interface{}{
|
||
"total_items": details["valid_count"].(int) + details["invalid_count"].(int),
|
||
"valid_items": details["valid_count"],
|
||
"invalid_items": details["invalid_count"],
|
||
"total_amount": details["total_amount"],
|
||
"selected_amount": details["selected_amount"],
|
||
"total_quantity": details["total_quantity"],
|
||
"selected_quantity": details["selected_quantity"],
|
||
}, nil
|
||
}
|
||
|
||
// MergeCart 合并购物车（用于登录后合并游客购物车）
|
||
func (s *CartService) MergeCart(userID uint, guestCartItems []struct {
|
||
ProductID uint `json:"product_id"`
|
||
SKUID uint `json:"sku_id"`
|
||
Quantity int `json:"quantity"`
|
||
}) error {
|
||
// 检查用户是否存在
|
||
_, err := s.userRepo.GetByID(userID)
|
||
if err != nil {
|
||
return errors.New("用户不存在")
|
||
}
|
||
|
||
// 获取用户现有购物车
|
||
existingCart, err := s.orderRepo.GetCart(userID)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
// 创建现有购物车的映射
|
||
existingMap := make(map[string]*model.Cart)
|
||
for i, item := range existingCart {
|
||
key := fmt.Sprintf("%d_%d", item.ProductID, item.SKUID)
|
||
if item.SKUID == nil {
|
||
key = fmt.Sprintf("%d_0", item.ProductID)
|
||
}
|
||
existingMap[key] = &existingCart[i]
|
||
}
|
||
|
||
// 合并游客购物车项
|
||
for _, guestItem := range guestCartItems {
|
||
key := fmt.Sprintf("%d_%d", guestItem.ProductID, guestItem.SKUID)
|
||
if guestItem.SKUID == 0 {
|
||
key = fmt.Sprintf("%d_0", guestItem.ProductID)
|
||
}
|
||
|
||
if existingItem, exists := existingMap[key]; exists {
|
||
// 已存在，更新数量
|
||
newQuantity := existingItem.Quantity + guestItem.Quantity
|
||
err = s.orderRepo.UpdateCartItem(existingItem.ID, newQuantity)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
} else {
|
||
// 不存在，添加新项
|
||
err = s.AddToCart(userID, guestItem.ProductID, guestItem.SKUID, guestItem.Quantity)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// GetSelectedCartItems 获取选中的购物车项
|
||
func (s *CartService) GetSelectedCartItems(userID uint) ([]model.Cart, error) {
|
||
// 检查用户是否存在
|
||
_, err := s.userRepo.GetByID(userID)
|
||
if err != nil {
|
||
return nil, errors.New("用户不存在")
|
||
}
|
||
|
||
return s.orderRepo.GetSelectedCartItems(userID)
|
||
}
|
||
|
||
// CalculateCartDiscount 计算购物车优惠（预留接口）
|
||
func (s *CartService) CalculateCartDiscount(userID uint, couponID uint) (map[string]interface{}, error) {
|
||
// 检查用户是否存在
|
||
_, err := s.userRepo.GetByID(userID)
|
||
if err != nil {
|
||
return nil, errors.New("用户不存在")
|
||
}
|
||
|
||
selectedItems, err := s.GetSelectedCartItems(userID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
var originalAmount float64
|
||
for _, item := range selectedItems {
|
||
product, err := s.productRepo.GetByID(item.ProductID)
|
||
if err != nil {
|
||
continue
|
||
}
|
||
originalAmount += float64(product.Price) / 100 * float64(item.Quantity)
|
||
}
|
||
|
||
// 这里可以添加优惠券计算逻辑
|
||
discountAmount := 0.0
|
||
finalAmount := originalAmount - discountAmount
|
||
|
||
return map[string]interface{}{
|
||
"original_amount": originalAmount,
|
||
"discount_amount": discountAmount,
|
||
"final_amount": finalAmount,
|
||
"coupon_id": couponID,
|
||
}, nil
|
||
} |