mirrors2/opencatd-open
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

team api

Browse Source
This commit is contained in:
Sakurasan
2025-02-01 23:52:55 +08:00
parent 65d6d12972
commit bc223d6530
30 changed files with 2683 additions and 242 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
team/dao/apikey.go
View File

@@ -18,6 +18,7 @@ type ApiKeyRepository interface {
Update(apiKey *model.ApiKey) error
Delete(id int64) error
List(offset, limit int, status *int) ([]model.ApiKey, error)
ListWithFilters(offset, limit int, filters map[string]interface{}) ([]model.ApiKey, int64, error)
Enable(id int64) error
Disable(id int64) error
BatchEnable(ids []int64) error
@@ -77,7 +78,7 @@ func (dao *ApiKeyDAO) Update(apiKey *model.ApiKey) error {
if apiKey == nil {
return errors.New("apiKey is nil")
}
apiKey.UpdatedAt = time.Now()
apiKey.UpdatedAt = time.Now().Unix()
return dao.db.Save(apiKey).Error
}
@@ -100,6 +101,21 @@ func (dao *ApiKeyDAO) List(offset, limit int, status *int) ([]model.ApiKey, erro
return apiKeys, nil
}
// ListApiKeysWithFilters 根据条件获取ApiKey列表
func (dao *ApiKeyDAO) ListWithFilters(offset, limit int, filters map[string]interface{}) ([]model.ApiKey, int64, error) {
var apiKeys []model.ApiKey
db := dao.db.Offset(offset).Limit(limit)
for key, value := range filters {
db = db.Where(key+" = ?", value)
}
var count int64
err := db.Find(&apiKeys).Count(&count).Error
if err != nil {
return nil, 0, err
}
return apiKeys, count, nil
}
// EnableApiKey 启用ApiKey
func (dao *ApiKeyDAO) Enable(id int64) error {
return dao.db.Model(&model.ApiKey{}).Where("id = ?", id).Update("status", 0).Error

146
team/dao/token.go
View File

@@ -1,28 +1,33 @@
package dao
import (
"context"
"errors"
"opencatd-open/team/consts"
"opencatd-open/team/model"
"time"
"gorm.io/gorm"
)
// 确保 TokenDAO 实现了 TokenDAOInterface 接口
var _ TokenDAOInterface = (*TokenDAO)(nil)
// 确保 TokenDAO 实现了 TokenRepository 接口
var _ TokenRepository = (*TokenDAO)(nil)
type TokenDAOInterface interface {
Create(token *model.Token) error
GetByID(id int) (*model.Token, error)
GetByKey(key string) (*model.Token, error)
GetByUserID(userID int) ([]model.Token, error)
Update(token *model.Token) error
Delete(id int) error
List(offset, limit int) ([]model.Token, error)
Disable(id int) error
Enable(id int) error
BatchDisable(ids []int) error
BatchEnable(ids []int) error
BatchDelete(ids []int) error
type TokenRepository interface {
Create(ctx context.Context, token *model.Token) error
GetByID(ctx context.Context, id int) (*model.Token, error)
GetByKey(ctx context.Context, key string) (*model.Token, error)
GetByUserID(ctx context.Context, userID int) (*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 int) error
List(ctx context.Context, offset, limit int) ([]model.Token, error)
ListWithFilters(ctx context.Context, offset, limit 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 []int) error
BatchEnable(ctx context.Context, ids []int) error
BatchDelete(ctx context.Context, ids []int) error
}
type TokenDAO struct {
@@ -34,87 +39,140 @@ func NewTokenDAO(db *gorm.DB) *TokenDAO {
}
// CreateToken 创建 Token
func (dao *TokenDAO) Create(token *model.Token) error {
func (dao *TokenDAO) Create(ctx context.Context, token *model.Token) error {
if token == nil {
return errors.New("token is nil")
}
return dao.db.Create(token).Error
return dao.db.WithContext(ctx).Create(token).Error
}
// GetTokenByID 根据 ID 获取 Token
func (dao *TokenDAO) GetByID(id int) (*model.Token, error) {
// 根据 ID 获取 Token
func (dao *TokenDAO) GetByID(ctx context.Context, id int) (*model.Token, error) {
var token model.Token
err := dao.db.First(&token, id).Error
err := dao.db.WithContext(ctx).First(&token, id).Error
if err != nil {
return nil, err
}
return &token, nil
}
// GetTokenByKey 根据 Key 获取 Token
func (dao *TokenDAO) GetByKey(key string) (*model.Token, error) {
// 根据 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.Where("key = ?", key).First(&token).Error
err := dao.db.WithContext(ctx).Preload("User").Where("key = ?", key).First(&token).Error
if err != nil {
return nil, err
}
return &token, nil
}
// GetTokensByUserID 根据 UserID 获取 Token 列表
func (dao *TokenDAO) GetByUserID(userID int) ([]model.Token, error) {
var tokens []model.Token
err := dao.db.Where("user_id = ?", userID).Find(&tokens).Error
// 根据 UserID 获取 Token
func (dao *TokenDAO) GetByUserID(ctx context.Context, userID int) (*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 tokens, nil
return &token, nil
}
// UpdateToken 更新 Token 信息
func (dao *TokenDAO) Update(token *model.Token) error {
func (dao *TokenDAO) Update(ctx context.Context, token *model.Token) error {
if token == nil {
return errors.New("token is nil")
}
return dao.db.Save(token).Error
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(id int) error {
return dao.db.Delete(&model.Token{}, id).Error
func (dao *TokenDAO) Delete(ctx context.Context, id int) error {
return dao.db.WithContext(ctx).Delete(&model.Token{}, id).Error
}
// ListTokens 获取 Token 列表
func (dao *TokenDAO) List(offset, limit int) ([]model.Token, error) {
func (dao *TokenDAO) List(ctx context.Context, offset, limit int) ([]model.Token, error) {
var tokens []model.Token
err := dao.db.Offset(offset).Limit(limit).Find(&tokens).Error
err := dao.db.WithContext(ctx).Offset(offset).Limit(limit).Find(&tokens).Error
if err != nil {
return nil, err
}
return tokens, nil
}
// ListTokensWithFilters 获取 Token 列表，支持过滤
func (dao *TokenDAO) ListWithFilters(ctx context.Context, offset, limit int, filters map[string]interface{}) ([]model.Token, int64, error) {
var tokens []model.Token
var count int64
db := dao.db.WithContext(ctx)
for key, value := range filters {
db = db.Where(key+" = ?", value)
}
if err := db.Offset(offset).Limit(limit).Find(&tokens).Error; err != nil {
return nil, 0, err
}
if err := db.Model(&model.Token{}).Count(&count).Error; err != nil {
return nil, 0, err
}
return tokens, count, nil
}
// DisableToken 禁用 Token
func (dao *TokenDAO) Disable(id int) error {
return dao.db.Model(&model.Token{}).Where("id = ?", id).Update("status", false).Error
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(id int) error {
return dao.db.Model(&model.Token{}).Where("id = ?", id).Update("status", true).Error
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(ids []int) error {
return dao.db.Model(&model.Token{}).Where("id IN ?", ids).Update("status", false).Error
func (dao *TokenDAO) BatchDisable(ctx context.Context, ids []int) error {
return dao.db.WithContext(ctx).Model(&model.Token{}).Where("id IN ?", ids).Update("status", false).Error
}
// BatchEnableTokens 批量启用 Token
func (dao *TokenDAO) BatchEnable(ids []int) error {
return dao.db.Model(&model.Token{}).Where("id IN ?", ids).Update("status", true).Error
func (dao *TokenDAO) BatchEnable(ctx context.Context, ids []int) error {
return dao.db.WithContext(ctx).Model(&model.Token{}).Where("id IN ?", ids).Update("status", true).Error
}
// BatchDeleteTokens 批量删除 Token
func (dao *TokenDAO) BatchDelete(ids []int) error {
return dao.db.Where("id IN ?", ids).Delete(&model.Token{}).Error
func (dao *TokenDAO) BatchDelete(ctx context.Context, ids []int) error {
return dao.db.WithContext(ctx).Where("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 == 1 && token.User.Quota <= 0) {
return false, nil
}
return true, nil
}

297
team/dao/usage.go Normal file
View File

@@ -0,0 +1,297 @@
package dao
import (
"context"
"fmt"
"opencatd-open/pkg/store"
"opencatd-open/team/consts"
dto "opencatd-open/team/dto/team"
"opencatd-open/team/model"
"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 {
db *gorm.DB
}
func NewUsageDAO(db *gorm.DB) *UsageDAO {
return &UsageDAO{db: db}
}
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
}
func (d *UsageDAO) BatchCreate(ctx context.Context, usages []*model.Usage) error {
return d.db.WithContext(ctx).Create(usages).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
err := d.db.WithContext(ctx).
Where("user_id = ?", userID).
Limit(limit).
Offset(offset).
Find(&usages).Error
return usages, 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) 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) {
var count int64
err := d.db.WithContext(ctx).Model(&model.Usage{}).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
}
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
err := d.db.WithContext(ctx).
Where("user_id = ?", userID).
Limit(limit).
Offset(offset).
Find(&usages).Error
return usages, 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
err := d.db.WithContext(ctx).
Where("user_id = ? AND date = ?", userID, date).
First(&usage).Error
if err != nil {
return nil, err
}
return &usage, 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 store.DBType {
case consts.DBTypeMySQL:
// MySQL: INSERT ... ON DUPLICATE KEY UPDATE
return db.Clauses(clause.OnConflict{
Columns: []clause.Column{
{Name: "user_id"},
{Name: "token_id"},
{Name: "capability"},
{Name: "date"},
{Name: "model"},
{Name: "stream"},
},
DoUpdates: clause.Assignments(updateColumns),
}).Create(dailyUsage).Error
case consts.DBTypePostgreSQL:
// 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: "token_id"},
{Name: "capability"},
{Name: "date"},
{Name: "model"},
{Name: "stream"},
},
DoUpdates: clause.Assignments(updateColumns),
}).Create(dailyUsage).Error
case consts.DBTypeSQLite:
// SQLite: 需要使用事务来模拟 upsert
return db.Transaction(func(tx *gorm.DB) error {
var existing model.DailyUsage
err := tx.Where("user_id = ? AND token_id = ? AND capability = ? AND date = ? AND model = ? AND stream = ?",
usage.UserID, usage.TokenID, usage.Capability, date, usage.Model, usage.Stream).
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
})
default:
return fmt.Errorf("不支持的数据库类型: %s", store.DBType)
}
}
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
}

76
team/dao/user.go
View File

@@ -2,6 +2,8 @@ package dao
import (
"errors"
"fmt"
"opencatd-open/team/consts"
"opencatd-open/team/model"
"time"
@@ -19,6 +21,7 @@ type UserRepository interface {
Update(user *model.User) error
Delete(id int64) error
List(offset, limit int) ([]model.User, error)
ListWithFilters(offset, limit int, filters map[string]interface{}) ([]model.User, int64, error)
Enable(id int64) error
Disable(id int64) error
BatchEnable(ids []int64) error
@@ -34,70 +37,107 @@ func NewUserDAO(db *gorm.DB) *UserDAO {
return &UserDAO{db: db}
}
// CreateUser 创建用户
// 创建用户
func (dao *UserDAO) Create(user *model.User) error {
if user == nil {
return errors.New("user is nil")
}
return dao.db.Create(user).Error
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
})
}
// GetUserByID 根据ID获取用户
// 根据ID获取用户
func (dao *UserDAO) GetByID(id int64) (*model.User, error) {
var user model.User
err := dao.db.First(&user, id).Error
// err := dao.db.First(&user, id).Error
err := dao.db.Preload("Tokens").First(&user, id).Error
if err != nil {
return nil, err
}
return &user, nil
}
// GetUserByUsername 根据用户名获取用户
// 根据用户名获取用户
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.Where("user_name = ?", username).First(&user).Error
err := dao.db.Preload("Tokens").Where("user_name = ?", username).First(&user).Error
if err != nil {
return nil, err
}
return &user, nil
}
// UpdateUser 更新用户信息
// 更新用户信息
func (dao *UserDAO) Update(user *model.User) error {
if user == nil {
return errors.New("user is nil")
}
user.UpdatedAt = time.Now()
user.UpdatedAt = time.Now().Unix()
return dao.db.Save(user).Error
}
// DeleteUser 删除用户
// 删除用户
func (dao *UserDAO) Delete(id int64) error {
return dao.db.Delete(&model.User{}, id).Error
// return dao.db.Model(&model.User{}).Where("id = ?", id).Update("status", 2).Error
}
// ListUsers 获取用户列表
// 获取用户列表
func (dao *UserDAO) List(offset, limit int) ([]model.User, error) {
var users []model.User
err := dao.db.Offset(offset).Limit(limit).Find(&users).Error
err := dao.db.Preload("Tokens").Offset(offset).Limit(limit).Find(&users).Error
if err != nil {
return nil, err
}
return users, nil
}
// EnableUser 启用User
// 获取用户列表，带过滤条件
func (dao *UserDAO) ListWithFilters(offset, limit int, filters map[string]interface{}) ([]model.User, int64, error) {
var users []model.User
var total int64
// 构建查询
query := dao.db.Model(&model.User{})
// 添加过滤条件
for key, value := range filters {
query = query.Where(key+" = ?", value)
}
// 查询总数
if err := query.Count(&total).Error; err != nil {
return nil, 0, err
}
// 分页查询
err := query.Offset(offset).Limit(limit).Find(&users).Error
if err != nil {
return nil, 0, err
}
return users, total, nil
}
// 启用User
func (dao *UserDAO) Enable(id int64) error {
return dao.db.Model(&model.User{}).Where("id = ?", id).Update("status", 0).Error
return dao.db.Model(&model.User{}).Where("id = ?", id).Update("status", consts.StatusEnabled).Error
}
// DisableUser 禁用User
// 禁用User
func (dao *UserDAO) Disable(id int64) error {
return dao.db.Model(&model.User{}).Where("id = ?", id).Update("status", 1).Error
return dao.db.Model(&model.User{}).Where("id = ?", id).Update("status", consts.StatusDisabled).Error
}
// BatchEnableUsers 批量启用User
// 批量启用User
func (dao *UserDAO) BatchEnable(ids []int64) error {
if len(ids) == 0 {
return errors.New("ids is empty")
@@ -105,7 +145,7 @@ func (dao *UserDAO) BatchEnable(ids []int64) error {
return dao.db.Model(&model.User{}).Where("id IN ?", ids).Update("status", 0).Error
}
// BatchDisableUsers 批量禁用User
// 批量禁用User
func (dao *UserDAO) BatchDisable(ids []int64) error {
if len(ids) == 0 {
return errors.New("ids is empty")
@@ -113,7 +153,7 @@ func (dao *UserDAO) BatchDisable(ids []int64) error {
return dao.db.Model(&model.User{}).Where("id IN ?", ids).Update("status", 1).Error
}
// BatchDeleteUser 批量删除用户
// 批量删除用户
func (dao *UserDAO) BatchDelete(ids []int64) error {
if len(ids) == 0 {
return errors.New("ids is empty")