gisk

README

gisk风控策略引擎

gisk是独立的即插即用的轻量级决策引擎，支持json和yaml格式DSL。支持自定义运算符，自定义函数，自定义动作开放灵活的扩展适用更多的业务场景。

功能列表

• 基础值
  • 变量
  • 输入值
  • 函数
• 决策（规则）
• 决策集
• 决策流
• 评分卡
• 条件分流
• 支持数据类型：number, string, bool, array, map
• 支持运算符号（支持自定义，覆盖默认运算符）：eq, neq, gt, lt, gte, lte, in, notIn, like, notLike
• 支持函数（支持自定义，函数支持嵌套）：内置函数rand、sum
• 支持决策动作（支持自定义）：内置动作 赋值,访问url
• 支持串行并行执行
• DSL支持历史版本控制（提供获取接口，实现不同介质DSL储存。内置文件存储）
• DSL支持json和yaml格式

快速开始

• 环境准备

  go version go1.2+

• 安装

go get -u -v gitee.com/sreeb/gisk

• 基础使用

package main

import (
  "fmt"
  "gitee.com/sreeb/gisk"
)

func main() {
  elementType := gisk.RULES //规则
  rulesKey := "rules1" //规则唯一key
  version := "1" //规则版本

  g := gisk.New() //创建gisk实例
  g.SetDslFormat(gisk.JSON) //设置dsl格式
  err := g.Parse(elementType, rulesKey, version) //解析规则
  if err != nil {
    //错误处理
  }
  //获取所有被初始化的变量值
  variates := g.GetVariates()
  fmt.Println(variates)
}

• 注册dsl获取接口

dsl接口获取器,可以根据提供的类型和key和版本获取dsl字符串。 dsl接口获取器需要实现gisk.DslGetterInterface接口，返回dsl字符串。

type DslGetterInterface interface {
	GetDsl(elementType ElementType, key string, version string) (string, error)
}

示例：

type fileDslGetter struct {
}

func (getter *fileDslGetter) GetDsl(elementType gisk.ElementType, key string, version string) (string, error) {
	path := "./dsl/" + elementType + "_" + key + "_" + version + ".json"
	bytes, err := os.ReadFile(path)
	if err != nil {
		return "", err
	}
	return  string(bytes), nil
}

func main() {
    //创建gisk实例
    g := gisk.New()
    //设置dsl获取器
    g.SetDslGetter(&fileDslGetter{})
    //...
}

• 注册比较符

系统实现默认的比较符 eq, neq, gt, lt, gte, lte,in,notIn,like,notLike如果需要自定义比较符，可以调用RegisterOperation方法。自定义比较符优先级高于系统内置的比较符，可以注册和系统同名比较符实现复写。

package main

import (
	"errors"
	"gitee.com/sreeb/gisk"
	"regexp"
)

func main() {
	//自定义正则匹配比较符
	gisk.RegisterOperation("reg", func(left gisk.Value, operator gisk.Operator, right gisk.Value) (result bool, err error) {
		if left.ValueType != gisk.STRING || right.ValueType != gisk.STRING {
			err = errors.New("left and right must be string")
			return
		}
		// 正则表达式匹配
		reg := regexp.MustCompile(right.Value.(string))
		if reg.MatchString(left.Value.(string)) {
			result = true
		}
		return
	})

	g := gisk.New()
	//...
}

• 注册函数

系统实现默认的函数 rand，sum，如果需要自定义函数，可以调用RegisterFunction方法。自定义函数优先级高于系统内置的函数，可以注册和系统同名函数实现复写。*

package main

import (
  "gitee.com/sreeb/gisk"
  "github.com/gogf/gf/v2/util/gconv"
)

func main() {
    //注册求和函数
    gisk.RegisterFunc("sum", func(parameters ...gisk.Value) (gisk.Value, error) {
      var v float64
      for _, parameter := range parameters {
        v += gconv.Float64(parameter.Value)
      }
      return gisk.Value{ValueType: gisk.NUMBER, Value: v}, nil
    })
	
    g := gisk.New()
    //...
}

未完待续。。。

Documentation

Index

