baize/convenient/domain/query_rule/query_rule_definition.go

package query_rule

import (
	"git.sxidc.com/go-framework/baize/framework/core/domain/entity"
	"git.sxidc.com/go-framework/baize/framework/core/tag/rule"
	"sync"
)

const (
	opEqual              = "eq"
	opNotEqual           = "ne"
	opLessThan           = "lt"
	opLessThanOrEqual    = "lte"
	opGreaterThan        = "gt"
	opGreaterThanOrEqual = "gte"
	opIn                 = "in"
	opNotIn              = "not-in"
	opPrefix             = "prefix"
	opSuffix             = "suffix"
	opContains           = "contains"
)

func IsSupportedOperator(op string) bool {
	return op == opEqual || op == opNotEqual ||
		op == opLessThan || op == opLessThanOrEqual ||
		op == opGreaterThan || op == opGreaterThanOrEqual ||
		op == opIn || op == opNotIn ||
		op == opPrefix || op == opSuffix || op == opContains
}

var opTranslationMap = map[string]string{
	opEqual:              "等于",
	opNotEqual:           "不等于",
	opLessThan:           "小于",
	opLessThanOrEqual:    "小于等于",
	opGreaterThan:        "大于",
	opGreaterThanOrEqual: "大于等于",
	opIn:                 "包含在列表",
	opNotIn:              "不包含在列表",
	opPrefix:             "包含前缀",
	opSuffix:             "包含后缀",
	opContains:           "包含",
}

var (
	operatorEqual = Operator{
		Name:   opEqual,
		CNName: opTranslationMap[opEqual],
	}

	operatorNotEqual = Operator{
		Name:   opNotEqual,
		CNName: opTranslationMap[opNotEqual],
	}

	operatorLessThan = Operator{
		Name:   opLessThan,
		CNName: opTranslationMap[opLessThan],
	}

	operatorLessThanOrEqual = Operator{
		Name:   opLessThanOrEqual,
		CNName: opTranslationMap[opLessThanOrEqual],
	}

	operatorGreaterThan = Operator{
		Name:   opGreaterThan,
		CNName: opTranslationMap[opGreaterThan],
	}

	operatorGreaterThanOrEqual = Operator{
		Name:   opGreaterThanOrEqual,
		CNName: opTranslationMap[opGreaterThanOrEqual],
	}

	operatorIn = Operator{
		Name:   opIn,
		CNName: opTranslationMap[opIn],
	}

	operatorNotIn = Operator{
		Name:   opNotIn,
		CNName: opTranslationMap[opNotIn],
	}

	operatorPrefix = Operator{
		Name:   opPrefix,
		CNName: opTranslationMap[opPrefix],
	}

	operatorSuffix = Operator{
		Name:   opSuffix,
		CNName: opTranslationMap[opSuffix],
	}

	operatorContains = Operator{
		Name:   opContains,
		CNName: opTranslationMap[opContains],
	}
)

var operatorOfTypeMap = map[string][]Operator{
	rule.TypeString: {
		operatorEqual, operatorNotEqual, operatorIn, operatorNotIn, operatorPrefix, operatorSuffix, operatorContains,
	},
	rule.TypeTime: {
		operatorEqual, operatorNotEqual, operatorLessThan, operatorLessThanOrEqual, operatorGreaterThan, operatorGreaterThanOrEqual, operatorIn, operatorNotIn,
	},
	rule.TypeNumber: {
		operatorEqual, operatorNotEqual, operatorLessThan, operatorLessThanOrEqual, operatorGreaterThan, operatorGreaterThanOrEqual, operatorIn, operatorNotIn,
	},
	rule.TypeBool: {
		operatorEqual, operatorNotEqual,
	},
}

var registeredDomainMap = &sync.Map{}

type Operator struct {
	Name   string `json:"name"`
	CNName string `json:"cnName"`
}

type QueryRuleDefinitionItem struct {
	FieldType   string     `json:"fieldType"`
	FieldName   string     `json:"fieldName"`
	FieldCNName string     `json:"fieldCNName"`
	ColumnName  string     `json:"columnName"`
	Operators   []Operator `json:"operators"`
}

type RegisterQueryRuleDefinitionsByEntityItem struct {
	Entity   entity.Entity
	FieldMap map[string]string
}

func RegisterQueryRuleDefinitionByEntity(items ...RegisterQueryRuleDefinitionsByEntityItem) error {
	for _, item := range items {
		e := item.Entity

		fields, err := rule.DefaultUsage(e)
		if err != nil {
			return err
		}

		definitions := make([]QueryRuleDefinitionItem, 0)
		for _, field := range fields {
			definitions = append(definitions, QueryRuleDefinitionItem{
				FieldType:   field.Type,
				FieldName:   field.FieldName,
				ColumnName:  field.ColumnName,
				FieldCNName: item.FieldMap[field.FieldName],
				Operators:   operatorOfTypeMap[field.Type],
			})
		}

		registeredDomainMap.Store(e.DomainCamelName(), definitions)
	}

	return nil
}

func GetQueryRuleDefinition(domainName string) []QueryRuleDefinitionItem {
	result, ok := registeredDomainMap.Load(domainName)
	if !ok {
		return make([]QueryRuleDefinitionItem, 0)
	}

	return result.([]QueryRuleDefinitionItem)
}