baize/convenient/gwtools/value_object_crud/value_object_crud.go

package value_object_crud

import (
	"git.sxidc.com/go-framework/baize/framework/gateway"
	"git.sxidc.com/go-tools/utils/http_client"
	"git.sxidc.com/go-tools/utils/template"
	"github.com/iancoleman/strcase"
)

func BindSimple(builder *gateway.Builder, params *Simple, opts ...any) {
	globalOptions := new(GlobalOptions)
	createOptions := new(CreateOptions)
	deleteOptions := new(DeleteOptions)
	queryOptions := new(QueryOptions)

	for _, opt := range opts {
		switch o := opt.(type) {
		case GlobalOption:
			o(globalOptions)
		case CreateOption:
			o(createOptions)
		case DeleteOption:
			o(deleteOptions)
		case QueryOption:
			o(queryOptions)
		default:
			continue
		}
	}

	params.globalOptions = globalOptions
	params.createOptions = createOptions
	params.deleteOptions = deleteOptions
	params.queryOptions = queryOptions

	params.bind(builder)
}

type Simple struct {
	// 除去后缀的服务URL，如http://localhost:8080/example/api/v1
	ServiceVersionedUrl string

	// 领域名称
	DomainCamelName string

	// 可选配置项，通过WithXXX配置
	globalOptions *GlobalOptions
	createOptions *CreateOptions
	deleteOptions *DeleteOptions
	queryOptions  *QueryOptions
}

func (simple *Simple) bind(builder *gateway.Builder) {
	globalOptions := simple.globalOptions
	createOptions := simple.createOptions
	deleteOptions := simple.deleteOptions
	queryOptions := simple.queryOptions

	domainPath := "/" + strcase.ToLowerCamel(template.Id(simple.DomainCamelName))

	// 创建
	if !createOptions.disable {
		createMiddlewares := append(globalOptions.middlewares, createOptions.middlewares...)

		builder.PostRouteWithTenantIDAndUserIDCommon(domainPath+"/create", "tenantId", "createUserId",
			func(requestBuilder *gateway.RequestBuilder) {
				requestBuilder.
					Post(
						&gateway.PostRequest{
							Url: simple.ServiceVersionedUrl + domainPath + "/create",
						},
						gateway.WithBeforeRequestCallback(
							func(requestBuilder *gateway.RequestBuilder) error {
								if createOptions.beforeBuilderCallback != nil {
									err := createOptions.beforeBuilderCallback(requestBuilder)
									if err != nil {
										return err
									}
								}

								return nil
							}),
						gateway.WithRequestResponseCallback(
							func(requestBuilder *gateway.RequestBuilder, response *http_client.Response) error {
								if createOptions.afterBuilderCallback != nil {
									err := createOptions.afterBuilderCallback(requestBuilder)
									if err != nil {
										return err
									}
								}

								return nil
							})).
					Request()
			}, createMiddlewares...)
	}

	// 删除
	if !deleteOptions.disable {
		deleteMiddlewares := append(globalOptions.middlewares, deleteOptions.middlewares...)

		builder.PostRoute(domainPath+"/delete",
			func(requestBuilder *gateway.RequestBuilder) {
				requestBuilder.
					Post(
						&gateway.PostRequest{
							Url: simple.ServiceVersionedUrl + domainPath + "/delete",
						},
						gateway.WithBeforeRequestCallback(
							func(requestBuilder *gateway.RequestBuilder) error {
								if deleteOptions.beforeBuilderCallback != nil {
									err := deleteOptions.beforeBuilderCallback(requestBuilder)
									if err != nil {
										return err
									}
								}

								return nil
							}),
						gateway.WithRequestResponseCallback(
							func(requestBuilder *gateway.RequestBuilder, response *http_client.Response) error {
								if deleteOptions.afterBuilderCallback != nil {
									err := deleteOptions.afterBuilderCallback(requestBuilder)
									if err != nil {
										return err
									}
								}

								return nil
							})).
					Request()
			}, deleteMiddlewares...)
	}

	// 查询
	if !queryOptions.disable {
		queryMiddlewares := append(globalOptions.middlewares, queryOptions.middlewares...)

		builder.GetRouteWithTenantID(domainPath+"/query",
			func(requestBuilder *gateway.RequestBuilder) {
				requestBuilder.
					Get(
						&gateway.GetRequest{
							Url: simple.ServiceVersionedUrl + domainPath + "/query",
						},
						gateway.WithBeforeRequestCallback(
							func(requestBuilder *gateway.RequestBuilder) error {
								if queryOptions.beforeBuilderCallback != nil {
									err := queryOptions.beforeBuilderCallback(requestBuilder)
									if err != nil {
										return err
									}
								}

								return nil
							}),
						gateway.WithRequestResponseCallback(
							func(requestBuilder *gateway.RequestBuilder, response *http_client.Response) error {
								if queryOptions.afterBuilderCallback != nil {
									err := queryOptions.afterBuilderCallback(requestBuilder)
									if err != nil {
										return err
									}
								}

								return nil
							})).
					Request()
			}, queryMiddlewares...)
	}
}

