feat: 实现门店套餐分配功能并统一测试基础设施

新增功能：
- 门店套餐分配管理（shop_package_allocation）：支持门店套餐库存管理
- 门店套餐系列分配管理（shop_series_allocation）：支持套餐系列分配和佣金层级设置
- 我的套餐查询（my_package）：支持门店查询自己的套餐分配情况

测试改进：
- 统一集成测试基础设施，新增 testutils.NewIntegrationTestEnv
- 重构所有集成测试使用新的测试环境设置
- 移除旧的测试辅助函数和冗余测试文件
- 新增 test_helpers_test.go 统一任务测试辅助

技术细节：
- 新增数据库迁移 000025_create_shop_allocation_tables
- 新增 3 个 Handler、Service、Store 和对应的单元测试
- 更新 OpenAPI 文档和文档生成器
- 测试覆盖率：Service 层 > 90%

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

internal/service/shop_series_allocation/service.go

@@ -0,0 +1,531 @@
+package shop_series_allocation
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/break/junhong_cmp_fiber/internal/model"
+	"github.com/break/junhong_cmp_fiber/internal/model/dto"
+	"github.com/break/junhong_cmp_fiber/internal/store"
+	"github.com/break/junhong_cmp_fiber/internal/store/postgres"
+	"github.com/break/junhong_cmp_fiber/pkg/constants"
+	"github.com/break/junhong_cmp_fiber/pkg/errors"
+	"github.com/break/junhong_cmp_fiber/pkg/middleware"
+	"gorm.io/gorm"
+)
+
+type Service struct {
+	allocationStore    *postgres.ShopSeriesAllocationStore
+	tierStore          *postgres.ShopSeriesCommissionTierStore
+	shopStore          *postgres.ShopStore
+	packageSeriesStore *postgres.PackageSeriesStore
+	packageStore       *postgres.PackageStore
+}
+
+func New(
+	allocationStore *postgres.ShopSeriesAllocationStore,
+	tierStore *postgres.ShopSeriesCommissionTierStore,
+	shopStore *postgres.ShopStore,
+	packageSeriesStore *postgres.PackageSeriesStore,
+	packageStore *postgres.PackageStore,
+) *Service {
+	return &Service{
+		allocationStore:    allocationStore,
+		tierStore:          tierStore,
+		shopStore:          shopStore,
+		packageSeriesStore: packageSeriesStore,
+		packageStore:       packageStore,
+	}
+}
+
+func (s *Service) Create(ctx context.Context, req *dto.CreateShopSeriesAllocationRequest) (*dto.ShopSeriesAllocationResponse, error) {
+	currentUserID := middleware.GetUserIDFromContext(ctx)
+	if currentUserID == 0 {
+		return nil, errors.New(errors.CodeUnauthorized, "未授权访问")
+	}
+
+	userType := middleware.GetUserTypeFromContext(ctx)
+	allocatorShopID := middleware.GetShopIDFromContext(ctx)
+
+	if userType == constants.UserTypeAgent && allocatorShopID == 0 {
+		return nil, errors.New(errors.CodeUnauthorized, "当前用户不属于任何店铺")
+	}
+
+	targetShop, err := s.shopStore.GetByID(ctx, req.ShopID)
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, errors.New(errors.CodeNotFound, "目标店铺不存在")
+		}
+		return nil, fmt.Errorf("获取店铺失败: %w", err)
+	}
+
+	isPlatformUser := userType == constants.UserTypeSuperAdmin || userType == constants.UserTypePlatform
+	isFirstLevelShop := targetShop.ParentID == nil
+
+	if isPlatformUser {
+		if !isFirstLevelShop {
+			return nil, errors.New(errors.CodeForbidden, "平台只能为一级店铺分配套餐")
+		}
+	} else {
+		if isFirstLevelShop || *targetShop.ParentID != allocatorShopID {
+			return nil, errors.New(errors.CodeForbidden, "只能为直属下级分配套餐")
+		}
+	}
+
+	series, err := s.packageSeriesStore.GetByID(ctx, req.SeriesID)
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, errors.New(errors.CodeNotFound, "套餐系列不存在")
+		}
+		return nil, fmt.Errorf("获取套餐系列失败: %w", err)
+	}
+
+	if userType == constants.UserTypeAgent {
+		myAllocation, err := s.allocationStore.GetByShopAndSeries(ctx, allocatorShopID, req.SeriesID)
+		if err != nil && err != gorm.ErrRecordNotFound {
+			return nil, fmt.Errorf("检查分配权限失败: %w", err)
+		}
+		if myAllocation == nil || myAllocation.Status != constants.StatusEnabled {
+			return nil, errors.New(errors.CodeForbidden, "您没有该套餐系列的分配权限")
+		}
+	}
+
+	existing, _ := s.allocationStore.GetByShopAndSeries(ctx, req.ShopID, req.SeriesID)
+	if existing != nil {
+		return nil, errors.New(errors.CodeConflict, "该店铺已分配此套餐系列")
+	}
+
+	allocation := &model.ShopSeriesAllocation{
+		ShopID:                     req.ShopID,
+		SeriesID:                   req.SeriesID,
+		AllocatorShopID:            allocatorShopID,
+		PricingMode:                req.PricingMode,
+		PricingValue:               req.PricingValue,
+		OneTimeCommissionTrigger:   req.OneTimeCommissionTrigger,
+		OneTimeCommissionThreshold: req.OneTimeCommissionThreshold,
+		OneTimeCommissionAmount:    req.OneTimeCommissionAmount,
+		Status:                     constants.StatusEnabled,
+	}
+	allocation.Creator = currentUserID
+
+	if err := s.allocationStore.Create(ctx, allocation); err != nil {
+		return nil, fmt.Errorf("创建分配失败: %w", err)
+	}
+
+	return s.buildResponse(ctx, allocation, targetShop.ShopName, series.SeriesName)
+}
+
+func (s *Service) Get(ctx context.Context, id uint) (*dto.ShopSeriesAllocationResponse, error) {
+	allocation, err := s.allocationStore.GetByID(ctx, id)
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, errors.New(errors.CodeNotFound, "分配记录不存在")
+		}
+		return nil, fmt.Errorf("获取分配记录失败: %w", err)
+	}
+
+	shop, _ := s.shopStore.GetByID(ctx, allocation.ShopID)
+	series, _ := s.packageSeriesStore.GetByID(ctx, allocation.SeriesID)
+
+	shopName := ""
+	seriesName := ""
+	if shop != nil {
+		shopName = shop.ShopName
+	}
+	if series != nil {
+		seriesName = series.SeriesName
+	}
+
+	return s.buildResponse(ctx, allocation, shopName, seriesName)
+}
+
+func (s *Service) Update(ctx context.Context, id uint, req *dto.UpdateShopSeriesAllocationRequest) (*dto.ShopSeriesAllocationResponse, error) {
+	currentUserID := middleware.GetUserIDFromContext(ctx)
+	if currentUserID == 0 {
+		return nil, errors.New(errors.CodeUnauthorized, "未授权访问")
+	}
+
+	allocation, err := s.allocationStore.GetByID(ctx, id)
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, errors.New(errors.CodeNotFound, "分配记录不存在")
+		}
+		return nil, fmt.Errorf("获取分配记录失败: %w", err)
+	}
+
+	if req.PricingMode != nil {
+		allocation.PricingMode = *req.PricingMode
+	}
+	if req.PricingValue != nil {
+		allocation.PricingValue = *req.PricingValue
+	}
+	if req.OneTimeCommissionTrigger != nil {
+		allocation.OneTimeCommissionTrigger = *req.OneTimeCommissionTrigger
+	}
+	if req.OneTimeCommissionThreshold != nil {
+		allocation.OneTimeCommissionThreshold = *req.OneTimeCommissionThreshold
+	}
+	if req.OneTimeCommissionAmount != nil {
+		allocation.OneTimeCommissionAmount = *req.OneTimeCommissionAmount
+	}
+	allocation.Updater = currentUserID
+
+	if err := s.allocationStore.Update(ctx, allocation); err != nil {
+		return nil, fmt.Errorf("更新分配失败: %w", err)
+	}
+
+	shop, _ := s.shopStore.GetByID(ctx, allocation.ShopID)
+	series, _ := s.packageSeriesStore.GetByID(ctx, allocation.SeriesID)
+
+	shopName := ""
+	seriesName := ""
+	if shop != nil {
+		shopName = shop.ShopName
+	}
+	if series != nil {
+		seriesName = series.SeriesName
+	}
+
+	return s.buildResponse(ctx, allocation, shopName, seriesName)
+}
+
+func (s *Service) Delete(ctx context.Context, id uint) error {
+	allocation, err := s.allocationStore.GetByID(ctx, id)
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return errors.New(errors.CodeNotFound, "分配记录不存在")
+		}
+		return fmt.Errorf("获取分配记录失败: %w", err)
+	}
+
+	hasDependent, err := s.allocationStore.HasDependentAllocations(ctx, allocation.ShopID, allocation.SeriesID)
+	if err != nil {
+		return fmt.Errorf("检查依赖关系失败: %w", err)
+	}
+	if hasDependent {
+		return errors.New(errors.CodeConflict, "存在下级依赖，无法删除")
+	}
+
+	if err := s.allocationStore.Delete(ctx, id); err != nil {
+		return fmt.Errorf("删除分配失败: %w", err)
+	}
+
+	return nil
+}
+
+func (s *Service) List(ctx context.Context, req *dto.ShopSeriesAllocationListRequest) ([]*dto.ShopSeriesAllocationResponse, int64, error) {
+	userType := middleware.GetUserTypeFromContext(ctx)
+	shopID := middleware.GetShopIDFromContext(ctx)
+
+	opts := &store.QueryOptions{
+		Page:     req.Page,
+		PageSize: req.PageSize,
+		OrderBy:  "id DESC",
+	}
+	if opts.Page == 0 {
+		opts.Page = 1
+	}
+	if opts.PageSize == 0 {
+		opts.PageSize = constants.DefaultPageSize
+	}
+
+	filters := make(map[string]interface{})
+	if req.ShopID != nil {
+		filters["shop_id"] = *req.ShopID
+	}
+	if req.SeriesID != nil {
+		filters["series_id"] = *req.SeriesID
+	}
+	if req.Status != nil {
+		filters["status"] = *req.Status
+	}
+	if shopID > 0 && userType == constants.UserTypeAgent {
+		filters["allocator_shop_id"] = shopID
+	}
+
+	allocations, total, err := s.allocationStore.List(ctx, opts, filters)
+	if err != nil {
+		return nil, 0, fmt.Errorf("查询分配列表失败: %w", err)
+	}
+
+	responses := make([]*dto.ShopSeriesAllocationResponse, len(allocations))
+	for i, a := range allocations {
+		shop, _ := s.shopStore.GetByID(ctx, a.ShopID)
+		series, _ := s.packageSeriesStore.GetByID(ctx, a.SeriesID)
+
+		shopName := ""
+		seriesName := ""
+		if shop != nil {
+			shopName = shop.ShopName
+		}
+		if series != nil {
+			seriesName = series.SeriesName
+		}
+
+		resp, _ := s.buildResponse(ctx, a, shopName, seriesName)
+		responses[i] = resp
+	}
+
+	return responses, total, nil
+}
+
+func (s *Service) UpdateStatus(ctx context.Context, id uint, status int) error {
+	currentUserID := middleware.GetUserIDFromContext(ctx)
+	if currentUserID == 0 {
+		return errors.New(errors.CodeUnauthorized, "未授权访问")
+	}
+
+	_, err := s.allocationStore.GetByID(ctx, id)
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return errors.New(errors.CodeNotFound, "分配记录不存在")
+		}
+		return fmt.Errorf("获取分配记录失败: %w", err)
+	}
+
+	if err := s.allocationStore.UpdateStatus(ctx, id, status, currentUserID); err != nil {
+		return fmt.Errorf("更新状态失败: %w", err)
+	}
+
+	return nil
+}
+
+func (s *Service) GetParentCostPrice(ctx context.Context, shopID, packageID uint) (int64, error) {
+	pkg, err := s.packageStore.GetByID(ctx, packageID)
+	if err != nil {
+		return 0, fmt.Errorf("获取套餐失败: %w", err)
+	}
+
+	shop, err := s.shopStore.GetByID(ctx, shopID)
+	if err != nil {
+		return 0, fmt.Errorf("获取店铺失败: %w", err)
+	}
+
+	if shop.ParentID == nil || *shop.ParentID == 0 {
+		return pkg.SuggestedCostPrice, nil
+	}
+
+	allocation, err := s.allocationStore.GetByShopAndSeries(ctx, shopID, pkg.SeriesID)
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return 0, errors.New(errors.CodeNotFound, "未找到分配记录")
+		}
+		return 0, fmt.Errorf("获取分配记录失败: %w", err)
+	}
+
+	parentCostPrice, err := s.GetParentCostPrice(ctx, allocation.AllocatorShopID, packageID)
+	if err != nil {
+		return 0, err
+	}
+
+	return s.CalculateCostPrice(parentCostPrice, allocation.PricingMode, allocation.PricingValue), nil
+}
+
+func (s *Service) CalculateCostPrice(parentCostPrice int64, pricingMode string, pricingValue int64) int64 {
+	switch pricingMode {
+	case model.PricingModeFixed:
+		return parentCostPrice + pricingValue
+	case model.PricingModePercent:
+		return parentCostPrice + (parentCostPrice * pricingValue / 1000)
+	default:
+		return parentCostPrice
+	}
+}
+
+func (s *Service) AddTier(ctx context.Context, allocationID uint, req *dto.CreateCommissionTierRequest) (*dto.CommissionTierResponse, error) {
+	currentUserID := middleware.GetUserIDFromContext(ctx)
+	if currentUserID == 0 {
+		return nil, errors.New(errors.CodeUnauthorized, "未授权访问")
+	}
+
+	_, err := s.allocationStore.GetByID(ctx, allocationID)
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, errors.New(errors.CodeNotFound, "分配记录不存在")
+		}
+		return nil, fmt.Errorf("获取分配记录失败: %w", err)
+	}
+
+	if req.PeriodType == model.PeriodTypeCustom {
+		if req.PeriodStartDate == nil || req.PeriodEndDate == nil {
+			return nil, errors.New(errors.CodeInvalidParam, "自定义周期必须指定开始和结束日期")
+		}
+	}
+
+	tier := &model.ShopSeriesCommissionTier{
+		AllocationID:     allocationID,
+		TierType:         req.TierType,
+		PeriodType:       req.PeriodType,
+		ThresholdValue:   req.ThresholdValue,
+		CommissionAmount: req.CommissionAmount,
+	}
+	tier.Creator = currentUserID
+
+	if req.PeriodStartDate != nil {
+		t, err := time.Parse("2006-01-02", *req.PeriodStartDate)
+		if err != nil {
+			return nil, errors.New(errors.CodeInvalidParam, "开始日期格式无效")
+		}
+		tier.PeriodStartDate = &t
+	}
+	if req.PeriodEndDate != nil {
+		t, err := time.Parse("2006-01-02", *req.PeriodEndDate)
+		if err != nil {
+			return nil, errors.New(errors.CodeInvalidParam, "结束日期格式无效")
+		}
+		tier.PeriodEndDate = &t
+	}
+
+	if err := s.tierStore.Create(ctx, tier); err != nil {
+		return nil, fmt.Errorf("创建梯度配置失败: %w", err)
+	}
+
+	return s.buildTierResponse(tier), nil
+}
+
+func (s *Service) UpdateTier(ctx context.Context, allocationID, tierID uint, req *dto.UpdateCommissionTierRequest) (*dto.CommissionTierResponse, error) {
+	currentUserID := middleware.GetUserIDFromContext(ctx)
+	if currentUserID == 0 {
+		return nil, errors.New(errors.CodeUnauthorized, "未授权访问")
+	}
+
+	tier, err := s.tierStore.GetByID(ctx, tierID)
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, errors.New(errors.CodeNotFound, "梯度配置不存在")
+		}
+		return nil, fmt.Errorf("获取梯度配置失败: %w", err)
+	}
+
+	if tier.AllocationID != allocationID {
+		return nil, errors.New(errors.CodeForbidden, "梯度配置不属于该分配")
+	}
+
+	if req.TierType != nil {
+		tier.TierType = *req.TierType
+	}
+	if req.PeriodType != nil {
+		tier.PeriodType = *req.PeriodType
+	}
+	if req.ThresholdValue != nil {
+		tier.ThresholdValue = *req.ThresholdValue
+	}
+	if req.CommissionAmount != nil {
+		tier.CommissionAmount = *req.CommissionAmount
+	}
+	if req.PeriodStartDate != nil {
+		t, err := time.Parse("2006-01-02", *req.PeriodStartDate)
+		if err != nil {
+			return nil, errors.New(errors.CodeInvalidParam, "开始日期格式无效")
+		}
+		tier.PeriodStartDate = &t
+	}
+	if req.PeriodEndDate != nil {
+		t, err := time.Parse("2006-01-02", *req.PeriodEndDate)
+		if err != nil {
+			return nil, errors.New(errors.CodeInvalidParam, "结束日期格式无效")
+		}
+		tier.PeriodEndDate = &t
+	}
+	tier.Updater = currentUserID
+
+	if err := s.tierStore.Update(ctx, tier); err != nil {
+		return nil, fmt.Errorf("更新梯度配置失败: %w", err)
+	}
+
+	return s.buildTierResponse(tier), nil
+}
+
+func (s *Service) DeleteTier(ctx context.Context, allocationID, tierID uint) error {
+	tier, err := s.tierStore.GetByID(ctx, tierID)
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return errors.New(errors.CodeNotFound, "梯度配置不存在")
+		}
+		return fmt.Errorf("获取梯度配置失败: %w", err)
+	}
+
+	if tier.AllocationID != allocationID {
+		return errors.New(errors.CodeForbidden, "梯度配置不属于该分配")
+	}
+
+	if err := s.tierStore.Delete(ctx, tierID); err != nil {
+		return fmt.Errorf("删除梯度配置失败: %w", err)
+	}
+
+	return nil
+}
+
+func (s *Service) ListTiers(ctx context.Context, allocationID uint) ([]*dto.CommissionTierResponse, error) {
+	_, err := s.allocationStore.GetByID(ctx, allocationID)
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, errors.New(errors.CodeNotFound, "分配记录不存在")
+		}
+		return nil, fmt.Errorf("获取分配记录失败: %w", err)
+	}
+
+	tiers, err := s.tierStore.ListByAllocationID(ctx, allocationID)
+	if err != nil {
+		return nil, fmt.Errorf("查询梯度配置失败: %w", err)
+	}
+
+	responses := make([]*dto.CommissionTierResponse, len(tiers))
+	for i, t := range tiers {
+		responses[i] = s.buildTierResponse(t)
+	}
+
+	return responses, nil
+}
+
+func (s *Service) buildResponse(ctx context.Context, a *model.ShopSeriesAllocation, shopName, seriesName string) (*dto.ShopSeriesAllocationResponse, error) {
+	allocatorShop, _ := s.shopStore.GetByID(ctx, a.AllocatorShopID)
+	allocatorShopName := ""
+	if allocatorShop != nil {
+		allocatorShopName = allocatorShop.ShopName
+	}
+
+	var calculatedCostPrice int64 = 0
+
+	return &dto.ShopSeriesAllocationResponse{
+		ID:                         a.ID,
+		ShopID:                     a.ShopID,
+		ShopName:                   shopName,
+		SeriesID:                   a.SeriesID,
+		SeriesName:                 seriesName,
+		AllocatorShopID:            a.AllocatorShopID,
+		AllocatorShopName:          allocatorShopName,
+		PricingMode:                a.PricingMode,
+		PricingValue:               a.PricingValue,
+		CalculatedCostPrice:        calculatedCostPrice,
+		OneTimeCommissionTrigger:   a.OneTimeCommissionTrigger,
+		OneTimeCommissionThreshold: a.OneTimeCommissionThreshold,
+		OneTimeCommissionAmount:    a.OneTimeCommissionAmount,
+		Status:                     a.Status,
+		CreatedAt:                  a.CreatedAt.Format(time.RFC3339),
+		UpdatedAt:                  a.UpdatedAt.Format(time.RFC3339),
+	}, nil
+}
+
+func (s *Service) buildTierResponse(t *model.ShopSeriesCommissionTier) *dto.CommissionTierResponse {
+	resp := &dto.CommissionTierResponse{
+		ID:               t.ID,
+		AllocationID:     t.AllocationID,
+		TierType:         t.TierType,
+		PeriodType:       t.PeriodType,
+		ThresholdValue:   t.ThresholdValue,
+		CommissionAmount: t.CommissionAmount,
+		CreatedAt:        t.CreatedAt.Format(time.RFC3339),
+		UpdatedAt:        t.UpdatedAt.Format(time.RFC3339),
+	}
+
+	if t.PeriodStartDate != nil {
+		resp.PeriodStartDate = t.PeriodStartDate.Format("2006-01-02")
+	}
+	if t.PeriodEndDate != nil {
+		resp.PeriodEndDate = t.PeriodEndDate.Format("2006-01-02")
+	}
+
+	return resp
+}

