feat: add audit logs and system configs

2026-01-15 20:07:36 +08:00
parent 914df9edf2
commit b3fc226bbe
25 changed files with 3325 additions and 108 deletions
--- a/backend/database/models/audit_logs.query.gen.go
+++ b/backend/database/models/audit_logs.query.gen.go
@@ -0,0 +1,485 @@
+// Code generated by go.ipao.vip/gen. DO NOT EDIT.
+// Code generated by go.ipao.vip/gen. DO NOT EDIT.
+// Code generated by go.ipao.vip/gen. DO NOT EDIT.
+
+package models
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"go.ipao.vip/gen"
+	"go.ipao.vip/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+)
+
+func newAuditLog(db *gorm.DB, opts ...gen.DOOption) auditLogQuery {
+	_auditLogQuery := auditLogQuery{}
+
+	_auditLogQuery.auditLogQueryDo.UseDB(db, opts...)
+	_auditLogQuery.auditLogQueryDo.UseModel(&AuditLog{})
+
+	tableName := _auditLogQuery.auditLogQueryDo.TableName()
+	_auditLogQuery.ALL = field.NewAsterisk(tableName)
+	_auditLogQuery.ID = field.NewInt64(tableName, "id")
+	_auditLogQuery.TenantID = field.NewInt64(tableName, "tenant_id")
+	_auditLogQuery.OperatorID = field.NewInt64(tableName, "operator_id")
+	_auditLogQuery.Action = field.NewString(tableName, "action")
+	_auditLogQuery.TargetID = field.NewString(tableName, "target_id")
+	_auditLogQuery.Detail = field.NewString(tableName, "detail")
+	_auditLogQuery.CreatedAt = field.NewTime(tableName, "created_at")
+
+	_auditLogQuery.fillFieldMap()
+
+	return _auditLogQuery
+}
+
+type auditLogQuery struct {
+	auditLogQueryDo auditLogQueryDo
+
+	ALL        field.Asterisk
+	ID         field.Int64  // 主键ID。
+	TenantID   field.Int64  // 租户ID；用途：关联租户审计（0表示平台级）。
+	OperatorID field.Int64  // 操作者用户ID；用途：审计追溯；约束：必须存在。
+	Action     field.String // 动作标识；用途：检索分类；约束：例如 review_content/freeze_coupon。
+	TargetID   field.String // 目标ID；用途：定位被操作对象；可为空字符串。
+	Detail     field.String // 动作详情；用途：记录操作原因与补充说明。
+	CreatedAt  field.Time   // 创建时间；用途：时间序列查询与审计留存。
+
+	fieldMap map[string]field.Expr
+}
+
+func (a auditLogQuery) Table(newTableName string) *auditLogQuery {
+	a.auditLogQueryDo.UseTable(newTableName)
+	return a.updateTableName(newTableName)
+}
+
+func (a auditLogQuery) As(alias string) *auditLogQuery {
+	a.auditLogQueryDo.DO = *(a.auditLogQueryDo.As(alias).(*gen.DO))
+	return a.updateTableName(alias)
+}
+
+func (a *auditLogQuery) updateTableName(table string) *auditLogQuery {
+	a.ALL = field.NewAsterisk(table)
+	a.ID = field.NewInt64(table, "id")
+	a.TenantID = field.NewInt64(table, "tenant_id")
+	a.OperatorID = field.NewInt64(table, "operator_id")
+	a.Action = field.NewString(table, "action")
+	a.TargetID = field.NewString(table, "target_id")
+	a.Detail = field.NewString(table, "detail")
+	a.CreatedAt = field.NewTime(table, "created_at")
+
+	a.fillFieldMap()
+
+	return a
+}
+
+func (a *auditLogQuery) QueryContext(ctx context.Context) (*auditLogQuery, *auditLogQueryDo) {
+	return a, a.auditLogQueryDo.WithContext(ctx)
+}
+
+func (a *auditLogQuery) WithContext(ctx context.Context) *auditLogQueryDo {
+	return a.auditLogQueryDo.WithContext(ctx)
+}
+
+func (a auditLogQuery) TableName() string { return a.auditLogQueryDo.TableName() }
+
+func (a auditLogQuery) Alias() string { return a.auditLogQueryDo.Alias() }
+
+func (a auditLogQuery) Columns(cols ...field.Expr) gen.Columns {
+	return a.auditLogQueryDo.Columns(cols...)
+}
+
+func (a *auditLogQuery) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := a.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (a *auditLogQuery) fillFieldMap() {
+	a.fieldMap = make(map[string]field.Expr, 7)
+	a.fieldMap["id"] = a.ID
+	a.fieldMap["tenant_id"] = a.TenantID
+	a.fieldMap["operator_id"] = a.OperatorID
+	a.fieldMap["action"] = a.Action
+	a.fieldMap["target_id"] = a.TargetID
+	a.fieldMap["detail"] = a.Detail
+	a.fieldMap["created_at"] = a.CreatedAt
+}
+
+func (a auditLogQuery) clone(db *gorm.DB) auditLogQuery {
+	a.auditLogQueryDo.ReplaceConnPool(db.Statement.ConnPool)
+	return a
+}
+
+func (a auditLogQuery) replaceDB(db *gorm.DB) auditLogQuery {
+	a.auditLogQueryDo.ReplaceDB(db)
+	return a
+}
+
+type auditLogQueryDo struct{ gen.DO }
+
+func (a auditLogQueryDo) Debug() *auditLogQueryDo {
+	return a.withDO(a.DO.Debug())
+}
+
+func (a auditLogQueryDo) WithContext(ctx context.Context) *auditLogQueryDo {
+	return a.withDO(a.DO.WithContext(ctx))
+}
+
+func (a auditLogQueryDo) ReadDB() *auditLogQueryDo {
+	return a.Clauses(dbresolver.Read)
+}
+
+func (a auditLogQueryDo) WriteDB() *auditLogQueryDo {
+	return a.Clauses(dbresolver.Write)
+}
+
+func (a auditLogQueryDo) Session(config *gorm.Session) *auditLogQueryDo {
+	return a.withDO(a.DO.Session(config))
+}
+
+func (a auditLogQueryDo) Clauses(conds ...clause.Expression) *auditLogQueryDo {
+	return a.withDO(a.DO.Clauses(conds...))
+}
+
+func (a auditLogQueryDo) Returning(value interface{}, columns ...string) *auditLogQueryDo {
+	return a.withDO(a.DO.Returning(value, columns...))
+}
+
+func (a auditLogQueryDo) Not(conds ...gen.Condition) *auditLogQueryDo {
+	return a.withDO(a.DO.Not(conds...))
+}
+
+func (a auditLogQueryDo) Or(conds ...gen.Condition) *auditLogQueryDo {
+	return a.withDO(a.DO.Or(conds...))
+}
+
+func (a auditLogQueryDo) Select(conds ...field.Expr) *auditLogQueryDo {
+	return a.withDO(a.DO.Select(conds...))
+}
+
+func (a auditLogQueryDo) Where(conds ...gen.Condition) *auditLogQueryDo {
+	return a.withDO(a.DO.Where(conds...))
+}
+
+func (a auditLogQueryDo) Order(conds ...field.Expr) *auditLogQueryDo {
+	return a.withDO(a.DO.Order(conds...))
+}
+
+func (a auditLogQueryDo) Distinct(cols ...field.Expr) *auditLogQueryDo {
+	return a.withDO(a.DO.Distinct(cols...))
+}
+
+func (a auditLogQueryDo) Omit(cols ...field.Expr) *auditLogQueryDo {
+	return a.withDO(a.DO.Omit(cols...))
+}
+
+func (a auditLogQueryDo) Join(table schema.Tabler, on ...field.Expr) *auditLogQueryDo {
+	return a.withDO(a.DO.Join(table, on...))
+}
+
+func (a auditLogQueryDo) LeftJoin(table schema.Tabler, on ...field.Expr) *auditLogQueryDo {
+	return a.withDO(a.DO.LeftJoin(table, on...))
+}
+
+func (a auditLogQueryDo) RightJoin(table schema.Tabler, on ...field.Expr) *auditLogQueryDo {
+	return a.withDO(a.DO.RightJoin(table, on...))
+}
+
+func (a auditLogQueryDo) Group(cols ...field.Expr) *auditLogQueryDo {
+	return a.withDO(a.DO.Group(cols...))
+}
+
+func (a auditLogQueryDo) Having(conds ...gen.Condition) *auditLogQueryDo {
+	return a.withDO(a.DO.Having(conds...))
+}
+
+func (a auditLogQueryDo) Limit(limit int) *auditLogQueryDo {
+	return a.withDO(a.DO.Limit(limit))
+}
+
+func (a auditLogQueryDo) Offset(offset int) *auditLogQueryDo {
+	return a.withDO(a.DO.Offset(offset))
+}
+
+func (a auditLogQueryDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *auditLogQueryDo {
+	return a.withDO(a.DO.Scopes(funcs...))
+}
+
+func (a auditLogQueryDo) Unscoped() *auditLogQueryDo {
+	return a.withDO(a.DO.Unscoped())
+}
+
+func (a auditLogQueryDo) Create(values ...*AuditLog) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return a.DO.Create(values)
+}
+
+func (a auditLogQueryDo) CreateInBatches(values []*AuditLog, batchSize int) error {
+	return a.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 (a auditLogQueryDo) Save(values ...*AuditLog) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return a.DO.Save(values)
+}
+
+func (a auditLogQueryDo) First() (*AuditLog, error) {
+	if result, err := a.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*AuditLog), nil
+	}
+}
+
+func (a auditLogQueryDo) Take() (*AuditLog, error) {
+	if result, err := a.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*AuditLog), nil
+	}
+}
+
+func (a auditLogQueryDo) Last() (*AuditLog, error) {
+	if result, err := a.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*AuditLog), nil
+	}
+}
+
+func (a auditLogQueryDo) Find() ([]*AuditLog, error) {
+	result, err := a.DO.Find()
+	return result.([]*AuditLog), err
+}
+
+func (a auditLogQueryDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*AuditLog, err error) {
+	buf := make([]*AuditLog, 0, batchSize)
+	err = a.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 (a auditLogQueryDo) FindInBatches(result *[]*AuditLog, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return a.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (a auditLogQueryDo) Attrs(attrs ...field.AssignExpr) *auditLogQueryDo {
+	return a.withDO(a.DO.Attrs(attrs...))
+}
+
+func (a auditLogQueryDo) Assign(attrs ...field.AssignExpr) *auditLogQueryDo {
+	return a.withDO(a.DO.Assign(attrs...))
+}
+
+func (a auditLogQueryDo) Joins(fields ...field.RelationField) *auditLogQueryDo {
+	for _, _f := range fields {
+		a = *a.withDO(a.DO.Joins(_f))
+	}
+	return &a
+}
+
+func (a auditLogQueryDo) Preload(fields ...field.RelationField) *auditLogQueryDo {
+	for _, _f := range fields {
+		a = *a.withDO(a.DO.Preload(_f))
+	}
+	return &a
+}
+
+func (a auditLogQueryDo) FirstOrInit() (*AuditLog, error) {
+	if result, err := a.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*AuditLog), nil
+	}
+}
+
+func (a auditLogQueryDo) FirstOrCreate() (*AuditLog, error) {
+	if result, err := a.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*AuditLog), nil
+	}
+}
+
+func (a auditLogQueryDo) FindByPage(offset int, limit int) (result []*AuditLog, count int64, err error) {
+	result, err = a.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 = a.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (a auditLogQueryDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = a.Count()
+	if err != nil {
+		return
+	}
+
+	err = a.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (a auditLogQueryDo) Scan(result interface{}) (err error) {
+	return a.DO.Scan(result)
+}
+
+func (a auditLogQueryDo) Delete(models ...*AuditLog) (result gen.ResultInfo, err error) {
+	return a.DO.Delete(models)
+}
+
+// ForceDelete performs a permanent delete (ignores soft-delete) for current scope.
+func (a auditLogQueryDo) ForceDelete() (gen.ResultInfo, error) {
+	return a.Unscoped().Delete()
+}
+
+// Inc increases the given column by step for current scope.
+func (a auditLogQueryDo) Inc(column field.Expr, step int64) (gen.ResultInfo, error) {
+	// column = column + step
+	e := field.NewUnsafeFieldRaw("?+?", column.RawExpr(), step)
+	return a.DO.UpdateColumn(column, e)
+}
+
+// Dec decreases the given column by step for current scope.
+func (a auditLogQueryDo) Dec(column field.Expr, step int64) (gen.ResultInfo, error) {
+	// column = column - step
+	e := field.NewUnsafeFieldRaw("?-?", column.RawExpr(), step)
+	return a.DO.UpdateColumn(column, e)
+}
+
+// Sum returns SUM(column) for current scope.
+func (a auditLogQueryDo) Sum(column field.Expr) (float64, error) {
+	var _v float64
+	agg := field.NewUnsafeFieldRaw("SUM(?)", column.RawExpr())
+	if err := a.Select(agg).Scan(&_v); err != nil {
+		return 0, err
+	}
+	return _v, nil
+}
+
+// Avg returns AVG(column) for current scope.
+func (a auditLogQueryDo) Avg(column field.Expr) (float64, error) {
+	var _v float64
+	agg := field.NewUnsafeFieldRaw("AVG(?)", column.RawExpr())
+	if err := a.Select(agg).Scan(&_v); err != nil {
+		return 0, err
+	}
+	return _v, nil
+}
+
+// Min returns MIN(column) for current scope.
+func (a auditLogQueryDo) Min(column field.Expr) (float64, error) {
+	var _v float64
+	agg := field.NewUnsafeFieldRaw("MIN(?)", column.RawExpr())
+	if err := a.Select(agg).Scan(&_v); err != nil {
+		return 0, err
+	}
+	return _v, nil
+}
+
+// Max returns MAX(column) for current scope.
+func (a auditLogQueryDo) Max(column field.Expr) (float64, error) {
+	var _v float64
+	agg := field.NewUnsafeFieldRaw("MAX(?)", column.RawExpr())
+	if err := a.Select(agg).Scan(&_v); err != nil {
+		return 0, err
+	}
+	return _v, nil
+}
+
+// PluckMap returns a map[key]value for selected key/value expressions within current scope.
+func (a auditLogQueryDo) PluckMap(key, val field.Expr) (map[interface{}]interface{}, error) {
+	do := a.Select(key, val)
+	rows, err := do.DO.Rows()
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	mm := make(map[interface{}]interface{})
+	for rows.Next() {
+		var k interface{}
+		var v interface{}
+		if err := rows.Scan(&k, &v); err != nil {
+			return nil, err
+		}
+		mm[k] = v
+	}
+	return mm, rows.Err()
+}
+
+// Exists returns true if any record matches the given conditions.
+func (a auditLogQueryDo) Exists(conds ...gen.Condition) (bool, error) {
+	cnt, err := a.Where(conds...).Count()
+	if err != nil {
+		return false, err
+	}
+	return cnt > 0, nil
+}
+
+// PluckIDs returns all primary key values under current scope.
+func (a auditLogQueryDo) PluckIDs() ([]int64, error) {
+	ids := make([]int64, 0, 16)
+	pk := field.NewInt64(a.TableName(), "id")
+	if err := a.DO.Pluck(pk, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// GetByID finds a single record by primary key.
+func (a auditLogQueryDo) GetByID(id int64) (*AuditLog, error) {
+	pk := field.NewInt64(a.TableName(), "id")
+	return a.Where(pk.Eq(id)).First()
+}
+
+// GetByIDs finds records by primary key list.
+func (a auditLogQueryDo) GetByIDs(ids ...int64) ([]*AuditLog, error) {
+	if len(ids) == 0 {
+		return []*AuditLog{}, nil
+	}
+	pk := field.NewInt64(a.TableName(), "id")
+	return a.Where(pk.In(ids...)).Find()
+}
+
+// DeleteByID deletes records by primary key.
+func (a auditLogQueryDo) DeleteByID(id int64) (gen.ResultInfo, error) {
+	pk := field.NewInt64(a.TableName(), "id")
+	return a.Where(pk.Eq(id)).Delete()
+}
+
+// DeleteByIDs deletes records by a list of primary keys.
+func (a auditLogQueryDo) DeleteByIDs(ids ...int64) (gen.ResultInfo, error) {
+	if len(ids) == 0 {
+		return gen.ResultInfo{RowsAffected: 0, Error: nil}, nil
+	}
+	pk := field.NewInt64(a.TableName(), "id")
+	return a.Where(pk.In(ids...)).Delete()
+}
+
+func (a *auditLogQueryDo) withDO(do gen.Dao) *auditLogQueryDo {
+	a.DO = *do.(*gen.DO)
+	return a
+}