完成一对多关联

convenient/relation/one2many/service.go

@@ -19,7 +19,7 @@ import (
 )
 
 func UpdateLeft(leftTableName string, leftDomainCNName string, leftRelationFieldName string,
-	rightTableName string, rightRelationColumnName string) binding.ServiceFunc[any] {
+	rightTableName string, rightDomainCNName string, rightRelationColumnName string) binding.ServiceFunc[any] {
 	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
 		object := objects[0]
 		if object == nil {
@@ -95,7 +95,7 @@ func UpdateLeft(leftTableName string, leftDomainCNName string, leftRelationField
 			}
 
 			if int(rightCount) != len(rightIDs) {
-				return fserr.New("部分{{ $toCNName }}不存在")
+				return fserr.New("部分" + rightDomainCNName + "不存在")
 			}
 
 			err = database.Update(tx, &sql.UpdateExecuteParams{
@@ -306,8 +306,10 @@ func QueryRight[LI any](rightTableName string, rightRelationFieldName string, le
 	}
 }
 
-func QueryRightWithLeftInfo[RI any, LI any](rightTableName string, leftTableName string) binding.ServiceFunc[map[string]any] {
-	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (map[string]any, error) {
+type ConditionFieldCallback func(conditions *sql.Conditions, fieldName string, columnName string, value any) (hasDeal bool)
+
+func QueryRightWithLeftInfo[RI any, LI any](rightTableName string, rightRelationColumnName string, rightFieldCallback ConditionFieldCallback, leftTableName string) binding.ServiceFunc[response.InfosData[map[string]any]] {
+	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (response.InfosData[map[string]any], error) {
 		errResponse := response.InfosData[map[string]any]{
 			Infos: make([]map[string]any, 0),
 		}
@@ -328,34 +330,34 @@ func QueryRightWithLeftInfo[RI any, LI any](rightTableName string, leftTableName
 			return errResponse, fserr.New("请求参数不是Query接口")
 		}
 
-		fromEntity, ok := object.(entity.Entity)
+		rightEntity, ok := object.(entity.Entity)
 		if !ok {
 			return errResponse, fserr.New("领域对象不是实体")
 		}
 
 		conditions := sql.NewConditions()
 
-		fromFields, err := sql_mapping.DefaultUsage(fromEntity)
+		rightFields, err := sql_mapping.DefaultUsage(rightEntity)
 		if err != nil {
 			return errResponse, err
 		}
 
-		for _, fromField := range fromFields {
+		for _, rightField := range rightFields {
 			hasDeal := false
-			if fromFieldCallback != nil {
-				hasDeal = fromFieldCallback(conditions, fromField.FieldName, fromField.ColumnName, fromField.Value)
+			if rightFieldCallback != nil {
+				hasDeal = rightFieldCallback(conditions, rightField.FieldName, rightField.ColumnName, rightField.Value)
 			}
 
 			if !hasDeal {
-				fieldValue := reflect.ValueOf(fromField.Value)
+				fieldValue := reflect.ValueOf(rightField.Value)
 				if !fieldValue.IsZero() {
-					conditions.Equal(fromField.ColumnName, fromField.Value)
+					conditions.Equal(rightField.ColumnName, rightField.Value)
 				}
 			}
 		}
 
-		fromResults, totalCount, err := database.Query(dbExecutor, &sql.QueryExecuteParams{
-			TableName:  fromTableName,
+		rightResults, totalCount, err := database.Query(dbExecutor, &sql.QueryExecuteParams{
+			TableName:  rightTableName,
 			Conditions: conditions,
 			PageNo:     queryParams.GetPageNo(),
 			PageSize:   queryParams.GetPageSize(),
@@ -364,7 +366,7 @@ func QueryRightWithLeftInfo[RI any, LI any](rightTableName string, leftTableName
 			return errResponse, nil
 		}
 
-		if fromResults == nil || len(fromResults) == 0 {
+		if rightResults == nil || len(rightResults) == 0 {
 			return response.InfosData[map[string]any]{
 				Infos:      make([]map[string]any, 0),
 				TotalCount: 0,
@@ -372,64 +374,64 @@ func QueryRightWithLeftInfo[RI any, LI any](rightTableName string, leftTableName
 			}, nil
 		}
 
-		toIDs := make([]string, 0)
-		for _, fromResult := range fromResults {
-			toID := fromResult.ColumnValueString(fromRelationColumnName)
-			if strutils.IsStringNotEmpty(toID) {
-				toIDs = append(toIDs, toID)
+		leftIDs := make([]string, 0)
+		for _, rightResult := range rightResults {
+			leftID := rightResult.ColumnValueString(rightRelationColumnName)
+			if strutils.IsStringNotEmpty(leftID) {
+				leftIDs = append(leftIDs, leftID)
 			}
 		}
 
-		toResults, _, err := database.Query(dbExecutor, &sql.QueryExecuteParams{
-			TableName:  toTableName,
-			Conditions: sql.NewConditions().In(entity.ColumnID, toIDs),
+		leftResults, _, err := database.Query(dbExecutor, &sql.QueryExecuteParams{
+			TableName:  leftTableName,
+			Conditions: sql.NewConditions().In(entity.ColumnID, leftIDs),
 		})
 		if err != nil {
 			return errResponse, err
 		}
 
-		toResultMap := make(map[string]sql.Result)
-		for _, toResult := range toResults {
-			toID := toResult.ColumnValueString(entity.ColumnID)
-			toResultMap[toID] = toResult
+		leftResultMap := make(map[string]sql.Result)
+		for _, leftResult := range leftResults {
+			leftID := leftResult.ColumnValueString(entity.ColumnID)
+			leftResultMap[leftID] = leftResult
 		}
 
-		infos := make([]map[string]any, len(fromResults))
-		for index, fromResult := range fromResults {
-			fromInfo := reflectutils.Zero[FI]()
-			toInfo := reflectutils.Zero[FI]()
+		infos := make([]map[string]any, len(rightResults))
+		for index, rightResult := range rightResults {
+			rightInfo := reflectutils.Zero[RI]()
+			leftInfo := reflectutils.Zero[LI]()
 
-			err = sql.ParseSqlResult(fromResult, &fromInfo)
+			err = sql.ParseSqlResult(rightResult, &rightInfo)
 			if err != nil {
 				return errResponse, err
 			}
 
-			toID := fromResult.ColumnValueString(fromRelationColumnName)
-			if strutils.IsStringEmpty(toID) {
+			leftID := rightResult.ColumnValueString(rightRelationColumnName)
+			if strutils.IsStringEmpty(leftID) {
 				infos[index] = map[string]any{
-					"self": fromInfo,
-					"with": toInfo,
+					"self": rightInfo,
+					"with": leftInfo,
 				}
 				continue
 			}
 
-			toResult, ok := toResultMap[toID]
+			leftResult, ok := leftResultMap[leftID]
 			if !ok {
 				infos[index] = map[string]any{
-					"self": fromInfo,
-					"with": toInfo,
+					"self": rightInfo,
+					"with": leftInfo,
 				}
 				continue
 			}
 
-			err = sql.ParseSqlResult(toResult, &toInfo)
+			err = sql.ParseSqlResult(leftResult, &leftInfo)
 			if err != nil {
 				return errResponse, err
 			}
 
 			infos[index] = map[string]any{
-				"self": fromInfo,
-				"with": toInfo,
+				"self": rightInfo,
+				"with": leftInfo,
 			}
 		}
 

convenient/relation/one2many/simple.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"git.sxidc.com/go-framework/baize/convenient/binding"
 	"git.sxidc.com/go-framework/baize/convenient/binding/request"
+	"git.sxidc.com/go-framework/baize/convenient/binding/response"
+	"git.sxidc.com/go-framework/baize/framwork/domain"
 	"git.sxidc.com/go-framework/baize/framwork/domain/entity"
 	"github.com/iancoleman/strcase"
 )
@@ -50,9 +52,69 @@ func (simple *Simple[LI, RI]) bind(binder *binding.Binder) {
 	rightRelationFieldName := fmt.Sprintf("%sID", simple.Left.DomainCamelName())
 
 	leftTableName := entity.TableName(simple.Schema, simple.Left)
-	leftRelationColumnName := fmt.Sprintf("%s_id", strcase.ToSnake(simple.Right.DomainCamelName()))
 	rightTableName := entity.TableName(simple.Schema, simple.Right)
 	rightRelationColumnName := fmt.Sprintf("%s_id", strcase.ToSnake(simple.Left.DomainCamelName()))
+
+	if !options.disableLeft {
+		if !options.disableLeftUpdate {
+			// 左到右更新
+			binding.PostBind(binder, &binding.SimpleBindItem[any]{
+				Path:          leftDomainPath + rightDomainPath + "/update",
+				ResponseFunc:  response.SendMsgResponse,
+				RequestParams: simple.LeftUpdateJsonBody,
+				Objects:       []domain.Object{simple.Left},
+				ServiceFunc: UpdateLeft(leftTableName, simple.Left.DomainCNName(), leftRelationFieldName,
+					rightTableName, simple.Right.DomainCNName(), rightRelationColumnName),
+			})
+		}
+
+		if !options.disableLeftQuery {
+			// 左到右查询
+			binding.GetBind(binder, &binding.SimpleBindItem[response.InfosData[RI]]{
+				Path:          leftDomainPath + rightDomainPath + "/query",
+				ResponseFunc:  response.SendInfosResponse[RI],
+				RequestParams: simple.LeftQueryQueryParams,
+				Objects:       []domain.Object{simple.Left},
+				ServiceFunc:   QueryLeft[RI](leftTableName, rightTableName, rightRelationColumnName),
+			})
+		}
+	}
+
+	if !options.disableRight {
+		if !options.disableRightUpdate {
+			// 右到左更新
+			binding.PostBind(binder, &binding.SimpleBindItem[any]{
+				Path:          rightDomainPath + leftDomainPath + "/update",
+				ResponseFunc:  response.SendMsgResponse,
+				RequestParams: simple.RightUpdateJsonBody,
+				Objects:       []domain.Object{simple.Right},
+				ServiceFunc: UpdateRight(rightTableName, rightRelationFieldName, rightRelationColumnName,
+					leftTableName, simple.Left.DomainCNName()),
+			})
+		}
+
+		if !options.disableRightQuery {
+			// 右到左查询
+			binding.GetBind(binder, &binding.SimpleBindItem[LI]{
+				Path:          rightDomainPath + leftDomainPath + "/query",
+				ResponseFunc:  response.SendInfoResponse[LI],
+				RequestParams: simple.RightQueryQueryParams,
+				Objects:       []domain.Object{simple.Right},
+				ServiceFunc:   QueryRight[LI](rightTableName, rightRelationFieldName, leftTableName),
+			})
+		}
+
+		if !options.disableRightWithLeftQuery {
+			// 右到左查询，携带左方信息
+			binding.GetBind(binder, &binding.SimpleBindItem[response.InfosData[map[string]any]]{
+				Path:          rightDomainPath + leftDomainPath + "/queryWith",
+				ResponseFunc:  response.SendInfosResponse[map[string]any],
+				RequestParams: simple.RightQueryWithLeftQueryParams,
+				Objects:       []domain.Object{simple.Right},
+				ServiceFunc:   QueryRightWithLeftInfo[RI, LI](rightTableName, rightRelationColumnName, options.rightQueryWithConditionFieldCallback, leftTableName),
+			})
+		}
+	}
 }
 
 func BindSimple[LI any, RI any](binder *binding.Binder, simple *Simple[LI, RI], opts ...Option) {
@@ -90,6 +152,9 @@ type Options struct {
 
 	// 关闭右实体带左实体信息查询
 	disableRightWithLeftQuery bool
+
+	// 右查询条件构造回调
+	rightQueryWithConditionFieldCallback ConditionFieldCallback
 }
 
 func WithDisableLeft() Option {
@@ -133,3 +198,9 @@ func WithDisableRightWithLeftQuery() Option {
 		options.disableRightWithLeftQuery = true
 	}
 }
+
+func WithRightQueryWithConditionFieldCallback(callbacks ConditionFieldCallback) Option {
+	return func(options *Options) {
+		options.rightQueryWithConditionFieldCallback = callbacks
+	}
+}

convenient/relation/one2one/simple.go

@@ -225,3 +225,15 @@ func WithDisableRightWithLeftQuery() Option {
 		options.disableRightWithLeftQuery = true
 	}
 }
+
+func WithLeftQueryWithConditionFieldCallback(callbacks ConditionFieldCallback) Option {
+	return func(options *Options) {
+		options.leftQueryWithConditionFieldCallback = callbacks
+	}
+}
+
+func WithRightQueryWithConditionFieldCallback(callbacks ConditionFieldCallback) Option {
+	return func(options *Options) {
+		options.rightQueryWithConditionFieldCallback = callbacks
+	}
+}