baize/convenient/gwtools/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 CRUD(builder *gateway.Builder, params *CRUDParams, opts ...any) {
	createOptions := new(CRUDCreateOptions)
	deleteOptions := new(CRUDDeleteOptions)
	updateOptions := new(CRUDUpdateOptions)
	queryOptions := new(CRUDQueryOptions)
	getByIDOptions := new(CRUDGetByIDOptions)

	for _, opt := range opts {
		switch o := opt.(type) {
		case CRUDCreateOption:
			o(createOptions)
		case CRUDDeleteOption:
			o(deleteOptions)
		case CRUDUpdateOption:
			o(updateOptions)
		case CRUDQueryOption:
			o(queryOptions)
		case CRUDGetByIDOption:
			o(getByIDOptions)
		default:
			continue
		}
	}

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

	params.crud(builder)
}

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

	// 领域名称
	DomainCamelName string

	// 可选配置项，通过WithXXX配置
	createOptions  *CRUDCreateOptions
	deleteOptions  *CRUDDeleteOptions
	updateOptions  *CRUDUpdateOptions
	queryOptions   *CRUDQueryOptions
	getByIDOptions *CRUDGetByIDOptions
}

func (params *CRUDParams) crud(builder *gateway.Builder) {
	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 {
		builder.
			Url(http.MethodPost, domainPath+"/create").
			Request(func(c *api.Context, historyRequests []gateway.BuilderRequest, resultMap map[string]any) (gateway.BuilderRequest, error) {
				newBody, err := gateway.AddJsonBodyTenantIDAndUserID(c, "tenantId", "createUserId")
				if err != nil {
					return nil, err
				}

				return &gateway.PostRequest{
					Url:  params.ServiceVersionedUrl + domainPath + "/create",
					Body: newBody,
				}, nil
			}, createOptions.requestResponseCallback).
			Build(createOptions.middlewares...)
	}

	// 删除
	if !deleteOptions.disable {
		builder.
			Url(http.MethodDelete, domainPath+"/delete").
			Delete(&gateway.DeleteRequest{
				Url: params.ServiceVersionedUrl + domainPath + "/delete",
			}, deleteOptions.requestResponseCallback).
			Build(deleteOptions.middlewares...)
	}

	// 修改
	if !updateOptions.disable {
		builder.
			Url(http.MethodPut, domainPath+"/update").
			Request(func(c *api.Context, historyRequests []gateway.BuilderRequest, resultMap map[string]any) (gateway.BuilderRequest, error) {
				newBody, err := gateway.AddJsonBodyTenantIDAndUserID(c, "", "updateUserId")
				if err != nil {
					return nil, err
				}

				return &gateway.PutRequest{
					Url:  params.ServiceVersionedUrl + domainPath + "/update",
					Body: newBody,
				}, nil
			}, updateOptions.requestResponseCallback).
			Build(updateOptions.middlewares...)
	}

	// 查询
	if !queryOptions.disable {
		builder.
			Url(http.MethodGet, domainPath+"/query").
			Request(func(c *api.Context, historyRequests []gateway.BuilderRequest, resultMap map[string]any) (gateway.BuilderRequest, error) {
				newQueryParams, err := gateway.AddQueryParamsTenantIDAndUserID(c, "tenantId", "")
				if err != nil {
					return nil, err
				}

				return &gateway.GetRequest{
					Url:         params.ServiceVersionedUrl + domainPath + "/query",
					QueryParams: newQueryParams,
				}, nil
			}, updateOptions.requestResponseCallback).
			Build(queryOptions.middlewares...)
	}

	// 通过ID获取
	if !getByIDOptions.disable {
		builder.
			Url(http.MethodGet, domainPath+"/get").
			Get(&gateway.GetRequest{
				Url: params.ServiceVersionedUrl + domainPath + "/get",
			}, getByIDOptions.requestResponseCallback).
			Build(getByIDOptions.middlewares...)
	}
}

type CRUDCreateOption func(options *CRUDCreateOptions)
type CRUDDeleteOption func(options *CRUDDeleteOptions)
type CRUDUpdateOption func(options *CRUDUpdateOptions)
type CRUDQueryOption func(options *CRUDQueryOptions)
type CRUDGetByIDOption func(options *CRUDGetByIDOptions)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func WithCRUDCreateCallbacks(callbacks gateway.RequestResponseCallback) CRUDCreateOption {
	return func(options *CRUDCreateOptions) {
		options.requestResponseCallback = callbacks
	}
}

func WithCRUDCreateMiddlewares(middlewares []api.Handler) CRUDCreateOption {
	return func(options *CRUDCreateOptions) {
		options.middlewares = middlewares
	}
}

func WithCRUDDisableDelete() CRUDDeleteOption {
	return func(options *CRUDDeleteOptions) {
		options.disable = true
	}
}

func WithCRUDDeleteCallbacks(callbacks gateway.RequestResponseCallback) CRUDDeleteOption {
	return func(options *CRUDDeleteOptions) {
		options.requestResponseCallback = callbacks
	}
}

func WithCRUDDeleteMiddlewares(middlewares []api.Handler) CRUDDeleteOption {
	return func(options *CRUDDeleteOptions) {
		options.middlewares = middlewares
	}
}

func WithCRUDDisableUpdate() CRUDUpdateOption {
	return func(options *CRUDUpdateOptions) {
		options.disable = true
	}
}

func WithCRUDUpdateCallbacks(callbacks gateway.RequestResponseCallback) CRUDUpdateOption {
	return func(options *CRUDUpdateOptions) {
		options.requestResponseCallback = callbacks
	}
}

func WithCRUDUpdateMiddlewares(middlewares []api.Handler) CRUDUpdateOption {
	return func(options *CRUDUpdateOptions) {
		options.middlewares = middlewares
	}
}

func WithCRUDDisableQuery() CRUDQueryOption {
	return func(options *CRUDQueryOptions) {
		options.disable = true
	}
}

func WithCRUDQueryCallbacks(callbacks gateway.RequestResponseCallback) CRUDQueryOption {
	return func(options *CRUDQueryOptions) {
		options.requestResponseCallback = callbacks
	}
}

func WithCRUDQueryMiddlewares(middlewares []api.Handler) CRUDQueryOption {
	return func(options *CRUDQueryOptions) {
		options.middlewares = middlewares
	}
}

func WithCRUDDisableGetByID() CRUDGetByIDOption {
	return func(options *CRUDGetByIDOptions) {
		options.disable = true
	}
}

func WithCRUDGetByIDCallbacks(callbacks gateway.RequestResponseCallback) CRUDGetByIDOption {
	return func(options *CRUDGetByIDOptions) {
		options.requestResponseCallback = callbacks
	}
}

func WithCRUDGetByIDMiddlewares(middlewares []api.Handler) CRUDGetByIDOption {
	return func(options *CRUDGetByIDOptions) {
		options.middlewares = middlewares
	}
}