type RequestBuilderCallback func(requestBuilder *gateway.RequestBuilder) error

type GlobalOption func(options *GlobalOptions)
type CreateOption func(options *CreateOptions)
type DeleteOption func(options *DeleteOptions)
type QueryOption func(options *QueryOptions)

type GlobalOptions struct {
	middlewares []gateway.Handler
}

type CreateOptions struct {
	// 关闭创建
	disable bool

	// 创建请求前回调
	beforeBuilderCallback RequestBuilderCallback

	// 创建请求后回调
	afterBuilderCallback RequestBuilderCallback

	// 创建中间件
	middlewares []gateway.Handler
}

type DeleteOptions struct {
	// 关闭删除
	disable bool

	// 删除请求前回调
	beforeBuilderCallback RequestBuilderCallback

	// 删除请求后回调
	afterBuilderCallback RequestBuilderCallback

	// 删除中间件
	middlewares []gateway.Handler
}

type QueryOptions struct {
	// 关闭查询
	disable bool

	// 查询请求前回调
	beforeBuilderCallback RequestBuilderCallback

	// 查询请求后回调
	afterBuilderCallback RequestBuilderCallback

	// 查询中间件
	middlewares []gateway.Handler
}

func WithGlobalMiddlewares(middlewares ...gateway.Handler) GlobalOption {
	return func(options *GlobalOptions) {
		options.middlewares = middlewares
	}
}

func WithBeforeCreateBuilderCallback(callbacks RequestBuilderCallback) CreateOption {
	return func(options *CreateOptions) {
		options.beforeBuilderCallback = callbacks
	}
}

func WithAfterCreateBuilderCallback(callbacks RequestBuilderCallback) CreateOption {
	return func(options *CreateOptions) {
		options.afterBuilderCallback = callbacks
	}
}

func WithCreateMiddlewares(middlewares []gateway.Handler) CreateOption {
	return func(options *CreateOptions) {
		options.middlewares = middlewares
	}
}

func WithDisableDelete() DeleteOption {
	return func(options *DeleteOptions) {
		options.disable = true
	}
}

func WithBeforeDeleteBuilderCallback(callbacks RequestBuilderCallback) DeleteOption {
	return func(options *DeleteOptions) {
		options.beforeBuilderCallback = callbacks
	}
}

func WithAfterDeleteBuilderCallback(callbacks RequestBuilderCallback) DeleteOption {
	return func(options *DeleteOptions) {
		options.afterBuilderCallback = callbacks
	}
}

func WithDeleteMiddlewares(middlewares []gateway.Handler) DeleteOption {
	return func(options *DeleteOptions) {
		options.middlewares = middlewares
	}
}

func WithDisableQuery() QueryOption {
	return func(options *QueryOptions) {
		options.disable = true
	}
}

func WithBeforeQueryBuilderCallback(callbacks RequestBuilderCallback) QueryOption {
	return func(options *QueryOptions) {
		options.beforeBuilderCallback = callbacks
	}
}

func WithAfterQueryBuilderCallback(callbacks RequestBuilderCallback) QueryOption {
	return func(options *QueryOptions) {
		options.afterBuilderCallback = callbacks
	}
}

func WithQueryMiddlewares(middlewares []gateway.Handler) QueryOption {
	return func(options *QueryOptions) {
		options.middlewares = middlewares
	}
}