baize/convenient/entity/simple.go

package entity

import (
	"git.sxidc.com/go-framework/baize/convenient/binding"
	"git.sxidc.com/go-framework/baize/convenient/binding/request"
	"git.sxidc.com/go-framework/baize/convenient/binding/response"
	"git.sxidc.com/go-framework/baize/framwork/api"
	"git.sxidc.com/go-framework/baize/framwork/domain"
	"git.sxidc.com/go-framework/baize/framwork/domain/entity"
)

// Simple 实体CRUD的Bind参数
// I 为查询相关接口返回的Info类型
type Simple[I any] struct {
	// 使用的领域实体，注意是Entity类型
	Entity entity.Entity

	// 数据库Schema
	Schema string

	// 创建使用的请求参数
	CreateJsonBody request.Params

	// 删除使用的请求参数，注意是WithID类型
	DeleteQueryParams request.IDRequestParam

	// 更新使用的请求参数，注意是WithID类型
	UpdateJsonBody request.IDRequestParam

	// 查询使用的请求参数，注意是Query类型
	QueryQueryParams request.QueryRequestParams

	// 根据ID查询使用的请求参数，注意是WithID类型
	GetByIDQueryParams request.IDRequestParam

	// 可选配置项，通过WithXXX配置
	options *Options[I]
}

func (simple *Simple[I]) bind(binder *binding.Binder) {
	options := simple.options

	tableName := domain.TableName(simple.Schema, simple.Entity)
	domainPath := domain.RelativeDomainPath(simple.Entity)

	// 创建
	if !options.disableCreate {
		if !options.createNeedTx {
			binding.PostBind[string](binder, &binding.SimpleBindItem[string]{
				Path:          domainPath + "/create",
				ResponseFunc:  response.SendIDResponse,
				RequestParams: simple.CreateJsonBody,
				Objects:       []domain.Object{simple.Entity},
				ServiceFunc:   Create(tableName, options.createCallbacks),
			}, options.createMiddlewares...)
		} else {
			binding.PostBind(binder, &binding.SimpleBindItem[string]{
				Path:          domainPath + "/create",
				ResponseFunc:  response.SendIDResponse,
				RequestParams: simple.CreateJsonBody,
				Objects:       []domain.Object{simple.Entity},
				ServiceFunc:   CreateTx(tableName, options.createCallbacks),
			}, options.createMiddlewares...)
		}
	}

	// 删除
	if !options.disableDelete {
		if !options.deleteNeedTx {
			binding.DeleteBind(binder, &binding.SimpleBindItem[any]{
				Path:          domainPath + "/delete",
				ResponseFunc:  response.SendMsgResponse,
				RequestParams: simple.DeleteQueryParams,
				Objects:       []domain.Object{simple.Entity},
				ServiceFunc:   Delete(tableName, options.deleteCallbacks),
			}, options.deleteMiddlewares...)
		} else {
			binding.DeleteBind(binder, &binding.SimpleBindItem[any]{
				Path:          domainPath + "/delete",
				ResponseFunc:  response.SendMsgResponse,
				RequestParams: simple.DeleteQueryParams,
				Objects:       []domain.Object{simple.Entity},
				ServiceFunc:   DeleteTx(tableName, options.deleteCallbacks),
			}, options.deleteMiddlewares...)
		}
	}

	// 修改
	if !options.disableUpdate {
		if !options.updateNeedTx {
			binding.PutBind(binder, &binding.SimpleBindItem[any]{
				Path:          domainPath + "/update",
				ResponseFunc:  response.SendMsgResponse,
				RequestParams: simple.UpdateJsonBody,
				Objects:       []domain.Object{simple.Entity},
				ServiceFunc:   Update(tableName, options.updateCallbacks),
			}, options.updateMiddlewares...)
		} else {
			binding.PutBind(binder, &binding.SimpleBindItem[any]{
				Path:          domainPath + "/update",
				ResponseFunc:  response.SendMsgResponse,
				RequestParams: simple.UpdateJsonBody,
				Objects:       []domain.Object{simple.Entity},
				ServiceFunc:   UpdateTx(tableName, options.updateCallbacks),
			}, options.updateMiddlewares...)
		}
	}

	// 查询
	if !options.disableQuery {
		binding.GetBind(binder, &binding.SimpleBindItem[response.InfosData[I]]{
			Path:          domainPath + "/query",
			ResponseFunc:  response.SendInfosResponse[I],
			RequestParams: simple.QueryQueryParams,
			Objects:       []domain.Object{simple.Entity},
			ServiceFunc:   Query[I](tableName, options.queryCallbacks, options.queryConditionFieldCallback),
		}, options.queryMiddlewares...)
	}

	// 通过ID获取
	if !options.disableQueryByID {
		binding.GetBind(binder, &binding.SimpleBindItem[I]{
			Path:          domainPath + "/get",
			ResponseFunc:  response.SendInfoResponse[I],
			RequestParams: simple.GetByIDQueryParams,
			Objects:       []domain.Object{simple.Entity},
			ServiceFunc:   GetByID[I](tableName, options.getByIDCallbacks),
		}, options.getByIDMiddlewares...)
	}
}