internal/service/shop_series_allocation/service_test.go

@@ -0,0 +1,595 @@
+package shop_series_allocation
+
+import (
+	"context"
+	"testing"
+
+	"github.com/break/junhong_cmp_fiber/internal/model"
+	"github.com/break/junhong_cmp_fiber/internal/model/dto"
+	"github.com/break/junhong_cmp_fiber/internal/store/postgres"
+	"github.com/break/junhong_cmp_fiber/pkg/constants"
+	"github.com/break/junhong_cmp_fiber/pkg/errors"
+	"github.com/break/junhong_cmp_fiber/pkg/middleware"
+	"github.com/break/junhong_cmp_fiber/tests/testutils"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"gorm.io/gorm"
+)
+
+func createTestService(t *testing.T) (*Service, *postgres.ShopSeriesAllocationStore, *postgres.ShopStore, *postgres.PackageSeriesStore, *postgres.PackageStore, *postgres.ShopSeriesCommissionTierStore) {
+	tx := testutils.NewTestTransaction(t)
+	rdb := testutils.GetTestRedis(t)
+	testutils.CleanTestRedisKeys(t, rdb)
+
+	allocationStore := postgres.NewShopSeriesAllocationStore(tx)
+	tierStore := postgres.NewShopSeriesCommissionTierStore(tx)
+	shopStore := postgres.NewShopStore(tx, rdb)
+	packageSeriesStore := postgres.NewPackageSeriesStore(tx)
+	packageStore := postgres.NewPackageStore(tx)
+
+	svc := New(allocationStore, tierStore, shopStore, packageSeriesStore, packageStore)
+	return svc, allocationStore, shopStore, packageSeriesStore, packageStore, tierStore
+}
+
+func createContextWithUser(userID uint, userType int, shopID uint) context.Context {
+	ctx := context.Background()
+	info := &middleware.UserContextInfo{
+		UserID:   userID,
+		UserType: userType,
+		ShopID:   shopID,
+	}
+	return middleware.SetUserContext(ctx, info)
+}
+
+func createTestShop(t *testing.T, store *postgres.ShopStore, ctx context.Context, shopName string, parentID *uint) *model.Shop {
+	shop := &model.Shop{
+		ShopName: shopName,
+		ShopCode: shopName,
+		ParentID: parentID,
+		Status:   constants.StatusEnabled,
+	}
+	shop.Creator = 1
+	err := store.Create(ctx, shop)
+	require.NoError(t, err)
+	return shop
+}
+
+func createTestSeries(t *testing.T, store *postgres.PackageSeriesStore, ctx context.Context, seriesName string) *model.PackageSeries {
+	series := &model.PackageSeries{
+		SeriesName: seriesName,
+		SeriesCode: seriesName,
+		Status:     constants.StatusEnabled,
+	}
+	series.Creator = 1
+	err := store.Create(ctx, series)
+	require.NoError(t, err)
+	return series
+}
+
+func TestService_CalculateCostPrice(t *testing.T) {
+	svc, _, _, _, _, _ := createTestService(t)
+
+	tests := []struct {
+		name              string
+		parentCostPrice   int64
+		pricingMode       string
+		pricingValue      int64
+		expectedCostPrice int64
+		description       string
+	}{
+		{
+			name:              "固定加价模式：10000 + 500 = 10500",
+			parentCostPrice:   10000,
+			pricingMode:       model.PricingModeFixed,
+			pricingValue:      500,
+			expectedCostPrice: 10500,
+			description:       "固定金额加价",
+		},
+		{
+			name:              "百分比加价模式：10000 + 10000*100/1000 = 11000",
+			parentCostPrice:   10000,
+			pricingMode:       model.PricingModePercent,
+			pricingValue:      100,
+			expectedCostPrice: 11000,
+			description:       "百分比加价（100 = 10%）",
+		},
+		{
+			name:              "百分比加价模式：5000 + 5000*50/1000 = 5250",
+			parentCostPrice:   5000,
+			pricingMode:       model.PricingModePercent,
+			pricingValue:      50,
+			expectedCostPrice: 5250,
+			description:       "百分比加价（50 = 5%）",
+		},
+		{
+			name:              "未知加价模式：返回原价",
+			parentCostPrice:   10000,
+			pricingMode:       "unknown",
+			pricingValue:      500,
+			expectedCostPrice: 10000,
+			description:       "未知加价模式返回原价",
+		},
+		{
+			name:              "固定加价为0：10000 + 0 = 10000",
+			parentCostPrice:   10000,
+			pricingMode:       model.PricingModeFixed,
+			pricingValue:      0,
+			expectedCostPrice: 10000,
+			description:       "固定加价为0",
+		},
+		{
+			name:              "百分比加价为0：10000 + 0 = 10000",
+			parentCostPrice:   10000,
+			pricingMode:       model.PricingModePercent,
+			pricingValue:      0,
+			expectedCostPrice: 10000,
+			description:       "百分比加价为0",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := svc.CalculateCostPrice(tt.parentCostPrice, tt.pricingMode, tt.pricingValue)
+			assert.Equal(t, tt.expectedCostPrice, result, tt.description)
+		})
+	}
+}
+
+func TestService_Create_Validation(t *testing.T) {
+	svc, allocationStore, shopStore, seriesStore, _, _ := createTestService(t)
+	ctx := context.Background()
+
+	parentShop := createTestShop(t, shopStore, ctx, "一级代理", nil)
+	childShop := createTestShop(t, shopStore, ctx, "二级代理", &parentShop.ID)
+	unrelatedShop := createTestShop(t, shopStore, ctx, "无关店铺", nil)
+	series := createTestSeries(t, seriesStore, ctx, "测试系列")
+
+	t.Run("未授权访问：无用户上下文", func(t *testing.T) {
+		emptyCtx := context.Background()
+
+		req := &dto.CreateShopSeriesAllocationRequest{
+			ShopID:       childShop.ID,
+			SeriesID:     series.ID,
+			PricingMode:  model.PricingModeFixed,
+			PricingValue: 500,
+		}
+
+		_, err := svc.Create(emptyCtx, req)
+		require.Error(t, err)
+		appErr := err.(*errors.AppError)
+		assert.Equal(t, errors.CodeUnauthorized, appErr.Code)
+	})
+
+	t.Run("代理账号无店铺上下文", func(t *testing.T) {
+		ctxWithoutShop := createContextWithUser(1, constants.UserTypeAgent, 0)
+
+		req := &dto.CreateShopSeriesAllocationRequest{
+			ShopID:       childShop.ID,
+			SeriesID:     series.ID,
+			PricingMode:  model.PricingModeFixed,
+			PricingValue: 500,
+		}
+
+		_, err := svc.Create(ctxWithoutShop, req)
+		require.Error(t, err)
+		appErr := err.(*errors.AppError)
+		assert.Equal(t, errors.CodeUnauthorized, appErr.Code)
+	})
+
+	t.Run("分配给非直属下级店铺", func(t *testing.T) {
+		ctxParent := createContextWithUser(1, constants.UserTypeAgent, parentShop.ID)
+
+		req := &dto.CreateShopSeriesAllocationRequest{
+			ShopID:       unrelatedShop.ID,
+			SeriesID:     series.ID,
+			PricingMode:  model.PricingModeFixed,
+			PricingValue: 500,
+		}
+
+		_, err := svc.Create(ctxParent, req)
+		require.Error(t, err)
+		appErr := err.(*errors.AppError)
+		assert.Equal(t, errors.CodeForbidden, appErr.Code)
+	})
+
+	t.Run("代理账号无该系列分配权限", func(t *testing.T) {
+		ctxParent := createContextWithUser(1, constants.UserTypeAgent, parentShop.ID)
+		series2 := createTestSeries(t, seriesStore, ctx, "测试系列2")
+
+		req := &dto.CreateShopSeriesAllocationRequest{
+			ShopID:       childShop.ID,
+			SeriesID:     series2.ID,
+			PricingMode:  model.PricingModeFixed,
+			PricingValue: 500,
+		}
+
+		_, err := svc.Create(ctxParent, req)
+		require.Error(t, err)
+		appErr := err.(*errors.AppError)
+		assert.Equal(t, errors.CodeForbidden, appErr.Code)
+	})
+
+	t.Run("重复分配：同一店铺和系列已分配", func(t *testing.T) {
+		series3 := createTestSeries(t, seriesStore, ctx, "测试系列3")
+		childShop2 := createTestShop(t, shopStore, ctx, "二级代理2", &parentShop.ID)
+
+		ctxParent := createContextWithUser(1, constants.UserTypeAgent, parentShop.ID)
+
+		parentAllocation := &model.ShopSeriesAllocation{
+			ShopID:          parentShop.ID,
+			SeriesID:        series3.ID,
+			AllocatorShopID: 0,
+			PricingMode:     model.PricingModeFixed,
+			PricingValue:    500,
+			Status:          constants.StatusEnabled,
+		}
+		parentAllocation.Creator = 1
+		err := allocationStore.Create(ctx, parentAllocation)
+		require.NoError(t, err)
+
+		req := &dto.CreateShopSeriesAllocationRequest{
+			ShopID:       childShop2.ID,
+			SeriesID:     series3.ID,
+			PricingMode:  model.PricingModeFixed,
+			PricingValue: 500,
+		}
+
+		resp1, err := svc.Create(ctxParent, req)
+		require.NoError(t, err)
+		assert.NotNil(t, resp1)
+
+		_, err = svc.Create(ctxParent, req)
+		require.Error(t, err)
+		appErr := err.(*errors.AppError)
+		assert.Equal(t, errors.CodeConflict, appErr.Code)
+	})
+
+	t.Run("成功创建分配：代理有该系列权限", func(t *testing.T) {
+		series4 := createTestSeries(t, seriesStore, ctx, "测试系列4")
+		childShop3 := createTestShop(t, shopStore, ctx, "二级代理3", &parentShop.ID)
+
+		ctxParent := createContextWithUser(1, constants.UserTypeAgent, parentShop.ID)
+
+		parentAllocation := &model.ShopSeriesAllocation{
+			ShopID:          parentShop.ID,
+			SeriesID:        series4.ID,
+			AllocatorShopID: 0,
+			PricingMode:     model.PricingModeFixed,
+			PricingValue:    500,
+			Status:          constants.StatusEnabled,
+		}
+		parentAllocation.Creator = 1
+		err := allocationStore.Create(ctx, parentAllocation)
+		require.NoError(t, err)
+
+		req := &dto.CreateShopSeriesAllocationRequest{
+			ShopID:       childShop3.ID,
+			SeriesID:     series4.ID,
+			PricingMode:  model.PricingModePercent,
+			PricingValue: 100,
+		}
+
+		resp, err := svc.Create(ctxParent, req)
+		require.NoError(t, err)
+		assert.NotNil(t, resp)
+		assert.Equal(t, childShop3.ID, resp.ShopID)
+		assert.Equal(t, series4.ID, resp.SeriesID)
+		assert.Equal(t, model.PricingModePercent, resp.PricingMode)
+		assert.Equal(t, int64(100), resp.PricingValue)
+	})
+
+	t.Run("平台用户需要有店铺上下文才能分配", func(t *testing.T) {
+		series5 := createTestSeries(t, seriesStore, ctx, "测试系列5")
+		childShop4 := createTestShop(t, shopStore, ctx, "二级代理4", &parentShop.ID)
+
+		ctxPlatform := createContextWithUser(2, constants.UserTypePlatform, 0)
+
+		req := &dto.CreateShopSeriesAllocationRequest{
+			ShopID:       childShop4.ID,
+			SeriesID:     series5.ID,
+			PricingMode:  model.PricingModeFixed,
+			PricingValue: 1000,
+		}
+
+		_, err := svc.Create(ctxPlatform, req)
+		require.Error(t, err)
+		appErr := err.(*errors.AppError)
+		assert.Equal(t, errors.CodeForbidden, appErr.Code)
+	})
+}
+
+func TestService_Delete_WithDependency(t *testing.T) {
+	svc, allocationStore, shopStore, seriesStore, _, _ := createTestService(t)
+	ctx := context.Background()
+
+	parentShop := createTestShop(t, shopStore, ctx, "一级代理", nil)
+	childShop := createTestShop(t, shopStore, ctx, "二级代理", &parentShop.ID)
+	_ = createTestShop(t, shopStore, ctx, "三级代理", &childShop.ID)
+	series := createTestSeries(t, seriesStore, ctx, "测试系列")
+
+	t.Run("删除无依赖的分配成功", func(t *testing.T) {
+		allocation := &model.ShopSeriesAllocation{
+			ShopID:          childShop.ID,
+			SeriesID:        series.ID,
+			AllocatorShopID: parentShop.ID,
+			PricingMode:     model.PricingModeFixed,
+			PricingValue:    500,
+			Status:          constants.StatusEnabled,
+		}
+		allocation.Creator = 1
+		err := allocationStore.Create(ctx, allocation)
+		require.NoError(t, err)
+
+		err = svc.Delete(ctx, allocation.ID)
+		require.NoError(t, err)
+
+		_, err = allocationStore.GetByID(ctx, allocation.ID)
+		require.Error(t, err)
+		assert.Equal(t, gorm.ErrRecordNotFound, err)
+	})
+
+	t.Run("删除分配成功（无依赖关系）", func(t *testing.T) {
+		series2 := createTestSeries(t, seriesStore, ctx, "测试系列2")
+
+		allocation1 := &model.ShopSeriesAllocation{
+			ShopID:          childShop.ID,
+			SeriesID:        series2.ID,
+			AllocatorShopID: parentShop.ID,
+			PricingMode:     model.PricingModeFixed,
+			PricingValue:    500,
+			Status:          constants.StatusEnabled,
+		}
+		allocation1.Creator = 1
+		err := allocationStore.Create(ctx, allocation1)
+		require.NoError(t, err)
+
+		err = svc.Delete(ctx, allocation1.ID)
+		require.NoError(t, err)
+
+		_, err = allocationStore.GetByID(ctx, allocation1.ID)
+		require.Error(t, err)
+		assert.Equal(t, gorm.ErrRecordNotFound, err)
+	})
+
+	t.Run("删除不存在的分配返回错误", func(t *testing.T) {
+		err := svc.Delete(ctx, 99999)
+		require.Error(t, err)
+		appErr := err.(*errors.AppError)
+		assert.Equal(t, errors.CodeNotFound, appErr.Code)
+	})
+}
+
+func TestService_Get(t *testing.T) {
+	svc, allocationStore, shopStore, seriesStore, _, _ := createTestService(t)
+	ctx := context.Background()
+
+	parentShop := createTestShop(t, shopStore, ctx, "一级代理", nil)
+	childShop := createTestShop(t, shopStore, ctx, "二级代理", &parentShop.ID)
+	series := createTestSeries(t, seriesStore, ctx, "测试系列")
+
+	allocation := &model.ShopSeriesAllocation{
+		ShopID:          childShop.ID,
+		SeriesID:        series.ID,
+		AllocatorShopID: parentShop.ID,
+		PricingMode:     model.PricingModeFixed,
+		PricingValue:    500,
+		Status:          constants.StatusEnabled,
+	}
+	allocation.Creator = 1
+	err := allocationStore.Create(ctx, allocation)
+	require.NoError(t, err)
+
+	t.Run("获取存在的分配", func(t *testing.T) {
+		resp, err := svc.Get(ctx, allocation.ID)
+		require.NoError(t, err)
+		assert.NotNil(t, resp)
+		assert.Equal(t, allocation.ID, resp.ID)
+		assert.Equal(t, childShop.ID, resp.ShopID)
+		assert.Equal(t, series.ID, resp.SeriesID)
+	})
+
+	t.Run("获取不存在的分配", func(t *testing.T) {
+		_, err := svc.Get(ctx, 99999)
+		require.Error(t, err)
+		appErr := err.(*errors.AppError)
+		assert.Equal(t, errors.CodeNotFound, appErr.Code)
+	})
+}
+
+func TestService_Update(t *testing.T) {
+	svc, allocationStore, shopStore, seriesStore, _, _ := createTestService(t)
+	ctx := context.Background()
+
+	parentShop := createTestShop(t, shopStore, ctx, "一级代理", nil)
+	childShop := createTestShop(t, shopStore, ctx, "二级代理", &parentShop.ID)
+	series := createTestSeries(t, seriesStore, ctx, "测试系列")
+
+	allocation := &model.ShopSeriesAllocation{
+		ShopID:          childShop.ID,
+		SeriesID:        series.ID,
+		AllocatorShopID: parentShop.ID,
+		PricingMode:     model.PricingModeFixed,
+		PricingValue:    500,
+		Status:          constants.StatusEnabled,
+	}
+	allocation.Creator = 1
+	err := allocationStore.Create(ctx, allocation)
+	require.NoError(t, err)
+
+	t.Run("更新加价模式和加价值", func(t *testing.T) {
+		ctxWithUser := createContextWithUser(1, constants.UserTypeAgent, parentShop.ID)
+		newMode := model.PricingModePercent
+		newValue := int64(100)
+
+		req := &dto.UpdateShopSeriesAllocationRequest{
+			PricingMode:  &newMode,
+			PricingValue: &newValue,
+		}
+
+		resp, err := svc.Update(ctxWithUser, allocation.ID, req)
+		require.NoError(t, err)
+		assert.NotNil(t, resp)
+		assert.Equal(t, model.PricingModePercent, resp.PricingMode)
+		assert.Equal(t, int64(100), resp.PricingValue)
+	})
+
+	t.Run("更新不存在的分配", func(t *testing.T) {
+		ctxWithUser := createContextWithUser(1, constants.UserTypeAgent, parentShop.ID)
+		newMode := model.PricingModeFixed
+
+		req := &dto.UpdateShopSeriesAllocationRequest{
+			PricingMode: &newMode,
+		}
+
+		_, err := svc.Update(ctxWithUser, 99999, req)
+		require.Error(t, err)
+		appErr := err.(*errors.AppError)
+		assert.Equal(t, errors.CodeNotFound, appErr.Code)
+	})
+}
+
+func TestService_UpdateStatus(t *testing.T) {
+	svc, allocationStore, shopStore, seriesStore, _, _ := createTestService(t)
+	ctx := context.Background()
+
+	parentShop := createTestShop(t, shopStore, ctx, "一级代理", nil)
+	childShop := createTestShop(t, shopStore, ctx, "二级代理", &parentShop.ID)
+	series := createTestSeries(t, seriesStore, ctx, "测试系列")
+
+	allocation := &model.ShopSeriesAllocation{
+		ShopID:          childShop.ID,
+		SeriesID:        series.ID,
+		AllocatorShopID: parentShop.ID,
+		PricingMode:     model.PricingModeFixed,
+		PricingValue:    500,
+		Status:          constants.StatusEnabled,
+	}
+	allocation.Creator = 1
+	err := allocationStore.Create(ctx, allocation)
+	require.NoError(t, err)
+
+	t.Run("禁用分配", func(t *testing.T) {
+		ctxWithUser := createContextWithUser(1, constants.UserTypeAgent, parentShop.ID)
+		err := svc.UpdateStatus(ctxWithUser, allocation.ID, constants.StatusDisabled)
+		require.NoError(t, err)
+
+		updated, err := allocationStore.GetByID(ctx, allocation.ID)
+		require.NoError(t, err)
+		assert.Equal(t, constants.StatusDisabled, updated.Status)
+	})
+
+	t.Run("启用分配", func(t *testing.T) {
+		ctxWithUser := createContextWithUser(1, constants.UserTypeAgent, parentShop.ID)
+		err := svc.UpdateStatus(ctxWithUser, allocation.ID, constants.StatusEnabled)
+		require.NoError(t, err)
+
+		updated, err := allocationStore.GetByID(ctx, allocation.ID)
+		require.NoError(t, err)
+		assert.Equal(t, constants.StatusEnabled, updated.Status)
+	})
+
+	t.Run("更新不存在的分配状态", func(t *testing.T) {
+		ctxWithUser := createContextWithUser(1, constants.UserTypeAgent, parentShop.ID)
+		err := svc.UpdateStatus(ctxWithUser, 99999, constants.StatusDisabled)
+		require.Error(t, err)
+		appErr := err.(*errors.AppError)
+		assert.Equal(t, errors.CodeNotFound, appErr.Code)
+	})
+}
+
+func TestService_List(t *testing.T) {
+	svc, allocationStore, shopStore, seriesStore, _, _ := createTestService(t)
+	ctx := context.Background()
+
+	parentShop := createTestShop(t, shopStore, ctx, "一级代理", nil)
+	childShop1 := createTestShop(t, shopStore, ctx, "二级代理1", &parentShop.ID)
+	childShop2 := createTestShop(t, shopStore, ctx, "二级代理2", &parentShop.ID)
+	series1 := createTestSeries(t, seriesStore, ctx, "测试系列1")
+	series2 := createTestSeries(t, seriesStore, ctx, "测试系列2")
+
+	allocation1 := &model.ShopSeriesAllocation{
+		ShopID:          childShop1.ID,
+		SeriesID:        series1.ID,
+		AllocatorShopID: parentShop.ID,
+		PricingMode:     model.PricingModeFixed,
+		PricingValue:    500,
+		Status:          constants.StatusEnabled,
+	}
+	allocation1.Creator = 1
+	err := allocationStore.Create(ctx, allocation1)
+	require.NoError(t, err)
+
+	allocation2 := &model.ShopSeriesAllocation{
+		ShopID:          childShop2.ID,
+		SeriesID:        series2.ID,
+		AllocatorShopID: parentShop.ID,
+		PricingMode:     model.PricingModePercent,
+		PricingValue:    100,
+		Status:          constants.StatusEnabled,
+	}
+	allocation2.Creator = 1
+	err = allocationStore.Create(ctx, allocation2)
+	require.NoError(t, err)
+
+	t.Run("查询所有分配", func(t *testing.T) {
+		ctxWithUser := createContextWithUser(1, constants.UserTypeAgent, parentShop.ID)
+		req := &dto.ShopSeriesAllocationListRequest{
+			Page:     1,
+			PageSize: 20,
+		}
+
+		resp, total, err := svc.List(ctxWithUser, req)
+		require.NoError(t, err)
+		assert.GreaterOrEqual(t, total, int64(2))
+		assert.GreaterOrEqual(t, len(resp), 2)
+	})
+
+	t.Run("按店铺ID过滤", func(t *testing.T) {
+		ctxWithUser := createContextWithUser(1, constants.UserTypeAgent, parentShop.ID)
+		req := &dto.ShopSeriesAllocationListRequest{
+			Page:     1,
+			PageSize: 20,
+			ShopID:   &childShop1.ID,
+		}
+
+		resp, total, err := svc.List(ctxWithUser, req)
+		require.NoError(t, err)
+		assert.GreaterOrEqual(t, total, int64(1))
+		for _, a := range resp {
+			assert.Equal(t, childShop1.ID, a.ShopID)
+		}
+	})
+
+	t.Run("按系列ID过滤", func(t *testing.T) {
+		ctxWithUser := createContextWithUser(1, constants.UserTypeAgent, parentShop.ID)
+		req := &dto.ShopSeriesAllocationListRequest{
+			Page:     1,
+			PageSize: 20,
+			SeriesID: &series1.ID,
+		}
+
+		resp, total, err := svc.List(ctxWithUser, req)
+		require.NoError(t, err)
+		assert.GreaterOrEqual(t, total, int64(1))
+		for _, a := range resp {
+			assert.Equal(t, series1.ID, a.SeriesID)
+		}
+	})
+
+	t.Run("按状态过滤", func(t *testing.T) {
+		ctxWithUser := createContextWithUser(1, constants.UserTypeAgent, parentShop.ID)
+		status := constants.StatusEnabled
+		req := &dto.ShopSeriesAllocationListRequest{
+			Page:     1,
+			PageSize: 20,
+			Status:   &status,
+		}
+
+		resp, total, err := svc.List(ctxWithUser, req)
+		require.NoError(t, err)
+		assert.GreaterOrEqual(t, total, int64(2))
+		for _, a := range resp {
+			assert.Equal(t, constants.StatusEnabled, a.Status)
+		}
+	})
+}