完成值对象增删改查

binding/entity_crud/service.go

@@ -10,7 +10,6 @@ import (
 	"git.sxidc.com/go-framework/baize/infrastructure/database"
 	"git.sxidc.com/go-framework/baize/infrastructure/database/sql"
 	"git.sxidc.com/go-framework/baize/tag/sql/sql_mapping"
-	"git.sxidc.com/go-tools/utils/strutils"
 	"git.sxidc.com/service-supports/fserr"
 	"reflect"
 )
@@ -27,6 +26,11 @@ func CreateEntity(tableName string, dbExecutor database.Executor, callbacks *Cal
 			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, "")
 		}
 
+		err = e.CheckID()
+		if err != nil {
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, "")
+		}
+
 		err = callbackBeforeDBOperate(callbacks, e, dbExecutor)
 		if err != nil {
 			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, "")
@@ -57,24 +61,11 @@ func DeleteEntity(tableName string, dbExecutor database.Executor, callbacks *Cal
 			return nil, fserr.New("需要传递领域对象应该为实体")
 		}
 
-		if strutils.IsStringEmpty(e.GetID()) {
-			err := fserr.New("领域实体ID为空")
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
-		}
-
-		exist, err := database.CheckExist(dbExecutor, &sql.CheckExistExecuteParams{
-			TableName:  tableName,
-			Conditions: sql.NewConditions().Equal(e.IDColumnName(), e.GetID()),
-		})
+		err := e.CheckID()
 		if err != nil {
 			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
 		}
 
-		if !exist {
-			err := fserr.New(e.DomainCNName() + "不存在")
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
-		}
-
 		err = callbackBeforeDBOperate(callbacks, e, dbExecutor)
 		if err != nil {
 			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
@@ -101,8 +92,8 @@ func UpdateEntity(tableName string, dbExecutor database.Executor, callbacks *Cal
 			return nil, fserr.New("需要传递领域对象应该为实体")
 		}
 
-		if strutils.IsStringEmpty(e.GetID()) {
-			err := fserr.New("领域实体ID为空")
+		err := e.CheckID()
+		if err != nil {
 			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
 		}
 
@@ -222,12 +213,12 @@ func GetEntityByID[O any](tableName string, dbExecutor database.Executor, callba
 			return outputZero, fserr.New("需要传递领域对象应该为实体")
 		}
 
-		if strutils.IsStringEmpty(e.GetID()) {
-			err := fserr.New("领域实体ID为空")
+		err := e.CheckID()
+		if err != nil {
 			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, outputZero)
 		}
 
-		err := callbackBeforeDBOperate(callbacks, e, dbExecutor)
+		err = callbackBeforeDBOperate(callbacks, e, dbExecutor)
 		if err != nil {
 			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, outputZero)
 		}
@@ -262,7 +253,7 @@ func GetEntityByID[O any](tableName string, dbExecutor database.Executor, callba
 	}
 }
 
