baize/convenient/gwtools/entity_crud.go

package gwtools

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

func EntityCRUD(builder *gateway.Builder, params *EntityCRUDParams, opts ...any) {
	globalOptions := new(EntityCRUDGlobalOptions)
	createOptions := new(EntityCRUDCreateOptions)
	deleteOptions := new(EntityCRUDDeleteOptions)
	updateOptions := new(EntityCRUDUpdateOptions)
	queryOptions := new(EntityCRUDQueryOptions)
	getByIDOptions := new(EntityCRUDGetByIDOptions)

	for _, opt := range opts {
		switch o := opt.(type) {
		case EntityCRUDGlobalOption:
			o(globalOptions)
		case EntityCRUDCreateOption:
			o(createOptions)
		case EntityCRUDDeleteOption:
			o(deleteOptions)
		case EntityCRUDUpdateOption:
			o(updateOptions)
		case EntityCRUDQueryOption:
			o(queryOptions)
		case EntityCRUDGetByIDOption:
			o(getByIDOptions)
		default:
			continue
		}
	}

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

	params.crud(builder)
}

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

	// 领域名称
	DomainCamelName string

	// 可选配置项，通过WithXXX配置
	globalOptions  *EntityCRUDGlobalOptions
	createOptions  *EntityCRUDCreateOptions
	deleteOptions  *EntityCRUDDeleteOptions
	updateOptions  *EntityCRUDUpdateOptions
	queryOptions   *EntityCRUDQueryOptions
	getByIDOptions *EntityCRUDGetByIDOptions
}

func (params *EntityCRUDParams) crud(builder *gateway.Builder) {
	globalOptions := params.globalOptions
	createOptions := params.createOptions
	deleteOptions := params.deleteOptions
	updateOptions := params.updateOptions
	queryOptions := params.queryOptions
	getByIDOptions := params.getByIDOptions

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

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

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

		postRequest := gateway.NewPostRequest(params.ServiceVersionedUrl+domainPath+"/create",
			gateway.PostRequestWithBodyForm(func(c *api.Context, historyRequest []gateway.BuilderRequest, resultMap map[string]any) (any, error) {
				_, err := gateway.FormJsonBodyWithTenantIDAndUserIDFunc("tenantId", "createUserId")(c, historyRequest, resultMap)
				if err != nil {
					return nil, err
				}

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

					copyBuilder = innerBuilder
				}

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

				return jsonBody.Map(), nil
			}))

		copyBuilder = copyBuilder.Post(postRequest, createOptions.requestResponseCallback)

		if createOptions.afterBuilderCallback != nil {
			copyBuilder = createOptions.afterBuilderCallback(copyBuilder)
		}

		copyBuilder.Build(createMiddlewares...)
	}

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

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

		deleteRequest := gateway.NewDeleteRequest(params.ServiceVersionedUrl+domainPath+"/delete",
			gateway.DeleteRequestWithQueryParamsForm(func(c *api.Context, historyRequest []gateway.BuilderRequest, resultMap map[string]any) (map[string]string, error) {
				if deleteOptions.beforeBuilderCallback != nil {
					innerBuilder, err := deleteOptions.beforeBuilderCallback(copyBuilder, c)
					if err != nil {
						return nil, err
					}

					copyBuilder = innerBuilder
				}

				return c.GetQueryParams().Map(), nil
			}))

		copyBuilder = copyBuilder.Delete(deleteRequest, deleteOptions.requestResponseCallback)

		if deleteOptions.afterBuilderCallback != nil {
			copyBuilder = deleteOptions.afterBuilderCallback(copyBuilder)
		}

		copyBuilder.Build(deleteMiddlewares...)
	}

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

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

		putRequest := gateway.NewPutRequest(params.ServiceVersionedUrl+domainPath+"/update",
			gateway.PutRequestWithBodyForm(func(c *api.Context, historyRequest []gateway.BuilderRequest, resultMap map[string]any) (any, error) {
				_, err := gateway.FormJsonBodyWithTenantIDAndUserIDFunc("", "updateUserId")(c, historyRequest, resultMap)
				if err != nil {
					return nil, err
				}

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

					copyBuilder = innerBuilder
				}

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

				return jsonBody.Map(), nil
			}))

		copyBuilder = copyBuilder.Put(putRequest, updateOptions.requestResponseCallback)

		if updateOptions.afterBuilderCallback != nil {
			copyBuilder = updateOptions.afterBuilderCallback(copyBuilder)
		}

		copyBuilder.Build(updateMiddlewares...)
	}

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

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

		getRequest := gateway.NewGetRequest(params.ServiceVersionedUrl+domainPath+"/query",
			gateway.GetRequestWithQueryParamsForm(func(c *api.Context, historyRequest []gateway.BuilderRequest, resultMap map[string]any) (map[string]string, error) {
				_, err := gateway.FormQueryParamsWithTenantIDAndUserIDFunc("tenantId", "")(c, historyRequest, resultMap)
				if err != nil {
					return nil, err
				}

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

					copyBuilder = innerBuilder
				}

				return c.GetQueryParams().Map(), nil
			}))

		copyBuilder = copyBuilder.Get(getRequest, queryOptions.requestResponseCallback)

		if queryOptions.afterBuilderCallback != nil {
			copyBuilder = queryOptions.afterBuilderCallback(copyBuilder)
		}

		copyBuilder.Build(queryMiddlewares...)
	}

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

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

		getRequest := gateway.NewGetRequest(params.ServiceVersionedUrl+domainPath+"/get",
			gateway.GetRequestWithQueryParamsForm(func(c *api.Context, historyRequest []gateway.BuilderRequest, resultMap map[string]any) (map[string]string, error) {
				if getByIDOptions.beforeBuilderCallback != nil {
					innerBuilder, err := getByIDOptions.beforeBuilderCallback(copyBuilder, c)
					if err != nil {
						return nil, err
					}

					copyBuilder = innerBuilder
				}

				return c.GetQueryParams().Map(), nil
			}))

		copyBuilder = copyBuilder.Get(getRequest, getByIDOptions.requestResponseCallback)

		if getByIDOptions.afterBuilderCallback != nil {
			copyBuilder = getByIDOptions.afterBuilderCallback(copyBuilder)
		}

		copyBuilder.Build(getByIDMiddlewares...)
	}
}

