baize/convenient/gwtools/entity_crud/entity_crud.go

package entity_crud

import (
	"git.sxidc.com/go-framework/baize/framework/core/api"
	"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"
	"net/http"
)

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

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

	params.globalOptions = globalOptions
	params.createOptions = createOptions
	params.deleteOptions = deleteOptions
	params.updateOptions = updateOptions
	params.queryOptions = queryOptions
	params.getByIDOptions = getByIDOptions

	params.bind(builder)
}

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

	// 领域名称
	DomainCamelName string

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

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

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

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

		copyBuilder := builder.Url(http.MethodPost, domainPath+"/create")

		copyBuilder.
			Post(&gateway.PostRequest{
				Url: simple.ServiceVersionedUrl + domainPath + "/create",
				BodyFormFunc: func(c *api.Context, body any, historyRequests []gateway.BuilderRequest, resultMap map[string]any) (any, error) {
					_, err := gateway.FormJsonBodyWithTenantIDAndUserIDFunc("tenantId", "createUserId")(c, body, historyRequests, resultMap)
					if err != nil {
						return nil, err
					}

					if createOptions.beforeBuilderCallback != nil {
						innerBuilder, err := createOptions.beforeBuilderCallback(copyBuilder, c, historyRequests, resultMap)
						if err != nil {
							return nil, err
						}

						copyBuilder = innerBuilder
					}

					jsonBody, err := c.GetJsonBody()
					if err != nil {
						return nil, err
					}

					return jsonBody.Map(), nil
				},
				HeadersFormFunc: nil,
			}, gateway.WithRequestResponseCallback(
				func(c *api.Context, response *http_client.Response, historyRequests []gateway.BuilderRequest, resultMap map[string]any) error {
					if createOptions.afterBuilderCallback != nil {
						innerBuilder, err := createOptions.afterBuilderCallback(copyBuilder, c, historyRequests, resultMap)
						if err != nil {
							return err
						}

						copyBuilder = innerBuilder
					}

					return nil
				})).
			Build(createMiddlewares...)
	}

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

		copyBuilder := builder.Url(http.MethodDelete, domainPath+"/delete")

		copyBuilder.
			Delete(&gateway.DeleteRequest{
				Url: simple.ServiceVersionedUrl + domainPath + "/delete",
				QueryParamsFormFunc: func(c *api.Context, _ map[string]string, historyRequests []gateway.BuilderRequest, resultMap map[string]any) (map[string]string, error) {
					if deleteOptions.beforeBuilderCallback != nil {
						innerBuilder, err := deleteOptions.beforeBuilderCallback(copyBuilder, c, historyRequests, resultMap)
						if err != nil {
							return nil, err
						}

						copyBuilder = innerBuilder
					}

					return c.GetQueryParams().Map(), nil
				},
			}, gateway.WithRequestResponseCallback(
				func(c *api.Context, response *http_client.Response, historyRequests []gateway.BuilderRequest, resultMap map[string]any) error {
					if deleteOptions.afterBuilderCallback != nil {
						innerBuilder, err := deleteOptions.afterBuilderCallback(copyBuilder, c, historyRequests, resultMap)
						if err != nil {
							return err
						}

						copyBuilder = innerBuilder
					}

					return nil
				})).
			Build(deleteMiddlewares...)
	}

	// 修改
	if !updateOptions.disable {
		updateMiddlewares := append(globalOptions.middlewares, updateOptions.middlewares...)

		copyBuilder := builder.Url(http.MethodPut, domainPath+"/update")

		copyBuilder.
			Put(&gateway.PutRequest{
				Url: simple.ServiceVersionedUrl + domainPath + "/update",
				BodyFormFunc: func(c *api.Context, body any, historyRequests []gateway.BuilderRequest, resultMap map[string]any) (any, error) {
					_, err := gateway.FormJsonBodyWithTenantIDAndUserIDFunc("", "updateUserId")(c, body, historyRequests, resultMap)
					if err != nil {
						return nil, err
					}

					if updateOptions.beforeBuilderCallback != nil {
						innerBuilder, err := updateOptions.beforeBuilderCallback(copyBuilder, c, historyRequests, resultMap)
						if err != nil {
							return nil, err
						}

						copyBuilder = innerBuilder
					}

					jsonBody, err := c.GetJsonBody()
					if err != nil {
						return nil, err
					}

					return jsonBody.Map(), nil
				},
			}, gateway.WithRequestResponseCallback(
				func(c *api.Context, response *http_client.Response, historyRequests []gateway.BuilderRequest, resultMap map[string]any) error {
					if updateOptions.afterBuilderCallback != nil {
						innerBuilder, err := updateOptions.afterBuilderCallback(copyBuilder, c, historyRequests, resultMap)
						if err != nil {
							return err
						}

						copyBuilder = innerBuilder
					}

					return nil
				})).
			Build(updateMiddlewares...)
	}

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

		copyBuilder := builder.Url(http.MethodGet, domainPath+"/query")

		copyBuilder.
			Get(&gateway.GetRequest{
				Url: simple.ServiceVersionedUrl + domainPath + "/query",
				QueryParamsFormFunc: func(c *api.Context, queryParams map[string]string, historyRequests []gateway.BuilderRequest, resultMap map[string]any) (map[string]string, error) {
					_, err := gateway.FormQueryParamsWithTenantIDAndUserIDFunc("tenantId", "")(c, queryParams, historyRequests, resultMap)
					if err != nil {
						return nil, err
					}

					if queryOptions.beforeBuilderCallback != nil {
						innerBuilder, err := queryOptions.beforeBuilderCallback(copyBuilder, c, historyRequests, resultMap)
						if err != nil {
							return nil, err
						}

						copyBuilder = innerBuilder
					}

					return c.GetQueryParams().Map(), nil
				},
				PathParamsFormFunc: nil,
			}, gateway.WithRequestResponseCallback(
				func(c *api.Context, response *http_client.Response, historyRequests []gateway.BuilderRequest, resultMap map[string]any) error {
					if queryOptions.afterBuilderCallback != nil {
						innerBuilder, err := queryOptions.afterBuilderCallback(copyBuilder, c, historyRequests, resultMap)
						if err != nil {
							return err
						}

						copyBuilder = innerBuilder
					}

					return nil
				})).
			Build(queryMiddlewares...)
	}

	// 通过ID获取
	if !getByIDOptions.disable {
		getByIDMiddlewares := append(globalOptions.middlewares, getByIDOptions.middlewares...)

		copyBuilder := builder.Url(http.MethodGet, domainPath+"/get")

		copyBuilder.
			Get(&gateway.GetRequest{
				Url:             simple.ServiceVersionedUrl + domainPath + "/get",
				QueryParams:     nil,
				PathParams:      nil,
				UrlFormFunc:     nil,
				HeadersFormFunc: nil,
				QueryParamsFormFunc: func(c *api.Context, _ map[string]string, historyRequests []gateway.BuilderRequest, resultMap map[string]any) (map[string]string, error) {
					if getByIDOptions.beforeBuilderCallback != nil {
						innerBuilder, err := getByIDOptions.beforeBuilderCallback(copyBuilder, c, historyRequests, resultMap)
						if err != nil {
							return nil, err
						}

						copyBuilder = innerBuilder
					}

					return c.GetQueryParams().Map(), nil
				},
				PathParamsFormFunc: nil,
			}, gateway.WithRequestResponseCallback(
				func(c *api.Context, response *http_client.Response, historyRequests []gateway.BuilderRequest, resultMap map[string]any) error {
					if getByIDOptions.afterBuilderCallback != nil {
						innerBuilder, err := getByIDOptions.afterBuilderCallback(copyBuilder, c, historyRequests, resultMap)
						if err != nil {
							return err
						}

						copyBuilder = innerBuilder
					}

					return nil
				})).
			Build(getByIDMiddlewares...)
	}
}