-func CommonEntityCreateTx(tableName string, dbExecutor database.Executor, callbacks *Callbacks[string]) binding.ServiceFunc[string] {
+func CreateEntityTx(tableName string, dbExecutor database.Executor, callbacks *Callbacks[string]) binding.ServiceFunc[string] {
 	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (string, error) {
 		e, ok := objects[0].(domain.Entity)
 		if !ok {
@@ -274,6 +265,11 @@ func CommonEntityCreateTx(tableName string, dbExecutor database.Executor, callba
 			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, "")
 		}
 
+		err = e.CheckID()
+		if err != nil {
+			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, "")
+		}
+
 		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
 			err = callbackBeforeDBOperate(callbacks, e, tx)
 			if err != nil {
@@ -304,31 +300,18 @@ func CommonEntityCreateTx(tableName string, dbExecutor database.Executor, callba
 	}
 }
 
-func CommonEntityDeleteTx(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
+func DeleteEntityTx(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
 	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
 		e, ok := objects[0].(domain.Entity)
 		if !ok {
 			return nil, fserr.New("需要传递领域对象应该为实体")
 		}
 
-		if strutils.IsStringEmpty(e.GetID()) {
-			err := fserr.New("领域实体ID为空")
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
-		}
-
-		exist, err := database.CheckExist(dbExecutor, &sql.CheckExistExecuteParams{
-			TableName:  tableName,
-			Conditions: sql.NewConditions().Equal(e.IDColumnName(), e.GetID()),
-		})
+		err := e.CheckID()
 		if err != nil {
 			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
 		}
 
-		if !exist {
-			err := fserr.New(e.DomainCNName() + "不存在")
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
-		}
-
 		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
 			err = callbackBeforeDBOperate(callbacks, e, tx)
 			if err != nil {
@@ -355,15 +338,15 @@ func CommonEntityDeleteTx(tableName string, dbExecutor database.Executor, callba
 	}
 }
 
-func CommonEntityUpdateTx(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
+func UpdateEntityTx(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
 	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
 		e, ok := objects[0].(domain.Entity)
 		if !ok {
 			return nil, fserr.New("需要传递领域对象应该为实体")
 		}
 
-		if strutils.IsStringEmpty(e.GetID()) {
-			err := fserr.New("领域实体ID为空")
+		err := e.CheckID()
+		if err != nil {
 			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
 		}
 

binding/entity_crud/simple.go

@@ -73,7 +73,7 @@ type Simple[O any] struct {
 func (crud *Simple[O]) bind(binder *binding.Binder) {
 	dbExecutor := binder.ChooseDBExecutor(crud.DBExecutorType)
 
-	// 创建班级
+	// 创建
 	if !crud.CreateNeedTx {
 		binding.PostBind(binder, &binding.SimpleBindItem[string]{
 			Path:         crud.DomainPath + "/create",
@@ -88,11 +88,11 @@ func (crud *Simple[O]) bind(binder *binding.Binder) {
 			ResponseFunc: response.SendIDResponse[string],
 			DTO:          crud.CreateDTO,
 			Objects:      []domain.Object{crud.Entity},
-			ServiceFunc:  CommonEntityCreateTx(crud.TableName, dbExecutor, crud.CreateCallbacks),
+			ServiceFunc:  CreateEntityTx(crud.TableName, dbExecutor, crud.CreateCallbacks),
 		})
 	}
 
-	// 删除班级
+	// 删除
 	if !crud.DeleteNeedTx {
 		binding.DeleteBind(binder, &binding.SimpleBindItem[any]{
 			Path:         crud.DomainPath + "/:id/delete",
@@ -107,11 +107,11 @@ func (crud *Simple[O]) bind(binder *binding.Binder) {
 			ResponseFunc: response.SendMsgResponse,
 			DTO:          crud.DeleteDTO,
 			Objects:      []domain.Object{crud.Entity},
-			ServiceFunc:  CommonEntityDeleteTx(crud.TableName, dbExecutor, crud.DeleteCallbacks),
+			ServiceFunc:  DeleteEntityTx(crud.TableName, dbExecutor, crud.DeleteCallbacks),
 		})
 	}
 
-	// 修改班级
+	// 修改
 	if !crud.UpdateNeedTx {
 		binding.PutBind(binder, &binding.SimpleBindItem[any]{
 			Path:         crud.DomainPath + "/update",
@@ -126,11 +126,11 @@ func (crud *Simple[O]) bind(binder *binding.Binder) {
 			ResponseFunc: response.SendMsgResponse,
 			DTO:          crud.UpdateDTO,
 			Objects:      []domain.Object{crud.Entity},
-			ServiceFunc:  CommonEntityUpdateTx(crud.TableName, dbExecutor, crud.UpdateCallbacks),
+			ServiceFunc:  UpdateEntityTx(crud.TableName, dbExecutor, crud.UpdateCallbacks),
 		})
 	}
 
-	// 查询班级
+	// 查询
 	binding.GetBind(binder, &binding.SimpleBindItem[response.InfosData[O]]{
 		Path:         crud.DomainPath + "/query",
 		ResponseFunc: response.SendInfosResponse[O],
@@ -139,7 +139,7 @@ func (crud *Simple[O]) bind(binder *binding.Binder) {
 		ServiceFunc:  QueryEntities[O](crud.TableName, dbExecutor, crud.QueryCallbacks, crud.QueryConditionFieldCallback),
 	})
 
-	// 通过ID获取班级
+	// 通过ID获取
 	binding.GetBind(binder, &binding.SimpleBindItem[O]{
 		Path:         crud.DomainPath + "/get",
 		ResponseFunc: response.SendInfoResponse[O],

binding/value_object/service.go

@@ -1,4 +1,4 @@
-package entity_crud
+package value_object
 
 import (
 	"git.sxidc.com/go-framework/baize/api"
@@ -10,151 +10,88 @@ import (
 	"git.sxidc.com/go-framework/baize/infrastructure/database"
 	"git.sxidc.com/go-framework/baize/infrastructure/database/sql"
 	"git.sxidc.com/go-framework/baize/tag/sql/sql_mapping"
-	"git.sxidc.com/go-tools/utils/strutils"
 	"git.sxidc.com/service-supports/fserr"
 	"reflect"
 )
 
-func CommonEntityCreate(tableName string, dbExecutor database.Executor, callbacks *Callbacks[string]) binding.ServiceFunc[string] {
-	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (string, error) {
-		e, ok := objects[0].(domain.Entity)
+func CreateValueObject(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
+	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
+		valueObject, ok := objects[0].(domain.ValueObject)
 		if !ok {
-			return "", fserr.New("需要传递领域对象应该为实体")
-		}
-
-		err := e.GenerateID()
-		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, "")
+			return nil, fserr.New("需要传递领域对象应该为值对象")
 		}
 
-		err = callbackBeforeDBOperate(callbacks, e, dbExecutor)
+		err := callbackBeforeDBOperate(callbacks, valueObject, dbExecutor)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, "")
+			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, nil)
 		}
 
-		err = database.InsertEntity(dbExecutor, tableName, e)
+		err = database.InsertEntity(dbExecutor, tableName, valueObject)
 		if err != nil {
 			if database.IsErrorDBRecordHasExist(err) {
-				err = fserr.New(e.DomainCNName() + "已存在")
+				err = fserr.New(valueObject.DomainCNName() + "已存在")
 			}
 
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, "")
-		}
-
-		err = callbackAfterDBOperate(callbacks, e, dbExecutor)
-		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, "")
-		}
-
-		return callbackOnSuccessReturn(callbacks, e, dbExecutor, e.GetID())
-	}
-}
-
-func CommonEntityDelete(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
-	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
-		e, ok := objects[0].(domain.Entity)
-		if !ok {
-			return nil, fserr.New("需要传递领域对象应该为实体")
-		}
-
-		if strutils.IsStringEmpty(e.GetID()) {
-			err := fserr.New("领域实体ID为空")
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
-		}
-
-		exist, err := database.CheckExist(dbExecutor, &sql.CheckExistExecuteParams{
-			TableName:  tableName,
-			Conditions: sql.NewConditions().Equal(e.IDColumnName(), e.GetID()),
-		})
-		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
-		}
-
-		if !exist {
-			err := fserr.New(e.DomainCNName() + "不存在")
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
-		}
-
-		err = callbackBeforeDBOperate(callbacks, e, dbExecutor)
-		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
-		}
-
-		err = database.DeleteEntity(dbExecutor, tableName, e)
-		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, nil)
 		}
 
-		err = callbackAfterDBOperate(callbacks, e, dbExecutor)
+		err = callbackAfterDBOperate(callbacks, valueObject, dbExecutor)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, nil)
 		}
 
-		return callbackOnSuccessReturn(callbacks, e, dbExecutor, nil)
+		return callbackOnSuccessReturn(callbacks, valueObject, dbExecutor, nil)
 	}
 }
 
-func CommonEntityUpdate(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
+func DeleteValueObject(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
 	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
-		e, ok := objects[0].(domain.Entity)
+		valueObject, ok := objects[0].(domain.ValueObject)
 		if !ok {
-			return nil, fserr.New("需要传递领域对象应该为实体")
-		}
-
-		if strutils.IsStringEmpty(e.GetID()) {
-			err := fserr.New("领域实体ID为空")
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+			return nil, fserr.New("需要传递领域对象应该为值对象")
 		}
 
-		exist, err := database.CheckExist(dbExecutor, &sql.CheckExistExecuteParams{
-			TableName:  tableName,
-			Conditions: sql.NewConditions().Equal(e.IDColumnName(), e.GetID()),
-		})
+		err := valueObject.CheckKeyFields()
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
-		}
-
-		if !exist {
-			err := fserr.New(e.DomainCNName() + "不存在")
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, nil)
 		}
 
-		err = callbackBeforeDBOperate(callbacks, e, dbExecutor)
+		err = callbackBeforeDBOperate(callbacks, valueObject, dbExecutor)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, nil)
 		}
 