type EntityCRUDBeforeCallback func(builder *gateway.Builder, c *api.Context) (*gateway.Builder, error)
type EntityCRUDAfterCallback func(builder *gateway.Builder) *gateway.Builder

type EntityCRUDGlobalOption func(options *EntityCRUDGlobalOptions)
type EntityCRUDCreateOption func(options *EntityCRUDCreateOptions)
type EntityCRUDDeleteOption func(options *EntityCRUDDeleteOptions)
type EntityCRUDUpdateOption func(options *EntityCRUDUpdateOptions)
type EntityCRUDQueryOption func(options *EntityCRUDQueryOptions)
type EntityCRUDGetByIDOption func(options *EntityCRUDGetByIDOptions)

type EntityCRUDGlobalOptions struct {
	middlewares []api.Handler
}

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

	// 创建请求前回调
	beforeBuilderCallback EntityCRUDBeforeCallback

	// 创建请求响应回调
	requestResponseCallback gateway.RequestResponseCallback

	// 创建请求后回调
	afterBuilderCallback EntityCRUDAfterCallback

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

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

	// 删除请求前回调
	beforeBuilderCallback EntityCRUDBeforeCallback

	// 删除请求响应回调
	requestResponseCallback gateway.RequestResponseCallback

	// 删除请求后回调
	afterBuilderCallback EntityCRUDAfterCallback

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

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

	// 更新请求前回调
	beforeBuilderCallback EntityCRUDBeforeCallback

	// 更新请求响应回调
	requestResponseCallback gateway.RequestResponseCallback

	// 更新请求后回调
	afterBuilderCallback EntityCRUDAfterCallback

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

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

	// 查询请求前回调
	beforeBuilderCallback EntityCRUDBeforeCallback

	// 查询请求响应回调
	requestResponseCallback gateway.RequestResponseCallback

	// 查询请求后回调
	afterBuilderCallback EntityCRUDAfterCallback

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

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

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

	// 根据ID请求响应回调
	requestResponseCallback gateway.RequestResponseCallback

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

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

func WithEntityCRUDGlobalMiddlewares(middlewares ...api.Handler) EntityCRUDGlobalOption {
	return func(options *EntityCRUDGlobalOptions) {
		options.middlewares = middlewares
	}
}

func WithEntityCRUDBeforeCreateBuilderCallback(callbacks EntityCRUDBeforeCallback) EntityCRUDCreateOption {
	return func(options *EntityCRUDCreateOptions) {
		options.beforeBuilderCallback = callbacks
	}
}

func WithEntityCRUDCreateCallbacks(callbacks gateway.RequestResponseCallback) EntityCRUDCreateOption {
	return func(options *EntityCRUDCreateOptions) {
		options.requestResponseCallback = callbacks
	}
}

func WithEntityCRUDAfterCreateBuilderCallback(callbacks EntityCRUDAfterCallback) EntityCRUDCreateOption {
	return func(options *EntityCRUDCreateOptions) {
		options.afterBuilderCallback = callbacks
	}
}

func WithEntityCRUDCreateMiddlewares(middlewares []api.Handler) EntityCRUDCreateOption {
	return func(options *EntityCRUDCreateOptions) {
		options.middlewares = middlewares
	}
}