• Constants
• func ConvertValueType(value interface{}, valueType ValueType) (Value interface{}, err error)
• func InfixToRPN(parts []string) ([]string, error)
• func Operation(left Value, operator Operator, right Value) (result bool, err error)
• func RegisterAction(name string, actionStruct ActionInterface)
• func RegisterFunc(name string, function Func)
• func RegisterOperation(name Operator, op OperationFunc)
• type ActionInterface
• type ActionType
• type Assignment
  • func (a *Assignment) Parse(gisk *Gisk) error
• type BreakMode
• type Compare
  • func (c *Compare) Parse(gisk *Gisk) (bool bool, err error)
• type Context
  • func (ctx *Context) GetVariate(key string) (Value Value, ok bool)
  • func (ctx *Context) GetVariates() map[string]Value
  • func (ctx *Context) SetVariate(key string, Value Value)
• type DslGetter
  • func (getter *DslGetter) GetDsl(elementType ElementType, key string, version string) (string, error)
• type DslGetterInterface
• type ElementType
• type Func
• type Gisk
  • func New() *Gisk
  • func (gisk *Gisk) GetVariates() map[string]interface{}
  • func (gisk *Gisk) Parse(elementType ElementType, key string, version string) error
  • func (gisk *Gisk) SetDslFormat(format string) *Gisk
  • func (gisk *Gisk) SetDslGetter(getter DslGetterInterface) *Gisk
• type Input
  • func (input *Input) Parse(gisk *Gisk) (Value Value, err error)
• type OperationFunc
• type Operator
• type Rule
  • func GetRule(gisk *Gisk, key string, version string) (*Rule, error)
  • func (r *Rule) Parse(gisk *Gisk) (bool, error)
• type Value
  • func GetValueByTrait(gisk *Gisk, key string) (Value, error)
• type ValueInterface
• type ValueType
• type Variate
  • func (variate *Variate) Parse(gisk *Gisk) (Value Value, err error)

Constants

const (
	HitBreak  = "hit_break"  //规则命中中断后续规则
	MissBreak = "miss_break" //规则未命中中断后续规则
)

const (
	JSON = "json"
	YAML = "yaml"
)

Functions

func ConvertValueType

func ConvertValueType(value interface{}, valueType ValueType) (Value interface{}, err error)

ConvertValueType 转换值数据类型

func InfixToRPN

func InfixToRPN(parts []string) ([]string, error)

InfixToRPN 将算公式转换为逆波兰表达式

func Operation

func Operation(left Value, operator Operator, right Value) (result bool, err error)

Operation 运算

func RegisterAction

func RegisterAction(name string, actionStruct ActionInterface)

func RegisterFunc

func RegisterFunc(name string, function Func)

func RegisterOperation

func RegisterOperation(name Operator, op OperationFunc)

Types

type ActionInterface

type ActionInterface interface {
	Parse(gisk *Gisk) error
}

type ActionType

type ActionType struct {
	ActionType string `json:"action_type" yaml:"action_type"`
}

type Assignment

type Assignment struct {
	ActionType ActionType
	Variate    string `json:"variate" yaml:"variate"`
	Value      string `json:"value" yaml:"value"`
}

func (*Assignment) Parse

func (a *Assignment) Parse(gisk *Gisk) error

type BreakMode

type BreakMode string

BreakMode 规则集规则中断模式

type Compare

type Compare struct {
	Left     string   `json:"left" yaml:"left"`
	Operator Operator `json:"operator" yaml:"operator"` // 比较符号
	Right    string   `json:"right" yaml:"right"`
}

func (*Compare) Parse

func (c *Compare) Parse(gisk *Gisk) (bool bool, err error)

type Context

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

func (*Context) GetVariate

func (ctx *Context) GetVariate(key string) (Value Value, ok bool)

func (*Context) GetVariates

func (ctx *Context) GetVariates() map[string]Value

func (*Context) SetVariate

func (ctx *Context) SetVariate(key string, Value Value)

type DslGetter

type DslGetter struct {
	Getter DslGetterInterface
	Dsl    sync.Map
}

func (*DslGetter) GetDsl

func (getter *DslGetter) GetDsl(elementType ElementType, key string, version string) (string, error)

type DslGetterInterface

