refactor: complete backend rewrite for multi-protocol proxy

Major rewrite of the Go backend to support:
- Three API format imports: openai, anthropic, compatible
- Three protocol conversions: Chat Completions, Responses, Messages
- Hub-and-spoke architecture with Chat as intermediate format

Deleted:
- opencat.go (old entry)
- store/, team/, pkg/team/, pkg/store/ (old data layer)
- internal/model/, internal/consts/ (old types)
- internal/service/team/, internal/controller/team/ (old handlers)
- llm/ (removed LLM client library, pure proxy mode)
- dist/, assets/ (old build artifacts)

Added:
- internal/store/ — 9 GORM models + multi-DB support
- internal/pkg/ — crypto (AES-GCM), apikey, jwt, ratelimit, resp, tokenizer
- internal/channel/ — channel selection, weighted LB, health checks
- internal/proxy/convert/ — 6 protocol conversion functions + SSE streaming
- internal/proxy/ — gateway with request dispatch and upstream selection
- internal/usage/ — async usage recorder with batch writes
- internal/api/ — management API (auth, users, keys, channels, models)
- Makefile for build/test/deploy

Fixed API to match frontend expectations:
- Login response wraps token in { data: { token } }
- GET /api/profile route added
- Profile response wraps user in { code, data }
- Role returned as number (10=admin, 1=user)

internal/dao/apikey.go

@@ -2,189 +2,67 @@ package dao
 
 import (
 	"errors"
-	"opencatd-open/internal/model"
-	"opencatd-open/internal/utils"
-	"opencatd-open/pkg/config"
+	"opencatd-open/internal/store"
 
 	"gorm.io/gorm"
 )
 
-var _ ApiKeyRepository = (*ApiKeyDAO)(nil)
-
-type ApiKeyRepository interface {
-	Create(apiKey *model.ApiKey) error
-	GetByID(id int64) (*model.ApiKey, error)
-	GetByName(name string) (*model.ApiKey, error)
-	GetByApiKey(apiKeyValue string) (*model.ApiKey, error)
-	Update(apiKey *model.ApiKey) error
-	List(limit, offset int, status string) ([]*model.ApiKey, error)
-	ListWithFilters(limit, offset int, filters map[string]interface{}) ([]*model.ApiKey, int64, error)
-	BatchEnable(ids []int64) error
-	BatchDisable(ids []int64) error
-	BatchDelete(ids []int64) error
-	Count() (int64, error)
-}
-
 type ApiKeyDAO struct {
-	cfg *config.Config
-	db  *gorm.DB
+	db *gorm.DB
 }
 
