RowKey 使用结构体取代纯map传递

Author: glennliao

.github/workflows/test.yml

@@ -0,0 +1,10 @@
+name: tests
+on:
+  push:
+    branches: [ "main" ,"dev"]
+  pull_request:
+    branches: [ "main", "dev" ]
+
+jobs:
+  simple-test:
+    run: cd test && go test -short

action/action.go

@@ -38,12 +38,13 @@ type Action struct {
 	// jsonFieldStyle 数据库返回的字段
 	JsonFieldStyle config.FieldStyle
 
-	Functions *config.Functions
+	Functions    *config.Functions
+	actionConfig *config.ActionConfig
 }
 
-func New(ctx context.Context, method string, req model.Map, requestCfg *config.RequestConfig) *Action {
+func New(ctx context.Context, actionConfig *config.ActionConfig, method string, req model.Map) *Action {
 
-	request, err := checkTag(req, method, requestCfg)
+	request, err := checkTag(req, method, actionConfig)
 	if err != nil {
 		panic(err)
 	}
@@ -52,12 +53,13 @@ func New(ctx context.Context, method string, req model.Map, requestCfg *config.R
 	delete(req, "version")
 
 	a := &Action{
-		ctx:        ctx,
-		tagRequest: request,
-		method:     method,
-		req:        req,
-		children:   map[string]*Node{},
-		keyNode:    map[string]*Node{},
+		ctx:          ctx,
+		tagRequest:   request,
+		method:       method,
+		req:          req,
+		children:     map[string]*Node{},
+		keyNode:      map[string]*Node{},
+		actionConfig: actionConfig,
 	}
 	return a
 }
@@ -157,7 +159,7 @@ func (a *Action) Result() (model.Map, error) {
 	return ret, err
 }
 
-func checkTag(req model.Map, method string, requestCfg *config.RequestConfig) (*config.Request, error) {
+func checkTag(req model.Map, method string, requestCfg *config.ActionConfig) (*config.Request, error) {
 	_tag, ok := req["tag"]
 	if !ok {
 		return nil, gerror.New("tag 缺失")

action/node.go

@@ -166,24 +166,29 @@ func (n *Node) checkAccess(ctx context.Context, method string, accessRoles []str
 	}
 
 	for i, item := range n.req {
-		where, err := n.action.Access.ConditionFunc(ctx, config.ConditionReq{
+
+		condition := config.NewConditionRet()
+
+		conditionReq := config.ConditionReq{
 			AccessName:          n.TableName,
 			TableAccessRoleList: accessRoles,
 			Method:              method,
 			NodeRole:            n.Role,
 			NodeReq:             item,
-		})
+		}
+
+		err := n.action.Access.ConditionFunc(ctx, conditionReq, condition)
 
 		if err != nil {
 			return err
 		}
 
 		if method == http.MethodPost {
-			for k, v := range where.Where() {
+			for k, v := range condition.Where() {
 				n.Data[i][k] = v
 			}
 		} else {
-			for k, v := range where.Where() {
+			for k, v := range condition.Where() {
 				n.Where[i][k] = v
 			}
 		}
@@ -306,24 +311,24 @@ func (n *Node) do(ctx context.Context, method string, dataIndex int) (ret model.
 			return nil, err
 		}
 
-		//if access.RowKeyGen != "" {
-		//	for i, _ := range n.Data {
-		//
-		//		rowKeyVal, err = config.RowKeyGen(ctx, access.RowKeyGen, n.TableName, n.Data[i])
-		//		if err != nil {
-		//			return nil, err
-		//		}
-		//
-		//		for k, v := range rowKeyVal {
-		//			if k == consts.RowKey {
-		//				n.Data[i][access.RowKey] = v
-		//			} else {
-		//				n.Data[i][k] = v
-		//			}
-		//		}
-		//
-		//	}
-		//}
+		if access.RowKeyGen != "" {
+			for i, _ := range n.Data {
+
+				rowKeyVal, err = n.action.actionConfig.RowKeyGen(ctx, access.RowKeyGen, n.TableName, n.Data[i])
+				if err != nil {
+					return nil, err
+				}
+
+				for k, v := range rowKeyVal {
+					if k == consts.RowKey {
+						n.Data[i][access.RowKey] = v
+					} else {
+						n.Data[i][k] = v
+					}
+				}
+
+			}
+		}
 
 		var id int64
 

apijson.go

@@ -49,7 +49,7 @@ func (a *ApiJson) Use(p ...func(ctx context.Context, a *ApiJson)) *ApiJson {
 }
 
 func (a *ApiJson) Load() {
-	a.config.Load()
+	a.config.ReLoad()
 }
 
 func (a *ApiJson) Config() *config.Config {
@@ -71,7 +71,7 @@ func (a *ApiJson) NewQuery(ctx context.Context, req model.Map) *query.Query {
 }
 
 func (a *ApiJson) NewAction(ctx context.Context, method string, req model.Map) *action.Action {
-	act := action.New(ctx, method, req, a.config.RequestConfig)
+	act := action.New(ctx, a.Config().ActionConfig(), method, req)
 
 	act.NoAccessVerify = a.config.Access.NoVerify
 	act.DbFieldStyle = a.config.DbFieldStyle

config/access.go

@@ -7,13 +7,6 @@ import (
 	"github.com/samber/lo"
 )
 
-// 设置 _access/_request 自定义表名
-// todo
-var (
-	TableAccess  = "_access"
-	TableRequest = "_request"
-)
-
 type ConditionReq struct {
 	AccessName          string // _access 中的alias
 	TableAccessRoleList []string
@@ -23,18 +16,32 @@ type ConditionReq struct {
 }
 
 type ConditionRet struct {
-	condition map[string]any
+	condition    map[string]any
+	rawCondition map[string]any
+}
+
+func NewConditionRet() *ConditionRet {
+	c := ConditionRet{
+		condition:    map[string]any{},
+		rawCondition: map[string]any{},
+	}
+	return &c
 }
 
 func (c *ConditionRet) Add(k string, v any) { // todo any?
 	c.condition[k] = v
 }
 
+func (c *ConditionRet) AddRaw(k string, v any) { // todo any?
+	c.rawCondition[k] = v
+}
+
 func (c *ConditionRet) Where() map[string]any {
+	c.condition[consts.Raw] = c.rawCondition
 	return c.condition
 }
 
-type AccessCondition func(ctx context.Context, req ConditionReq) (*ConditionRet, error)
+type AccessCondition func(ctx context.Context, req ConditionReq, condition *ConditionRet) error
 
 type RoleReq struct {
 	AccessName string
@@ -48,8 +55,8 @@ func defaultRole(ctx context.Context, req RoleReq) (string, error) {
 	return consts.UNKNOWN, nil
 }
 
-func defaultCondition(ctx context.Context, req ConditionReq) (*ConditionRet, error) {
-	return &ConditionRet{}, nil
+func defaultCondition(ctx context.Context, req ConditionReq, condition *ConditionRet) error {
+	return nil
 }
 
 type Access struct {

config/action_config.go

@@ -0,0 +1,124 @@
+package config
+
+import (
+	"context"
+	"github.com/glennliao/apijson-go/model"
+)
+
+type ActionConfig struct {
+	requestConfig    RequestConfig
+	access           *Access
+	functions        *Functions
+	rowKeyGenFuncMap map[string]RowKeyGenFuncHandler
+	defaultRoleFunc  DefaultRole
+}
+
+func (c *ActionConfig) NoVerify() bool {
+	return c.access.NoVerify
+}
+
+func (c *ActionConfig) DefaultRoleFunc() DefaultRole {
+	return c.defaultRoleFunc
+}
+
+func (c *ActionConfig) GetAccessConfig(key string, noVerify bool) (*AccessConfig, error) {
+	return c.access.GetAccess(key, noVerify)
+}
+
+func (c *ActionConfig) CallFunc(ctx context.Context, name string, param model.Map) (any, error) {
+	return c.functions.Call(ctx, name, param)
+}
+
+func (c *ActionConfig) GetRequest(tag string, method string, version string) (*Request, error) {
+	return c.requestConfig.GetRequest(tag, method, version)
+}
+
+func (c *ActionConfig) RowKeyGen(ctx context.Context, genFuncName string, accessName string, data model.Map) (model.Map, error) {
+	if f, exists := c.rowKeyGenFuncMap[genFuncName]; exists {
+		req := &RowKeyGenReq{
+			AccessName: accessName,
+			Data:       data,
+		}
+		ret := NewRowKeyGenRet()
+		err := f(ctx, req, ret)
+		return ret.data, err
+	}
+
+	return nil, nil
+}
+
+//
+//type ExecutorConfig struct {
+//	NoVerify       bool
+//	accessConfig   *AccessConfig
+//	method         string
+//	role           string
+//	DBMeta         *DBMeta
+//	DbFieldStyle   FieldStyle
+//	JsonFieldStyle FieldStyle
+//}
+//
+//func NewExecutorConfig(accessConfig *AccessConfig, method string, noVerify bool) *ExecutorConfig {
+//	return &ExecutorConfig{
+//		accessConfig: accessConfig,
+//		method:       method,
+//		NoVerify:     noVerify,
+//	}
+//}
+//
+//func (c *ExecutorConfig) SetRole(role string) {
+//	c.role = role
+//}
+//
+//func (c *ExecutorConfig) TableName() string {
+//	return c.accessConfig.Name
+//}
+//
+//func (c *ExecutorConfig) TableColumns() []string {
+//	return c.DBMeta.GetTableColumns(c.accessConfig.Name)
+//}
+//
+//func (c *ExecutorConfig) GetFieldsGetOutByRole() []string {
+//	var fieldsMap map[string]string
+//
+//	if val, exists := c.accessConfig.FieldsGet[c.role]; exists {
+//		fieldsMap = val.Out
+//	} else {
+//		fieldsMap = c.accessConfig.FieldsGet["default"].Out
+//	}
+//	return lo.Keys(fieldsMap)
+//}
+//
+//func (c *ExecutorConfig) GetFieldsGetInByRole() map[string][]string {
+//	var inFieldsMap map[string][]string
+//
+//	if val, exists := c.accessConfig.FieldsGet[c.role]; exists {
+//		inFieldsMap = val.In
+//	} else {
+//		inFieldsMap = c.accessConfig.FieldsGet["default"].In
+//	}
+//
+//	return inFieldsMap
+//}
+//
+//func (c *ExecutorConfig) AccessRoles() []string {
+//	switch c.method {
+//	case http.MethodGet:
+//		return c.accessConfig.Get
+//	case http.MethodHead:
+//		return c.accessConfig.Head
+//	case http.MethodPost:
+//		return c.accessConfig.Post
+//	case http.MethodPut:
+//		return c.accessConfig.Put
+//	case http.MethodDelete:
+//		return c.accessConfig.Delete
+//	}
+//	return []string{}
+//
+//}
+//
+//func (c *ExecutorConfig) Executor() string {
+//	return c.accessConfig.Executor
+//
+//}

config/config.go

@@ -50,9 +50,10 @@ type Config struct {
 
 	accessList []AccessConfig // todo to access
 
-	RequestConfig *RequestConfig
+	requestConfig *RequestConfig
 
-	queryConfig *QueryConfig
+	queryConfig  *QueryConfig
+	actionConfig *ActionConfig
 }
 
 func New() *Config {
@@ -76,7 +77,7 @@ func New() *Config {
 	return a
 }
 
-func (c *Config) Load() {
+func (c *Config) ReLoad() {
 
 	c.Access.accessConfigMap = make(map[string]AccessConfig)
 
@@ -98,7 +99,7 @@ func (c *Config) Load() {
 	requestListProvider := requestListProviderMap[c.RequestListProvider]
 	if requestListProvider != nil {
 		requestList := requestListProvider(ctx)
-		c.RequestConfig = NewRequestConfig(requestList)
+		c.requestConfig = NewRequestConfig(requestList)
 	}
 
 	dbMetaProvider := dbMetaProviderMap[c.DbMetaProvider]
@@ -118,3 +119,7 @@ func (c *Config) Load() {
 func (c *Config) QueryConfig() *QueryConfig {
 	return c.queryConfig
 }
+
+func (c *Config) ActionConfig() *ActionConfig {
+	return c.actionConfig
+}

config/functions.go

@@ -8,6 +8,7 @@ import (
 )
 
 type Func struct {
+	// todo 调整成结构体
 	Handler func(ctx context.Context, param model.Map) (res any, err error)
 }