调整日志输出方式，更新数据库日志存储结构；首页查询统计数据接口实现

web/queries/gen.go

@@ -28,7 +28,10 @@ var (
 	ClientPermissionLink    *clientPermissionLink
 	Coupon                  *coupon
 	Edge                    *edge
+	LogsLogin               *logsLogin
 	LogsRequest             *logsRequest
+	LogsUserBandwidth       *logsUserBandwidth
+	LogsUserUsage           *logsUserUsage
 	Permission              *permission
 	Product                 *product
 	Proxy                   *proxy
@@ -58,7 +61,10 @@ func SetDefault(db *gorm.DB, opts ...gen.DOOption) {
 	ClientPermissionLink = &Q.ClientPermissionLink
 	Coupon = &Q.Coupon
 	Edge = &Q.Edge
+	LogsLogin = &Q.LogsLogin
 	LogsRequest = &Q.LogsRequest
+	LogsUserBandwidth = &Q.LogsUserBandwidth
+	LogsUserUsage = &Q.LogsUserUsage
 	Permission = &Q.Permission
 	Product = &Q.Product
 	Proxy = &Q.Proxy
@@ -89,7 +95,10 @@ func Use(db *gorm.DB, opts ...gen.DOOption) *Query {
 		ClientPermissionLink:    newClientPermissionLink(db, opts...),
 		Coupon:                  newCoupon(db, opts...),
 		Edge:                    newEdge(db, opts...),
+		LogsLogin:               newLogsLogin(db, opts...),
 		LogsRequest:             newLogsRequest(db, opts...),
+		LogsUserBandwidth:       newLogsUserBandwidth(db, opts...),
+		LogsUserUsage:           newLogsUserUsage(db, opts...),
 		Permission:              newPermission(db, opts...),
 		Product:                 newProduct(db, opts...),
 		Proxy:                   newProxy(db, opts...),
@@ -121,7 +130,10 @@ type Query struct {
 	ClientPermissionLink    clientPermissionLink
 	Coupon                  coupon
 	Edge                    edge
+	LogsLogin               logsLogin
 	LogsRequest             logsRequest
+	LogsUserBandwidth       logsUserBandwidth
+	LogsUserUsage           logsUserUsage
 	Permission              permission
 	Product                 product
 	Proxy                   proxy
@@ -154,7 +166,10 @@ func (q *Query) clone(db *gorm.DB) *Query {
 		ClientPermissionLink:    q.ClientPermissionLink.clone(db),
 		Coupon:                  q.Coupon.clone(db),
 		Edge:                    q.Edge.clone(db),
+		LogsLogin:               q.LogsLogin.clone(db),
 		LogsRequest:             q.LogsRequest.clone(db),
+		LogsUserBandwidth:       q.LogsUserBandwidth.clone(db),
+		LogsUserUsage:           q.LogsUserUsage.clone(db),
 		Permission:              q.Permission.clone(db),
 		Product:                 q.Product.clone(db),
 		Proxy:                   q.Proxy.clone(db),
@@ -194,7 +209,10 @@ func (q *Query) ReplaceDB(db *gorm.DB) *Query {
 		ClientPermissionLink:    q.ClientPermissionLink.replaceDB(db),
 		Coupon:                  q.Coupon.replaceDB(db),
 		Edge:                    q.Edge.replaceDB(db),
+		LogsLogin:               q.LogsLogin.replaceDB(db),
 		LogsRequest:             q.LogsRequest.replaceDB(db),
+		LogsUserBandwidth:       q.LogsUserBandwidth.replaceDB(db),
+		LogsUserUsage:           q.LogsUserUsage.replaceDB(db),
 		Permission:              q.Permission.replaceDB(db),
 		Product:                 q.Product.replaceDB(db),
 		Proxy:                   q.Proxy.replaceDB(db),
@@ -224,7 +242,10 @@ type queryCtx struct {
 	ClientPermissionLink    *clientPermissionLinkDo
 	Coupon                  *couponDo
 	Edge                    *edgeDo
+	LogsLogin               *logsLoginDo
 	LogsRequest             *logsRequestDo
+	LogsUserBandwidth       *logsUserBandwidthDo
+	LogsUserUsage           *logsUserUsageDo
 	Permission              *permissionDo
 	Product                 *productDo
 	Proxy                   *proxyDo
@@ -254,7 +275,10 @@ func (q *Query) WithContext(ctx context.Context) *queryCtx {
 		ClientPermissionLink:    q.ClientPermissionLink.WithContext(ctx),
 		Coupon:                  q.Coupon.WithContext(ctx),
 		Edge:                    q.Edge.WithContext(ctx),
+		LogsLogin:               q.LogsLogin.WithContext(ctx),
 		LogsRequest:             q.LogsRequest.WithContext(ctx),
+		LogsUserBandwidth:       q.LogsUserBandwidth.WithContext(ctx),
+		LogsUserUsage:           q.LogsUserUsage.WithContext(ctx),
 		Permission:              q.Permission.WithContext(ctx),
 		Product:                 q.Product.WithContext(ctx),
 		Proxy:                   q.Proxy.WithContext(ctx),

web/queries/logs_login.gen.go

@@ -0,0 +1,347 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package queries
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"platform/web/models"
+)
+
+func newLogsLogin(db *gorm.DB, opts ...gen.DOOption) logsLogin {
+	_logsLogin := logsLogin{}
+
+	_logsLogin.logsLoginDo.UseDB(db, opts...)
+	_logsLogin.logsLoginDo.UseModel(&models.LogsLogin{})
+
+	tableName := _logsLogin.logsLoginDo.TableName()
+	_logsLogin.ALL = field.NewAsterisk(tableName)
+	_logsLogin.ID = field.NewInt32(tableName, "id")
+	_logsLogin.IP = field.NewString(tableName, "ip")
+	_logsLogin.Ua = field.NewString(tableName, "ua")
+	_logsLogin.GrantType = field.NewString(tableName, "grant_type")
+	_logsLogin.PasswordGrantType = field.NewString(tableName, "password_grant_type")
+	_logsLogin.Success = field.NewBool(tableName, "success")
+	_logsLogin.Time = field.NewField(tableName, "time")
+	_logsLogin.UserID = field.NewInt32(tableName, "user_id")
+
+	_logsLogin.fillFieldMap()
+
+	return _logsLogin
+}
+
+type logsLogin struct {
+	logsLoginDo
+
+	ALL               field.Asterisk
+	ID                field.Int32  // 登录日志ID
+	IP                field.String // IP地址
+	Ua                field.String // 用户代理
+	GrantType         field.String // 授权类型：authorization_code-授权码模式，client_credentials-客户端凭证模式，refresh_token-刷新令牌模式，password-密码模式
+	PasswordGrantType field.String // 密码模式子授权类型：password-账号密码，phone_code-手机验证码，email_code-邮箱验证码
+	Success           field.Bool   // 登录是否成功
+	Time              field.Field  // 登录时间
+	UserID            field.Int32  // 用户ID
+
+	fieldMap map[string]field.Expr
+}
+
+func (l logsLogin) Table(newTableName string) *logsLogin {
+	l.logsLoginDo.UseTable(newTableName)
+	return l.updateTableName(newTableName)
+}
+
+func (l logsLogin) As(alias string) *logsLogin {
+	l.logsLoginDo.DO = *(l.logsLoginDo.As(alias).(*gen.DO))
+	return l.updateTableName(alias)
+}
+
+func (l *logsLogin) updateTableName(table string) *logsLogin {
+	l.ALL = field.NewAsterisk(table)
+	l.ID = field.NewInt32(table, "id")
+	l.IP = field.NewString(table, "ip")
+	l.Ua = field.NewString(table, "ua")
+	l.GrantType = field.NewString(table, "grant_type")
+	l.PasswordGrantType = field.NewString(table, "password_grant_type")
+	l.Success = field.NewBool(table, "success")
+	l.Time = field.NewField(table, "time")
+	l.UserID = field.NewInt32(table, "user_id")
+
+	l.fillFieldMap()
+
+	return l
+}
+
+func (l *logsLogin) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := l.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (l *logsLogin) fillFieldMap() {
+	l.fieldMap = make(map[string]field.Expr, 8)
+	l.fieldMap["id"] = l.ID
+	l.fieldMap["ip"] = l.IP
+	l.fieldMap["ua"] = l.Ua
+	l.fieldMap["grant_type"] = l.GrantType
+	l.fieldMap["password_grant_type"] = l.PasswordGrantType
+	l.fieldMap["success"] = l.Success
+	l.fieldMap["time"] = l.Time
+	l.fieldMap["user_id"] = l.UserID
+}
+
+func (l logsLogin) clone(db *gorm.DB) logsLogin {
+	l.logsLoginDo.ReplaceConnPool(db.Statement.ConnPool)
+	return l
+}
+
+func (l logsLogin) replaceDB(db *gorm.DB) logsLogin {
+	l.logsLoginDo.ReplaceDB(db)
+	return l
+}
+
+type logsLoginDo struct{ gen.DO }
+
+func (l logsLoginDo) Debug() *logsLoginDo {
+	return l.withDO(l.DO.Debug())
+}
+
+func (l logsLoginDo) WithContext(ctx context.Context) *logsLoginDo {
+	return l.withDO(l.DO.WithContext(ctx))
+}
+
+func (l logsLoginDo) ReadDB() *logsLoginDo {
+	return l.Clauses(dbresolver.Read)
+}
+
+func (l logsLoginDo) WriteDB() *logsLoginDo {
+	return l.Clauses(dbresolver.Write)
+}
+
+func (l logsLoginDo) Session(config *gorm.Session) *logsLoginDo {
+	return l.withDO(l.DO.Session(config))
+}
+
+func (l logsLoginDo) Clauses(conds ...clause.Expression) *logsLoginDo {
+	return l.withDO(l.DO.Clauses(conds...))
+}
+
+func (l logsLoginDo) Returning(value interface{}, columns ...string) *logsLoginDo {
+	return l.withDO(l.DO.Returning(value, columns...))
+}
+
+func (l logsLoginDo) Not(conds ...gen.Condition) *logsLoginDo {
+	return l.withDO(l.DO.Not(conds...))
+}
+
+func (l logsLoginDo) Or(conds ...gen.Condition) *logsLoginDo {
+	return l.withDO(l.DO.Or(conds...))
+}
+
+func (l logsLoginDo) Select(conds ...field.Expr) *logsLoginDo {
+	return l.withDO(l.DO.Select(conds...))
+}
+
+func (l logsLoginDo) Where(conds ...gen.Condition) *logsLoginDo {
+	return l.withDO(l.DO.Where(conds...))
+}
+
+func (l logsLoginDo) Order(conds ...field.Expr) *logsLoginDo {
+	return l.withDO(l.DO.Order(conds...))
+}
+
+func (l logsLoginDo) Distinct(cols ...field.Expr) *logsLoginDo {
+	return l.withDO(l.DO.Distinct(cols...))
+}
+
+func (l logsLoginDo) Omit(cols ...field.Expr) *logsLoginDo {
+	return l.withDO(l.DO.Omit(cols...))
+}
+
+func (l logsLoginDo) Join(table schema.Tabler, on ...field.Expr) *logsLoginDo {
+	return l.withDO(l.DO.Join(table, on...))
+}
+
+func (l logsLoginDo) LeftJoin(table schema.Tabler, on ...field.Expr) *logsLoginDo {
+	return l.withDO(l.DO.LeftJoin(table, on...))
+}
+
+func (l logsLoginDo) RightJoin(table schema.Tabler, on ...field.Expr) *logsLoginDo {
+	return l.withDO(l.DO.RightJoin(table, on...))
+}
+
+func (l logsLoginDo) Group(cols ...field.Expr) *logsLoginDo {
+	return l.withDO(l.DO.Group(cols...))
+}
+
+func (l logsLoginDo) Having(conds ...gen.Condition) *logsLoginDo {
+	return l.withDO(l.DO.Having(conds...))
+}
+
+func (l logsLoginDo) Limit(limit int) *logsLoginDo {
+	return l.withDO(l.DO.Limit(limit))
+}
+
+func (l logsLoginDo) Offset(offset int) *logsLoginDo {
+	return l.withDO(l.DO.Offset(offset))
+}
+
+func (l logsLoginDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *logsLoginDo {
+	return l.withDO(l.DO.Scopes(funcs...))
+}
+
+func (l logsLoginDo) Unscoped() *logsLoginDo {
+	return l.withDO(l.DO.Unscoped())
+}
+
+func (l logsLoginDo) Create(values ...*models.LogsLogin) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return l.DO.Create(values)
+}
+
+func (l logsLoginDo) CreateInBatches(values []*models.LogsLogin, batchSize int) error {
+	return l.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (l logsLoginDo) Save(values ...*models.LogsLogin) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return l.DO.Save(values)
+}
+
+func (l logsLoginDo) First() (*models.LogsLogin, error) {
+	if result, err := l.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.LogsLogin), nil
+	}
+}
+
+func (l logsLoginDo) Take() (*models.LogsLogin, error) {
+	if result, err := l.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.LogsLogin), nil
+	}
+}
+
+func (l logsLoginDo) Last() (*models.LogsLogin, error) {
+	if result, err := l.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.LogsLogin), nil
+	}
+}
+
+func (l logsLoginDo) Find() ([]*models.LogsLogin, error) {
+	result, err := l.DO.Find()
+	return result.([]*models.LogsLogin), err
+}
+
+func (l logsLoginDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.LogsLogin, err error) {
+	buf := make([]*models.LogsLogin, 0, batchSize)
+	err = l.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (l logsLoginDo) FindInBatches(result *[]*models.LogsLogin, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return l.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (l logsLoginDo) Attrs(attrs ...field.AssignExpr) *logsLoginDo {
+	return l.withDO(l.DO.Attrs(attrs...))
+}
+
+func (l logsLoginDo) Assign(attrs ...field.AssignExpr) *logsLoginDo {
+	return l.withDO(l.DO.Assign(attrs...))
+}
+
+func (l logsLoginDo) Joins(fields ...field.RelationField) *logsLoginDo {
+	for _, _f := range fields {
+		l = *l.withDO(l.DO.Joins(_f))
+	}
+	return &l
+}
+
+func (l logsLoginDo) Preload(fields ...field.RelationField) *logsLoginDo {
+	for _, _f := range fields {
+		l = *l.withDO(l.DO.Preload(_f))
+	}
+	return &l
+}
+
+func (l logsLoginDo) FirstOrInit() (*models.LogsLogin, error) {
+	if result, err := l.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.LogsLogin), nil
+	}
+}
+
+func (l logsLoginDo) FirstOrCreate() (*models.LogsLogin, error) {
+	if result, err := l.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.LogsLogin), nil
+	}
+}
+
+func (l logsLoginDo) FindByPage(offset int, limit int) (result []*models.LogsLogin, count int64, err error) {
+	result, err = l.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = l.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (l logsLoginDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = l.Count()
+	if err != nil {
+		return
+	}
+
+	err = l.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (l logsLoginDo) Scan(result interface{}) (err error) {
+	return l.DO.Scan(result)
+}
+
+func (l logsLoginDo) Delete(models ...*models.LogsLogin) (result gen.ResultInfo, err error) {
+	return l.DO.Delete(models)
+}
+
+func (l *logsLoginDo) withDO(do gen.Dao) *logsLoginDo {
+	l.DO = *do.(*gen.DO)
+	return l
+}

web/queries/logs_user_bandwidth.gen.go

@@ -0,0 +1,331 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package queries
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"platform/web/models"
+)
+
+func newLogsUserBandwidth(db *gorm.DB, opts ...gen.DOOption) logsUserBandwidth {
+	_logsUserBandwidth := logsUserBandwidth{}
+
+	_logsUserBandwidth.logsUserBandwidthDo.UseDB(db, opts...)
+	_logsUserBandwidth.logsUserBandwidthDo.UseModel(&models.LogsUserBandwidth{})
+
+	tableName := _logsUserBandwidth.logsUserBandwidthDo.TableName()
+	_logsUserBandwidth.ALL = field.NewAsterisk(tableName)
+	_logsUserBandwidth.ID = field.NewInt32(tableName, "id")
+	_logsUserBandwidth.UserID = field.NewInt32(tableName, "user_id")
+	_logsUserBandwidth.Bandwidth = field.NewInt32(tableName, "bandwidth")
+	_logsUserBandwidth.Time = field.NewField(tableName, "time")
+
+	_logsUserBandwidth.fillFieldMap()
+
+	return _logsUserBandwidth
+}
+
+type logsUserBandwidth struct {
+	logsUserBandwidthDo
+
+	ALL       field.Asterisk
+	ID        field.Int32 // 日志ID
+	UserID    field.Int32 // 用户ID
+	Bandwidth field.Int32 // 带宽使用量(KB)
+	Time      field.Field // 记录时间
+
+	fieldMap map[string]field.Expr
+}
+
+func (l logsUserBandwidth) Table(newTableName string) *logsUserBandwidth {
+	l.logsUserBandwidthDo.UseTable(newTableName)
+	return l.updateTableName(newTableName)
+}
+
+func (l logsUserBandwidth) As(alias string) *logsUserBandwidth {
+	l.logsUserBandwidthDo.DO = *(l.logsUserBandwidthDo.As(alias).(*gen.DO))
+	return l.updateTableName(alias)
+}
+
+func (l *logsUserBandwidth) updateTableName(table string) *logsUserBandwidth {
+	l.ALL = field.NewAsterisk(table)
+	l.ID = field.NewInt32(table, "id")
+	l.UserID = field.NewInt32(table, "user_id")
+	l.Bandwidth = field.NewInt32(table, "bandwidth")
+	l.Time = field.NewField(table, "time")
+
+	l.fillFieldMap()
+
+	return l
+}
+
+func (l *logsUserBandwidth) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := l.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (l *logsUserBandwidth) fillFieldMap() {
+	l.fieldMap = make(map[string]field.Expr, 4)
+	l.fieldMap["id"] = l.ID
+	l.fieldMap["user_id"] = l.UserID
+	l.fieldMap["bandwidth"] = l.Bandwidth
+	l.fieldMap["time"] = l.Time
+}
+
+func (l logsUserBandwidth) clone(db *gorm.DB) logsUserBandwidth {
+	l.logsUserBandwidthDo.ReplaceConnPool(db.Statement.ConnPool)
+	return l
+}
+
+func (l logsUserBandwidth) replaceDB(db *gorm.DB) logsUserBandwidth {
+	l.logsUserBandwidthDo.ReplaceDB(db)
+	return l
+}
+
+type logsUserBandwidthDo struct{ gen.DO }
+
+func (l logsUserBandwidthDo) Debug() *logsUserBandwidthDo {
+	return l.withDO(l.DO.Debug())
+}
+
+func (l logsUserBandwidthDo) WithContext(ctx context.Context) *logsUserBandwidthDo {
+	return l.withDO(l.DO.WithContext(ctx))
+}
+
+func (l logsUserBandwidthDo) ReadDB() *logsUserBandwidthDo {
+	return l.Clauses(dbresolver.Read)
+}
+
+func (l logsUserBandwidthDo) WriteDB() *logsUserBandwidthDo {
+	return l.Clauses(dbresolver.Write)
+}
+
+func (l logsUserBandwidthDo) Session(config *gorm.Session) *logsUserBandwidthDo {
+	return l.withDO(l.DO.Session(config))
+}
+
+func (l logsUserBandwidthDo) Clauses(conds ...clause.Expression) *logsUserBandwidthDo {
+	return l.withDO(l.DO.Clauses(conds...))
+}
+
+func (l logsUserBandwidthDo) Returning(value interface{}, columns ...string) *logsUserBandwidthDo {
+	return l.withDO(l.DO.Returning(value, columns...))
+}
+
+func (l logsUserBandwidthDo) Not(conds ...gen.Condition) *logsUserBandwidthDo {
+	return l.withDO(l.DO.Not(conds...))
+}
+
+func (l logsUserBandwidthDo) Or(conds ...gen.Condition) *logsUserBandwidthDo {
+	return l.withDO(l.DO.Or(conds...))
+}
+
+func (l logsUserBandwidthDo) Select(conds ...field.Expr) *logsUserBandwidthDo {
+	return l.withDO(l.DO.Select(conds...))
+}
+
+func (l logsUserBandwidthDo) Where(conds ...gen.Condition) *logsUserBandwidthDo {
+	return l.withDO(l.DO.Where(conds...))
+}
+
+func (l logsUserBandwidthDo) Order(conds ...field.Expr) *logsUserBandwidthDo {
+	return l.withDO(l.DO.Order(conds...))
+}
+
+func (l logsUserBandwidthDo) Distinct(cols ...field.Expr) *logsUserBandwidthDo {
+	return l.withDO(l.DO.Distinct(cols...))
+}
+
+func (l logsUserBandwidthDo) Omit(cols ...field.Expr) *logsUserBandwidthDo {
+	return l.withDO(l.DO.Omit(cols...))
+}
+
+func (l logsUserBandwidthDo) Join(table schema.Tabler, on ...field.Expr) *logsUserBandwidthDo {
+	return l.withDO(l.DO.Join(table, on...))
+}
+
+func (l logsUserBandwidthDo) LeftJoin(table schema.Tabler, on ...field.Expr) *logsUserBandwidthDo {
+	return l.withDO(l.DO.LeftJoin(table, on...))
+}
+
+func (l logsUserBandwidthDo) RightJoin(table schema.Tabler, on ...field.Expr) *logsUserBandwidthDo {
+	return l.withDO(l.DO.RightJoin(table, on...))
+}
+
+func (l logsUserBandwidthDo) Group(cols ...field.Expr) *logsUserBandwidthDo {
+	return l.withDO(l.DO.Group(cols...))
+}
+
+func (l logsUserBandwidthDo) Having(conds ...gen.Condition) *logsUserBandwidthDo {
+	return l.withDO(l.DO.Having(conds...))
+}
+
+func (l logsUserBandwidthDo) Limit(limit int) *logsUserBandwidthDo {
+	return l.withDO(l.DO.Limit(limit))
+}
+
+func (l logsUserBandwidthDo) Offset(offset int) *logsUserBandwidthDo {
+	return l.withDO(l.DO.Offset(offset))
+}
+
+func (l logsUserBandwidthDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *logsUserBandwidthDo {
+	return l.withDO(l.DO.Scopes(funcs...))
+}
+
+func (l logsUserBandwidthDo) Unscoped() *logsUserBandwidthDo {
+	return l.withDO(l.DO.Unscoped())
+}
+
+func (l logsUserBandwidthDo) Create(values ...*models.LogsUserBandwidth) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return l.DO.Create(values)
+}
+
+func (l logsUserBandwidthDo) CreateInBatches(values []*models.LogsUserBandwidth, batchSize int) error {
+	return l.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (l logsUserBandwidthDo) Save(values ...*models.LogsUserBandwidth) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return l.DO.Save(values)
+}
+
+func (l logsUserBandwidthDo) First() (*models.LogsUserBandwidth, error) {
+	if result, err := l.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.LogsUserBandwidth), nil
+	}
+}
+
+func (l logsUserBandwidthDo) Take() (*models.LogsUserBandwidth, error) {
+	if result, err := l.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.LogsUserBandwidth), nil
+	}
+}
+
+func (l logsUserBandwidthDo) Last() (*models.LogsUserBandwidth, error) {
+	if result, err := l.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.LogsUserBandwidth), nil
+	}
+}
+
+func (l logsUserBandwidthDo) Find() ([]*models.LogsUserBandwidth, error) {
+	result, err := l.DO.Find()
+	return result.([]*models.LogsUserBandwidth), err
+}
+
+func (l logsUserBandwidthDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.LogsUserBandwidth, err error) {
+	buf := make([]*models.LogsUserBandwidth, 0, batchSize)
+	err = l.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (l logsUserBandwidthDo) FindInBatches(result *[]*models.LogsUserBandwidth, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return l.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (l logsUserBandwidthDo) Attrs(attrs ...field.AssignExpr) *logsUserBandwidthDo {
+	return l.withDO(l.DO.Attrs(attrs...))
+}
+
+func (l logsUserBandwidthDo) Assign(attrs ...field.AssignExpr) *logsUserBandwidthDo {
+	return l.withDO(l.DO.Assign(attrs...))
+}
+
+func (l logsUserBandwidthDo) Joins(fields ...field.RelationField) *logsUserBandwidthDo {
+	for _, _f := range fields {
+		l = *l.withDO(l.DO.Joins(_f))
+	}
+	return &l
+}
+
+func (l logsUserBandwidthDo) Preload(fields ...field.RelationField) *logsUserBandwidthDo {
+	for _, _f := range fields {
+		l = *l.withDO(l.DO.Preload(_f))
+	}
+	return &l
+}
+
+func (l logsUserBandwidthDo) FirstOrInit() (*models.LogsUserBandwidth, error) {
+	if result, err := l.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.LogsUserBandwidth), nil
+	}
+}
+
+func (l logsUserBandwidthDo) FirstOrCreate() (*models.LogsUserBandwidth, error) {
+	if result, err := l.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.LogsUserBandwidth), nil
+	}
+}
+
+func (l logsUserBandwidthDo) FindByPage(offset int, limit int) (result []*models.LogsUserBandwidth, count int64, err error) {
+	result, err = l.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = l.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (l logsUserBandwidthDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = l.Count()
+	if err != nil {
+		return
+	}
+
+	err = l.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (l logsUserBandwidthDo) Scan(result interface{}) (err error) {
+	return l.DO.Scan(result)
+}
+
+func (l logsUserBandwidthDo) Delete(models ...*models.LogsUserBandwidth) (result gen.ResultInfo, err error) {
+	return l.DO.Delete(models)
+}
+
+func (l *logsUserBandwidthDo) withDO(do gen.Dao) *logsUserBandwidthDo {
+	l.DO = *do.(*gen.DO)
+	return l
+}

web/queries/logs_user_usage.gen.go

@@ -0,0 +1,351 @@
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+// Code generated by gorm.io/gen. DO NOT EDIT.
+
+package queries
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"platform/web/models"
+)
+
+func newLogsUserUsage(db *gorm.DB, opts ...gen.DOOption) logsUserUsage {
+	_logsUserUsage := logsUserUsage{}
+
+	_logsUserUsage.logsUserUsageDo.UseDB(db, opts...)
+	_logsUserUsage.logsUserUsageDo.UseModel(&models.LogsUserUsage{})
+
+	tableName := _logsUserUsage.logsUserUsageDo.TableName()
+	_logsUserUsage.ALL = field.NewAsterisk(tableName)
+	_logsUserUsage.ID = field.NewInt32(tableName, "id")
+	_logsUserUsage.UserID = field.NewInt32(tableName, "user_id")
+	_logsUserUsage.ResourceID = field.NewInt32(tableName, "resource_id")
+	_logsUserUsage.Count_ = field.NewInt32(tableName, "count")
+	_logsUserUsage.Prov = field.NewString(tableName, "prov")
+	_logsUserUsage.City = field.NewString(tableName, "city")
+	_logsUserUsage.Isp = field.NewString(tableName, "isp")
+	_logsUserUsage.IP = field.NewString(tableName, "ip")
+	_logsUserUsage.Time = field.NewField(tableName, "time")
+
+	_logsUserUsage.fillFieldMap()
+
+	return _logsUserUsage
+}
+
+type logsUserUsage struct {
+	logsUserUsageDo
+
+	ALL        field.Asterisk
+	ID         field.Int32  // 日志ID
+	UserID     field.Int32  // 用户ID
+	ResourceID field.Int32  // 套餐ID
+	Count_     field.Int32  // 数量
+	Prov       field.String // 省份
+	City       field.String // 城市
+	Isp        field.String // 运营商
+	IP         field.String // IP地址
+	Time       field.Field  // 提取时间
+
+	fieldMap map[string]field.Expr
+}
+
+func (l logsUserUsage) Table(newTableName string) *logsUserUsage {
+	l.logsUserUsageDo.UseTable(newTableName)
+	return l.updateTableName(newTableName)
+}
+
+func (l logsUserUsage) As(alias string) *logsUserUsage {
+	l.logsUserUsageDo.DO = *(l.logsUserUsageDo.As(alias).(*gen.DO))
+	return l.updateTableName(alias)
+}
+
+func (l *logsUserUsage) updateTableName(table string) *logsUserUsage {
+	l.ALL = field.NewAsterisk(table)
+	l.ID = field.NewInt32(table, "id")
+	l.UserID = field.NewInt32(table, "user_id")
+	l.ResourceID = field.NewInt32(table, "resource_id")
+	l.Count_ = field.NewInt32(table, "count")
+	l.Prov = field.NewString(table, "prov")
+	l.City = field.NewString(table, "city")
+	l.Isp = field.NewString(table, "isp")
+	l.IP = field.NewString(table, "ip")
+	l.Time = field.NewField(table, "time")
+
+	l.fillFieldMap()
+
+	return l
+}
+
+func (l *logsUserUsage) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := l.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (l *logsUserUsage) fillFieldMap() {
+	l.fieldMap = make(map[string]field.Expr, 9)
+	l.fieldMap["id"] = l.ID
+	l.fieldMap["user_id"] = l.UserID
+	l.fieldMap["resource_id"] = l.ResourceID
+	l.fieldMap["count"] = l.Count_
+	l.fieldMap["prov"] = l.Prov
+	l.fieldMap["city"] = l.City
+	l.fieldMap["isp"] = l.Isp
+	l.fieldMap["ip"] = l.IP
+	l.fieldMap["time"] = l.Time
+}
+
+func (l logsUserUsage) clone(db *gorm.DB) logsUserUsage {
+	l.logsUserUsageDo.ReplaceConnPool(db.Statement.ConnPool)
+	return l
+}
+
+func (l logsUserUsage) replaceDB(db *gorm.DB) logsUserUsage {
+	l.logsUserUsageDo.ReplaceDB(db)
+	return l
+}
+
+type logsUserUsageDo struct{ gen.DO }
+
+func (l logsUserUsageDo) Debug() *logsUserUsageDo {
+	return l.withDO(l.DO.Debug())
+}
+
+func (l logsUserUsageDo) WithContext(ctx context.Context) *logsUserUsageDo {
+	return l.withDO(l.DO.WithContext(ctx))
+}
+
+func (l logsUserUsageDo) ReadDB() *logsUserUsageDo {
+	return l.Clauses(dbresolver.Read)
+}
+
+func (l logsUserUsageDo) WriteDB() *logsUserUsageDo {
+	return l.Clauses(dbresolver.Write)
+}
+
+func (l logsUserUsageDo) Session(config *gorm.Session) *logsUserUsageDo {
+	return l.withDO(l.DO.Session(config))
+}
+
+func (l logsUserUsageDo) Clauses(conds ...clause.Expression) *logsUserUsageDo {
+	return l.withDO(l.DO.Clauses(conds...))
+}
+
+func (l logsUserUsageDo) Returning(value interface{}, columns ...string) *logsUserUsageDo {
+	return l.withDO(l.DO.Returning(value, columns...))
+}
+
+func (l logsUserUsageDo) Not(conds ...gen.Condition) *logsUserUsageDo {
+	return l.withDO(l.DO.Not(conds...))
+}
+
+func (l logsUserUsageDo) Or(conds ...gen.Condition) *logsUserUsageDo {
+	return l.withDO(l.DO.Or(conds...))
+}
+
+func (l logsUserUsageDo) Select(conds ...field.Expr) *logsUserUsageDo {
+	return l.withDO(l.DO.Select(conds...))
+}
+
+func (l logsUserUsageDo) Where(conds ...gen.Condition) *logsUserUsageDo {
+	return l.withDO(l.DO.Where(conds...))
+}
+
+func (l logsUserUsageDo) Order(conds ...field.Expr) *logsUserUsageDo {
+	return l.withDO(l.DO.Order(conds...))
+}
+
+func (l logsUserUsageDo) Distinct(cols ...field.Expr) *logsUserUsageDo {
+	return l.withDO(l.DO.Distinct(cols...))
+}
+
+func (l logsUserUsageDo) Omit(cols ...field.Expr) *logsUserUsageDo {
+	return l.withDO(l.DO.Omit(cols...))
+}
+
+func (l logsUserUsageDo) Join(table schema.Tabler, on ...field.Expr) *logsUserUsageDo {
+	return l.withDO(l.DO.Join(table, on...))
+}
+
+func (l logsUserUsageDo) LeftJoin(table schema.Tabler, on ...field.Expr) *logsUserUsageDo {
+	return l.withDO(l.DO.LeftJoin(table, on...))
+}
+
+func (l logsUserUsageDo) RightJoin(table schema.Tabler, on ...field.Expr) *logsUserUsageDo {
+	return l.withDO(l.DO.RightJoin(table, on...))
+}
+
+func (l logsUserUsageDo) Group(cols ...field.Expr) *logsUserUsageDo {
+	return l.withDO(l.DO.Group(cols...))
+}
+
+func (l logsUserUsageDo) Having(conds ...gen.Condition) *logsUserUsageDo {
+	return l.withDO(l.DO.Having(conds...))
+}
+
+func (l logsUserUsageDo) Limit(limit int) *logsUserUsageDo {
+	return l.withDO(l.DO.Limit(limit))
+}
+
+func (l logsUserUsageDo) Offset(offset int) *logsUserUsageDo {
+	return l.withDO(l.DO.Offset(offset))
+}
+
+func (l logsUserUsageDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *logsUserUsageDo {
+	return l.withDO(l.DO.Scopes(funcs...))
+}
+
+func (l logsUserUsageDo) Unscoped() *logsUserUsageDo {
+	return l.withDO(l.DO.Unscoped())
+}
+
+func (l logsUserUsageDo) Create(values ...*models.LogsUserUsage) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return l.DO.Create(values)
+}
+
+func (l logsUserUsageDo) CreateInBatches(values []*models.LogsUserUsage, batchSize int) error {
+	return l.DO.CreateInBatches(values, batchSize)
+}
+
+// Save : !!! underlying implementation is different with GORM
+// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
+func (l logsUserUsageDo) Save(values ...*models.LogsUserUsage) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return l.DO.Save(values)
+}
+
+func (l logsUserUsageDo) First() (*models.LogsUserUsage, error) {
+	if result, err := l.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.LogsUserUsage), nil
+	}
+}
+
+func (l logsUserUsageDo) Take() (*models.LogsUserUsage, error) {
+	if result, err := l.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.LogsUserUsage), nil
+	}
+}
+
+func (l logsUserUsageDo) Last() (*models.LogsUserUsage, error) {
+	if result, err := l.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.LogsUserUsage), nil
+	}
+}
+
+func (l logsUserUsageDo) Find() ([]*models.LogsUserUsage, error) {
+	result, err := l.DO.Find()
+	return result.([]*models.LogsUserUsage), err
+}
+
+func (l logsUserUsageDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.LogsUserUsage, err error) {
+	buf := make([]*models.LogsUserUsage, 0, batchSize)
+	err = l.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
+		defer func() { results = append(results, buf...) }()
+		return fc(tx, batch)
+	})
+	return results, err
+}
+
+func (l logsUserUsageDo) FindInBatches(result *[]*models.LogsUserUsage, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return l.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (l logsUserUsageDo) Attrs(attrs ...field.AssignExpr) *logsUserUsageDo {
+	return l.withDO(l.DO.Attrs(attrs...))
+}
+
+func (l logsUserUsageDo) Assign(attrs ...field.AssignExpr) *logsUserUsageDo {
+	return l.withDO(l.DO.Assign(attrs...))
+}
+
+func (l logsUserUsageDo) Joins(fields ...field.RelationField) *logsUserUsageDo {
+	for _, _f := range fields {
+		l = *l.withDO(l.DO.Joins(_f))
+	}
+	return &l
+}
+
+func (l logsUserUsageDo) Preload(fields ...field.RelationField) *logsUserUsageDo {
+	for _, _f := range fields {
+		l = *l.withDO(l.DO.Preload(_f))
+	}
+	return &l
+}
+
+func (l logsUserUsageDo) FirstOrInit() (*models.LogsUserUsage, error) {
+	if result, err := l.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.LogsUserUsage), nil
+	}
+}
+
+func (l logsUserUsageDo) FirstOrCreate() (*models.LogsUserUsage, error) {
+	if result, err := l.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*models.LogsUserUsage), nil
+	}
+}
+
+func (l logsUserUsageDo) FindByPage(offset int, limit int) (result []*models.LogsUserUsage, count int64, err error) {
+	result, err = l.Offset(offset).Limit(limit).Find()
+	if err != nil {
+		return
+	}
+
+	if size := len(result); 0 < limit && 0 < size && size < limit {
+		count = int64(size + offset)
+		return
+	}
+
+	count, err = l.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (l logsUserUsageDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = l.Count()
+	if err != nil {
+		return
+	}
+
+	err = l.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (l logsUserUsageDo) Scan(result interface{}) (err error) {
+	return l.DO.Scan(result)
+}
+
+func (l logsUserUsageDo) Delete(models ...*models.LogsUserUsage) (result gen.ResultInfo, err error) {
+	return l.DO.Delete(models)
+}
+
+func (l *logsUserUsageDo) withDO(do gen.Dao) *logsUserUsageDo {
+	l.DO = *do.(*gen.DO)
+	return l
+}