-func NewApiKeyDAO(cfg *config.Config, db *gorm.DB) *ApiKeyDAO {
-	return &ApiKeyDAO{cfg: cfg, db: db}
+func NewApiKeyDAO(db *gorm.DB) *ApiKeyDAO {
+	return &ApiKeyDAO{db: db}
 }
 
-// CreateApiKey 创建ApiKey
-func (dao *ApiKeyDAO) Create(apiKey *model.ApiKey) error {
+func (d *ApiKeyDAO) Create(apiKey *store.APIKey) error {
 	if apiKey == nil {
 		return errors.New("apiKey is nil")
 	}
-	if len(*apiKey.SupportModels) < 2 {
-		apiKey.SupportModels = utils.ToPtr("[]")
-	}
-	return dao.db.Create(apiKey).Error
+	return d.db.Create(apiKey).Error
 }
 
-// GetApiKeyByID 根据ID获取ApiKey
-func (dao *ApiKeyDAO) GetByID(id int64) (*model.ApiKey, error) {
-	var apiKey model.ApiKey
-	err := dao.db.First(&apiKey, id).Error
+func (d *ApiKeyDAO) GetByID(id uint64) (*store.APIKey, error) {
+	var apiKey store.APIKey
+	err := d.db.First(&apiKey, id).Error
 	if err != nil {
 		return nil, err
 	}
 	return &apiKey, nil
 }
 
-// GetApiKeyByName 根据名称获取ApiKey
-func (dao *ApiKeyDAO) GetByName(name string) (*model.ApiKey, error) {
-	var apiKey model.ApiKey
-	err := dao.db.Where("name = ?", name).First(&apiKey).Error
+func (d *ApiKeyDAO) GetByHash(keyHash string) (*store.APIKey, error) {
+	var apiKey store.APIKey
+	err := d.db.Where("key_hash = ? AND status = ?", keyHash, store.KeyStatusActive).First(&apiKey).Error
 	if err != nil {
 		return nil, err
 	}
 	return &apiKey, nil
 }
 
-// GetApiKeyByApiKey 根据ApiKey值获取ApiKey
-func (dao *ApiKeyDAO) GetByApiKey(apiKeyValue string) (*model.ApiKey, error) {
-	var apiKey model.ApiKey
-	err := dao.db.Where("api_key = ?", apiKeyValue).First(&apiKey).Error
-	if err != nil {
-		return nil, err
-	}
-	return &apiKey, nil
-}
-
-func (dao *ApiKeyDAO) FindKeys(condition map[string]any) ([]model.ApiKey, error) {
-	var apiKeys []model.ApiKey
-
-	query := dao.db.Model(&model.ApiKey{})
-	for k, v := range condition {
-		query = query.Where(k, v)
-	}
-	err := query.Find(&apiKeys).Error
-
-	return apiKeys, err
-}
-
-func (dao *ApiKeyDAO) FindApiKeysBySupportModel(db *gorm.DB, modelName string) ([]model.ApiKey, error) {
-	var apiKeys []model.ApiKey
-	switch dao.cfg.DB_Type {
-	case "mysql":
-		err := db.Raw(`
-		SELECT *
-		FROM apikeys
-		WHERE active = true 
-      	AND JSON_CONTAINS(support_models, ?, '$')`, modelName).
-			Scan(&apiKeys).Error
-		return apiKeys, err
-	case "postgres":
-		return nil, errors.New("not support")
-	}
-	err := db.Raw(`
-    SELECT a.*
-    FROM apikeys a
-    JOIN json_each(a.support_models) AS je ON je.value = ?
-    WHERE a.active = true`, modelName).Scan(&apiKeys).Error
-	return apiKeys, err
-}
-
-// UpdateApiKey 更新ApiKey信息
-func (dao *ApiKeyDAO) Update(apiKey *model.ApiKey) error {
-	if apiKey == nil {
-		return errors.New("apiKey is nil")
-	}
-	// return dao.db.Model(&model.ApiKey{}).
-	// Select("name", "apitype", "apikey", "status", "endpoint", "resource_name", "deployment_name").Updates(apiKey).Error
-	return dao.db.Save(apiKey).Error
-}
-
-// DeleteApiKey 删除ApiKey
-func (dao *ApiKeyDAO) Delete(id int64) error {
-	return dao.db.Unscoped().Delete(&model.ApiKey{}, id).Error
-}
-
-// ListApiKeys 获取ApiKey列表
-func (dao *ApiKeyDAO) List(limit, offset int, status string) ([]*model.ApiKey, error) {
-	var apiKeys []*model.ApiKey
-	db := dao.db.Limit(limit).Offset(offset)
-	if status != "" {
-		db = db.Where("status = ?", status)
-	}
-	err := db.Find(&apiKeys).Error
-	if err != nil {
-		return nil, err
-	}
-	return apiKeys, nil
-}
-
-// ListApiKeysWithFilters 根据条件获取ApiKey列表
-func (dao *ApiKeyDAO) ListWithFilters(limit, offset int, filters map[string]interface{}) ([]*model.ApiKey, int64, error) {
-	var apiKeys []*model.ApiKey
-	db := dao.db.Limit(limit).Offset(offset)
-	for k, v := range filters {
-		db = db.Where(k, v)
-	}
-	err := db.Find(&apiKeys).Error
-	if err != nil {
-		return nil, 0, err
-	}
+func (d *ApiKeyDAO) ListByUserID(userID uint64, limit, offset int) ([]*store.APIKey, int64, error) {
+	var apiKeys []*store.APIKey
 	var total int64
-	db.Model(&model.ApiKey{}).Count(&total)
-
-	return apiKeys, total, nil
+	db := d.db.Where("user_id = ?", userID)
+	db.Model(&store.APIKey{}).Count(&total)
+	err := db.Limit(limit).Offset(offset).Order("created_at DESC").Find(&apiKeys).Error
+	return apiKeys, total, err
 }
 
-// BatchEnableApiKeys 批量启用ApiKey
-func (dao *ApiKeyDAO) BatchEnable(ids []int64) error {
+func (d *ApiKeyDAO) Update(apiKey *store.APIKey) error {
+	if apiKey == nil {
+		return errors.New("apiKey is nil")
+	}
+	return d.db.Save(apiKey).Error
+}
+
+func (d *ApiKeyDAO) Delete(id uint64) error {
+	return d.db.Delete(&store.APIKey{}, id).Error
+}
+
+func (d *ApiKeyDAO) BatchDelete(ids []uint64) error {
 	if len(ids) == 0 {
 		return errors.New("ids is empty")
 	}
-	return dao.db.Model(&model.ApiKey{}).Where("id IN ?", ids).Update("active", true).Error
-}
-
-// BatchDisableApiKeys 批量禁用ApiKey
-func (dao *ApiKeyDAO) BatchDisable(ids []int64) error {
-	if len(ids) == 0 {
-		return errors.New("ids is empty")
-	}
-	return dao.db.Model(&model.ApiKey{}).Where("id IN ?", ids).Update("active", false).Error
-}
-
-// BatchDeleteApiKey 批量删除ApiKey
-func (dao *ApiKeyDAO) BatchDelete(ids []int64) error {
-	if len(ids) == 0 {
-		return errors.New("ids is empty")
-	}
-	return dao.db.Unscoped().Delete(&model.ApiKey{}, ids).Error
-}
-
-// CountApiKeys 获取ApiKey总数
-func (dao *ApiKeyDAO) Count() (int64, error) {
-	var count int64
-	err := dao.db.Model(&model.ApiKey{}).Count(&count).Error
-	if err != nil {
-		return 0, err
-	}
-	return count, nil
+	return d.db.Delete(&store.APIKey{}, ids).Error
 }

internal/dao/channel.go

@@ -0,0 +1,105 @@
+package dao
+
+import (
+	"opencatd-open/internal/store"
+
+	"gorm.io/gorm"
+)
+
+type ChannelDAO struct {
+	db *gorm.DB
+}
+
+func NewChannelDAO(db *gorm.DB) *ChannelDAO {
+	return &ChannelDAO{db: db}
+}
+
+func (d *ChannelDAO) Create(channel *store.Channel) error {
+	return d.db.Create(channel).Error
+}
+
+func (d *ChannelDAO) GetByID(id uint64) (*store.Channel, error) {
+	var channel store.Channel
+	err := d.db.First(&channel, id).Error
+	if err != nil {
+		return nil, err
+	}
+	return &channel, nil
+}
+
+func (d *ChannelDAO) GetByName(name string) (*store.Channel, error) {
+	var channel store.Channel
+	err := d.db.Where("name = ?", name).First(&channel).Error
+	if err != nil {
+		return nil, err
+	}
+	return &channel, nil
+}
+
+func (d *ChannelDAO) List(limit, offset int) ([]*store.Channel, int64, error) {
+	var channels []*store.Channel
+	var total int64
+	d.db.Model(&store.Channel{}).Count(&total)
+	err := d.db.Limit(limit).Offset(offset).Order("priority DESC, weight DESC").Find(&channels).Error
+	return channels, total, err
+}
+
+func (d *ChannelDAO) ListEnabled() ([]*store.Channel, error) {
+	var channels []*store.Channel
+	err := d.db.Where("enabled = ?", true).Order("priority DESC, weight DESC").Find(&channels).Error
+	return channels, err
+}
+
+func (d *ChannelDAO) Update(channel *store.Channel) error {
+	return d.db.Save(channel).Error
+}
+
+func (d *ChannelDAO) Delete(id uint64) error {
+	return d.db.Delete(&store.Channel{}, id).Error
+}
+
+// BindModels binds models to a channel (replaces existing bindings)
+func (d *ChannelDAO) BindModels(channelID uint64, bindings []store.ChannelModelBinding) error {
+	return d.db.Transaction(func(tx *gorm.DB) error {
+		// Delete existing bindings
+		if err := tx.Where("channel_id = ?", channelID).Delete(&store.ChannelModelBinding{}).Error; err != nil {
+			return err
+		}
+		// Create new bindings
+		for i := range bindings {
+			bindings[i].ChannelID = channelID
+		}
+		return tx.Create(&bindings).Error
+	})
+}
+
+// GetChannelModels returns all models bound to a channel
+func (d *ChannelDAO) GetChannelModels(channelID uint64) ([]store.ChannelModelBinding, error) {
+	var bindings []store.ChannelModelBinding
+	err := d.db.Where("channel_id = ?", channelID).Find(&bindings).Error
+	return bindings, err
+}
+
+// GetModelChannels returns all channels that support a given model (by model name)
+func (d *ChannelDAO) GetModelChannels(modelName string) ([]store.ChannelModelBinding, error) {
+	var bindings []store.ChannelModelBinding
+	err := d.db.
+		Joins("JOIN channels ON channels.id = channel_model_bindings.channel_id").
+		Joins("JOIN models ON models.id = channel_model_bindings.model_id").
+		Where("models.name = ? AND channels.enabled = ?", modelName, true).
+		Find(&bindings).Error
+	return bindings, err
+}
+
+// GetEnabledChannelsByModel returns enabled channels for a model, ordered by priority/weight
+func (d *ChannelDAO) GetEnabledChannelsByModel(modelName string) ([]*store.Channel, error) {
+	var channels []*store.Channel
+	err := d.db.
+		Distinct("channels.*").
+		Joins("JOIN channel_model_bindings ON channel_model_bindings.channel_id = channels.id").
+		Joins("JOIN models ON models.id = channel_model_bindings.model_id").
+		Where("models.name = ? AND channels.enabled = ?", modelName, true).
+		Order("channels.priority DESC, channels.weight DESC").
+		Find(&channels).Error
+	return channels, err
+}

internal/dao/model.go

@@ -0,0 +1,71 @@
+package dao
+
+import (
+	"opencatd-open/internal/store"
+
+	"gorm.io/gorm"
+)
+
+type ModelDAO struct {
+	db *gorm.DB
+}
+
+func NewModelDAO(db *gorm.DB) *ModelDAO {
+	return &ModelDAO{db: db}
+}
+
+func (d *ModelDAO) Create(model *store.Model) error {
+	return d.db.Create(model).Error
+}
+
+func (d *ModelDAO) GetByID(id uint64) (*store.Model, error) {
+	var model store.Model
+	err := d.db.First(&model, id).Error
+	if err != nil {
+		return nil, err
+	}
+	return &model, nil
+}
+
+func (d *ModelDAO) GetByName(name string) (*store.Model, error) {
+	var model store.Model
+	err := d.db.Where("name = ?", name).First(&model).Error
+	if err != nil {
+		return nil, err
+	}
+	return &model, nil
+}
+
+func (d *ModelDAO) List(limit, offset int) ([]*store.Model, int64, error) {
+	var models []*store.Model
+	var total int64
+	d.db.Model(&store.Model{}).Count(&total)
+	err := d.db.Limit(limit).Offset(offset).Order("sort ASC, name ASC").Find(&models).Error
+	return models, total, err
+}
+
+func (d *ModelDAO) ListEnabled() ([]*store.Model, error) {
+	var models []*store.Model
+	err := d.db.Where("enabled = ?", true).Order("sort ASC, name ASC").Find(&models).Error
+	return models, err
+}
+
+func (d *ModelDAO) Update(model *store.Model) error {
+	return d.db.Save(model).Error
+}
+
+func (d *ModelDAO) Delete(id uint64) error {
+	return d.db.Delete(&store.Model{}, id).Error
+}
+
+// Upsert creates or updates a model by name
+func (d *ModelDAO) Upsert(model *store.Model) error {
+	return d.db.Where("name = ?", model.Name).Assign(store.Model{
+		DisplayName:    model.DisplayName,
+		InputPrice:     model.InputPrice,
+		OutputPrice:    model.OutputPrice,
+		CacheReadPrice: model.CacheReadPrice,
+		Enabled:        model.Enabled,
+		Sort:           model.Sort,
+	}).FirstOrCreate(model).Error
+}

internal/dao/token.go

@@ -1,35 +1,12 @@
 package dao
 
 import (
-	"context"
 	"errors"
-	"opencatd-open/internal/consts"
-	"opencatd-open/internal/model"
-	"time"
+	"opencatd-open/internal/store"
 
 	"gorm.io/gorm"
 )
 
-// 确保 TokenDAO 实现了 TokenRepository 接口
-var _ TokenRepository = (*TokenDAO)(nil)
-
-type TokenRepository interface {
-	Create(ctx context.Context, token *model.Token) error
-	GetByID(ctx context.Context, id int64) (*model.Token, error)
-	GetByKey(ctx context.Context, key string) (*model.Token, error)
-	GetByUserID(ctx context.Context, userID int64) (*model.Token, error)
-	Update(ctx context.Context, token *model.Token) error
-	UpdateWithCondition(ctx context.Context, token *model.Token, filters map[string]interface{}, updates map[string]interface{}) error
-	Delete(ctx context.Context, id int64, condition map[string]interface{}) error
-	List(ctx context.Context, limit, offset int) ([]*model.Token, error)
-	ListWithFilters(ctx context.Context, limit, offset int, filters map[string]interface{}) ([]*model.Token, int64, error)
-	Disable(ctx context.Context, id int) error
-	Enable(ctx context.Context, id int) error
-	BatchDisable(ctx context.Context, ids []int64, filters map[string]interface{}) error
-	BatchEnable(ctx context.Context, ids []int64, filters map[string]interface{}) error
-	BatchDelete(ctx context.Context, ids []int64, filters map[string]interface{}) error
-}
-
 type TokenDAO struct {
 	db *gorm.DB
 }
@@ -38,161 +15,24 @@ func NewTokenDAO(db *gorm.DB) *TokenDAO {
 	return &TokenDAO{db: db}
 }
 
-// CreateToken 创建 Token
-func (dao *TokenDAO) Create(ctx context.Context, token *model.Token) error {
-	if token == nil {
-		return errors.New("token is nil")
-	}
-	return dao.db.WithContext(ctx).Create(token).Error
-}
-
-// 根据 ID 获取 Token
-func (dao *TokenDAO) GetByID(ctx context.Context, id int64) (*model.Token, error) {
-	var token model.Token
-	err := dao.db.WithContext(ctx).Preload("User").First(&token, id).Error
+func (d *TokenDAO) GetByKey(key string) (*store.User, error) {
+	var user store.User
+	err := d.db.Where("username = ?", key).First(&user).Error
 	if err != nil {
 		return nil, err
 	}
-	return &token, nil
+	return &user, nil
 }
 
-// 根据 Key 获取 Token
-func (dao *TokenDAO) GetByKey(ctx context.Context, key string) (*model.Token, error) {
-	var token model.Token
-	// err := dao.db.Where("key = ?", key).First(&token).Error
-	err := dao.db.WithContext(ctx).Preload("User").Where("key = ?", key).First(&token).Error
+func (d *TokenDAO) GetByID(id uint64) (*store.User, error) {
+	var user store.User
+	err := d.db.First(&user, id).Error
 	if err != nil {
 		return nil, err
 	}
-	return &token, nil
+	return &user, nil
 }
 
-// 根据 UserID 获取 Token
-func (dao *TokenDAO) GetByUserID(ctx context.Context, userID int64) (*model.Token, error) {
-	var token model.Token
-	err := dao.db.WithContext(ctx).Preload("User").Where("user_id = ?", userID).Find(&token).Error
-	if err != nil {
-		return nil, err
-	}
-	return &token, nil
-}
-
-// UpdateToken 更新 Token 信息
-func (dao *TokenDAO) Update(ctx context.Context, token *model.Token) error {
-	if token == nil {
-		return errors.New("token is nil")
-	}
-	return dao.db.WithContext(ctx).Save(token).Error
-}
-
-// UpdateTokenWithFilters 更新 Token 信息，支持过滤
-func (dao *TokenDAO) UpdateWithCondition(ctx context.Context, token *model.Token, filters map[string]interface{}, updates map[string]interface{}) error {
-	if token == nil {
-		return errors.New("token is nil")
-	}
-	db := dao.db.WithContext(ctx)
-	for key, value := range filters {
-		db = db.Where(key+" = ?", value)
-	}
-	return db.Model(&model.Token{}).Updates(updates).Error
-}
-
-// DeleteToken 删除 Token
-func (dao *TokenDAO) Delete(ctx context.Context, id int64, condition map[string]interface{}) error {
-	if id <= 0 {
-		return errors.New("id is invalid")
-	}
-	query := dao.db.WithContext(ctx).Where("id = ?", id)
-	for key, value := range condition {
-		query = query.Where(key, value)
-	}
-	return query.Unscoped().Delete(&model.Token{}).Error
-}
-
-// ListTokens 获取 Token 列表
-func (dao *TokenDAO) List(ctx context.Context, limit, offset int) ([]*model.Token, error) {
-	var tokens []*model.Token
-	err := dao.db.WithContext(ctx).Limit(limit).Offset(offset).Find(&tokens).Error
-	if err != nil {
-		return nil, err
-	}
-	return tokens, nil
-}
-
-// ListTokensWithFilters 获取 Token 列表，支持过滤
-func (dao *TokenDAO) ListWithFilters(ctx context.Context, limit, offset int, filters map[string]interface{}) ([]*model.Token, int64, error) {
-	var tokens []*model.Token
-	var count int64
-
-	db := dao.db.WithContext(ctx)
-	if filters != nil {
-		for k, v := range filters {
-			db = db.Where(k, v)
-		}
-	}
-
-	if err := db.Limit(limit).Offset(offset).Find(&tokens).Error; err != nil {
-		return nil, 0, err
-	}
-
-	db.Model(&model.Token{}).Count(&count)
-
-	return tokens, count, nil
-}
-
-// DisableToken 禁用 Token
-func (dao *TokenDAO) Disable(ctx context.Context, id int) error {
-	return dao.db.WithContext(ctx).Model(&model.Token{}).Where("id = ?", id).Update("status", false).Error
-}
-
-// EnableToken 启用 Token
-func (dao *TokenDAO) Enable(ctx context.Context, id int) error {
-	return dao.db.WithContext(ctx).Model(&model.Token{}).Where("id = ?", id).Update("status", true).Error
-}
-
-// BatchDisableTokens 批量禁用 Token
-func (dao *TokenDAO) BatchDisable(ctx context.Context, ids []int64, filters map[string]interface{}) error {
-	query := dao.db.WithContext(ctx).Model(&model.Token{}).Where("id IN ?", ids)
-	for key, value := range filters {
-		query = query.Where(key, value)
-	}
-	return query.Update("active", false).Error
-}
-
-// BatchEnableTokens 批量启用 Token
-func (dao *TokenDAO) BatchEnable(ctx context.Context, ids []int64, filters map[string]interface{}) error {
-	query := dao.db.WithContext(ctx).Model(&model.Token{}).Where("id IN ?", ids)
-	for key, value := range filters {
-		query = query.Where(key, value)
-	}
-	return query.Update("active", true).Error
-}
-
-// BatchDeleteTokens 批量删除 Token
-func (dao *TokenDAO) BatchDelete(ctx context.Context, ids []int64, filters map[string]interface{}) error {
-	query := dao.db.Unscoped().WithContext(ctx).Where("id IN ?", ids)
-	for key, value := range filters {
-		query = query.Where(key, value)
-	}
-	return query.Delete(&model.Token{}).Error
-	// return dao.db.WithContext(ctx).Where("name != 'default' AND id IN ?", ids).Delete(&model.Token{}).Error
-}
-
-// 检查 token 是否有效
-func (dao *TokenDAO) IsValid(ctx context.Context, key string) (bool, error) {
-	var token model.Token
-	err := dao.db.WithContext(ctx).Where("key = ? AND status = ? AND (expired_time = -1 OR expired_time > ?)",
-		key, consts.StatusEnabled, time.Now().Unix()).First(&token).Error
-
-	if err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return false, nil
-		}
-		return false, err
-	}
-	if token.User.Status != consts.StatusEnabled || (*token.User.UnlimitedQuota && *token.User.Quota <= 0) {
-		return false, nil
-	}
-
-	return true, nil
-}
+// Placeholder to avoid compile errors - will be expanded in Phase 1
+var _ = errors.New
+var _ = gorm.ErrRecordNotFound

internal/dao/usage.go

@@ -2,286 +2,98 @@ package dao
 
 import (
 	"context"
-	"fmt"
-	dto "opencatd-open/internal/dto/team"
-	"opencatd-open/internal/model"
-	"opencatd-open/pkg/config"
+	"opencatd-open/internal/store"
 	"time"
 
 	"gorm.io/gorm"
 	"gorm.io/gorm/clause"
 )
 
-var _ UsageRepository = (*UsageDAO)(nil)
-var _ DailyUsageRepository = (*DailyUsageDAO)(nil)
-
-type UsageRepository interface {
-	// Create
-	Create(ctx context.Context, usage *model.Usage) error
-	BatchCreate(ctx context.Context, usages []*model.Usage) error
-
-	// Read
-	ListByUserID(ctx context.Context, userID int64, limit, offset int) ([]*model.Usage, error)
-	ListByTokenID(ctx context.Context, tokenID int64, limit, offset int) ([]*model.Usage, error)
-	ListByDateRange(ctx context.Context, start, end time.Time) ([]*model.Usage, error)
-	ListByCapability(ctx context.Context, capability string, limit, offset int) ([]*model.Usage, error)
-
-	// Delete
-	Delete(ctx context.Context, id int64) error
-
-	// Statistics
-	CountByUserID(ctx context.Context, userID int64) (int64, error)
-}
-
-type DailyUsageRepository interface {
-	// Create
-	Create(ctx context.Context, usage *model.DailyUsage) error
-	BatchCreate(ctx context.Context, usages []*model.DailyUsage) error
-
-	// Read
-	ListByUserID(ctx context.Context, userID int64, limit, offset int) ([]*model.DailyUsage, error)
-	ListByTokenID(ctx context.Context, tokenID int64, limit, offset int) ([]*model.DailyUsage, error)
-	ListByDateRange(ctx context.Context, start, end time.Time) ([]*model.DailyUsage, error)
-	GetByDate(ctx context.Context, userID int64, date time.Time) (*model.DailyUsage, error)
-
-	// Delete
-	Delete(ctx context.Context, id int64) error
-
-	// Statistics
-	CountByUserID(ctx context.Context, userID int64) (int64, error)
-	StatUserUsages(ctx context.Context, start, end time.Time, filters map[string]interface{}) ([]*dto.UsageInfo, error)
-}
-
 type UsageDAO struct {
 	db *gorm.DB
 }
 
 type DailyUsageDAO struct {
-	cfg *config.Config
-	db  *gorm.DB
+	db *gorm.DB
 }
 
-func NewUsageDAO(cfg *config.Config, db *gorm.DB) *UsageDAO {
+func NewUsageDAO(db *gorm.DB) *UsageDAO {
 	return &UsageDAO{db: db}
 }
 
-func NewDailyUsageDAO(cfg *config.Config, db *gorm.DB) *DailyUsageDAO {
+func NewDailyUsageDAO(db *gorm.DB) *DailyUsageDAO {
 	return &DailyUsageDAO{db: db}
 }
 
-// Usage DAO implementations
-func (d *UsageDAO) Create(ctx context.Context, usage *model.Usage) error {
-	return d.db.WithContext(ctx).Create(usage).Error
+// UsageLog DAO
+func (d *UsageDAO) Create(ctx context.Context, log *store.UsageLog) error {
+	return d.db.WithContext(ctx).Create(log).Error
 }
 
-func (d *UsageDAO) BatchCreate(ctx context.Context, usages []*model.Usage) error {
-	return d.db.WithContext(ctx).Create(usages).Error
+func (d *UsageDAO) BatchCreate(ctx context.Context, logs []*store.UsageLog) error {
+	return d.db.WithContext(ctx).Create(logs).Error
 }
 
-func (d *UsageDAO) GetByID(ctx context.Context, id int64) (*model.Usage, error) {
-	var usage model.Usage
-	err := d.db.WithContext(ctx).First(&usage, id).Error
-	if err != nil {
-		return nil, err
-	}
-	return &usage, nil
-}
-
-func (d *UsageDAO) ListByUserID(ctx context.Context, userID int64, limit, offset int) ([]*model.Usage, error) {
-	var usages []*model.Usage
+func (d *UsageDAO) ListByUserID(ctx context.Context, userID uint64, limit, offset int) ([]*store.UsageLog, error) {
+	var logs []*store.UsageLog
 	err := d.db.WithContext(ctx).
 		Where("user_id = ?", userID).
+		Order("created_at DESC").
 		Limit(limit).
 		Offset(offset).
-		Find(&usages).Error
-	return usages, err
+		Find(&logs).Error
+	return logs, err
 }
 
-func (d *UsageDAO) ListByTokenID(ctx context.Context, tokenID int64, limit, offset int) ([]*model.Usage, error) {
-	var usages []*model.Usage
-	err := d.db.WithContext(ctx).
-		Where("token_id = ?", tokenID).
-		Limit(limit).
-		Offset(offset).
-		Find(&usages).Error
-	return usages, err
+func (d *UsageDAO) Delete(ctx context.Context, id uint64) error {
+	return d.db.WithContext(ctx).Delete(&store.UsageLog{}, id).Error
 }
 
-func (d *UsageDAO) ListByDateRange(ctx context.Context, start, end time.Time) ([]*model.Usage, error) {
-	var usages []*model.Usage
-	err := d.db.WithContext(ctx).
-		Where("date BETWEEN ? AND ?", start, end).
-		Find(&usages).Error
-	return usages, err
-}
-
-func (d *UsageDAO) ListByCapability(ctx context.Context, capability string, limit, offset int) ([]*model.Usage, error) {
-	var usages []*model.Usage
-	err := d.db.WithContext(ctx).
-		Where("capability = ?", capability).
-		Limit(limit).
-		Offset(offset).
-		Find(&usages).Error
-	return usages, err
-}
-
-func (d *UsageDAO) Delete(ctx context.Context, id int64) error {
-	return d.db.WithContext(ctx).Delete(&model.Usage{}, id).Error
-}
-
-func (d *UsageDAO) CountByUserID(ctx context.Context, userID int64) (int64, error) {
+func (d *UsageDAO) CountByUserID(ctx context.Context, userID uint64) (int64, error) {
 	var count int64
-	err := d.db.WithContext(ctx).Model(&model.Usage{}).Where("user_id = ?", userID).Count(&count).Error
+	err := d.db.WithContext(ctx).Model(&store.UsageLog{}).Where("user_id = ?", userID).Count(&count).Error
 	return count, err
 }
 
-// DailyUsage DAO implementations
-func (d *DailyUsageDAO) Create(ctx context.Context, usage *model.DailyUsage) error {
-	return d.db.WithContext(ctx).Create(usage).Error
+// UsageDaily DAO
+func (d *DailyUsageDAO) Create(ctx context.Context, log *store.UsageDaily) error {
+	return d.db.WithContext(ctx).Create(log).Error
 }
 
-func (d *DailyUsageDAO) BatchCreate(ctx context.Context, usages []*model.DailyUsage) error {
-	return d.db.WithContext(ctx).Create(usages).Error
-}
-
-func (d *DailyUsageDAO) ListByUserID(ctx context.Context, userID int64, limit, offset int) ([]*model.DailyUsage, error) {
-	var usages []*model.DailyUsage
+func (d *DailyUsageDAO) ListByUserID(ctx context.Context, userID uint64, limit, offset int) ([]*store.UsageDaily, error) {
+	var logs []*store.UsageDaily
 	err := d.db.WithContext(ctx).
 		Where("user_id = ?", userID).
+		Order("date DESC").
 		Limit(limit).
 		Offset(offset).
-		Find(&usages).Error
-	return usages, err
+		Find(&logs).Error
+	return logs, err
 }
 
-func (d *DailyUsageDAO) ListByTokenID(ctx context.Context, tokenID int64, limit, offset int) ([]*model.DailyUsage, error) {
-	var usages []*model.DailyUsage
-	err := d.db.WithContext(ctx).
-		Where("token_id = ?", tokenID).
-		Limit(limit).
-		Offset(offset).
-		Find(&usages).Error
-	return usages, err
-}
-
-func (d *DailyUsageDAO) ListByDateRange(ctx context.Context, start, end time.Time) ([]*model.DailyUsage, error) {
-	var usages []*model.DailyUsage
-	err := d.db.WithContext(ctx).
-		Where("date BETWEEN ? AND ?", start, end).
-		Find(&usages).Error
-	return usages, err
-}
-
-func (d *DailyUsageDAO) GetByDate(ctx context.Context, userID int64, date time.Time) (*model.DailyUsage, error) {
-	var usage model.DailyUsage
+func (d *DailyUsageDAO) GetByDate(ctx context.Context, userID uint64, date string) (*store.UsageDaily, error) {
+	var log store.UsageDaily
 	err := d.db.WithContext(ctx).
 		Where("user_id = ? AND date = ?", userID, date).
-		First(&usage).Error
+		First(&log).Error
 	if err != nil {
 		return nil, err
 	}
-	return &usage, nil
+	return &log, nil
 }
 
-// UpsertDailyUsage 根据不同数据库类型执行 Upsert
-func (d *DailyUsageDAO) UpsertDailyUsage(ctx context.Context, usage *model.Usage) error {
-	date := usage.Date.Truncate(24 * time.Hour)
-	dailyUsage := &model.DailyUsage{
-		UserID:           usage.UserID,
-		TokenID:          usage.TokenID,
-		Capability:       usage.Capability,
-		Model:            usage.Model,
-		Stream:           usage.Stream,
-		PromptTokens:     usage.PromptTokens,
-		CompletionTokens: usage.CompletionTokens,
-		TotalTokens:      usage.TotalTokens,
-		Cost:             usage.Cost,
-	}
-
-	updateColumns := map[string]interface{}{
-		"prompt_tokens":     gorm.Expr("prompt_tokens + VALUES(prompt_tokens)"),
-		"completion_tokens": gorm.Expr("completion_tokens + VALUES(completion_tokens)"),
-		"total_tokens":      gorm.Expr("total_tokens + VALUES(total_tokens)"),
-	}
-
-	db := d.db.WithContext(ctx)
-
-	switch d.cfg.DB_Type {
-	case "mysql":
-		// MySQL: INSERT ... ON DUPLICATE KEY UPDATE
-		return db.Clauses(clause.OnConflict{
-			Columns: []clause.Column{
-				{Name: "user_id"},
-				{Name: "date"},
-			},
-			DoUpdates: clause.Assignments(updateColumns),
-		}).Create(dailyUsage).Error
-
-	case "postgres":
-		// PostgreSQL: INSERT ... ON CONFLICT DO UPDATE
-		updateColumns := map[string]interface{}{
-			"prompt_tokens":     gorm.Expr("daily_usages.prompt_tokens + EXCLUDED.prompt_tokens"),
-			"completion_tokens": gorm.Expr("daily_usages.completion_tokens + EXCLUDED.completion_tokens"),
-			"total_tokens":      gorm.Expr("daily_usages.total_tokens + EXCLUDED.total_tokens"),
-		}
-		return db.Clauses(clause.OnConflict{
-			Columns: []clause.Column{
-				{Name: "user_id"},
-				{Name: "date"},
-			},
-			DoUpdates: clause.Assignments(updateColumns),
-		}).Create(dailyUsage).Error
-	case "sqlite":
-		fallthrough
-	default:
-		return db.Transaction(func(tx *gorm.DB) error {
-			var existing model.DailyUsage
-			err := tx.Where("user_id = ? AND date = ?",
-				usage.UserID, date).
-				First(&existing).Error
-
-			if err == gorm.ErrRecordNotFound {
-				// 记录不存在，创建新记录
-				return tx.Create(dailyUsage).Error
-			} else if err != nil {
-				return err // 返回其他错误
-			}
-
-			// 记录存在，更新
-			return tx.Model(&existing).Updates(map[string]interface{}{
-				"prompt_tokens":     gorm.Expr("prompt_tokens + ?", usage.PromptTokens),
-				"completion_tokens": gorm.Expr("completion_tokens + ?", usage.CompletionTokens),
-				"total_tokens":      gorm.Expr("total_tokens + ?", usage.TotalTokens),
-			}).Error
-		})
-	}
+func (d *DailyUsageDAO) UpsertDailyUsage(ctx context.Context, log *store.UsageDaily) error {
+	return d.db.WithContext(ctx).Clauses(clause.OnConflict{
+		Columns:   []clause.Column{{Name: "user_id"}, {Name: "model_id"}, {Name: "date"}},
+		DoUpdates: clause.AssignmentColumns([]string{"requests", "input_tokens", "output_tokens", "cache_read_tokens", "cost"}),
+	}).Create(log).Error
 }
 
-func (d *DailyUsageDAO) Delete(ctx context.Context, id int64) error {
-	return d.db.WithContext(ctx).Delete(&model.DailyUsage{}, id).Error
-}
-
-func (d *DailyUsageDAO) CountByUserID(ctx context.Context, userID int64) (int64, error) {
-	var count int64
-	err := d.db.WithContext(ctx).Model(&model.DailyUsage{}).Where("user_id = ?", userID).Count(&count).Error
-	return count, err
-}
-
-func (d *DailyUsageDAO) StatUserUsages(ctx context.Context, from, to time.Time, filters map[string]interface{}) ([]*dto.UsageInfo, error) {
-	var usages []*dto.UsageInfo
-
-	query := d.db.WithContext(ctx).
-		Model(&model.DailyUsage{}).
-		Select("user_id as userId, sum(total_tokens) as totalUnit, sum(cast(cost as decimal(20,6))) as cost")
-	for key, value := range filters {
-		query = query.Where(fmt.Sprintf("%s = ?", key), value)
-	}
-	query = query.Group("user_id").Where("date >= ? AND date <= ?", from, to)
-
-	err := query.Group("user_id").Find(&usages).Error
-	if err != nil {
-		return nil, fmt.Errorf("failed to list usages: %w", err)
-	}
-
-	return usages, nil
+func (d *DailyUsageDAO) ListByDateRange(ctx context.Context, userID uint64, start, end time.Time) ([]*store.UsageDaily, error) {
+	var logs []*store.UsageDaily
+	err := d.db.WithContext(ctx).
+		Where("user_id = ? AND date >= ? AND date <= ?", userID, start.Format("2006-01-02"), end.Format("2006-01-02")).
+		Order("date DESC").
+		Find(&logs).Error
+	return logs, err
 }

internal/dao/user.go

@@ -1,32 +1,11 @@
 package dao
 
 import (
-	"errors"
-	"fmt"
-	"opencatd-open/internal/model"
-	"time"
+	"opencatd-open/internal/store"
 
 	"gorm.io/gorm"
 )
 
-// 确保 UserDAO 实现了 UserRepository 接口
-var _ UserRepository = (*UserDAO)(nil)
-
-// UserRepository 定义用户数据访问操作的接口
-type UserRepository interface {
-	Create(user *model.User) error
-	GetByID(id int64) (*model.User, error)
-	GetByUsername(username string) (*model.User, error)
-	Update(user *model.User) error
-	Delete(id int64) error
-	List(limit, offset int, condition map[string]interface{}) ([]model.User, int64, error)
-	// Enable(id int64) error
-	// Disable(id int64) error
-	BatchEnable(ids []int64, condition []string) error
-	BatchDisable(ids []int64, condition []string) error
-	BatchDelete(ids []int64, condition []string) error
-}
-
 type UserDAO struct {
 	db *gorm.DB
 }
@@ -35,129 +14,49 @@ func NewUserDAO(db *gorm.DB) *UserDAO {
 	return &UserDAO{db: db}
 }
 
-// 创建用户
-func (dao *UserDAO) Create(user *model.User) error {
-	if user == nil {
-		return errors.New("user is nil")
-	}
-	fmt.Println(*user)
-
-	return dao.db.Transaction(func(tx *gorm.DB) error {
-		// 创建用户
-		if err := tx.Create(user).Error; err != nil {
-			return fmt.Errorf("failed to create user: %w", err)
-		}
-
-		return nil
-	})
+func (d *UserDAO) Create(user *store.User) error {
+	return d.db.Create(user).Error
 }
 
-// 根据ID获取用户
-func (dao *UserDAO) GetByID(id int64) (*model.User, error) {
-	var user model.User
-	// err := dao.db.First(&user, id).Error
-	err := dao.db.Preload("Tokens", "user_id = ?", id).First(&user, id).Error
+func (d *UserDAO) GetByID(id uint64) (*store.User, error) {
+	var user store.User
+	err := d.db.First(&user, id).Error
 	if err != nil {
 		return nil, err
 	}
 	return &user, nil
 }
 
-// 根据用户名获取用户
-func (dao *UserDAO) GetByUsername(username string) (*model.User, error) {
-	var user model.User
-	// err := dao.db.Where("user_name = ?", username).First(&user).Error
-	err := dao.db.Preload("Tokens").Where("user_name = ?", username).First(&user).Error
+func (d *UserDAO) GetByUsername(username string) (*store.User, error) {
+	var user store.User
+	err := d.db.Where("username = ?", username).First(&user).Error
 	if err != nil {
 		return nil, err
 	}
 	return &user, nil
 }
 
-// 更新用户信息
-func (dao *UserDAO) Update(user *model.User) error {
-	if user == nil {
-		return errors.New("user is nil")
+func (d *UserDAO) GetByEmail(email string) (*store.User, error) {
+	var user store.User
+	err := d.db.Where("email = ?", email).First(&user).Error
+	if err != nil {
+		return nil, err
 	}
-
-	user.UpdatedAt = time.Now().Unix()
-	return dao.db.Save(user).Error
+	return &user, nil
 }
 
-// 删除用户
-func (dao *UserDAO) Delete(id int64) error {
-	return dao.db.Unscoped().Delete(&model.User{}, id).Error
-	// return dao.db.Model(&model.User{}).Where("id = ?", id).Update("status", 2).Error
-}
-
-// 获取用户列表
-func (dao *UserDAO) List(limit, offset int, condition map[string]interface{}) ([]model.User, int64, error) {
-	if offset < 0 {
-		offset = 0
-	}
-	var users []model.User
+func (d *UserDAO) List(limit, offset int) ([]*store.User, int64, error) {
+	var users []*store.User
 	var total int64
-
-	query := dao.db.Preload("Tokens").Model(&model.User{})
-
-	for k, v := range condition {
-		query = query.Where(k, v)
-	}
-	err := query.Limit(limit).Offset(offset).Find(&users).Error
-	if err != nil {
-		return nil, 0, err
-	}
-	query = dao.db.Model(&model.User{})
-	for k, v := range condition {
-		query = query.Where(k, v)
-	}
-	query.Count(&total)
-
-	return users, total, nil
+	d.db.Model(&store.User{}).Count(&total)
+	err := d.db.Limit(limit).Offset(offset).Order("created_at DESC").Find(&users).Error
+	return users, total, err
 }
 
-// 启用User
-func (dao *UserDAO) Enable(id uint) error {
-	return dao.db.Model(&model.User{}).Where("id = ?", id).Update("active", true).Error
+func (d *UserDAO) Update(user *store.User) error {
+	return d.db.Save(user).Error
 }
 
-// 禁用User
-func (dao *UserDAO) Disable(id uint) error {
-	return dao.db.Model(&model.User{}).Where("id = ?", id).Update("active", false).Error
-}
-
-// 批量启用User
-func (dao *UserDAO) BatchEnable(ids []int64, condition []string) error {
-	if len(ids) == 0 {
-		return errors.New("ids is empty")
-	}
-	query := dao.db.Model(&model.User{}).Where("id IN ?", ids)
-	for _, value := range condition {
-		query = query.Where(value)
-	}
-	return query.Update("active", true).Error
-}
-
-// 批量禁用User
-func (dao *UserDAO) BatchDisable(ids []int64, condition []string) error {
-	if len(ids) == 0 {
-		return errors.New("ids is empty")
-	}
-	query := dao.db.Model(&model.User{}).Where("id IN ?", ids)
-	for _, value := range condition {
-		query = query.Where(value)
-	}
-	return query.Update("active", false).Error
-}
-
-// 批量删除用户
-func (dao *UserDAO) BatchDelete(ids []int64, condition []string) error {
-	if len(ids) == 0 {
-		return errors.New("ids is empty")
-	}
-	query := dao.db.Unscoped().Where("id IN ?", ids)
-	for _, value := range condition {
-		query = query.Where(value)
-	}
-	return query.Delete(&model.User{}).Error
+func (d *UserDAO) Delete(id uint64) error {
+	return d.db.Delete(&store.User{}, id).Error
 }