不要组件，直接写了测试通过

model/request/queryreq/operator_enum.go

@@ -0,0 +1,53 @@
+package queryreq
+
+// Operator 查询运算符枚举
+type Operator string
+
+const (
+	// OpEquals 等于
+	OpEquals Operator = "="
+	// OpNotEquals 不等于
+	OpNotEquals Operator = "!="
+	// OpLike 模糊匹配
+	OpLike Operator = "like"
+	// OpIn IN筛选
+	OpIn Operator = "in"
+	// OpGreaterThan 大于
+	OpGreaterThan Operator = ">"
+	// OpLessThan 小于
+	OpLessThan Operator = "<"
+	// OpGreaterOrEq 大于等于
+	OpGreaterOrEq Operator = ">="
+	// OpLessOrEq 小于等于
+	OpLessOrEq Operator = "<="
+)
+
+// IsValid 检查运算符是否有效
+func (o Operator) IsValid() bool {
+	switch o {
+	case OpEquals, OpNotEquals, OpLike, OpIn, OpGreaterThan,
+		OpLessThan, OpGreaterOrEq, OpLessOrEq:
+		return true
+	default:
+		return false
+	}
+}
+
+// ToSQL 将运算符转换为SQL操作符
+func (o Operator) ToSQL() string {
+	switch o {
+	case OpLike:
+		return "LIKE"
+	case OpIn:
+		return "IN"
+	default:
+		return string(o)
+	}
+}
+
+// RequiresValue 检查运算符是否需要值
+func (o Operator) RequiresValue() bool {
+	// 所有定义的运算符都需要值
+	// 未来如果添加IS NULL等不需要值的运算符，可以在此排除
+	return true
+}

model/request/queryreq/query_builder.go