-		err = database.UpdateEntity(dbExecutor, tableName, e)
+		err = database.DeleteEntity(dbExecutor, tableName, valueObject)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, nil)
 		}
 
-		err = callbackAfterDBOperate(callbacks, e, dbExecutor)
+		err = callbackAfterDBOperate(callbacks, valueObject, dbExecutor)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, nil)
 		}
 
-		return callbackOnSuccessReturn(callbacks, e, dbExecutor, nil)
+		return callbackOnSuccessReturn(callbacks, valueObject, dbExecutor, nil)
 	}
 }
 
 type ConditionFieldCallback func(conditions *sql.Conditions, fieldName string, columnName string, value any) (hasDeal bool)
 
-func CommonEntityQuery[O any](tableName string, dbExecutor database.Executor, callbacks *Callbacks[response.InfosData[O]], conditionFieldCallback ConditionFieldCallback) binding.ServiceFunc[response.InfosData[O]] {
+func QueryValueObjects[O any](tableName string, dbExecutor database.Executor, callbacks *Callbacks[response.InfosData[O]], conditionFieldCallback ConditionFieldCallback) binding.ServiceFunc[response.InfosData[O]] {
 	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (response.InfosData[O], error) {
 		queryDTO, ok := dto.(request.Query)
 		if !ok {
 			return response.InfosData[O]{}, fserr.New("DTO不是Query")
 		}
 
-		e, ok := objects[0].(domain.Entity)
+		valueObject, ok := objects[0].(domain.ValueObject)
 		if !ok {
-			return response.InfosData[O]{}, fserr.New("需要传递领域对象应该为实体")
+			return response.InfosData[O]{}, fserr.New("需要传递领域对象应该为值对象")
 		}
 
 		conditions := sql.NewConditions()
 
-		fields, err := sql_mapping.DefaultUsage(e)
+		fields, err := sql_mapping.DefaultUsage(valueObject)
 		if err != nil {
 			return response.InfosData[O]{}, err
 		}
@@ -173,9 +110,9 @@ func CommonEntityQuery[O any](tableName string, dbExecutor database.Executor, ca
 			}
 		}
 
-		err = callbackBeforeDBOperate(callbacks, e, dbExecutor)
+		err = callbackBeforeDBOperate(callbacks, valueObject, dbExecutor)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, response.InfosData[O]{})
+			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, response.InfosData[O]{})
 		}
 
 		results, totalCount, err := database.Query(dbExecutor, &sql.QueryExecuteParams{
@@ -185,18 +122,18 @@ func CommonEntityQuery[O any](tableName string, dbExecutor database.Executor, ca
 			PageSize:   queryDTO.GetPageSize(),
 		})
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, response.InfosData[O]{})
+			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, response.InfosData[O]{})
 		}
 
