baize/convenient/relation/remote/simple.go

package remote

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"
)

// Simple 关联的Bind参数
// I 为本地实体的Info类型
type Simple[I any] struct {
	// 左领域实体，注意是Entity类型
	Left entity.Entity

	// 右领域实体，注意是Entity类型
	Right entity.Entity

	// 左领域实体不是本地的
	LeftRemote bool

	// 右领域实体不是本地的
	RightRemote bool

	// 数据库Schema
	Schema string

	// 中间表表名
	MiddleTableName string

	// URL领域相对路径，如/person，后面会自动补充，如/person/右领域path/update
	LeftDomainPath string

	// URL领域相对路径，如/identity，后面会自动补充，如/identity/左领域path/update
	RightDomainPath string

	// 更新左实体关联使用的请求参数
	LeftUpdateJsonBody request.Params

	// 查询左实体关联使用的请求参数，注意是Query类型
	LeftQueryQueryParams request.Query

	// 更新右实体关联使用的请求参数
	RightUpdateJsonBody request.Params

	// 查询右实体关联使用的请求参数，注意是Query类型
	RightQueryQueryParams request.Query

	// 可选配置项，通过WithXXX配置
	options *Options
}

func (simple *Simple[I]) bind(binder *binding.Binder) {
	options := simple.options

	leftDomainPath := entity.RelativeDomainPath(simple.Left)
	rightDomainPath := entity.RelativeDomainPath(simple.Right)

	leftRelationFieldName := fmt.Sprintf("%sIDs", simple.Right.DomainCamelName())
	rightRelationFieldName := fmt.Sprintf("%sIDs", simple.Left.DomainCamelName())

	middleTableName := entity.SnakeDomainName(simple.Left) + "_and_" + entity.SnakeDomainName(simple.Right)
	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 {
			// 左到右更新
			if !simple.LeftRemote {
				binding.PostBind(binder, &binding.SimpleBindItem[any]{
					Path:          leftDomainPath + rightDomainPath + "/update",
					ResponseFunc:  response.SendMsgResponse,
					RequestParams: simple.LeftUpdateJsonBody,
					Objects:       []domain.Object{simple.Left},
					ServiceFunc: UpdateFromExist(middleTableName,
						leftTableName, simple.Left.DomainCNName(), leftRelationFieldName, leftRelationColumnName,
						rightTableName, rightRelationColumnName),
				})
			} else {
				binding.PostBind(binder, &binding.SimpleBindItem[any]{
					Path:          leftDomainPath + rightDomainPath + "/update",
					ResponseFunc:  response.SendMsgResponse,
					RequestParams: simple.LeftUpdateJsonBody,
					Objects:       []domain.Object{simple.Left},
					ServiceFunc: UpdateFromRemote(middleTableName,
						simple.Left.DomainCNName(), leftRelationFieldName, leftRelationColumnName,
						rightTableName, rightRelationColumnName),
				})
			}
		}

		if !options.disableLeftQuery {
			// 左到右查询
			if !simple.LeftRemote {
				binding.GetBind(binder, &binding.SimpleBindItem[response.InfosData[I]]{
					Path:          leftDomainPath + rightDomainPath + "/query",
					ResponseFunc:  response.SendInfosResponse[I],
					RequestParams: simple.LeftQueryQueryParams,
					Objects:       []domain.Object{simple.Left},
					ServiceFunc: QueryFromExist[I](middleTableName,
						leftTableName, leftRelationColumnName,
						rightTableName, rightRelationColumnName),
				})
			} else {
				binding.GetBind(binder, &binding.SimpleBindItem[response.InfosData[string]]{
					Path:          leftDomainPath + rightDomainPath + "/query",
					ResponseFunc:  response.SendInfosResponse[string],
					RequestParams: simple.LeftQueryQueryParams,
					Objects:       []domain.Object{simple.Left},
					ServiceFunc:   QueryFromRemote(middleTableName, leftRelationColumnName, rightRelationColumnName),
				})
			}
		}
	}

	if !options.disableRight {
		if !options.disableRightUpdate {
			// 右到左更新
			if !simple.RightRemote {
				binding.PostBind(binder, &binding.SimpleBindItem[any]{
					Path:          rightDomainPath + leftDomainPath + "/update",
					ResponseFunc:  response.SendMsgResponse,
					RequestParams: simple.RightUpdateJsonBody,
					Objects:       []domain.Object{simple.Right},
					ServiceFunc: UpdateFromExist(middleTableName,
						rightTableName, simple.Right.DomainCNName(), rightRelationFieldName, rightRelationColumnName,
						leftTableName, leftRelationColumnName),
				})
			} else {
				binding.PostBind(binder, &binding.SimpleBindItem[any]{
					Path:          rightDomainPath + leftDomainPath + "/update",
					ResponseFunc:  response.SendMsgResponse,
					RequestParams: simple.RightUpdateJsonBody,
					Objects:       []domain.Object{simple.Right},
					ServiceFunc: UpdateFromRemote(middleTableName,
						simple.Right.DomainCNName(), rightRelationFieldName, rightRelationColumnName,
						leftTableName, leftRelationColumnName),
				})
			}
		}

		if !options.disableRightQuery {
			// 右到左查询
			if !simple.RightRemote {
				binding.GetBind(binder, &binding.SimpleBindItem[response.InfosData[I]]{
					Path:          rightDomainPath + leftDomainPath + "/query",
					ResponseFunc:  response.SendInfosResponse[I],
					RequestParams: simple.RightQueryQueryParams,
					Objects:       []domain.Object{simple.Right},
					ServiceFunc: QueryFromExist[I](middleTableName,
						rightTableName, rightRelationColumnName,
						leftTableName, leftRelationColumnName),
				})
			} else {
				binding.GetBind(binder, &binding.SimpleBindItem[response.InfosData[string]]{
					Path:          rightDomainPath + leftDomainPath + "/query",
					ResponseFunc:  response.SendInfosResponse[string],
					RequestParams: simple.RightQueryQueryParams,
					Objects:       []domain.Object{simple.Right},
					ServiceFunc:   QueryFromRemote(middleTableName, rightRelationColumnName, leftRelationColumnName),
				})
			}
		}
	}
}

func BindSimple[LI any, RI any](binder *binding.Binder, simple *Simple[LI, RI], opts ...Option) {
	options := new(Options)

	for _, opt := range opts {
		opt(options)
	}

	simple.options = options

	simple.bind(binder)
}

type Option func(options *Options)

type Options struct {
	// 关闭左侧到右侧关联
	disableLeft bool

	// 关闭右侧到左侧关联
	disableRight bool

	// 关闭左侧更新
	disableLeftUpdate bool

	// 关闭左侧查询
	disableLeftQuery bool

	// 关闭右侧更新
	disableRightUpdate bool

	// 关闭右侧查询
	disableRightQuery bool
}

func WithDisableLeft() Option {
	return func(options *Options) {
		options.disableLeft = true
	}
}

func WithDisableRight() Option {
	return func(options *Options) {
		options.disableRight = true
	}
}

func WithDisableLeftUpdate() Option {
	return func(options *Options) {
		options.disableLeftUpdate = true
	}
}

func WithDisableLeftQuery() Option {
	return func(options *Options) {
		options.disableLeftQuery = true
	}
}

func WithDisableRightUpdate() Option {
	return func(options *Options) {
		options.disableRightUpdate = true
	}
}

func WithDisableRightQuery() Option {
	return func(options *Options) {
		options.disableRightQuery = true
	}
}