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"
	"git.sxidc.com/service-supports/fserr"
	"time"
)

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

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
}

func (builder *Builder) Post(request *PostRequest, requestCallbackFunc RequestResponseCallback) *Builder {
	return builder.Request(func(c *api.Context, historyRequests []BuilderRequest, resultMap map[string]any) (BuilderRequest, error) {
		if request.Body == nil {
			body, err := c.ReadBody()
			if err != nil {
				return nil, err
			}

			request.Body = body
		}

		return &PostRequest{
			Url:     request.Url,
			Headers: request.Headers,
			Body:    request.Body,
		}, nil
	}, requestCallbackFunc)
}

func (builder *Builder) Delete(request *DeleteRequest, requestCallbackFunc RequestResponseCallback) *Builder {
	return builder.Request(func(c *api.Context, historyRequests []BuilderRequest, resultMap map[string]any) (BuilderRequest, error) {
		if request.PathParams == nil {
			request.PathParams = c.GetAllPathParams()
		}

		if request.QueryParams == nil {
			request.QueryParams = c.GetAllQueryParams()
		}

		return &DeleteRequest{
			Url:         request.Url,
			Headers:     request.Headers,
			PathParams:  request.PathParams,
			QueryParams: request.QueryParams,
		}, nil
	}, requestCallbackFunc)
}

func (builder *Builder) Put(request *PutRequest, requestCallbackFunc RequestResponseCallback) *Builder {
	return builder.Request(func(c *api.Context, historyRequests []BuilderRequest, resultMap map[string]any) (BuilderRequest, error) {
		if request.Body == nil {
			body, err := c.ReadBody()
			if err != nil {
				return nil, err
			}

			request.Body = body
		}

		return &PutRequest{
			Url:     request.Url,
			Headers: request.Headers,
			Body:    request.Body,
		}, nil
	}, requestCallbackFunc)
}

func (builder *Builder) Get(request *GetRequest, requestCallbackFunc RequestResponseCallback) *Builder {
	return builder.Request(func(c *api.Context, historyRequests []BuilderRequest, resultMap map[string]any) (BuilderRequest, error) {
		if request.PathParams == nil {
			request.PathParams = c.GetAllPathParams()
		}

		if request.QueryParams == nil {
			request.QueryParams = c.GetAllQueryParams()
		}

		return &GetRequest{
			Url:         request.Url,
			Headers:     request.Headers,
			PathParams:  request.PathParams,
			QueryParams: request.QueryParams,
		}, nil
	}, requestCallbackFunc)
}

func (builder *Builder) Request(formBuilderRequestFunc FormBuilderRequestFunc, requestCallbackFunc RequestResponseCallback) *Builder {
	return builder.addRequest(newBuilderRequestItem(formBuilderRequestFunc, requestCallbackFunc))
}

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) 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 {
				request, err := requestItem.formBuilderRequestFuc(c, historyRequests, resultMap)
				if err != nil {
					builder.params.responseErrorCallback(c, fserr.New(err.Error()))
					return
				}

				err = request.Request(httpRequest)
				if err != nil {
					builder.params.responseErrorCallback(c, fserr.New(err.Error()))
					return
				}

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

					continue
				}

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

					continue
				}

				historyRequests = append(historyRequests, request)
			}

			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
}