init: 1.0.0

2025-04-25 12:08:29 +09:00
commit 8addcc584b
1031 changed files with 76472 additions and 0 deletions
@@ -0,0 +1,66 @@
+package user
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+)
+
+func (m *defaultUserModel) FindUserAuthMethods(ctx context.Context, userId int64) ([]*AuthMethods, error) {
+	var data []*AuthMethods
+	err := m.QueryNoCacheCtx(ctx, &data, func(conn *gorm.DB, v interface{}) error {
+		return conn.Model(&AuthMethods{}).Where("user_id = ?", userId).Find(&data).Error
+	})
+	return data, err
+}
+
+func (m *defaultUserModel) FindUserAuthMethodByOpenID(ctx context.Context, method, openID string) (*AuthMethods, error) {
+	var data AuthMethods
+	err := m.QueryNoCacheCtx(ctx, &data, func(conn *gorm.DB, v interface{}) error {
+		return conn.Model(&AuthMethods{}).Where("auth_type = ? AND auth_identifier = ?", method, openID).First(&data).Error
+	})
+	return &data, err
+}
+
+func (m *defaultUserModel) FindUserAuthMethodByPlatform(ctx context.Context, userId int64, platform string) (*AuthMethods, error) {
+	var data AuthMethods
+	err := m.QueryNoCacheCtx(ctx, &data, func(conn *gorm.DB, v interface{}) error {
+		return conn.Model(&AuthMethods{}).Where("user_id = ? AND auth_type = ?", userId, platform).First(&data).Error
+	})
+	return &data, err
+}
+
+func (m *defaultUserModel) InsertUserAuthMethods(ctx context.Context, data *AuthMethods, tx ...*gorm.DB) error {
+	return m.ExecNoCacheCtx(ctx, func(conn *gorm.DB) error {
+		if len(tx) > 0 {
+			conn = tx[0]
+		}
+		return conn.Model(&AuthMethods{}).Create(data).Error
+	})
+}
+
+func (m *defaultUserModel) UpdateUserAuthMethods(ctx context.Context, data *AuthMethods, tx ...*gorm.DB) error {
+	return m.ExecNoCacheCtx(ctx, func(conn *gorm.DB) error {
+		if len(tx) > 0 {
+			conn = tx[0]
+		}
+		return conn.Model(&AuthMethods{}).Where("user_id = ? AND auth_type = ?", data.UserId, data.AuthType).Save(data).Error
+	})
+}
+
+func (m *defaultUserModel) DeleteUserAuthMethods(ctx context.Context, userId int64, platform string, tx ...*gorm.DB) error {
+	return m.ExecNoCacheCtx(ctx, func(conn *gorm.DB) error {
+		if len(tx) > 0 {
+			conn = tx[0]
+		}
+		return conn.Model(&AuthMethods{}).Where("user_id = ? AND auth_type = ?", userId, platform).Delete(&AuthMethods{}).Error
+	})
+}
+
+func (m *defaultUserModel) FindUserAuthMethodByUserId(ctx context.Context, method string, userId int64) (*AuthMethods, error) {
+	var data AuthMethods
+	err := m.QueryNoCacheCtx(ctx, &data, func(conn *gorm.DB, v interface{}) error {
+		return conn.Model(&AuthMethods{}).Where("auth_type = ? AND user_id = ?", method, userId).First(&data).Error
+	})
+	return &data, err
+}
@@ -0,0 +1,181 @@
+package user
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/perfect-panel/ppanel-server/pkg/cache"
+	"github.com/redis/go-redis/v9"
+	"gorm.io/gorm"
+)
+
+var (
+	cacheUserIdPrefix    = "cache:user:id:"
+	cacheUserEmailPrefix = "cache:user:email:"
+)
+var _ Model = (*customUserModel)(nil)
+
+type (
+	Model interface {
+		userModel
+		customUserLogicModel
+	}
+	userModel interface {
+		Insert(ctx context.Context, data *User, tx ...*gorm.DB) error
+		FindOne(ctx context.Context, id int64) (*User, error)
+		Update(ctx context.Context, data *User, tx ...*gorm.DB) error
+		Delete(ctx context.Context, id int64, tx ...*gorm.DB) error
+		Transaction(ctx context.Context, fn func(db *gorm.DB) error) error
+	}
+
+	customUserModel struct {
+		*defaultUserModel
+	}
+	defaultUserModel struct {
+		cache.CachedConn
+		table string
+	}
+)
+
+func newUserModel(db *gorm.DB, c *redis.Client) *defaultUserModel {
+	return &defaultUserModel{
+		CachedConn: cache.NewConn(db, c),
+		table:      "`user`",
+	}
+}
+
+func (m *defaultUserModel) batchGetCacheKeys(users ...*User) []string {
+	var keys []string
+	for _, user := range users {
+		keys = append(keys, m.getCacheKeys(user)...)
+	}
+	return keys
+
+}
+func (m *defaultUserModel) getCacheKeys(data *User) []string {
+	if data == nil {
+		return []string{}
+	}
+	userIdKey := fmt.Sprintf("%s%v", cacheUserIdPrefix, data.Id)
+	cacheKeys := []string{
+		userIdKey,
+	}
+	// email key
+	if len(data.AuthMethods) > 0 {
+		for _, auth := range data.AuthMethods {
+			if auth.AuthType == "email" {
+				cacheKeys = append(cacheKeys, fmt.Sprintf("%s%v", cacheUserEmailPrefix, auth.AuthIdentifier))
+				break
+			}
+		}
+	}
+	return cacheKeys
+}
+
+func (m *defaultUserModel) FindOneByEmail(ctx context.Context, email string) (*User, error) {
+	var user User
+	key := fmt.Sprintf("%s%v", cacheUserEmailPrefix, email)
+	err := m.QueryCtx(ctx, &user, key, func(conn *gorm.DB, v interface{}) error {
+		var data AuthMethods
+		if err := conn.Model(&AuthMethods{}).Where("`auth_type` = 'email' AND `auth_identifier` = ?", email).First(&data).Error; err != nil {
+			return err
+		}
+		return conn.Model(&User{}).Where("`id` = ?", data.UserId).Preload("UserDevices").Preload("AuthMethods").First(v).Error
+	})
+	return &user, err
+}
+
+func (m *defaultUserModel) Insert(ctx context.Context, data *User, tx ...*gorm.DB) error {
+	err := m.ExecCtx(ctx, func(conn *gorm.DB) error {
+		if len(tx) > 0 {
+			conn = tx[0]
+		}
+		return conn.Create(&data).Error
+	}, m.getCacheKeys(data)...)
+	return err
+}
+
+func (m *defaultUserModel) FindOne(ctx context.Context, id int64) (*User, error) {
+	userIdKey := fmt.Sprintf("%s%v", cacheUserIdPrefix, id)
+	var resp User
+	err := m.QueryCtx(ctx, &resp, userIdKey, func(conn *gorm.DB, v interface{}) error {
+		return conn.Model(&User{}).Where("`id` = ?", id).Preload("UserDevices").Preload("AuthMethods").First(&resp).Error
+	})
+	return &resp, err
+}
+
+func (m *defaultUserModel) Update(ctx context.Context, data *User, tx ...*gorm.DB) error {
+	old, err := m.FindOne(ctx, data.Id)
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+		return err
+	}
+	err = m.ExecCtx(ctx, func(conn *gorm.DB) error {
+		if len(tx) > 0 {
+			conn = tx[0]
+		}
+		return conn.Save(data).Error
+	}, m.getCacheKeys(old)...)
+	return err
+}
+
+func (m *defaultUserModel) Delete(ctx context.Context, id int64, tx ...*gorm.DB) error {
+	data, err := m.FindOne(ctx, id)
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil
+		}
+		return err
+	}
+	err = m.ExecCtx(ctx, func(conn *gorm.DB) error {
+		if len(tx) > 0 {
+			conn = tx[0]
+		}
+		return conn.Transaction(func(db *gorm.DB) error {
+			if err := db.Model(&User{}).Where("`id` = ?", id).Delete(&User{}).Error; err != nil {
+				return err
+			}
+			if err := db.Model(&AuthMethods{}).Where("`user_id` = ?", id).Delete(&User{}).Error; err != nil {
+				return err
+			}
+			if err := db.Model(&Subscribe{}).Where("`user_id` = ?", id).Delete(&User{}).Error; err != nil {
+				return err
+			}
+			if err := db.Model(&BalanceLog{}).Where("`user_id` = ?", id).Delete(&User{}).Error; err != nil {
+				return err
+			}
+			if err := db.Model(&GiftAmountLog{}).Where("`user_id` = ?", id).Delete(&User{}).Error; err != nil {
+				return err
+			}
+			if err := db.Model(&LoginLog{}).Where("`user_id` = ?", id).Delete(&User{}).Error; err != nil {
+				return err
+			}
+			if err := db.Model(&SubscribeLog{}).Where("`user_id` = ?", id).Delete(&User{}).Error; err != nil {
+				return err
+			}
+			if err := db.Model(&Device{}).Where("`user_id` = ?", id).Delete(&User{}).Error; err != nil {
+				return err
+			}
+
+			subs, err := m.QueryUserSubscribe(ctx, id)
+			if err != nil {
+				return err
+			}
+			for _, sub := range subs {
+				if err := m.DeleteSubscribeById(ctx, sub.Id, db); err != nil {
+					return err
+				}
+			}
+
+			if err := db.Model(&CommissionLog{}).Where("`user_id` = ?", id).Delete(&User{}).Error; err != nil {
+				return err
+			}
+			return nil
+		})
+	}, m.getCacheKeys(data)...)
+	return err
+}
+
+func (m *defaultUserModel) Transaction(ctx context.Context, fn func(db *gorm.DB) error) error {
+	return m.TransactCtx(ctx, fn)
+}
@@ -0,0 +1,80 @@
+package user
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"gorm.io/gorm"
+)
+
+func (m *customUserModel) FindOneDevice(ctx context.Context, id int64) (*Device, error) {
+	deviceIdKey := fmt.Sprintf("%s%v", cacheUserDeviceIdPrefix, id)
+	var resp Device
+	err := m.QueryCtx(ctx, &resp, deviceIdKey, func(conn *gorm.DB, v interface{}) error {
+		return conn.Model(&Device{}).Where("`id` = ?", id).First(&resp).Error
+	})
+	switch {
+	case err == nil:
+		return &resp, nil
+	default:
+		return nil, err
+	}
+}
+
+func (m *customUserModel) FindOneDeviceByIdentifier(ctx context.Context, id string) (*Device, error) {
+	deviceIdKey := fmt.Sprintf("%s%v", cacheUserDeviceNumberPrefix, id)
+	var resp Device
+	err := m.QueryCtx(ctx, &resp, deviceIdKey, func(conn *gorm.DB, v interface{}) error {
+		return conn.Model(&Device{}).Where("`identifier` = ?", id).First(&resp).Error
+	})
+	switch {
+	case err == nil:
+		return &resp, nil
+	default:
+		return nil, err
+	}
+}
+
+// QueryDevicePageList  returns a list of records that meet the conditions.
+func (m *customUserModel) QueryDevicePageList(ctx context.Context, userId, subscribeId int64, page, size int) ([]*Device, int64, error) {
+	var list []*Device
+	var total int64
+	err := m.QueryNoCacheCtx(ctx, &list, func(conn *gorm.DB, v interface{}) error {
+		return conn.Model(&Device{}).Where("`user_id` = ? and `subscribe_id` = ?", userId, subscribeId).Count(&total).Limit(size).Offset((page - 1) * size).Find(&list).Error
+	})
+	return list, total, err
+}
+
+func (m *customUserModel) UpdateDevice(ctx context.Context, data *Device, tx ...*gorm.DB) error {
+	old, err := m.FindOneDevice(ctx, data.Id)
+	if err != nil {
+		return err
+	}
+	deviceIdKey := fmt.Sprintf("%s%v", cacheUserDeviceIdPrefix, old.Id)
+	err = m.ExecCtx(ctx, func(conn *gorm.DB) error {
+		if len(tx) > 0 {
+			conn = tx[0]
+		}
+		return conn.Save(data).Error
+	}, deviceIdKey)
+	return err
+}
+
+func (m *customUserModel) DeleteDevice(ctx context.Context, id int64, tx ...*gorm.DB) error {
+	data, err := m.FindOneDevice(ctx, id)
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil
+		}
+		return err
+	}
+	deviceIdKey := fmt.Sprintf("%s%v", cacheUserDeviceIdPrefix, data.Id)
+	err = m.ExecCtx(ctx, func(conn *gorm.DB) error {
+		if len(tx) > 0 {
+			conn = tx[0]
+		}
+		return conn.Delete(&Device{}, id).Error
+	}, deviceIdKey)
+	return err
+}
@@ -0,0 +1,81 @@
+package user
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"gorm.io/gorm"
+)
+
+func (m *customUserModel) InsertSubscribeLog(ctx context.Context, log *SubscribeLog) error {
+	return m.ExecNoCacheCtx(ctx, func(conn *gorm.DB) error {
+		return conn.Create(log).Error
+	})
+}
+
+func (m *customUserModel) FilterSubscribeLogList(ctx context.Context, page, size int, filter *SubscribeLogFilterParams) ([]*SubscribeLog, int64, error) {
+	var list []*SubscribeLog
+	var total int64
+	err := m.QueryNoCacheCtx(ctx, &list, func(conn *gorm.DB, v interface{}) error {
+		query := conn.Model(&SubscribeLog{})
+		if filter != nil {
+			if filter.UserId != 0 {
+				query = query.Where("user_id = ?", filter.UserId)
+			}
+			if filter.UserSubscribeId != 0 {
+				query = query.Where("user_subscribe_id = ?", filter.UserSubscribeId)
+			}
+			if filter.IP != "" {
+				query = query.Where("ip LIKE ?", "%"+filter.IP+"%")
+			}
+			if filter.Token != "" {
+				query = query.Where("token LIKE ?", "%"+filter.Token+"%")
+			}
+			if filter.UserAgent != "" {
+				query = query.Where("user_agent LIKE ?", "%"+filter.UserAgent+"%")
+			}
+		}
+		return query.Count(&total).Limit(size).Offset((page - 1) * size).Find(v).Error
+	})
+
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, 0, err
+	}
+
+	return list, total, nil
+}
+
+func (m *customUserModel) InsertLoginLog(ctx context.Context, log *LoginLog) error {
+	return m.ExecNoCacheCtx(ctx, func(conn *gorm.DB) error {
+		return conn.Create(log).Error
+	})
+}
+
+func (m *customUserModel) FilterLoginLogList(ctx context.Context, page, size int, filter *LoginLogFilterParams) ([]*LoginLog, int64, error) {
+	var list []*LoginLog
+	var total int64
+	err := m.QueryNoCacheCtx(ctx, &list, func(conn *gorm.DB, v interface{}) error {
+		query := conn.Model(&LoginLog{})
+		if filter != nil {
+			if filter.UserId != 0 {
+				query = query.Where("user_id = ?", filter.UserId)
+			}
+			if filter.IP != "" {
+				query = query.Where("ip LIKE ?", "%"+filter.IP+"%")
+			}
+			if filter.UserAgent != "" {
+				query = query.Where("user_agent LIKE ?", "%"+filter.UserAgent+"%")
+			}
+			if filter.Success != nil {
+				query = query.Where("success = ?", *filter.Success)
+			}
+		}
+		return query.Count(&total).Limit(size).Offset((page - 1) * size).Find(v).Error
+	})
+
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, 0, err
+	}
+
+	return list, total, nil
+}
@@ -0,0 +1,400 @@
+package user
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/perfect-panel/ppanel-server/internal/config"
+	"github.com/perfect-panel/ppanel-server/internal/model/server"
+	"github.com/perfect-panel/ppanel-server/internal/model/subscribe"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"github.com/redis/go-redis/v9"
+	"gorm.io/gorm"
+)
+
+const (
+	cacheUserSubscribeTokenPrefix = "cache:user:subscribe:token:"
+	cacheUserSubscribeUserPrefix  = "cache:user:subscribe:user:"
+	cacheUserSubscribeIdPrefix    = "cache:user:subscribe:id:"
+	cacheUserDeviceNumberPrefix   = "cache:user:device:number:"
+	cacheUserDeviceIdPrefix       = "cache:user:device:id:"
+)
+
+type SubscribeDetails struct {
+	Id          int64                `gorm:"primarykey"`
+	UserId      int64                `gorm:"index:idx_user_id;not null;comment:User ID"`
+	User        *User                `gorm:"foreignKey:UserId;references:Id"`
+	OrderId     int64                `gorm:"index:idx_order_id;not null;comment:Order ID"`
+	SubscribeId int64                `gorm:"index:idx_subscribe_id;not null;comment:Subscription ID"`
+	Subscribe   *subscribe.Subscribe `gorm:"foreignKey:SubscribeId;references:Id"`
+	StartTime   time.Time            `gorm:"default:CURRENT_TIMESTAMP(3);not null;comment:Subscription Start Time"`
+	ExpireTime  time.Time            `gorm:"default:NULL;comment:Subscription Expire Time"`
+	Traffic     int64                `gorm:"default:0;comment:Traffic"`
+	Download    int64                `gorm:"default:0;comment:Download Traffic"`
+	Upload      int64                `gorm:"default:0;comment:Upload Traffic"`
+	Token       string               `gorm:"index:idx_token;unique;type:varchar(255);default:'';comment:Token"`
+	UUID        string               `gorm:"type:varchar(255);unique;index:idx_uuid;default:'';comment:UUID"`
+	Status      uint8                `gorm:"type:tinyint(1);default:0;comment:Subscription Status: 0: Pending 1: Active 2: Finished 3: Expired; 4: Cancelled"`
+	CreatedAt   time.Time            `gorm:"<-:create;comment:Creation Time"`
+	UpdatedAt   time.Time            `gorm:"comment:Update Time"`
+}
+
+type SubscribeLogFilterParams struct {
+	IP              string
+	UserAgent       string
+	UserId          int64
+	Token           string
+	UserSubscribeId int64
+}
+
+type LoginLogFilterParams struct {
+	IP        string
+	UserId    int64
+	UserAgent string
+	Success   *bool
+}
+
+type UserFilterParams struct {
+	Search          string
+	UserId          *int64
+	SubscribeId     *int64
+	UserSubscribeId *int64
+}
+
+type customUserLogicModel interface {
+	QueryPageList(ctx context.Context, page, size int, filter *UserFilterParams) ([]*User, int64, error)
+	FindOneByReferCode(ctx context.Context, referCode string) (*User, error)
+	BatchDeleteUser(ctx context.Context, ids []int64, tx ...*gorm.DB) error
+	InsertSubscribe(ctx context.Context, data *Subscribe, tx ...*gorm.DB) error
+	FindOneSubscribeByToken(ctx context.Context, token string) (*Subscribe, error)
+	FindOneSubscribeByOrderId(ctx context.Context, orderId int64) (*Subscribe, error)
+	FindOneSubscribe(ctx context.Context, id int64) (*Subscribe, error)
+	UpdateSubscribe(ctx context.Context, data *Subscribe, tx ...*gorm.DB) error
+	DeleteSubscribe(ctx context.Context, token string, tx ...*gorm.DB) error
+	DeleteSubscribeById(ctx context.Context, id int64, tx ...*gorm.DB) error
+	QueryUserSubscribe(ctx context.Context, userId int64, status ...int64) ([]*SubscribeDetails, error)
+	FindOneSubscribeDetailsById(ctx context.Context, id int64) (*SubscribeDetails, error)
+	FindOneUserSubscribe(ctx context.Context, id int64) (*SubscribeDetails, error)
+	InsertBalanceLog(ctx context.Context, data *BalanceLog, tx ...*gorm.DB) error
+	FindUsersSubscribeBySubscribeId(ctx context.Context, subscribeId int64) ([]*Subscribe, error)
+	UpdateUserSubscribeWithTraffic(ctx context.Context, id, download, upload int64, tx ...*gorm.DB) error
+	QueryResisterUserTotalByDate(ctx context.Context, date time.Time) (int64, error)
+	QueryResisterUserTotalByMonthly(ctx context.Context, date time.Time) (int64, error)
+	QueryResisterUserTotal(ctx context.Context) (int64, error)
+	QueryAdminUsers(ctx context.Context) ([]*User, error)
+	UpdateUserCache(ctx context.Context, data *User) error
+	UpdateUserSubscribeCache(ctx context.Context, data *Subscribe) error
+	InsertCommissionLog(ctx context.Context, data *CommissionLog, tx ...*gorm.DB) error
+	QueryActiveSubscriptions(ctx context.Context, subscribeId ...int64) (map[int64]int64, error)
+	FindUserAuthMethods(ctx context.Context, userId int64) ([]*AuthMethods, error)
+	InsertUserAuthMethods(ctx context.Context, data *AuthMethods, tx ...*gorm.DB) error
+	UpdateUserAuthMethods(ctx context.Context, data *AuthMethods, tx ...*gorm.DB) error
+	DeleteUserAuthMethods(ctx context.Context, userId int64, platform string, tx ...*gorm.DB) error
+	FindUserAuthMethodByOpenID(ctx context.Context, method, openID string) (*AuthMethods, error)
+	FindUserAuthMethodByUserId(ctx context.Context, method string, userId int64) (*AuthMethods, error)
+	FindUserAuthMethodByPlatform(ctx context.Context, userId int64, platform string) (*AuthMethods, error)
+	FindOneByEmail(ctx context.Context, email string) (*User, error)
+	FindOneDevice(ctx context.Context, id int64) (*Device, error)
+	QueryDevicePageList(ctx context.Context, userid, subscribeId int64, page, size int) ([]*Device, int64, error)
+	UpdateDevice(ctx context.Context, data *Device, tx ...*gorm.DB) error
+	FindOneDeviceByIdentifier(ctx context.Context, id string) (*Device, error)
+	DeleteDevice(ctx context.Context, id int64, tx ...*gorm.DB) error
+
+	InsertSubscribeLog(ctx context.Context, log *SubscribeLog) error
+	FilterSubscribeLogList(ctx context.Context, page, size int, filter *SubscribeLogFilterParams) ([]*SubscribeLog, int64, error)
+	InsertLoginLog(ctx context.Context, log *LoginLog) error
+	FilterLoginLogList(ctx context.Context, page, size int, filter *LoginLogFilterParams) ([]*LoginLog, int64, error)
+
+	ClearSubscribeCache(ctx context.Context, data ...*Subscribe) error
+
+	InsertResetSubscribeLog(ctx context.Context, log *ResetSubscribeLog, tx ...*gorm.DB) error
+	UpdateResetSubscribeLog(ctx context.Context, log *ResetSubscribeLog, tx ...*gorm.DB) error
+	FindResetSubscribeLog(ctx context.Context, id int64) (*ResetSubscribeLog, error)
+	DeleteResetSubscribeLog(ctx context.Context, id int64, tx ...*gorm.DB) error
+	FilterResetSubscribeLogList(ctx context.Context, filter *FilterResetSubscribeLogParams) ([]*ResetSubscribeLog, int64, error)
+}
+
+// NewModel returns a model for the database table.
+func NewModel(conn *gorm.DB, c *redis.Client) Model {
+	return &customUserModel{
+		defaultUserModel: newUserModel(conn, c),
+	}
+}
+
+func (m *defaultUserModel) getSubscribeCacheKey(data *Subscribe) []string {
+	if data == nil {
+		return []string{}
+	}
+	var keys []string
+	if data.Token != "" {
+		keys = append(keys, fmt.Sprintf("%s%s", cacheUserSubscribeTokenPrefix, data.Token))
+	}
+	if data.UserId != 0 {
+		keys = append(keys, fmt.Sprintf("%s%d", cacheUserSubscribeUserPrefix, data.UserId))
+	}
+	if data.Id != 0 {
+		keys = append(keys, fmt.Sprintf("%s%d", cacheUserSubscribeIdPrefix, data.Id))
+	}
+
+	if data.SubscribeId != 0 {
+		var sub *subscribe.Subscribe
+		err := m.QueryNoCacheCtx(context.Background(), &sub, func(conn *gorm.DB, v interface{}) error {
+			return conn.Model(&subscribe.Subscribe{}).Where("id = ?", data.SubscribeId).First(&sub).Error
+		})
+		if err != nil {
+			logger.Error("getUserSubscribeCacheKey", logger.Field("error", err.Error()), logger.Field("subscribeId", data.SubscribeId))
+			return keys
+		}
+		if sub.Server != "" {
+			ids := tool.StringToInt64Slice(sub.Server)
+			for _, id := range ids {
+				keys = append(keys, fmt.Sprintf("%s%d", config.ServerUserListCacheKey, id))
+			}
+		}
+		if sub.ServerGroup != "" {
+			ids := tool.StringToInt64Slice(sub.ServerGroup)
+			var servers []*server.Server
+			err = m.QueryNoCacheCtx(context.Background(), &servers, func(conn *gorm.DB, v interface{}) error {
+				return conn.Model(&server.Server{}).Where("group_id in ?", ids).Find(v).Error
+			})
+			if err != nil {
+				logger.Error("getUserSubscribeCacheKey", logger.Field("error", err.Error()), logger.Field("subscribeId", data.SubscribeId))
+				return keys
+			}
+			for _, s := range servers {
+				keys = append(keys, fmt.Sprintf("%s%d", config.ServerUserListCacheKey, s.Id))
+			}
+		}
+	}
+
+	return keys
+
+}
+
+// QueryPageList returns a list of records that meet the conditions.
+func (m *customUserModel) QueryPageList(ctx context.Context, page, size int, filter *UserFilterParams) ([]*User, int64, error) {
+	var list []*User
+	var total int64
+	err := m.QueryNoCacheCtx(ctx, &list, func(conn *gorm.DB, v interface{}) error {
+		if filter != nil {
+			if filter.UserId != nil {
+				conn = conn.Where("user.id =?", *filter.UserId)
+			}
+			if filter.Search != "" {
+				conn = conn.Joins("LEFT JOIN user_auth_methods ON user.id = user_auth_methods.user_id").
+					Where("user_auth_methods.auth_identifier LIKE ?", "%"+filter.Search+"%").Or("user.refer_code like ?", "%"+filter.Search+"%")
+			}
+			if filter.UserSubscribeId != nil {
+				conn = conn.Joins("LEFT JOIN user_subscribe ON user.id = user_subscribe.user_id").
+					Where("user_subscribe.id =? and `status` IN (0,1)", *filter.UserSubscribeId)
+			}
+			if filter.SubscribeId != nil {
+				conn = conn.Joins("LEFT JOIN user_subscribe ON user.id = user_subscribe.user_id").
+					Where("user_subscribe.subscribe_id =? and `status` IN (0,1)", *filter.SubscribeId)
+			}
+		}
+		return conn.Model(&User{}).Group("user.id").Count(&total).Limit(size).Offset((page - 1) * size).Preload("UserDevices").Preload("AuthMethods").Find(&list).Error
+	})
+	return list, total, err
+}
+
+// BatchDeleteUser deletes multiple records by primary key.
+func (m *customUserModel) BatchDeleteUser(ctx context.Context, ids []int64, tx ...*gorm.DB) error {
+	var users []*User
+	err := m.QueryNoCacheCtx(ctx, &users, func(conn *gorm.DB, v interface{}) error {
+		if len(tx) > 0 {
+			conn = tx[0]
+		}
+		return conn.Where("id in ?", ids).Find(&users).Error
+	})
+	if err != nil {
+		return err
+	}
+	return m.ExecCtx(ctx, func(conn *gorm.DB) error {
+		return conn.Where("id in ?", ids).Delete(&User{}).Error
+	}, m.batchGetCacheKeys(users...)...)
+}
+
+// InsertBalanceLog insert BalanceLog into the database.
+func (m *customUserModel) InsertBalanceLog(ctx context.Context, data *BalanceLog, tx ...*gorm.DB) error {
+	return m.ExecNoCacheCtx(ctx, func(conn *gorm.DB) error {
+		if len(tx) > 0 {
+			conn = tx[0]
+		}
+		return conn.Create(data).Error
+	})
+}
+
+// FindUserBalanceLogList returns a list of records that meet the conditions.
+func (m *customUserModel) FindUserBalanceLogList(ctx context.Context, userId int64, page, size int) ([]*BalanceLog, int64, error) {
+	var list []*BalanceLog
+	var total int64
+	err := m.QueryNoCacheCtx(ctx, &list, func(conn *gorm.DB, v interface{}) error {
+
+		return conn.Model(&BalanceLog{}).Where("`user_id` = ?", userId).Count(&total).Limit(size).Offset((page - 1) * size).Find(&list).Error
+	})
+	return list, total, err
+}
+
+func (m *customUserModel) UpdateUserSubscribeWithTraffic(ctx context.Context, id, download, upload int64, tx ...*gorm.DB) error {
+	sub, err := m.FindOneSubscribe(ctx, id)
+	if err != nil {
+		return err
+	}
+	return m.ExecCtx(ctx, func(conn *gorm.DB) error {
+		if len(tx) > 0 {
+			conn = tx[0]
+		}
+		return conn.Model(&Subscribe{}).Where("id = ?", id).Updates(map[string]interface{}{
+			"download": gorm.Expr("download + ?", download),
+			"upload":   gorm.Expr("upload + ?", upload),
+		}).Error
+	}, m.getSubscribeCacheKey(sub)...)
+}
+
+func (m *customUserModel) QueryResisterUserTotalByDate(ctx context.Context, date time.Time) (int64, error) {
+	var total int64
+	start := date.Truncate(24 * time.Hour)
+	end := start.Add(24 * time.Hour).Add(-time.Second)
+	err := m.QueryNoCacheCtx(ctx, &total, func(conn *gorm.DB, v interface{}) error {
+		return conn.Model(&User{}).Where("created_at > ? and created_at < ?", start, end).Count(&total).Error
+	})
+	return total, err
+}
+
+func (m *customUserModel) QueryResisterUserTotalByMonthly(ctx context.Context, date time.Time) (int64, error) {
+	var total int64
+	start := time.Date(date.Year(), date.Month(), 1, 0, 0, 0, 0, time.Local)
+	end := start.AddDate(0, 1, 0).Add(-time.Nanosecond)
+	err := m.QueryNoCacheCtx(ctx, &total, func(conn *gorm.DB, v interface{}) error {
+		return conn.Model(&User{}).Where("created_at > ? and created_at < ?", start, end).Count(&total).Error
+	})
+	return total, err
+}
+
+func (m *customUserModel) QueryResisterUserTotal(ctx context.Context) (int64, error) {
+	var total int64
+	err := m.QueryNoCacheCtx(ctx, &total, func(conn *gorm.DB, v interface{}) error {
+		return conn.Model(&User{}).Count(&total).Error
+	})
+	return total, err
+}
+
+func (m *customUserModel) QueryAdminUsers(ctx context.Context) ([]*User, error) {
+	var data []*User
+	err := m.QueryNoCacheCtx(ctx, &data, func(conn *gorm.DB, v interface{}) error {
+		return conn.Model(&User{}).Preload("AuthMethods").Where("is_admin = ?", true).Find(&data).Error
+	})
+	return data, err
+}
+
+func (m *customUserModel) UpdateUserCache(ctx context.Context, data *User) error {
+	return m.CachedConn.DelCacheCtx(ctx, m.getCacheKeys(data)...)
+}
+
+func (m *customUserModel) InsertCommissionLog(ctx context.Context, data *CommissionLog, tx ...*gorm.DB) error {
+	return m.ExecNoCacheCtx(ctx, func(conn *gorm.DB) error {
+		if len(tx) > 0 {
+			conn = tx[0]
+		}
+		return conn.Model(&CommissionLog{}).Create(data).Error
+	})
+}
+
+func (m *customUserModel) FindOneByReferCode(ctx context.Context, referCode string) (*User, error) {
+	var data User
+	err := m.QueryNoCacheCtx(ctx, &data, func(conn *gorm.DB, v interface{}) error {
+		return conn.Model(&User{}).Where("refer_code = ?", referCode).First(&data).Error
+	})
+	return &data, err
+}
+
+func (m *customUserModel) FindOneSubscribeDetailsById(ctx context.Context, id int64) (*SubscribeDetails, error) {
+	var data SubscribeDetails
+	err := m.QueryNoCacheCtx(ctx, &data, func(conn *gorm.DB, v interface{}) error {
+		return conn.Model(&Subscribe{}).Preload("Subscribe").Preload("User").Where("id = ?", id).First(&data).Error
+	})
+	return &data, err
+}
+
+func (m *customUserModel) InsertResetSubscribeLog(ctx context.Context, log *ResetSubscribeLog, tx ...*gorm.DB) error {
+	return m.ExecNoCacheCtx(ctx, func(conn *gorm.DB) error {
+		if len(tx) > 0 {
+			conn = tx[0]
+		}
+		return conn.Model(&ResetSubscribeLog{}).Create(log).Error
+	})
+}
+
+func (m *customUserModel) UpdateResetSubscribeLog(ctx context.Context, log *ResetSubscribeLog, tx ...*gorm.DB) error {
+	return m.ExecNoCacheCtx(ctx, func(conn *gorm.DB) error {
+		if len(tx) > 0 {
+			conn = tx[0]
+		}
+		return conn.Model(&ResetSubscribeLog{}).Where("id = ?", log.Id).Updates(log).Error
+	})
+}
+
+func (m *customUserModel) FindResetSubscribeLog(ctx context.Context, id int64) (*ResetSubscribeLog, error) {
+	var data ResetSubscribeLog
+	err := m.QueryNoCacheCtx(ctx, &data, func(conn *gorm.DB, v interface{}) error {
+		return conn.Model(&ResetSubscribeLog{}).Where("id = ?", id).First(&data).Error
+	})
+	return &data, err
+}
+
+func (m *customUserModel) DeleteResetSubscribeLog(ctx context.Context, id int64, tx ...*gorm.DB) error {
+	return m.ExecNoCacheCtx(ctx, func(conn *gorm.DB) error {
+		if len(tx) > 0 {
+			conn = tx[0]
+		}
+		return conn.Model(&ResetSubscribeLog{}).Where("id = ?", id).Delete(&ResetSubscribeLog{}).Error
+	})
+}
+
+func (m *customUserModel) FilterResetSubscribeLogList(ctx context.Context, filter *FilterResetSubscribeLogParams) ([]*ResetSubscribeLog, int64, error) {
+	if filter == nil {
+		return nil, 0, errors.New("filter params is nil")
+	}
+
+	var list []*ResetSubscribeLog
+	var total int64
+
+	err := m.QueryNoCacheCtx(ctx, &list, func(conn *gorm.DB, v interface{}) error {
+		query := conn.Model(&ResetSubscribeLog{})
+
+		// 应用筛选条件
+		if filter.UserId != 0 {
+			query = query.Where("user_id = ?", filter.UserId)
+		}
+		if filter.UserSubscribeId != 0 {
+			query = query.Where("user_subscribe_id = ?", filter.UserSubscribeId)
+		}
+		if filter.Type != 0 {
+			query = query.Where("type = ?", filter.Type)
+		}
+		if filter.OrderNo != "" {
+			query = query.Where("order_no = ?", filter.OrderNo)
+		}
+
+		// 计算总数
+		if err := query.Count(&total).Error; err != nil {
+			return err
+		}
+
+		// 应用分页
+		if filter.Page > 0 && filter.Size > 0 {
+			query = query.Offset((filter.Page - 1) * filter.Size)
+		}
+		if filter.Size > 0 {
+			query = query.Limit(filter.Size)
+		}
+
+		return query.Find(&list).Error
+	})
+
+	return list, total, err
+}
@@ -0,0 +1,160 @@
+package user
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"gorm.io/gorm"
+)
+
+func (m *defaultUserModel) UpdateUserSubscribeCache(ctx context.Context, data *Subscribe) error {
+	return m.CachedConn.DelCacheCtx(ctx, m.getSubscribeCacheKey(data)...)
+}
+
+// QueryActiveSubscriptions returns the number of active subscriptions.
+func (m *defaultUserModel) QueryActiveSubscriptions(ctx context.Context, subscribeId ...int64) (map[int64]int64, error) {
+	type SubscriptionCount struct {
+		SubscribeId int64
+		Total       int64
+	}
+	var result []SubscriptionCount
+	err := m.QueryNoCacheCtx(ctx, &result, func(conn *gorm.DB, v interface{}) error {
+		return conn.Model(&Subscribe{}).
+			Where("subscribe_id IN ? AND `status` IN ?", subscribeId, []int64{1, 0, 3}).
+			Select("subscribe_id, COUNT(id) as total").
+			Group("subscribe_id").
+			Scan(&result).
+			Error
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	resultMap := make(map[int64]int64)
+	for _, item := range result {
+		resultMap[item.SubscribeId] = item.Total
+	}
+
+	return resultMap, nil
+}
+
+func (m *defaultUserModel) FindOneSubscribeByOrderId(ctx context.Context, orderId int64) (*Subscribe, error) {
+	var data Subscribe
+	err := m.QueryNoCacheCtx(ctx, &data, func(conn *gorm.DB, v interface{}) error {
+		return conn.Model(&Subscribe{}).Where("order_id = ?", orderId).First(&data).Error
+	})
+	return &data, err
+}
+
+func (m *defaultUserModel) FindOneSubscribe(ctx context.Context, id int64) (*Subscribe, error) {
+	var data Subscribe
+	key := fmt.Sprintf("%s%d", cacheUserSubscribeIdPrefix, id)
+	err := m.QueryCtx(ctx, &data, key, func(conn *gorm.DB, v interface{}) error {
+		return conn.Model(&Subscribe{}).Where("id = ?", id).First(&data).Error
+	})
+	return &data, err
+
+}
+
+func (m *defaultUserModel) FindUsersSubscribeBySubscribeId(ctx context.Context, subscribeId int64) ([]*Subscribe, error) {
+	var data []*Subscribe
+	err := m.QueryNoCacheCtx(ctx, &data, func(conn *gorm.DB, v interface{}) error {
+		return conn.Model(&Subscribe{}).Where("subscribe_id = ? AND `status` IN ?", subscribeId, []int64{1, 0}).Find(&data).Error
+	})
+	return data, err
+}
+
+// QueryUserSubscribe returns a list of records that meet the conditions.
+func (m *defaultUserModel) QueryUserSubscribe(ctx context.Context, userId int64, status ...int64) ([]*SubscribeDetails, error) {
+	var list []*SubscribeDetails
+	key := fmt.Sprintf("%s%d", cacheUserSubscribeUserPrefix, userId)
+	err := m.QueryCtx(ctx, &list, key, func(conn *gorm.DB, v interface{}) error {
+		// 获取当前时间
+		now := time.Now()
+		// 获取当前时间向前推 7 天
+		sevenDaysAgo := time.Now().Add(-7 * 24 * time.Hour)
+		// 基础条件查询
+		conn = conn.Model(&Subscribe{}).Where("`user_id` = ? and `status` IN ?", userId, status)
+		return conn.Where("`expire_time` > ? OR `finished_at` >= ?", now, sevenDaysAgo).
+			Preload("Subscribe").
+			Find(&list).Error
+	})
+	return list, err
+}
+
+// FindOneUserSubscribe  finds a subscribeDetails by id.
+func (m *defaultUserModel) FindOneUserSubscribe(ctx context.Context, id int64) (subscribeDetails *SubscribeDetails, err error) {
+	//TODO cache
+	//key := fmt.Sprintf("%s%d", cacheUserSubscribeUserPrefix, userId)
+	err = m.QueryNoCacheCtx(ctx, subscribeDetails, func(conn *gorm.DB, v interface{}) error {
+		return conn.Model(&Subscribe{}).Preload("Subscribe").Where("id = ?", id).First(&subscribeDetails).Error
+	})
+	return
+}
+
+// FindOneSubscribeByToken  finds a record by token.
+func (m *defaultUserModel) FindOneSubscribeByToken(ctx context.Context, token string) (*Subscribe, error) {
+	var data Subscribe
+	key := fmt.Sprintf("%s%s", cacheUserSubscribeTokenPrefix, token)
+	err := m.QueryCtx(ctx, &data, key, func(conn *gorm.DB, v interface{}) error {
+		return conn.Model(&Subscribe{}).Where("token = ?", token).First(&data).Error
+	})
+	return &data, err
+}
+
+// UpdateSubscribe updates a record.
+func (m *defaultUserModel) UpdateSubscribe(ctx context.Context, data *Subscribe, tx ...*gorm.DB) error {
+	return m.ExecCtx(ctx, func(conn *gorm.DB) error {
+		if len(tx) > 0 {
+			conn = tx[0]
+		}
+		return conn.Model(&Subscribe{}).Where("token = ?", data.Token).Save(data).Error
+	}, m.getSubscribeCacheKey(data)...)
+}
+
+// DeleteSubscribe deletes a record.
+func (m *defaultUserModel) DeleteSubscribe(ctx context.Context, token string, tx ...*gorm.DB) error {
+	data, err := m.FindOneSubscribeByToken(ctx, token)
+	if err != nil {
+		return err
+	}
+	return m.ExecCtx(ctx, func(conn *gorm.DB) error {
+		if len(tx) > 0 {
+			conn = tx[0]
+		}
+		return conn.Where("token = ?", token).Delete(&Subscribe{}).Error
+	}, m.getSubscribeCacheKey(data)...)
+}
+
+// InsertSubscribe insert Subscribe into the database.
+func (m *defaultUserModel) InsertSubscribe(ctx context.Context, data *Subscribe, tx ...*gorm.DB) error {
+	return m.ExecCtx(ctx, func(conn *gorm.DB) error {
+		if len(tx) > 0 {
+			conn = tx[0]
+		}
+		return conn.Create(data).Error
+	}, m.getSubscribeCacheKey(data)...)
+}
+
+func (m *defaultUserModel) DeleteSubscribeById(ctx context.Context, id int64, tx ...*gorm.DB) error {
+	data, err := m.FindOneSubscribe(ctx, id)
+	if err != nil {
+		return err
+	}
+	return m.ExecCtx(ctx, func(conn *gorm.DB) error {
+		if len(tx) > 0 {
+			conn = tx[0]
+		}
+		return conn.Where("id = ?", id).Delete(&Subscribe{}).Error
+	}, m.getSubscribeCacheKey(data)...)
+}
+
+func (m *defaultUserModel) ClearSubscribeCache(ctx context.Context, data ...*Subscribe) error {
+	var keys []string
+	for _, item := range data {
+		keys = append(keys, m.getSubscribeCacheKey(item)...)
+	}
+	return m.CachedConn.DelCacheCtx(ctx, keys...)
+}
@@ -0,0 +1,230 @@
+package user
+
+import (
+	"time"
+
+	"gorm.io/gorm"
+	"gorm.io/plugin/soft_delete"
+)
+
+type User struct {
+	Id                    int64         `gorm:"primaryKey"`
+	Password              string        `gorm:"type:varchar(100);not null;comment:User Password"`
+	Avatar                string        `gorm:"type:MEDIUMTEXT;comment:User Avatar"`
+	Balance               int64         `gorm:"default:0;comment:User Balance"` // User Balance Amount
+	ReferCode             string        `gorm:"type:varchar(20);default:'';comment:Referral Code"`
+	RefererId             int64         `gorm:"index:idx_referer;comment:Referrer ID"`
+	Commission            int64         `gorm:"default:0;comment:Commission"` // Commission Amount
+	GiftAmount            int64         `gorm:"default:0;comment:User Gift Amount"`
+	Enable                *bool         `gorm:"default:true;not null;comment:Is Account Enabled"`
+	IsAdmin               *bool         `gorm:"default:false;not null;comment:Is Admin"`
+	EnableBalanceNotify   *bool         `gorm:"default:false;not null;comment:Enable Balance Change Notifications"`
+	EnableLoginNotify     *bool         `gorm:"default:false;not null;comment:Enable Login Notifications"`
+	EnableSubscribeNotify *bool         `gorm:"default:false;not null;comment:Enable Subscription Notifications"`
+	EnableTradeNotify     *bool         `gorm:"default:false;not null;comment:Enable Trade Notifications"`
+	AuthMethods           []AuthMethods `gorm:"foreignKey:UserId;references:Id"`
+	UserDevices           []Device      `gorm:"foreignKey:UserId;references:Id"`
+	CreatedAt             time.Time     `gorm:"<-:create;comment:Creation Time"`
+	UpdatedAt             time.Time     `gorm:"comment:Update Time"`
+}
+
+func (User) TableName() string {
+	return "user"
+}
+
+type OldUser struct {
+	Id    int64  `gorm:"primaryKey"`
+	Email string `gorm:"index:idx_email;type:varchar(100);comment:Email"`
+	//Telephone             string                `gorm:"index:idx_telephone;type:varchar(20);default:'';comment:Telephone"`
+	//TelephoneAreaCode     string                `gorm:"index:idx_telephone;type:varchar(20);default:'';comment:TelephoneAreaCode"`
+	Password              string                `gorm:"type:varchar(100);not null;comment:User Password"`
+	Avatar                string                `gorm:"type:varchar(200);default:'';comment:User Avatar"`
+	Balance               int64                 `gorm:"default:0;comment:User Balance"` // User Balance Amount
+	Telegram              int64                 `gorm:"default:null;comment:Telegram Account"`
+	ReferCode             string                `gorm:"type:varchar(20);default:'';comment:Referral Code"`
+	RefererId             int64                 `gorm:"index:idx_referer;comment:Referrer ID"`
+	Commission            int64                 `gorm:"default:0;comment:Commission"` // Commission Amount
+	GiftAmount            int64                 `gorm:"default:0;comment:User Gift Amount"`
+	Enable                *bool                 `gorm:"default:true;not null;comment:Is Account Enabled"`
+	IsAdmin               *bool                 `gorm:"default:false;not null;comment:Is Admin"`
+	ValidEmail            *bool                 `gorm:"default:false;not null;comment:Is Email Verified"`
+	EnableEmailNotify     *bool                 `gorm:"default:false;not null;comment:Enable Email Notifications"`
+	EnableTelegramNotify  *bool                 `gorm:"default:false;not null;comment:Enable Telegram Notifications"`
+	EnableBalanceNotify   *bool                 `gorm:"default:false;not null;comment:Enable Balance Change Notifications"`
+	EnableLoginNotify     *bool                 `gorm:"default:false;not null;comment:Enable Login Notifications"`
+	EnableSubscribeNotify *bool                 `gorm:"default:false;not null;comment:Enable Subscription Notifications"`
+	EnableTradeNotify     *bool                 `gorm:"default:false;not null;comment:Enable Trade Notifications"`
+	CreatedAt             time.Time             `gorm:"<-:create;comment:Creation Time"`
+	UpdatedAt             time.Time             `gorm:"comment:Update Time"`
+	DeletedAt             gorm.DeletedAt        `gorm:"default:null;comment:Deletion Time"`
+	IsDel                 soft_delete.DeletedAt `gorm:"softDelete:flag,DeletedAtField:DeletedAt;comment:1: Normal 0: Deleted"` // Using `1` and `0` to indicate
+}
+
+func (OldUser) TableName() string {
+	return "user"
+}
+
+type Subscribe struct {
+	Id          int64      `gorm:"primaryKey"`
+	UserId      int64      `gorm:"index:idx_user_id;not null;comment:User ID"`
+	User        User       `gorm:"foreignKey:UserId;references:Id"`
+	OrderId     int64      `gorm:"index:idx_order_id;not null;comment:Order ID"`
+	SubscribeId int64      `gorm:"index:idx_subscribe_id;not null;comment:Subscription ID"`
+	StartTime   time.Time  `gorm:"default:CURRENT_TIMESTAMP(3);not null;comment:Subscription Start Time"`
+	ExpireTime  time.Time  `gorm:"default:NULL;comment:Subscription Expire Time"`
+	FinishedAt  *time.Time `gorm:"default:NULL;comment:Finished Time"`
+	Traffic     int64      `gorm:"default:0;comment:Traffic"`
+	Download    int64      `gorm:"default:0;comment:Download Traffic"`
+	Upload      int64      `gorm:"default:0;comment:Upload Traffic"`
+	Token       string     `gorm:"index:idx_token;unique;type:varchar(255);default:'';comment:Token"`
+	UUID        string     `gorm:"type:varchar(255);unique;index:idx_uuid;default:'';comment:UUID"`
+	Status      uint8      `gorm:"type:tinyint(1);default:0;comment:Subscription Status: 0: Pending 1: Active 2: Finished 3: Expired 4: Deducted"`
+	CreatedAt   time.Time  `gorm:"<-:create;comment:Creation Time"`
+	UpdatedAt   time.Time  `gorm:"comment:Update Time"`
+}
+
+func (Subscribe) TableName() string {
+	return "user_subscribe"
+}
+
+type BalanceLog struct {
+	Id        int64     `gorm:"primaryKey"`
+	UserId    int64     `gorm:"index:idx_user_id;not null;comment:User ID"`
+	Amount    int64     `gorm:"not null;comment:Amount"`
+	Type      uint8     `gorm:"type:tinyint(1);not null;comment:Type: 1: Recharge 2: Withdraw 3: Payment 4: Refund 5: Reward"`
+	OrderId   int64     `gorm:"default:null;comment:Order ID"`
+	Balance   int64     `gorm:"not null;comment:Balance"`
+	CreatedAt time.Time `gorm:"<-:create;comment:Creation Time"`
+}
+
+func (BalanceLog) TableName() string {
+	return "user_balance_log"
+}
+
+type GiftAmountLog struct {
+	Id              int64     `gorm:"primaryKey"`
+	UserId          int64     `gorm:"index:idx_user_id;not null;comment:User ID"`
+	UserSubscribeId int64     `gorm:"default:null;comment:Deduction User Subscribe ID"`
+	OrderNo         string    `gorm:"default:null;comment:Order No."`
+	Type            uint8     `gorm:"type:tinyint(1);not null;comment:Type: 1: Increase 2: Reduce"`
+	Amount          int64     `gorm:"not null;comment:Amount"`
+	Balance         int64     `gorm:"not null;comment:Balance"`
+	Remark          string    `gorm:"type:varchar(255);default:'';comment:Remark"`
+	CreatedAt       time.Time `gorm:"<-:create;comment:Creation Time"`
+}
+
+func (GiftAmountLog) TableName() string {
+	return "user_gift_amount_log"
+}
+
+type CommissionLog struct {
+	Id        int64     `gorm:"primaryKey"`
+	UserId    int64     `gorm:"index:idx_user_id;not null;comment:User ID"`
+	OrderNo   string    `gorm:"default:null;comment:Order No."`
+	Amount    int64     `gorm:"not null;comment:Amount"`
+	CreatedAt time.Time `gorm:"<-:create;comment:Creation Time"`
+}
+
+func (CommissionLog) TableName() string {
+	return "user_commission_log"
+}
+
+type AuthMethods struct {
+	Id             int64     `gorm:"primaryKey"`
+	UserId         int64     `gorm:"index:idx_user_id;not null;comment:User ID"`
+	AuthType       string    `gorm:"type:varchar(255);not null;comment:Auth Type 1: apple 2: google 3: github 4: facebook 5: telegram 6: email 7: mobile 8: device"`
+	AuthIdentifier string    `gorm:"type:varchar(255);unique;index:idx_auth_identifier;not null;comment:Auth Identifier"`
+	Verified       bool      `gorm:"default:false;not null;comment:Is Verified"`
+	CreatedAt      time.Time `gorm:"<-:create;comment:Creation Time"`
+	UpdatedAt      time.Time `gorm:"comment:Update Time"`
+}
+
+func (AuthMethods) TableName() string {
+	return "user_auth_methods"
+}
+
+type Device struct {
+	Id         int64     `gorm:"primaryKey"`
+	Ip         string    `gorm:"type:varchar(255);not null;comment:Device IP"`
+	UserId     int64     `gorm:"index:idx_user_id;not null;comment:User ID"`
+	UserAgent  string    `gorm:"default:null;comment:UserAgent."`
+	Identifier string    `gorm:"type:varchar(255);unique;index:idx_identifier;default:'';comment:Device Identifier"`
+	Online     bool      `gorm:"default:false;not null;comment:Online"`
+	Enabled    bool      `gorm:"default:true;not null;comment:Enabled"`
+	CreatedAt  time.Time `gorm:"<-:create;comment:Creation Time"`
+	UpdatedAt  time.Time `gorm:"comment:Update Time"`
+}
+
+func (Device) TableName() string {
+	return "user_device"
+}
+
+type DeviceOnlineRecord struct {
+	Id            int64     `gorm:"primaryKey"`
+	UserId        int64     `gorm:"type:bigint;not null;comment:User ID"`
+	Identifier    string    `gorm:"type:varchar(255);not null;comment:Device Identifier"`
+	OnlineTime    time.Time `gorm:"comment:Online Time"` // The time when the device goes online
+	OfflineTime   time.Time `gorm:"comment:Offline Time"`
+	OnlineSeconds int64     `gorm:"comment:Offline Seconds"`
+	DurationDays  int64     `gorm:"comment:Duration Days"`
+	CreatedAt     time.Time `gorm:"<-:create;comment:Creation Time"`
+}
+
+func (DeviceOnlineRecord) TableName() string {
+	return "user_device_online_record"
+}
+
+type LoginLog struct {
+	Id        int64     `gorm:"primaryKey"`
+	UserId    int64     `gorm:"index:idx_user_id;not null;comment:User ID"`
+	LoginIP   string    `gorm:"type:varchar(255);not null;comment:Login IP"`
+	UserAgent string    `gorm:"type:text;not null;comment:UserAgent"`
+	Success   *bool     `gorm:"default:false;not null;comment:Login Success"`
+	CreatedAt time.Time `gorm:"<-:create;comment:Creation Time"`
+}
+
+func (LoginLog) TableName() string {
+	return "user_login_log"
+}
+
+type SubscribeLog struct {
+	Id              int64     `gorm:"primaryKey"`
+	UserId          int64     `gorm:"index:idx_user_id;not null;comment:User ID"`
+	UserSubscribeId int64     `gorm:"index:idx_user_subscribe_id;not null;comment:User Subscribe ID"`
+	Token           string    `gorm:"type:varchar(255);not null;comment:Token"`
+	IP              string    `gorm:"type:varchar(255);not null;comment:IP"`
+	UserAgent       string    `gorm:"type:text;not null;comment:UserAgent"`
+	CreatedAt       time.Time `gorm:"<-:create;comment:Creation Time"`
+}
+
+func (SubscribeLog) TableName() string {
+	return "user_subscribe_log"
+}
+
+const (
+	ResetSubscribeTypeAuto    uint8 = 1
+	ResetSubscribeTypeAdvance uint8 = 2
+	ResetSubscribeTypePaid    uint8 = 3
+)
+
+type FilterResetSubscribeLogParams struct {
+	Page            int
+	Size            int
+	Type            uint8
+	UserId          int64
+	OrderNo         string
+	UserSubscribeId int64
+}
+
+type ResetSubscribeLog struct {
+	Id              int64     `gorm:"primaryKey"`
+	UserId          int64     `gorm:"type:bigint;index:idx_user_id;not null;comment:User ID"`
+	Type            uint8     `gorm:"type:tinyint(1);not null;comment:Type: 1: Auto 2: Advance 3: Paid"`
+	OrderNo         string    `gorm:"type:varchar(255);default:null;comment:Order No."`
+	UserSubscribeId int64     `gorm:"type:bigint;index:idx_user_subscribe_id;not null;comment:User Subscribe ID"`
+	CreatedAt       time.Time `gorm:"<-:create;comment:Creation Time"`
+}
+
+func (ResetSubscribeLog) TableName() string {
+	return "user_reset_subscribe_log"
+}