Skip to content
Closed
Show file tree
Hide file tree
Changes from 1 commit
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 6 additions & 0 deletions common/constants.go
Original file line number Diff line number Diff line change
Expand Up @@ -264,6 +264,12 @@ const (
RedemptionCodeStatusUsed = 3 // also don't use 0
)

const (
InvitationCodeStatusEnabled = 1
InvitationCodeStatusDisabled = 2
InvitationCodeStatusUsed = 3
)

const (
ChannelStatusUnknown = 0
ChannelStatusEnabled = 1 // don't use 0, 0 is the default value!
Expand Down
2 changes: 1 addition & 1 deletion common/database.go
Original file line number Diff line number Diff line change
Expand Up @@ -41,4 +41,4 @@ func UsingLogDatabase(databaseType DatabaseType) bool {
return logDatabaseType == databaseType
}

var SQLitePath = "one-api.db?_busy_timeout=30000"
var SQLitePath = "one-api.db?_pragma=busy_timeout(30000)"
199 changes: 199 additions & 0 deletions common/invitation.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,199 @@
package common

import (
"errors"
"sort"
"strings"
"sync"
)

const (
InvitationCodeMaxLength = 128

InvitationRegistrationMethodPassword = "password"
InvitationRegistrationMethodGitHub = "github"
InvitationRegistrationMethodDiscord = "discord"
InvitationRegistrationMethodLinuxDO = "linuxdo"
InvitationRegistrationMethodOIDC = "oidc"
InvitationRegistrationMethodCustomOAuth = "custom_oauth"
InvitationRegistrationMethodWeChat = "wechat"
)

var invitationRegistrationMethods = map[string]struct{}{
InvitationRegistrationMethodPassword: {},
InvitationRegistrationMethodGitHub: {},
InvitationRegistrationMethodDiscord: {},
InvitationRegistrationMethodLinuxDO: {},
InvitationRegistrationMethodOIDC: {},
InvitationRegistrationMethodCustomOAuth: {},
InvitationRegistrationMethodWeChat: {},
}

var invitationSettings = struct {
sync.RWMutex
required bool
methods map[string]struct{}
}{
methods: map[string]struct{}{
InvitationRegistrationMethodLinuxDO: {},
},
}

type InvitationCodeSettings struct {
Required bool `json:"required"`
Methods []string `json:"methods"`
}

func (settings InvitationCodeSettings) Requires(method string) bool {
if !settings.Required {
return false
}
method = strings.ToLower(strings.TrimSpace(method))
for _, configuredMethod := range settings.Methods {
if strings.ToLower(strings.TrimSpace(configuredMethod)) == method {
return true
}
}
return false
}

func DefaultInvitationCodeSettings() InvitationCodeSettings {
return InvitationCodeSettings{
Required: false,
Methods: []string{InvitationRegistrationMethodLinuxDO},
}
}

func NormalizeInvitationCodeSettings(required bool, methods []string) (InvitationCodeSettings, error) {
normalized := make(map[string]struct{}, len(methods))
for _, method := range methods {
method = strings.ToLower(strings.TrimSpace(method))
if _, ok := invitationRegistrationMethods[method]; !ok {
return InvitationCodeSettings{}, errors.New("unsupported invitation registration method: " + method)
}
normalized[method] = struct{}{}
}
if required && len(normalized) == 0 {
return InvitationCodeSettings{}, errors.New("at least one invitation registration method is required when invitation codes are enabled")
}

normalizedMethods := make([]string, 0, len(normalized))
for method := range normalized {
normalizedMethods = append(normalizedMethods, method)
}
sort.Strings(normalizedMethods)
return InvitationCodeSettings{
Required: required,
Methods: normalizedMethods,
}, nil
}

func ApplyInvitationCodeSettings(required bool, methods []string) (InvitationCodeSettings, error) {
normalized, err := NormalizeInvitationCodeSettings(required, methods)
if err != nil {
return InvitationCodeSettings{}, err
}

invitationSettings.Lock()
defer invitationSettings.Unlock()
invitationSettings.required = normalized.Required
invitationSettings.methods = make(map[string]struct{}, len(normalized.Methods))
for _, method := range normalized.Methods {
invitationSettings.methods[method] = struct{}{}
}
return normalized, nil
}

func GetInvitationCodeSettings() InvitationCodeSettings {
invitationSettings.RLock()
defer invitationSettings.RUnlock()

methods := make([]string, 0, len(invitationSettings.methods))
for method := range invitationSettings.methods {
methods = append(methods, method)
}
sort.Strings(methods)
return InvitationCodeSettings{
Required: invitationSettings.required,
Methods: methods,
}
}

func SetInvitationCodeRequired(required bool) error {
invitationSettings.Lock()
defer invitationSettings.Unlock()
if required && len(invitationSettings.methods) == 0 {
return errors.New("at least one invitation registration method is required when invitation codes are enabled")
}
invitationSettings.required = required
return nil
}

func IsInvitationCodeRequired() bool {
invitationSettings.RLock()
defer invitationSettings.RUnlock()
return invitationSettings.required
}

func IsInvitationCodeRequiredFor(method string) bool {
return GetInvitationCodeSettings().Requires(method)
}

func IsValidInvitationRegistrationMethod(method string) bool {
_, ok := invitationRegistrationMethods[strings.ToLower(strings.TrimSpace(method))]
return ok
}

func SetInvitationCodeMethods(methods []string) error {
normalized, err := NormalizeInvitationCodeSettings(false, methods)
if err != nil {
return err
}

invitationSettings.Lock()
defer invitationSettings.Unlock()
if invitationSettings.required && len(normalized.Methods) == 0 {
return errors.New("at least one invitation registration method is required when invitation codes are enabled")
}
invitationSettings.methods = make(map[string]struct{}, len(normalized.Methods))
for _, method := range normalized.Methods {
invitationSettings.methods[method] = struct{}{}
}
return nil
}

func SetInvitationCodeMethodsJSON(value string) error {
methods, err := ParseInvitationCodeMethodsJSON(value)
if err != nil {
return err
}
return SetInvitationCodeMethods(methods)
}

func ParseInvitationCodeMethodsJSON(value string) ([]string, error) {
trimmed := strings.TrimSpace(value)
if len(trimmed) == 0 || trimmed[0] != '[' {
return nil, errors.New("invitation registration methods must be a JSON array")
}
var methods []string
if err := UnmarshalJsonStr(value, &methods); err != nil {
return nil, err
}
normalized, err := NormalizeInvitationCodeSettings(false, methods)
if err != nil {
return nil, err
}
return normalized.Methods, nil
}

func GetInvitationCodeMethods() []string {
return GetInvitationCodeSettings().Methods
}

func InvitationCodeMethodsJSON() string {
data, err := Marshal(GetInvitationCodeMethods())
if err != nil {
return "[]"
}
return string(data)
}
94 changes: 94 additions & 0 deletions common/invitation_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,94 @@
package common

import (
"testing"

"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)

func TestInvitationCodeSettingsAreMethodScoped(t *testing.T) {
original := GetInvitationCodeSettings()
t.Cleanup(func() {
_, err := ApplyInvitationCodeSettings(original.Required, original.Methods)
require.NoError(t, err)
})

settings, err := ApplyInvitationCodeSettings(true, []string{
InvitationRegistrationMethodLinuxDO,
InvitationRegistrationMethodPassword,
InvitationRegistrationMethodLinuxDO,
})
require.NoError(t, err)

assert.True(t, IsInvitationCodeRequiredFor(InvitationRegistrationMethodLinuxDO))
assert.True(t, IsInvitationCodeRequiredFor(InvitationRegistrationMethodPassword))
assert.False(t, IsInvitationCodeRequiredFor(InvitationRegistrationMethodGitHub))
assert.Equal(t, InvitationCodeSettings{
Required: true,
Methods: []string{"linuxdo", "password"},
}, settings)
assert.Equal(t, settings, GetInvitationCodeSettings())

require.NoError(t, SetInvitationCodeRequired(false))
assert.False(t, IsInvitationCodeRequiredFor(InvitationRegistrationMethodLinuxDO))
}

func TestSetInvitationCodeMethodsJSONRejectsUnsupportedMethods(t *testing.T) {
original := GetInvitationCodeSettings()
t.Cleanup(func() {
_, err := ApplyInvitationCodeSettings(original.Required, original.Methods)
require.NoError(t, err)
})

require.NoError(t, SetInvitationCodeMethodsJSON(`["github","custom_oauth"]`))
assert.Equal(t, []string{"custom_oauth", "github"}, GetInvitationCodeMethods())
require.Error(t, SetInvitationCodeMethodsJSON(`["github","unknown"]`))
assert.Equal(t, []string{"custom_oauth", "github"}, GetInvitationCodeMethods())
}

func TestApplyInvitationCodeSettingsRejectsRequiredWithoutMethodsAndPreservesState(t *testing.T) {
original := GetInvitationCodeSettings()
t.Cleanup(func() {
_, err := ApplyInvitationCodeSettings(original.Required, original.Methods)
require.NoError(t, err)
})

before, err := ApplyInvitationCodeSettings(false, []string{InvitationRegistrationMethodGitHub})
require.NoError(t, err)

_, err = ApplyInvitationCodeSettings(true, nil)
require.Error(t, err)
assert.Equal(t, before, GetInvitationCodeSettings())
}

func TestInvitationCodeSettingsRequiresNormalizesMethod(t *testing.T) {
settings := InvitationCodeSettings{
Required: true,
Methods: []string{InvitationRegistrationMethodPassword, InvitationRegistrationMethodLinuxDO},
}
assert.True(t, settings.Requires(" PASSWORD "))
assert.True(t, settings.Requires("LinuxDO"))
assert.False(t, settings.Requires(InvitationRegistrationMethodGitHub))
settings.Required = false
assert.False(t, settings.Requires(InvitationRegistrationMethodPassword))
}

func TestNormalizeInvitationCodeSettingsRejectsUnknownMethod(t *testing.T) {
_, err := NormalizeInvitationCodeSettings(false, []string{"github", "unknown"})
require.Error(t, err)
}

func TestInvitationCodeSettingsAllowDisabledWithExplicitEmptyMethods(t *testing.T) {
original := GetInvitationCodeSettings()
t.Cleanup(func() {
_, err := ApplyInvitationCodeSettings(original.Required, original.Methods)
require.NoError(t, err)
})

settings, err := ApplyInvitationCodeSettings(false, []string{})
require.NoError(t, err)
assert.False(t, settings.Required)
assert.Empty(t, settings.Methods)
assert.Equal(t, settings, GetInvitationCodeSettings())
}
7 changes: 6 additions & 1 deletion controller/audit.go
Original file line number Diff line number Diff line change
Expand Up @@ -45,7 +45,12 @@ var auditContentTemplates = map[string]string{
"channel.upstream_apply": "Applied upstream model changes to channel (ID: ${id})",
"channel.upstream_apply_all": "Applied upstream model changes to ${count} channels",

"redemption.create": "Created ${count} redemption codes named ${name} (${quota} each)",
"redemption.create": "Created ${count} redemption codes named ${name} (${quota} each)",
"invitation.create": "Created ${count} invitation codes named ${name}",
"invitation.update": "Updated invitation code ${id}",
"invitation.status_update": "Updated invitation code ${id} status to ${status}",
"invitation.delete": "Deleted invitation code ${id}",
"invitation.delete_used": "Deleted ${count} used invitation codes",

"subscription.plan_reset": "Reset active subscriptions for plan ${plan_id}",
"subscription.user_plan_reset": "Reset active plan ${plan_id} subscriptions for user ${target_user_id}",
Expand Down
2 changes: 2 additions & 0 deletions controller/custom_oauth.go
Original file line number Diff line number Diff line change
Expand Up @@ -217,6 +217,7 @@ func CreateCustomOAuthProvider(c *gin.Context) {
common.ApiErrorMsg(c, "无效的请求参数: "+err.Error())
return
}
req.Slug = model.NormalizeCustomOAuthProviderSlug(req.Slug)

// Check if slug is already taken
if model.IsSlugTaken(req.Slug, 0) {
Expand Down Expand Up @@ -302,6 +303,7 @@ func UpdateCustomOAuthProvider(c *gin.Context) {
common.ApiErrorMsg(c, "无效的请求参数: "+err.Error())
return
}
req.Slug = model.NormalizeCustomOAuthProviderSlug(req.Slug)

// Get existing provider
provider, err := model.GetCustomOAuthProviderById(id)
Expand Down
Loading