-		err = callbackAfterDBOperate(callbacks, e, dbExecutor)
+		err = callbackAfterDBOperate(callbacks, valueObject, dbExecutor)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, response.InfosData[O]{})
+			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, response.InfosData[O]{})
 		}
 
 		infos := make([]O, 0)
 		err = sql.ParseSqlResult(results, &infos)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, response.InfosData[O]{})
+			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, response.InfosData[O]{})
 		}
 
 		output := response.InfosData[O]{
@@ -205,91 +142,33 @@ func CommonEntityQuery[O any](tableName string, dbExecutor database.Executor, ca
 			PageNo:     queryDTO.GetPageNo(),
 		}
 
-		return callbackOnSuccessReturn(callbacks, e, dbExecutor, output)
+		return callbackOnSuccessReturn(callbacks, valueObject, dbExecutor, output)
 	}
 }
 
-func CommonEntityQueryByID[O any](tableName string, dbExecutor database.Executor, callbacks *Callbacks[O]) binding.ServiceFunc[O] {
-	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (O, error) {
-		var outputZero O
-		outputZeroValue := reflect.Zero(reflect.TypeOf(outputZero))
-		if outputZeroValue.Kind() == reflect.Pointer {
-			outputZeroValue.Set(reflect.New(outputZeroValue.Type().Elem()))
-		}
-
-		e, ok := objects[0].(domain.Entity)
-		if !ok {
-			return outputZero, fserr.New("需要传递领域对象应该为实体")
-		}
-
-		if strutils.IsStringEmpty(e.GetID()) {
-			err := fserr.New("领域实体ID为空")
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, outputZero)
-		}
-
-		err := callbackBeforeDBOperate(callbacks, e, dbExecutor)
-		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, outputZero)
-		}
-
-		result, err := database.QueryOne(dbExecutor, &sql.QueryOneExecuteParams{
-			TableName:  tableName,
-			Conditions: sql.NewConditions().Equal(e.IDColumnName(), e.GetID()),
-		})
-		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, outputZero)
-		}
-
-		err = callbackAfterDBOperate(callbacks, e, dbExecutor)
-		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, outputZero)
-		}
-
-		var info O
-		var infoPointer any
-
-		infoPointer = &info
-		if outputZeroValue.Kind() == reflect.Pointer {
-			infoPointer = info
-		}
-
-		err = sql.ParseSqlResult(result, infoPointer)
-		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, outputZero)
-		}
-
-		return callbackOnSuccessReturn(callbacks, e, dbExecutor, info)
-	}
-}
-
-func CommonEntityCreateTx(tableName string, dbExecutor database.Executor, callbacks *Callbacks[string]) binding.ServiceFunc[string] {
-	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (string, error) {
-		e, ok := objects[0].(domain.Entity)
+func CreateValueObjectTx(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
+	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
+		valueObject, ok := objects[0].(domain.ValueObject)
 		if !ok {
-			return "", fserr.New("需要传递领域对象应该为实体")
+			return nil, fserr.New("需要传递领域对象应该为值对象")
 		}
 
-		err := e.GenerateID()
-		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, "")
-		}
-
-		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
-			err = callbackBeforeDBOperate(callbacks, e, tx)
+		err := database.Transaction(dbExecutor, func(tx database.Executor) error {
+			err := callbackBeforeDBOperate(callbacks, valueObject, dbExecutor)
 			if err != nil {
 				return err
 			}
 
-			err = database.InsertEntity(tx, tableName, e)
+			err = database.InsertEntity(dbExecutor, tableName, valueObject)
 			if err != nil {
 				if database.IsErrorDBRecordHasExist(err) {
-					err = fserr.New(e.DomainCNName() + "已存在")
+					err = fserr.New(valueObject.DomainCNName() + "已存在")
 				}
 
 				return err
 			}
 
-			err = callbackAfterDBOperate(callbacks, e, tx)
+			err = callbackAfterDBOperate(callbacks, valueObject, dbExecutor)
 			if err != nil {
 				return err
 			}
@@ -297,101 +176,37 @@ func CommonEntityCreateTx(tableName string, dbExecutor database.Executor, callba
 			return nil
 		})
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, "")
+			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, nil)
 		}
 
