baize/binding/binding.go

package binding

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

type Binder struct {
	router api.Router
	i      *infrastructure.Infrastructure
}

func NewBinder(router api.Router, i *infrastructure.Infrastructure) *Binder {
	return &Binder{
		router: router,
		i:      i,
	}
}

func PostBind[O any](binder *Binder, item *SimpleBindItem[O], middlewares ...api.Handler) {
	item.bind(binder, http.MethodPost, middlewares...)
}

func DeleteBind[O any](binder *Binder, item *SimpleBindItem[O], middlewares ...api.Handler) {
	item.bind(binder, http.MethodDelete, middlewares...)
}

func PutBind[O any](binder *Binder, item *SimpleBindItem[O], middlewares ...api.Handler) {
	item.bind(binder, http.MethodPut, middlewares...)
}

func GetBind[O any](binder *Binder, item *SimpleBindItem[O], middlewares ...api.Handler) {
	item.bind(binder, http.MethodGet, middlewares...)
}

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

func Static(binder *Binder, item *StaticBindItem) {
	item.bind(binder)
}

func StaticFile(binder *Binder, item *StaticFileBindItem) {
	item.bind(binder)
}

type DTOBindFunc func(c *api.Context, dto request.DTO) error
type FormDomainObjectsFunc func(c *api.Context, dto request.DTO) ([]domain.Object, error)
type ServiceFunc[O any] func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (O, error)
type ResponseFunc[O any] func(c *api.Context, statusCode int, data O, err error)

// SimpleBindItem  路由条目
type SimpleBindItem[O any] struct {
	// URL相对路径
	Path string

	// 使用的dto，非必传，当dto为nil时，说明该接口没有参数
	DTO request.DTO

	// 可选的dto绑定函数
	// 非必传，POST和PUT请求默认为JsonBody，DELETE默认为PathParams，GET默认为QueryParams
	// 额外还提供了一些转化函数：
	// MultipartForm: 绑定multipart form
	// FormBody: 绑定form body
	// XMLBody: 绑定XML body
	DTOBindFunc DTOBindFunc

	// 通过DTO构造使用的领域对象，之后在ServiceFunc中会按照构造实体的顺序进行回调
	// 非必传，如果为nil，则说明没有领域对象
	// 与Objects字段二选一使用，如果都指定，会按照该字段处理
	FormDomainObjectsFunc FormDomainObjectsFunc

	// 使用的领域对象，当使用Tag对实体进行标注后，可以直接通过该字段给定实体，之后在ServiceFunc中会按照给定实体的顺序进行回调
	// 非必传，如果为nil或长度为0，则说明没有领域对象
	// 与FormObjectsFunc字段二选一使用，如果都指定，会按照FormObjectsFunc字段处理
	Objects []domain.Object

	// 基础设施实例，可以通过Application取到
	Infrastructure *infrastructure.Infrastructure

	// 应用服务泛型函数
	ServiceFunc ServiceFunc[O]

	// 响应泛型函数，如果不响应，需要使用NoResponse零值占位
	ResponseFunc ResponseFunc[O]
}

func (item *SimpleBindItem[O]) bind(binder *Binder, method string, middlewares ...api.Handler) {
	bindingItem := &BindItem[O]{
		Method:         method,
		SimpleBindItem: item,
	}

	bindingItem.bind(binder, middlewares...)
}

// 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("需要指定应用服务函数")
	}

	// 给单个路由增加中间件
	handlers := []api.Handler{
		func(c *api.Context) {
			itemDTO := item.DTO

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

			// 进行领域对象转化
			var domainObjects []domain.Object
			if item.FormDomainObjectsFunc != nil {
				innerDomainObjects, err := item.FormDomainObjectsFunc(c, itemDTO)
				if err != nil {
					var outputZero O
					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) {
							var outputZero O
							item.ResponseFunc(c, http.StatusOK, outputZero, fserr.New("领域对象不是结构或结构指针"))
							return
						}

						obj := reflect.New(reflectutils.PointerTypeElem(objectType)).Interface()
						err := request.AssignDTOToDomainObject(itemDTO, obj)
						if err != nil {
							var outputZero O
							item.ResponseFunc(c, http.StatusOK, outputZero, err)
							return
						}

						domainObjects = append(domainObjects, obj)
					}
				}
			}

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

			i := binder.i
			if item.Infrastructure != nil {
				i = item.Infrastructure
			}

			outputModel, err := item.ServiceFunc(c, itemDTO, domainObjects, 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...)
}

// StaticBindItem 静态路由item
type StaticBindItem struct {
	RelativePath string
	Root         string
	WithBasePath bool
}

func (item *StaticBindItem) bind(binder *Binder) {
	if item.WithBasePath {
		binder.router.Static(strings.TrimPrefix(item.RelativePath, binder.router.BasePath()), item.Root)
	} else {
		binder.router.Static(item.RelativePath, item.Root)
	}
}

type StaticFileBindItem struct {
	RelativePath string
	FilePath     string
	WithBasePath bool
}

func (item *StaticFileBindItem) bind(binder *Binder) {
	if item.WithBasePath {
		binder.router.StaticFile(strings.TrimPrefix(item.RelativePath, binder.router.BasePath()), item.FilePath)
	} else {
		binder.router.StaticFile(item.RelativePath, item.FilePath)
	}
}