diff --git a/controller/subscription.go b/controller/subscription.go index 22cee9d5392a..1bef59e9ff2b 100644 --- a/controller/subscription.go +++ b/controller/subscription.go @@ -199,6 +199,14 @@ func AdminCreateSubscriptionPlan(c *gin.Context) { return } } + usableGroups := req.Plan.QuotaUsableGroupList() + for _, g := range usableGroups { + if _, ok := ratio_setting.GetGroupRatioCopy()[g]; !ok { + common.ApiErrorMsg(c, "额度可用分组不存在: "+g) + return + } + } + req.Plan.QuotaUsableGroups = strings.Join(usableGroups, ",") req.Plan.QuotaResetPeriod = model.NormalizeResetPeriod(req.Plan.QuotaResetPeriod) if req.Plan.QuotaResetPeriod == model.SubscriptionResetCustom && req.Plan.QuotaResetCustomSeconds <= 0 { common.ApiErrorMsg(c, "自定义重置周期需大于0秒") @@ -273,6 +281,14 @@ func AdminUpdateSubscriptionPlan(c *gin.Context) { return } } + usableGroups := req.Plan.QuotaUsableGroupList() + for _, g := range usableGroups { + if _, ok := ratio_setting.GetGroupRatioCopy()[g]; !ok { + common.ApiErrorMsg(c, "额度可用分组不存在: "+g) + return + } + } + req.Plan.QuotaUsableGroups = strings.Join(usableGroups, ",") req.Plan.QuotaResetPeriod = model.NormalizeResetPeriod(req.Plan.QuotaResetPeriod) if req.Plan.QuotaResetPeriod == model.SubscriptionResetCustom && req.Plan.QuotaResetCustomSeconds <= 0 { common.ApiErrorMsg(c, "自定义重置周期需大于0秒") @@ -298,6 +314,7 @@ func AdminUpdateSubscriptionPlan(c *gin.Context) { "total_amount": req.Plan.TotalAmount, "upgrade_group": req.Plan.UpgradeGroup, "downgrade_group": req.Plan.DowngradeGroup, + "quota_usable_groups": req.Plan.QuotaUsableGroups, "quota_reset_period": req.Plan.QuotaResetPeriod, "quota_reset_custom_seconds": req.Plan.QuotaResetCustomSeconds, "updated_at": common.GetTimestamp(), diff --git a/model/subscription.go b/model/subscription.go index 642c7b0355c6..3a333772a5c5 100644 --- a/model/subscription.go +++ b/model/subscription.go @@ -178,6 +178,9 @@ type SubscriptionPlan struct { // Downgrade user group on expiry (empty = revert to the group held before purchase) DowngradeGroup string `json:"downgrade_group" gorm:"type:varchar(64);default:''"` + // Restrict subscription quota to these groups, comma separated (empty = usable in any group) + QuotaUsableGroups string `json:"quota_usable_groups" gorm:"type:varchar(255);default:''"` + // Total quota (amount in quota units, 0 = unlimited) TotalAmount int64 `json:"total_amount" gorm:"type:bigint;not null;default:0"` @@ -210,6 +213,32 @@ func (p *SubscriptionPlan) NormalizeDefaults() { } } +// QuotaUsableGroupList 返回套餐额度可用分组列表(逗号分隔,空 = 不限制)。 +func (p *SubscriptionPlan) QuotaUsableGroupList() []string { + raw := strings.Split(p.QuotaUsableGroups, ",") + groups := make([]string, 0, len(raw)) + for _, g := range raw { + if g = strings.TrimSpace(g); g != "" { + groups = append(groups, g) + } + } + return groups +} + +// IsQuotaUsableForGroup 判断套餐额度是否可用于指定分组(未配置可用分组时不限制)。 +func (p *SubscriptionPlan) IsQuotaUsableForGroup(group string) bool { + groups := p.QuotaUsableGroupList() + if len(groups) == 0 { + return true + } + for _, g := range groups { + if g == group { + return true + } + } + return false +} + // Subscription order (payment -> webhook -> create UserSubscription) type SubscriptionOrder struct { Id int `json:"id"` @@ -869,6 +898,31 @@ func UserActiveSubscriptionsAllowWalletOverflow(userId int) (bool, error) { return strictCount == 0, nil } +// UserHasUsableSubscriptionForGroup 返回用户是否存在额度可用于指定分组的活跃订阅 +// (套餐未配置额度可用分组时视为不限制)。 +func UserHasUsableSubscriptionForGroup(userId int, group string) (bool, error) { + if userId <= 0 { + return false, errors.New("invalid userId") + } + now := common.GetTimestamp() + var subs []UserSubscription + if err := DB.Where("user_id = ? AND status = ? AND end_time > ?", userId, "active", now). + Find(&subs).Error; err != nil { + return false, err + } + for _, sub := range subs { + plan, err := GetSubscriptionPlanById(sub.PlanId) + if err != nil { + // 套餐缺失的订阅无法消耗,跳过 + continue + } + if plan.IsQuotaUsableForGroup(group) { + return true, nil + } + } + return false, nil +} + // GetAllUserSubscriptions returns all subscriptions (active and expired) for a user. func GetAllUserSubscriptions(userId int) ([]SubscriptionSummary, error) { if userId <= 0 { @@ -1270,7 +1324,7 @@ func maybeResetUserSubscriptionWithPlanTx(tx *gorm.DB, sub *UserSubscription, pl } // PreConsumeUserSubscription pre-consumes from any active subscription total quota. -func PreConsumeUserSubscription(requestId string, userId int, modelName string, quotaType int, amount int64) (*SubscriptionPreConsumeResult, error) { +func PreConsumeUserSubscription(requestId string, userId int, modelName string, group string, quotaType int, amount int64) (*SubscriptionPreConsumeResult, error) { if userId <= 0 { return nil, errors.New("invalid userId") } @@ -1322,6 +1376,10 @@ func PreConsumeUserSubscription(requestId string, userId int, modelName string, if err != nil { return err } + // 套餐配置了额度可用分组时,跳过不适用于当前请求分组的订阅 + if !plan.IsQuotaUsableForGroup(group) { + continue + } if err := maybeResetUserSubscriptionWithPlanTx(tx, &sub, plan, now); err != nil { return err } diff --git a/model/subscription_group_limit_test.go b/model/subscription_group_limit_test.go new file mode 100644 index 000000000000..af97e3064e31 --- /dev/null +++ b/model/subscription_group_limit_test.go @@ -0,0 +1,105 @@ +package model + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +// 套餐未配置可用分组时不限制;配置后仅列表内分组可用(逗号分隔,容忍空格)。 +func TestPlanIsQuotaUsableForGroup(t *testing.T) { + plan := &SubscriptionPlan{} + assert.True(t, plan.IsQuotaUsableForGroup("default")) + + plan.QuotaUsableGroups = "vip" + assert.True(t, plan.IsQuotaUsableForGroup("vip")) + assert.False(t, plan.IsQuotaUsableForGroup("default")) + + plan.QuotaUsableGroups = "vip, svip" + assert.True(t, plan.IsQuotaUsableForGroup("vip")) + assert.True(t, plan.IsQuotaUsableForGroup("svip")) + assert.False(t, plan.IsQuotaUsableForGroup("default")) +} + +func TestPreConsumeUserSubscriptionRespectsQuotaUsableGroups(t *testing.T) { + truncateTables(t) + now := GetDBTimestamp() + plan := &SubscriptionPlan{ + Id: 9301, + Title: "Team", + DurationUnit: SubscriptionDurationMonth, + DurationValue: 1, + TotalAmount: 1000, + QuotaResetPeriod: SubscriptionResetNever, + QuotaUsableGroups: "vip", + } + seedSubscriptionResetPlan(t, plan) + seedSubscriptionResetSub(t, &UserSubscription{Id: 9401, UserId: 201, PlanId: plan.Id, AmountTotal: 1000, AmountUsed: 0, StartTime: now - 3600, EndTime: now + 3600, Status: "active"}) + + // 请求分组不在套餐可用分组内 → 不得消耗订阅额度 + _, err := PreConsumeUserSubscription("req-sub-group-1", 201, "gpt-test", "default", 0, 100) + require.Error(t, err) + assert.Contains(t, err.Error(), "subscription quota insufficient") + sub := getSubscriptionResetSub(t, 9401) + assert.Zero(t, sub.AmountUsed) + + // 分组匹配 → 正常消耗 + res, err := PreConsumeUserSubscription("req-sub-group-2", 201, "gpt-test", "vip", 0, 100) + require.NoError(t, err) + assert.Equal(t, 9401, res.UserSubscriptionId) + assert.Equal(t, int64(100), res.AmountUsedAfter) +} + +func TestPreConsumeUserSubscriptionPrefersUsableSubscription(t *testing.T) { + truncateTables(t) + now := GetDBTimestamp() + restricted := &SubscriptionPlan{Id: 9302, Title: "Team", DurationUnit: SubscriptionDurationMonth, DurationValue: 1, TotalAmount: 1000, QuotaResetPeriod: SubscriptionResetNever, QuotaUsableGroups: "vip"} + open := &SubscriptionPlan{Id: 9303, Title: "Open", DurationUnit: SubscriptionDurationMonth, DurationValue: 1, TotalAmount: 1000, QuotaResetPeriod: SubscriptionResetNever} + seedSubscriptionResetPlan(t, restricted) + seedSubscriptionResetPlan(t, open) + // 受限订阅 end_time 更早,正常排序下会被优先选中 + seedSubscriptionResetSub(t, &UserSubscription{Id: 9402, UserId: 202, PlanId: restricted.Id, AmountTotal: 1000, StartTime: now - 3600, EndTime: now + 3600, Status: "active"}) + seedSubscriptionResetSub(t, &UserSubscription{Id: 9403, UserId: 202, PlanId: open.Id, AmountTotal: 1000, StartTime: now - 3600, EndTime: now + 7200, Status: "active"}) + + // default 分组 → 跳过受限订阅,从不受限订阅扣 + res, err := PreConsumeUserSubscription("req-sub-group-3", 202, "gpt-test", "default", 0, 100) + require.NoError(t, err) + assert.Equal(t, 9403, res.UserSubscriptionId) + + // vip 分组 → 受限订阅(end_time 更早)优先 + res2, err := PreConsumeUserSubscription("req-sub-group-4", 202, "gpt-test", "vip", 0, 100) + require.NoError(t, err) + assert.Equal(t, 9402, res2.UserSubscriptionId) +} + +func TestUserHasUsableSubscriptionForGroup(t *testing.T) { + truncateTables(t) + now := GetDBTimestamp() + + // 无订阅 + ok, err := UserHasUsableSubscriptionForGroup(203, "default") + require.NoError(t, err) + assert.False(t, ok) + + restricted := &SubscriptionPlan{Id: 9304, Title: "Team", DurationUnit: SubscriptionDurationMonth, DurationValue: 1, TotalAmount: 1000, QuotaResetPeriod: SubscriptionResetNever, QuotaUsableGroups: "vip"} + seedSubscriptionResetPlan(t, restricted) + seedSubscriptionResetSub(t, &UserSubscription{Id: 9404, UserId: 203, PlanId: restricted.Id, AmountTotal: 1000, StartTime: now - 3600, EndTime: now + 3600, Status: "active"}) + + ok, err = UserHasUsableSubscriptionForGroup(203, "vip") + require.NoError(t, err) + assert.True(t, ok) + + ok, err = UserHasUsableSubscriptionForGroup(203, "default") + require.NoError(t, err) + assert.False(t, ok) + + // 追加一个不受限订阅 → 任何分组都可用 + openPlan := &SubscriptionPlan{Id: 9305, Title: "Open", DurationUnit: SubscriptionDurationMonth, DurationValue: 1, TotalAmount: 1000, QuotaResetPeriod: SubscriptionResetNever} + seedSubscriptionResetPlan(t, openPlan) + seedSubscriptionResetSub(t, &UserSubscription{Id: 9405, UserId: 203, PlanId: openPlan.Id, AmountTotal: 1000, StartTime: now - 3600, EndTime: now + 3600, Status: "active"}) + + ok, err = UserHasUsableSubscriptionForGroup(203, "default") + require.NoError(t, err) + assert.True(t, ok) +} diff --git a/model/task_cas_test.go b/model/task_cas_test.go index 479774cd3fd5..6f1ce6d6c576 100644 --- a/model/task_cas_test.go +++ b/model/task_cas_test.go @@ -46,6 +46,7 @@ func TestMain(m *testing.M) { &SubscriptionPlan{}, &SubscriptionOrder{}, &UserSubscription{}, + &SubscriptionPreConsumeRecord{}, &UserOAuthBinding{}, &PerfMetric{}, &SystemInstance{}, @@ -72,6 +73,7 @@ func truncateTables(t *testing.T) { DB.Exec("DELETE FROM subscription_orders") DB.Exec("DELETE FROM subscription_plans") DB.Exec("DELETE FROM user_subscriptions") + DB.Exec("DELETE FROM subscription_pre_consume_records") DB.Exec("DELETE FROM user_oauth_bindings") DB.Exec("DELETE FROM perf_metrics") DB.Exec("DELETE FROM system_instances") diff --git a/service/billing_session.go b/service/billing_session.go index 32344eaf405c..65fe9d62d445 100644 --- a/service/billing_session.go +++ b/service/billing_session.go @@ -387,6 +387,7 @@ func NewBillingSession(c *gin.Context, relayInfo *relaycommon.RelayInfo, preCons requestId: relayInfo.RequestId, userId: relayInfo.UserId, modelName: relayInfo.OriginModelName, + group: relayInfo.UsingGroup, amount: subConsume, }, } @@ -415,11 +416,13 @@ func NewBillingSession(c *gin.Context, relayInfo *relaycommon.RelayInfo, preCons case "subscription_first": fallthrough default: - hasSub, subCheckErr := model.HasActiveUserSubscription(relayInfo.UserId) + // 无活跃订阅,或订阅套餐限定了额度可用分组且当前请求分组不匹配时, + // 直接走钱包(分组不匹配不属于额度耗尽,不受 allow_wallet_overflow 限制) + hasUsableSub, subCheckErr := model.UserHasUsableSubscriptionForGroup(relayInfo.UserId, relayInfo.UsingGroup) if subCheckErr != nil { return nil, types.NewError(subCheckErr, types.ErrorCodeQueryDataError, types.ErrOptionWithSkipRetry()) } - if !hasSub { + if !hasUsableSub { return tryWallet() } session, apiErr := trySubscription() diff --git a/service/billing_session_group_test.go b/service/billing_session_group_test.go new file mode 100644 index 000000000000..5b6a524db4af --- /dev/null +++ b/service/billing_session_group_test.go @@ -0,0 +1,45 @@ +package service + +import ( + "net/http/httptest" + "testing" + + "github.com/QuantumNous/new-api/common" + "github.com/QuantumNous/new-api/model" + relaycommon "github.com/QuantumNous/new-api/relay/common" + "github.com/gin-gonic/gin" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func newBillingTestContext(t *testing.T) *gin.Context { + t.Helper() + gin.SetMode(gin.TestMode) + c, _ := gin.CreateTestContext(httptest.NewRecorder()) + c.Request = httptest.NewRequest("POST", "/v1/chat/completions", nil) + return c +} + +// 套餐限定可用分组后:请求分组不匹配 → 直接走钱包;匹配 → 走订阅。 +func TestNewBillingSessionRoutesFundingByPlanUsableGroups(t *testing.T) { + truncate(t) + now := common.GetTimestamp() + + seedUser(t, 301, 5000) + seedToken(t, 401, 301, "sk-billing-group-test", 5000) + plan := &model.SubscriptionPlan{Id: 9501, Title: "Team", DurationUnit: model.SubscriptionDurationMonth, DurationValue: 1, TotalAmount: 1000, QuotaResetPeriod: model.SubscriptionResetNever, QuotaUsableGroups: "vip"} + require.NoError(t, model.DB.Create(plan).Error) + require.NoError(t, model.DB.Create(&model.UserSubscription{Id: 9601, UserId: 301, PlanId: plan.Id, AmountTotal: 1000, StartTime: now - 3600, EndTime: now + 3600, Status: "active"}).Error) + + // 分组不匹配 → 钱包(不受 allow_wallet_overflow 限制) + walletInfo := &relaycommon.RelayInfo{UserId: 301, TokenId: 401, TokenKey: "sk-billing-group-test", UsingGroup: "default", RequestId: "req-bsg-1"} + session, apiErr := NewBillingSession(newBillingTestContext(t), walletInfo, 0) + require.Nil(t, apiErr) + assert.Equal(t, BillingSourceWallet, session.funding.Source()) + + // 分组匹配 → 订阅 + subInfo := &relaycommon.RelayInfo{UserId: 301, TokenId: 401, TokenKey: "sk-billing-group-test", UsingGroup: "vip", RequestId: "req-bsg-2"} + session2, apiErr := NewBillingSession(newBillingTestContext(t), subInfo, 0) + require.Nil(t, apiErr) + assert.Equal(t, BillingSourceSubscription, session2.funding.Source()) +} diff --git a/service/funding_source.go b/service/funding_source.go index fc629c8392a1..a59ab18c1435 100644 --- a/service/funding_source.go +++ b/service/funding_source.go @@ -71,7 +71,8 @@ type SubscriptionFunding struct { requestId string userId int modelName string - amount int64 // 预扣的订阅额度(subConsume) + group string // 请求实际使用的分组,用于套餐额度可用分组过滤 + amount int64 // 预扣的订阅额度(subConsume) subscriptionId int preConsumed int64 // 以下字段在 PreConsume 成功后填充,供 RelayInfo 同步使用 @@ -85,7 +86,7 @@ func (s *SubscriptionFunding) Source() string { return BillingSourceSubscription func (s *SubscriptionFunding) PreConsume(_ int) error { // amount 参数被忽略,使用内部 s.amount(已在构造时根据 preConsumedQuota 计算) - res, err := model.PreConsumeUserSubscription(s.requestId, s.userId, s.modelName, 0, s.amount) + res, err := model.PreConsumeUserSubscription(s.requestId, s.userId, s.modelName, s.group, 0, s.amount) if err != nil { return err } diff --git a/service/task_billing_test.go b/service/task_billing_test.go index fb1c29157a36..09def94dc43a 100644 --- a/service/task_billing_test.go +++ b/service/task_billing_test.go @@ -38,6 +38,10 @@ func TestMain(m *testing.M) { common.RedisEnabled = false common.BatchUpdateEnabled = false common.LogConsumeEnabled = true + // LOG_SQL_DSN 为空时 InitLogDB 仅执行 LOG_DB = DB 并初始化带引号的列名(initCol) + if err := model.InitLogDB(); err != nil { + panic("failed to init column names: " + err.Error()) + } if err := db.AutoMigrate( &model.Task{}, @@ -47,6 +51,8 @@ func TestMain(m *testing.M) { &model.Channel{}, &model.TopUp{}, &model.UserSubscription{}, + &model.SubscriptionPlan{}, + &model.SubscriptionPreConsumeRecord{}, &model.SystemTask{}, &model.SystemTaskLock{}, ); err != nil { @@ -70,6 +76,8 @@ func truncate(t *testing.T) { model.DB.Exec("DELETE FROM channels") model.DB.Exec("DELETE FROM top_ups") model.DB.Exec("DELETE FROM user_subscriptions") + model.DB.Exec("DELETE FROM subscription_plans") + model.DB.Exec("DELETE FROM subscription_pre_consume_records") model.DB.Exec("DELETE FROM system_task_locks") model.DB.Exec("DELETE FROM system_tasks") }) diff --git a/web/classic/src/components/table/subscriptions/modals/AddEditSubscriptionModal.jsx b/web/classic/src/components/table/subscriptions/modals/AddEditSubscriptionModal.jsx index 73aef7317ad3..3e8c0b276b32 100644 --- a/web/classic/src/components/table/subscriptions/modals/AddEditSubscriptionModal.jsx +++ b/web/classic/src/components/table/subscriptions/modals/AddEditSubscriptionModal.jsx @@ -95,6 +95,7 @@ const AddEditSubscriptionModal = ({ max_purchase_per_user: 0, total_amount: 0, upgrade_group: '', + quota_usable_groups: [], stripe_price_id: '', creem_product_id: '', }); @@ -121,6 +122,10 @@ const AddEditSubscriptionModal = ({ quotaToDisplayAmount(p.total_amount || 0).toFixed(2), ), upgrade_group: p.upgrade_group || '', + quota_usable_groups: (p.quota_usable_groups || '') + .split(',') + .map((g) => g.trim()) + .filter(Boolean), stripe_price_id: p.stripe_price_id || '', creem_product_id: p.creem_product_id || '', }; @@ -164,6 +169,7 @@ const AddEditSubscriptionModal = ({ max_purchase_per_user: Number(values.max_purchase_per_user || 0), total_amount: displayAmountToQuota(values.total_amount), upgrade_group: values.upgrade_group || '', + quota_usable_groups: (values.quota_usable_groups || []).join(','), }, }; if (editingPlan?.plan?.id) { @@ -342,6 +348,27 @@ const AddEditSubscriptionModal = ({ + + + {(groupOptions || []).map((g) => ( + + {g} + + ))} + + + + ( + + {t('Quota Usable Groups')} + + ({ + value: g, + label: g, + }))} + selected={ + field.value + ? field.value.split(',').filter(Boolean) + : [] + } + onChange={(values) => + field.onChange(values.join(',')) + } + placeholder={t( + 'Select groups, empty means no restriction' + )} + /> + + + {t( + 'Subscription quota is only usable in these groups; requests in other groups fall back to wallet balance (rejected under subscription_only preference)' + )} + + + + )} + /> +