Dockerfile

service/sync/default.go

@@ -0,0 +1,108 @@
+package service
+
+import (
+	consts "assets/consts/public"
+	"assets/model/entity/sync"
+	"context"
+
+	"go.mongodb.org/mongo-driver/v2/bson"
+)
+
+// BasePlatformService 平台服务基类
+type BasePlatformService struct {
+	Platform consts.SyncPlatform
+	Config   *entity.ChannelConfig
+}
+
+// NewBasePlatformService 创建基础平台服务
+func NewBasePlatformService(platform consts.SyncPlatform, config *entity.ChannelConfig) *BasePlatformService {
+	return &BasePlatformService{
+		Platform: platform,
+		Config:   config,
+	}
+}
+
+// DefaultAssetService 默认资产平台服务（用于未明确定义的平台）
+type DefaultAssetService struct {
+	*BasePlatformService
+}
+
+// NewDefaultAssetService 创建默认资产服务
+func NewDefaultAssetService(platform consts.SyncPlatform, config *entity.ChannelConfig) *DefaultAssetService {
+	return &DefaultAssetService{
+		BasePlatformService: NewBasePlatformService(platform, config),
+	}
+}
+
+func (s *DefaultAssetService) SyncAsset(ctx context.Context, assetID *bson.ObjectID) error {
+	// 默认实现，不执行实际同步
+	return nil
+}
+
+func (s *DefaultAssetService) GetAsset(ctx context.Context, assetID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *DefaultAssetService) UpdateAsset(ctx context.Context, assetID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *DefaultAssetService) DeleteAsset(ctx context.Context, assetID *bson.ObjectID) error {
+	return nil
+}
+
+// DefaultAssetSkuService 默认资产SKU平台服务
+type DefaultAssetSkuService struct {
+	*BasePlatformService
+}
+
+// NewDefaultAssetSkuService 创建默认资产SKU服务
+func NewDefaultAssetSkuService(platform consts.SyncPlatform, config *entity.ChannelConfig) *DefaultAssetSkuService {
+	return &DefaultAssetSkuService{
+		BasePlatformService: NewBasePlatformService(platform, config),
+	}
+}
+
+func (s *DefaultAssetSkuService) SyncAssetSku(ctx context.Context, assetSkuID *bson.ObjectID) error {
+	return nil
+}
+
+func (s *DefaultAssetSkuService) GetAssetSku(ctx context.Context, assetSkuID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *DefaultAssetSkuService) UpdateAssetSku(ctx context.Context, assetSkuID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *DefaultAssetSkuService) DeleteAssetSku(ctx context.Context, assetSkuID *bson.ObjectID) error {
+	return nil
+}
+
+// DefaultStockService 默认库存平台服务
+type DefaultStockService struct {
+	*BasePlatformService
+}
+
+// NewDefaultStockService 创建默认库存服务
+func NewDefaultStockService(platform consts.SyncPlatform, config *entity.ChannelConfig) *DefaultStockService {
+	return &DefaultStockService{
+		BasePlatformService: NewBasePlatformService(platform, config),
+	}
+}
+
+func (s *DefaultStockService) SyncStock(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+func (s *DefaultStockService) GetStock(ctx context.Context, stockID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *DefaultStockService) UpdateStock(ctx context.Context, stockID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *DefaultStockService) DeleteStock(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}

service/sync/platform_factory.go

@@ -0,0 +1,156 @@
+package service
+
+import (
+	consts "assets/consts/public"
+	"assets/dao/sync"
+	"context"
+)
+
+// DefaultPlatformFactory 默认平台服务工厂实现
+type DefaultPlatformFactory struct{}
+
+// NewPlatformServiceFactory 创建平台服务工厂
+func NewPlatformServiceFactory() PlatformFactory {
+	return &DefaultPlatformFactory{}
+}
+
+// CreateAssetService 创建资产平台服务
+func (f *DefaultPlatformFactory) CreateAssetService(platform consts.SyncPlatform) AssetPlatformService {
+	config, err := dao.SyncConfig.GetByPlatform(context.Background(), platform)
+	if err != nil || config == nil {
+		// 如果没有配置，创建默认配置
+		//config = &entity.SyncConfig{
+		//	Platform:     platform,
+		//	IsEnabled:    true,
+		//	APIEndpoint:  f.getAPIEndpoint(platform),
+		//	SyncInterval: 300,
+		//	BatchSize:    100,
+		//	MaxRetries:   3,
+		//}
+	}
+
+	switch platform {
+	case consts.SyncPlatformTaobao:
+		return NewTaobaoAssetService(config)
+	case consts.SyncPlatformJD:
+		return NewJDAssetService(config)
+	case consts.SyncPlatformDouyin:
+		return NewDouyinAssetService(config)
+	case consts.SyncPlatformKuaishou:
+		return NewKuaishouAssetService(config)
+	case consts.SyncPlatformXiaohongshu:
+		return NewXiaohongshuAssetService(config)
+	case consts.SyncPlatformPinduoduo:
+		return NewPinduoduoAssetService(config)
+	case consts.SyncPlatformXianyu:
+		return NewXianyuAssetService(config)
+	case consts.SyncPlatformBlockchain:
+		return NewBlockchainAssetService(config)
+	case consts.SyncPlatformInternal:
+		return NewInternalAssetService(config)
+	default:
+		return NewDefaultAssetService(platform, config)
+	}
+}
+
+// CreateAssetSkuService 创建资产SKU平台服务
+func (f *DefaultPlatformFactory) CreateAssetSkuService(platform consts.SyncPlatform) AssetSkuPlatformService {
+	config, err := dao.SyncConfig.GetByPlatform(context.Background(), platform)
+	if err != nil || config == nil {
+		//config = &entity.ChannelConfig{
+		//	Platform:     platform,
+		//	IsEnabled:    true,
+		//	APIEndpoint:  f.getAPIEndpoint(platform),
+		//	SyncInterval: 300,
+		//	BatchSize:    100,
+		//	MaxRetries:   3,
+		//}
+	}
+
+	switch platform {
+	case consts.SyncPlatformTaobao:
+		return NewTaobaoAssetSkuService(config)
+	case consts.SyncPlatformJD:
+		return NewJDAssetSkuService(config)
+	case consts.SyncPlatformDouyin:
+		return NewDouyinAssetSkuService(config)
+	case consts.SyncPlatformKuaishou:
+		return NewKuaishouAssetSkuService(config)
+	case consts.SyncPlatformXiaohongshu:
+		return NewXiaohongshuAssetSkuService(config)
+	case consts.SyncPlatformPinduoduo:
+		return NewPinduoduoAssetSkuService(config)
+	case consts.SyncPlatformXianyu:
+		return NewXianyuAssetSkuService(config)
+	case consts.SyncPlatformBlockchain:
+		return NewBlockchainAssetSkuService(config)
+	case consts.SyncPlatformInternal:
+		return NewInternalAssetSkuService(config)
+	default:
+		return NewDefaultAssetSkuService(platform, config)
+	}
+}
+
+// CreateStockService 创建库存平台服务
+func (f *DefaultPlatformFactory) CreateStockService(platform consts.SyncPlatform) StockPlatformService {
+	config, err := dao.SyncConfig.GetByPlatform(context.Background(), platform)
+	if err != nil || config == nil {
+		//config = &entity.SyncConfig{
+		//	Platform:     platform,
+		//	IsEnabled:    true,
+		//	APIEndpoint:  f.getAPIEndpoint(platform),
+		//	SyncInterval: 300,
+		//	BatchSize:    100,
+		//	MaxRetries:   3,
+		//}
+	}
+
+	switch platform {
+	case consts.SyncPlatformTaobao:
+		return NewTaobaoStockService(config)
+	case consts.SyncPlatformJD:
+		return NewJDStockService(config)
+	case consts.SyncPlatformDouyin:
+		return NewDouyinStockService(config)
+	case consts.SyncPlatformKuaishou:
+		return NewKuaishouStockService(config)
+	case consts.SyncPlatformXiaohongshu:
+		return NewXiaohongshuStockService(config)
+	case consts.SyncPlatformPinduoduo:
+		return NewPinduoduoStockService(config)
+	case consts.SyncPlatformXianyu:
+		return NewXianyuStockService(config)
+	case consts.SyncPlatformBlockchain:
+		return NewBlockchainStockService(config)
+	case consts.SyncPlatformInternal:
+		return NewInternalStockService(config)
+	default:
+		return NewDefaultStockService(platform, config)
+	}
+}
+
+// getAPIEndpoint 根据平台获取API端点
+func (f *DefaultPlatformFactory) getAPIEndpoint(platform consts.SyncPlatform) string {
+	switch platform {
+	case consts.SyncPlatformTaobao:
+		return "https://eco.taobao.com/router/rest"
+	case consts.SyncPlatformJD:
+		return "https://api.jd.com/routerjson"
+	case consts.SyncPlatformDouyin:
+		return "https://open.douyin.com/api"
+	case consts.SyncPlatformKuaishou:
+		return "https://open.kuaishou.com/api"
+	case consts.SyncPlatformXiaohongshu:
+		return "https://open.xiaohongshu.com/api"
+	case consts.SyncPlatformPinduoduo:
+		return "https://open.pinduoduo.com/api"
+	case consts.SyncPlatformXianyu:
+		return "https://api.xianyu.com/api"
+	case consts.SyncPlatformBlockchain:
+		return "https://api.blockchain.com/api"
+	case consts.SyncPlatformInternal:
+		return "http://localhost:3004/api"
+	default:
+		return ""
+	}
+}

service/sync/platform_interface.go

@@ -0,0 +1,54 @@
+package service
+
+import (
+	consts "assets/consts/public"
+	"context"
+
+	"go.mongodb.org/mongo-driver/v2/bson"
+)
+
+// AssetPlatformService 资产平台服务接口
+type AssetPlatformService interface {
+	// SyncAsset 同步资产到平台
+	SyncAsset(ctx context.Context, assetID *bson.ObjectID) error
+	// GetAsset 从平台获取资产
+	GetAsset(ctx context.Context, assetID *bson.ObjectID) (interface{}, error)
+	// UpdateAsset 更新平台资产
+	UpdateAsset(ctx context.Context, assetID *bson.ObjectID, data interface{}) error
+	// DeleteAsset 删除平台资产
+	DeleteAsset(ctx context.Context, assetID *bson.ObjectID) error
+}
+
+// AssetSkuPlatformService 资产SKU平台服务接口
+type AssetSkuPlatformService interface {
+	// SyncAssetSku 同步资产SKU到平台
+	SyncAssetSku(ctx context.Context, assetSkuID *bson.ObjectID) error
+	// GetAssetSku 从平台获取资产SKU
+	GetAssetSku(ctx context.Context, assetSkuID *bson.ObjectID) (interface{}, error)
+	// UpdateAssetSku 更新平台资产SKU
+	UpdateAssetSku(ctx context.Context, assetSkuID *bson.ObjectID, data interface{}) error
+	// DeleteAssetSku 删除平台资产SKU
+	DeleteAssetSku(ctx context.Context, assetSkuID *bson.ObjectID) error
+}
+
+// StockPlatformService 库存平台服务接口
+type StockPlatformService interface {
+	// SyncStock 同步库存到平台
+	SyncStock(ctx context.Context, stockID *bson.ObjectID) error
+	// GetStock 从平台获取库存
+	GetStock(ctx context.Context, stockID *bson.ObjectID) (interface{}, error)
+	// UpdateStock 更新平台库存
+	UpdateStock(ctx context.Context, stockID *bson.ObjectID, data interface{}) error
+	// DeleteStock 删除平台库存
+	DeleteStock(ctx context.Context, stockID *bson.ObjectID) error
+}
+
+// PlatformFactory 平台服务工厂
+type PlatformFactory interface {
+	// CreateAssetService 创建资产平台服务
+	CreateAssetService(platform consts.SyncPlatform) AssetPlatformService
+	// CreateAssetSkuService 创建资产SKU平台服务
+	CreateAssetSkuService(platform consts.SyncPlatform) AssetSkuPlatformService
+	// CreateStockService 创建库存平台服务
+	CreateStockService(platform consts.SyncPlatform) StockPlatformService
+}

service/sync/platforms.go

@@ -0,0 +1,755 @@
+package service
+
+import (
+	consts "assets/consts/public"
+	"assets/model/entity/sync"
+	"context"
+
+	"go.mongodb.org/mongo-driver/v2/bson"
+)
+
+// 为各平台创建占位服务
+// 实际的API调用逻辑将在后续实现
+
+// TaobaoAssetService 淘宝资产服务
+type TaobaoAssetService struct {
+	*BasePlatformService
+}
+
+func NewTaobaoAssetService(config *entity.ChannelConfig) *TaobaoAssetService {
+	return &TaobaoAssetService{
+		BasePlatformService: NewBasePlatformService(consts.SyncPlatformTaobao, config),
+	}
+}
+
+func (s *TaobaoAssetService) SyncAsset(ctx context.Context, assetID *bson.ObjectID) error {
+	// TODO: 实现淘宝资产同步逻辑
+	return nil
+}
+
+func (s *TaobaoAssetService) GetAsset(ctx context.Context, assetID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *TaobaoAssetService) UpdateAsset(ctx context.Context, assetID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *TaobaoAssetService) DeleteAsset(ctx context.Context, assetID *bson.ObjectID) error {
+	return nil
+}
+
+// TaobaoAssetSkuService 淘宝资产SKU服务
+type TaobaoAssetSkuService struct {
+	*BasePlatformService
+}
+
+func NewTaobaoAssetSkuService(config *entity.ChannelConfig) *TaobaoAssetSkuService {
+	return &TaobaoAssetSkuService{
+		BasePlatformService: NewBasePlatformService(consts.SyncPlatformTaobao, config),
+	}
+}
+
+func (s *TaobaoAssetSkuService) SyncAssetSku(ctx context.Context, assetSkuID *bson.ObjectID) error {
+	return nil
+}
+
+func (s *TaobaoAssetSkuService) GetAssetSku(ctx context.Context, assetSkuID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *TaobaoAssetSkuService) UpdateAssetSku(ctx context.Context, assetSkuID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *TaobaoAssetSkuService) DeleteAssetSku(ctx context.Context, assetSkuID *bson.ObjectID) error {
+	return nil
+}
+
+// TaobaoStockService 淘宝库存服务
+type TaobaoStockService struct {
+	*BasePlatformService
+}
+
+func NewTaobaoStockService(config *entity.ChannelConfig) *TaobaoStockService {
+	return &TaobaoStockService{
+		BasePlatformService: NewBasePlatformService(consts.SyncPlatformTaobao, config),
+	}
+}
+
+func (s *TaobaoStockService) SyncStock(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+func (s *TaobaoStockService) GetStock(ctx context.Context, stockID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *TaobaoStockService) UpdateStock(ctx context.Context, stockID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *TaobaoStockService) DeleteStock(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+// 其他平台的占位服务结构体...
+// 京东、抖音、快手、小红书、拼多多、闲鱼、区块链等
+// 由于代码结构相似，这里只展示模板
+
+// JDAssetService 京东资产服务
+type JDAssetService struct {
+	*BasePlatformService
+}
+
+func NewJDAssetService(config *entity.ChannelConfig) *JDAssetService {
+	return &JDAssetService{
+		BasePlatformService: NewBasePlatformService(consts.SyncPlatformJD, config),
+	}
+}
+
+func (s *JDAssetService) SyncAsset(ctx context.Context, assetID *bson.ObjectID) error {
+	return nil
+}
+
+func (s *JDAssetService) GetAsset(ctx context.Context, assetID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *JDAssetService) UpdateAsset(ctx context.Context, assetID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *JDAssetService) DeleteAsset(ctx context.Context, assetID *bson.ObjectID) error {
+	return nil
+}
+
+// JDAssetSkuService 京东资产SKU服务
+type JDAssetSkuService struct {
+	*BasePlatformService
+}
+
+func NewJDAssetSkuService(config *entity.ChannelConfig) *JDAssetSkuService {
+	return &JDAssetSkuService{
+		BasePlatformService: NewBasePlatformService(consts.SyncPlatformJD, config),
+	}
+}
+
+func (s *JDAssetSkuService) SyncAssetSku(ctx context.Context, assetSkuID *bson.ObjectID) error {
+	return nil
+}
+
+func (s *JDAssetSkuService) GetAssetSku(ctx context.Context, assetSkuID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *JDAssetSkuService) UpdateAssetSku(ctx context.Context, assetSkuID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *JDAssetSkuService) DeleteAssetSku(ctx context.Context, assetSkuID *bson.ObjectID) error {
+	return nil
+}
+
+// JDStockService 京东库存服务
+type JDStockService struct {
+	*BasePlatformService
+}
+
+func NewJDStockService(config *entity.ChannelConfig) *JDStockService {
+	return &JDStockService{
+		BasePlatformService: NewBasePlatformService(consts.SyncPlatformJD, config),
+	}
+}
+
+func (s *JDStockService) SyncStock(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+func (s *JDStockService) GetStock(ctx context.Context, stockID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *JDStockService) UpdateStock(ctx context.Context, stockID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *JDStockService) DeleteStock(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+// DouyinAssetService 抖音资产服务
+type DouyinAssetService struct {
+	*BasePlatformService
+}
+
+func NewDouyinAssetService(config *entity.ChannelConfig) *DouyinAssetService {
+	return &DouyinAssetService{
+		BasePlatformService: NewBasePlatformService(consts.SyncPlatformDouyin, config),
+	}
+}
+
+func (s *DouyinAssetService) SyncAsset(ctx context.Context, assetID *bson.ObjectID) error {
+	return nil
+}
+
+func (s *DouyinAssetService) GetAsset(ctx context.Context, assetID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *DouyinAssetService) UpdateAsset(ctx context.Context, assetID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *DouyinAssetService) DeleteAsset(ctx context.Context, assetID *bson.ObjectID) error {
+	return nil
+}
+
+// DouyinAssetSkuService 抖音资产SKU服务
+type DouyinAssetSkuService struct {
+	*BasePlatformService
+}
+
+func NewDouyinAssetSkuService(config *entity.ChannelConfig) *DouyinAssetSkuService {
+	return &DouyinAssetSkuService{
+		BasePlatformService: NewBasePlatformService(consts.SyncPlatformDouyin, config),
+	}
+}
+
+func (s *DouyinAssetSkuService) SyncAssetSku(ctx context.Context, assetSkuID *bson.ObjectID) error {
+	return nil
+}
+
+func (s *DouyinAssetSkuService) GetAssetSku(ctx context.Context, assetSkuID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *DouyinAssetSkuService) UpdateAssetSku(ctx context.Context, assetSkuID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *DouyinAssetSkuService) DeleteAssetSku(ctx context.Context, assetSkuID *bson.ObjectID) error {
+	return nil
+}
+
+// DouyinStockService 抖音库存服务
+type DouyinStockService struct {
+	*BasePlatformService
+}
+
+func NewDouyinStockService(config *entity.ChannelConfig) *DouyinStockService {
+	return &DouyinStockService{
+		BasePlatformService: NewBasePlatformService(consts.SyncPlatformDouyin, config),
+	}
+}
+
+func (s *DouyinStockService) SyncStock(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+func (s *DouyinStockService) GetStock(ctx context.Context, stockID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *DouyinStockService) UpdateStock(ctx context.Context, stockID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *DouyinStockService) DeleteStock(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+// 其他平台服务的占位函数声明
+// KuaishouAssetService, KuaishouAssetSkuService, KuaishouStockService
+// XiaohongshuAssetService, XiaohongshuAssetSkuService, XiaohongshuStockService
+// PinduoduoAssetService, PinduoduoAssetSkuService, PinduoduoStockService
+// XianyuAssetService, XianyuAssetSkuService, XianyuStockService
+// BlockchainAssetService, BlockchainAssetSkuService, BlockchainStockService
+// InternalAssetService, InternalAssetSkuService, InternalStockService
+
+// KuaishouAssetService 快手资产服务
+type KuaishouAssetService struct {
+	*BasePlatformService
+}
+
+func NewKuaishouAssetService(config *entity.ChannelConfig) *KuaishouAssetService {
+	return &KuaishouAssetService{
+		BasePlatformService: NewBasePlatformService(consts.SyncPlatformKuaishou, config),
+	}
+}
+
+func (s *KuaishouAssetService) SyncAsset(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+func (s *KuaishouAssetService) GetAsset(ctx context.Context, stockID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *KuaishouAssetService) UpdateAsset(ctx context.Context, stockID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *KuaishouAssetService) DeleteAsset(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+// KuaishouAssetSkuService 快手资产SKU服务
+type KuaishouAssetSkuService struct {
+	*BasePlatformService
+}
+
+func NewKuaishouAssetSkuService(config *entity.ChannelConfig) *KuaishouAssetSkuService {
+	return &KuaishouAssetSkuService{
+		BasePlatformService: NewBasePlatformService(consts.SyncPlatformKuaishou, config),
+	}
+}
+
+func (s *KuaishouAssetSkuService) SyncAssetSku(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+func (s *KuaishouAssetSkuService) GetAssetSku(ctx context.Context, stockID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *KuaishouAssetSkuService) UpdateAssetSku(ctx context.Context, stockID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *KuaishouAssetSkuService) DeleteAssetSku(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+// KuaishouStockService 快手库存服务
+type KuaishouStockService struct {
+	*BasePlatformService
+}
+
+func NewKuaishouStockService(config *entity.ChannelConfig) *KuaishouStockService {
+	return &KuaishouStockService{
+		BasePlatformService: NewBasePlatformService(consts.SyncPlatformKuaishou, config),
+	}
+}
+
+func (s *KuaishouStockService) SyncStock(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+func (s *KuaishouStockService) GetStock(ctx context.Context, stockID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *KuaishouStockService) UpdateStock(ctx context.Context, stockID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *KuaishouStockService) DeleteStock(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+// XiaohongshuAssetService 小红书资产服务
+type XiaohongshuAssetService struct {
+	*BasePlatformService
+}
+
+func NewXiaohongshuAssetService(config *entity.ChannelConfig) *XiaohongshuAssetService {
+	return &XiaohongshuAssetService{
+		BasePlatformService: NewBasePlatformService(consts.SyncPlatformXiaohongshu, config),
+	}
+}
+
+func (s *XiaohongshuAssetService) SyncAsset(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+func (s *XiaohongshuAssetService) GetAsset(ctx context.Context, stockID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *XiaohongshuAssetService) UpdateAsset(ctx context.Context, stockID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *XiaohongshuAssetService) DeleteAsset(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+// XiaohongshuAssetSkuService 小红书资产SKU服务
+type XiaohongshuAssetSkuService struct {
+	*BasePlatformService
+}
+
+func NewXiaohongshuAssetSkuService(config *entity.ChannelConfig) *XiaohongshuAssetSkuService {
+	return &XiaohongshuAssetSkuService{
+		BasePlatformService: NewBasePlatformService(consts.SyncPlatformXiaohongshu, config),
+	}
+}
+
+func (s *XiaohongshuAssetSkuService) SyncAssetSku(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+func (s *XiaohongshuAssetSkuService) GetAssetSku(ctx context.Context, stockID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *XiaohongshuAssetSkuService) UpdateAssetSku(ctx context.Context, stockID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *XiaohongshuAssetSkuService) DeleteAssetSku(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+// XiaohongshuStockService 小红书库存服务
+type XiaohongshuStockService struct {
+	*BasePlatformService
+}
+
+func NewXiaohongshuStockService(config *entity.ChannelConfig) *XiaohongshuStockService {
+	return &XiaohongshuStockService{
+		BasePlatformService: NewBasePlatformService(consts.SyncPlatformXiaohongshu, config),
+	}
+}
+
+func (s *XiaohongshuStockService) SyncStock(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+func (s *XiaohongshuStockService) GetStock(ctx context.Context, stockID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *XiaohongshuStockService) UpdateStock(ctx context.Context, stockID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *XiaohongshuStockService) DeleteStock(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+// PinduoduoAssetService 拼多多资产服务
+type PinduoduoAssetService struct {
+	*BasePlatformService
+}
+
+func NewPinduoduoAssetService(config *entity.ChannelConfig) *PinduoduoAssetService {
+	return &PinduoduoAssetService{
+		BasePlatformService: NewBasePlatformService(consts.SyncPlatformPinduoduo, config),
+	}
+}
+
+func (s *PinduoduoAssetService) SyncAsset(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+func (s *PinduoduoAssetService) GetAsset(ctx context.Context, stockID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *PinduoduoAssetService) UpdateAsset(ctx context.Context, stockID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *PinduoduoAssetService) DeleteAsset(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+// PinduoduoAssetSkuService 拼多多资产SKU服务
+type PinduoduoAssetSkuService struct {
+	*BasePlatformService
+}
+
+func NewPinduoduoAssetSkuService(config *entity.ChannelConfig) *PinduoduoAssetSkuService {
+	return &PinduoduoAssetSkuService{
+		BasePlatformService: NewBasePlatformService(consts.SyncPlatformPinduoduo, config),
+	}
+}
+
+func (s *PinduoduoAssetSkuService) SyncAssetSku(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+func (s *PinduoduoAssetSkuService) GetAssetSku(ctx context.Context, stockID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *PinduoduoAssetSkuService) UpdateAssetSku(ctx context.Context, stockID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *PinduoduoAssetSkuService) DeleteAssetSku(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+// PinduoduoStockService 拼多多库存服务
+type PinduoduoStockService struct {
+	*BasePlatformService
+}
+
+func NewPinduoduoStockService(config *entity.ChannelConfig) *PinduoduoStockService {
+	return &PinduoduoStockService{
+		BasePlatformService: NewBasePlatformService(consts.SyncPlatformPinduoduo, config),
+	}
+}
+
+func (s *PinduoduoStockService) SyncStock(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+func (s *PinduoduoStockService) GetStock(ctx context.Context, stockID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *PinduoduoStockService) UpdateStock(ctx context.Context, stockID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *PinduoduoStockService) DeleteStock(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+// XianyuAssetService 闲鱼资产服务
+type XianyuAssetService struct {
+	*BasePlatformService
+}
+
+func NewXianyuAssetService(config *entity.ChannelConfig) *XianyuAssetService {
+	return &XianyuAssetService{
+		BasePlatformService: NewBasePlatformService(consts.SyncPlatformXianyu, config),
+	}
+}
+
+func (s *XianyuAssetService) SyncAsset(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+func (s *XianyuAssetService) GetAsset(ctx context.Context, stockID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *XianyuAssetService) UpdateAsset(ctx context.Context, stockID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *XianyuAssetService) DeleteAsset(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+// XianyuAssetSkuService 闲鱼资产SKU服务
+type XianyuAssetSkuService struct {
+	*BasePlatformService
+}
+
+func NewXianyuAssetSkuService(config *entity.ChannelConfig) *XianyuAssetSkuService {
+	return &XianyuAssetSkuService{
+		BasePlatformService: NewBasePlatformService(consts.SyncPlatformXianyu, config),
+	}
+}
+
+func (s *XianyuAssetSkuService) SyncAssetSku(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+func (s *XianyuAssetSkuService) GetAssetSku(ctx context.Context, stockID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *XianyuAssetSkuService) UpdateAssetSku(ctx context.Context, stockID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *XianyuAssetSkuService) DeleteAssetSku(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+// XianyuStockService 闲鱼库存服务
+type XianyuStockService struct {
+	*BasePlatformService
+}
+
+func NewXianyuStockService(config *entity.ChannelConfig) *XianyuStockService {
+	return &XianyuStockService{
+		BasePlatformService: NewBasePlatformService(consts.SyncPlatformXianyu, config),
+	}
+}
+
+func (s *XianyuStockService) SyncStock(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+func (s *XianyuStockService) GetStock(ctx context.Context, stockID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *XianyuStockService) UpdateStock(ctx context.Context, stockID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *XianyuStockService) DeleteStock(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+// BlockchainAssetService 区块链资产服务
+type BlockchainAssetService struct {
+	*BasePlatformService
+}
+
+func NewBlockchainAssetService(config *entity.ChannelConfig) *BlockchainAssetService {
+	return &BlockchainAssetService{
+		BasePlatformService: NewBasePlatformService(consts.SyncPlatformBlockchain, config),
+	}
+}
+
+func (s *BlockchainAssetService) SyncAsset(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+func (s *BlockchainAssetService) GetAsset(ctx context.Context, stockID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *BlockchainAssetService) UpdateAsset(ctx context.Context, stockID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *BlockchainAssetService) DeleteAsset(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+// BlockchainAssetSkuService 区块链资产SKU服务
+type BlockchainAssetSkuService struct {
+	*BasePlatformService
+}
+
+func NewBlockchainAssetSkuService(config *entity.ChannelConfig) *BlockchainAssetSkuService {
+	return &BlockchainAssetSkuService{
+		BasePlatformService: NewBasePlatformService(consts.SyncPlatformBlockchain, config),
+	}
+}
+
+func (s *BlockchainAssetSkuService) SyncAssetSku(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+func (s *BlockchainAssetSkuService) GetAssetSku(ctx context.Context, stockID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *BlockchainAssetSkuService) UpdateAssetSku(ctx context.Context, stockID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *BlockchainAssetSkuService) DeleteAssetSku(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+// BlockchainStockService 区块链库存服务
+type BlockchainStockService struct {
+	*BasePlatformService
+}
+
+func NewBlockchainStockService(config *entity.ChannelConfig) *BlockchainStockService {
+	return &BlockchainStockService{
+		BasePlatformService: NewBasePlatformService(consts.SyncPlatformBlockchain, config),
+	}
+}
+
+func (s *BlockchainStockService) SyncStock(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+func (s *BlockchainStockService) GetStock(ctx context.Context, stockID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *BlockchainStockService) UpdateStock(ctx context.Context, stockID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *BlockchainStockService) DeleteStock(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+// InternalAssetService 内部资产服务（使用 assets-sync 中的完整实现）
+type InternalAssetService struct {
+	*BasePlatformService
+}
+
+func NewInternalAssetService(config *entity.ChannelConfig) *InternalAssetService {
+	return &InternalAssetService{
+		BasePlatformService: NewBasePlatformService(consts.SyncPlatformInternal, config),
+	}
+}
+
+func (s *InternalAssetService) SyncAsset(ctx context.Context, stockID *bson.ObjectID) error {
+	// TODO: 实现内部资产同步逻辑
+	return nil
+}
+
+func (s *InternalAssetService) GetAsset(ctx context.Context, stockID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *InternalAssetService) UpdateAsset(ctx context.Context, stockID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *InternalAssetService) DeleteAsset(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+// InternalAssetSkuService 内部资产SKU服务
+type InternalAssetSkuService struct {
+	*BasePlatformService
+}
+
+func NewInternalAssetSkuService(config *entity.ChannelConfig) *InternalAssetSkuService {
+	return &InternalAssetSkuService{
+		BasePlatformService: NewBasePlatformService(consts.SyncPlatformInternal, config),
+	}
+}
+
+func (s *InternalAssetSkuService) SyncAssetSku(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+func (s *InternalAssetSkuService) GetAssetSku(ctx context.Context, stockID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *InternalAssetSkuService) UpdateAssetSku(ctx context.Context, stockID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *InternalAssetSkuService) DeleteAssetSku(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+// InternalStockService 内部库存服务
+type InternalStockService struct {
+	*BasePlatformService
+}
+
+func NewInternalStockService(config *entity.ChannelConfig) *InternalStockService {
+	return &InternalStockService{
+		BasePlatformService: NewBasePlatformService(consts.SyncPlatformInternal, config),
+	}
+}
+
+func (s *InternalStockService) SyncStock(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}
+
+func (s *InternalStockService) GetStock(ctx context.Context, stockID *bson.ObjectID) (interface{}, error) {
+	return nil, nil
+}
+
+func (s *InternalStockService) UpdateStock(ctx context.Context, stockID *bson.ObjectID, data interface{}) error {
+	return nil
+}
+
+func (s *InternalStockService) DeleteStock(ctx context.Context, stockID *bson.ObjectID) error {
+	return nil
+}

service/sync/sync_service.go

@@ -0,0 +1,292 @@
+package service
+
+import (
+	consts "assets/consts/public"
+	dao "assets/dao/sync"
+	dto "assets/model/dto/sync"
+	entity "assets/model/entity/sync"
+	"context"
+
+	"gitea.com/red-future/common/utils"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/grpool"
+	"go.mongodb.org/mongo-driver/v2/bson"
+)
+
+type syncService struct{}
+
+// Sync 同步服务
+var Sync = new(syncService)
+
+// PlatformFactory 平台服务工厂实例
+var platformFactory = NewPlatformServiceFactory()
+
+// SyncPool 同步任务协程池，限制并发数避免goroutine爆炸
+var SyncPool = grpool.New(20)
+
+// CreateSyncTask 创建同步任务
+func (s *syncService) CreateSyncTask(ctx context.Context, req *dto.CreateSyncTaskReq) (*bson.ObjectID, error) {
+	task := &entity.SyncTask{
+		Platform:     req.Platform,
+		SyncType:     req.SyncType,
+		Status:       consts.SyncStatusPending,
+		AssetID:      req.AssetID,
+		AssetSKUID:   req.AssetSKUID,
+		StockID:      req.StockID,
+		ErrorMessage: "",
+		ErrorCount:   0,
+	}
+
+	err := dao.SyncTask.Insert(ctx, task)
+	if err != nil {
+		return nil, err
+	}
+
+	return task.Id, nil
+}
+
+// GetSyncTask 获取同步任务详情
+func (s *syncService) GetSyncTask(ctx context.Context, id *bson.ObjectID) (res *dto.GetSyncTaskRes, err error) {
+	task, err := dao.SyncTask.GetOne(ctx, id)
+	if err != nil {
+		return
+	}
+	res = &dto.GetSyncTaskRes{}
+	err = utils.Struct(task, &res.SyncTaskItem)
+	return
+}
+
+// ListSyncTasks 获取同步任务列表
+func (s *syncService) ListSyncTasks(ctx context.Context, req *dto.ListSyncTaskReq) (list []*dto.SyncTaskItem, total int64, err error) {
+	tasks, total, err := dao.SyncTask.List(ctx, req)
+	if err != nil {
+		return
+	}
+	err = utils.Struct(tasks, &list)
+	return
+}
+
+// UpdateSyncTaskStatus 更新同步任务状态
+func (s *syncService) UpdateSyncTaskStatus(ctx context.Context, req *dto.UpdateSyncTaskStatusReq) error {
+	return dao.SyncTask.UpdateStatus(ctx, req.ID, req.Status, req.ErrorMessage)
+}
+
+// SyncAsset 同步资产
+func (s *syncService) SyncAsset(ctx context.Context, req *dto.SyncAssetReq) (*bson.ObjectID, error) {
+	// 创建同步任务
+	taskReq := &dto.CreateSyncTaskReq{
+		Platform: req.Platform,
+		SyncType: consts.SyncTypeIncremental,
+		AssetID:  req.AssetID,
+	}
+
+	taskID, err := s.CreateSyncTask(ctx, taskReq)
+	if err != nil {
+		return nil, err
+	}
+
+	// 异步执行同步任务（使用协程池限制并发）
+	asyncCtx := context.WithoutCancel(ctx)
+	SyncPool.Add(asyncCtx, func(ctx context.Context) {
+		s.executeAssetSync(ctx, taskID, req.AssetID, req.Platform)
+	})
+
+	return taskID, nil
+}
+
+// SyncAssetSku 同步资产SKU
+func (s *syncService) SyncAssetSku(ctx context.Context, req *dto.SyncAssetSkuReq) (*bson.ObjectID, error) {
+	taskReq := &dto.CreateSyncTaskReq{
+		Platform:   req.Platform,
+		SyncType:   consts.SyncTypeIncremental,
+		AssetSKUID: req.AssetSKUID,
+	}
+
+	taskID, err := s.CreateSyncTask(ctx, taskReq)
+	if err != nil {
+		return nil, err
+	}
+
+	// 异步执行同步任务（使用协程池限制并发）
+	asyncCtx := context.WithoutCancel(ctx)
+	SyncPool.Add(asyncCtx, func(ctx context.Context) {
+		s.executeAssetSkuSync(ctx, taskID, req.AssetSKUID, req.Platform)
+	})
+
+	return taskID, nil
+}
+
+// SyncStock 同步库存
+func (s *syncService) SyncStock(ctx context.Context, req *dto.SyncStockReq) (*bson.ObjectID, error) {
+	taskReq := &dto.CreateSyncTaskReq{
+		Platform: req.Platform,
+		SyncType: consts.SyncTypeIncremental,
+		StockID:  req.StockID,
+	}
+
+	taskID, err := s.CreateSyncTask(ctx, taskReq)
+	if err != nil {
+		return nil, err
+	}
+
+	// 异步执行同步任务（使用协程池限制并发）
+	asyncCtx := context.WithoutCancel(ctx)
+	SyncPool.Add(asyncCtx, func(ctx context.Context) {
+		s.executeStockSync(ctx, taskID, req.StockID, req.Platform)
+	})
+
+	return taskID, nil
+}
+
+// BatchSyncAssets 批量同步资产
+func (s *syncService) BatchSyncAssets(ctx context.Context, req *dto.BatchSyncAssetsReq) ([]*bson.ObjectID, error) {
+	var taskIDs []*bson.ObjectID
+	for _, assetID := range req.AssetIDs {
+		taskReq := &dto.CreateSyncTaskReq{
+			Platform: req.Platform,
+			SyncType: consts.SyncTypeIncremental,
+			AssetID:  assetID,
+		}
+
+		taskID, err := s.CreateSyncTask(ctx, taskReq)
+		if err != nil {
+			return taskIDs, err
+		}
+		taskIDs = append(taskIDs, taskID)
+
+		// 异步执行同步任务（使用协程池限制并发）
+		asyncCtx := context.WithoutCancel(ctx)
+		currentAssetID := assetID
+		SyncPool.Add(asyncCtx, func(ctx context.Context) {
+			s.executeAssetSync(ctx, taskID, currentAssetID, req.Platform)
+		})
+	}
+
+	return taskIDs, nil
+}
+
+// GetPlatformSyncStatus 获取平台同步状态
+func (s *syncService) GetPlatformSyncStatus(ctx context.Context, req *dto.GetPlatformSyncStatusReq) (*dto.GetPlatformSyncStatusRes, error) {
+	// 统计各状态任务数量
+	totalReq := &dto.ListSyncTaskReq{Platform: req.Platform}
+	totalReq.PageNum = 1
+	totalReq.PageSize = 1
+	_, total, err := dao.SyncTask.List(ctx, totalReq)
+	if err != nil {
+		return nil, err
+	}
+
+	successReq := &dto.ListSyncTaskReq{Platform: req.Platform, Status: consts.SyncStatusSuccess}
+	successReq.PageNum = 1
+	successReq.PageSize = 1
+	_, successCount, err := dao.SyncTask.List(ctx, successReq)
+	if err != nil {
+		return nil, err
+	}
+
+	failedReq := &dto.ListSyncTaskReq{Platform: req.Platform, Status: consts.SyncStatusFailed}
+	failedReq.PageNum = 1
+	failedReq.PageSize = 1
+	_, failedCount, err := dao.SyncTask.List(ctx, failedReq)
+	if err != nil {
+		return nil, err
+	}
+
+	return &dto.GetPlatformSyncStatusRes{
+		Platform:     req.Platform,
+		IsEnabled:    true,
+		SyncCount:    total,
+		SuccessCount: successCount,
+		FailedCount:  failedCount,
+	}, nil
+}
+
+// executeAssetSync 执行资产同步
+func (s *syncService) executeAssetSync(ctx context.Context, taskID, assetID *bson.ObjectID, platform consts.SyncPlatform) {
+	// 更新任务状态为同步中
+	dao.SyncTask.UpdateStatus(ctx, taskID, consts.SyncStatusSyncing, "")
+
+	// 获取平台服务
+	assetService := platformFactory.CreateAssetService(platform)
+
+	// 执行同步
+	err := assetService.SyncAsset(ctx, assetID)
+	if err != nil {
+		// 同步失败
+		g.Log().Error(ctx, "资产同步失败", g.Map{
+			"task_id":  taskID,
+			"asset_id": assetID,
+			"platform": string(platform),
+			"error":    err.Error(),
+		})
+		dao.SyncTask.UpdateStatus(ctx, taskID, consts.SyncStatusFailed, err.Error())
+	} else {
+		// 同步成功
+		g.Log().Info(ctx, "资产同步成功", g.Map{
+			"task_id":  taskID,
+			"asset_id": assetID,
+			"platform": string(platform),
+		})
+		dao.SyncTask.UpdateStatus(ctx, taskID, consts.SyncStatusSuccess, "")
+	}
+}
+
+// executeAssetSkuSync 执行资产SKU同步
+func (s *syncService) executeAssetSkuSync(ctx context.Context, taskID, assetSkuID *bson.ObjectID, platform consts.SyncPlatform) {
+	// 更新任务状态为同步中
+	dao.SyncTask.UpdateStatus(ctx, taskID, consts.SyncStatusSyncing, "")
+
+	// 获取平台服务
+	assetSkuService := platformFactory.CreateAssetSkuService(platform)
+
+	// 执行同步
+	err := assetSkuService.SyncAssetSku(ctx, assetSkuID)
+	if err != nil {
+		// 同步失败
+		g.Log().Error(ctx, "资产SKU同步失败", g.Map{
+			"task_id":      taskID,
+			"asset_sku_id": assetSkuID,
+			"platform":     string(platform),
+			"error":        err.Error(),
+		})
+		dao.SyncTask.UpdateStatus(ctx, taskID, consts.SyncStatusFailed, err.Error())
+	} else {
+		// 同步成功
+		g.Log().Info(ctx, "资产SKU同步成功", g.Map{
+			"task_id":      taskID,
+			"asset_sku_id": assetSkuID,
+			"platform":     string(platform),
+		})
+		dao.SyncTask.UpdateStatus(ctx, taskID, consts.SyncStatusSuccess, "")
+	}
+}
+
+// executeStockSync 执行库存同步
+func (s *syncService) executeStockSync(ctx context.Context, taskID, stockID *bson.ObjectID, platform consts.SyncPlatform) {
+	// 更新任务状态为同步中
+	dao.SyncTask.UpdateStatus(ctx, taskID, consts.SyncStatusSyncing, "")
+
+	// 获取平台服务
+	stockService := platformFactory.CreateStockService(platform)
+
+	// 执行同步
+	err := stockService.SyncStock(ctx, stockID)
+	if err != nil {
+		// 同步失败
+		g.Log().Error(ctx, "库存同步失败", g.Map{
+			"task_id":  taskID,
+			"stock_id": stockID,
+			"platform": string(platform),
+			"error":    err.Error(),
+		})
+		dao.SyncTask.UpdateStatus(ctx, taskID, consts.SyncStatusFailed, err.Error())
+	} else {
+		// 同步成功
+		g.Log().Info(ctx, "库存同步成功", g.Map{
+			"task_id":  taskID,
+			"stock_id": stockID,
+			"platform": string(platform),
+		})
+		dao.SyncTask.UpdateStatus(ctx, taskID, consts.SyncStatusSuccess, "")
+	}
+}