282 lines
8.3 KiB
Go
282 lines
8.3 KiB
Go
package repository
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
|
|
"github.com/Wei-Shaw/sub2api/internal/service"
|
|
|
|
"github.com/Wei-Shaw/sub2api/internal/pkg/pagination"
|
|
|
|
"gorm.io/gorm"
|
|
"gorm.io/gorm/clause"
|
|
)
|
|
|
|
type groupRepository struct {
|
|
db *gorm.DB
|
|
}
|
|
|
|
func NewGroupRepository(db *gorm.DB) service.GroupRepository {
|
|
return &groupRepository{db: db}
|
|
}
|
|
|
|
func (r *groupRepository) Create(ctx context.Context, group *service.Group) error {
|
|
m := groupModelFromService(group)
|
|
err := r.db.WithContext(ctx).Create(m).Error
|
|
if err == nil {
|
|
applyGroupModelToService(group, m)
|
|
}
|
|
return translatePersistenceError(err, nil, service.ErrGroupExists)
|
|
}
|
|
|
|
func (r *groupRepository) GetByID(ctx context.Context, id int64) (*service.Group, error) {
|
|
var m groupModel
|
|
err := r.db.WithContext(ctx).First(&m, id).Error
|
|
if err != nil {
|
|
return nil, translatePersistenceError(err, service.ErrGroupNotFound, nil)
|
|
}
|
|
group := groupModelToService(&m)
|
|
count, _ := r.GetAccountCount(ctx, group.ID)
|
|
group.AccountCount = count
|
|
return group, nil
|
|
}
|
|
|
|
func (r *groupRepository) Update(ctx context.Context, group *service.Group) error {
|
|
m := groupModelFromService(group)
|
|
err := r.db.WithContext(ctx).Save(m).Error
|
|
if err == nil {
|
|
applyGroupModelToService(group, m)
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (r *groupRepository) Delete(ctx context.Context, id int64) error {
|
|
return r.db.WithContext(ctx).Delete(&groupModel{}, id).Error
|
|
}
|
|
|
|
func (r *groupRepository) List(ctx context.Context, params pagination.PaginationParams) ([]service.Group, *pagination.PaginationResult, error) {
|
|
return r.ListWithFilters(ctx, params, "", "", nil)
|
|
}
|
|
|
|
// ListWithFilters lists groups with optional filtering by platform, status, and is_exclusive
|
|
func (r *groupRepository) ListWithFilters(ctx context.Context, params pagination.PaginationParams, platform, status string, isExclusive *bool) ([]service.Group, *pagination.PaginationResult, error) {
|
|
var groups []groupModel
|
|
var total int64
|
|
|
|
db := r.db.WithContext(ctx).Model(&groupModel{})
|
|
|
|
// Apply filters
|
|
if platform != "" {
|
|
db = db.Where("platform = ?", platform)
|
|
}
|
|
if status != "" {
|
|
db = db.Where("status = ?", status)
|
|
}
|
|
if isExclusive != nil {
|
|
db = db.Where("is_exclusive = ?", *isExclusive)
|
|
}
|
|
|
|
if err := db.Count(&total).Error; err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
if err := db.Offset(params.Offset()).Limit(params.Limit()).Order("id ASC").Find(&groups).Error; err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
outGroups := make([]service.Group, 0, len(groups))
|
|
for i := range groups {
|
|
outGroups = append(outGroups, *groupModelToService(&groups[i]))
|
|
}
|
|
|
|
// 获取每个分组的账号数量
|
|
for i := range outGroups {
|
|
count, _ := r.GetAccountCount(ctx, outGroups[i].ID)
|
|
outGroups[i].AccountCount = count
|
|
}
|
|
|
|
return outGroups, paginationResultFromTotal(total, params), nil
|
|
}
|
|
|
|
func (r *groupRepository) ListActive(ctx context.Context) ([]service.Group, error) {
|
|
var groups []groupModel
|
|
err := r.db.WithContext(ctx).Where("status = ?", service.StatusActive).Order("id ASC").Find(&groups).Error
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
outGroups := make([]service.Group, 0, len(groups))
|
|
for i := range groups {
|
|
outGroups = append(outGroups, *groupModelToService(&groups[i]))
|
|
}
|
|
// 获取每个分组的账号数量
|
|
for i := range outGroups {
|
|
count, _ := r.GetAccountCount(ctx, outGroups[i].ID)
|
|
outGroups[i].AccountCount = count
|
|
}
|
|
return outGroups, nil
|
|
}
|
|
|
|
func (r *groupRepository) ListActiveByPlatform(ctx context.Context, platform string) ([]service.Group, error) {
|
|
var groups []groupModel
|
|
err := r.db.WithContext(ctx).Where("status = ? AND platform = ?", service.StatusActive, platform).Order("id ASC").Find(&groups).Error
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
outGroups := make([]service.Group, 0, len(groups))
|
|
for i := range groups {
|
|
outGroups = append(outGroups, *groupModelToService(&groups[i]))
|
|
}
|
|
// 获取每个分组的账号数量
|
|
for i := range outGroups {
|
|
count, _ := r.GetAccountCount(ctx, outGroups[i].ID)
|
|
outGroups[i].AccountCount = count
|
|
}
|
|
return outGroups, nil
|
|
}
|
|
|
|
func (r *groupRepository) ExistsByName(ctx context.Context, name string) (bool, error) {
|
|
var count int64
|
|
err := r.db.WithContext(ctx).Model(&groupModel{}).Where("name = ?", name).Count(&count).Error
|
|
return count > 0, err
|
|
}
|
|
|
|
func (r *groupRepository) GetAccountCount(ctx context.Context, groupID int64) (int64, error) {
|
|
var count int64
|
|
err := r.db.WithContext(ctx).Table("account_groups").Where("group_id = ?", groupID).Count(&count).Error
|
|
return count, err
|
|
}
|
|
|
|
// DeleteAccountGroupsByGroupID 删除分组与账号的关联关系
|
|
func (r *groupRepository) DeleteAccountGroupsByGroupID(ctx context.Context, groupID int64) (int64, error) {
|
|
result := r.db.WithContext(ctx).Exec("DELETE FROM account_groups WHERE group_id = ?", groupID)
|
|
return result.RowsAffected, result.Error
|
|
}
|
|
|
|
func (r *groupRepository) DeleteCascade(ctx context.Context, id int64) ([]int64, error) {
|
|
group, err := r.GetByID(ctx, id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var affectedUserIDs []int64
|
|
if group.IsSubscriptionType() {
|
|
if err := r.db.WithContext(ctx).
|
|
Table("user_subscriptions").
|
|
Where("group_id = ?", id).
|
|
Pluck("user_id", &affectedUserIDs).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
err = r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
// 1. 删除订阅类型分组的订阅记录
|
|
if group.IsSubscriptionType() {
|
|
if err := tx.Exec("DELETE FROM user_subscriptions WHERE group_id = ?", id).Error; err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// 2. 将 api_keys 中绑定该分组的 group_id 设为 nil
|
|
if err := tx.Exec("UPDATE api_keys SET group_id = NULL WHERE group_id = ?", id).Error; err != nil {
|
|
return err
|
|
}
|
|
|
|
// 3. 从 users.allowed_groups 数组中移除该分组 ID
|
|
if err := tx.Exec(
|
|
"UPDATE users SET allowed_groups = array_remove(allowed_groups, ?) WHERE ? = ANY(allowed_groups)",
|
|
id, id,
|
|
).Error; err != nil {
|
|
return err
|
|
}
|
|
|
|
// 4. 删除 account_groups 中间表的数据
|
|
if err := tx.Exec("DELETE FROM account_groups WHERE group_id = ?", id).Error; err != nil {
|
|
return err
|
|
}
|
|
|
|
// 5. 删除分组本身（带锁，避免并发写）
|
|
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).Delete(&groupModel{}, id).Error; err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return affectedUserIDs, nil
|
|
}
|
|
|
|
type groupModel struct {
|
|
ID int64 `gorm:"primaryKey"`
|
|
Name string `gorm:"uniqueIndex;size:100;not null"`
|
|
Description string `gorm:"type:text"`
|
|
Platform string `gorm:"size:50;default:anthropic;not null"`
|
|
RateMultiplier float64 `gorm:"type:decimal(10,4);default:1.0;not null"`
|
|
IsExclusive bool `gorm:"default:false;not null"`
|
|
Status string `gorm:"size:20;default:active;not null"`
|
|
|
|
SubscriptionType string `gorm:"size:20;default:standard;not null"`
|
|
DailyLimitUSD *float64 `gorm:"type:decimal(20,8)"`
|
|
WeeklyLimitUSD *float64 `gorm:"type:decimal(20,8)"`
|
|
MonthlyLimitUSD *float64 `gorm:"type:decimal(20,8)"`
|
|
|
|
CreatedAt time.Time `gorm:"not null"`
|
|
UpdatedAt time.Time `gorm:"not null"`
|
|
DeletedAt gorm.DeletedAt `gorm:"index"`
|
|
}
|
|
|
|
func (groupModel) TableName() string { return "groups" }
|
|
|
|
func groupModelToService(m *groupModel) *service.Group {
|
|
if m == nil {
|
|
return nil
|
|
}
|
|
return &service.Group{
|
|
ID: m.ID,
|
|
Name: m.Name,
|
|
Description: m.Description,
|
|
Platform: m.Platform,
|
|
RateMultiplier: m.RateMultiplier,
|
|
IsExclusive: m.IsExclusive,
|
|
Status: m.Status,
|
|
SubscriptionType: m.SubscriptionType,
|
|
DailyLimitUSD: m.DailyLimitUSD,
|
|
WeeklyLimitUSD: m.WeeklyLimitUSD,
|
|
MonthlyLimitUSD: m.MonthlyLimitUSD,
|
|
CreatedAt: m.CreatedAt,
|
|
UpdatedAt: m.UpdatedAt,
|
|
}
|
|
}
|
|
|
|
func groupModelFromService(sg *service.Group) *groupModel {
|
|
if sg == nil {
|
|
return nil
|
|
}
|
|
return &groupModel{
|
|
ID: sg.ID,
|
|
Name: sg.Name,
|
|
Description: sg.Description,
|
|
Platform: sg.Platform,
|
|
RateMultiplier: sg.RateMultiplier,
|
|
IsExclusive: sg.IsExclusive,
|
|
Status: sg.Status,
|
|
SubscriptionType: sg.SubscriptionType,
|
|
DailyLimitUSD: sg.DailyLimitUSD,
|
|
WeeklyLimitUSD: sg.WeeklyLimitUSD,
|
|
MonthlyLimitUSD: sg.MonthlyLimitUSD,
|
|
CreatedAt: sg.CreatedAt,
|
|
UpdatedAt: sg.UpdatedAt,
|
|
}
|
|
}
|
|
|
|
func applyGroupModelToService(group *service.Group, m *groupModel) {
|
|
if group == nil || m == nil {
|
|
return
|
|
}
|
|
group.ID = m.ID
|
|
group.CreatedAt = m.CreatedAt
|
|
group.UpdatedAt = m.UpdatedAt
|
|
}
|