baize/convenient/domain_gateway/sql_executor/sql_executor.go

package sql_executor

import (
	"git.sxidc.com/go-framework/baize/framework/core/api"
	"git.sxidc.com/go-framework/baize/framework/gateway"
	"git.sxidc.com/go-tools/utils/strutils"
	"github.com/gin-gonic/gin"
	"github.com/pkg/errors"
	"net/http"
	"net/url"
	"sync"
)

type Option func(options *Options)

type Options struct {
	serviceApiVersion                  string
	globalMiddlewares                  []api.Handler
	executeSqlMiddlewares              []api.Handler
	sqlExecuteLogMiddlewares           []api.Handler
	queryRegisteredServicesMiddlewares []api.Handler
}

func WithServiceApiVersion(serviceApiVersion string) Option {
	return func(options *Options) {
		options.serviceApiVersion = serviceApiVersion
	}
}

func WithGlobalMiddlewares(middlewares ...api.Handler) Option {
	return func(options *Options) {
		options.globalMiddlewares = middlewares
	}
}

func WithExecuteSqlMiddlewares(middlewares ...api.Handler) Option {
	return func(options *Options) {
		options.executeSqlMiddlewares = middlewares
	}
}

func WithSqlExecuteLogMiddlewares(middlewares ...api.Handler) Option {
	return func(options *Options) {
		options.sqlExecuteLogMiddlewares = middlewares
	}
}

func WithQueryRegisteredServicesMiddlewares(middlewares ...api.Handler) Option {
	return func(options *Options) {
		options.queryRegisteredServicesMiddlewares = middlewares
	}
}

var serviceBaseUrlMap sync.Map

func RegisterService(serviceShortName string, baseUrl string) {
	serviceBaseUrlMap.Store(serviceShortName, baseUrl)
}

func BuildGateway(gw *gateway.Gateway, opts ...Option) {
	options := new(Options)

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

	executeSqlMiddlewares := append(options.globalMiddlewares, options.executeSqlMiddlewares...)
	sqlExecuteLogMiddlewares := append(options.globalMiddlewares, options.sqlExecuteLogMiddlewares...)
	queryRegisteredServicesMiddlewares := append(options.globalMiddlewares, options.queryRegisteredServicesMiddlewares...)

	builder := gw.NewBuilder(api.RouterPrefix, "")

	builder.
		Url(http.MethodPost, "/sql/execute").
		Post(gateway.NewPostRequest("",
			gateway.PostRequestWithUrlTransferFunc(
				func(c *api.Context, _ string, historyRequests []gateway.BuilderRequest, resultMap map[string]any) (string, error) {
					jsonBody, err := c.GetJsonBody()
					if err != nil {
						return "", err
					}

					serviceShortName, ok := jsonBody.Get("serviceShortName").(string)
					if !ok {
						return "", errors.New("没有传递服务名缩写或服务名缩写不是string类型")
					}

					jsonBody.Delete("serviceShortName")

					serviceBaseUrl, loaded := serviceBaseUrlMap.Load(serviceShortName)
					if !loaded {
						return "", errors.New("没有注册对应的服务: " + serviceShortName)
					}

					var serviceUrl string

					if strutils.IsStringEmpty(options.serviceApiVersion) {
						innerServiceUrl, err := url.JoinPath(serviceBaseUrl.(string), serviceShortName, "/api", "/sql/execute")
						if err != nil {
							return "", err
						}

						serviceUrl = innerServiceUrl
					} else {
						innerServiceUrl, err := url.JoinPath(serviceBaseUrl.(string), serviceShortName, "/api", options.serviceApiVersion, "/sql/execute")
						if err != nil {
							return "", err
						}

						serviceUrl = innerServiceUrl
					}

					return serviceUrl, nil
				}),
			gateway.PostRequestWithBodyForm(
				func(c *api.Context, historyRequests []gateway.BuilderRequest, resultMap map[string]any) (any, error) {
					err := gateway.AddJsonBodyTenantIDAndUserID(c, "", "executorId")
					if err != nil {
						return nil, err
					}

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

					userInfo := c.GetUserInfo()
					if userInfo == nil {
						jsonBody.Set("executorName", "guest")
					} else {
						jsonBody.Set("executorName", userInfo.GetName)
					}

					return jsonBody.Map(), nil
				})), nil).
		Build(executeSqlMiddlewares...)

	builder.
		Url(http.MethodGet, "/sql/execute/log").
		Get(gateway.NewGetRequest("",
			gateway.GetRequestWithUrlTransferFunc(
				func(c *api.Context, _ string, historyRequests []gateway.BuilderRequest, resultMap map[string]any) (string, error) {
					queryParams := c.GetQueryParams()

					serviceShortName := queryParams.Get("serviceShortName")
					if strutils.IsStringEmpty(serviceShortName) {
						return "", errors.New("没有传递服务名缩写")
					}

					queryParams.Delete("serviceShortName")

					serviceBaseUrl, loaded := serviceBaseUrlMap.Load(serviceShortName)
					if !loaded {
						return "", errors.New("没有注册对应的服务: " + serviceShortName)
					}

					var serviceUrl string

					if strutils.IsStringEmpty(options.serviceApiVersion) {
						innerServiceUrl, err := url.JoinPath(serviceBaseUrl.(string), serviceShortName, "/api", "/sql/execute/log")
						if err != nil {
							return "", err
						}

						serviceUrl = innerServiceUrl
					} else {
						innerServiceUrl, err := url.JoinPath(serviceBaseUrl.(string), serviceShortName, "/api", options.serviceApiVersion, "/sql/execute/log")
						if err != nil {
							return "", err
						}

						serviceUrl = innerServiceUrl
					}

					return serviceUrl, nil
				}),
			gateway.GetRequestWithQueryParamsForm(
				gateway.FormQueryParamsWithTenantIDAndUserIDFunc("", "executorId")),
		), nil).
		Build(sqlExecuteLogMiddlewares...)

	// 查询注册的服务
	builder.
		Url(http.MethodGet, "/sql/execute/registered/services").
		Local(func(c *api.Context) {
			serviceShortNames := make([]string, 0)
			serviceBaseUrlMap.Range(func(key any, value any) bool {
				serviceShortNames = append(serviceShortNames, key.(string))
				return true
			})

			c.JSON(http.StatusOK, gin.H{
				"services": serviceShortNames,
			})
		}, queryRegisteredServicesMiddlewares...)
}