xfilter

package
v0.0.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 8, 2019 License: MIT Imports: 12 Imported by: 0

Documentation

Overview

表单过滤库

Index

Examples

Constants

View Source 
const XFilterTagName = "filter"
View Source 
const XOrmTagName = "orm"

Variables

This section is empty.

Functions

func Filter 

func Filter(src map[string]interface{}, rules []string, selects ...map[string]interface{}) (map[string]interface{}, *gvalid.Error)

使用规则数组过滤

Example 
data, errs := Filter(testData, arrRules)
fmt.Printf("filter3 result:%v, errors:%v\n", data, errs)

data1, errs1 := Filter(testData, arrRules, map[string]interface{}{
	"name":  1,
	"email": 1,
})
fmt.Printf("filter4 result:%v, errors:%v\n", data1, errs1)

Output:

func FilterJson 

func FilterJson(src map[string]interface{}, jsonRule string, selects ...map[string]interface{}) (map[string]interface{}, *gvalid.Error)

使用json验证规则过滤

Example 
data, errs := FilterJson(testData, jsonRules)
fmt.Printf("filter5 result:%v, errors:%v\n", data, errs)

data1, errs1 := FilterJson(testData, jsonRules, map[string]interface{}{
	"name":  1,
	"email": 1,
})
fmt.Printf("filter6 result:%v, errors:%v\n", data1, errs1)

Output:

func FilterJsonOnly 

func FilterJsonOnly(src map[string]interface{}, jsonRule string, selects ...map[string]interface{}) (map[string]interface{}, *gvalid.Error)

使用json验证规则过滤,前且只返回src中存在的字段

func FilterMap 

func FilterMap(src map[string]interface{}, rules map[string]string, selects ...map[string]interface{}) (map[string]interface{}, *gvalid.Error)

使用map规则过滤

Example 
data, errs := FilterMap(testData, rules)
fmt.Printf("filter1 result:%v, errors:%v\n", data, errs)

data1, errs1 := FilterMap(testData, rules, map[string]interface{}{
	"name":  1,
	"email": 1,
})
fmt.Printf("filter2 result:%v, errors:%v\n", data1, errs1)

Output:

func FilterOnly 

func FilterOnly(src map[string]interface{}, rules []string, selects ...map[string]interface{}) (map[string]interface{}, *gvalid.Error)

使用规则数组过滤,并且只返回输入参数中存在的字段

func FilterStruct 

func FilterStruct(src map[string]interface{}, rules interface{}, selects ...map[string]interface{}) (map[string]interface{}, *gvalid.Error)

使用struct定义过滤

Example 
data, errs := FilterStruct(testData, &TestFilterStruct{})
fmt.Printf("filter7 result:%v, errors:%v\n", data, errs)

data1, errs1 := FilterStruct(testData, &TestFilterStruct{}, map[string]interface{}{
	"name":  1,
	"email": 1,
})
fmt.Printf("filter8 result:%v, errors:%v\n", data1, errs1)

Output:

func FilterStructOnly 

func FilterStructOnly(src map[string]interface{}, rules interface{}, selects ...map[string]interface{}) (map[string]interface{}, *gvalid.Error)

使用struct定义过滤并且只返回src中存在的字段

Types

type DefValueFunc 

type DefValueFunc func(params ...interface{}) interface{}

type FieldDataType 

type FieldDataType string

type FieldName 

type FieldName string

type FilterTag 

type FilterTag struct {
	// contains filtered or unexported fields
}

字段过滤器使用的tag

func GetFilterFromArray 

func GetFilterFromArray(arr []string, selects ...map[string]interface{}) []*FilterTag

从字符串数组中获取过滤规则列表

Example 
rules := []string{
	"^name&string$author~!required",
	"^age&int~1",
	"^birthday&time$datetime~2019-01-01!required",
	"^isAudit&bool~false",
}
filters := GetFilterFromArray(rules)
for i, item := range filters {
	fmt.Printf(fmt.Sprintf("%d:%s\n", i, item.ToJson()))
}

Output:

0:{
	"dataType": "string",
	"defValue": "",
	"fieldName": "name",
	"formatter": "author",
	"rules": "required"
}
1:{
	"dataType": "int",
	"defValue": "1",
	"fieldName": "age",
	"formatter": "",
	"rules": ""
}
2:{
	"dataType": "time",
	"defValue": "2019-01-01",
	"fieldName": "birthday",
	"formatter": "datetime",
	"rules": "required"
}
3:{
	"dataType": "bool",
	"defValue": "false",
	"fieldName": "isAudit",
	"formatter": "",
	"rules": ""
}

func GetFilterFromJson 

func GetFilterFromJson(js string, selects ...map[string]interface{}) []*FilterTag

从json字符串获取过滤规则

Example 
filters := GetFilterFromJson(jsonRules)
if filters == nil {
	fmt.Printf("parse fail.")
}
for i, item := range filters {
	fmt.Printf(fmt.Sprintf("%d:%s\n", i, item.ToJson()))
}

Output:

0:{
	"dataType": "bool",
	"defValue": "",
	"fieldName": "isAudit",
	"formatter": "",
	"rules": ""
}
1:{
	"dataType": "string",
	"defValue": "",
	"fieldName": "name",
	"formatter": "author",
	"rules": "required"
}
2:{
	"dataType": "int",
	"defValue": "",
	"fieldName": "age",
	"formatter": "",
	"rules": ""
}
3:{
	"dataType": "time",
	"defValue": "2019-01-01",
	"fieldName": "birthday",
	"formatter": "",
	"rules": "required"
}

