baize/framework/gateway/builder.go

package gateway

import (
	"git.sxidc.com/go-framework/baize/framework/core/api"
	"git.sxidc.com/go-tools/utils/http_client"
	"github.com/gin-gonic/gin"
	"github.com/pkg/errors"
	"time"
)

type LocalServiceFunc func(c *gin.Context)

type GlobalRequestResponseCallback func(c *api.Context, request BuilderRequest, historyRequests []BuilderRequest, resultMap map[string]any) error
type RequestResponseCallback func(c *api.Context, response *http_client.Response, historyRequests []BuilderRequest, resultMap map[string]any) error

type ResponseSuccessCallback func(c *api.Context, historyRequests []BuilderRequest, resultMap map[string]any)
type ResponseErrorCallback func(c *api.Context, err error)

type Builder struct {
	router         api.Router
	httpClient     *http_client.Client
	httpTimeoutSec int64

	params *builderParams
}

func newBuilder(router api.Router, httpClient *http_client.Client, httpTimeoutSec int64) *Builder {
	return &Builder{
		router:         router,
		httpClient:     httpClient,
		httpTimeoutSec: httpTimeoutSec,
		params:         newBuilderParams(),
	}
}

func (builder *Builder) Url(httpMethod string, relativePath string) *Builder {
	copyBuilder := builder.copy()
	copyBuilder.params.httpMethod = httpMethod
	copyBuilder.params.relativePath = relativePath
	return copyBuilder
}

type RequestOption func(options *RequestOptions)

type RequestOptions struct {
	requestResponseCallback RequestResponseCallback
}

func WithRequestResponseCallback(callback RequestResponseCallback) RequestOption {
	return func(options *RequestOptions) {
		options.requestResponseCallback = callback
	}
}

func (builder *Builder) Post(request *PostRequest, opts ...RequestOption) *Builder {
	return builder.request(request, opts...)
}

func (builder *Builder) Delete(request *DeleteRequest, opts ...RequestOption) *Builder {
	return builder.request(request, opts...)
}

func (builder *Builder) Put(request *PutRequest, opts ...RequestOption) *Builder {
	return builder.request(request, opts...)
}

func (builder *Builder) Get(request *GetRequest, opts ...RequestOption) *Builder {
	return builder.request(request, opts...)
}

func (builder *Builder) request(builderRequest BuilderRequest, opts ...RequestOption) *Builder {
	options := new(RequestOptions)
	for _, opt := range opts {
		opt(options)
	}

	return builder.addRequest(newBuilderRequestItem(builderRequest, options))
}

func (builder *Builder) GlobalRequestCallback(globalRequestResponseCallback GlobalRequestResponseCallback) *Builder {
	copyBuilder := builder.copy()
	copyBuilder.params.globalRequestResponseCallback = globalRequestResponseCallback
	return copyBuilder
}

func (builder *Builder) ResponseSuccessCallback(responseSuccessCallback ResponseSuccessCallback) *Builder {
	copyBuilder := builder.copy()
	copyBuilder.params.responseSuccessCallback = responseSuccessCallback
	return copyBuilder
}

func (builder *Builder) ResponseErrorCallback(responseErrorCallback ResponseErrorCallback) *Builder {
	copyBuilder := builder.copy()
	copyBuilder.params.responseErrorCallback = responseErrorCallback
	return copyBuilder
}

func (builder *Builder) Local(handler api.Handler, middlewares ...api.Handler) {
	copyBuilder := builder.copy()
	copyBuilder.router.AddRoute(builder.params.httpMethod, builder.params.relativePath, append(middlewares, handler)...)
}

func (builder *Builder) Build(middlewares ...api.Handler) {
	copyBuilder := builder.copy()
	copyBuilder.router.AddRoute(builder.params.httpMethod, builder.params.relativePath, append(middlewares,
		func(c *api.Context) {
			httpRequest := builder.httpClient.NewRequest(http_client.WithNewRequestTimeout(time.Duration(builder.httpTimeoutSec) * time.Second))
			historyRequests := make([]BuilderRequest, 0)
			resultMap := make(map[string]any)

			for _, requestItem := range builder.params.requestItems {
				requestWithResponse, err := requestItem.builderRequest.Request(c, httpRequest, historyRequests, resultMap)
				if err != nil {
					builder.params.responseErrorCallback(c, errors.New(err.Error()))
					return
				}

				historyRequests = append(historyRequests, requestWithResponse)

				if requestItem.options.requestResponseCallback != nil {
					err := requestItem.options.requestResponseCallback(c, requestWithResponse.Response(), historyRequests, resultMap)
					if err != nil {
						builder.params.responseErrorCallback(c, errors.New(err.Error()))
						return
					}

					continue
				}

				if builder.params.globalRequestResponseCallback != nil {
					err := builder.params.globalRequestResponseCallback(c, requestWithResponse, historyRequests, resultMap)
					if err != nil {
						builder.params.responseErrorCallback(c, errors.New(err.Error()))
						return
					}

					continue
				}
			}

			builder.params.responseSuccessCallback(c, historyRequests, resultMap)
		})...)
}

func (builder *Builder) addRequest(item *builderRequestItem) *Builder {
	copyBuilder := builder.copy()
	copyBuilder.params.requestItems = append(copyBuilder.params.requestItems, item)
	return copyBuilder
}

func (builder *Builder) copy() *Builder {
	copyBuilder := newBuilder(builder.router, builder.httpClient, builder.httpTimeoutSec)
	copyBuilder.params = builder.params.copy()
	return copyBuilder
}