feat: 实现账号与佣金管理模块
All checks were successful
构建并部署到测试环境(无 SSH) / build-and-deploy (push) Successful in 4m35s

新增功能:
- 店铺佣金查询:店铺佣金统计、店铺佣金记录列表、店铺提现记录
- 佣金提现审批:提现申请列表、审批通过、审批拒绝
- 提现配置管理:配置列表、新增配置、获取当前生效配置
- 企业管理:企业列表、创建、更新、删除、获取详情
- 企业卡授权:授权列表、批量授权、批量取消授权、统计
- 客户账号管理:账号列表、创建、更新状态、重置密码
- 我的佣金:佣金统计、佣金记录、提现申请、提现记录

数据库变更:
- 扩展 tb_commission_withdrawal_request 新增提现单号等字段
- 扩展 tb_account 新增 is_primary 字段
- 扩展 tb_commission_record 新增 shop_id、balance_after
- 扩展 tb_commission_withdrawal_setting 新增每日提现次数限制
- 扩展 tb_iot_card、tb_device 新增 shop_id 冗余字段
- 新建 tb_enterprise_card_authorization 企业卡授权表
- 新建 tb_asset_allocation_record 资产分配记录表
- 数据迁移:owner_type 枚举值 agent 统一为 shop

测试:
- 新增 7 个单元测试文件覆盖各服务
- 修复集成测试 Redis 依赖问题
This commit is contained in:
2026-01-21 18:20:44 +08:00
parent 1489abe668
commit 91c9bbfeb8
89 changed files with 11958 additions and 159 deletions

View File

