615 lines
16 KiB
Go
615 lines
16 KiB
Go
package utils
|
||
|
||
import (
|
||
"context"
|
||
"errors"
|
||
"fmt"
|
||
"reflect"
|
||
"strings"
|
||
|
||
"gorm.io/gorm"
|
||
"gorm.io/gorm/schema"
|
||
)
|
||
|
||
// 定义上下文别名，保持原代码风格
|
||
type ctx = context.Context
|
||
|
||
// IDao -------------------------- 核心接口定义 --------------------------
|
||
// IDao GORM 版本的Dao接口，提供GORM DB实例和表相关信息
|
||
type IDao interface {
|
||
DB() *gorm.DB // 返回GORM的DB实例
|
||
Table() string // 返回表名
|
||
PrimaryKey() string // 返回主键字段名（如：id）
|
||
Ctx(ctx context.Context) *gorm.DB // 绑定上下文的DB实例
|
||
Transaction(ctx context.Context, f func(ctx context.Context, tx *gorm.DB) error) error // 事务方法
|
||
}
|
||
|
||
// Paginate -------------------------- 分页结构体定义 --------------------------
|
||
// Paginate 分页参数结构体（补全原代码中缺失的定义，保持功能完整）
|
||
type Paginate struct {
|
||
Page int // 页码（从1开始）
|
||
Limit int // 每页条数
|
||
}
|
||
|
||
// -------------------------- 全局常量 --------------------------
|
||
// 分页相关字段，用于清理请求参数
|
||
var pageInfo = []string{
|
||
"page",
|
||
"size",
|
||
"num",
|
||
"limit",
|
||
"pagesize",
|
||
"pageSize",
|
||
"page_size",
|
||
"pageNum",
|
||
"pagenum",
|
||
"page_num",
|
||
}
|
||
|
||
// Curd -------------------------- 泛型CURD核心结构体 --------------------------
|
||
// Curd GORM 版本的泛型CURD封装，R为对应的模型结构体
|
||
type Curd[R any] struct {
|
||
Dao IDao
|
||
}
|
||
|
||
// -------------------------- 工具方法：字段名转换（保持原代码的命名风格转换） --------------------------
|
||
// caseConvert 字段名风格转换（下划线 <-> 小驼峰）
|
||
func caseConvert(key string, toSnake bool) string {
|
||
if toSnake {
|
||
// 驼峰转下划线（参考GORM的命名策略）
|
||
return schema.NamingStrategy{}.ColumnName("", key)
|
||
}
|
||
// 下划线转小驼峰
|
||
var result strings.Builder
|
||
upperNext := false
|
||
for i, c := range key {
|
||
if c == '_' && i < len(key)-1 {
|
||
upperNext = true
|
||
continue
|
||
}
|
||
if upperNext {
|
||
result.WriteRune(rune(strings.ToUpper(string(c))[0]))
|
||
upperNext = false
|
||
} else {
|
||
result.WriteRune(c)
|
||
}
|
||
}
|
||
return result.String()
|
||
}
|
||
|
||
// BuildWhere -------------------------- 原BuildWhere对应实现：构建查询条件map --------------------------
|
||
func (c Curd[R]) BuildWhere(req any, changeWhere any, subWhere any, removeFields []string, isSnake ...bool) map[string]any {
|
||
// 默认使用小写下划线方式
|
||
toSnake := true
|
||
if len(isSnake) > 0 && !isSnake[0] {
|
||
toSnake = false
|
||
}
|
||
|
||
// 1. 转换req为map并清理无效数据
|
||
reqMap := convToMap(req)
|
||
cleanedReq := make(map[string]any)
|
||
|
||
for k, v := range reqMap {
|
||
// 清理空值
|
||
if isEmpty(v) {
|
||
continue
|
||
}
|
||
// 清理分页字段
|
||
if strInArray(pageInfo, k) {
|
||
continue
|
||
}
|
||
// 清理指定移除字段
|
||
if len(removeFields) > 0 && strInArray(removeFields, k) {
|
||
continue
|
||
}
|
||
// 转换字段名风格并存入
|
||
cleanedReq[caseConvert(k, toSnake)] = v
|
||
}
|
||
|
||
// 2. 处理changeWhere（修改查询操作符，如：eq -> gt）
|
||
if changeWhere != nil {
|
||
changeMap := convToMap(changeWhere)
|
||
for k, v := range changeMap {
|
||
// 跳过不存在于cleanedReq的字段
|
||
if _, exists := cleanedReq[k]; !exists {
|
||
continue
|
||
}
|
||
// 跳过指定移除的字段
|
||
if len(removeFields) > 0 && strInArray(removeFields, k) {
|
||
continue
|
||
}
|
||
|
||
vMap := convToMap(v)
|
||
value, hasValue := vMap["value"]
|
||
op, hasOp := vMap["op"]
|
||
|
||
if hasValue {
|
||
// 存在操作符则重构字段名（GORM支持 "字段名 >" 这种格式作为where key）
|
||
if hasOp && op != "" {
|
||
newKey := fmt.Sprintf("%s %s", k, op)
|
||
delete(cleanedReq, k)
|
||
cleanedReq[newKey] = value
|
||
} else {
|
||
cleanedReq[k] = value
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 3. 字段名风格最终转换（确保一致性）
|
||
resultMap := make(map[string]any)
|
||
for k, v := range cleanedReq {
|
||
// 拆分字段名和操作符
|
||
parts := strings.SplitN(k, " ", 2)
|
||
fieldName := parts[0]
|
||
opStr := ""
|
||
if len(parts) == 2 {
|
||
opStr = parts[1]
|
||
}
|
||
|
||
// 转换字段名风格
|
||
convertedField := caseConvert(fieldName, toSnake)
|
||
|
||
// 重构带操作符的key
|
||
if opStr != "" {
|
||
resultMap[fmt.Sprintf("%s %s", convertedField, opStr)] = v
|
||
} else {
|
||
resultMap[convertedField] = v
|
||
}
|
||
}
|
||
|
||
// 4. 合并subWhere附加条件
|
||
if subWhere != nil {
|
||
subMap := convToMap(subWhere)
|
||
for k, v := range subMap {
|
||
resultMap[caseConvert(k, toSnake)] = v
|
||
}
|
||
}
|
||
|
||
return resultMap
|
||
}
|
||
|
||
// BuildMap -------------------------- 原BuildMap对应实现：构建变更条件map --------------------------
|
||
func (c Curd[R]) BuildMap(op string, value any, field ...string) map[string]any {
|
||
res := map[string]any{
|
||
"op": op,
|
||
"field": "",
|
||
"value": value,
|
||
}
|
||
if len(field) > 0 {
|
||
res["field"] = field[0]
|
||
}
|
||
return res
|
||
}
|
||
|
||
// ClearField -------------------------- 原ClearField对应实现：清理请求参数并返回有效map --------------------------
|
||
func (c Curd[R]) ClearField(req any, delField []string, subField ...map[string]any) map[string]any {
|
||
reqMap := convToMap(req)
|
||
resultMap := make(map[string]any)
|
||
|
||
// 过滤无效数据和指定删除字段
|
||
for k, v := range reqMap {
|
||
if isEmpty(v) {
|
||
continue
|
||
}
|
||
if strInArray(pageInfo, k) {
|
||
continue
|
||
}
|
||
if len(delField) > 0 && strInArray(delField, k) {
|
||
continue
|
||
}
|
||
resultMap[k] = v
|
||
}
|
||
|
||
// 合并附加字段
|
||
if len(subField) > 0 && subField[0] != nil {
|
||
for k, v := range subField[0] {
|
||
resultMap[k] = v
|
||
}
|
||
}
|
||
|
||
return resultMap
|
||
}
|
||
|
||
// ClearFieldPage -------------------------- 原ClearFieldPage对应实现：清理参数+分页查询 --------------------------
|
||
func (c Curd[R]) ClearFieldPage(ctx ctx, req any, delField []string, where any, page *Paginate, order any, with bool) (items []*R, total int64, err error) {
|
||
// 1. 清理请求参数
|
||
filterMap := c.ClearField(req, delField)
|
||
|
||
// 2. 初始化GORM查询
|
||
db := c.Dao.Ctx(ctx)
|
||
if with {
|
||
db = db.Preload("*") // GORM 关联查询全部，对应GF的WithAll()
|
||
}
|
||
|
||
// 3. 构建查询条件
|
||
db = db.Model(new(R)).Where(filterMap)
|
||
if where != nil {
|
||
db = db.Where(where)
|
||
}
|
||
|
||
// 4. 排序
|
||
if order != nil {
|
||
db = db.Order(order)
|
||
}
|
||
|
||
// 5. 统计总数
|
||
if err = db.Count(&total).Error; err != nil {
|
||
return nil, 0, err
|
||
}
|
||
|
||
// 6. 分页查询
|
||
if page != nil && page.Limit > 0 {
|
||
offset := (page.Page - 1) * page.Limit
|
||
db = db.Offset(offset).Limit(page.Limit)
|
||
}
|
||
|
||
// 7. 执行查询
|
||
err = db.Find(&items).Error
|
||
return
|
||
}
|
||
|
||
// ClearFieldList -------------------------- 原ClearFieldList对应实现：清理参数+列表查询（不分页） --------------------------
|
||
func (c Curd[R]) ClearFieldList(ctx ctx, req any, delField []string, where any, order any, with bool) (items []*R, err error) {
|
||
filterMap := c.ClearField(req, delField)
|
||
db := c.Dao.Ctx(ctx).Model(new(R))
|
||
|
||
if with {
|
||
db = db.Preload("*")
|
||
}
|
||
if where != nil {
|
||
db = db.Where(where)
|
||
}
|
||
if order != nil {
|
||
db = db.Order(order)
|
||
}
|
||
|
||
err = db.Where(filterMap).Find(&items).Error
|
||
return
|
||
}
|
||
|
||
// ClearFieldOne -------------------------- 原ClearFieldOne对应实现：清理参数+单条查询 --------------------------
|
||
func (c Curd[R]) ClearFieldOne(ctx ctx, req any, delField []string, where any, order any, with bool) (item *R, err error) {
|
||
item = new(R)
|
||
filterMap := c.ClearField(req, delField)
|
||
db := c.Dao.Ctx(ctx).Model(item)
|
||
|
||
if with {
|
||
db = db.Preload("*")
|
||
}
|
||
if where != nil {
|
||
db = db.Where(where)
|
||
}
|
||
if order != nil {
|
||
db = db.Order(order)
|
||
}
|
||
|
||
err = db.Where(filterMap).First(item).Error
|
||
// 处理记录不存在的情况（GORM会返回ErrRecordNotFound）
|
||
if errors.Is(err, gorm.ErrRecordNotFound) {
|
||
panic("未找到数据")
|
||
}
|
||
return
|
||
}
|
||
|
||
// Value -------------------------- 原Value对应实现：查询单个字段值 --------------------------
|
||
func (c Curd[R]) Value(ctx ctx, where any, field any) (interface{}, error) {
|
||
var result interface{}
|
||
db := c.Dao.Ctx(ctx).Model(new(R)).Where(where)
|
||
|
||
// 处理字段参数
|
||
if field != nil {
|
||
fieldStr, ok := field.(string)
|
||
if !ok || fieldStr == "" {
|
||
fieldStr = "*"
|
||
}
|
||
db = db.Select(fieldStr)
|
||
} else {
|
||
db = db.Select("*")
|
||
}
|
||
|
||
// 执行查询（取第一条记录的指定字段）
|
||
err := db.First(&result).Error
|
||
if errors.Is(err, gorm.ErrRecordNotFound) {
|
||
panic("未找到数据")
|
||
}
|
||
return result, err
|
||
}
|
||
|
||
// DeletePri -------------------------- 原DeletePri对应实现：按主键删除 --------------------------
|
||
func (c Curd[R]) DeletePri(ctx ctx, primaryKey any) error {
|
||
db := c.Dao.Ctx(ctx).Model(new(R))
|
||
// 按主键字段构建查询
|
||
pk := c.Dao.PrimaryKey()
|
||
if pk == "" {
|
||
panic("主键字段未配置")
|
||
}
|
||
return db.Where(fmt.Sprintf("%s = ?", pk), primaryKey).Delete(new(R)).Error
|
||
}
|
||
|
||
// DeleteWhere -------------------------- 原DeleteWhere对应实现：按条件删除 --------------------------
|
||
func (c Curd[R]) DeleteWhere(ctx ctx, where any) error {
|
||
return c.Dao.Ctx(ctx).Model(new(R)).Where(where).Delete(new(R)).Error
|
||
}
|
||
|
||
// Sum -------------------------- 原Sum对应实现：字段求和 --------------------------
|
||
func (c Curd[R]) Sum(ctx ctx, where any, field string) float64 {
|
||
var sum float64
|
||
if field == "" {
|
||
panic("求和字段不能为空")
|
||
}
|
||
|
||
err := c.Dao.Ctx(ctx).Model(new(R)).Where(where).Select(fmt.Sprintf("SUM(%s) as sum", field)).Scan(&sum).Error
|
||
if errors.Is(err, gorm.ErrRecordNotFound) {
|
||
panic("未找到数据")
|
||
}
|
||
return sum
|
||
}
|
||
|
||
// ArrayField -------------------------- 原ArrayField对应实现：查询指定字段数组 --------------------------
|
||
func (c Curd[R]) ArrayField(ctx ctx, where any, field any) []interface{} {
|
||
var result []interface{}
|
||
db := c.Dao.Ctx(ctx).Model(new(R)).Where(where)
|
||
|
||
// 处理字段参数
|
||
if field != nil {
|
||
fieldStr, ok := field.(string)
|
||
if !ok || fieldStr == "" {
|
||
fieldStr = "*"
|
||
}
|
||
db = db.Select(fieldStr)
|
||
} else {
|
||
db = db.Select("*")
|
||
}
|
||
|
||
// 执行查询
|
||
err := db.Find(&result).Error
|
||
if errors.Is(err, gorm.ErrRecordNotFound) {
|
||
panic("未找到数据")
|
||
}
|
||
return result
|
||
}
|
||
|
||
// FindPri -------------------------- 原FindPri对应实现：按主键查询单条记录 --------------------------
|
||
func (c Curd[R]) FindPri(ctx ctx, primaryKey any, with bool) (model *R) {
|
||
model = new(R)
|
||
db := c.Dao.Ctx(ctx).Model(model)
|
||
pk := c.Dao.PrimaryKey()
|
||
|
||
if pk == "" {
|
||
panic("主键字段未配置")
|
||
}
|
||
if with {
|
||
db = db.Preload("*")
|
||
}
|
||
|
||
// 按主键查询
|
||
err := db.Where(fmt.Sprintf("%s = ?", pk), primaryKey).First(model).Error
|
||
if errors.Is(err, gorm.ErrRecordNotFound) {
|
||
panic("未找到数据")
|
||
}
|
||
return
|
||
}
|
||
|
||
// -------------------------- 原First对应实现：按条件查询第一条记录 --------------------------
|
||
func (c Curd[R]) First(ctx ctx, where any, order any, with bool) (model *R) {
|
||
model = new(R)
|
||
db := c.Dao.Ctx(ctx).Model(model)
|
||
|
||
if with {
|
||
db = db.Preload("*")
|
||
}
|
||
if where != nil {
|
||
db = db.Where(where)
|
||
}
|
||
if order != nil {
|
||
db = db.Order(order)
|
||
}
|
||
|
||
err := db.First(model).Error
|
||
if errors.Is(err, gorm.ErrRecordNotFound) {
|
||
panic("未找到数据")
|
||
}
|
||
return
|
||
}
|
||
|
||
// -------------------------- 原Exists对应实现：判断记录是否存在 --------------------------
|
||
func (c Curd[R]) Exists(ctx ctx, where any) (exists bool) {
|
||
var count int64
|
||
err := c.Dao.Ctx(ctx).Model(new(R)).Where(where).Count(&count).Error
|
||
if err != nil {
|
||
panic(fmt.Sprintf("Exists查询错误: %v", err))
|
||
}
|
||
return count > 0
|
||
}
|
||
|
||
// -------------------------- 原All对应实现：查询所有符合条件的记录 --------------------------
|
||
func (c Curd[R]) All(ctx ctx, where any, order any, with bool) (items []*R) {
|
||
db := c.Dao.Ctx(ctx).Model(new(R))
|
||
|
||
if with {
|
||
db = db.Preload("*")
|
||
}
|
||
if where != nil {
|
||
db = db.Where(where)
|
||
}
|
||
if order != nil {
|
||
db = db.Order(order)
|
||
}
|
||
|
||
err := db.Find(&items).Error
|
||
if errors.Is(err, gorm.ErrRecordNotFound) {
|
||
panic(fmt.Sprintf("All查询错误: %v", err))
|
||
}
|
||
return
|
||
}
|
||
|
||
// -------------------------- 原Count对应实现：统计记录总数 --------------------------
|
||
func (c Curd[R]) Count(ctx ctx, where any) (count int64) {
|
||
err := c.Dao.Ctx(ctx).Model(new(R)).Where(where).Count(&count).Error
|
||
if errors.Is(err, gorm.ErrRecordNotFound) {
|
||
panic(fmt.Sprintf("Count查询错误: %v", err))
|
||
}
|
||
return
|
||
}
|
||
|
||
// -------------------------- 原Save对应实现：新增/更新记录（对应GORM的Save） --------------------------
|
||
func (c Curd[R]) Save(ctx ctx, data any) {
|
||
err := c.Dao.Ctx(ctx).Model(new(R)).Create(data).Error
|
||
if err != nil {
|
||
panic(fmt.Sprintf("Save保存错误: %v", err))
|
||
}
|
||
}
|
||
|
||
// -------------------------- 原Update对应实现：按条件更新记录 --------------------------
|
||
func (c Curd[R]) Update(ctx ctx, where any, data any) (count int64) {
|
||
result := c.Dao.Ctx(ctx).Model(new(R)).Where(where).Updates(data)
|
||
if errors.Is(result.Error, gorm.ErrRecordNotFound) {
|
||
panic(fmt.Sprintf("Update更新错误: %v", result.Error.Error()))
|
||
}
|
||
return result.RowsAffected
|
||
}
|
||
|
||
// -------------------------- 原UpdatePri对应实现：按主键更新记录 --------------------------
|
||
func (c Curd[R]) UpdatePri(ctx ctx, primaryKey any, data any) (count int64) {
|
||
db := c.Dao.Ctx(ctx).Model(new(R))
|
||
pk := c.Dao.PrimaryKey()
|
||
|
||
if pk == "" {
|
||
panic("主键字段未配置")
|
||
}
|
||
|
||
result := db.Where(fmt.Sprintf("%s = ?", pk), primaryKey).Updates(data)
|
||
if errors.Is(result.Error, gorm.ErrRecordNotFound) {
|
||
panic(fmt.Sprintf("UpdatePri更新错误: %v", result.Error.Error()))
|
||
}
|
||
return result.RowsAffected
|
||
}
|
||
|
||
// -------------------------- 原Paginate对应实现：分页查询 --------------------------
|
||
func (c Curd[R]) Paginate(ctx context.Context, where any, p Paginate, with bool, order any) (items []*R, total int64) {
|
||
db := c.Dao.Ctx(ctx).Model(new(R))
|
||
|
||
// 1. 构建查询条件
|
||
if where != nil {
|
||
db = db.Where(where)
|
||
}
|
||
|
||
// 2. 统计总数
|
||
if err := db.Count(&total).Error; err != nil {
|
||
panic(fmt.Sprintf("Paginate查询错误: %v", err))
|
||
}
|
||
|
||
// 3. 关联查询
|
||
if with {
|
||
db = db.Preload("*")
|
||
}
|
||
|
||
// 4. 排序
|
||
if order != nil {
|
||
db = db.Order(order)
|
||
}
|
||
|
||
// 5. 分页（offset = (页码-1)*每页条数）
|
||
if p.Limit > 0 {
|
||
offset := (p.Page - 1) * p.Limit
|
||
db = db.Offset(offset).Limit(p.Limit)
|
||
}
|
||
|
||
// 6. 执行查询
|
||
err := db.Find(&items).Error
|
||
if err != nil || errors.Is(err, gorm.ErrRecordNotFound) {
|
||
panic(fmt.Sprintf("Paginate查询错误: %v", err))
|
||
}
|
||
return
|
||
}
|
||
|
||
// -------------------------- 内部辅助工具函数 --------------------------
|
||
// convToMap 将任意类型转换为map[string]any（简化版，适配常见场景）
|
||
func convToMap(v any) map[string]any {
|
||
if v == nil {
|
||
return make(map[string]any)
|
||
}
|
||
|
||
val := reflect.ValueOf(v)
|
||
// 处理指针类型
|
||
if val.Kind() == reflect.Ptr {
|
||
val = val.Elem()
|
||
}
|
||
|
||
// 只处理结构体和map类型
|
||
if val.Kind() != reflect.Struct && val.Kind() != reflect.Map {
|
||
return make(map[string]any)
|
||
}
|
||
|
||
result := make(map[string]any)
|
||
|
||
if val.Kind() == reflect.Map {
|
||
// 处理map类型
|
||
for _, key := range val.MapKeys() {
|
||
keyStr, ok := key.Interface().(string)
|
||
if !ok {
|
||
continue
|
||
}
|
||
result[keyStr] = val.MapIndex(key).Interface()
|
||
}
|
||
} else {
|
||
// 处理结构体类型
|
||
typ := val.Type()
|
||
for i := 0; i < val.NumField(); i++ {
|
||
field := typ.Field(i)
|
||
fieldVal := val.Field(i)
|
||
|
||
// 获取json标签作为key（优先），否则用字段名
|
||
jsonTag := field.Tag.Get("json")
|
||
if jsonTag == "" || jsonTag == "-" {
|
||
jsonTag = field.Name
|
||
} else {
|
||
// 分割json标签（忽略omitempty等选项）
|
||
jsonTag = strings.Split(jsonTag, ",")[0]
|
||
}
|
||
|
||
result[jsonTag] = fieldVal.Interface()
|
||
}
|
||
}
|
||
|
||
return result
|
||
}
|
||
|
||
// isEmpty 判断值是否为空
|
||
func isEmpty(v any) bool {
|
||
if v == nil {
|
||
return true
|
||
}
|
||
|
||
val := reflect.ValueOf(v)
|
||
switch val.Kind() {
|
||
case reflect.String:
|
||
return val.String() == ""
|
||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
||
return val.Int() == 0
|
||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
|
||
return val.Uint() == 0
|
||
case reflect.Float32, reflect.Float64:
|
||
return val.Float() == 0
|
||
case reflect.Bool:
|
||
return !val.Bool()
|
||
case reflect.Slice, reflect.Array, reflect.Map, reflect.Chan:
|
||
return val.Len() == 0
|
||
case reflect.Ptr, reflect.Interface:
|
||
return val.IsNil()
|
||
default:
|
||
return false
|
||
}
|
||
}
|
||
|
||
// strInArray 判断字符串是否在数组中
|
||
func strInArray(arr []string, str string) bool {
|
||
for _, v := range arr {
|
||
if strings.EqualFold(v, str) { // 忽略大小写比较
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|