func GetFilterFromMap 

func GetFilterFromMap(mp map[string]string, selects ...map[string]interface{}) []*FilterTag

从map中获取过滤字段列表

Example 
rules := map[string]string{
	"name":     "&string$author~!required",
	"age":      "&int~1",
	"birthday": "&time$datetime~2019-01-01!required",
	"isAudit":  "&bool~false",
}
filters := GetFilterFromMap(rules)
for i, item := range filters {
	fmt.Printf(fmt.Sprintf("%d:%s\n", i, item.ToJson()))
}

Output:

0:{
	"dataType": "string",
	"defValue": "",
	"fieldName": "",
	"formatter": "author",
	"rules": "required"
}
1:{
	"dataType": "int",
	"defValue": "1",
	"fieldName": "",
	"formatter": "",
	"rules": ""
}
2:{
	"dataType": "time",
	"defValue": "2019-01-01",
	"fieldName": "",
	"formatter": "datetime",
	"rules": "required"
}
3:{
	"dataType": "bool",
	"defValue": "false",
	"fieldName": "",
	"formatter": "",
	"rules": ""
}

func GetFilterFromStruct 

func GetFilterFromStruct(obj interface{}, selects ...map[string]interface{}) []*FilterTag

从struct中获取过滤规则

Example 
filters := GetFilterFromStruct(&TestFilterStruct{})
if filters == nil {
	fmt.Printf("parse fail.")
}
for i, item := range filters {
	fmt.Printf(fmt.Sprintf("%d:%s\n", i, item.ToJson()))
}

Output:

func NewTag 

func NewTag(structTag ...string) *FilterTag

创建过滤器

Example 
filterTag = NewTag("^user_id&string~admin")
fmt.Printf("new tag:%v", filterTag)

Output:

new tag:^user_id&string~admin

func (*FilterTag) FromJson 

func (f *FilterTag) FromJson(v map[string]interface{})

func (*FilterTag) GetDataType 

func (f *FilterTag) GetDataType() FieldDataType

func (*FilterTag) GetDefValue 

func (f *FilterTag) GetDefValue() interface{}

func (*FilterTag) GetFieldName 

func (f *FilterTag) GetFieldName() FieldName

func (*FilterTag) GetFormatter 

func (f *FilterTag) GetFormatter() string

func (*FilterTag) GetParamName 

func (f *FilterTag) GetParamName() string

func (*FilterTag) GetRules 

func (f *FilterTag) GetRules() string

func (*FilterTag) GetValidMsg 

func (f *FilterTag) GetValidMsg() string

func (*FilterTag) Parse 

func (f *FilterTag) Parse(structTag string)
Example 
filterTag.Parse("^name&string~张三$author!required")
fmt.Printf("parse:%v", filterTag)

Output:

parse:^name&string$author~张三!required

func (*FilterTag) SetDataType 

func (f *FilterTag) SetDataType(dataType FieldDataType)

func (*FilterTag) SetDefValue 

func (f *FilterTag) SetDefValue(v interface{})

func (*FilterTag) SetFieldName 

func (f *FilterTag) SetFieldName(fieldName FieldName)

func (*FilterTag) SetFormatter 

func (f *FilterTag) SetFormatter(formatter string)

func (*FilterTag) SetParamName 

func (f *FilterTag) SetParamName(paramName string)

func (*FilterTag) SetRules 

func (f *FilterTag) SetRules(rules string)

func (*FilterTag) SetValidMsg 

func (f *FilterTag) SetValidMsg(msg string)

func (*FilterTag) String 

func (f *FilterTag) String() string

转换成tag字符串 @字段名 #数据类型 $格式化工具名 ~默认值 !验证规则 @fieldName#dataType$formatter~defValue!rules

Example 
s := filterTag.String()
fmt.Printf("string:%v", s)

Output:

string:^name&string$author~张三!required

func (*FilterTag) ToJson 

func (f *FilterTag) ToJson() string
Example 
fmt.Printf("json:%v", filterTag.ToJson())

Output:

json:{
	"dataType": "string",
	"defValue": "张三",
	"fieldName": "name",
	"formatter": "author",
	"rules": "required"
}

func (*FilterTag) ToMap 

func (f *FilterTag) ToMap() map[string]interface{}
Example 
fmt.Printf("map:%v", filterTag.ToMap())

Output:

map:map[dataType:string defValue:张三 fieldName:name formatter:author rules:required]

func (*FilterTag) ToRuleTag 

func (f *FilterTag) ToRuleTag() string

转换成验证规则字符串

type IFuncManager 

type IFuncManager interface {
	Register(name string, fn DefValueFunc) bool
	Unregister(fnName string) bool
	RegisterFormat(name string, fn DefValueFunc) bool
	UnregisterFormat(name string) bool
	HasFunc(fnName string) bool
	HasFormatter(fnName string) bool
	Call(fnName string, params ...interface{}) (interface{}, error)
	Format(fnName string, params ...interface{}) (interface{}, error)
}

func FuncManager 

func FuncManager(name ...string) IFuncManager

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.