type BuilderCallback func(builder *gateway.Builder, c *api.Context, historyRequests []gateway.BuilderRequest, resultMap map[string]any) (*gateway.Builder, error)

type GlobalOption func(options *GlobalOptions)
type CreateOption func(options *CreateOptions)
type DeleteOption func(options *DeleteOptions)
type UpdateOption func(options *UpdateOptions)
type QueryOption func(options *QueryOptions)
type GetByIDOption func(options *GetByIDOptions)

type GlobalOptions struct {
	middlewares []api.Handler
}

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

	// 创建请求前回调
	beforeBuilderCallback BuilderCallback

	// 创建请求后回调
	afterBuilderCallback BuilderCallback

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

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

	// 删除请求前回调
	beforeBuilderCallback BuilderCallback

	// 删除请求后回调
	afterBuilderCallback BuilderCallback

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

type UpdateOptions struct {
	// 关闭更新
	disable bool

	// 更新请求前回调
	beforeBuilderCallback BuilderCallback

	// 更新请求后回调
	afterBuilderCallback BuilderCallback

	// 更新中间件
	middlewares []api.Handler
}

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

	// 查询请求前回调
	beforeBuilderCallback BuilderCallback

	// 查询请求后回调
	afterBuilderCallback BuilderCallback

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

type GetByIDOptions struct {
	// 关闭根据ID查询
	disable bool

	// 根据ID请求前回调
	beforeBuilderCallback BuilderCallback

	// 根据ID请求后回调
	afterBuilderCallback BuilderCallback

	// 根据ID查询中间件
	middlewares []api.Handler
}

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

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

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

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

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

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

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

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

func WithDisableUpdate() UpdateOption {
	return func(options *UpdateOptions) {
		options.disable = true
	}
}

func WithBeforeUpdateBuilderCallback(callbacks BuilderCallback) UpdateOption {
	return func(options *UpdateOptions) {
		options.beforeBuilderCallback = callbacks
	}
}

func WithAfterUpdateBuilderCallback(callbacks BuilderCallback) UpdateOption {
	return func(options *UpdateOptions) {
		options.afterBuilderCallback = callbacks
	}
}

func WithUpdateMiddlewares(middlewares []api.Handler) UpdateOption {
	return func(options *UpdateOptions) {
		options.middlewares = middlewares
	}
}

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

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

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

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

func WithDisableGetByID() GetByIDOption {
	return func(options *GetByIDOptions) {
		options.disable = true
	}
}

func WithBeforeGetByIDBuilderCallback(callbacks BuilderCallback) GetByIDOption {
	return func(options *GetByIDOptions) {
		options.beforeBuilderCallback = callbacks
	}
}

func WithAfterGetByIDBuilderCallback(callbacks BuilderCallback) GetByIDOption {
	return func(options *GetByIDOptions) {
		options.afterBuilderCallback = callbacks
	}
}

func WithGetByIDMiddlewares(middlewares []api.Handler) GetByIDOption {
	return func(options *GetByIDOptions) {
		options.middlewares = middlewares
	}
}