@@ -0,0 +1,202 @@
+package queryreq
+
+import (
+	"fmt"
+	"strings"
+)
+
+// FieldMapper 字段映射函数类型：前端字段名 -> 数据库列名
+type FieldMapper func(string) string
+
+// DefaultFieldMapper 默认字段映射（直接使用原字段名）
+func DefaultFieldMapper(field string) string {
+	return field
+}
+
+// BuildWhereClause 安全构建WHERE子句
+// 返回: WHERE条件字符串, 参数值数组
+func BuildWhereClause(filters []FilterParam, fieldMapper FieldMapper) (string, []interface{}) {
+	if len(filters) == 0 {
+		return "", nil
+	}
+
+	var conditions []string
+	var args []interface{}
+
+	for _, filter := range filters {
+		if !filter.Operator.IsValid() {
+			continue
+		}
+
+		// 获取安全的数据库列名
+		dbField := fieldMapper(filter.Field)
+		if dbField == "" {
+			continue // 无效字段，跳过
+		}
+
+		// 根据运算符构建条件
+		condition, filterArgs := buildCondition(dbField, filter.Operator, filter.Value)
+		if condition != "" {
+			conditions = append(conditions, condition)
+			args = append(args, filterArgs...)
+		}
+	}
+
+	if len(conditions) == 0 {
+		return "", nil
+	}
+
+	return "WHERE " + strings.Join(conditions, " AND "), args
+}
+
+// BuildOrderByClause 安全构建ORDER BY子句
+// 返回: ORDER BY子句字符串
+func BuildOrderByClause(sorts []SortParam, fieldMapper FieldMapper) string {
+	if len(sorts) == 0 {
+		return ""
+	}
+
+	var orderClauses []string
+	for _, sort := range sorts {
+		// 获取安全的数据库列名
+		dbField := fieldMapper(sort.Field)
+		if dbField == "" {
+			continue // 无效字段，跳过
+		}
+
+		// 验证排序方向
+		order := strings.ToUpper(sort.Order)
+		if order != "ASC" && order != "DESC" {
+			order = "ASC" // 默认升序
+		}
+
+		orderClauses = append(orderClauses, fmt.Sprintf("%s %s", dbField, order))
+	}
+
+	if len(orderClauses) == 0 {
+		return ""
+	}
+
+	return "ORDER BY " + strings.Join(orderClauses, ", ")
+}
+
+// buildCondition 构建单个筛选条件
+func buildCondition(field string, operator Operator, value interface{}) (string, []interface{}) {
+	switch operator {
+	case OpEquals, OpNotEquals, OpGreaterThan, OpLessThan, OpGreaterOrEq, OpLessOrEq:
+		return fmt.Sprintf("%s %s ?", field, operator.ToSQL()), []interface{}{value}
+
+	case OpLike:
+		// LIKE操作自动添加通配符
+		if strVal, ok := value.(string); ok {
+			return fmt.Sprintf("%s LIKE ?", field), []interface{}{"%" + strVal + "%"}
+		}
+		// 非字符串类型，直接使用值
+		return fmt.Sprintf("%s LIKE ?", field), []interface{}{value}
+
+	case OpIn:
+		return buildInCondition(field, value)
+
+	default:
+		return "", nil
+	}
+}
+
+// buildInCondition 构建IN条件
+func buildInCondition(field string, value interface{}) (string, []interface{}) {
+	// 处理IN操作符的值
+	values, ok := processInValue(value)
+	if !ok || len(values) == 0 {
+		return "", nil
+	}
+
+	// 构建占位符 (?, ?, ?)
+	placeholders := strings.Repeat("?, ", len(values))
+	placeholders = placeholders[:len(placeholders)-2] // 移除最后的逗号和空格
+
+	return fmt.Sprintf("%s IN (%s)", field, placeholders), values
+}
+
+// processInValue 处理IN操作符的值，转换为参数数组
+// 支持逗号分隔的字符串、字符串数组、接口数组等
+func processInValue(value interface{}) ([]interface{}, bool) {
+	switch v := value.(type) {
+	case string:
+		// 逗号分隔的字符串
+		if strings.Contains(v, ",") {
+			parts := strings.Split(v, ",")
+			var result []interface{}
+			for _, part := range parts {
+				trimmed := strings.TrimSpace(part)
+				if trimmed != "" {
+					// 尝试解析为数值
+					if num, err := parseNumber(trimmed); err == nil {
+						result = append(result, num)
+					} else {
+						result = append(result, trimmed)
+					}
+				}
+			}
+			return result, len(result) > 0
+		}
+		// 单个字符串值
+		return []interface{}{v}, true
+
+	case []string:
+		// 字符串数组
+		var result []interface{}
+		for _, item := range v {
+			if trimmed := strings.TrimSpace(item); trimmed != "" {
+				if num, err := parseNumber(trimmed); err == nil {
+					result = append(result, num)
+				} else {
+					result = append(result, trimmed)
+				}
+			}
+		}
+		return result, len(result) > 0
+
+	case []interface{}:
+		// 接口数组
+		var result []interface{}
+		for _, item := range v {
+			if item != nil {
+				result = append(result, item)
+			}
+		}
+		return result, len(result) > 0
+
+	default:
+		// 其他类型视为单个值
+		return []interface{}{v}, true
+	}
+}
+
+// parseNumber 尝试将字符串解析为数值
+func parseNumber(s string) (interface{}, error) {
+	// 尝试解析为整数
+	if intVal, err := parseInt(s); err == nil {
+		return intVal, nil
+	}
+
+	// 尝试解析为浮点数
+	if floatVal, err := parseFloat(s); err == nil {
+		return floatVal, nil
+	}
+
+	return nil, fmt.Errorf("not a number")
+}
+
+// parseInt 解析整数
+func parseInt(s string) (int64, error) {
+	var val int64
+	_, err := fmt.Sscanf(s, "%d", &val)
+	return val, err
+}
+
+// parseFloat 解析浮点数
+func parseFloat(s string) (float64, error) {
+	var val float64
+	_, err := fmt.Sscanf(s, "%f", &val)
+	return val, err
+}

model/request/queryreq/query_request.go

