yml2213andCursor
f7f48d0feb
在保持 DLC 默认零破坏的前提下，支持 priority/仅乐玩/仅 DLC 履约策略与后台 GUI 配置；同步补齐 Prepare 渠道落库、乐玩订单取消、Webhook 验签与失败重试。 Co-authored-by: Cursor <cursoragent@cursor.com>
459 lines
15 KiB
Go
459 lines
15 KiB
Go
package service
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
|
|
"affiliate_dash/internal/model"
|
|
|
|
"gorm.io/gorm"
|
|
"gorm.io/gorm/clause"
|
|
)
|
|
|
|
type ProductCatalogItem struct {
|
|
ID uint `json:"id"`
|
|
ProductID uint `json:"product_id"`
|
|
SKU string `json:"sku"`
|
|
DisplayName string `json:"display_name"`
|
|
Category string `json:"category"`
|
|
PriceAmount int64 `json:"price_amount"`
|
|
CostAmount int64 `json:"cost_amount"`
|
|
Currency string `json:"currency"`
|
|
Stock int64 `json:"stock"`
|
|
Status string `json:"status"`
|
|
FulfillmentConfig string `json:"fulfillment_config,omitempty"`
|
|
Routing ProductRoutingConfig `json:"routing"`
|
|
}
|
|
|
|
// ListProductCatalog 返回自营商户的全部可售商品，作为平台默认商品目录供分配。
|
|
func (s *MerchantService) ListProductCatalog() ([]ProductCatalogItem, error) {
|
|
var selfMerchant model.Merchant
|
|
if err := s.db.Where("code = ?", model.MerchantCodeSelfOperated).First(&selfMerchant).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, errors.New("平台商品目录尚未初始化")
|
|
}
|
|
return nil, err
|
|
}
|
|
var products []model.MerchantProduct
|
|
if err := s.db.Preload("Product").Where("merchant_id = ?", selfMerchant.ID).Order("id ASC").Find(&products).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
items := make([]ProductCatalogItem, 0, len(products))
|
|
for _, p := range products {
|
|
category := ""
|
|
if p.Product != nil {
|
|
category = p.Product.Category
|
|
}
|
|
routing := ParseProductRoutingConfig(p.FulfillmentConfig, p.SKU)
|
|
items = append(items, ProductCatalogItem{
|
|
ID: p.ID,
|
|
ProductID: p.ProductID,
|
|
SKU: p.SKU,
|
|
DisplayName: p.DisplayName,
|
|
Category: category,
|
|
PriceAmount: p.PriceAmount,
|
|
CostAmount: p.CostAmount,
|
|
Currency: p.Currency,
|
|
Stock: p.Stock,
|
|
Status: p.Status,
|
|
FulfillmentConfig: p.FulfillmentConfig,
|
|
Routing: routing,
|
|
})
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
// ListMerchantProductsByAdmin 供平台管理员查看指定商户的可售商品（不限功能开关）。
|
|
func (s *MerchantService) ListMerchantProductsByAdmin(merchantID uint) ([]ProductCatalogItem, error) {
|
|
var products []model.MerchantProduct
|
|
if err := s.db.Preload("Product").Where("merchant_id = ?", merchantID).Order("id ASC").Find(&products).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
items := make([]ProductCatalogItem, 0, len(products))
|
|
for _, p := range products {
|
|
category := ""
|
|
if p.Product != nil {
|
|
category = p.Product.Category
|
|
}
|
|
items = append(items, ProductCatalogItem{
|
|
ID: p.ID,
|
|
ProductID: p.ProductID,
|
|
SKU: p.SKU,
|
|
DisplayName: p.DisplayName,
|
|
Category: category,
|
|
PriceAmount: p.PriceAmount,
|
|
CostAmount: p.CostAmount,
|
|
Currency: p.Currency,
|
|
Stock: p.Stock,
|
|
Status: p.Status,
|
|
})
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
// AssignProductsInput 批量分配商品给商户的入参。
|
|
type AssignProductsInput struct {
|
|
// CatalogIDs 为自营商户商品目录 ID 列表；为空表示清空该商户全部商品。
|
|
CatalogIDs []uint
|
|
}
|
|
|
|
// AssignProducts 按自营商户商品目录 ID 批量同步商户的可售商品：
|
|
// 目录中勾选的商品会被复制（已存在则跳过），未勾选的已有商品会被移除。
|
|
func (s *MerchantService) AssignProducts(merchantID uint, in AssignProductsInput, actorUserID uint) (int, error) {
|
|
assigned := 0
|
|
err := s.db.Transaction(func(tx *gorm.DB) error {
|
|
var merchant model.Merchant
|
|
if err := tx.Where("id = ?", merchantID).First(&merchant).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return errors.New("商户不存在")
|
|
}
|
|
return err
|
|
}
|
|
if merchant.Code == model.MerchantCodeSelfOperated {
|
|
return errors.New("自营商户的商品目录由平台维护，不可分配")
|
|
}
|
|
var selfMerchant model.Merchant
|
|
if err := tx.Where("code = ?", model.MerchantCodeSelfOperated).First(&selfMerchant).Error; err != nil {
|
|
return errors.New("平台商品目录尚未初始化")
|
|
}
|
|
|
|
// 读取目录全量，构造 id -> 模板 的映射
|
|
var templates []model.MerchantProduct
|
|
if err := tx.Where("merchant_id = ?", selfMerchant.ID).Find(&templates).Error; err != nil {
|
|
return err
|
|
}
|
|
tmplByID := make(map[uint]model.MerchantProduct, len(templates))
|
|
for _, t := range templates {
|
|
tmplByID[t.ID] = t
|
|
}
|
|
|
|
// 读取商户已有商品，构造 sku -> 已有 的映射
|
|
var existing []model.MerchantProduct
|
|
if err := tx.Where("merchant_id = ?", merchantID).Find(&existing).Error; err != nil {
|
|
return err
|
|
}
|
|
existBySKU := make(map[string]model.MerchantProduct, len(existing))
|
|
for _, e := range existing {
|
|
existBySKU[e.SKU] = e
|
|
}
|
|
|
|
// 计算需要新增的 SKU 集合
|
|
wantSKUs := make(map[string]bool, len(in.CatalogIDs))
|
|
toCreate := make([]model.MerchantProduct, 0, len(in.CatalogIDs))
|
|
for _, id := range in.CatalogIDs {
|
|
t, ok := tmplByID[id]
|
|
if !ok {
|
|
continue
|
|
}
|
|
wantSKUs[t.SKU] = true
|
|
if _, has := existBySKU[t.SKU]; !has {
|
|
toCreate = append(toCreate, model.MerchantProduct{
|
|
MerchantID: merchantID,
|
|
ProductID: t.ProductID,
|
|
SKU: t.SKU,
|
|
DisplayName: t.DisplayName,
|
|
PriceAmount: t.PriceAmount,
|
|
CostAmount: t.CostAmount,
|
|
Currency: t.Currency,
|
|
Stock: t.Stock,
|
|
Status: t.Status,
|
|
FulfillmentConfig: t.FulfillmentConfig,
|
|
})
|
|
}
|
|
}
|
|
|
|
// 移除未勾选的已有商品
|
|
var removeIDs []uint
|
|
for _, e := range existing {
|
|
if !wantSKUs[e.SKU] {
|
|
removeIDs = append(removeIDs, e.ID)
|
|
}
|
|
}
|
|
if len(removeIDs) > 0 {
|
|
if err := tx.Where("merchant_id = ? AND id IN ?", merchantID, removeIDs).Delete(&model.MerchantProduct{}).Error; err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// 新增勾选但尚未拥有的商品
|
|
if len(toCreate) > 0 {
|
|
if err := tx.Clauses(clause.OnConflict{DoNothing: true}).Create(&toCreate).Error; err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
assigned = len(wantSKUs)
|
|
return writeAudit(tx, &merchantID, &actorUserID, nil, "merchant.products.assign", "merchant", fmt.Sprint(merchantID), map[string]string{"assigned": fmt.Sprint(assigned)})
|
|
})
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return assigned, nil
|
|
}
|
|
|
|
// copyDefaultProducts 将自营商户的全部可售商品复制给新建商户，作为默认商品目录。
|
|
// 自营商户（self-operated）充当平台默认商品模板，新商户开箱即用。
|
|
// 使用 OnConflict DoNothing 保证幂等：即使重复调用也不会报唯一索引冲突。
|
|
func copyDefaultProducts(tx *gorm.DB, merchantID uint) error {
|
|
var selfMerchant model.Merchant
|
|
if err := tx.Where("code = ?", model.MerchantCodeSelfOperated).First(&selfMerchant).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil // 自营商户不存在时跳过，不阻断建商户
|
|
}
|
|
return err
|
|
}
|
|
if selfMerchant.ID == merchantID {
|
|
return nil // 自营商户自身无需复制
|
|
}
|
|
var templates []model.MerchantProduct
|
|
if err := tx.Where("merchant_id = ?", selfMerchant.ID).Find(&templates).Error; err != nil {
|
|
return err
|
|
}
|
|
if len(templates) == 0 {
|
|
return nil
|
|
}
|
|
products := make([]model.MerchantProduct, 0, len(templates))
|
|
for _, t := range templates {
|
|
products = append(products, model.MerchantProduct{
|
|
MerchantID: merchantID,
|
|
ProductID: t.ProductID,
|
|
SKU: t.SKU,
|
|
DisplayName: t.DisplayName,
|
|
PriceAmount: t.PriceAmount,
|
|
CostAmount: t.CostAmount,
|
|
Currency: t.Currency,
|
|
Stock: t.Stock,
|
|
Status: t.Status,
|
|
FulfillmentConfig: t.FulfillmentConfig,
|
|
})
|
|
}
|
|
return tx.Clauses(clause.OnConflict{DoNothing: true}).Create(&products).Error
|
|
}
|
|
|
|
func ensureProduct(tx *gorm.DB, in CreateMerchantProductInput) (*model.Product, error) {
|
|
if in.ProductCode != "" {
|
|
var product model.Product
|
|
err := tx.Where("code = ?", in.ProductCode).First(&product).Error
|
|
if err == nil {
|
|
return &product, nil
|
|
}
|
|
if !errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, err
|
|
}
|
|
}
|
|
if in.ProductName == "" {
|
|
return nil, errors.New("新建平台商品时商品名称不能为空")
|
|
}
|
|
code := in.ProductCode
|
|
if code == "" {
|
|
token, err := randomToken("prd_", 12)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
code = token
|
|
}
|
|
product := &model.Product{
|
|
Code: code,
|
|
Name: in.ProductName,
|
|
Category: in.Category,
|
|
Description: in.Description,
|
|
Attributes: in.Attributes,
|
|
Status: model.ProductStatusActive,
|
|
}
|
|
if err := tx.Create(product).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return product, nil
|
|
}
|
|
|
|
// UpdateProductRouting 更新平台目录商品的履约渠道与优先级配置
|
|
func (s *MerchantService) UpdateProductRouting(catalogID uint, routing ProductRoutingConfig, actorUserID uint) error {
|
|
switch routing.RoutingMode {
|
|
case RoutingModePriority, RoutingModeLewan, RoutingModeDLC:
|
|
default:
|
|
return errors.New("routing_mode 仅支持 priority / lewan / dlc")
|
|
}
|
|
if routing.RoutingMode == RoutingModePriority {
|
|
if len(routing.Priority) == 0 {
|
|
routing.Priority = []string{ProviderLewan, ProviderDLC}
|
|
}
|
|
for _, name := range routing.Priority {
|
|
if name != ProviderLewan && name != ProviderDLC {
|
|
return errors.New("priority 仅支持 lewan / dlc")
|
|
}
|
|
}
|
|
}
|
|
if routing.RoutingMode == RoutingModeLewan || routing.RoutingMode == RoutingModePriority {
|
|
if strings.TrimSpace(routing.LewanProductID) == "" {
|
|
return errors.New("乐玩渠道需配置 lewan_product_id")
|
|
}
|
|
}
|
|
if routing.DeliveryType != "" && routing.DeliveryType != "LINK_BINDING" && routing.DeliveryType != "EMAIL_BINDING" {
|
|
return errors.New("delivery_type 仅支持 LINK_BINDING / EMAIL_BINDING")
|
|
}
|
|
|
|
configBytes, err := json.Marshal(routing)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
configStr := string(configBytes)
|
|
|
|
return s.db.Transaction(func(tx *gorm.DB) error {
|
|
var item model.MerchantProduct
|
|
if err := tx.Preload("Product").Where("id = ?", catalogID).First(&item).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return errors.New("目录商品不存在")
|
|
}
|
|
return err
|
|
}
|
|
|
|
// 更新自营模板
|
|
if err := tx.Model(&model.MerchantProduct{}).Where("id = ?", item.ID).Update("fulfillment_config", configStr).Error; err != nil {
|
|
return err
|
|
}
|
|
|
|
// 同步更新所有商户同 SKU 商品的履约配置，保证全平台生效
|
|
if item.SKU != "" {
|
|
_ = tx.Model(&model.MerchantProduct{}).Where("sku = ?", item.SKU).Update("fulfillment_config", configStr).Error
|
|
}
|
|
|
|
return writeAudit(tx, &item.MerchantID, &actorUserID, nil, "catalog.routing.update", "merchant_product", fmt.Sprint(catalogID), map[string]string{
|
|
"sku": item.SKU,
|
|
"routing_mode": routing.RoutingMode,
|
|
"priority": strings.Join(routing.Priority, ","),
|
|
})
|
|
})
|
|
}
|
|
|
|
type SyncLewanProductInput struct {
|
|
LewanProductID string `json:"lewan_product_id"`
|
|
Name string `json:"name"`
|
|
Category string `json:"category"`
|
|
SKU string `json:"sku"`
|
|
Price int64 `json:"price"`
|
|
DeliveryType string `json:"delivery_type"`
|
|
}
|
|
|
|
// SyncLewanProductToCatalog 导入或关联乐玩商品至平台商品目录
|
|
func (s *MerchantService) SyncLewanProductToCatalog(in SyncLewanProductInput, actorUserID uint) (*ProductCatalogItem, error) {
|
|
if in.LewanProductID == "" {
|
|
return nil, errors.New("乐玩商品ID不能为空")
|
|
}
|
|
if in.Name == "" {
|
|
return nil, errors.New("商品名称不能为空")
|
|
}
|
|
|
|
var res *ProductCatalogItem
|
|
err := s.db.Transaction(func(tx *gorm.DB) error {
|
|
var selfMerchant model.Merchant
|
|
if err := tx.Where("code = ?", model.MerchantCodeSelfOperated).First(&selfMerchant).Error; err != nil {
|
|
return errors.New("自营商户未初始化")
|
|
}
|
|
|
|
sku := strings.TrimSpace(in.SKU)
|
|
if sku == "" {
|
|
// 自动根据乐玩 UUID 派生 SKU
|
|
cleanID := strings.ReplaceAll(in.LewanProductID, "-", "")
|
|
if len(cleanID) > 12 {
|
|
cleanID = cleanID[:12]
|
|
}
|
|
sku = "lewan_" + cleanID
|
|
}
|
|
|
|
// 检查 Product
|
|
var product model.Product
|
|
if err := tx.Where("code = ?", sku).First(&product).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
product = model.Product{
|
|
Code: sku,
|
|
Name: in.Name,
|
|
Category: in.Category,
|
|
Status: model.ProductStatusActive,
|
|
}
|
|
if err := tx.Create(&product).Error; err != nil {
|
|
return err
|
|
}
|
|
} else {
|
|
return err
|
|
}
|
|
}
|
|
|
|
routing := ProductRoutingConfig{
|
|
RoutingMode: RoutingModeLewan,
|
|
Priority: []string{ProviderLewan, ProviderDLC},
|
|
LewanProductID: in.LewanProductID,
|
|
LewanName: in.Name,
|
|
DeliveryType: in.DeliveryType,
|
|
}
|
|
if routing.DeliveryType == "" {
|
|
routing.DeliveryType = "LINK_BINDING"
|
|
}
|
|
if routing.DeliveryType != "LINK_BINDING" && routing.DeliveryType != "EMAIL_BINDING" {
|
|
return errors.New("delivery_type 仅支持 LINK_BINDING / EMAIL_BINDING")
|
|
}
|
|
if builtinDLC := deliveryGoodID("dlc", sku); builtinDLC != "" {
|
|
routing.DLCGoodID = builtinDLC
|
|
routing.RoutingMode = RoutingModePriority
|
|
}
|
|
configBytes, _ := json.Marshal(routing)
|
|
configStr := string(configBytes)
|
|
|
|
// 检查自营商户商品
|
|
var mp model.MerchantProduct
|
|
if err := tx.Where("merchant_id = ? AND sku = ?", selfMerchant.ID, sku).First(&mp).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
price := in.Price
|
|
if price <= 0 {
|
|
price = 1000
|
|
}
|
|
mp = model.MerchantProduct{
|
|
MerchantID: selfMerchant.ID,
|
|
ProductID: product.ID,
|
|
SKU: sku,
|
|
DisplayName: in.Name,
|
|
PriceAmount: price,
|
|
CostAmount: price,
|
|
Currency: "POINT",
|
|
Stock: -1,
|
|
Status: model.ProductStatusActive,
|
|
FulfillmentConfig: configStr,
|
|
}
|
|
if err := tx.Create(&mp).Error; err != nil {
|
|
return err
|
|
}
|
|
} else {
|
|
return err
|
|
}
|
|
} else {
|
|
// 更新现有配置
|
|
_ = tx.Model(&mp).Update("fulfillment_config", configStr).Error
|
|
}
|
|
|
|
res = &ProductCatalogItem{
|
|
ID: mp.ID,
|
|
ProductID: product.ID,
|
|
SKU: sku,
|
|
DisplayName: mp.DisplayName,
|
|
Category: product.Category,
|
|
PriceAmount: mp.PriceAmount,
|
|
CostAmount: mp.CostAmount,
|
|
Currency: mp.Currency,
|
|
Stock: mp.Stock,
|
|
Status: mp.Status,
|
|
FulfillmentConfig: configStr,
|
|
Routing: routing,
|
|
}
|
|
|
|
return writeAudit(tx, &selfMerchant.ID, &actorUserID, nil, "catalog.lewan.sync", "merchant_product", fmt.Sprint(mp.ID), map[string]string{
|
|
"lewan_product_id": in.LewanProductID,
|
|
"sku": sku,
|
|
})
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return res, nil
|
|
}
|