@@ -0,0 +1,534 @@
package unit
import (
"context"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/break/junhong_cmp_fiber/internal/model"
"github.com/break/junhong_cmp_fiber/internal/service/enterprise_card"
"github.com/break/junhong_cmp_fiber/internal/store/postgres"
"github.com/break/junhong_cmp_fiber/pkg/constants"
"github.com/break/junhong_cmp_fiber/tests/testutils"
)
func createEnterpriseCardTestContext(userID uint, shopID uint) context.Context {
ctx := context.Background()
ctx = context.WithValue(ctx, constants.ContextKeyUserID, userID)
ctx = context.WithValue(ctx, constants.ContextKeyUserType, constants.UserTypePlatform)
ctx = context.WithValue(ctx, constants.ContextKeyShopID, shopID)
return ctx
}
func TestEnterpriseCardService_AllocateCardsPreview(t *testing.T) {
db, redisClient := testutils.SetupTestDB(t)
defer testutils.TeardownTestDB(t, db, redisClient)
enterpriseStore := postgres.NewEnterpriseStore(db, redisClient)
enterpriseCardAuthStore := postgres.NewEnterpriseCardAuthorizationStore(db, redisClient)
service := enterprise_card.New(db, enterpriseStore, enterpriseCardAuthStore)
t.Run("授权预检-企业不存在应失败", func(t *testing.T) {
ctx := createEnterpriseCardTestContext(1, 1)
req := &model.AllocateCardsPreviewReq{
ICCIDs: []string{"898600000001"},
}
_, err := service.AllocateCardsPreview(ctx, 99999, req)
assert.Error(t, err)
})
t.Run("授权预检-未授权用户应失败", func(t *testing.T) {
ctx := context.Background()
req := &model.AllocateCardsPreviewReq{
ICCIDs: []string{"898600000001"},
}
_, err := service.AllocateCardsPreview(ctx, 1, req)
assert.Error(t, err)
})
t.Run("授权预检-空ICCID列表", func(t *testing.T) {
ctx := createEnterpriseCardTestContext(1, 1)
ent := &model.Enterprise{
EnterpriseName: "预检测试企业",
EnterpriseCode: "ENT_PREVIEW_001",
Status: constants.StatusEnabled,
}
ent.Creator = 1
ent.Updater = 1
err := db.Create(ent).Error
require.NoError(t, err)
req := &model.AllocateCardsPreviewReq{
ICCIDs: []string{},
}
result, err := service.AllocateCardsPreview(ctx, ent.ID, req)
require.NoError(t, err)
assert.NotNil(t, result)
assert.Equal(t, 0, result.Summary.TotalCardCount)
})
t.Run("授权预检-卡不存在", func(t *testing.T) {
ctx := createEnterpriseCardTestContext(1, 1)
ent := &model.Enterprise{
EnterpriseName: "预检测试企业2",
EnterpriseCode: "ENT_PREVIEW_002",
Status: constants.StatusEnabled,
}
ent.Creator = 1
ent.Updater = 1
err := db.Create(ent).Error
require.NoError(t, err)
req := &model.AllocateCardsPreviewReq{
ICCIDs: []string{"NON_EXIST_ICCID"},
}
result, err := service.AllocateCardsPreview(ctx, ent.ID, req)
require.NoError(t, err)
assert.NotNil(t, result)
assert.Equal(t, 1, result.Summary.FailedCount)
assert.Len(t, result.FailedItems, 1)
assert.Equal(t, "卡不存在", result.FailedItems[0].Reason)
})
t.Run("授权预检-独立卡", func(t *testing.T) {
ctx := createEnterpriseCardTestContext(1, 1)
ent := &model.Enterprise{
EnterpriseName: "预检测试企业3",
EnterpriseCode: "ENT_PREVIEW_003",
Status: constants.StatusEnabled,
}
ent.Creator = 1
ent.Updater = 1
err := db.Create(ent).Error
require.NoError(t, err)
shopID := uint(1)
card := &model.IotCard{
ICCID: "898600001234567890",
MSISDN: "13800000001",
Status: 1,
ShopID: &shopID,
}
err = db.Create(card).Error
require.NoError(t, err)
req := &model.AllocateCardsPreviewReq{
ICCIDs: []string{"898600001234567890"},
}
result, err := service.AllocateCardsPreview(ctx, ent.ID, req)
require.NoError(t, err)
assert.NotNil(t, result)
assert.Equal(t, 1, result.Summary.StandaloneCardCount)
assert.Len(t, result.StandaloneCards, 1)
})
}
func TestEnterpriseCardService_AllocateCards(t *testing.T) {
db, redisClient := testutils.SetupTestDB(t)
defer testutils.TeardownTestDB(t, db, redisClient)
enterpriseStore := postgres.NewEnterpriseStore(db, redisClient)
enterpriseCardAuthStore := postgres.NewEnterpriseCardAuthorizationStore(db, redisClient)
service := enterprise_card.New(db, enterpriseStore, enterpriseCardAuthStore)
t.Run("授权卡-企业不存在应失败", func(t *testing.T) {
ctx := createEnterpriseCardTestContext(1, 1)
req := &model.AllocateCardsReq{
ICCIDs: []string{"898600000001"},
}
_, err := service.AllocateCards(ctx, 99999, req)
assert.Error(t, err)
})
t.Run("授权卡-成功", func(t *testing.T) {
ctx := createEnterpriseCardTestContext(1, 1)
ent := &model.Enterprise{
EnterpriseName: "授权测试企业",
EnterpriseCode: "ENT_ALLOC_001",
Status: constants.StatusEnabled,
}
ent.Creator = 1
ent.Updater = 1
err := db.Create(ent).Error
require.NoError(t, err)
shopID := uint(1)
card := &model.IotCard{
ICCID: "898600002345678901",
MSISDN: "13800000002",
Status: 1,
ShopID: &shopID,
}
err = db.Create(card).Error
require.NoError(t, err)
req := &model.AllocateCardsReq{
ICCIDs: []string{"898600002345678901"},
}
result, err := service.AllocateCards(ctx, ent.ID, req)
require.NoError(t, err)
assert.NotNil(t, result)
assert.Equal(t, 1, result.SuccessCount)
})
t.Run("授权卡-重复授权不创建新记录", func(t *testing.T) {
ctx := createEnterpriseCardTestContext(1, 1)
ent := &model.Enterprise{
EnterpriseName: "重复授权测试企业",
EnterpriseCode: "ENT_ALLOC_002",
Status: constants.StatusEnabled,
}
ent.Creator = 1
ent.Updater = 1
err := db.Create(ent).Error
require.NoError(t, err)
shopID := uint(1)
card := &model.IotCard{
ICCID: "898600003456789012",
MSISDN: "13800000003",
Status: 1,
ShopID: &shopID,
}
err = db.Create(card).Error
require.NoError(t, err)
req := &model.AllocateCardsReq{
ICCIDs: []string{"898600003456789012"},
}
_, err = service.AllocateCards(ctx, ent.ID, req)
require.NoError(t, err)
_, err = service.AllocateCards(ctx, ent.ID, req)
require.NoError(t, err)
var count int64
db.Model(&model.EnterpriseCardAuthorization{}).
Where("enterprise_id = ? AND iot_card_id = ?", ent.ID, card.ID).
Count(&count)
assert.Equal(t, int64(1), count)
})
}
func TestEnterpriseCardService_RecallCards(t *testing.T) {
db, redisClient := testutils.SetupTestDB(t)
defer testutils.TeardownTestDB(t, db, redisClient)
enterpriseStore := postgres.NewEnterpriseStore(db, redisClient)
enterpriseCardAuthStore := postgres.NewEnterpriseCardAuthorizationStore(db, redisClient)
service := enterprise_card.New(db, enterpriseStore, enterpriseCardAuthStore)
t.Run("回收授权-企业不存在应失败", func(t *testing.T) {
ctx := createEnterpriseCardTestContext(1, 1)
req := &model.RecallCardsReq{
ICCIDs: []string{"898600000001"},
}
_, err := service.RecallCards(ctx, 99999, req)
assert.Error(t, err)
})
t.Run("回收授权-卡未授权应失败", func(t *testing.T) {
ctx := createEnterpriseCardTestContext(1, 1)
ent := &model.Enterprise{
EnterpriseName: "回收测试企业",
EnterpriseCode: "ENT_RECALL_001",
Status: constants.StatusEnabled,
}
ent.Creator = 1
ent.Updater = 1
err := db.Create(ent).Error
require.NoError(t, err)
shopID := uint(1)
card := &model.IotCard{
ICCID: "898600004567890123",
MSISDN: "13800000004",
Status: 1,
ShopID: &shopID,
}
err = db.Create(card).Error
require.NoError(t, err)
req := &model.RecallCardsReq{
ICCIDs: []string{"898600004567890123"},
}
result, err := service.RecallCards(ctx, ent.ID, req)
require.NoError(t, err)
assert.Equal(t, 1, result.FailCount)
assert.Equal(t, "该卡未授权给此企业", result.FailedItems[0].Reason)
})
t.Run("回收授权-成功", func(t *testing.T) {
ctx := createEnterpriseCardTestContext(1, 1)
ent := &model.Enterprise{
EnterpriseName: "回收成功测试企业",
EnterpriseCode: "ENT_RECALL_002",
Status: constants.StatusEnabled,
}
ent.Creator = 1
ent.Updater = 1
err := db.Create(ent).Error
require.NoError(t, err)
shopID := uint(1)
card := &model.IotCard{
ICCID: "898600005678901234",
MSISDN: "13800000005",
Status: 1,
ShopID: &shopID,
}
err = db.Create(card).Error
require.NoError(t, err)
allocReq := &model.AllocateCardsReq{
ICCIDs: []string{"898600005678901234"},
}
_, err = service.AllocateCards(ctx, ent.ID, allocReq)
require.NoError(t, err)
recallReq := &model.RecallCardsReq{
ICCIDs: []string{"898600005678901234"},
}
result, err := service.RecallCards(ctx, ent.ID, recallReq)
require.NoError(t, err)
assert.Equal(t, 1, result.SuccessCount)
assert.Equal(t, 0, result.FailCount)
})
}
func TestEnterpriseCardService_ListCards(t *testing.T) {
db, redisClient := testutils.SetupTestDB(t)
defer testutils.TeardownTestDB(t, db, redisClient)
enterpriseStore := postgres.NewEnterpriseStore(db, redisClient)
enterpriseCardAuthStore := postgres.NewEnterpriseCardAuthorizationStore(db, redisClient)
service := enterprise_card.New(db, enterpriseStore, enterpriseCardAuthStore)
t.Run("查询企业卡列表-企业不存在应失败", func(t *testing.T) {
ctx := createEnterpriseCardTestContext(1, 1)
req := &model.EnterpriseCardListReq{
Page: 1,
PageSize: 20,
}
_, err := service.ListCards(ctx, 99999, req)
assert.Error(t, err)
})
t.Run("查询企业卡列表-空结果", func(t *testing.T) {
ctx := createEnterpriseCardTestContext(1, 1)
ent := &model.Enterprise{
EnterpriseName: "列表测试企业",
EnterpriseCode: "ENT_LIST_001",
Status: constants.StatusEnabled,
}
ent.Creator = 1
ent.Updater = 1
err := db.Create(ent).Error
require.NoError(t, err)
req := &model.EnterpriseCardListReq{
Page: 1,
PageSize: 20,
}
result, err := service.ListCards(ctx, ent.ID, req)
require.NoError(t, err)
assert.NotNil(t, result)
assert.Equal(t, int64(0), result.Total)
})
t.Run("查询企业卡列表-有数据", func(t *testing.T) {
ctx := createEnterpriseCardTestContext(1, 1)
ent := &model.Enterprise{
EnterpriseName: "列表数据测试企业",
EnterpriseCode: "ENT_LIST_002",
Status: constants.StatusEnabled,
}
ent.Creator = 1
ent.Updater = 1
err := db.Create(ent).Error
require.NoError(t, err)
shopID := uint(1)
card := &model.IotCard{
ICCID: "898600006789012345",
MSISDN: "13800000006",
Status: 1,
ShopID: &shopID,
}
err = db.Create(card).Error
require.NoError(t, err)
allocReq := &model.AllocateCardsReq{
ICCIDs: []string{"898600006789012345"},
}
_, err = service.AllocateCards(ctx, ent.ID, allocReq)
require.NoError(t, err)
req := &model.EnterpriseCardListReq{
Page: 1,
PageSize: 20,
}
result, err := service.ListCards(ctx, ent.ID, req)
require.NoError(t, err)
assert.NotNil(t, result)
assert.Equal(t, int64(1), result.Total)
assert.Len(t, result.Items, 1)
assert.Equal(t, "898600006789012345", result.Items[0].ICCID)
})
t.Run("查询企业卡列表-按ICCID筛选", func(t *testing.T) {
ctx := createEnterpriseCardTestContext(1, 1)
ent := &model.Enterprise{
EnterpriseName: "筛选测试企业",
EnterpriseCode: "ENT_LIST_003",
Status: constants.StatusEnabled,
}
ent.Creator = 1
ent.Updater = 1
err := db.Create(ent).Error
require.NoError(t, err)
shopID := uint(1)
card := &model.IotCard{
ICCID: "898600007890123456",
MSISDN: "13800000007",
Status: 1,
ShopID: &shopID,
}
err = db.Create(card).Error
require.NoError(t, err)
allocReq := &model.AllocateCardsReq{
ICCIDs: []string{"898600007890123456"},
}
_, err = service.AllocateCards(ctx, ent.ID, allocReq)
require.NoError(t, err)
req := &model.EnterpriseCardListReq{
Page: 1,
PageSize: 20,
ICCID: "78901",
}
result, err := service.ListCards(ctx, ent.ID, req)
require.NoError(t, err)
assert.NotNil(t, result)
assert.GreaterOrEqual(t, result.Total, int64(1))
})
}
func TestEnterpriseCardService_SuspendAndResumeCard(t *testing.T) {
db, redisClient := testutils.SetupTestDB(t)
defer testutils.TeardownTestDB(t, db, redisClient)
enterpriseStore := postgres.NewEnterpriseStore(db, redisClient)
enterpriseCardAuthStore := postgres.NewEnterpriseCardAuthorizationStore(db, redisClient)
service := enterprise_card.New(db, enterpriseStore, enterpriseCardAuthStore)
t.Run("停机-未授权的卡应失败", func(t *testing.T) {
ctx := createEnterpriseCardTestContext(1, 1)
ent := &model.Enterprise{
EnterpriseName: "停机测试企业",
EnterpriseCode: "ENT_SUSPEND_001",
Status: constants.StatusEnabled,
}
ent.Creator = 1
ent.Updater = 1
err := db.Create(ent).Error
require.NoError(t, err)
shopID := uint(1)
card := &model.IotCard{
ICCID: "898600008901234567",
MSISDN: "13800000008",
Status: 1,
ShopID: &shopID,
}
err = db.Create(card).Error
require.NoError(t, err)
err = service.SuspendCard(ctx, ent.ID, card.ID)
assert.Error(t, err)
})
t.Run("停机和复机-成功", func(t *testing.T) {
ctx := createEnterpriseCardTestContext(1, 1)
ent := &model.Enterprise{
EnterpriseName: "停复机测试企业",
EnterpriseCode: "ENT_SUSPEND_002",
Status: constants.StatusEnabled,
}
ent.Creator = 1
ent.Updater = 1
err := db.Create(ent).Error
require.NoError(t, err)
shopID := uint(1)
card := &model.IotCard{
ICCID: "898600009012345678",
MSISDN: "13800000009",
Status: 1,
NetworkStatus: 1,
ShopID: &shopID,
}
err = db.Create(card).Error
require.NoError(t, err)
allocReq := &model.AllocateCardsReq{
ICCIDs: []string{"898600009012345678"},
}
_, err = service.AllocateCards(ctx, ent.ID, allocReq)
require.NoError(t, err)
err = service.SuspendCard(ctx, ent.ID, card.ID)
require.NoError(t, err)
var suspendedCard model.IotCard
db.First(&suspendedCard, card.ID)
assert.Equal(t, 0, suspendedCard.NetworkStatus)
err = service.ResumeCard(ctx, ent.ID, card.ID)
require.NoError(t, err)
var resumedCard model.IotCard
db.First(&resumedCard, card.ID)
assert.Equal(t, 1, resumedCard.NetworkStatus)
})
}