@@ -0,0 +1,63 @@
+package queryreq
+
+// SortParam 排序参数
+type SortParam struct {
+	Field string `json:"field"` // 前端字段名
+	Order string `json:"order"` // asc/desc
+}
+
+// FilterParam 筛选参数
+type FilterParam struct {
+	Field    string      `json:"field"`    // 前端字段名
+	Operator Operator    `json:"operator"` // 运算符枚举
+	Value    interface{} `json:"value"`    // 值（支持多种类型）
+}
+
+// QueryRequest 通用查询请求
+type QueryRequest struct {
+	Page     int           `json:"page"`     // 页码（从0开始）
+	PageSize int           `json:"pageSize"` // 每页大小
+	Sort     []SortParam   `json:"sort,omitempty"`
+	Filter   []FilterParam `json:"filter,omitempty"`
+}
+
+// Validate 验证查询请求参数
+func (q *QueryRequest) Validate() error {
+	// 验证分页参数
+	if q.Page < 0 {
+		q.Page = 0
+	}
+	if q.PageSize <= 0 {
+		q.PageSize = 10
+	} else if q.PageSize > 1000 {
+		q.PageSize = 1000 // 限制最大页大小
+	}
+
+	// 验证排序参数
+	for i := range q.Sort {
+		if q.Sort[i].Order != "asc" && q.Sort[i].Order != "desc" {
+			q.Sort[i].Order = "asc" // 默认升序
+		}
+	}
+
+	// 验证筛选参数
+	for i := range q.Filter {
+		if !q.Filter[i].Operator.IsValid() {
+			// 无效运算符，移除该筛选条件
+			q.Filter = append(q.Filter[:i], q.Filter[i+1:]...)
+			continue
+		}
+	}
+
+	return nil
+}
+
+// GetOffset 计算分页偏移量
+func (q *QueryRequest) GetOffset() int {
+	return q.Page * q.PageSize
+}
+
+// GetLimit 获取分页限制
+func (q *QueryRequest) GetLimit() int {
+	return q.PageSize
+}

model/request/tabulatorreq/tabulator_request.go

@@ -0,0 +1,97 @@
+package tabulatorreq
+
+import (
+	"git.x2erp.com/qdy/go-base/model/request/queryreq"
+)
+
+// TabulatorSorter Tabulator排序器格式
+type TabulatorSorter struct {
+	Field string `json:"field"` // 排序字段
+	Dir   string `json:"dir"`   // 排序方向: asc/desc
+}
+
+// TabulatorFilter Tabulator筛选器格式
+type TabulatorFilter struct {
+	Field string      `json:"field"` // 筛选字段
+	Type  string      `json:"type"`  // 筛选类型: =, !=, like, >, <, in等
+	Value interface{} `json:"value"` // 筛选值
+}
+
+// TabulatorRequest Tabulator原生请求格式
+type TabulatorRequest struct {
+	Page   int               `json:"page"`             // 当前页码（从1开始）
+	Size   int               `json:"size"`             // 每页大小
+	Sort   []TabulatorSorter `json:"sort,omitempty"`   // 排序器数组（单数，匹配前端）
+	Filter []TabulatorFilter `json:"filter,omitempty"` // 筛选器数组（单数，匹配前端）
+}
+
+// Validate 验证请求参数
+func (r *TabulatorRequest) Validate() {
+	if r.Page < 1 {
+		r.Page = 1
+	}
+	if r.Size <= 0 {
+		r.Size = 10
+	} else if r.Size > 1000 {
+		r.Size = 1000
+	}
+}
+
+// ToQueryRequest 转换为通用QueryRequest
+func (r *TabulatorRequest) ToQueryRequest(fieldMapper func(string) string) *queryreq.QueryRequest {
+	req := &queryreq.QueryRequest{
+		Page:     r.Page - 1, // Tabulator从1开始，QueryRequest从0开始
+		PageSize: r.Size,
+	}
+
+	// 转换排序器
+	for _, sorter := range r.Sort {
+		field := fieldMapper(sorter.Field)
+		if field == "" {
+			continue // 无效字段，跳过
+		}
+		req.Sort = append(req.Sort, queryreq.SortParam{
+			Field: field,
+			Order: sorter.Dir,
+		})
+	}
+
+	// 转换筛选器
+	for _, filter := range r.Filter {
+		field := fieldMapper(filter.Field)
+		if field == "" {
+			continue // 无效字段，跳过
+		}
+		req.Filter = append(req.Filter, queryreq.FilterParam{
+			Field:    field,
+			Operator: mapOperator(filter.Type),
+			Value:    filter.Value,
+		})
+	}
+
+	return req
+}
+
+// mapOperator 映射Tabulator操作符到QueryRequest操作符
+func mapOperator(tabulatorOp string) queryreq.Operator {
+	switch tabulatorOp {
+	case "=", "==":
+		return queryreq.OpEquals
+	case "!=", "<>":
+		return queryreq.OpNotEquals
+	case "like", "contains":
+		return queryreq.OpLike
+	case "in":
+		return queryreq.OpIn
+	case ">":
+		return queryreq.OpGreaterThan
+	case "<":
+		return queryreq.OpLessThan
+	case ">=":
+		return queryreq.OpGreaterOrEq
+	case "<=":
+		return queryreq.OpLessOrEq
+	default:
+		return queryreq.OpEquals
+	}
+}

