baize/convenient/binding/bind_item.go

package binding

import (
	"git.sxidc.com/go-framework/baize/convenient/binding/request"
	"git.sxidc.com/go-framework/baize/framwork/api"
	"git.sxidc.com/go-framework/baize/framwork/domain"
	"git.sxidc.com/go-tools/utils/reflectutils"
	"git.sxidc.com/go-tools/utils/strutils"
	"git.sxidc.com/service-supports/fserr"
	"net/http"
	"reflect"
)

func Bind[O any](binder *Binder, item *BindItem[O], middlewares ...api.Handler) {
	item.bind(binder, middlewares...)
}

// BindItem 通用BindItem
type BindItem[O any] struct {
	Method string
	*SimpleBindItem[O]
}

func (item *BindItem[O]) bind(binder *Binder, middlewares ...api.Handler) {
	if strutils.IsStringEmpty(item.Path) {
		panic("需要指定路径")
	}

	if strutils.IsStringEmpty(item.Method) {
		panic("需要指定方法")
	}

	if item.ResponseFunc == nil {
		panic("需要指定响应函数")
	}

	if item.ServiceFunc == nil {
		panic("需要指定应用服务函数")
	}

	var outputZero O
	outputZeroType := reflect.TypeOf(outputZero)
	if outputZeroType != nil && outputZeroType.Kind() == reflect.Pointer {
		panic("bind的输出类型不能使用指针类型")
	}

	// 给单个路由增加中间件
	handlers := []api.Handler{
		func(c *api.Context) {
			var params request.Params

			// 有请求数据
			if item.RequestParams != nil {
				requestParamsType := reflect.TypeOf(item.RequestParams)
				if !reflectutils.IsTypeStructOrStructPointer(requestParamsType) {
					item.ResponseFunc(c, http.StatusOK, outputZero, fserr.New("请求参数不是结构或结构指针"))
					return
				}

				if requestParamsType.Kind() == reflect.Pointer {
					params = reflect.New(requestParamsType.Elem()).Interface().(request.Params)
				} else {
					params = reflect.New(requestParamsType).Interface().(request.Params)
				}

				// 将请求数据解析到请求参数中
				if item.RequestParamsBindFunc != nil {
					err := item.RequestParamsBindFunc(c, params)
					if err != nil {
						item.ResponseFunc(c, http.StatusBadRequest, outputZero, err)
						return
					}
				} else {
					switch item.Method {
					case http.MethodPost:
						fallthrough
					case http.MethodPut:
						err := request.JsonBody(c, params)
						if err != nil {
							item.ResponseFunc(c, http.StatusBadRequest, outputZero, err)
							return
						}
					case http.MethodGet:
						err := request.QueryParams(c, params)
						if err != nil {
							item.ResponseFunc(c, http.StatusBadRequest, outputZero, err)
							return
						}
					case http.MethodDelete:
						err := request.PathParams(c, params)
						if err != nil {
							item.ResponseFunc(c, http.StatusBadRequest, outputZero, err)
							return
						}
					}
				}
			}

			// 进行领域对象转化
			var domainObjects []domain.Object
			if item.FormDomainObjectsFunc != nil {
				innerDomainObjects, err := item.FormDomainObjectsFunc(c, params)
				if err != nil {
					item.ResponseFunc(c, http.StatusOK, outputZero, err)
					return
				}

				domainObjects = innerDomainObjects
			} else {
				if item.Objects != nil && len(item.Objects) != 0 {
					for _, object := range item.Objects {
						if object == nil {
							continue
						}

						objectType := reflect.TypeOf(object)
						if !reflectutils.IsTypeStructOrStructPointer(objectType) {
							item.ResponseFunc(c, http.StatusOK, outputZero, fserr.New("领域对象不是结构或结构指针"))
							return
						}

						obj := reflect.New(reflectutils.PointerTypeElem(objectType)).Interface()

						if params != nil {
							err := request.AssignRequestParamsToDomainObject(params, obj)
							if err != nil {
								item.ResponseFunc(c, http.StatusOK, outputZero, err)
								return
							}
						}

						domainObjects = append(domainObjects, obj)
					}
				}
			}

			// 执行业务函数
			statusCode := http.StatusOK

			outputModel, err := item.ServiceFunc(c, params, domainObjects, binder.i)
			if err != nil {
				statusCode = fserr.ParseCode(err).HttpCode
			}

			item.ResponseFunc(c, statusCode, outputModel, err)
			return
		},
	}

	handlers = append(handlers, middlewares...)

	// 所有的函数加入到执行链中
	binder.router.AddRoute(item.Method, item.Path, handlers...)
}