func BindSimple[I any](binder *binding.Binder, simple *Simple[I], opts ...Option[I]) {
	options := new(Options[I])

	for _, opt := range opts {
		opt(options)
	}

	simple.options = options

	simple.bind(binder)
}

type Option[I any] func(options *Options[I])

type Options[I any] struct {
	// 关闭创建
	disableCreate bool

	// 创建是否使用事务
	createNeedTx bool

	// 创建回调
	createCallbacks *Callbacks[string]

	// 创建中间件
	createMiddlewares []api.Handler

	// 关闭删除
	disableDelete bool

	// 删除是否使用事务
	deleteNeedTx bool

	// 删除回调
	deleteCallbacks *Callbacks[any]

	// 删除中间件
	deleteMiddlewares []api.Handler

	// 关闭更新
	disableUpdate bool

	// 更新是否使用事务
	updateNeedTx bool

	// 更新回调
	updateCallbacks *Callbacks[any]

	// 更新中间件
	updateMiddlewares []api.Handler

	// 关闭查询
	disableQuery bool

	// 查询条件构造回调
	queryConditionFieldCallback ConditionFieldCallback

	// 查询回调
	queryCallbacks *Callbacks[response.InfosData[I]]

	// 查询中间件
	queryMiddlewares []api.Handler

	// 关闭根据ID查询
	disableQueryByID bool

	// 根据ID查询回调
	getByIDCallbacks *Callbacks[I]

	// 根据ID查询中间件
	getByIDMiddlewares []api.Handler
}

func WithDisableCreate[I any]() Option[I] {
	return func(options *Options[I]) {
		options.disableCreate = true
	}
}

func WithCreateTx[I any]() Option[I] {
	return func(options *Options[I]) {
		options.createNeedTx = true
	}
}

func WithCreateCallbacks[I any](callbacks *Callbacks[string]) Option[I] {
	return func(options *Options[I]) {
		options.createCallbacks = callbacks
	}
}

func WithCreateMiddlewares[I any](middlewares []api.Handler) Option[I] {
	return func(options *Options[I]) {
		options.createMiddlewares = middlewares
	}
}

func WithDisableDelete[I any]() Option[I] {
	return func(options *Options[I]) {
		options.disableDelete = true
	}
}

func WithDeleteTx[I any]() Option[I] {
	return func(options *Options[I]) {
		options.deleteNeedTx = true
	}
}

func WithDeleteCallbacks[I any](callbacks *Callbacks[any]) Option[I] {
	return func(options *Options[I]) {
		options.deleteCallbacks = callbacks
	}
}

func WithDeleteMiddlewares[I any](middlewares []api.Handler) Option[I] {
	return func(options *Options[I]) {
		options.deleteMiddlewares = middlewares
	}
}

func WithDisableUpdate[I any]() Option[I] {
	return func(options *Options[I]) {
		options.disableUpdate = true
	}
}

func WithUpdateTx[I any]() Option[I] {
	return func(options *Options[I]) {
		options.updateNeedTx = true
	}
}

func WithUpdateCallbacks[I any](callbacks *Callbacks[any]) Option[I] {
	return func(options *Options[I]) {
		options.updateCallbacks = callbacks
	}
}

func WithUpdateMiddlewares[I any](middlewares []api.Handler) Option[I] {
	return func(options *Options[I]) {
		options.updateMiddlewares = middlewares
	}
}

func WithDisableQuery[I any]() Option[I] {
	return func(options *Options[I]) {
		options.disableQuery = true
	}
}

func WithQueryConditionFieldCallback[I any](callback ConditionFieldCallback) Option[I] {
	return func(options *Options[I]) {
		options.queryConditionFieldCallback = callback
	}
}

func WithQueryCallbacks[I any](callbacks *Callbacks[response.InfosData[I]]) Option[I] {
	return func(options *Options[I]) {
		options.queryCallbacks = callbacks
	}
}

func WithQueryMiddlewares[I any](middlewares []api.Handler) Option[I] {
	return func(options *Options[I]) {
		options.queryMiddlewares = middlewares
	}
}

func WithDisableQueryByID[I any]() Option[I] {
	return func(options *Options[I]) {
		options.disableQueryByID = true
	}
}

func WithGetByIDCallbacks[I any](callbacks *Callbacks[I]) Option[I] {
	return func(options *Options[I]) {
		options.getByIDCallbacks = callbacks
	}
}

func WithGetByIDMiddlewares[I any](middlewares []api.Handler) Option[I] {
	return func(options *Options[I]) {
		options.getByIDMiddlewares = middlewares
	}
}