-		return callbackOnSuccessReturn(callbacks, e, dbExecutor, e.GetID())
+		return callbackOnSuccessReturn(callbacks, valueObject, dbExecutor, nil)
 	}
 }
 
-func CommonEntityDeleteTx(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
+func DeleteValueObjectTx(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
 	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
-		e, ok := objects[0].(domain.Entity)
+		valueObject, ok := objects[0].(domain.ValueObject)
 		if !ok {
-			return nil, fserr.New("需要传递领域对象应该为实体")
+			return nil, fserr.New("需要传递领域对象应该为值对象")
 		}
 
-		if strutils.IsStringEmpty(e.GetID()) {
-			err := fserr.New("领域实体ID为空")
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
-		}
-
-		exist, err := database.CheckExist(dbExecutor, &sql.CheckExistExecuteParams{
-			TableName:  tableName,
-			Conditions: sql.NewConditions().Equal(e.IDColumnName(), e.GetID()),
-		})
+		err := valueObject.CheckKeyFields()
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
-		}
-
-		if !exist {
-			err := fserr.New(e.DomainCNName() + "不存在")
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
-		}
-
-		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
-			err = callbackBeforeDBOperate(callbacks, e, tx)
-			if err != nil {
-				return err
-			}
-
-			err = database.DeleteEntity(tx, tableName, e)
-			if err != nil {
-				return err
-			}
-
-			err = callbackAfterDBOperate(callbacks, e, tx)
-			if err != nil {
-				return err
-			}
-
-			return nil
-		})
-		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
-		}
-
-		return callbackOnSuccessReturn(callbacks, e, dbExecutor, nil)
-	}
-}
-
-func CommonEntityUpdateTx(tableName string, dbExecutor database.Executor, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
-	return func(c *api.Context, dto request.DTO, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
-		e, ok := objects[0].(domain.Entity)
-		if !ok {
-			return nil, fserr.New("需要传递领域对象应该为实体")
-		}
-
-		if strutils.IsStringEmpty(e.GetID()) {
-			err := fserr.New("领域实体ID为空")
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
-		}
-
-		exist, err := database.CheckExist(dbExecutor, &sql.CheckExistExecuteParams{
-			TableName:  tableName,
-			Conditions: sql.NewConditions().Equal(e.IDColumnName(), e.GetID()),
-		})
-		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
-		}
-
-		if !exist {
-			err := fserr.New(e.DomainCNName() + "不存在")
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, nil)
 		}
 
 		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
