1493 lines
47 KiB
Go
1493 lines
47 KiB
Go
//go:build unit
|
|
|
|
package server_test
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"errors"
|
|
"io"
|
|
"math"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"sort"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/Wei-Shaw/sub2api/internal/config"
|
|
"github.com/Wei-Shaw/sub2api/internal/handler"
|
|
adminhandler "github.com/Wei-Shaw/sub2api/internal/handler/admin"
|
|
"github.com/Wei-Shaw/sub2api/internal/pkg/pagination"
|
|
"github.com/Wei-Shaw/sub2api/internal/pkg/usagestats"
|
|
"github.com/Wei-Shaw/sub2api/internal/server/middleware"
|
|
"github.com/Wei-Shaw/sub2api/internal/service"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestAPIContracts(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
|
|
tests := []struct {
|
|
name string
|
|
setup func(t *testing.T, deps *contractDeps)
|
|
method string
|
|
path string
|
|
body string
|
|
headers map[string]string
|
|
wantStatus int
|
|
wantJSON string
|
|
}{
|
|
{
|
|
name: "GET /api/v1/auth/me",
|
|
method: http.MethodGet,
|
|
path: "/api/v1/auth/me",
|
|
wantStatus: http.StatusOK,
|
|
wantJSON: `{
|
|
"code": 0,
|
|
"message": "success",
|
|
"data": {
|
|
"id": 1,
|
|
"email": "alice@example.com",
|
|
"username": "alice",
|
|
"notes": "hello",
|
|
"role": "user",
|
|
"balance": 12.5,
|
|
"concurrency": 5,
|
|
"status": "active",
|
|
"allowed_groups": null,
|
|
"created_at": "2025-01-02T03:04:05Z",
|
|
"updated_at": "2025-01-02T03:04:05Z",
|
|
"run_mode": "standard"
|
|
}
|
|
}`,
|
|
},
|
|
{
|
|
name: "POST /api/v1/keys",
|
|
method: http.MethodPost,
|
|
path: "/api/v1/keys",
|
|
body: `{"name":"Key One","custom_key":"sk_custom_1234567890"}`,
|
|
headers: map[string]string{
|
|
"Content-Type": "application/json",
|
|
},
|
|
wantStatus: http.StatusOK,
|
|
wantJSON: `{
|
|
"code": 0,
|
|
"message": "success",
|
|
"data": {
|
|
"id": 100,
|
|
"user_id": 1,
|
|
"key": "sk_custom_1234567890",
|
|
"name": "Key One",
|
|
"group_id": null,
|
|
"status": "active",
|
|
"ip_whitelist": null,
|
|
"ip_blacklist": null,
|
|
"created_at": "2025-01-02T03:04:05Z",
|
|
"updated_at": "2025-01-02T03:04:05Z"
|
|
}
|
|
}`,
|
|
},
|
|
{
|
|
name: "GET /api/v1/keys (paginated)",
|
|
setup: func(t *testing.T, deps *contractDeps) {
|
|
t.Helper()
|
|
deps.apiKeyRepo.MustSeed(&service.APIKey{
|
|
ID: 100,
|
|
UserID: 1,
|
|
Key: "sk_custom_1234567890",
|
|
Name: "Key One",
|
|
Status: service.StatusActive,
|
|
CreatedAt: deps.now,
|
|
UpdatedAt: deps.now,
|
|
})
|
|
},
|
|
method: http.MethodGet,
|
|
path: "/api/v1/keys?page=1&page_size=10",
|
|
wantStatus: http.StatusOK,
|
|
wantJSON: `{
|
|
"code": 0,
|
|
"message": "success",
|
|
"data": {
|
|
"items": [
|
|
{
|
|
"id": 100,
|
|
"user_id": 1,
|
|
"key": "sk_custom_1234567890",
|
|
"name": "Key One",
|
|
"group_id": null,
|
|
"status": "active",
|
|
"ip_whitelist": null,
|
|
"ip_blacklist": null,
|
|
"created_at": "2025-01-02T03:04:05Z",
|
|
"updated_at": "2025-01-02T03:04:05Z"
|
|
}
|
|
],
|
|
"total": 1,
|
|
"page": 1,
|
|
"page_size": 10,
|
|
"pages": 1
|
|
}
|
|
}`,
|
|
},
|
|
{
|
|
name: "GET /api/v1/usage/stats",
|
|
setup: func(t *testing.T, deps *contractDeps) {
|
|
t.Helper()
|
|
deps.usageRepo.SetUserLogs(1, []service.UsageLog{
|
|
{
|
|
ID: 1,
|
|
UserID: 1,
|
|
APIKeyID: 100,
|
|
AccountID: 200,
|
|
Model: "claude-3",
|
|
InputTokens: 10,
|
|
OutputTokens: 20,
|
|
CacheCreationTokens: 1,
|
|
CacheReadTokens: 2,
|
|
TotalCost: 0.5,
|
|
ActualCost: 0.5,
|
|
DurationMs: ptr(100),
|
|
CreatedAt: deps.now,
|
|
},
|
|
{
|
|
ID: 2,
|
|
UserID: 1,
|
|
APIKeyID: 100,
|
|
AccountID: 200,
|
|
Model: "claude-3",
|
|
InputTokens: 5,
|
|
OutputTokens: 15,
|
|
TotalCost: 0.25,
|
|
ActualCost: 0.25,
|
|
DurationMs: ptr(300),
|
|
CreatedAt: deps.now,
|
|
},
|
|
})
|
|
},
|
|
method: http.MethodGet,
|
|
path: "/api/v1/usage/stats?start_date=2025-01-01&end_date=2025-01-02",
|
|
wantStatus: http.StatusOK,
|
|
wantJSON: `{
|
|
"code": 0,
|
|
"message": "success",
|
|
"data": {
|
|
"total_requests": 2,
|
|
"total_input_tokens": 15,
|
|
"total_output_tokens": 35,
|
|
"total_cache_tokens": 3,
|
|
"total_tokens": 53,
|
|
"total_cost": 0.75,
|
|
"total_actual_cost": 0.75,
|
|
"average_duration_ms": 200
|
|
}
|
|
}`,
|
|
},
|
|
{
|
|
name: "GET /api/v1/usage (paginated)",
|
|
setup: func(t *testing.T, deps *contractDeps) {
|
|
t.Helper()
|
|
deps.usageRepo.SetUserLogs(1, []service.UsageLog{
|
|
{
|
|
ID: 1,
|
|
UserID: 1,
|
|
APIKeyID: 100,
|
|
AccountID: 200,
|
|
RequestID: "req_123",
|
|
Model: "claude-3",
|
|
InputTokens: 10,
|
|
OutputTokens: 20,
|
|
CacheCreationTokens: 1,
|
|
CacheReadTokens: 2,
|
|
TotalCost: 0.5,
|
|
ActualCost: 0.5,
|
|
RateMultiplier: 1,
|
|
BillingType: service.BillingTypeBalance,
|
|
Stream: true,
|
|
DurationMs: ptr(100),
|
|
FirstTokenMs: ptr(50),
|
|
CreatedAt: deps.now,
|
|
},
|
|
})
|
|
},
|
|
method: http.MethodGet,
|
|
path: "/api/v1/usage?page=1&page_size=10",
|
|
wantStatus: http.StatusOK,
|
|
wantJSON: `{
|
|
"code": 0,
|
|
"message": "success",
|
|
"data": {
|
|
"items": [
|
|
{
|
|
"id": 1,
|
|
"user_id": 1,
|
|
"api_key_id": 100,
|
|
"account_id": 200,
|
|
"request_id": "req_123",
|
|
"model": "claude-3",
|
|
"group_id": null,
|
|
"subscription_id": null,
|
|
"input_tokens": 10,
|
|
"output_tokens": 20,
|
|
"cache_creation_tokens": 1,
|
|
"cache_read_tokens": 2,
|
|
"cache_creation_5m_tokens": 0,
|
|
"cache_creation_1h_tokens": 0,
|
|
"input_cost": 0,
|
|
"output_cost": 0,
|
|
"cache_creation_cost": 0,
|
|
"cache_read_cost": 0,
|
|
"total_cost": 0.5,
|
|
"actual_cost": 0.5,
|
|
"rate_multiplier": 1,
|
|
"account_rate_multiplier": null,
|
|
"billing_type": 0,
|
|
"stream": true,
|
|
"duration_ms": 100,
|
|
"first_token_ms": 50,
|
|
"image_count": 0,
|
|
"image_size": null,
|
|
"created_at": "2025-01-02T03:04:05Z",
|
|
"user_agent": null
|
|
}
|
|
],
|
|
"total": 1,
|
|
"page": 1,
|
|
"page_size": 10,
|
|
"pages": 1
|
|
}
|
|
}`,
|
|
},
|
|
{
|
|
name: "GET /api/v1/admin/settings",
|
|
setup: func(t *testing.T, deps *contractDeps) {
|
|
t.Helper()
|
|
deps.settingRepo.SetAll(map[string]string{
|
|
service.SettingKeyRegistrationEnabled: "true",
|
|
service.SettingKeyEmailVerifyEnabled: "false",
|
|
|
|
service.SettingKeySMTPHost: "smtp.example.com",
|
|
service.SettingKeySMTPPort: "587",
|
|
service.SettingKeySMTPUsername: "user",
|
|
service.SettingKeySMTPPassword: "secret",
|
|
service.SettingKeySMTPFrom: "no-reply@example.com",
|
|
service.SettingKeySMTPFromName: "Sub2API",
|
|
service.SettingKeySMTPUseTLS: "true",
|
|
|
|
service.SettingKeyTurnstileEnabled: "true",
|
|
service.SettingKeyTurnstileSiteKey: "site-key",
|
|
service.SettingKeyTurnstileSecretKey: "secret-key",
|
|
|
|
service.SettingKeySiteName: "Sub2API",
|
|
service.SettingKeySiteLogo: "",
|
|
service.SettingKeySiteSubtitle: "Subtitle",
|
|
service.SettingKeyAPIBaseURL: "https://api.example.com",
|
|
service.SettingKeyContactInfo: "support",
|
|
service.SettingKeyDocURL: "https://docs.example.com",
|
|
|
|
service.SettingKeyDefaultConcurrency: "5",
|
|
service.SettingKeyDefaultBalance: "1.25",
|
|
|
|
service.SettingKeyOpsMonitoringEnabled: "false",
|
|
service.SettingKeyOpsRealtimeMonitoringEnabled: "true",
|
|
service.SettingKeyOpsQueryModeDefault: "auto",
|
|
service.SettingKeyOpsMetricsIntervalSeconds: "60",
|
|
})
|
|
},
|
|
method: http.MethodGet,
|
|
path: "/api/v1/admin/settings",
|
|
wantStatus: http.StatusOK,
|
|
wantJSON: `{
|
|
"code": 0,
|
|
"message": "success",
|
|
"data": {
|
|
"registration_enabled": true,
|
|
"email_verify_enabled": false,
|
|
"smtp_host": "smtp.example.com",
|
|
"smtp_port": 587,
|
|
"smtp_username": "user",
|
|
"smtp_password_configured": true,
|
|
"smtp_from_email": "no-reply@example.com",
|
|
"smtp_from_name": "Sub2API",
|
|
"smtp_use_tls": true,
|
|
"turnstile_enabled": true,
|
|
"turnstile_site_key": "site-key",
|
|
"turnstile_secret_key_configured": true,
|
|
"linuxdo_connect_enabled": false,
|
|
"linuxdo_connect_client_id": "",
|
|
"linuxdo_connect_client_secret_configured": false,
|
|
"linuxdo_connect_redirect_url": "",
|
|
"ops_monitoring_enabled": false,
|
|
"ops_realtime_monitoring_enabled": true,
|
|
"ops_query_mode_default": "auto",
|
|
"ops_metrics_interval_seconds": 60,
|
|
"site_name": "Sub2API",
|
|
"site_logo": "",
|
|
"site_subtitle": "Subtitle",
|
|
"api_base_url": "https://api.example.com",
|
|
"contact_info": "support",
|
|
"doc_url": "https://docs.example.com",
|
|
"default_concurrency": 5,
|
|
"default_balance": 1.25,
|
|
"enable_model_fallback": false,
|
|
"fallback_model_anthropic": "claude-3-5-sonnet-20241022",
|
|
"fallback_model_antigravity": "gemini-2.5-pro",
|
|
"fallback_model_gemini": "gemini-2.5-pro",
|
|
"fallback_model_openai": "gpt-4o",
|
|
"enable_identity_patch": true,
|
|
"identity_patch_prompt": "",
|
|
"home_content": ""
|
|
}
|
|
}`,
|
|
},
|
|
{
|
|
name: "POST /api/v1/admin/accounts/bulk-update",
|
|
method: http.MethodPost,
|
|
path: "/api/v1/admin/accounts/bulk-update",
|
|
body: `{"account_ids":[101,102],"schedulable":false}`,
|
|
headers: map[string]string{
|
|
"Content-Type": "application/json",
|
|
},
|
|
wantStatus: http.StatusOK,
|
|
wantJSON: `{
|
|
"code": 0,
|
|
"message": "success",
|
|
"data": {
|
|
"success": 2,
|
|
"failed": 0,
|
|
"success_ids": [101, 102],
|
|
"failed_ids": [],
|
|
"results": [
|
|
{"account_id": 101, "success": true},
|
|
{"account_id": 102, "success": true}
|
|
]
|
|
}
|
|
}`,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
deps := newContractDeps(t)
|
|
if tt.setup != nil {
|
|
tt.setup(t, deps)
|
|
}
|
|
|
|
status, body := doRequest(t, deps.router, tt.method, tt.path, tt.body, tt.headers)
|
|
require.Equal(t, tt.wantStatus, status)
|
|
require.JSONEq(t, tt.wantJSON, body)
|
|
})
|
|
}
|
|
}
|
|
|
|
type contractDeps struct {
|
|
now time.Time
|
|
router http.Handler
|
|
apiKeyRepo *stubApiKeyRepo
|
|
usageRepo *stubUsageLogRepo
|
|
settingRepo *stubSettingRepo
|
|
}
|
|
|
|
func newContractDeps(t *testing.T) *contractDeps {
|
|
t.Helper()
|
|
|
|
now := time.Date(2025, 1, 2, 3, 4, 5, 0, time.UTC)
|
|
|
|
userRepo := &stubUserRepo{
|
|
users: map[int64]*service.User{
|
|
1: {
|
|
ID: 1,
|
|
Email: "alice@example.com",
|
|
Username: "alice",
|
|
Notes: "hello",
|
|
Role: service.RoleUser,
|
|
Balance: 12.5,
|
|
Concurrency: 5,
|
|
Status: service.StatusActive,
|
|
AllowedGroups: nil,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
},
|
|
},
|
|
}
|
|
|
|
apiKeyRepo := newStubApiKeyRepo(now)
|
|
apiKeyCache := stubApiKeyCache{}
|
|
groupRepo := stubGroupRepo{}
|
|
userSubRepo := stubUserSubscriptionRepo{}
|
|
accountRepo := stubAccountRepo{}
|
|
proxyRepo := stubProxyRepo{}
|
|
redeemRepo := stubRedeemCodeRepo{}
|
|
|
|
cfg := &config.Config{
|
|
Default: config.DefaultConfig{
|
|
APIKeyPrefix: "sk-",
|
|
},
|
|
RunMode: config.RunModeStandard,
|
|
}
|
|
|
|
userService := service.NewUserService(userRepo, nil)
|
|
apiKeyService := service.NewAPIKeyService(apiKeyRepo, userRepo, groupRepo, userSubRepo, apiKeyCache, cfg)
|
|
|
|
usageRepo := newStubUsageLogRepo()
|
|
usageService := service.NewUsageService(usageRepo, userRepo, nil, nil)
|
|
|
|
settingRepo := newStubSettingRepo()
|
|
settingService := service.NewSettingService(settingRepo, cfg)
|
|
|
|
adminService := service.NewAdminService(userRepo, groupRepo, &accountRepo, proxyRepo, apiKeyRepo, redeemRepo, nil, nil, nil, nil)
|
|
authHandler := handler.NewAuthHandler(cfg, nil, userService, settingService, nil)
|
|
apiKeyHandler := handler.NewAPIKeyHandler(apiKeyService)
|
|
usageHandler := handler.NewUsageHandler(usageService, apiKeyService)
|
|
adminSettingHandler := adminhandler.NewSettingHandler(settingService, nil, nil, nil)
|
|
adminAccountHandler := adminhandler.NewAccountHandler(adminService, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
|
|
|
|
jwtAuth := func(c *gin.Context) {
|
|
c.Set(string(middleware.ContextKeyUser), middleware.AuthSubject{
|
|
UserID: 1,
|
|
Concurrency: 5,
|
|
})
|
|
c.Set(string(middleware.ContextKeyUserRole), service.RoleUser)
|
|
c.Next()
|
|
}
|
|
adminAuth := func(c *gin.Context) {
|
|
c.Set(string(middleware.ContextKeyUser), middleware.AuthSubject{
|
|
UserID: 1,
|
|
Concurrency: 5,
|
|
})
|
|
c.Set(string(middleware.ContextKeyUserRole), service.RoleAdmin)
|
|
c.Next()
|
|
}
|
|
|
|
r := gin.New()
|
|
|
|
v1 := r.Group("/api/v1")
|
|
|
|
v1Auth := v1.Group("")
|
|
v1Auth.Use(jwtAuth)
|
|
v1Auth.GET("/auth/me", authHandler.GetCurrentUser)
|
|
|
|
v1Keys := v1.Group("")
|
|
v1Keys.Use(jwtAuth)
|
|
v1Keys.GET("/keys", apiKeyHandler.List)
|
|
v1Keys.POST("/keys", apiKeyHandler.Create)
|
|
|
|
v1Usage := v1.Group("")
|
|
v1Usage.Use(jwtAuth)
|
|
v1Usage.GET("/usage", usageHandler.List)
|
|
v1Usage.GET("/usage/stats", usageHandler.Stats)
|
|
|
|
v1Admin := v1.Group("/admin")
|
|
v1Admin.Use(adminAuth)
|
|
v1Admin.GET("/settings", adminSettingHandler.GetSettings)
|
|
v1Admin.POST("/accounts/bulk-update", adminAccountHandler.BulkUpdate)
|
|
|
|
return &contractDeps{
|
|
now: now,
|
|
router: r,
|
|
apiKeyRepo: apiKeyRepo,
|
|
usageRepo: usageRepo,
|
|
settingRepo: settingRepo,
|
|
}
|
|
}
|
|
|
|
func doRequest(t *testing.T, router http.Handler, method, path, body string, headers map[string]string) (int, string) {
|
|
t.Helper()
|
|
|
|
req := httptest.NewRequest(method, path, bytes.NewBufferString(body))
|
|
for k, v := range headers {
|
|
req.Header.Set(k, v)
|
|
}
|
|
|
|
w := httptest.NewRecorder()
|
|
router.ServeHTTP(w, req)
|
|
|
|
respBody, err := io.ReadAll(w.Result().Body)
|
|
require.NoError(t, err)
|
|
|
|
return w.Result().StatusCode, string(respBody)
|
|
}
|
|
|
|
func ptr[T any](v T) *T { return &v }
|
|
|
|
type stubUserRepo struct {
|
|
users map[int64]*service.User
|
|
}
|
|
|
|
func (r *stubUserRepo) Create(ctx context.Context, user *service.User) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUserRepo) GetByID(ctx context.Context, id int64) (*service.User, error) {
|
|
user, ok := r.users[id]
|
|
if !ok {
|
|
return nil, service.ErrUserNotFound
|
|
}
|
|
clone := *user
|
|
return &clone, nil
|
|
}
|
|
|
|
func (r *stubUserRepo) GetByEmail(ctx context.Context, email string) (*service.User, error) {
|
|
for _, user := range r.users {
|
|
if user.Email == email {
|
|
clone := *user
|
|
return &clone, nil
|
|
}
|
|
}
|
|
return nil, service.ErrUserNotFound
|
|
}
|
|
|
|
func (r *stubUserRepo) GetFirstAdmin(ctx context.Context) (*service.User, error) {
|
|
for _, user := range r.users {
|
|
if user.Role == service.RoleAdmin && user.Status == service.StatusActive {
|
|
clone := *user
|
|
return &clone, nil
|
|
}
|
|
}
|
|
return nil, service.ErrUserNotFound
|
|
}
|
|
|
|
func (r *stubUserRepo) Update(ctx context.Context, user *service.User) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUserRepo) Delete(ctx context.Context, id int64) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUserRepo) List(ctx context.Context, params pagination.PaginationParams) ([]service.User, *pagination.PaginationResult, error) {
|
|
return nil, nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUserRepo) ListWithFilters(ctx context.Context, params pagination.PaginationParams, filters service.UserListFilters) ([]service.User, *pagination.PaginationResult, error) {
|
|
return nil, nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUserRepo) UpdateBalance(ctx context.Context, id int64, amount float64) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUserRepo) DeductBalance(ctx context.Context, id int64, amount float64) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUserRepo) UpdateConcurrency(ctx context.Context, id int64, amount int) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUserRepo) ExistsByEmail(ctx context.Context, email string) (bool, error) {
|
|
return false, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUserRepo) RemoveGroupFromAllowedGroups(ctx context.Context, groupID int64) (int64, error) {
|
|
return 0, errors.New("not implemented")
|
|
}
|
|
|
|
type stubApiKeyCache struct{}
|
|
|
|
func (stubApiKeyCache) GetCreateAttemptCount(ctx context.Context, userID int64) (int, error) {
|
|
return 0, nil
|
|
}
|
|
|
|
func (stubApiKeyCache) IncrementCreateAttemptCount(ctx context.Context, userID int64) error {
|
|
return nil
|
|
}
|
|
|
|
func (stubApiKeyCache) DeleteCreateAttemptCount(ctx context.Context, userID int64) error {
|
|
return nil
|
|
}
|
|
|
|
func (stubApiKeyCache) IncrementDailyUsage(ctx context.Context, apiKey string) error {
|
|
return nil
|
|
}
|
|
|
|
func (stubApiKeyCache) SetDailyUsageExpiry(ctx context.Context, apiKey string, ttl time.Duration) error {
|
|
return nil
|
|
}
|
|
|
|
func (stubApiKeyCache) GetAuthCache(ctx context.Context, key string) (*service.APIKeyAuthCacheEntry, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func (stubApiKeyCache) SetAuthCache(ctx context.Context, key string, entry *service.APIKeyAuthCacheEntry, ttl time.Duration) error {
|
|
return nil
|
|
}
|
|
|
|
func (stubApiKeyCache) DeleteAuthCache(ctx context.Context, key string) error {
|
|
return nil
|
|
}
|
|
|
|
type stubGroupRepo struct{}
|
|
|
|
func (stubGroupRepo) Create(ctx context.Context, group *service.Group) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (stubGroupRepo) GetByID(ctx context.Context, id int64) (*service.Group, error) {
|
|
return nil, service.ErrGroupNotFound
|
|
}
|
|
|
|
func (stubGroupRepo) GetByIDLite(ctx context.Context, id int64) (*service.Group, error) {
|
|
return nil, service.ErrGroupNotFound
|
|
}
|
|
|
|
func (stubGroupRepo) Update(ctx context.Context, group *service.Group) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (stubGroupRepo) Delete(ctx context.Context, id int64) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (stubGroupRepo) DeleteCascade(ctx context.Context, id int64) ([]int64, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (stubGroupRepo) List(ctx context.Context, params pagination.PaginationParams) ([]service.Group, *pagination.PaginationResult, error) {
|
|
return nil, nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (stubGroupRepo) ListWithFilters(ctx context.Context, params pagination.PaginationParams, platform, status, search string, isExclusive *bool) ([]service.Group, *pagination.PaginationResult, error) {
|
|
return nil, nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (stubGroupRepo) ListActive(ctx context.Context) ([]service.Group, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (stubGroupRepo) ListActiveByPlatform(ctx context.Context, platform string) ([]service.Group, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (stubGroupRepo) ExistsByName(ctx context.Context, name string) (bool, error) {
|
|
return false, errors.New("not implemented")
|
|
}
|
|
|
|
func (stubGroupRepo) GetAccountCount(ctx context.Context, groupID int64) (int64, error) {
|
|
return 0, errors.New("not implemented")
|
|
}
|
|
|
|
func (stubGroupRepo) DeleteAccountGroupsByGroupID(ctx context.Context, groupID int64) (int64, error) {
|
|
return 0, errors.New("not implemented")
|
|
}
|
|
|
|
type stubAccountRepo struct {
|
|
bulkUpdateIDs []int64
|
|
}
|
|
|
|
func (s *stubAccountRepo) Create(ctx context.Context, account *service.Account) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) GetByID(ctx context.Context, id int64) (*service.Account, error) {
|
|
return nil, service.ErrAccountNotFound
|
|
}
|
|
|
|
func (s *stubAccountRepo) GetByIDs(ctx context.Context, ids []int64) ([]*service.Account, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) ExistsByID(ctx context.Context, id int64) (bool, error) {
|
|
return false, errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) GetByCRSAccountID(ctx context.Context, crsAccountID string) (*service.Account, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) Update(ctx context.Context, account *service.Account) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) Delete(ctx context.Context, id int64) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) List(ctx context.Context, params pagination.PaginationParams) ([]service.Account, *pagination.PaginationResult, error) {
|
|
return nil, nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) ListWithFilters(ctx context.Context, params pagination.PaginationParams, platform, accountType, status, search string) ([]service.Account, *pagination.PaginationResult, error) {
|
|
return nil, nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) ListByGroup(ctx context.Context, groupID int64) ([]service.Account, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) ListActive(ctx context.Context) ([]service.Account, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) ListByPlatform(ctx context.Context, platform string) ([]service.Account, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) UpdateLastUsed(ctx context.Context, id int64) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) BatchUpdateLastUsed(ctx context.Context, updates map[int64]time.Time) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) SetError(ctx context.Context, id int64, errorMsg string) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) SetSchedulable(ctx context.Context, id int64, schedulable bool) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) AutoPauseExpiredAccounts(ctx context.Context, now time.Time) (int64, error) {
|
|
return 0, errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) BindGroups(ctx context.Context, accountID int64, groupIDs []int64) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) ListSchedulable(ctx context.Context) ([]service.Account, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) ListSchedulableByGroupID(ctx context.Context, groupID int64) ([]service.Account, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) ListSchedulableByPlatform(ctx context.Context, platform string) ([]service.Account, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) ListSchedulableByGroupIDAndPlatform(ctx context.Context, groupID int64, platform string) ([]service.Account, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) ListSchedulableByPlatforms(ctx context.Context, platforms []string) ([]service.Account, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) ListSchedulableByGroupIDAndPlatforms(ctx context.Context, groupID int64, platforms []string) ([]service.Account, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) SetRateLimited(ctx context.Context, id int64, resetAt time.Time) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) SetAntigravityQuotaScopeLimit(ctx context.Context, id int64, scope service.AntigravityQuotaScope, resetAt time.Time) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) SetModelRateLimit(ctx context.Context, id int64, scope string, resetAt time.Time) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) SetOverloaded(ctx context.Context, id int64, until time.Time) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) SetTempUnschedulable(ctx context.Context, id int64, until time.Time, reason string) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) ClearTempUnschedulable(ctx context.Context, id int64) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) ClearRateLimit(ctx context.Context, id int64) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) ClearAntigravityQuotaScopes(ctx context.Context, id int64) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) ClearModelRateLimits(ctx context.Context, id int64) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) UpdateSessionWindow(ctx context.Context, id int64, start, end *time.Time, status string) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) UpdateExtra(ctx context.Context, id int64, updates map[string]any) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (s *stubAccountRepo) BulkUpdate(ctx context.Context, ids []int64, updates service.AccountBulkUpdate) (int64, error) {
|
|
s.bulkUpdateIDs = append([]int64{}, ids...)
|
|
return int64(len(ids)), nil
|
|
}
|
|
|
|
type stubProxyRepo struct{}
|
|
|
|
func (stubProxyRepo) Create(ctx context.Context, proxy *service.Proxy) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (stubProxyRepo) GetByID(ctx context.Context, id int64) (*service.Proxy, error) {
|
|
return nil, service.ErrProxyNotFound
|
|
}
|
|
|
|
func (stubProxyRepo) Update(ctx context.Context, proxy *service.Proxy) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (stubProxyRepo) Delete(ctx context.Context, id int64) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (stubProxyRepo) List(ctx context.Context, params pagination.PaginationParams) ([]service.Proxy, *pagination.PaginationResult, error) {
|
|
return nil, nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (stubProxyRepo) ListWithFilters(ctx context.Context, params pagination.PaginationParams, protocol, status, search string) ([]service.Proxy, *pagination.PaginationResult, error) {
|
|
return nil, nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (stubProxyRepo) ListWithFiltersAndAccountCount(ctx context.Context, params pagination.PaginationParams, protocol, status, search string) ([]service.ProxyWithAccountCount, *pagination.PaginationResult, error) {
|
|
return nil, nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (stubProxyRepo) ListActive(ctx context.Context) ([]service.Proxy, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (stubProxyRepo) ListActiveWithAccountCount(ctx context.Context) ([]service.ProxyWithAccountCount, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (stubProxyRepo) ExistsByHostPortAuth(ctx context.Context, host string, port int, username, password string) (bool, error) {
|
|
return false, errors.New("not implemented")
|
|
}
|
|
|
|
func (stubProxyRepo) CountAccountsByProxyID(ctx context.Context, proxyID int64) (int64, error) {
|
|
return 0, errors.New("not implemented")
|
|
}
|
|
|
|
func (stubProxyRepo) ListAccountSummariesByProxyID(ctx context.Context, proxyID int64) ([]service.ProxyAccountSummary, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
type stubRedeemCodeRepo struct{}
|
|
|
|
func (stubRedeemCodeRepo) Create(ctx context.Context, code *service.RedeemCode) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (stubRedeemCodeRepo) CreateBatch(ctx context.Context, codes []service.RedeemCode) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (stubRedeemCodeRepo) GetByID(ctx context.Context, id int64) (*service.RedeemCode, error) {
|
|
return nil, service.ErrRedeemCodeNotFound
|
|
}
|
|
|
|
func (stubRedeemCodeRepo) GetByCode(ctx context.Context, code string) (*service.RedeemCode, error) {
|
|
return nil, service.ErrRedeemCodeNotFound
|
|
}
|
|
|
|
func (stubRedeemCodeRepo) Update(ctx context.Context, code *service.RedeemCode) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (stubRedeemCodeRepo) Delete(ctx context.Context, id int64) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (stubRedeemCodeRepo) Use(ctx context.Context, id, userID int64) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (stubRedeemCodeRepo) List(ctx context.Context, params pagination.PaginationParams) ([]service.RedeemCode, *pagination.PaginationResult, error) {
|
|
return nil, nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (stubRedeemCodeRepo) ListWithFilters(ctx context.Context, params pagination.PaginationParams, codeType, status, search string) ([]service.RedeemCode, *pagination.PaginationResult, error) {
|
|
return nil, nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (stubRedeemCodeRepo) ListByUser(ctx context.Context, userID int64, limit int) ([]service.RedeemCode, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
type stubUserSubscriptionRepo struct{}
|
|
|
|
func (stubUserSubscriptionRepo) Create(ctx context.Context, sub *service.UserSubscription) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
func (stubUserSubscriptionRepo) GetByID(ctx context.Context, id int64) (*service.UserSubscription, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
func (stubUserSubscriptionRepo) GetByUserIDAndGroupID(ctx context.Context, userID, groupID int64) (*service.UserSubscription, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
func (stubUserSubscriptionRepo) GetActiveByUserIDAndGroupID(ctx context.Context, userID, groupID int64) (*service.UserSubscription, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
func (stubUserSubscriptionRepo) Update(ctx context.Context, sub *service.UserSubscription) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
func (stubUserSubscriptionRepo) Delete(ctx context.Context, id int64) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
func (stubUserSubscriptionRepo) ListByUserID(ctx context.Context, userID int64) ([]service.UserSubscription, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
func (stubUserSubscriptionRepo) ListActiveByUserID(ctx context.Context, userID int64) ([]service.UserSubscription, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
func (stubUserSubscriptionRepo) ListByGroupID(ctx context.Context, groupID int64, params pagination.PaginationParams) ([]service.UserSubscription, *pagination.PaginationResult, error) {
|
|
return nil, nil, errors.New("not implemented")
|
|
}
|
|
func (stubUserSubscriptionRepo) List(ctx context.Context, params pagination.PaginationParams, userID, groupID *int64, status string) ([]service.UserSubscription, *pagination.PaginationResult, error) {
|
|
return nil, nil, errors.New("not implemented")
|
|
}
|
|
func (stubUserSubscriptionRepo) ExistsByUserIDAndGroupID(ctx context.Context, userID, groupID int64) (bool, error) {
|
|
return false, errors.New("not implemented")
|
|
}
|
|
func (stubUserSubscriptionRepo) ExtendExpiry(ctx context.Context, subscriptionID int64, newExpiresAt time.Time) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
func (stubUserSubscriptionRepo) UpdateStatus(ctx context.Context, subscriptionID int64, status string) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
func (stubUserSubscriptionRepo) UpdateNotes(ctx context.Context, subscriptionID int64, notes string) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
func (stubUserSubscriptionRepo) ActivateWindows(ctx context.Context, id int64, start time.Time) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
func (stubUserSubscriptionRepo) ResetDailyUsage(ctx context.Context, id int64, newWindowStart time.Time) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
func (stubUserSubscriptionRepo) ResetWeeklyUsage(ctx context.Context, id int64, newWindowStart time.Time) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
func (stubUserSubscriptionRepo) ResetMonthlyUsage(ctx context.Context, id int64, newWindowStart time.Time) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
func (stubUserSubscriptionRepo) IncrementUsage(ctx context.Context, id int64, costUSD float64) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
func (stubUserSubscriptionRepo) BatchUpdateExpiredStatus(ctx context.Context) (int64, error) {
|
|
return 0, errors.New("not implemented")
|
|
}
|
|
|
|
type stubApiKeyRepo struct {
|
|
now time.Time
|
|
|
|
nextID int64
|
|
byID map[int64]*service.APIKey
|
|
byKey map[string]*service.APIKey
|
|
}
|
|
|
|
func newStubApiKeyRepo(now time.Time) *stubApiKeyRepo {
|
|
return &stubApiKeyRepo{
|
|
now: now,
|
|
nextID: 100,
|
|
byID: make(map[int64]*service.APIKey),
|
|
byKey: make(map[string]*service.APIKey),
|
|
}
|
|
}
|
|
|
|
func (r *stubApiKeyRepo) MustSeed(key *service.APIKey) {
|
|
if key == nil {
|
|
return
|
|
}
|
|
clone := *key
|
|
r.byID[clone.ID] = &clone
|
|
r.byKey[clone.Key] = &clone
|
|
}
|
|
|
|
func (r *stubApiKeyRepo) Create(ctx context.Context, key *service.APIKey) error {
|
|
if key == nil {
|
|
return errors.New("nil key")
|
|
}
|
|
if key.ID == 0 {
|
|
key.ID = r.nextID
|
|
r.nextID++
|
|
}
|
|
if key.CreatedAt.IsZero() {
|
|
key.CreatedAt = r.now
|
|
}
|
|
if key.UpdatedAt.IsZero() {
|
|
key.UpdatedAt = r.now
|
|
}
|
|
clone := *key
|
|
r.byID[clone.ID] = &clone
|
|
r.byKey[clone.Key] = &clone
|
|
return nil
|
|
}
|
|
|
|
func (r *stubApiKeyRepo) GetByID(ctx context.Context, id int64) (*service.APIKey, error) {
|
|
key, ok := r.byID[id]
|
|
if !ok {
|
|
return nil, service.ErrAPIKeyNotFound
|
|
}
|
|
clone := *key
|
|
return &clone, nil
|
|
}
|
|
|
|
func (r *stubApiKeyRepo) GetKeyAndOwnerID(ctx context.Context, id int64) (string, int64, error) {
|
|
key, ok := r.byID[id]
|
|
if !ok {
|
|
return "", 0, service.ErrAPIKeyNotFound
|
|
}
|
|
return key.Key, key.UserID, nil
|
|
}
|
|
|
|
func (r *stubApiKeyRepo) GetByKey(ctx context.Context, key string) (*service.APIKey, error) {
|
|
found, ok := r.byKey[key]
|
|
if !ok {
|
|
return nil, service.ErrAPIKeyNotFound
|
|
}
|
|
clone := *found
|
|
return &clone, nil
|
|
}
|
|
|
|
func (r *stubApiKeyRepo) GetByKeyForAuth(ctx context.Context, key string) (*service.APIKey, error) {
|
|
return r.GetByKey(ctx, key)
|
|
}
|
|
|
|
func (r *stubApiKeyRepo) Update(ctx context.Context, key *service.APIKey) error {
|
|
if key == nil {
|
|
return errors.New("nil key")
|
|
}
|
|
if _, ok := r.byID[key.ID]; !ok {
|
|
return service.ErrAPIKeyNotFound
|
|
}
|
|
if key.UpdatedAt.IsZero() {
|
|
key.UpdatedAt = r.now
|
|
}
|
|
clone := *key
|
|
r.byID[clone.ID] = &clone
|
|
r.byKey[clone.Key] = &clone
|
|
return nil
|
|
}
|
|
|
|
func (r *stubApiKeyRepo) Delete(ctx context.Context, id int64) error {
|
|
key, ok := r.byID[id]
|
|
if !ok {
|
|
return service.ErrAPIKeyNotFound
|
|
}
|
|
delete(r.byID, id)
|
|
delete(r.byKey, key.Key)
|
|
return nil
|
|
}
|
|
|
|
func (r *stubApiKeyRepo) ListByUserID(ctx context.Context, userID int64, params pagination.PaginationParams) ([]service.APIKey, *pagination.PaginationResult, error) {
|
|
ids := make([]int64, 0, len(r.byID))
|
|
for id := range r.byID {
|
|
if r.byID[id].UserID == userID {
|
|
ids = append(ids, id)
|
|
}
|
|
}
|
|
sort.Slice(ids, func(i, j int) bool { return ids[i] > ids[j] })
|
|
|
|
start := params.Offset()
|
|
if start > len(ids) {
|
|
start = len(ids)
|
|
}
|
|
end := start + params.Limit()
|
|
if end > len(ids) {
|
|
end = len(ids)
|
|
}
|
|
|
|
out := make([]service.APIKey, 0, end-start)
|
|
for _, id := range ids[start:end] {
|
|
clone := *r.byID[id]
|
|
out = append(out, clone)
|
|
}
|
|
|
|
total := int64(len(ids))
|
|
pageSize := params.Limit()
|
|
pages := int(math.Ceil(float64(total) / float64(pageSize)))
|
|
if pages < 1 {
|
|
pages = 1
|
|
}
|
|
return out, &pagination.PaginationResult{
|
|
Total: total,
|
|
Page: params.Page,
|
|
PageSize: pageSize,
|
|
Pages: pages,
|
|
}, nil
|
|
}
|
|
|
|
func (r *stubApiKeyRepo) VerifyOwnership(ctx context.Context, userID int64, apiKeyIDs []int64) ([]int64, error) {
|
|
if len(apiKeyIDs) == 0 {
|
|
return []int64{}, nil
|
|
}
|
|
seen := make(map[int64]struct{}, len(apiKeyIDs))
|
|
out := make([]int64, 0, len(apiKeyIDs))
|
|
for _, id := range apiKeyIDs {
|
|
if _, ok := seen[id]; ok {
|
|
continue
|
|
}
|
|
seen[id] = struct{}{}
|
|
key, ok := r.byID[id]
|
|
if ok && key.UserID == userID {
|
|
out = append(out, id)
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (r *stubApiKeyRepo) CountByUserID(ctx context.Context, userID int64) (int64, error) {
|
|
var count int64
|
|
for _, key := range r.byID {
|
|
if key.UserID == userID {
|
|
count++
|
|
}
|
|
}
|
|
return count, nil
|
|
}
|
|
|
|
func (r *stubApiKeyRepo) ExistsByKey(ctx context.Context, key string) (bool, error) {
|
|
_, ok := r.byKey[key]
|
|
return ok, nil
|
|
}
|
|
|
|
func (r *stubApiKeyRepo) ListByGroupID(ctx context.Context, groupID int64, params pagination.PaginationParams) ([]service.APIKey, *pagination.PaginationResult, error) {
|
|
return nil, nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubApiKeyRepo) SearchAPIKeys(ctx context.Context, userID int64, keyword string, limit int) ([]service.APIKey, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubApiKeyRepo) ClearGroupIDByGroupID(ctx context.Context, groupID int64) (int64, error) {
|
|
return 0, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubApiKeyRepo) CountByGroupID(ctx context.Context, groupID int64) (int64, error) {
|
|
return 0, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubApiKeyRepo) ListKeysByUserID(ctx context.Context, userID int64) ([]string, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubApiKeyRepo) ListKeysByGroupID(ctx context.Context, groupID int64) ([]string, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
type stubUsageLogRepo struct {
|
|
userLogs map[int64][]service.UsageLog
|
|
}
|
|
|
|
func newStubUsageLogRepo() *stubUsageLogRepo {
|
|
return &stubUsageLogRepo{userLogs: make(map[int64][]service.UsageLog)}
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) SetUserLogs(userID int64, logs []service.UsageLog) {
|
|
r.userLogs[userID] = logs
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) Create(ctx context.Context, log *service.UsageLog) (bool, error) {
|
|
return false, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) GetByID(ctx context.Context, id int64) (*service.UsageLog, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) Delete(ctx context.Context, id int64) error {
|
|
return errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) ListByUser(ctx context.Context, userID int64, params pagination.PaginationParams) ([]service.UsageLog, *pagination.PaginationResult, error) {
|
|
logs := r.userLogs[userID]
|
|
total := int64(len(logs))
|
|
out := paginateLogs(logs, params)
|
|
return out, paginationResult(total, params), nil
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) ListByAPIKey(ctx context.Context, apiKeyID int64, params pagination.PaginationParams) ([]service.UsageLog, *pagination.PaginationResult, error) {
|
|
return nil, nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) ListByAccount(ctx context.Context, accountID int64, params pagination.PaginationParams) ([]service.UsageLog, *pagination.PaginationResult, error) {
|
|
return nil, nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) ListByUserAndTimeRange(ctx context.Context, userID int64, startTime, endTime time.Time) ([]service.UsageLog, *pagination.PaginationResult, error) {
|
|
logs := r.userLogs[userID]
|
|
return logs, paginationResult(int64(len(logs)), pagination.PaginationParams{Page: 1, PageSize: 100}), nil
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) ListByAPIKeyAndTimeRange(ctx context.Context, apiKeyID int64, startTime, endTime time.Time) ([]service.UsageLog, *pagination.PaginationResult, error) {
|
|
return nil, nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) ListByAccountAndTimeRange(ctx context.Context, accountID int64, startTime, endTime time.Time) ([]service.UsageLog, *pagination.PaginationResult, error) {
|
|
return nil, nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) ListByModelAndTimeRange(ctx context.Context, modelName string, startTime, endTime time.Time) ([]service.UsageLog, *pagination.PaginationResult, error) {
|
|
return nil, nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) GetAccountWindowStats(ctx context.Context, accountID int64, startTime time.Time) (*usagestats.AccountStats, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) GetAccountTodayStats(ctx context.Context, accountID int64) (*usagestats.AccountStats, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) GetDashboardStats(ctx context.Context) (*usagestats.DashboardStats, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) GetUsageTrendWithFilters(ctx context.Context, startTime, endTime time.Time, granularity string, userID, apiKeyID, accountID, groupID int64, model string, stream *bool) ([]usagestats.TrendDataPoint, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) GetModelStatsWithFilters(ctx context.Context, startTime, endTime time.Time, userID, apiKeyID, accountID, groupID int64, stream *bool) ([]usagestats.ModelStat, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) GetAPIKeyUsageTrend(ctx context.Context, startTime, endTime time.Time, granularity string, limit int) ([]usagestats.APIKeyUsageTrendPoint, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) GetUserUsageTrend(ctx context.Context, startTime, endTime time.Time, granularity string, limit int) ([]usagestats.UserUsageTrendPoint, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) GetUserStatsAggregated(ctx context.Context, userID int64, startTime, endTime time.Time) (*usagestats.UsageStats, error) {
|
|
logs := r.userLogs[userID]
|
|
if len(logs) == 0 {
|
|
return &usagestats.UsageStats{}, nil
|
|
}
|
|
|
|
var totalRequests int64
|
|
var totalInputTokens int64
|
|
var totalOutputTokens int64
|
|
var totalCacheTokens int64
|
|
var totalCost float64
|
|
var totalActualCost float64
|
|
var totalDuration int64
|
|
var durationCount int64
|
|
|
|
for _, log := range logs {
|
|
totalRequests++
|
|
totalInputTokens += int64(log.InputTokens)
|
|
totalOutputTokens += int64(log.OutputTokens)
|
|
totalCacheTokens += int64(log.CacheCreationTokens + log.CacheReadTokens)
|
|
totalCost += log.TotalCost
|
|
totalActualCost += log.ActualCost
|
|
if log.DurationMs != nil {
|
|
totalDuration += int64(*log.DurationMs)
|
|
durationCount++
|
|
}
|
|
}
|
|
|
|
var avgDuration float64
|
|
if durationCount > 0 {
|
|
avgDuration = float64(totalDuration) / float64(durationCount)
|
|
}
|
|
|
|
return &usagestats.UsageStats{
|
|
TotalRequests: totalRequests,
|
|
TotalInputTokens: totalInputTokens,
|
|
TotalOutputTokens: totalOutputTokens,
|
|
TotalCacheTokens: totalCacheTokens,
|
|
TotalTokens: totalInputTokens + totalOutputTokens + totalCacheTokens,
|
|
TotalCost: totalCost,
|
|
TotalActualCost: totalActualCost,
|
|
AverageDurationMs: avgDuration,
|
|
}, nil
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) GetAPIKeyStatsAggregated(ctx context.Context, apiKeyID int64, startTime, endTime time.Time) (*usagestats.UsageStats, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) GetAccountStatsAggregated(ctx context.Context, accountID int64, startTime, endTime time.Time) (*usagestats.UsageStats, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) GetModelStatsAggregated(ctx context.Context, modelName string, startTime, endTime time.Time) (*usagestats.UsageStats, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) GetDailyStatsAggregated(ctx context.Context, userID int64, startTime, endTime time.Time) ([]map[string]any, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) GetBatchUserUsageStats(ctx context.Context, userIDs []int64) (map[int64]*usagestats.BatchUserUsageStats, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) GetBatchAPIKeyUsageStats(ctx context.Context, apiKeyIDs []int64) (map[int64]*usagestats.BatchAPIKeyUsageStats, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) GetUserDashboardStats(ctx context.Context, userID int64) (*usagestats.UserDashboardStats, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) GetUserUsageTrendByUserID(ctx context.Context, userID int64, startTime, endTime time.Time, granularity string) ([]usagestats.TrendDataPoint, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) GetUserModelStats(ctx context.Context, userID int64, startTime, endTime time.Time) ([]usagestats.ModelStat, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) ListWithFilters(ctx context.Context, params pagination.PaginationParams, filters usagestats.UsageLogFilters) ([]service.UsageLog, *pagination.PaginationResult, error) {
|
|
logs := r.userLogs[filters.UserID]
|
|
|
|
// Apply filters
|
|
var filtered []service.UsageLog
|
|
for _, log := range logs {
|
|
// Apply APIKeyID filter
|
|
if filters.APIKeyID > 0 && log.APIKeyID != filters.APIKeyID {
|
|
continue
|
|
}
|
|
// Apply Model filter
|
|
if filters.Model != "" && log.Model != filters.Model {
|
|
continue
|
|
}
|
|
// Apply Stream filter
|
|
if filters.Stream != nil && log.Stream != *filters.Stream {
|
|
continue
|
|
}
|
|
// Apply BillingType filter
|
|
if filters.BillingType != nil && log.BillingType != *filters.BillingType {
|
|
continue
|
|
}
|
|
// Apply time range filters
|
|
if filters.StartTime != nil && log.CreatedAt.Before(*filters.StartTime) {
|
|
continue
|
|
}
|
|
if filters.EndTime != nil && log.CreatedAt.After(*filters.EndTime) {
|
|
continue
|
|
}
|
|
filtered = append(filtered, log)
|
|
}
|
|
|
|
total := int64(len(filtered))
|
|
out := paginateLogs(filtered, params)
|
|
return out, paginationResult(total, params), nil
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) GetGlobalStats(ctx context.Context, startTime, endTime time.Time) (*usagestats.UsageStats, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) GetAccountUsageStats(ctx context.Context, accountID int64, startTime, endTime time.Time) (*usagestats.AccountUsageStatsResponse, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (r *stubUsageLogRepo) GetStatsWithFilters(ctx context.Context, filters usagestats.UsageLogFilters) (*usagestats.UsageStats, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
type stubSettingRepo struct {
|
|
all map[string]string
|
|
}
|
|
|
|
func newStubSettingRepo() *stubSettingRepo {
|
|
return &stubSettingRepo{all: make(map[string]string)}
|
|
}
|
|
|
|
func (r *stubSettingRepo) SetAll(values map[string]string) {
|
|
r.all = make(map[string]string, len(values))
|
|
for k, v := range values {
|
|
r.all[k] = v
|
|
}
|
|
}
|
|
|
|
func (r *stubSettingRepo) Get(ctx context.Context, key string) (*service.Setting, error) {
|
|
value, ok := r.all[key]
|
|
if !ok {
|
|
return nil, service.ErrSettingNotFound
|
|
}
|
|
return &service.Setting{Key: key, Value: value}, nil
|
|
}
|
|
|
|
func (r *stubSettingRepo) GetValue(ctx context.Context, key string) (string, error) {
|
|
value, ok := r.all[key]
|
|
if !ok {
|
|
return "", service.ErrSettingNotFound
|
|
}
|
|
return value, nil
|
|
}
|
|
|
|
func (r *stubSettingRepo) Set(ctx context.Context, key, value string) error {
|
|
r.all[key] = value
|
|
return nil
|
|
}
|
|
|
|
func (r *stubSettingRepo) GetMultiple(ctx context.Context, keys []string) (map[string]string, error) {
|
|
out := make(map[string]string, len(keys))
|
|
for _, key := range keys {
|
|
out[key] = r.all[key]
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (r *stubSettingRepo) SetMultiple(ctx context.Context, settings map[string]string) error {
|
|
for k, v := range settings {
|
|
r.all[k] = v
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (r *stubSettingRepo) GetAll(ctx context.Context) (map[string]string, error) {
|
|
out := make(map[string]string, len(r.all))
|
|
for k, v := range r.all {
|
|
out[k] = v
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (r *stubSettingRepo) Delete(ctx context.Context, key string) error {
|
|
delete(r.all, key)
|
|
return nil
|
|
}
|
|
|
|
func paginateLogs(logs []service.UsageLog, params pagination.PaginationParams) []service.UsageLog {
|
|
start := params.Offset()
|
|
if start > len(logs) {
|
|
start = len(logs)
|
|
}
|
|
end := start + params.Limit()
|
|
if end > len(logs) {
|
|
end = len(logs)
|
|
}
|
|
out := make([]service.UsageLog, 0, end-start)
|
|
out = append(out, logs[start:end]...)
|
|
return out
|
|
}
|
|
|
|
func paginationResult(total int64, params pagination.PaginationParams) *pagination.PaginationResult {
|
|
pageSize := params.Limit()
|
|
pages := int(math.Ceil(float64(total) / float64(pageSize)))
|
|
if pages < 1 {
|
|
pages = 1
|
|
}
|
|
return &pagination.PaginationResult{
|
|
Total: total,
|
|
Page: params.Page,
|
|
PageSize: pageSize,
|
|
Pages: pages,
|
|
}
|
|
}
|
|
|
|
// Ensure compile-time interface compliance.
|
|
var (
|
|
_ service.UserRepository = (*stubUserRepo)(nil)
|
|
_ service.APIKeyRepository = (*stubApiKeyRepo)(nil)
|
|
_ service.APIKeyCache = (*stubApiKeyCache)(nil)
|
|
_ service.GroupRepository = (*stubGroupRepo)(nil)
|
|
_ service.UserSubscriptionRepository = (*stubUserSubscriptionRepo)(nil)
|
|
_ service.UsageLogRepository = (*stubUsageLogRepo)(nil)
|
|
_ service.SettingRepository = (*stubSettingRepo)(nil)
|
|
)
|