model/response/response_model.go

@@ -9,6 +9,7 @@ import (
 // QueryResult 查询结果
 type QueryResult[T any] struct {
 	Success    bool                `json:"success"`
+	LastPage   int                 `json:"last_page,omitempty"`
 	Data       T                   `json:"data,omitempty"`
 	Error      string              `json:"error,omitempty"`
 	Count      int                 `json:"count,omitempty"`

model/response/tabulator_response.go

@@ -0,0 +1,109 @@
+package response
+
+import (
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"git.x2erp.com/qdy/go-base/ctx"
+)
+
+// TabulatorResponse Tabulator期望的响应格式
+type TabulatorResponse struct {
+	LastPage int         `json:"last_page"` // 总页数
+	Data     interface{} `json:"data"`      // 数据数组
+}
+
+// CreateTabulatorResponse 创建Tabulator格式的响应
+func CreateTabulatorResponse[T any](data T, totalCount int, pageSize int, reqCtx *ctx.RequestContext) *QueryResult[map[string]interface{}] {
+	// 计算总页数
+	lastPage := 1
+	if pageSize > 0 && totalCount > 0 {
+		lastPage = (totalCount + pageSize - 1) / pageSize
+	}
+
+	// 构建Tabulator格式数据
+	tabulatorData := map[string]interface{}{
+		"last_page": lastPage,
+		"data":      data,
+	}
+
+	// 创建成功结果
+	result := &QueryResult[map[string]interface{}]{
+		Success:    true,
+		Data:       tabulatorData,
+		TotalCount: totalCount,
+		Time:       time.Now().Format(time.RFC3339),
+		Metadata:   reqCtx,
+	}
+
+	// 如果数据是数组，设置Count
+	switch v := any(data).(type) {
+	case []interface{}:
+		result.Count = len(v)
+	case []map[string]interface{}:
+		result.Count = len(v)
+	default:
+		// 尝试通过反射获取长度
+		// 简化处理，如果无法获取长度，使用TotalCount
+		result.Count = totalCount
+	}
+
+	return result
+}
+
+// AdaptToTabulator 将现有QueryResult适配为Tabulator格式
+// 此函数主要用于中间件或处理器直接输出Tabulator格式
+func AdaptToTabulator[T any](result *QueryResult[T], pageSize int) []byte {
+	if !result.Success {
+		// 错误响应格式
+		errorResponse := map[string]interface{}{
+			"error": result.Error,
+		}
+		if result.Message != "" {
+			errorResponse["message"] = result.Message
+		}
+		jsonData, _ := json.Marshal(errorResponse)
+		return jsonData
+	}
+
+	// 计算总页数
+	lastPage := 1
+	if pageSize > 0 && result.TotalCount > 0 {
+		lastPage = (result.TotalCount + pageSize - 1) / pageSize
+	}
+
+	// 构建Tabulator格式响应
+	tabulatorResponse := map[string]interface{}{
+		"last_page": lastPage,
+		"data":      result.Data,
+	}
+
+	// 编码为JSON
+	jsonData, err := json.Marshal(tabulatorResponse)
+	if err != nil {
+		// 编码失败，返回错误
+		errorResponse := map[string]interface{}{
+			"error": fmt.Sprintf("JSON编码失败: %v", err),
+		}
+		errorData, _ := json.Marshal(errorResponse)
+		return errorData
+	}
+
+	return jsonData
+}
+
+// CreateTabulatorErrorResponse 创建Tabulator格式的错误响应
+func CreateTabulatorErrorResponse(errorMsg string, reqCtx *ctx.RequestContext) *QueryResult[map[string]interface{}] {
+	errorResponse := map[string]interface{}{
+		"error": errorMsg,
+	}
+
+	return &QueryResult[map[string]interface{}]{
+		Success:  false,
+		Data:     errorResponse,
+		Error:    errorMsg,
+		Time:     time.Now().Format(time.RFC3339),
+		Metadata: reqCtx,
+	}
+}