DaShangDao/daShangDao_psiServer
8
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
96c39486af
daShangDao_psiServer/service/product.go
Administrator 96c39486af 最新版本
2026-06-18 13:01:56 +08:00

2905 lines
93 KiB
Go
Raw Blame History

package service
import (
"bytes"
"crypto/md5"
"encoding/json"
"errors"
"fmt"
"github.com/xuri/excelize/v2"
"gorm.io/datatypes"
"gorm.io/gorm"
"io"
"net/http"
"psi/config"
"psi/constant"
"psi/database"
"psi/models"
systemReq "psi/models/request"
systemRes "psi/models/response"
"psi/utils"
"strconv"
"strings"
"time"
)
type ProductService struct{}
type OutTaskInfo struct {
ShopList []systemRes.ShopInfo
}
// 获取商品列表
func (s *ProductService) GetProductList(req systemReq.GetProductListRequest, db ...*gorm.DB) (*systemRes.ProductListResponse, error) {
databaseConn := database.OptionalDB(db...)
if req.Page < 1 {
req.Page = 1
}
if req.PageSize < 1 || req.PageSize > 100 {
req.PageSize = 20
}
query := databaseConn.Model(&models.Product{}).Where("product.is_del = ?", 0)
if len(req.IDs) > 0 {
query = query.Where("product.id IN ?", req.IDs)
}
if req.Status != "" {
query = query.Where("product.status = ?", req.Status)
}
if req.Keyword != "" {
query = query.Where("product.name LIKE ? OR product.barcode LIKE ?", "%"+req.Keyword+"%", "%"+req.Keyword+"%")
}
if req.StartCreatedAt > 0 {
query = query.Where("product.created_at >= ?", req.StartCreatedAt)
}
if req.EndCreatedAt > 0 {
query = query.Where("product.created_at <= ?", req.EndCreatedAt)
}
if req.MinSalePrice > 0 {
query = query.Where("product.sale_price >= ?", req.MinSalePrice)
}
if req.MaxSalePrice > 0 {
query = query.Where("product.sale_price <= ?", req.MaxSalePrice)
}
if req.WarehouseID > 0 || req.MinStock > 0 || req.MaxStock > 0 || req.LocationID > 0 {
query = query.Joins("LEFT JOIN inventory_detail inv_filter ON inv_filter.product_id = product.id AND inv_filter.is_del = ?", 0)
if req.WarehouseID > 0 {
query = query.Where("inv_filter.warehouse_id = ?", req.WarehouseID)
}
if req.MinStock > 0 {
query = query.Where("COALESCE(inv_filter.quantity, 0) > ?", req.MinStock)
}
if req.MaxStock > 0 {
query = query.Where("COALESCE(inv_filter.quantity, 0) < ?", req.MaxStock)
}
if req.LocationID > 0 {
query = query.Where("inv_filter.location_id = ?", req.LocationID)
}
}
var total int64
if err := query.Count(&total).Error; err != nil {
return nil, utils.NewError("查询总数失败")
}
var products []systemRes.ProductWithInfo
offset := (req.Page - 1) * req.PageSize
if err := query.Select("product.*,c.name as category_name,w.id as warehouse_id,w.code as warehouse_code,w.name as warehouse_name,l.id as location_id,l.code as location_code,t.quantity").
Joins("LEFT JOIN product_category c ON c.id = product.category_id").
Joins("LEFT JOIN inventory t ON t.product_id = product.id").
Joins("LEFT JOIN inventory_detail i ON i.product_id = product.id").
Joins("LEFT JOIN warehouse w ON w.id = i.warehouse_id").
Joins("LEFT JOIN location l ON l.id = i.location_id").
Order("created_at DESC").Offset(offset).Limit(req.PageSize).Find(&products).Error; err != nil {
return nil, utils.NewError("查询商品列表失败")
}
productIDs := make([]int64, 0, len(products))
for _, product := range products {
productIDs = append(productIDs, product.ID)
}
outTaskInfoMap, err := s.getProductOutTaskInfo(databaseConn, productIDs)
if err != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "查询商品任务信息",
"error": fmt.Sprintf("查询失败: %v", err),
})
}
var productItems []systemRes.ProductItem
for _, product := range products {
item := systemRes.ConvertProductWithInfoToItem(product)
if outTaskInfo, exists := outTaskInfoMap[product.ID]; exists {
item.ShopList = outTaskInfo.ShopList
}
// item.LiveImage[0] 按照 , 分割数组
liveImage := strings.Split(item.LiveImage[0], ",")
item.LiveImage[0] = liveImage[0]
productItems = append(productItems, item)
}
return &systemRes.ProductListResponse{
List: productItems,
Total: total,
Page: req.Page,
PageSize: req.PageSize,
}, nil
}
// 获取商品任务信息
func (s *ProductService) GetDistributionProductList(req systemReq.GetDistributionProductListRequest) (*systemRes.ProductListResponse, error) {
databaseConn, err := database.GetTenantDB(req.UserID)
if err != nil {
return nil, utils.NewError("获取数据库连接失败")
}
if req.Page < 1 {
req.Page = 1
}
if req.PageSize < 1 || req.PageSize > 100 {
req.PageSize = 20
}
query := databaseConn.Model(&models.Product{}).Where("product.is_del = ?", 0)
if req.Keyword != "" {
query = query.Where("(product.name LIKE ? OR product.barcode LIKE ?)", "%"+req.Keyword+"%", "%"+req.Keyword+"%")
}
if req.Name != "" {
query = query.Where("product.name LIKE ?", "%"+req.Name+"%")
}
if req.Barcode != "" {
query = query.Where("product.barcode LIKE ?", "%"+req.Barcode+"%")
}
if req.Appearance > 0 {
query = query.Where("product.appearance = ?", req.Appearance)
}
if req.StartCreatedAt > 0 {
query = query.Where("product.created_at >= ?", req.StartCreatedAt)
}
if req.EndCreatedAt > 0 {
query = query.Where("product.created_at <= ?", req.EndCreatedAt)
}
if req.MinSalePrice > 0 {
query = query.Where("product.sale_price >= ?", req.MinSalePrice)
}
if req.MaxSalePrice > 0 {
query = query.Where("product.sale_price <= ?", req.MaxSalePrice)
}
subQuery := databaseConn.Table("inventory").
Select("product_id, SUM(quantity) as total_quantity").
Where("is_del = ?", 0)
if req.StartStockAt > 0 {
subQuery = subQuery.Where("created_at >= ?", req.StartStockAt)
}
if req.EndStockAt > 0 {
subQuery = subQuery.Where("created_at <= ?", req.EndStockAt)
}
if req.WarehouseID > 0 {
subQuery = subQuery.Where("warehouse_id = ?", req.WarehouseID)
}
subQuery = subQuery.Group("product_id").Having("SUM(quantity) > 0")
query = query.Joins("INNER JOIN (?) as inv_sum ON inv_sum.product_id = product.id", subQuery)
if req.LocationID > 0 {
query = query.Joins("INNER JOIN inventory_detail inv_detail ON inv_detail.product_id = product.id AND inv_detail.location_id = ? AND inv_detail.is_del = ?", req.LocationID, 0)
}
if req.MinStock > 0 {
query = query.Where("inv_sum.total_quantity > ?", req.MinStock)
}
if req.MaxStock > 0 {
query = query.Where("inv_sum.total_quantity < ?", req.MaxStock)
}
if req.StockValue > 0 && req.StockOperator != "" {
query = query.Where("inv_sum.total_quantity "+req.StockOperator+" ?", req.StockValue)
}
if req.SalePriceValue > 0 && req.SalePriceOperator != "" {
query = query.Where("product.sale_price "+req.SalePriceOperator+" ?", req.SalePriceValue)
}
var total int64
if err := query.Count(&total).Error; err != nil {
return nil, utils.NewError("查询总数失败")
}
var products []systemRes.ProductWithInfo
offset := (req.Page - 1) * req.PageSize
if err := query.Select("product.*, c.name as category_name, w.id as warehouse_id, w.code as warehouse_code, " +
"w.name as warehouse_name, l.id as location_id, l.code as location_code, inv_sum.total_quantity as quantity, " +
"IF(ls.fir_price IS NOT NULL, ls.fir_price * 100, NULL) as fir_price, " +
"FROM_UNIXTIME(i.created_at, '%Y-%m-%d %H:%i:%s') as inbound_time ").
Joins("LEFT JOIN product_category c ON c.id = product.category_id").
Joins("LEFT JOIN inventory_detail i ON i.product_id = product.id AND i.is_del = 0").
Joins("LEFT JOIN warehouse w ON w.id = i.warehouse_id").
Joins("LEFT JOIN location l ON l.id = i.location_id").
Joins("left join logistics ls ON ls.warehouse_id = w.id and ls.del_flag='0'").
Order("product.created_at DESC").Offset(offset).Limit(req.PageSize).Find(&products).Error; err != nil {
return nil, utils.NewError("查询商品列表失败")
}
var productItems []systemRes.ProductItem
for _, product := range products {
item := systemRes.ConvertProductWithInfoToItem(product)
productItems = append(productItems, item)
}
return &systemRes.ProductListResponse{
List: productItems,
Total: total,
Page: req.Page,
PageSize: req.PageSize,
}, nil
}
// GetProductDetail 获取商品详情
func (s *ProductService) GetProductDetail(req systemReq.GetProductDetailRequest, db ...*gorm.DB) (*systemRes.ProductItem, error) {
databaseConn := database.OptionalDB(db...)
if req.ID <= 0 {
return nil, utils.NewError("商品ID不能为空")
}
var product models.Product
if err := databaseConn.Where("id = ? AND is_del = ?", req.ID, 0).First(&product).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, utils.NewError("商品不存在")
}
return nil, utils.NewError("查询商品详情失败")
}
// 打印SQL
var liveImage []string
if len(product.LiveImage) > 0 {
err := json.Unmarshal(product.LiveImage, &liveImage)
if err != nil {
return nil, err
}
}
item := &systemRes.ProductItem{
ID: product.ID,
CategoryID: product.CategoryID,
StandardProductID: product.StandardProductID,
Name: product.Name,
Appearance: product.Appearance,
Barcode: product.Barcode,
Price: product.Price,
SalePrice: product.SalePrice,
LiveImage: liveImage,
IsBatchManaged: product.IsBatchManaged,
IsShelfLifeManaged: product.IsShelfLifeManaged,
Status: product.Status,
CreatedAt: product.CreatedAt,
UpdatedAt: product.UpdatedAt,
ShopList: []systemRes.ShopInfo{},
}
return item, nil
}
// GetProductFullInfo 获取商品完整信息(包含库存和店铺信息)
func (s *ProductService) GetProductFullInfo(req systemReq.GetProductFullInfoRequest, db ...*gorm.DB) (*systemRes.ProductFullInfoResponse, error) {
databaseConn := database.OptionalDB(db...)
utils.InfoLog(constant.LoggerChannelWork, map[string]interface{}{
"action": "开始查询商品完整信息",
"product_id": req.ProductID,
"user_id": req.UserID,
})
if req.ProductID <= 0 {
return nil, utils.NewError("商品ID不能为空")
}
if req.UserID <= 0 {
return nil, utils.NewError("用户ID不能为空")
}
var product models.Product
if err := databaseConn.Where("id = ? AND is_del = ?", req.ProductID, 0).First(&product).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"action": "商品不存在",
"product_id": req.ProductID,
})
return nil, utils.NewError("商品不存在")
}
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"action": "查询商品失败",
"product_id": req.ProductID,
"error": err.Error(),
})
return nil, utils.NewError("查询商品失败")
}
utils.InfoLog(constant.LoggerChannelWork, map[string]interface{}{
"action": "商品基本信息查询成功",
"product_name": product.Name,
"barcode": product.Barcode,
})
var liveImage []string
if len(product.LiveImage) > 0 {
if err := json.Unmarshal(product.LiveImage, &liveImage); err != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"action": "解析商品图片失败",
"error": err.Error(),
})
liveImage = []string{}
}
}
var categoryName string
if product.CategoryID > 0 {
var category models.ProductCategory
if err := databaseConn.Where("id = ?", product.CategoryID).First(&category).Error; err == nil {
categoryName = category.Name
}
}
var inventories []systemRes.ProductInventoryDetail
if err := databaseConn.Table("inventory_detail inv").
Select("inv.warehouse_id, w.name as warehouse_name, w.code as warehouse_code, inv.location_id, l.code as location_code, l.name as location_name, inv.quantity, inv.inbound_time").
Joins("LEFT JOIN warehouse w ON w.id = inv.warehouse_id").
Joins("LEFT JOIN location l ON l.id = inv.location_id").
Where("inv.product_id = ? AND inv.is_del = ?", req.ProductID, 0).
Scan(&inventories).Error; err != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"action": "查询库存信息失败",
"error": err.Error(),
})
inventories = []systemRes.ProductInventoryDetail{}
}
utils.InfoLog(constant.LoggerChannelWork, map[string]interface{}{
"action": "库存信息查询完成",
"inventory_count": len(inventories),
})
outTaskInfoMap, err := s.getProductOutTaskInfo(databaseConn, []int64{req.ProductID})
if err != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"action": "查询任务信息失败",
"error": err.Error(),
})
}
var shopList []systemRes.ShopInfo
if outTaskInfo, exists := outTaskInfoMap[req.ProductID]; exists {
shopList = outTaskInfo.ShopList
}
response := &systemRes.ProductFullInfoResponse{
ID: product.ID,
CategoryID: product.CategoryID,
CategoryName: categoryName,
StandardProductID: product.StandardProductID,
Name: product.Name,
Appearance: product.Appearance,
Barcode: product.Barcode,
Price: product.Price,
SalePrice: product.SalePrice,
LiveImage: liveImage,
IsBatchManaged: product.IsBatchManaged,
IsShelfLifeManaged: product.IsShelfLifeManaged,
Status: product.Status,
CreatedAt: product.CreatedAt,
UpdatedAt: product.UpdatedAt,
Inventories: inventories,
ShopList: shopList,
}
utils.InfoLog(constant.LoggerChannelWork, map[string]interface{}{
"action": "商品完整信息查询成功",
"success": true,
"shop_count": len(shopList),
})
return response, nil
}
// getProductOutTaskInfo
func (s *ProductService) getProductOutTaskInfo(db *gorm.DB, productIDs []int64) (map[int64]*OutTaskInfo, error) {
resultMap := make(map[int64]*OutTaskInfo)
if len(productIDs) == 0 {
return resultMap, nil
}
type OutTaskResult struct {
ProductID int64 `gorm:"column:product_id"`
ShopID int64 `gorm:"column:shop_id"`
ShopAliasName string `gorm:"column:shop_alias_name"`
ShopType int8 `gorm:"column:shop_type"`
IsSent bool `gorm:"column:is_sent"`
OutTaskLogID int64 `gorm:"column:out_task_log_id"`
OutTaskID int64 `gorm:"column:out_task_id"`
LogStatus int8 `gorm:"column:log_status"`
LogMsg string `gorm:"column:log_msg"`
LogCreatedAt int64 `gorm:"column:log_created_at"`
}
var outTaskResults []OutTaskResult
err := db.Table("wave_task_detail wtd").
Select(`wtd.product_id,
s.id as shop_id,
s.shop_alias_name,
s.shop_type,
CASE WHEN ot.id IS NOT NULL THEN 1 ELSE 0 END as is_sent,
otl.id as out_task_log_id,
ot.out_task_id as out_task_id,
otl.status as log_status,
otl.msg as log_msg,
otl.created_at as log_created_at`).
Joins("INNER JOIN wave_task wt ON wt.id = wtd.wave_task_id AND wt.is_del = 0").
Joins("LEFT JOIN out_task ot ON ot.wave_task_id = wt.id AND ot.is_del = 0").
Joins("LEFT JOIN shop s ON s.id = ot.shop_id AND s.del_flag = 0").
Joins("LEFT JOIN out_task_log otl ON otl.out_task_id = ot.out_task_id AND otl.product_id = wtd.product_id AND otl.is_del = 0 AND otl.id = (SELECT MAX(otl2.id) FROM out_task_log otl2 WHERE otl2.out_task_id = ot.out_task_id AND otl2.product_id = wtd.product_id AND otl2.is_del = 0)").
Where("wtd.product_id IN ? AND wtd.is_del = 0", productIDs).
Order("otl.created_at DESC").
Scan(&outTaskResults).Error
if err != nil {
return nil, err
}
for _, item := range outTaskResults {
if _, exists := resultMap[item.ProductID]; !exists {
resultMap[item.ProductID] = &OutTaskInfo{
ShopList: []systemRes.ShopInfo{},
}
}
outTaskInfo := resultMap[item.ProductID]
if item.ShopAliasName != "" {
shopInfo := systemRes.ShopInfo{
ShopID: strconv.FormatInt(item.ShopID, 10),
ShopAliasName: item.ShopAliasName,
ShopType: item.ShopType,
ShopTypeName: s.getShopTypeName(item.ShopType),
IsSent: item.IsSent,
OutTaskLogID: item.OutTaskLogID,
OutTaskID: item.OutTaskID,
LogStatus: item.LogStatus,
LogMsg: item.LogMsg,
LogCreatedAt: item.LogCreatedAt,
}
exists := false
for _, shop := range outTaskInfo.ShopList {
if shop.ShopAliasName == item.ShopAliasName && shop.ShopType == item.ShopType {
exists = true
break
}
}
if !exists {
outTaskInfo.ShopList = append(outTaskInfo.ShopList, shopInfo)
}
}
}
return resultMap, nil
}
// SaveProduct 保存商品
func (s *ProductService) SaveProduct(req systemReq.ProductRequest, db ...*gorm.DB) (int64, error) {
databaseConn := database.OptionalDB(db...)
now := time.Now().Unix()
if req.ID > 0 {
return s.updateProduct(req, now, databaseConn)
}
return s.createProduct(req, now, databaseConn)
}
// createProduct 创建商品
func (s *ProductService) createProduct(req systemReq.ProductRequest, now int64, db *gorm.DB) (int64, error) {
var liveImage datatypes.JSON
if len(req.LiveImage) > 0 {
jsonBytes, _ := json.Marshal(req.LiveImage)
liveImage = jsonBytes
} else {
liveImage = datatypes.JSON("[]")
}
product := models.Product{
CategoryID: req.CategoryID,
StandardProductID: req.StandardProductID,
Name: req.Name,
Appearance: req.Appearance,
Barcode: req.Barcode,
Price: req.Price,
LiveImage: liveImage,
IsBatchManaged: req.IsBatchManaged,
IsShelfLifeManaged: req.IsShelfLifeManaged,
Status: req.Status,
CreatedAt: now,
UpdatedAt: now,
IsDel: 0,
}
if err := db.Create(&product).Error; err != nil {
return 0, fmt.Errorf("创建商品失败：%w", err)
}
return product.ID, nil
}
// updateProduct 修改商品
func (s *ProductService) updateProduct(req systemReq.ProductRequest, now int64, db *gorm.DB) (int64, error) {
var product models.Product
if err := db.Where("id = ? AND is_del = 0", req.ID).First(&product).Error; err != nil {
return 0, fmt.Errorf("商品不存在：%w", err)
}
var liveImage datatypes.JSON
if len(req.LiveImage) > 0 {
jsonBytes, _ := json.Marshal(req.LiveImage)
liveImage = jsonBytes
} else {
liveImage = product.LiveImage
}
updates := map[string]interface{}{
"category_id": req.CategoryID,
"standard_product_id": req.StandardProductID,
"name": req.Name,
"appearance": req.Appearance,
"barcode": req.Barcode,
"price": req.Price,
"live_image": liveImage,
"is_batch_managed": req.IsBatchManaged,
"is_shelf_life_managed": req.IsShelfLifeManaged,
"status": req.Status,
"updated_at": now,
}
if err := db.Model(&product).Updates(updates).Error; err != nil {
return 0, fmt.Errorf("更新商品失败：%w", err)
}
return product.ID, nil
}
// DeleteProduct 删除商品
func (s *ProductService) DeleteProduct(req systemReq.DeleteProductRequest, db ...*gorm.DB) error {
databaseConn := database.OptionalDB(db...)
var product models.Product
if err := databaseConn.Where("id = ? AND is_del = ?", req.ID, 0).First(&product).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return fmt.Errorf("商品不存在")
}
return fmt.Errorf("查询商品失败: %v", err)
}
now := time.Now().Unix()
err := executeInTransactionWithDB(databaseConn, func(tx *gorm.DB) error {
var purchaseOrderItems []models.PurchaseOrderItem
if err := tx.Where("product_id = ? AND is_del = ?", req.ID, 0).Find(&purchaseOrderItems).Error; err != nil {
return fmt.Errorf("查询采购订单明细失败: %v", err)
}
if len(purchaseOrderItems) > 0 {
purchaseOrderIDs := make([]int64, 0)
for _, item := range purchaseOrderItems {
purchaseOrderIDs = append(purchaseOrderIDs, item.PurchaseOrderID)
}
if err := tx.Model(&models.PurchaseOrderItem{}).
Where("product_id = ? AND is_del = ?", req.ID, 0).
Updates(map[string]interface{}{
"is_del": 1,
"updated_at": now,
}).Error; err != nil {
return fmt.Errorf("删除采购订单明细失败: %v", err)
}
for _, poID := range purchaseOrderIDs {
var remainingItems int64
if err := tx.Model(&models.PurchaseOrderItem{}).
Where("purchase_order_id = ? AND is_del = ?", poID, 0).
Count(&remainingItems).Error; err != nil {
return fmt.Errorf("检查采购订单剩余明细失败: %v", err)
}
if remainingItems == 0 {
if err := tx.Model(&models.PurchaseOrder{}).
Where("id = ? AND is_del = ?", poID, 0).
Updates(map[string]interface{}{
"is_del": 1,
"updated_at": now,
}).Error; err != nil {
return fmt.Errorf("删除采购订单失败: %v", err)
}
}
}
}
var waveHeaders []models.WaveHeader
if err := tx.Where("direction = ? AND status <= ? AND is_del = ?", 1, 2, 0).
Find(&waveHeaders).Error; err != nil {
return fmt.Errorf("查询波次主表失败: %v", err)
}
for _, waveHeader := range waveHeaders {
var waveTasks []models.WaveTask
if err := tx.Where("wave_id = ? AND is_del = ?", waveHeader.ID, 0).
Find(&waveTasks).Error; err != nil {
return fmt.Errorf("查询波次任务失败: %v", err)
}
for _, waveTask := range waveTasks {
var taskDetails []models.WaveTaskDetail
if err := tx.Where("wave_task_id = ? AND product_id = ? AND is_del = ?", waveTask.ID, req.ID, 0).
Find(&taskDetails).Error; err != nil {
return fmt.Errorf("查询波次任务明细失败: %v", err)
}
if len(taskDetails) > 0 {
if err := tx.Model(&models.WaveTaskDetail{}).
Where("wave_task_id = ? AND product_id = ? AND is_del = ?", waveTask.ID, req.ID, 0).
Updates(map[string]interface{}{
"is_del": 1,
"updated_at": now,
}).Error; err != nil {
return fmt.Errorf("删除波次任务明细失败: %v", err)
}
var remainingDetails int64
if err := tx.Model(&models.WaveTaskDetail{}).
Where("wave_task_id = ? AND is_del = ?", waveTask.ID, 0).
Count(&remainingDetails).Error; err != nil {
return fmt.Errorf("检查波次任务剩余明细失败: %v", err)
}
if remainingDetails == 0 {
if err := tx.Model(&models.WaveTask{}).
Where("id = ? AND is_del = ?", waveTask.ID, 0).
Updates(map[string]interface{}{
"is_del": 1,
"updated_at": now,
}).Error; err != nil {
return fmt.Errorf("删除波次任务失败: %v", err)
}
var remainingTasks int64
if err := tx.Model(&models.WaveTask{}).
Where("wave_id = ? AND is_del = ?", waveHeader.ID, 0).
Count(&remainingTasks).Error; err != nil {
return fmt.Errorf("检查波次剩余任务失败: %v", err)
}
if remainingTasks == 0 {
if err := tx.Model(&models.WaveHeader{}).
Where("id = ? AND is_del = ?", waveHeader.ID, 0).
Updates(map[string]interface{}{
"is_del": 1,
"updated_at": now,
}).Error; err != nil {
return fmt.Errorf("删除波次主表失败: %v", err)
}
}
}
}
}
}
if err := tx.Model(&models.Product{}).
Where("id = ? AND is_del = ?", req.ID, 0).
Updates(map[string]interface{}{
"is_del": 1,
"updated_at": now,
}).Error; err != nil {
return fmt.Errorf("删除商品失败: %v", err)
}
return nil
})
if err != nil {
return err
}
return nil
}
// UpdatePrice 修改商品售价
func (s *ProductService) UpdatePrice(req systemReq.UpdatePriceRequest) error {
databaseConn, err := database.GetTenantDB(req.UserID)
if err != nil {
return fmt.Errorf("获取数据库连接失败: %v", err)
}
now := time.Now().Unix()
var product models.Product
if err := databaseConn.Where("id = ? AND is_del = 0", req.ProductID).First(&product).Error; err != nil {
return fmt.Errorf("商品不存在: %v", err)
}
if req.SalePrice < 0 {
return fmt.Errorf("售价不能为负数")
}
if err := databaseConn.Model(&models.Product{}).Where("id = ?", req.ProductID).Updates(map[string]interface{}{
"sale_price": req.SalePrice,
"cost": req.Cost,
"updated_at": now,
}).Error; err != nil {
return fmt.Errorf("更新售价失败: %v", err)
}
shouldSync := true
var waveTaskDetail models.WaveTaskDetail
if err := databaseConn.Where("product_id = ? AND is_del = 0", req.ProductID).First(&waveTaskDetail).Error; err == nil && waveTaskDetail.WaveTaskID > 0 {
var waveTask models.WaveTask
if err := databaseConn.Where("id = ? AND is_del = 0", waveTaskDetail.WaveTaskID).First(&waveTask).Error; err == nil && waveTask.CarId > 0 {
var car models.Car
if err := databaseConn.Where("id = ? AND is_del = 0", waveTask.CarId).First(&car).Error; err == nil {
if car.PushType == 2 {
shouldSync = false
}
}
}
}
if shouldSync {
if err := s.syncPriceToExternal(waveTaskDetail, req.ProductID, req.SalePrice, req.UserID, databaseConn); err != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "同步售价到外部接口",
"product_id": req.ProductID,
"sale_price": req.SalePrice,
"cost": req.Cost,
"error": fmt.Sprintf("同步失败: %v", err),
})
}
}
return nil
}
// GetProductInventory 获取商品库存数量
func (s *ProductService) GetProductInventory(req systemReq.GetProductInventoryRequest) (*systemRes.ProductInventoryResponse, error) {
databaseConn, err := database.GetTenantDB(req.UserID)
if err != nil {
return nil, fmt.Errorf("获取数据库连接失败: %v", err)
}
// 验证商品是否存在，并获取商品信息
var product models.Product
if err := databaseConn.Where("id = ? AND is_del = ?", req.ProductID, 0).First(&product).Error; err != nil {
return nil, fmt.Errorf("商品不存在")
}
var totalQuantity int64
// type=1: 按品相+ISBN+仓库分组后统计总数量
if req.Type == 1 {
type GroupStock struct {
TotalQuantity int64 `gorm:"column:total_quantity"`
}
var groupList []GroupStock
// 先根据商品的 ISBN 和品相，查询所有匹配的库存记录，再按仓库分组统计（可用量 = 总量 - 锁定量）
databaseConn.Table("inventory").
Select(`
COALESCE(SUM(inventory.quantity - inventory.locked_quantity), 0) as total_quantity
`).
Joins("LEFT JOIN product p ON inventory.product_id = p.id AND p.is_del = ?", 0).
Where("p.barcode = ? AND p.appearance = ? AND inventory.warehouse_id IS NOT NULL AND inventory.is_del = ?",
product.Barcode, product.Appearance, 0).
Group("inventory.warehouse_id").
Scan(&groupList)
// 累加所有分组的可用数量
for _, group := range groupList {
totalQuantity += group.TotalQuantity
}
} else {
databaseConn.Table("inventory").
Select("COALESCE(SUM(quantity), 0)").
Where("product_id = ? AND is_del = ?", req.ProductID, 0).
Scan(&totalQuantity)
}
return &systemRes.ProductInventoryResponse{
Quantity: totalQuantity,
}, nil
}
// RetryOutTask 重试失败的外部任务（单条商品）
func (s *ProductService) RetryOutTask(req systemReq.RetryOutTaskRequest, db ...*gorm.DB) error {
databaseConn := database.OptionalDB(db...)
// 验证店铺是否存在
var shop models.Shop
if err := databaseConn.Where("id = ? AND del_flag = ?", req.ShopID, 0).First(&shop).Error; err != nil {
return fmt.Errorf("店铺不存在: %v", err)
}
// 验证店铺类型是否匹配
if shop.ShopType != req.ShopType {
return fmt.Errorf("店铺类型不匹配")
}
// 获取产品信息
var product models.Product
if err := databaseConn.Where("id = ? AND is_del = ?", req.ProductID, 0).First(&product).Error; err != nil {
return fmt.Errorf("商品不存在: %v", err)
}
// 查找该商品的波次任务明细（可能不存在，比如从外部同步的商品）
var waveTaskDetail models.WaveTaskDetail
var hasWaveTask bool
if err := databaseConn.Where("product_id = ? AND is_del = ?", req.ProductID, 0).First(&waveTaskDetail).Error; err == nil {
hasWaveTask = true
} else {
hasWaveTask = false
}
params := map[string]string{
"shop_id": strconv.FormatInt(req.ShopID, 10),
"shop_type": strconv.Itoa(int(req.ShopType)),
"task_count": "1",
"task_type": "7",
"img_type": "2",
}
sign := utils.SignParams(params)
params["sign"] = sign
// 创建任务
url := config.AppConfig.ExternalAPI.SyncTaskURL
res, err := utils.SubmitFormData(url, params)
if err != nil {
// 创建任务失败，记录日志
s.saveRetryLog(req.ShopID, 0, req.ProductID, product, waveTaskDetail, hasWaveTask, fmt.Sprintf("创建任务接口请求失败: %v", err), databaseConn)
return fmt.Errorf("创建任务接口请求失败: %v", err)
}
var resData systemRes.ExternalAPIResponse
if err := json.Unmarshal([]byte(res), &resData); err != nil {
// 解析响应失败，记录日志
s.saveRetryLog(req.ShopID, 0, req.ProductID, product, waveTaskDetail, hasWaveTask, fmt.Sprintf("解析外部接口响应失败: %v", err), databaseConn)
return fmt.Errorf("解析外部接口响应失败: %v", err)
}
if resData.Code != "200" {
// 创建任务失败，记录日志
s.saveRetryLog(req.ShopID, 0, req.ProductID, product, waveTaskDetail, hasWaveTask, fmt.Sprintf("创建任务接口返回错误: %s", resData.Msg), databaseConn)
return fmt.Errorf("创建任务接口返回错误: %s", resData.Msg)
}
// 解析任务ID
var taskIDInt int64
switch v := resData.Data.(type) {
case float64:
taskIDInt = int64(v)
case string:
if parsed, err := strconv.ParseInt(v, 10, 64); err == nil {
taskIDInt = parsed
}
default:
taskIDInt = 0
}
if taskIDInt == 0 {
s.saveRetryLog(req.ShopID, 0, req.ProductID, product, waveTaskDetail, hasWaveTask, "创建任务接口返回的任务ID无效", databaseConn)
return fmt.Errorf("创建任务接口返回的任务ID无效")
}
// 创建外部任务记录
now := time.Now().Unix()
waveTaskID := func() int64 {
if hasWaveTask {
return waveTaskDetail.WaveTaskID
}
return 0
}()
outTask := models.OutTask{
ShopID: req.ShopID,
WaveTaskID: waveTaskID,
OutTaskID: taskIDInt,
ShopType: req.ShopType,
TaskType: 7,
ImgType: 2,
TaskCount: 1,
CreatedAt: now,
UpdatedAt: now,
IsDel: 0,
}
if createErr := databaseConn.Create(&outTask).Error; createErr != nil {
s.saveRetryLog(req.ShopID, taskIDInt, req.ProductID, product, waveTaskDetail, hasWaveTask, fmt.Sprintf("创建外部任务记录失败: %v", createErr), databaseConn)
return fmt.Errorf("创建外部任务记录失败: %v", createErr)
}
// 调用外部接口推送任务数据
salePrice := product.SalePrice
err = s.syncPriceToExternalTaskWithOptionalWave(outTask, product, waveTaskDetail, hasWaveTask, salePrice, databaseConn)
if err != nil {
// 推送数据失败，记录日志
s.saveRetryLog(req.ShopID, taskIDInt, req.ProductID, product, waveTaskDetail, hasWaveTask, fmt.Sprintf("推送任务数据失败: %v", err), databaseConn)
return fmt.Errorf("推送任务数据失败: %v", err)
}
// 推送成功，更新之前相同 shop_id 和 product_id 的所有日志状态为成功
if updateErr := databaseConn.Model(&models.OutTaskLog{}).
Where("shop_id = ? AND product_id = ? AND is_del = ?", req.ShopID, req.ProductID, 0).
Updates(map[string]interface{}{
"status": 1,
"msg": "成功",
"updated_at": now,
}).Error; updateErr != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "更新历史日志状态失败",
"shop_id": req.ShopID,
"product_id": req.ProductID,
"error": fmt.Sprintf("更新失败: %v", updateErr),
})
}
return nil
}
// BatchPushProducts 批量推送商品到多个店铺
func (s *ProductService) BatchPushProducts(req systemReq.BatchPushProductRequest) error {
fmt.Printf("[DEBUG BatchPushProducts] 入口 user_id=%d shop_ids=%v shop_types=%v product_ids=%v\n", req.UserID, req.ShopIDs, req.ShopTypes, req.ProductIDs)
utils.InfoLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "批量推送-入口",
"user_id": req.UserID,
"shop_ids": req.ShopIDs,
"shop_types": req.ShopTypes,
"product_ids": req.ProductIDs,
})
db, err := database.GetTenantDB(req.UserID)
if err != nil {
fmt.Printf("[DEBUG BatchPushProducts] 获取数据库连接失败 user_id=%d err=%v\n", req.UserID, err)
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "批量推送-获取数据库连接失败",
"user_id": req.UserID,
"error": err.Error(),
})
return fmt.Errorf("获取数据库连接失败: %v", err)
}
if len(req.ShopIDs) != len(req.ShopTypes) {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "批量推送-参数校验失败",
"shop_ids_count": len(req.ShopIDs),
"shop_types_count": len(req.ShopTypes),
})
return fmt.Errorf("商家ID数组与商家类型数组长度不一致")
}
now := time.Now().Unix()
taskCount := int64(len(req.ProductIDs))
type shopTask struct {
shopID int64
shopType int8
taskID int64
outTask models.OutTask
}
var tasks []shopTask
fmt.Printf("[DEBUG BatchPushProducts] 开始遍历店铺 shop_ids=%v task_count=%d\n", req.ShopIDs, taskCount)
for i, shopID := range req.ShopIDs {
shopType := req.ShopTypes[i]
params := map[string]string{
"shop_id": strconv.FormatInt(shopID, 10),
"shop_type": strconv.Itoa(int(shopType)),
"task_count": strconv.FormatInt(taskCount, 10),
"task_type": "7",
"img_type": "2",
}
sign := utils.SignParams(params)
params["sign"] = sign
url := config.AppConfig.ExternalAPI.SyncTaskURL
fmt.Printf("[DEBUG BatchPushProducts] 请求API shop_id=%d url=%s params=%v\n", shopID, url, params)
utils.InfoLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "批量推送-发起创建任务请求",
"shop_id": shopID,
"url": url,
"params": params,
})
res, err := utils.SubmitFormData(url, params)
if err != nil {
fmt.Printf("[DEBUG BatchPushProducts] API请求失败 shop_id=%d err=%v\n", shopID, err)
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "批量推送-创建外部任务失败",
"shop_id": shopID,
"error": fmt.Sprintf("请求失败: %v", err),
})
continue
}
var resData systemRes.ExternalAPIResponse
if err := json.Unmarshal([]byte(res), &resData); err != nil {
fmt.Printf("[DEBUG BatchPushProducts] 解析响应失败 shop_id=%d raw=%s err=%v\n", shopID, res, err)
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "批量推送-解析创建任务响应失败",
"shop_id": shopID,
"raw_response": res,
"error": fmt.Sprintf("解析失败: %v", err),
})
continue
}
fmt.Printf("[DEBUG BatchPushProducts] API响应 shop_id=%d code=%s msg=%s data=%v data_type=%T\n",
shopID, resData.Code, resData.Msg, resData.Data, resData.Data)
utils.InfoLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "批量推送-创建任务响应",
"shop_id": shopID,
"code": resData.Code,
"msg": resData.Msg,
"data": resData.Data,
"data_type": fmt.Sprintf("%T", resData.Data),
})
if resData.Code != "200" {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "批量推送-创建任务返回错误",
"shop_id": shopID,
"code": resData.Code,
"msg": resData.Msg,
})
continue
}
var taskIDInt int64
switch v := resData.Data.(type) {
case float64:
taskIDInt = int64(v)
case string:
if parsed, err := strconv.ParseInt(v, 10, 64); err == nil {
taskIDInt = parsed
}
}
if taskIDInt == 0 {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "批量推送-任务ID无效",
"shop_id": shopID,
})
continue
}
outTask := models.OutTask{
ShopID: shopID,
OutTaskID: taskIDInt,
ShopType: shopType,
TaskType: 7,
ImgType: 2,
TaskCount: taskCount,
CreatedAt: now,
UpdatedAt: now,
IsDel: 0,
}
if err := db.Create(&outTask).Error; err != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "批量推送-保存OutTask记录失败",
"shop_id": shopID,
"out_task_id": taskIDInt,
"error": fmt.Sprintf("保存失败: %v", err),
})
continue
}
tasks = append(tasks, shopTask{
shopID: shopID,
shopType: shopType,
taskID: taskIDInt,
outTask: outTask,
})
}
if len(tasks) == 0 {
fmt.Printf("[DEBUG BatchPushProducts] tasks为空! 没有成功创建任何任务 user_id=%d shop_ids=%v shop_types=%v product_ids=%v\n",
req.UserID, req.ShopIDs, req.ShopTypes, req.ProductIDs)
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "批量推送-没有成功创建任何任务",
"user_id": req.UserID,
"shop_ids": req.ShopIDs,
"shop_types": req.ShopTypes,
"product_ids": req.ProductIDs,
"task_count": taskCount,
})
return fmt.Errorf("没有成功创建任何任务")
}
// 批量查询商品
var products []models.Product
if err := db.Where("id IN ? AND is_del = ?", req.ProductIDs, 0).Find(&products).Error; err != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "批量推送-批量查询商品失败",
"product_ids": req.ProductIDs,
"error": err.Error(),
})
return fmt.Errorf("批量查询商品失败: %v", err)
}
productMap := make(map[int64]models.Product, len(products))
for _, p := range products {
productMap[p.ID] = p
}
// 批量查询库存明细(每个product取第一条)
var inventoryDetails []models.InventoryDetail
if err := db.Where("product_id IN ? AND is_del = ?", req.ProductIDs, 0).Find(&inventoryDetails).Error; err != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "批量推送-批量查询库存明细失败",
"product_ids": req.ProductIDs,
"error": err.Error(),
})
return fmt.Errorf("批量查询库存明细失败: %v", err)
}
inventoryMap := make(map[int64]models.InventoryDetail)
warehouseIDSet := make(map[int64]bool)
for _, inv := range inventoryDetails {
if _, exists := inventoryMap[inv.ProductID]; !exists {
inventoryMap[inv.ProductID] = inv
}
warehouseIDSet[inv.WarehouseID] = true
}
warehouseIDs := make([]int64, 0, len(warehouseIDSet))
for wid := range warehouseIDSet {
warehouseIDs = append(warehouseIDs, wid)
}
// 批量查询仓库
warehouseMap := make(map[int64]models.Warehouse)
if len(warehouseIDs) > 0 {
var warehouses []models.Warehouse
if err := db.Where("id IN ? AND is_del = ?", warehouseIDs, 0).Find(&warehouses).Error; err != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "批量推送-批量查询仓库失败",
"warehouse_ids": warehouseIDs,
"error": err.Error(),
})
return fmt.Errorf("批量查询仓库失败: %v", err)
}
for _, w := range warehouses {
warehouseMap[w.ID] = w
}
}
// 收集所有 logistics_id 并批量查询
logisticsIDSet := make(map[int64]bool)
for _, w := range warehouseMap {
if w.LogisticsID > 0 {
logisticsIDSet[w.LogisticsID] = true
}
}
logisticsIDs := make([]int64, 0, len(logisticsIDSet))
for lid := range logisticsIDSet {
logisticsIDs = append(logisticsIDs, lid)
}
logisticsMap := make(map[int64]models.Logistics)
if len(logisticsIDs) > 0 {
var logisticsList []models.Logistics
if err := db.Where("id IN ? AND del_flag = ?", logisticsIDs, "0").Find(&logisticsList).Error; err != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "批量推送-批量查询物流失败",
"logistics_ids": logisticsIDs,
"error": err.Error(),
})
return fmt.Errorf("批量查询物流失败: %v", err)
}
for _, l := range logisticsList {
logisticsMap[int64(l.Id)] = l
}
}
// 批量查询库位
locationIDSet := make(map[int64]bool)
for _, inv := range inventoryDetails {
if inv.LocationID > 0 {
locationIDSet[inv.LocationID] = true
}
}
locationIDs := make([]int64, 0, len(locationIDSet))
for lid := range locationIDSet {
locationIDs = append(locationIDs, lid)
}
locationMap := make(map[int64]models.Location)
if len(locationIDs) > 0 {
var locations []models.Location
if err := db.Where("id IN ? AND is_del = ?", locationIDs, 0).Find(&locations).Error; err != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "批量推送-批量查询库位失败",
"location_ids": locationIDs,
"error": err.Error(),
})
return fmt.Errorf("批量查询库位失败: %v", err)
}
for _, loc := range locations {
locationMap[loc.ID] = loc
}
}
// 遍历商品推送
for _, productID := range req.ProductIDs {
product, ok := productMap[productID]
if !ok {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "批量推送-商品不存在",
"product_id": productID,
})
continue
}
inventoryDetail, ok := inventoryMap[productID]
if !ok {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "批量推送-库存明细不存在",
"product_id": productID,
})
continue
}
warehouse, ok := warehouseMap[inventoryDetail.WarehouseID]
if !ok {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "批量推送-仓库不存在",
"product_id": productID,
"warehouse_id": inventoryDetail.WarehouseID,
})
continue
}
if warehouse.LogisticsID == 0 {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "批量推送-仓库未绑定运费模板",
"product_id": productID,
"warehouse": warehouse.Name,
})
continue
}
logistics, ok := logisticsMap[warehouse.LogisticsID]
if !ok {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "批量推送-物流模板不存在",
"product_id": productID,
"logistics_id": warehouse.LogisticsID,
})
continue
}
cost := int64(logistics.FirPrice * 100)
stock := inventoryDetail.Quantity
salePrice := product.SalePrice
warehouseCode := warehouse.Code
location, ok := locationMap[inventoryDetail.LocationID]
if !ok {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "批量推送-库位不存在",
"product_id": productID,
"location_id": inventoryDetail.LocationID,
"warehouse_id": inventoryDetail.WarehouseID,
})
continue
}
locationCode := location.Code
condition := product.Appearance
for _, st := range tasks {
s.batchPushProductBody(db, st.outTask, product, stock, salePrice, cost, now, req.UserID, warehouseCode, locationCode, condition)
}
}
return nil
}
// PushProductToShop 上架商品到商铺：创建商品、库存记录，并推送到商铺
func (s *ProductService) PushProductToShop(req systemReq.PushProductToShopRequest) (*systemRes.PushProductToShopResponse, error) {
utils.InfoLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "上架到商铺保存数据库-入口",
"user_id": req.UserID,
"location_id": req.LocationID,
"warehouse_id": req.WarehouseID,
"isbn": req.ISBN,
"price": req.Price,
"stock": req.Stock,
"appearance": req.Appearance,
})
db, err := database.GetTenantDB(req.UserID)
if err != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "上架到商铺保存数据库-获取数据库连接失败",
"user_id": req.UserID,
"error": err.Error(),
})
return nil, fmt.Errorf("获取数据库连接失败: %v", err)
}
// 1. 根据货位ID查找库位
var location models.Location
if err := db.Where("id = ? AND is_del = ?", req.LocationID, 0).First(&location).Error; err != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "上架到商铺保存数据库-货位不存在",
"location_id": req.LocationID,
"error": err.Error(),
})
return nil, fmt.Errorf("货位ID【%d】不存在", req.LocationID)
}
// 2. 根据仓库ID查找仓库
var warehouse models.Warehouse
if err := db.Where("id = ? AND is_del = ?", req.WarehouseID, 0).First(&warehouse).Error; err != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "上架到商铺保存数据库-仓库不存在",
"warehouse_id": req.WarehouseID,
"error": err.Error(),
})
return nil, fmt.Errorf("仓库ID【%d】不存在", req.WarehouseID)
}
now := time.Now().Unix()
// 3. 查找或创建商品
var product models.Product
err = db.Where("barcode = ? AND is_del = ?", req.ISBN, 0).First(&product).Error
// 序列化照片为JSON
var liveImageJSON datatypes.JSON
if len(req.Photos) > 0 {
jsonBytes, _ := json.Marshal(req.Photos)
liveImageJSON = jsonBytes
} else {
liveImageJSON = datatypes.JSON("[]")
}
/////////////////////////////////////////////////////////////////////////
// 创建新商品
productName := req.ISBN // 默认用ISBN作为名称
// 优先使用传入的图书名称
if req.ProductName != "" {
productName = req.ProductName
} else {
// 尝试从ES API获取书名
bookSvc := BookService{}
bookInfo, bookErr := bookSvc.GetBookInfo(systemReq.BookRequest{Isbn: req.ISBN})
if bookErr == nil && bookInfo != nil && bookInfo.BookName.Value != "" {
productName = bookInfo.BookName.Value
utils.InfoLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "上架到商铺-获取书名成功",
"isbn": req.ISBN,
"product_name": productName,
})
}
}
product = models.Product{
Name: productName,
Barcode: req.ISBN,
Appearance: req.Appearance,
Price: req.Price,
SalePrice: req.Price,
LiveImage: liveImageJSON,
Status: 1,
CreatedAt: now,
UpdatedAt: now,
IsDel: 0,
}
if err := db.Create(&product).Error; err != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "上架到商铺-创建商品失败",
"isbn": req.ISBN,
"error": err.Error(),
})
return nil, fmt.Errorf("创建商品失败: %v", err)
}
utils.InfoLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "上架到商铺-创建商品成功",
"product_id": product.ID,
"isbn": req.ISBN,
})
////////////////////////////////////////////////////////////////////////
//if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
// // 创建新商品
// productName := req.ISBN // 默认用ISBN作为名称
// // 优先使用传入的图书名称
// if req.ProductName != "" {
// productName = req.ProductName
// } else {
// // 尝试从ES API获取书名
// bookSvc := BookService{}
// bookInfo, bookErr := bookSvc.GetBookInfo(systemReq.BookRequest{Isbn: req.ISBN})
// if bookErr == nil && bookInfo != nil && bookInfo.BookName.Value != "" {
// productName = bookInfo.BookName.Value
// utils.InfoLog(constant.LoggerChannelWork, map[string]interface{}{
// "source": "上架到商铺-获取书名成功",
// "isbn": req.ISBN,
// "product_name": productName,
// })
// }
// }
//
// product = models.Product{
// Name: productName,
// Barcode: req.ISBN,
// Appearance: req.Appearance,
// Price: req.Price,
// SalePrice: req.Price,
// LiveImage: liveImageJSON,
// Status: 1,
// CreatedAt: now,
// UpdatedAt: now,
// IsDel: 0,
// }
//
// if err := db.Create(&product).Error; err != nil {
// utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
// "source": "上架到商铺-创建商品失败",
// "isbn": req.ISBN,
// "error": err.Error(),
// })
// return nil, fmt.Errorf("创建商品失败: %v", err)
// }
// utils.InfoLog(constant.LoggerChannelWork, map[string]interface{}{
// "source": "上架到商铺-创建商品成功",
// "product_id": product.ID,
// "isbn": req.ISBN,
// })
//} else if err != nil {
// utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
// "source": "上架到商铺-查询商品失败",
// "isbn": req.ISBN,
// "error": err.Error(),
// })
// return nil, fmt.Errorf("查询商品失败: %v", err)
//} else {
// // 更新已有商品
// updates := map[string]interface{}{
// "appearance": req.Appearance,
// "price": req.Price,
// "sale_price": req.Price,
// "updated_at": now,
// }
// if req.ProductName != "" {
// updates["name"] = req.ProductName
// }
// if len(req.Photos) > 0 {
// updates["live_image"] = liveImageJSON
// }
//
// if err := db.Model(&product).Updates(updates).Error; err != nil {
// utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
// "source": "上架到商铺-更新商品失败",
// "product_id": product.ID,
// "error": err.Error(),
// })
// return nil, fmt.Errorf("更新商品失败: %v", err)
// }
// utils.InfoLog(constant.LoggerChannelWork, map[string]interface{}{
// "source": "上架到商铺-更新商品成功",
// "product_id": product.ID,
// "isbn": req.ISBN,
// })
//}
// 4. 创建或更新 InventoryDetail (库位级库存)
var invDetail models.InventoryDetail
err = db.Where("product_id = ? AND location_id = ? AND is_del = ?", product.ID, location.ID, 0).First(&invDetail).Error
if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
invDetail = models.InventoryDetail{
WarehouseID: warehouse.ID,
LocationID: location.ID,
ProductID: product.ID,
Quantity: req.Stock,
CreatedAt: now,
UpdatedAt: now,
IsDel: 0,
}
if err := db.Create(&invDetail).Error; err != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "上架到商铺-创建库存明细失败",
"product_id": product.ID,
"location_id": location.ID,
"error": err.Error(),
})
return nil, fmt.Errorf("创建库存明细失败: %v", err)
}
} else if err == nil {
if err := db.Model(&invDetail).Updates(map[string]interface{}{
"quantity": req.Stock,
"updated_at": now,
}).Error; err != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "上架到商铺-更新库存明细失败",
"product_id": product.ID,
"error": err.Error(),
})
return nil, fmt.Errorf("更新库存明细失败: %v", err)
}
}
// 5. 创建或更新 Inventory (仓库级库存)
var inv models.Inventory
err = db.Where("warehouse_id = ? AND product_id = ? AND is_del = ?", warehouse.ID, product.ID, 0).First(&inv).Error
if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
inv = models.Inventory{
WarehouseID: warehouse.ID,
ProductID: product.ID,
Quantity: req.Stock,
CreatedAt: now,
UpdatedAt: now,
IsDel: 0,
}
if err := db.Create(&inv).Error; err != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "上架到商铺-创建库存失败",
"product_id": product.ID,
"warehouse_id": warehouse.ID,
"error": err.Error(),
})
return nil, fmt.Errorf("创建库存失败: %v", err)
}
} else if err == nil {
if err := db.Model(&inv).Updates(map[string]interface{}{
"quantity": req.Stock,
"updated_at": now,
}).Error; err != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "上架到商铺-更新库存失败",
"product_id": product.ID,
"error": err.Error(),
})
return nil, fmt.Errorf("更新库存失败: %v", err)
}
}
utils.InfoLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "上架到商铺-数据保存完成",
"product_id": product.ID,
"warehouse_id": warehouse.ID,
"location_id": location.ID,
"quantity": req.Stock,
})
return &systemRes.PushProductToShopResponse{
UserID: req.UserID,
WarehouseID: warehouse.ID,
ProductID: product.ID,
ISBN: req.ISBN,
}, nil
}
// batchPushProductBody 批量上架
func (s *ProductService) batchPushProductBody(db *gorm.DB, outTask models.OutTask, product models.Product, stock, salePrice, cost, now, userID int64, warehouseCode string, locationCode string, condition int64) {
isbn := product.Barcode
var imgList []string
if product.LiveImage != nil && len(product.LiveImage) > 0 {
var rawImgList []string
if err := json.Unmarshal(product.LiveImage, &rawImgList); err != nil {
s.saveOutTaskLogWithStock(outTask, product.ID, isbn, product.LiveImage, stock, salePrice, cost, fmt.Sprintf("解析图片失败: %v", err), db)
return
}
for _, imgStr := range rawImgList {
urls := strings.Split(imgStr, ",")
for _, url := range urls {
url = strings.TrimSpace(url)
if url != "" {
imgList = append(imgList, url)
}
}
}
}
msgData := map[string]interface{}{
"product_id": product.ID,
"user_id": strconv.FormatInt(userID, 10),
"is_distribution": "1",
}
msgJSON, _ := json.Marshal(msgData)
bodyData := map[string]interface{}{
"book_info": map[string]interface{}{
"isbn": isbn,
"book_name": product.Name,
"image_object": map[string]interface{}{
"carousel_url_array": imgList,
},
},
"detail": map[string]interface{}{
"stock": stock,
"price": salePrice,
"shipping_cost": cost,
"msg": string(msgJSON),
"sku_code": warehouseCode + "##" + locationCode,
"condition": condition,
},
}
bodyDataJSON, err := json.Marshal(bodyData)
if err != nil {
s.saveOutTaskLogWithStock(outTask, product.ID, isbn, product.LiveImage, stock, salePrice, cost, fmt.Sprintf("序列化请求体失败: %v", err), db)
return
}
bodyList := []string{string(bodyDataJSON)}
taskID := fmt.Sprintf("%d", outTask.OutTaskID)
allBody := strings.Join(bodyList, "")
signParams := map[string]string{
"task_id": taskID,
"body": allBody,
}
sign := utils.SignParams(signParams)
url := config.AppConfig.ExternalAPI.SyncTaskBodyURL
resp, err := utils.SubmitMultiBody(url, taskID, bodyList, sign)
if err != nil {
s.saveOutTaskLogWithStock(outTask, product.ID, isbn, product.LiveImage, stock, salePrice, cost, fmt.Sprintf("请求外部接口失败: %v", err), db)
return
}
var resData systemRes.ExternalAPIResponse
if err := json.Unmarshal([]byte(resp), &resData); err != nil {
s.saveOutTaskLogWithStock(outTask, product.ID, isbn, product.LiveImage, stock, salePrice, cost, fmt.Sprintf("解析响应失败: %v", err), db)
return
}
if resData.Code != "200" {
s.saveOutTaskLogWithStock(outTask, product.ID, isbn, product.LiveImage, stock, salePrice, cost, fmt.Sprintf("外部接口返回错误: code=%s, msg=%s", resData.Code, resData.Msg), db)
return
}
if updateErr := db.Model(&models.OutTaskLog{}).
Where("shop_id = ? AND product_id = ? AND is_del = ?", outTask.ShopID, product.ID, 0).
Updates(map[string]interface{}{
"status": 1,
"msg": "成功",
"updated_at": now,
}).Error; updateErr != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "批量推送-更新历史日志状态失败",
"shop_id": outTask.ShopID,
"product_id": product.ID,
"error": fmt.Sprintf("更新失败: %v", updateErr),
})
}
}
// saveRetryLog 保存重试任务日志
func (s *ProductService) saveRetryLog(shopID, outTaskID, productID int64, product models.Product, waveTaskDetail models.WaveTaskDetail, hasWaveTask bool, msg string, db *gorm.DB) {
now := time.Now().Unix()
stock := func() int64 {
if hasWaveTask {
return waveTaskDetail.PlannedQuantity
}
return 0
}()
logRecord := models.OutTaskLog{
ShopID: shopID,
OutTaskID: outTaskID,
ProductID: productID,
ISBN: product.Barcode,
LiveImage: product.LiveImage,
Stock: stock,
SalePrice: product.SalePrice,
Cost: product.Cost,
Status: func() int8 {
if msg == "成功" {
return 1 // 成功
}
return 0 // 失败
}(),
Msg: msg,
CreatedAt: now,
UpdatedAt: now,
IsDel: 0,
}
if err := db.Create(&logRecord).Error; err != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "保存重试任务日志",
"shop_id": shopID,
"product_id": productID,
"out_task_id": outTaskID,
"error": fmt.Sprintf("保存日志失败: %v", err),
})
}
}
// syncPriceToExternalTaskWithOptionalWave 同步售价到单个外部任务（支持无波次明细）
func (s *ProductService) syncPriceToExternalTaskWithOptionalWave(outTask models.OutTask, product models.Product, waveTaskDetail models.WaveTaskDetail, hasWaveTask bool, salePrice int64, db *gorm.DB) error {
isbn := product.Barcode
var imgList []string
if product.LiveImage != nil && len(product.LiveImage) > 0 {
var rawImgList []string
if err := json.Unmarshal(product.LiveImage, &rawImgList); err != nil {
return fmt.Errorf("解析json失败: %v", err)
}
for _, imgStr := range rawImgList {
urls := strings.Split(imgStr, ",")
for _, url := range urls {
url = strings.TrimSpace(url)
if url != "" {
imgList = append(imgList, url)
}
}
}
}
msgData := map[string]interface{}{
"product_id": product.ID,
}
msgJSON, _ := json.Marshal(msgData)
// 获取库存数量
var stock int64
// 获取运费模板首费
var cost int64
if hasWaveTask {
// 有波次任务明细：通过波次任务 -> 波次头 -> 仓库 -> 物流模板
var logistics models.Logistics
err := db.Table("logistics").
Select("logistics.fir_price").
Joins("INNER JOIN warehouse ON warehouse.logistics_id = logistics.id AND warehouse.is_del = ?", "0").
Joins("INNER JOIN wave_header ON wave_header.warehouse_id = warehouse.id AND wave_header.is_del = 0").
Joins("INNER JOIN wave_task ON wave_task.wave_id = wave_header.id AND wave_task.is_del = 0").
Where("wave_task.id = ?", waveTaskDetail.WaveTaskID).
First(&logistics).Error
if err != nil {
return fmt.Errorf("查询物流运费失败: %v", err)
}
cost = int64(logistics.FirPrice * 100)
stock = waveTaskDetail.PlannedQuantity
} else {
// 无波次任务明细（同步商品）：通过库存明细 -> 仓库 -> 物流模板
var inventoryDetail models.InventoryDetail
if err := db.Where("product_id = ? AND is_del = ?", product.ID, 0).First(&inventoryDetail).Error; err != nil {
return fmt.Errorf("查询库存明细失败: %v", err)
}
var warehouse models.Warehouse
if err := db.Where("id = ? AND is_del = ?", inventoryDetail.WarehouseID, 0).First(&warehouse).Error; err != nil {
return fmt.Errorf("查询仓库信息失败: %v", err)
}
if warehouse.LogisticsID == 0 {
return fmt.Errorf("仓库未绑定运费模板")
}
var logistics models.Logistics
if err := db.Where("id = ? AND del_flag = ?", warehouse.LogisticsID, "0").First(&logistics).Error; err != nil {
return fmt.Errorf("查询物流运费失败: %v", err)
}
cost = int64(logistics.FirPrice * 100)
stock = inventoryDetail.Quantity
}
bodyData := map[string]interface{}{
"book_info": map[string]interface{}{
"isbn": isbn,
"book_name": product.Name,
"image_object": map[string]interface{}{
"carousel_url_array": imgList,
},
},
"detail": map[string]interface{}{
"stock": stock,
"price": salePrice,
"shipping_cost": cost,
"msg": string(msgJSON),
},
}
bodyDataJSON, err := json.Marshal(bodyData)
if err != nil {
return fmt.Errorf("序列化请求体失败: %v", err)
}
bodyList := []string{
string(bodyDataJSON),
}
taskID := fmt.Sprintf("%d", outTask.OutTaskID)
allBody := strings.Join(bodyList, "") // 直接无缝拼接（和服务端一致）
signParams := map[string]string{
"task_id": taskID,
"body": allBody,
}
sign := utils.SignParams(signParams)
// 发送请求
url := config.AppConfig.ExternalAPI.SyncTaskBodyURL
resp, err := utils.SubmitMultiBody(url, taskID, bodyList, sign)
if err != nil {
s.saveOutTaskLogWithStock(outTask, product.ID, isbn, product.LiveImage, stock, salePrice, cost, fmt.Sprintf("请求外部接口失败: %v", err), db)
return fmt.Errorf("请求外部接口失败: %v", err)
}
var resData systemRes.ExternalAPIResponse
if err := json.Unmarshal([]byte(resp), &resData); err != nil {
return fmt.Errorf("解析响应失败: %v", err)
}
if resData.Code != "200" {
s.saveOutTaskLogWithStock(outTask, product.ID, isbn, product.LiveImage, stock, salePrice, cost, fmt.Sprintf("外部接口返回错误: code=%s, msg=%s", resData.Code, resData.Msg), db)
return fmt.Errorf("外部接口返回错误: code=%s, msg=%s", resData.Code, resData.Msg)
}
return nil
}
// saveOutTaskLogWithStock 保存外部任务日志（支持自定义库存）
func (s *ProductService) saveOutTaskLogWithStock(outTask models.OutTask, productID int64, isbn string, liveImage datatypes.JSON, stock, salePrice, cost int64, msg string, db *gorm.DB) {
now := time.Now().Unix()
logRecord := models.OutTaskLog{
ShopID: outTask.ShopID,
OutTaskID: outTask.OutTaskID,
ProductID: productID,
ISBN: isbn,
LiveImage: liveImage,
Stock: stock,
SalePrice: salePrice,
Cost: cost,
Status: 0,
Msg: msg,
CreatedAt: now,
UpdatedAt: now,
IsDel: 0,
}
if err := db.Create(&logRecord).Error; err != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "保存外部任务日志",
"out_task_id": outTask.OutTaskID,
"product_id": productID,
"error": fmt.Sprintf("保存日志失败: %v", err),
})
}
}
// syncPriceToExternal 同步售价到外部接口
func (s *ProductService) syncPriceToExternal(waveTaskDetail models.WaveTaskDetail, productID, salePrice, userId int64, db *gorm.DB) error {
var logistics models.Logistics
err := db.Table("logistics").
Select("logistics.fir_price").
Joins("INNER JOIN warehouse ON warehouse.logistics_id = logistics.id AND warehouse.is_del = ?", "0").
Joins("INNER JOIN wave_header ON wave_header.warehouse_id = warehouse.id AND wave_header.is_del = 0").
Joins("INNER JOIN wave_task ON wave_task.wave_id = wave_header.id AND wave_task.is_del = 0").
Where("wave_task.id = ?", waveTaskDetail.WaveTaskID).
First(&logistics).Error
if err != nil {
return fmt.Errorf("查询物流运费失败: %v", err)
}
cost := int64(logistics.FirPrice * 100)
var product models.Product
if err := db.Where("id = ? AND is_del = 0", productID).First(&product).Error; err != nil {
return fmt.Errorf("查询商品信息失败: %v", err)
}
var outTasks []models.OutTask
if err := db.Where("wave_task_id = ? AND is_del = 0", waveTaskDetail.WaveTaskID).Find(&outTasks).Error; err != nil {
return fmt.Errorf("查询外部任务失败: %v", err)
}
if len(outTasks) == 0 {
return fmt.Errorf("未找到关联的外部任务")
}
for _, outTask := range outTasks {
if outTask.OutTaskID > 0 {
if err := s.syncPriceToExternalTask(outTask, product, waveTaskDetail, salePrice, cost, userId, db); err != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "同步售价到外部接口",
"product_id": productID,
"task_id": outTask.OutTaskID,
"error": fmt.Sprintf("请求失败: %v", err),
})
}
}
}
return nil
}
// syncPriceToExternalTask 同步售价到单个外部任务
func (s *ProductService) syncPriceToExternalTask(outTask models.OutTask, product models.Product, waveTaskDetail models.WaveTaskDetail, salePrice, cost, userId int64, db *gorm.DB) error {
isbn := product.Barcode
var imgList []string
if product.LiveImage != nil && len(product.LiveImage) > 0 {
var rawImgList []string
if err := json.Unmarshal(product.LiveImage, &rawImgList); err != nil {
return fmt.Errorf("解析json失败: %v", err)
}
for _, imgStr := range rawImgList {
urls := strings.Split(imgStr, ",")
for _, url := range urls {
url = strings.TrimSpace(url)
if url != "" {
imgList = append(imgList, url)
}
}
}
}
msgData := map[string]interface{}{
"product_id": product.ID,
"user_id": fmt.Sprintf("%d", userId),
}
msgJSON, _ := json.Marshal(msgData)
bodyData := map[string]interface{}{
"book_info": map[string]interface{}{
"isbn": isbn,
"book_name": product.Name,
"image_object": map[string]interface{}{
"carousel_url_array": imgList,
},
},
"detail": map[string]interface{}{
"stock": waveTaskDetail.PlannedQuantity,
"price": salePrice,
"shipping_cost": cost,
"msg": string(msgJSON),
},
}
bodyDataJSON, err := json.Marshal(bodyData)
if err != nil {
return fmt.Errorf("序列化请求体失败: %v", err)
}
bodyList := []string{
string(bodyDataJSON),
}
taskID := fmt.Sprintf("%d", outTask.OutTaskID)
allBody := strings.Join(bodyList, "") // 直接无缝拼接（和服务端一致）
signParams := map[string]string{
"task_id": taskID,
"body": allBody,
}
sign := utils.SignParams(signParams)
// 发送请求
url := config.AppConfig.ExternalAPI.SyncTaskBodyURL
resp, err := utils.SubmitMultiBody(url, taskID, bodyList, sign)
if err != nil {
s.saveOutTaskLog(outTask, product.ID, isbn, product.LiveImage, waveTaskDetail.PlannedQuantity, salePrice, cost, fmt.Sprintf("请求外部接口失败: %v", err), db)
return fmt.Errorf("请求外部接口失败: %v", err)
}
var resData systemRes.ExternalAPIResponse
if err := json.Unmarshal([]byte(resp), &resData); err != nil {
return fmt.Errorf("解析响应失败: %v", err)
}
if resData.Code != "200" {
s.saveOutTaskLog(outTask, product.ID, isbn, product.LiveImage, waveTaskDetail.PlannedQuantity, salePrice, cost, fmt.Sprintf("外部接口返回错误: code=%s, msg=%s", resData.Code, resData.Msg), db)
return fmt.Errorf("外部接口返回错误: code=%s, msg=%s", resData.Code, resData.Msg)
}
s.saveOutTaskLog(outTask, product.ID, isbn, product.LiveImage, waveTaskDetail.PlannedQuantity, salePrice, cost, "成功", db)
return nil
}
// saveOutTaskLog 保存外部任务日志
func (s *ProductService) saveOutTaskLog(outTask models.OutTask, productID int64, isbn string, liveImage []byte, stock, salePrice, cost int64, msg string, db *gorm.DB) {
now := time.Now().Unix()
logRecord := models.OutTaskLog{
ShopID: outTask.ShopID,
OutTaskID: outTask.OutTaskID,
ProductID: productID,
ISBN: isbn,
LiveImage: liveImage,
Stock: stock,
SalePrice: salePrice,
Cost: cost,
Status: func() int8 {
if msg == "成功" {
return 1
} else {
return 0
}
}(),
Msg: msg,
CreatedAt: now,
UpdatedAt: now,
IsDel: 0,
}
if err := db.Create(&logRecord).Error; err != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "保存外部任务日志",
"out_task_id": outTask.OutTaskID,
"product_id": productID,
"error": fmt.Sprintf("保存日志失败: %v", err),
})
}
}
// ExportProducts 导出商品到Excel
func (s *ProductService) ExportProducts(req systemReq.ExportProductRequest, db ...*gorm.DB) (*systemRes.ExportProductResponse, error) {
databaseConn := database.OptionalDB(db...)
query := databaseConn.Table("product").
Select(`product.barcode,
product.name,
product.sale_price,
product.live_image,
product.created_at,
inventory_detail.location_id,
COALESCE(inventory_detail.quantity, 0) as quantity`).
Joins("LEFT JOIN inventory_detail ON inventory_detail.product_id = product.id AND inventory_detail.is_del = ?", 0).
Where("product.is_del = ?", 0)
if req.StartCreatedAt > 0 {
query = query.Where("product.created_at >= ?", req.StartCreatedAt)
}
if req.EndCreatedAt > 0 {
query = query.Where("product.created_at <= ?", req.EndCreatedAt)
}
if req.MinSalePrice > 0 {
query = query.Where("product.sale_price >= ?", req.MinSalePrice)
}
if req.MaxSalePrice > 0 {
query = query.Where("product.sale_price <= ?", req.MaxSalePrice)
}
if req.WarehouseID > 0 {
query = query.Where("inventory_detail.warehouse_id = ? OR inventory_detail.warehouse_id IS NULL", req.WarehouseID)
}
if req.MinStock >= 0 {
query = query.Where("COALESCE(inventory_detail.quantity, 0) >= ?", req.MinStock)
}
if req.MaxStock >= 0 {
query = query.Where("COALESCE(inventory_detail.quantity, 0) <= ?", req.MaxStock)
}
var total int64
if err := query.Count(&total).Error; err != nil {
return nil, utils.NewError("查询总数失败")
}
if req.Type == 0 {
return &systemRes.ExportProductResponse{
Total: total,
}, nil
}
if total == 0 {
return nil, fmt.Errorf("没有符合条件的商品数据")
}
type ProductExportData struct {
Barcode string `gorm:"column:barcode"`
Name string `gorm:"column:name"`
SalePrice int64 `gorm:"column:sale_price"`
LiveImage datatypes.JSON `gorm:"column:live_image"`
CreatedAt int64 `gorm:"column:created_at"`
LocationID int64 `gorm:"column:location_id"`
Quantity int64 `gorm:"column:quantity"`
}
var products []ProductExportData
if err := query.Order("product.created_at DESC").Find(&products).Error; err != nil {
return nil, utils.NewError("查询商品数据失败")
}
locationIDs := make([]int64, 0)
for _, p := range products {
if p.LocationID > 0 {
locationIDs = append(locationIDs, p.LocationID)
}
}
locationMap := make(map[int64]string)
if len(locationIDs) > 0 {
var locations []models.Location
if err := databaseConn.Where("id IN ? AND is_del = ?", locationIDs, 0).Find(&locations).Error; err == nil {
for _, loc := range locations {
locationMap[loc.ID] = loc.Code
}
}
}
f := excelize.NewFile()
defer func() {
if err := f.Close(); err != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "关闭Excel文件",
"error": fmt.Sprintf("关闭失败: %v", err),
})
}
}()
sheetName := "Sheet1"
f.SetSheetName("Sheet1", sheetName)
headers := []string{"ISBN", "", "", "商品名称", "库存数量", "创建时间", "价格", "规格编码/货号", "", "商品图片"}
for i, header := range headers {
cell, _ := excelize.CoordinatesToCellName(i+1, 1)
f.SetCellValue(sheetName, cell, header)
}
headerStyle, _ := f.NewStyle(&excelize.Style{
Font: &excelize.Font{
Bold: true,
Size: 12,
},
Alignment: &excelize.Alignment{
Horizontal: "center",
Vertical: "center",
},
Fill: excelize.Fill{
Type: "pattern",
Color: []string{"#E0E0E0"},
Pattern: 1,
},
})
f.SetCellStyle(sheetName, "A1", "J1", headerStyle)
for idx, product := range products {
row := idx + 2
f.SetCellValue(sheetName, fmt.Sprintf("A%d", row), product.Barcode)
f.SetCellValue(sheetName, fmt.Sprintf("D%d", row), product.Name)
f.SetCellValue(sheetName, fmt.Sprintf("E%d", row), product.Quantity)
createdAtStr := time.Unix(product.CreatedAt, 0).Format("2006-01-02 15:04:05")
f.SetCellValue(sheetName, fmt.Sprintf("F%d", row), createdAtStr)
f.SetCellValue(sheetName, fmt.Sprintf("G%d", row), float64(product.SalePrice)/100.0)
locationCode := ""
if product.LocationID > 0 {
if code, exists := locationMap[product.LocationID]; exists {
locationCode = code
}
}
f.SetCellValue(sheetName, fmt.Sprintf("H%d", row), locationCode)
var imgList []string
if product.LiveImage != nil && len(product.LiveImage) > 0 {
if err := json.Unmarshal(product.LiveImage, &imgList); err == nil && len(imgList) > 0 {
f.SetCellValue(sheetName, fmt.Sprintf("J%d", row), imgList[0])
}
}
}
colWidths := map[string]float64{
"A": 20,
"D": 30,
"E": 12,
"F": 20,
"G": 12,
"H": 15,
"J": 40,
}
for col, width := range colWidths {
f.SetColWidth(sheetName, col, col, width)
}
now := time.Now()
fileName := fmt.Sprintf("task_template_product_%s.xlsx", now.Format("20060102150405"))
filePath := fmt.Sprintf("excel/%s", fileName)
if err := f.SaveAs(filePath); err != nil {
return nil, fmt.Errorf("保存Excel文件失败: %v", err)
}
return &systemRes.ExportProductResponse{
Total: total,
FileName: fileName,
FilePath: config.AppConfig.Server.Host + filePath,
}, nil
}
// GetProductLogList 导出商品
func (s *ProductService) GetProductLogList(req systemReq.GetProductLogListRequest, aboutID int64) (*systemRes.ProductLogListResponse, error) {
// TODO
//if aboutID != 0 {
// return nil, utils.NewError("只有系统管理员才可以访问")
//}
if req.Page < 1 {
req.Page = 1
}
if req.PageSize < 1 || req.PageSize > 100 {
req.PageSize = 20
}
query := database.DB.Model(&models.ProductLog{}).Where("is_del = ?", 0)
if req.Barcode != "" {
query = query.Where("barcode = ?", req.Barcode)
}
if req.Status != nil {
query = query.Where("status = ?", *req.Status)
}
var total int64
if err := query.Count(&total).Error; err != nil {
return nil, utils.NewError("查询总数失败")
}
var logs []models.ProductLog
offset := (req.Page - 1) * req.PageSize
if err := query.Order("created_at DESC").Offset(offset).Limit(req.PageSize).Find(&logs).Error; err != nil {
return nil, utils.NewError("查询商品日志列表失败")
}
var logItems []systemRes.ProductLogItem
for _, log := range logs {
item := s.convertProductLogToItem(log)
logItems = append(logItems, item)
}
return &systemRes.ProductLogListResponse{
List: logItems,
Total: total,
Page: req.Page,
PageSize: req.PageSize,
}, nil
}
func (s *ProductService) SaveProductLog(req systemReq.ProductLogRequest, id int64) (int64, error) {
now := time.Now().Unix()
if req.ID > 0 {
return s.updateProductLog(req, now)
}
return s.createProductLog(req, now, id)
}
func (s *ProductService) createProductLog(req systemReq.ProductLogRequest, now, userId int64) (int64, error) {
var OldliveImage datatypes.JSON
if len(req.OldLiveImage) > 0 {
jsonBytes, _ := json.Marshal(req.OldLiveImage)
OldliveImage = jsonBytes
} else {
OldliveImage = datatypes.JSON("[]")
}
var NewliveImage datatypes.JSON
if len(req.NewLiveImage) > 0 {
jsonBytes, _ := json.Marshal(req.NewLiveImage)
NewliveImage = jsonBytes
} else {
NewliveImage = datatypes.JSON("[]")
}
if req.OldName == req.NewName &&
req.OldPublisher == req.NewPublisher &&
req.OldAuthor == req.NewAuthor &&
req.OldPublicationTime == req.NewPublicationTime &&
req.OldPrice == req.NewPrice &&
req.OldBindingLayout == req.NewBindingLayout &&
req.OldPageCount == req.NewPageCount &&
req.OldWordCount == req.NewWordCount &&
string(OldliveImage) == string(NewliveImage) &&
req.OldIsSuit == req.NewIsSuit {
return 0, fmt.Errorf("新旧数据完全一致，无需提交变更")
}
md5Str := fmt.Sprintf("%x", md5.Sum([]byte(fmt.Sprintf("%s|%s|%s|%d|%d|%d|%s|%d|%d|%d",
req.Barcode,
req.NewName,
req.NewPublisher,
req.NewAuthor,
req.NewPublicationTime,
req.NewPrice,
req.NewBindingLayout,
req.NewPageCount,
req.NewWordCount,
string(NewliveImage),
))))
var existingLog models.ProductLog
if err := database.DB.Where("md5_data = ? AND is_del = 0", md5Str).First(&existingLog).Error; err == nil {
return 0, fmt.Errorf("该商品变更日志已存在，无需重复提交")
} else if err != gorm.ErrRecordNotFound {
return 0, fmt.Errorf("查询商品日志失败：%w", err)
}
product := models.ProductLog{
Barcode: req.Barcode,
Md5Data: md5Str,
OldName: req.OldName,
NewName: req.NewName,
OldPublisher: req.OldPublisher,
NewPublisher: req.NewPublisher,
OldAuthor: req.OldAuthor,
NewAuthor: req.NewAuthor,
OldPublicationTime: req.OldPublicationTime,
NewPublicationTime: req.NewPublicationTime,
OldPrice: req.OldPrice,
NewPrice: req.NewPrice,
OldBindingLayout: req.OldBindingLayout,
NewBindingLayout: req.NewBindingLayout,
OldPageCount: req.OldPageCount,
NewPageCount: req.NewPageCount,
OldWordCount: req.OldWordCount,
NewWordCount: req.NewWordCount,
OldLiveImage: OldliveImage,
NewLiveImage: NewliveImage,
OldIsSuit: req.OldIsSuit,
NewIsSuit: req.NewIsSuit,
Status: 0,
CreateBy: userId,
CreatedAt: now,
UpdatedAt: now,
}
if err := database.DB.Create(&product).Error; err != nil {
return 0, fmt.Errorf("创建商品日志失败：%w", err)
}
return product.ID, nil
}
// 更新商品日志
func (s *ProductService) updateProductLog(req systemReq.ProductLogRequest, now int64) (int64, error) {
var productLog models.ProductLog
if err := database.DB.Where("id = ? AND is_del = 0", req.ID).First(&productLog).Error; err != nil {
return 0, fmt.Errorf("商品日志不存在：%w", err)
}
if productLog.Status != 0 {
return 0, fmt.Errorf("商品日志已审核，无法修改")
}
var OldliveImage datatypes.JSON
if len(req.OldLiveImage) > 0 {
jsonBytes, _ := json.Marshal(req.OldLiveImage)
OldliveImage = jsonBytes
} else {
OldliveImage = datatypes.JSON("[]")
}
var NewliveImage datatypes.JSON
if len(req.NewLiveImage) > 0 {
jsonBytes, _ := json.Marshal(req.NewLiveImage)
NewliveImage = jsonBytes
} else {
NewliveImage = datatypes.JSON("[]")
}
md5Str := fmt.Sprintf("%x", md5.Sum([]byte(fmt.Sprintf("%s|%s|%s|%d|%d|%d|%s|%d|%d|%d",
req.Barcode,
req.NewName,
req.NewPublisher,
req.NewAuthor,
req.NewPublicationTime,
req.NewPrice,
req.NewBindingLayout,
req.NewPageCount,
req.NewWordCount,
string(NewliveImage),
))))
var existingLog models.ProductLog
if err := database.DB.Where("md5_data = ? AND is_del = 0 AND id != ?", md5Str, req.ID).First(&existingLog).Error; err == nil {
return 0, fmt.Errorf("该商品变更日志已存在，无需重复提交")
} else if err != gorm.ErrRecordNotFound {
return 0, fmt.Errorf("查询商品日志失败：%w", err)
}
if req.OldName == req.NewName &&
req.OldPublisher == req.NewPublisher &&
req.OldAuthor == req.NewAuthor &&
req.OldPublicationTime == req.NewPublicationTime &&
req.OldPrice == req.NewPrice &&
req.OldBindingLayout == req.NewBindingLayout &&
req.OldPageCount == req.NewPageCount &&
req.OldWordCount == req.NewWordCount &&
string(OldliveImage) == string(NewliveImage) &&
req.OldIsSuit == req.NewIsSuit {
return 0, fmt.Errorf("新旧数据完全一致，无需提交变更")
}
updates := map[string]interface{}{
"barcode": req.Barcode,
"md5_data": md5Str,
"old_name": req.OldName,
"new_name": req.NewName,
"old_publisher": req.OldPublisher,
"new_publisher": req.NewPublisher,
"old_author": req.OldAuthor,
"new_author": req.NewAuthor,
"old_publication_time": req.OldPublicationTime,
"new_publication_time": req.NewPublicationTime,
"old_price": req.OldPrice,
"new_price": req.NewPrice,
"old_binding_layout": req.OldBindingLayout,
"new_binding_layout": req.NewBindingLayout,
"old_page_count": req.OldPageCount,
"new_page_count": req.NewPageCount,
"old_word_count": req.OldWordCount,
"new_word_count": req.NewWordCount,
"old_live_image": OldliveImage,
"new_live_image": NewliveImage,
"old_is_suit": req.OldIsSuit,
"new_is_suit": req.NewIsSuit,
"updated_at": now,
}
if err := database.DB.Model(&productLog).Updates(updates).Error; err != nil {
return 0, fmt.Errorf("更新商品日志失败：%w", err)
}
return productLog.ID, nil
}
// 审核商品日志
func (s *ProductService) AuditProductLog(req systemReq.AuditProductLogRequest, userID int64) error {
var log models.ProductLog
if err := database.DB.Where("id = ? AND is_del = 0", req.ID).First(&log).Error; err != nil {
return fmt.Errorf("商品日志不存在：%w", err)
}
if log.Status != 0 {
return fmt.Errorf("该日志已审核，无法重复审核")
}
var NewliveImage datatypes.JSON
if len(req.NewLiveImage) > 0 {
jsonBytes, _ := json.Marshal(req.NewLiveImage)
NewliveImage = jsonBytes
} else {
NewliveImage = datatypes.JSON("[]")
}
now := time.Now().Unix()
updates := map[string]interface{}{
"new_name": req.NewName,
"new_publisher": req.NewPublisher,
"new_author": req.NewAuthor,
"new_publication_time": req.NewPublicationTime,
"new_price": req.NewPrice,
"new_binding_layout": req.NewBindingLayout,
"new_page_count": req.NewPageCount,
"new_word_count": req.NewWordCount,
"new_live_image": NewliveImage,
"new_is_suit": req.NewIsSuit,
"status": req.Status,
"audit_by": userID,
"updated_at": now,
}
if err := database.DB.Model(&log).Updates(updates).Error; err != nil {
return fmt.Errorf("审核商品日志失败：%w", err)
}
// 审核通过时，同步更新 ES 中的商品字段
if req.Status == 1 {
if err := s.syncApprovedLogToES(log.Barcode, req); err != nil {
// ES 同步失败只记日志，不阻断审核流程
fmt.Printf("[WARN] 审核后同步 ES 失败 (product_log_id=%d, barcode=%s): %v\r\n", req.ID, log.Barcode, err)
}
}
return nil
}
// syncApprovedLogToES 审核通过后将 new_* 字段同步到 ES 商品数据
func (s *ProductService) syncApprovedLogToES(barcode string, req systemReq.AuditProductLogRequest) error {
esURL := config.AppConfig.ExternalAPI.ESUpdateBookURL
if esURL == "" {
return fmt.Errorf("ES 更新接口地址未配置")
}
// 构建 data 字段（只传有值的字段）
data := make(map[string]interface{})
if req.NewName != "" {
data["book_name"] = req.NewName
}
if req.NewAuthor != "" {
data["author"] = req.NewAuthor
}
if req.NewPublisher != "" {
data["publisher"] = req.NewPublisher
}
if req.NewPrice > 0 {
data["fix_price"] = req.NewPrice
}
if req.NewBindingLayout != "" {
data["binding_layout"] = req.NewBindingLayout
}
if req.NewPublicationTime > 0 {
data["publication_time"] = req.NewPublicationTime
}
data["is_suit"] = req.NewIsSuit
payload := map[string]interface{}{
"isbn": barcode,
"data": data,
}
jsonBytes, err := json.Marshal(payload)
if err != nil {
return fmt.Errorf("序列化请求参数失败：%w", err)
}
resp, err := http.Post(esURL, "application/json", bytes.NewReader(jsonBytes))
if err != nil {
return fmt.Errorf("调用 ES 更新接口失败：%w", err)
}
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)
if resp.StatusCode != http.StatusOK {
return fmt.Errorf("ES 更新接口返回非200状态码[%d]: %s", resp.StatusCode, string(body))
}
return nil
}
// 删除商品日志
func (s *ProductService) DeleteProductLog(req systemReq.DeleteProductLogRequest) error {
var log models.ProductLog
if err := database.DB.Where("id = ? AND is_del = 0", req.ID).First(&log).Error; err != nil {
return fmt.Errorf("商品日志不存在：%w", err)
}
now := time.Now().Unix()
if err := database.DB.Model(&log).Updates(map[string]interface{}{
"is_del": 1,
"updated_at": now,
}).Error; err != nil {
return fmt.Errorf("删除商品日志失败：%w", err)
}
return nil
}
// GetShopProductDetail 获取店铺商品详情（包含商品数据和发送记录）
func (s *ProductService) GetShopProductDetail(req systemReq.GetShopProductDetailRequest, db ...*gorm.DB) (*systemRes.ShopProductDetailResponse, error) {
databaseConn := database.OptionalDB(db...)
if req.Page < 1 {
req.Page = 1
}
if req.PageSize < 1 || req.PageSize > 100 {
req.PageSize = 20
}
// 查询店铺信息
var shop models.Shop
if err := databaseConn.Where("id = ? AND del_flag = ?", req.ShopID, 0).First(&shop).Error; err != nil {
return nil, utils.NewError("店铺不存在")
}
// 构建响应
response := &systemRes.ShopProductDetailResponse{
ID: shop.ID,
ShopName: shop.ShopAliasName, // 使用别名作为店铺名称
ShopAliasName: shop.ShopAliasName,
ShopType: shop.ShopType,
ShopTypeName: s.getShopTypeName(shop.ShopType),
CreatedAt: shop.CreateTime,
UpdatedAt: shop.UpdateTime,
Products: []systemRes.ProductInShop{},
Page: req.Page,
PageSize: req.PageSize,
}
// 查询该店铺下的商品信息及发送记录
type ProductShopInfo struct {
ProductID int64 `gorm:"column:product_id"`
ProductName string `gorm:"column:product_name"`
ProductBarcode string `gorm:"column:product_barcode"`
LiveImage datatypes.JSON `gorm:"column:live_image"`
Price int64 `gorm:"column:price"`
SalePrice int64 `gorm:"column:sale_price"`
Quantity int64 `gorm:"column:quantity"`
WarehouseName string `gorm:"column:warehouse_name"`
LocationCode string `gorm:"column:location_code"`
IsBatchManaged int8 `gorm:"column:is_batch_managed"`
IsShelfLifeManaged int8 `gorm:"column:is_shelf_life_managed"`
OutTaskLogID int64 `gorm:"column:out_task_log_id"`
LogStatus int8 `gorm:"column:log_status"`
LogMsg string `gorm:"column:log_msg"`
WaveNo string `gorm:"column:wave_no"`
WaveTaskNo string `gorm:"column:wave_task_no"`
OutTaskNo int64 `gorm:"column:out_task_no"`
SalesOrderNo string `gorm:"column:sales_order_no"`
ShippingNo string `gorm:"column:shipping_no"`
ProductCreatedAt int64 `gorm:"column:product_created_at"`
ProductUpdatedAt int64 `gorm:"column:product_updated_at"`
}
var productInfos []ProductShopInfo
// 通过 out_task 和 wave_task_detail 关联查询商品
baseQuery := databaseConn.Table("out_task ot").
Select(`p.id as product_id,
p.name as product_name,
p.barcode as product_barcode,
p.live_image,
p.price,
p.sale_price,
COALESCE(inv.quantity, 0) as quantity,
w.name as warehouse_name,
l.code as location_code,
p.is_batch_managed,
p.is_shelf_life_managed,
COALESCE(otl.id, 0) as out_task_log_id,
COALESCE(otl.status, 0) as log_status,
COALESCE(otl.msg, '') as log_msg,
COALESCE(wh.wave_no, '') as wave_no,
COALESCE(wt.task_no, '') as wave_task_no,
ot.out_task_id as out_task_no,
COALESCE(so.so_no, '') as sales_order_no,
COALESCE(sh.shipping_no, '') as shipping_no,
p.created_at as product_created_at,
p.updated_at as product_updated_at`).
Joins("INNER JOIN wave_task wt ON wt.id = ot.wave_task_id AND wt.is_del = 0").
Joins("INNER JOIN wave_task_detail wtd ON wtd.wave_task_id = wt.id AND wtd.is_del = 0").
Joins("INNER JOIN product p ON p.id = wtd.product_id AND p.is_del = 0").
Joins("LEFT JOIN wave_header wh ON wh.id = wt.wave_id AND wh.is_del = 0").
Joins("LEFT JOIN sales_order so ON so.id = wh.related_order_id AND so.is_del = 0").
Joins("LEFT JOIN outbound_order obo ON obo.wave_task_id = wt.id AND obo.is_del = 0").
Joins("LEFT JOIN outbound_order_item oboi ON oboi.out_order_id = obo.id AND oboi.product_id = p.id AND oboi.is_del = 0").
Joins("LEFT JOIN shipping_order_item soi ON soi.outbound_order_item_id = oboi.id AND soi.is_del = 0").
Joins("LEFT JOIN shipping_order sh ON sh.id = soi.shipping_order_id AND sh.is_del = 0").
Joins("LEFT JOIN inventory inv ON inv.product_id = p.id AND inv.is_del = 0").
Joins("LEFT JOIN inventory_detail idetail ON idetail.product_id = p.id AND idetail.is_del = 0").
Joins("LEFT JOIN warehouse w ON w.id = inv.warehouse_id").
Joins("LEFT JOIN location l ON l.id = idetail.location_id").
Joins("LEFT JOIN out_task_log otl ON otl.out_task_id = ot.out_task_id AND otl.product_id = p.id AND otl.is_del = 0 AND otl.id = (SELECT MAX(otl2.id) FROM out_task_log otl2 WHERE otl2.out_task_id = ot.out_task_id AND otl2.product_id = p.id AND otl2.is_del = 0)").
Where("ot.shop_id = ? AND ot.is_del = 0", req.ShopID).
Group("p.id, p.name, p.barcode, p.live_image, p.price, p.sale_price, inv.quantity, w.name, l.code, p.is_batch_managed, p.is_shelf_life_managed, out_task_log_id, log_status, log_msg, wh.wave_no, wt.task_no, ot.out_task_id, so.so_no, sh.shipping_no, p.created_at, p.updated_at")
// 查询总数
var total int64
if err := databaseConn.Raw("SELECT COUNT(*) FROM (?) AS sub", baseQuery).Scan(&total).Error; err != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "查询店铺商品总数",
"error": fmt.Sprintf("查询失败: %v", err),
})
return nil, utils.NewError("查询店铺商品总数失败")
}
response.Total = total
// 查询各状态数量（基于全量商品，不受分页影响）
type StatusCount struct {
StatusType string `gorm:"column:status_type"`
Cnt int64 `gorm:"column:cnt"`
}
var statusCounts []StatusCount
if err := databaseConn.Table("(?) AS sub", baseQuery).
Select(`CASE
WHEN COALESCE(sub.out_task_log_id, 0) > 0 AND COALESCE(sub.log_status, 0) = 2 THEN 'success'
WHEN COALESCE(sub.out_task_log_id, 0) = 0 THEN 'not_sent'
ELSE 'failed'
END as status_type, COUNT(*) as cnt`).
Group("status_type").
Scan(&statusCounts).Error; err != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "查询店铺商品状态统计",
"error": fmt.Sprintf("查询失败: %v", err),
})
} else {
for _, sc := range statusCounts {
switch sc.StatusType {
case "success":
response.SuccessCount = sc.Cnt
case "not_sent":
response.NotSentCount = sc.Cnt
case "failed":
response.FailedCount = sc.Cnt
}
}
}
// 按状态筛选（不影响上述的全局统计计数）
if req.Status > 0 {
switch req.Status {
case 1: // 成功
baseQuery = baseQuery.Having("out_task_log_id > 0 AND log_status = 2")
case 2: // 任务已创建未发送到店铺
baseQuery = baseQuery.Having("out_task_log_id = 0")
case 3: // 发送失败
baseQuery = baseQuery.Having("out_task_log_id > 0 AND log_status != 2")
}
// 按筛选条件重新计算 total
var filteredTotal int64
if err := databaseConn.Raw("SELECT COUNT(*) FROM (?) AS sub", baseQuery).Scan(&filteredTotal).Error; err == nil {
response.Total = filteredTotal
}
}
// 分页查询
offset := (req.Page - 1) * req.PageSize
err := baseQuery.
Order("p.created_at DESC").
Offset(offset).
Limit(req.PageSize).
Scan(&productInfos).Error
if err != nil {
utils.ErrorLog(constant.LoggerChannelWork, map[string]interface{}{
"source": "查询店铺商品详情",
"error": fmt.Sprintf("查询失败: %v", err),
})
return nil, utils.NewError("查询店铺商品详情失败")
}
// 转换为响应格式
for _, info := range productInfos {
var liveImage []string
if len(info.LiveImage) > 0 {
json.Unmarshal(info.LiveImage, &liveImage)
}
// 根据日志状态判断在店铺中的状态和消息
statusInShop := int8(0)
msg := "任务已创建未发送到店铺"
if info.OutTaskLogID > 0 {
if info.LogStatus == 2 {
statusInShop = 1
msg = "发布成功"
} else if info.LogStatus == 0 {
statusInShop = 0
msg = info.LogMsg
if msg == "" {
msg = "发送到店铺失败"
}
} else if info.LogStatus == 1 {
statusInShop = 0
msg = "推送成功，待发布"
}
}
product := systemRes.ProductInShop{
ID: info.ProductID,
Name: info.ProductName,
Barcode: info.ProductBarcode,
LiveImage: liveImage,
Price: info.Price,
SalePrice: info.SalePrice,
Quantity: info.Quantity,
WarehouseName: info.WarehouseName,
LocationCode: info.LocationCode,
IsBatchManaged: info.IsBatchManaged,
IsShelfLifeManaged: info.IsShelfLifeManaged,
OutTaskLogID: info.OutTaskLogID,
StatusInShop: statusInShop,
Msg: msg,
WaveNo: info.WaveNo,
WaveTaskNo: info.WaveTaskNo,
OutTaskNo: info.OutTaskNo,
SalesOrderNo: info.SalesOrderNo,
ShippingNo: info.ShippingNo,
CreatedAt: info.ProductCreatedAt,
UpdatedAt: info.ProductUpdatedAt,
}
response.Products = append(response.Products, product)
}
return response, nil
}
func (s *ProductService) convertProductLogToItem(log models.ProductLog) systemRes.ProductLogItem {
var oldLiveImage []string
var newLiveImage []string
if len(log.OldLiveImage) > 0 {
err := json.Unmarshal(log.OldLiveImage, &oldLiveImage)
if err != nil {
return systemRes.ProductLogItem{}
}
}
if len(log.NewLiveImage) > 0 {
err := json.Unmarshal(log.NewLiveImage, &newLiveImage)
if err != nil {
return systemRes.ProductLogItem{}
}
}
return systemRes.ProductLogItem{
ID: log.ID,
Barcode: log.Barcode,
Md5Data: log.Md5Data,
OldName: log.OldName,
NewName: log.NewName,
OldPublisher: log.OldPublisher,
NewPublisher: log.NewPublisher,
OldAuthor: log.OldAuthor,
NewAuthor: log.NewAuthor,
OldPublicationTime: log.OldPublicationTime,
NewPublicationTime: log.NewPublicationTime,
OldPrice: log.OldPrice,
NewPrice: log.NewPrice,
OldBindingLayout: log.OldBindingLayout,
NewBindingLayout: log.NewBindingLayout,
OldPageCount: log.OldPageCount,
NewPageCount: log.NewPageCount,
OldWordCount: log.OldWordCount,
NewWordCount: log.NewWordCount,
OldLiveImage: oldLiveImage,
NewLiveImage: newLiveImage,
OldIsSuit: log.OldIsSuit,
NewIsSuit: log.NewIsSuit,
Status: log.Status,
CreateBy: log.CreateBy,
AuditBy: log.AuditBy,
CreatedAt: log.CreatedAt,
UpdatedAt: log.UpdatedAt,
}
}
func (s *ProductService) getShopTypeName(shopType int8) string {
switch shopType {
case 1:
return "拼多多"
case 2:
return "孔夫子"
case 5:
return "闲鱼"
default:
return "未知"
}
}
// 在 service 中使用
/*func (s *ProcessService) asyncWriteToMainDB(aboutID int64, data interface{}) {
go func() {
mainDB := database.DB
// 写入主库逻辑
mainDB.Create(data)
}()
}*/
Reference in New Issue View Git Blame Copy Permalink