baize/framework/gateway/request_builder.go

package gateway

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

type ResponseSuccessCallback func(requestBuilder *RequestBuilder)
type ResponseErrorCallback func(requestBuilder *RequestBuilder, err error)
type BeforeRequestCallback func(requestBuilder *RequestBuilder) error
type RequestResponseCallback func(requestBuilder *RequestBuilder, response *http_client.Response) error

type RequestOption func(options *RequestOptions)

type RequestOptions struct {
	beforeRequestCallback   BeforeRequestCallback
	requestResponseCallback RequestResponseCallback
}

func WithBeforeRequestCallback(callback BeforeRequestCallback) RequestOption {
	return func(options *RequestOptions) {
		options.beforeRequestCallback = callback
	}
}

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

type RequestBuilder struct {
	c               *api.Context
	historyRequests []Request
	resultMap       map[string]any

	httpRequest *http_client.Request
	params      *requestBuilderParams
}

func newRequestBuilder(c *api.Context, httpRequest *http_client.Request) *RequestBuilder {
	return &RequestBuilder{
		c:               c,
		historyRequests: make([]Request, 0),
		resultMap:       make(map[string]any),
		httpRequest:     httpRequest,
		params:          newRequestBuilderParams(),
	}
}

func (builder *RequestBuilder) Context() *api.Context {
	return builder.c
}

func (builder *RequestBuilder) HistoryRequests() []Request {
	return builder.historyRequests
}

func (builder *RequestBuilder) GetResultMapValue(key string) any {
	return builder.resultMap[key]
}

func (builder *RequestBuilder) SetResultMapValue(key string, value any) {
	builder.resultMap[key] = value
}

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

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

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

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

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

	builder.params.requestItems = append(builder.params.requestItems, newBuilderRequestItem(builderRequest, options))
	return builder
}

func (builder *RequestBuilder) ResponseSuccessCallback(responseSuccessCallback ResponseSuccessCallback) *RequestBuilder {
	builder.params.responseSuccessCallback = responseSuccessCallback
	return builder
}

func (builder *RequestBuilder) ResponseErrorCallback(responseErrorCallback ResponseErrorCallback) *RequestBuilder {
	builder.params.responseErrorCallback = responseErrorCallback
	return builder
}

func (builder *RequestBuilder) Request() {
	httpRequest := builder.httpRequest

	for _, requestItem := range builder.params.requestItems {
		if requestItem.options.beforeRequestCallback != nil {
			err := requestItem.options.beforeRequestCallback(builder)
			if err != nil {
				builder.params.responseErrorCallback(builder, errors.New(err.Error()))
				return
			}
		}

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

		builder.historyRequests = append(builder.historyRequests, requestWithResponse)

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

	builder.params.responseSuccessCallback(builder)
}

func (builder *RequestBuilder) ResponseError(err error) {
	builder.params.responseErrorCallback(builder, err)
}