func WithEntityCRUDDisableDelete() EntityCRUDDeleteOption {
	return func(options *EntityCRUDDeleteOptions) {
		options.disable = true
	}
}

func WithEntityCRUDBeforeDeleteBuilderCallback(callbacks EntityCRUDBeforeCallback) EntityCRUDDeleteOption {
	return func(options *EntityCRUDDeleteOptions) {
		options.beforeBuilderCallback = callbacks
	}
}

func WithEntityCRUDDeleteCallbacks(callbacks gateway.RequestResponseCallback) EntityCRUDDeleteOption {
	return func(options *EntityCRUDDeleteOptions) {
		options.requestResponseCallback = callbacks
	}
}

func WithEntityCRUDAfterDeleteBuilderCallback(callbacks EntityCRUDAfterCallback) EntityCRUDDeleteOption {
	return func(options *EntityCRUDDeleteOptions) {
		options.afterBuilderCallback = callbacks
	}
}

func WithEntityCRUDDeleteMiddlewares(middlewares []api.Handler) EntityCRUDDeleteOption {
	return func(options *EntityCRUDDeleteOptions) {
		options.middlewares = middlewares
	}
}

func WithEntityCRUDDisableUpdate() EntityCRUDUpdateOption {
	return func(options *EntityCRUDUpdateOptions) {
		options.disable = true
	}
}

func WithEntityCRUDBeforeUpdateBuilderCallback(callbacks EntityCRUDBeforeCallback) EntityCRUDUpdateOption {
	return func(options *EntityCRUDUpdateOptions) {
		options.beforeBuilderCallback = callbacks
	}
}

func WithEntityCRUDUpdateCallbacks(callbacks gateway.RequestResponseCallback) EntityCRUDUpdateOption {
	return func(options *EntityCRUDUpdateOptions) {
		options.requestResponseCallback = callbacks
	}
}

func WithEntityCRUDAfterUpdateBuilderCallback(callbacks EntityCRUDAfterCallback) EntityCRUDUpdateOption {
	return func(options *EntityCRUDUpdateOptions) {
		options.afterBuilderCallback = callbacks
	}
}

func WithEntityCRUDUpdateMiddlewares(middlewares []api.Handler) EntityCRUDUpdateOption {
	return func(options *EntityCRUDUpdateOptions) {
		options.middlewares = middlewares
	}
}

func WithEntityCRUDDisableQuery() EntityCRUDQueryOption {
	return func(options *EntityCRUDQueryOptions) {
		options.disable = true
	}
}

func WithEntityCRUDBeforeQueryBuilderCallback(callbacks EntityCRUDBeforeCallback) EntityCRUDQueryOption {
	return func(options *EntityCRUDQueryOptions) {
		options.beforeBuilderCallback = callbacks
	}
}

func WithEntityCRUDQueryCallbacks(callbacks gateway.RequestResponseCallback) EntityCRUDQueryOption {
	return func(options *EntityCRUDQueryOptions) {
		options.requestResponseCallback = callbacks
	}
}

func WithEntityCRUDAfterQueryBuilderCallback(callbacks EntityCRUDAfterCallback) EntityCRUDQueryOption {
	return func(options *EntityCRUDQueryOptions) {
		options.afterBuilderCallback = callbacks
	}
}

func WithEntityCRUDQueryMiddlewares(middlewares []api.Handler) EntityCRUDQueryOption {
	return func(options *EntityCRUDQueryOptions) {
		options.middlewares = middlewares
	}
}

func WithEntityCRUDDisableGetByID() EntityCRUDGetByIDOption {
	return func(options *EntityCRUDGetByIDOptions) {
		options.disable = true
	}
}

func WithEntityCRUDBeforeGetByIDBuilderCallback(callbacks EntityCRUDBeforeCallback) EntityCRUDGetByIDOption {
	return func(options *EntityCRUDGetByIDOptions) {
		options.beforeBuilderCallback = callbacks
	}
}

func WithEntityCRUDGetByIDCallbacks(callbacks gateway.RequestResponseCallback) EntityCRUDGetByIDOption {
	return func(options *EntityCRUDGetByIDOptions) {
		options.requestResponseCallback = callbacks
	}
}

func WithEntityCRUDAfterGetByIDBuilderCallback(callbacks EntityCRUDAfterCallback) EntityCRUDGetByIDOption {
	return func(options *EntityCRUDGetByIDOptions) {
		options.afterBuilderCallback = callbacks
	}
}

func WithEntityCRUDGetByIDMiddlewares(middlewares []api.Handler) EntityCRUDGetByIDOption {
	return func(options *EntityCRUDGetByIDOptions) {
		options.middlewares = middlewares
	}
}