-			err = callbackBeforeDBOperate(callbacks, e, tx)
+			err = callbackBeforeDBOperate(callbacks, valueObject, dbExecutor)
 			if err != nil {
 				return err
 			}
 
-			err = database.UpdateEntity(tx, tableName, e)
+			err = database.DeleteEntity(dbExecutor, tableName, valueObject)
 			if err != nil {
 				return err
 			}
 
-			err = callbackAfterDBOperate(callbacks, e, tx)
+			err = callbackAfterDBOperate(callbacks, valueObject, dbExecutor)
 			if err != nil {
 				return err
 			}
@@ -399,9 +214,9 @@ func CommonEntityUpdateTx(tableName string, dbExecutor database.Executor, callba
 			return nil
 		})
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, dbExecutor, nil)
+			return callbackOnErrorReturn(callbacks, valueObject, err, dbExecutor, nil)
 		}
 
-		return callbackOnSuccessReturn(callbacks, e, dbExecutor, nil)
+		return callbackOnSuccessReturn(callbacks, valueObject, dbExecutor, nil)
 	}
 }

binding/value_object/service_callbacks.go

@@ -1,4 +1,4 @@
-package entity_crud
+package value_object
 
 import (
 	"git.sxidc.com/go-framework/baize/domain"

binding/value_object/simple.go

@@ -0,0 +1,107 @@
+package value_object
+
+import (
+	"git.sxidc.com/go-framework/baize/binding"
+	"git.sxidc.com/go-framework/baize/binding/request"
+	"git.sxidc.com/go-framework/baize/binding/response"
+	"git.sxidc.com/go-framework/baize/domain"
+)
+
+func BindSimple[O any](binder *binding.Binder, crud *Simple[O]) {
+	crud.bind(binder)
+}
+
+// Simple 实体CRUD的Bind参数
+type Simple[O any] struct {
+	// 使用的领域实体，注意是ValueObject类型
+	ValueObject domain.ValueObject
+
+	// 表名
+	TableName string
+
+	// 选择要使用的数据库Executor
+	// DBExecutorOperations operations 数据库操作
+	// DBExecutorDataService data_service 数据服务
+	DBExecutorType string
+
+	// URL领域相对路径，如/class，后面会自动补充
+	DomainPath string
+
+	// 创建使用的DTO
+	CreateDTO request.DTO
+
+	// 创建是否使用事务
+	CreateNeedTx bool
+
+	// 创建回调
+	CreateCallbacks *Callbacks[any]
+
+	// 删除使用的DTO，注意是WithID类型
+	DeleteDTO request.WithID
+
+	// 删除是否使用事务
+	DeleteNeedTx bool
+
+	// 删除回调
+	DeleteCallbacks *Callbacks[any]
+
+	// 查询使用的DTO，注意是Query类型
+	QueryDTO request.Query
+
+	// 查询条件构造回调
+	QueryConditionFieldCallback ConditionFieldCallback
+
+	// 查询回调
+	QueryCallbacks *Callbacks[response.InfosData[O]]
+}
+
+func (crud *Simple[O]) bind(binder *binding.Binder) {
+	dbExecutor := binder.ChooseDBExecutor(crud.DBExecutorType)
+
+	// 创建
+	if !crud.CreateNeedTx {
+		binding.PostBind(binder, &binding.SimpleBindItem[any]{
+			Path:         crud.DomainPath + "/create",
+			ResponseFunc: response.SendMsgResponse,
+			DTO:          crud.CreateDTO,
+			Objects:      []domain.Object{crud.ValueObject},
+			ServiceFunc:  CreateValueObject(crud.TableName, dbExecutor, crud.CreateCallbacks),
+		})
+	} else {
+		binding.PostBind(binder, &binding.SimpleBindItem[any]{
+			Path:         crud.DomainPath + "/create",
+			ResponseFunc: response.SendMsgResponse,
+			DTO:          crud.CreateDTO,
+			Objects:      []domain.Object{crud.ValueObject},
+			ServiceFunc:  CreateValueObjectTx(crud.TableName, dbExecutor, crud.CreateCallbacks),
+		})
+	}
+
+	// 删除班级
+	if !crud.DeleteNeedTx {
+		binding.DeleteBind(binder, &binding.SimpleBindItem[any]{
+			Path:         crud.DomainPath + "/:id/delete",
+			ResponseFunc: response.SendMsgResponse,
+			DTO:          crud.DeleteDTO,
+			Objects:      []domain.Object{crud.ValueObject},
+			ServiceFunc:  DeleteValueObject(crud.TableName, dbExecutor, crud.DeleteCallbacks),
+		})
+	} else {
+		binding.DeleteBind(binder, &binding.SimpleBindItem[any]{
+			Path:         crud.DomainPath + "/:id/delete",
+			ResponseFunc: response.SendMsgResponse,
+			DTO:          crud.DeleteDTO,
+			Objects:      []domain.Object{crud.ValueObject},
+			ServiceFunc:  DeleteValueObjectTx(crud.TableName, dbExecutor, crud.DeleteCallbacks),
+		})
+	}
+
+	// 查询班级
+	binding.GetBind(binder, &binding.SimpleBindItem[response.InfosData[O]]{
+		Path:         crud.DomainPath + "/query",
+		ResponseFunc: response.SendInfosResponse[O],
+		DTO:          crud.QueryDTO,
+		Objects:      []domain.Object{crud.ValueObject},
+		ServiceFunc:  QueryValueObjects(crud.TableName, dbExecutor, crud.QueryCallbacks, crud.QueryConditionFieldCallback),
+	})
+}

domain/entity.go

@@ -10,7 +10,7 @@ type Entity interface {
 	DomainCNName() string
 	GenerateID() error
 	GetID() string
-	CheckID(errCode int) error
+	CheckID() error
 	IDColumnName() string
 }
 
@@ -31,13 +31,13 @@ func (e *BaseEntity) GetID() string {
 	return e.ID
 }
 
-func (e *BaseEntity) CheckID(errCode int) error {
+func (e *BaseEntity) CheckID() error {
 	if strutils.IsStringEmpty(e.ID) {
-		return fserr.WithCode(nil, errCode, fserr.MsgOption(e.DomainCNName()+"ID为空"))
+		return fserr.New(e.DomainCNName() + "ID为空")
 	}
 
 	if len([]byte(e.ID)) != FieldIDLen {
-		return fserr.WithCode(nil, errCode, fserr.MsgOption(e.DomainCNName()+"ID长度不正确"))
+		return fserr.New(e.DomainCNName() + "ID长度不正确")
 	}
 
 	return nil

domain/value_object.go

@@ -3,6 +3,5 @@ package domain
 type ValueObject interface {
 	Object
 	DomainCNName() string
-	GetKeyColumnAndValues() map[string]any
-	CheckKeyColumnAndValues(errCode int) error
+	CheckKeyFields() error
 }