type DslGetterInterface interface {
	GetDsl(elementType ElementType, key string, version string) (string, error)
}

type ElementType

type ElementType string

ElementType 元素类型

const (
	VARIATE ElementType = "variate" //变量
	INPUT   ElementType = "input"   //输入值
	FUNC    ElementType = "func"    //函数
	RULE    ElementType = "rule"    //规则
)

type Func

type Func func(parameters ...Value) (Value, error)

type Gisk

type Gisk struct {
	DslFormat string                 //dsl解析格式：json 或 yaml
	Input     map[string]interface{} //输入值
	Context   *Context               //上下文
	DslGetter *DslGetter             //dsl获取器
}

func New

func New() *Gisk

func (*Gisk) GetVariates

func (gisk *Gisk) GetVariates() map[string]interface{}

GetVariates 获取所有赋值变量

func (*Gisk) Parse

func (gisk *Gisk) Parse(elementType ElementType, key string, version string) error

func (*Gisk) SetDslFormat

func (gisk *Gisk) SetDslFormat(format string) *Gisk

SetDslFormat 设置dsl格式

func (*Gisk) SetDslGetter

func (gisk *Gisk) SetDslGetter(getter DslGetterInterface) *Gisk

SetDslGetter 设置dsl获取器

type Input

type Input struct {
	ValueType ValueType
	Value     interface{}
}

func (*Input) Parse

func (input *Input) Parse(gisk *Gisk) (Value Value, err error)

type OperationFunc

type OperationFunc func(left Value, operator Operator, right Value) (result bool, err error)

type Operator

type Operator string

Operator 运算符

const (
	EQ      Operator = "eq"
	NEQ     Operator = "neq"
	GT      Operator = "gt"
	LT      Operator = "lt"
	GTE     Operator = "gte"
	LTE     Operator = "lte"
	IN      Operator = "in"
	NOTIN   Operator = "notIn"
	LIKE    Operator = "like"
	NOTLIKE Operator = "notLike"
)

type Rule

type Rule struct {
	Key         string              `json:"key" yaml:"key"`                //唯一标识
	Name        string              `json:"name" yaml:"name"`              //名称
	Desc        string              `json:"desc" yaml:"desc"`              //描述
	Version     string              `json:"version" yaml:"version"`        //版本
	Parallel    bool                `json:"parallel" yaml:"parallel"`      //是否并发执行
	Compares    map[string]*Compare `json:"compares" yaml:"compares"`      //比较
	Expression  string              `json:"expression"  yaml:"expression"` //计算公式
	ActionTure  []json.RawMessage   `json:"action_true" yaml:"action_true"`
	ActionFalse []json.RawMessage   `json:"action_false" yaml:"action_false"`
}

func GetRule

func GetRule(gisk *Gisk, key string, version string) (*Rule, error)

func (*Rule) Parse

func (r *Rule) Parse(gisk *Gisk) (bool, error)

type Value

type Value struct {
	ValueType ValueType
	Value     interface{}
}

func GetValueByTrait

func GetValueByTrait(gisk *Gisk, key string) (Value, error)

GetValueByTrait 获取特征数据

type ValueInterface

type ValueInterface interface {
	Parse(gisk *Gisk) (Value, error)
}

type ValueType

type ValueType string

ValueType 值类型

const (
	NUMBER ValueType = "number"
	STRING ValueType = "string"
	ARRAY  ValueType = "array"
	MAP    ValueType = "map"
	BOOL   ValueType = "bool"
)

type Variate

type Variate struct {
	Key       string      `json:"key" yaml:"key"`               //唯一标识
	Name      string      `json:"name" yaml:"name"`             //变量名称
	Desc      string      `json:"desc" yaml:"desc"`             //描述
	Version   string      `json:"version" yaml:"version"`       //版本
	ValueType ValueType   `json:"value_type" yaml:"value_type"` //值类型
	Default   interface{} `json:"default" yaml:"default"`       //默认值
	IsInput   bool        `json:"is_input" yaml:"is_input"`     //是否要从输入值中匹配
}

func (*Variate) Parse

func (variate *Variate) Parse(gisk *Gisk) (Value Value, err error)