实体CRUD和值对象CRUD的回调增加参数，回调传回请求结构

convenient/entity_crud/service.go

@@ -32,30 +32,30 @@ func Create(tableName string, needCreateUserID bool, callbacks *CreateCallbacks)
 
 		err := e.GenerateID()
 		if err != nil {
-			return callbackOnCreateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
+			return callbackOnCreateErrorReturn(callbacks, c, params, e, make(map[string]any), err, i)
 		}
 
 		if needCreateUserID {
 			userInfo := c.GetUserInfo()
 			err := domain.SetField(e, entity.FieldCreateUserID, userInfo.GetID())
 			if err != nil {
-				return callbackOnCreateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
+				return callbackOnCreateErrorReturn(callbacks, c, params, e, make(map[string]any), err, i)
 			}
 		}
 
-		prepared, err := callbackPrepareCreate(callbacks, c, e, i)
+		prepared, err := callbackPrepareCreate(callbacks, c, params, e, i)
 		if err != nil {
-			return callbackOnCreateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
+			return callbackOnCreateErrorReturn(callbacks, c, params, e, make(map[string]any), err, i)
 		}
 
 		err = domain.CheckFieldsForCreate(e, e.GetFieldMap())
 		if err != nil {
-			return callbackOnCreateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
+			return callbackOnCreateErrorReturn(callbacks, c, params, e, make(map[string]any), err, i)
 		}
 
-		err = callbackBeforeCreate(callbacks, c, e, prepared, i, nil)
+		err = callbackBeforeCreate(callbacks, c, params, e, prepared, i, nil)
 		if err != nil {
-			return callbackOnCreateErrorReturn(callbacks, c, e, prepared, err, i)
+			return callbackOnCreateErrorReturn(callbacks, c, params, e, prepared, err, i)
 		}
 
 		err = database.InsertEntity(dbExecutor, tableName, e)
@@ -64,15 +64,15 @@ func Create(tableName string, needCreateUserID bool, callbacks *CreateCallbacks)
 				err = errors.New(e.DomainCNName() + "已存在")
 			}
 
-			return callbackOnCreateErrorReturn(callbacks, c, e, prepared, err, i)
+			return callbackOnCreateErrorReturn(callbacks, c, params, e, prepared, err, i)
 		}
 
-		err = callbackAfterCreate(callbacks, c, e, prepared, i, nil)
+		err = callbackAfterCreate(callbacks, c, params, e, prepared, i, nil)
 		if err != nil {
-			return callbackOnCreateErrorReturn(callbacks, c, e, prepared, err, i)
+			return callbackOnCreateErrorReturn(callbacks, c, params, e, prepared, err, i)
 		}
 
-		return callbackOnCreateSuccessReturn(callbacks, c, e, prepared, i, e.GetID())
+		return callbackOnCreateSuccessReturn(callbacks, c, params, e, prepared, i, e.GetID())
 	}
 }
 
@@ -90,32 +90,32 @@ func Delete(tableName string, callbacks *DeleteCallbacks) binding.ServiceFunc[an
 			return nil, errors.New("需要传递领域对象应该为实体")
 		}
 
-		prepared, err := callbackPrepareDelete(callbacks, c, e, i)
+		prepared, err := callbackPrepareDelete(callbacks, c, params, e, i)
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, c, e, make(map[string]any), err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, params, e, make(map[string]any), err, i)
 		}
 
 		err = domain.CheckFieldsForDelete(e, e.GetFieldMap())
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, c, e, make(map[string]any), err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, params, e, make(map[string]any), err, i)
 		}
 
-		err = callbackBeforeDelete(callbacks, c, e, prepared, i, nil)
+		err = callbackBeforeDelete(callbacks, c, params, e, prepared, i, nil)
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, c, e, prepared, err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, params, e, prepared, err, i)
 		}
 
 		err = database.DeleteEntity(dbExecutor, tableName, e)
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, c, e, prepared, err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, params, e, prepared, err, i)
 		}
 
-		err = callbackAfterDelete(callbacks, c, e, prepared, i, nil)
+		err = callbackAfterDelete(callbacks, c, params, e, prepared, i, nil)
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, c, e, prepared, err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, params, e, prepared, err, i)
 		}
 
-		return nil, callbackOnDeleteSuccessReturn(callbacks, c, e, prepared, i)
+		return nil, callbackOnDeleteSuccessReturn(callbacks, c, params, e, prepared, i)
 	}
 }
 
@@ -138,48 +138,48 @@ func Update(tableName string, needLastUpdateUserID bool, callbacks *UpdateCallba
 			Conditions: sql.NewConditions().Equal(entity.ColumnID, e.GetID()),
 		})
 		if err != nil {
-			return nil, callbackOnUpdateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
+			return nil, callbackOnUpdateErrorReturn(callbacks, c, params, e, make(map[string]any), err, i)
 		}
 
 		if !exist {
 			err := errors.New(e.DomainCNName() + "不存在")
-			return nil, callbackOnUpdateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
+			return nil, callbackOnUpdateErrorReturn(callbacks, c, params, e, make(map[string]any), err, i)
 		}
 
 		if needLastUpdateUserID {
 			userInfo := c.GetUserInfo()
 			err := domain.SetField(e, entity.FieldLastUpdateUserID, userInfo.GetID())
 			if err != nil {
-				return nil, callbackOnUpdateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
+				return nil, callbackOnUpdateErrorReturn(callbacks, c, params, e, make(map[string]any), err, i)
 			}
 		}
 
-		prepared, err := callbackPrepareUpdate(callbacks, c, e, i)
+		prepared, err := callbackPrepareUpdate(callbacks, c, params, e, i)
 		if err != nil {
-			return nil, callbackOnUpdateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
+			return nil, callbackOnUpdateErrorReturn(callbacks, c, params, e, make(map[string]any), err, i)
 		}
 
 		err = domain.CheckFieldsForUpdate(e, e.GetFieldMap())
 		if err != nil {
-			return nil, callbackOnUpdateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
+			return nil, callbackOnUpdateErrorReturn(callbacks, c, params, e, make(map[string]any), err, i)
 		}
 
-		err = callbackBeforeUpdate(callbacks, c, e, prepared, i, nil)
+		err = callbackBeforeUpdate(callbacks, c, params, e, prepared, i, nil)
 		if err != nil {
-			return nil, callbackOnUpdateErrorReturn(callbacks, c, e, prepared, err, i)
+			return nil, callbackOnUpdateErrorReturn(callbacks, c, params, e, prepared, err, i)
 		}
 
 		err = database.UpdateEntity(dbExecutor, tableName, e)
 		if err != nil {
-			return nil, callbackOnUpdateErrorReturn(callbacks, c, e, prepared, err, i)
+			return nil, callbackOnUpdateErrorReturn(callbacks, c, params, e, prepared, err, i)
 		}
 
-		err = callbackAfterUpdate(callbacks, c, e, prepared, i, nil)
+		err = callbackAfterUpdate(callbacks, c, params, e, prepared, i, nil)
 		if err != nil {
-			return nil, callbackOnUpdateErrorReturn(callbacks, c, e, prepared, err, i)
+			return nil, callbackOnUpdateErrorReturn(callbacks, c, params, e, prepared, err, i)
 		}
 
-		return nil, callbackOnUpdateSuccessReturn(callbacks, c, e, prepared, i)
+		return nil, callbackOnUpdateSuccessReturn(callbacks, c, params, e, prepared, i)
 	}
 }
 
@@ -236,9 +236,9 @@ func Query[O any](tableName string, orderBy string, callbacks *QueryCallbacks[O]
 			}
 		}
 
-		err = callbackBeforeQuery(callbacks, c, e, i)
+		err = callbackBeforeQuery(callbacks, c, params, e, i)
 		if err != nil {
-			return callbackOnQueryErrorReturn(callbacks, c, e, err, i)
+			return callbackOnQueryErrorReturn(callbacks, c, params, e, err, i)
 		}
 
 		results, totalCount, err := database.Query(dbExecutor, &sql.QueryExecuteParams{
@@ -249,18 +249,18 @@ func Query[O any](tableName string, orderBy string, callbacks *QueryCallbacks[O]
 			PageSize:   queryParams.GetPageSize(),
 		})
 		if err != nil {
-			return callbackOnQueryErrorReturn(callbacks, c, e, err, i)
+			return callbackOnQueryErrorReturn(callbacks, c, params, e, err, i)
 		}
 
-		err = callbackAfterQuery(callbacks, c, e, i)
+		err = callbackAfterQuery(callbacks, c, params, e, i)
 		if err != nil {
-			return callbackOnQueryErrorReturn(callbacks, c, e, err, i)
+			return callbackOnQueryErrorReturn(callbacks, c, params, e, err, i)
 		}
 
 		infos := make([]O, 0)
 		err = sql.ParseSqlResult(results, &infos)
 		if err != nil {
-			return callbackOnQueryErrorReturn(callbacks, c, e, err, i)
+			return callbackOnQueryErrorReturn(callbacks, c, params, e, err, i)
 		}
 
 		output := response.InfosData[O]{
@@ -269,7 +269,7 @@ func Query[O any](tableName string, orderBy string, callbacks *QueryCallbacks[O]
 			PageNo:     queryParams.GetPageNo(),
 		}
 
-		return callbackOnQuerySuccessReturn(callbacks, c, e, i, output)
+		return callbackOnQuerySuccessReturn(callbacks, c, params, e, i, output)
 	}
 }
 
@@ -291,12 +291,12 @@ func GetByID[O any](tableName string, callbacks *GetByIDCallbacks[O]) binding.Se
 
 		err := domain.CheckField(e, entity.FieldID, e.GetFieldMap())
 		if err != nil {
-			return callbackOnGetByIDErrorReturn(callbacks, c, e, err, i)
+			return callbackOnGetByIDErrorReturn(callbacks, c, params, e, err, i)
 		}
 
-		err = callbackBeforeGetByID(callbacks, c, e, i)
+		err = callbackBeforeGetByID(callbacks, c, params, e, i)
 		if err != nil {
-			return callbackOnGetByIDErrorReturn(callbacks, c, e, err, i)
+			return callbackOnGetByIDErrorReturn(callbacks, c, params, e, err, i)
 		}
 
 		result, err := database.QueryOne(dbExecutor, &sql.QueryOneExecuteParams{
@@ -308,21 +308,21 @@ func GetByID[O any](tableName string, callbacks *GetByIDCallbacks[O]) binding.Se
 				err = errors.New(e.DomainCNName() + "不存在")
 			}
 
-			return callbackOnGetByIDErrorReturn(callbacks, c, e, err, i)
+			return callbackOnGetByIDErrorReturn(callbacks, c, params, e, err, i)
 		}
 
-		err = callbackAfterGetByID(callbacks, c, e, i)
+		err = callbackAfterGetByID(callbacks, c, params, e, i)
 		if err != nil {
-			return callbackOnGetByIDErrorReturn(callbacks, c, e, err, i)
+			return callbackOnGetByIDErrorReturn(callbacks, c, params, e, err, i)
 		}
 
 		info := reflectutils.Zero[O]()
 		err = sql.ParseSqlResult(result, &info)
 		if err != nil {
-			return callbackOnGetByIDErrorReturn(callbacks, c, e, err, i)
+			return callbackOnGetByIDErrorReturn(callbacks, c, params, e, err, i)
 		}
 
-		return callbackOnGetByIDSuccessReturn(callbacks, c, e, i, info)
+		return callbackOnGetByIDSuccessReturn(callbacks, c, params, e, i, info)
 	}
 }
 
@@ -342,29 +342,29 @@ func CreateTx(tableName string, needCreateUserID bool, callbacks *CreateCallback
 
 		err := e.GenerateID()
 		if err != nil {
-			return callbackOnCreateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
+			return callbackOnCreateErrorReturn(callbacks, c, params, e, make(map[string]any), err, i)
 		}
 
 		if needCreateUserID {
 			userInfo := c.GetUserInfo()
 			err := domain.SetField(e, entity.FieldCreateUserID, userInfo.GetID())
 			if err != nil {
-				return callbackOnCreateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
+				return callbackOnCreateErrorReturn(callbacks, c, params, e, make(map[string]any), err, i)
 			}
 		}
 
-		prepared, err := callbackPrepareCreate(callbacks, c, e, i)
+		prepared, err := callbackPrepareCreate(callbacks, c, params, e, i)
 		if err != nil {
-			return callbackOnCreateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
+			return callbackOnCreateErrorReturn(callbacks, c, params, e, make(map[string]any), err, i)
 		}
 
 		err = domain.CheckFieldsForCreate(e, e.GetFieldMap())
 		if err != nil {
-			return callbackOnCreateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
+			return callbackOnCreateErrorReturn(callbacks, c, params, e, make(map[string]any), err, i)
 		}
 
 		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
-			err = callbackBeforeCreate(callbacks, c, e, prepared, i, tx)
+			err = callbackBeforeCreate(callbacks, c, params, e, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -378,7 +378,7 @@ func CreateTx(tableName string, needCreateUserID bool, callbacks *CreateCallback
 				return err
 			}
 
-			err = callbackAfterCreate(callbacks, c, e, prepared, i, tx)
+			err = callbackAfterCreate(callbacks, c, params, e, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -386,10 +386,10 @@ func CreateTx(tableName string, needCreateUserID bool, callbacks *CreateCallback
 			return nil
 		})
 		if err != nil {
-			return callbackOnCreateErrorReturn(callbacks, c, e, prepared, err, i)
+			return callbackOnCreateErrorReturn(callbacks, c, params, e, prepared, err, i)
 		}
 
-		return callbackOnCreateSuccessReturn(callbacks, c, e, prepared, i, e.GetID())
+		return callbackOnCreateSuccessReturn(callbacks, c, params, e, prepared, i, e.GetID())
 	}
 }
 
@@ -407,18 +407,18 @@ func DeleteTx(tableName string, callbacks *DeleteCallbacks) binding.ServiceFunc[
 			return nil, errors.New("需要传递领域对象应该为实体")
 		}
 
-		prepared, err := callbackPrepareDelete(callbacks, c, e, i)
+		prepared, err := callbackPrepareDelete(callbacks, c, params, e, i)
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, c, e, make(map[string]any), err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, params, e, make(map[string]any), err, i)
 		}
 
 		err = domain.CheckFieldsForDelete(e, e.GetFieldMap())
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, c, e, make(map[string]any), err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, params, e, make(map[string]any), err, i)
 		}
 
 		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
-			err = callbackBeforeDelete(callbacks, c, e, prepared, i, tx)
+			err = callbackBeforeDelete(callbacks, c, params, e, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -428,7 +428,7 @@ func DeleteTx(tableName string, callbacks *DeleteCallbacks) binding.ServiceFunc[
 				return err
 			}
 
-			err = callbackAfterDelete(callbacks, c, e, prepared, i, tx)
+			err = callbackAfterDelete(callbacks, c, params, e, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -436,10 +436,10 @@ func DeleteTx(tableName string, callbacks *DeleteCallbacks) binding.ServiceFunc[
 			return nil
 		})
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, c, e, prepared, err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, params, e, prepared, err, i)
 		}
 
-		return nil, callbackOnDeleteSuccessReturn(callbacks, c, e, prepared, i)
+		return nil, callbackOnDeleteSuccessReturn(callbacks, c, params, e, prepared, i)
 	}
 }
 
@@ -462,33 +462,33 @@ func UpdateTx(tableName string, needLastUpdateUserID bool, callbacks *UpdateCall
 			Conditions: sql.NewConditions().Equal(entity.ColumnID, e.GetID()),
 		})
 		if err != nil {
-			return nil, callbackOnUpdateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
+			return nil, callbackOnUpdateErrorReturn(callbacks, c, params, e, make(map[string]any), err, i)
 		}
 
 		if !exist {
-			return nil, callbackOnUpdateErrorReturn(callbacks, c, e, make(map[string]any), errors.New(e.DomainCNName()+"不存在"), i)
+			return nil, callbackOnUpdateErrorReturn(callbacks, c, params, e, make(map[string]any), errors.New(e.DomainCNName()+"不存在"), i)
 		}
 
 		if needLastUpdateUserID {
 			userInfo := c.GetUserInfo()
 			err := domain.SetField(e, entity.FieldLastUpdateUserID, userInfo.GetID())
 			if err != nil {
-				return nil, callbackOnUpdateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
+				return nil, callbackOnUpdateErrorReturn(callbacks, c, params, e, make(map[string]any), err, i)
 			}
 		}
 
-		prepared, err := callbackPrepareUpdate(callbacks, c, e, i)
+		prepared, err := callbackPrepareUpdate(callbacks, c, params, e, i)
 		if err != nil {
-			return nil, callbackOnUpdateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
+			return nil, callbackOnUpdateErrorReturn(callbacks, c, params, e, make(map[string]any), err, i)
 		}
 
 		err = domain.CheckFieldsForUpdate(e, e.GetFieldMap())
 		if err != nil {
-			return nil, callbackOnUpdateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
+			return nil, callbackOnUpdateErrorReturn(callbacks, c, params, e, make(map[string]any), err, i)
 		}
 
 		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
-			err = callbackBeforeUpdate(callbacks, c, e, prepared, i, tx)
+			err = callbackBeforeUpdate(callbacks, c, params, e, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -498,7 +498,7 @@ func UpdateTx(tableName string, needLastUpdateUserID bool, callbacks *UpdateCall
 				return err
 			}
 
-			err = callbackAfterUpdate(callbacks, c, e, prepared, i, tx)
+			err = callbackAfterUpdate(callbacks, c, params, e, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -506,9 +506,9 @@ func UpdateTx(tableName string, needLastUpdateUserID bool, callbacks *UpdateCall
 			return nil
 		})
 		if err != nil {
-			return nil, callbackOnUpdateErrorReturn(callbacks, c, e, prepared, err, i)
+			return nil, callbackOnUpdateErrorReturn(callbacks, c, params, e, prepared, err, i)
 		}
 
-		return nil, callbackOnUpdateSuccessReturn(callbacks, c, e, prepared, i)
+		return nil, callbackOnUpdateSuccessReturn(callbacks, c, params, e, prepared, i)
 	}
 }

convenient/entity_crud/service_callbacks.go

@@ -2,6 +2,7 @@ package entity_crud
 
 import (
 	"git.sxidc.com/go-framework/baize/framework/core/api"
+	"git.sxidc.com/go-framework/baize/framework/core/api/request"
 	"git.sxidc.com/go-framework/baize/framework/core/api/response"
 	"git.sxidc.com/go-framework/baize/framework/core/domain/entity"
 	"git.sxidc.com/go-framework/baize/framework/core/infrastructure"
@@ -10,14 +11,14 @@ import (
 )
 
 type CreateCallbacks struct {
-	Prepare         func(c *api.Context, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error)
-	Before          func(c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
-	After           func(c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
-	OnSuccessReturn func(c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, id string) (string, error)
-	OnErrorReturn   func(c *api.Context, e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) (string, error)
+	Prepare         func(c *api.Context, params request.Params, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error)
+	Before          func(c *api.Context, params request.Params, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
+	After           func(c *api.Context, params request.Params, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
+	OnSuccessReturn func(c *api.Context, params request.Params, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, id string) (string, error)
+	OnErrorReturn   func(c *api.Context, params request.Params, e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) (string, error)
 }
 
-func callbackPrepareCreate(callbacks *CreateCallbacks, c *api.Context, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error) {
+func callbackPrepareCreate(callbacks *CreateCallbacks, c *api.Context, params request.Params, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error) {
 	if callbacks == nil {
 		return make(map[string]any), nil
 	}
@@ -26,10 +27,10 @@ func callbackPrepareCreate(callbacks *CreateCallbacks, c *api.Context, e entity.
 		return make(map[string]any), nil
 	}
 
-	return callbacks.Prepare(c, e, i)
+	return callbacks.Prepare(c, params, e, i)
 }
 
-func callbackBeforeCreate(callbacks *CreateCallbacks, c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
+func callbackBeforeCreate(callbacks *CreateCallbacks, c *api.Context, params request.Params, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -38,10 +39,10 @@ func callbackBeforeCreate(callbacks *CreateCallbacks, c *api.Context, e entity.E
 		return nil
 	}
 
-	return callbacks.Before(c, e, prepared, i, tx)
+	return callbacks.Before(c, params, e, prepared, i, tx)
 }
 
-func callbackAfterCreate(callbacks *CreateCallbacks, c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, dbExecutor database.Executor) error {
+func callbackAfterCreate(callbacks *CreateCallbacks, c *api.Context, params request.Params, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, dbExecutor database.Executor) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -50,10 +51,10 @@ func callbackAfterCreate(callbacks *CreateCallbacks, c *api.Context, e entity.En
 		return nil
 	}
 
-	return callbacks.After(c, e, prepared, i, dbExecutor)
+	return callbacks.After(c, params, e, prepared, i, dbExecutor)
 }
 
-func callbackOnCreateSuccessReturn(callbacks *CreateCallbacks, c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, id string) (string, error) {
+func callbackOnCreateSuccessReturn(callbacks *CreateCallbacks, c *api.Context, params request.Params, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, id string) (string, error) {
 	if callbacks == nil {
 		return id, nil
 	}
@@ -62,10 +63,10 @@ func callbackOnCreateSuccessReturn(callbacks *CreateCallbacks, c *api.Context, e
 		return id, nil
 	}
 
-	return callbacks.OnSuccessReturn(c, e, prepared, i, id)
+	return callbacks.OnSuccessReturn(c, params, e, prepared, i, id)
 }
 
-func callbackOnCreateErrorReturn(callbacks *CreateCallbacks, c *api.Context, e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) (string, error) {
+func callbackOnCreateErrorReturn(callbacks *CreateCallbacks, c *api.Context, params request.Params, e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) (string, error) {
 	if callbacks == nil {
 		return "", err
 	}
@@ -74,18 +75,18 @@ func callbackOnCreateErrorReturn(callbacks *CreateCallbacks, c *api.Context, e e
 		return "", err
 	}
 
-	return callbacks.OnErrorReturn(c, e, prepared, err, i)
+	return callbacks.OnErrorReturn(c, params, e, prepared, err, i)
 }
 
 type DeleteCallbacks struct {
-	Prepare         func(c *api.Context, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error)
-	Before          func(c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
-	After           func(c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
-	OnSuccessReturn func(c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure) error
-	OnErrorReturn   func(c *api.Context, e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) error
+	Prepare         func(c *api.Context, params request.Params, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error)
+	Before          func(c *api.Context, params request.Params, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
+	After           func(c *api.Context, params request.Params, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
+	OnSuccessReturn func(c *api.Context, params request.Params, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure) error
+	OnErrorReturn   func(c *api.Context, params request.Params, e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) error
 }
 
-func callbackPrepareDelete(callbacks *DeleteCallbacks, c *api.Context, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error) {
+func callbackPrepareDelete(callbacks *DeleteCallbacks, c *api.Context, params request.Params, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error) {
 	if callbacks == nil {
 		return make(map[string]any), nil
 	}
@@ -94,10 +95,10 @@ func callbackPrepareDelete(callbacks *DeleteCallbacks, c *api.Context, e entity.
 		return make(map[string]any), nil
 	}
 
-	return callbacks.Prepare(c, e, i)
+	return callbacks.Prepare(c, params, e, i)
 }
 
-func callbackBeforeDelete(callbacks *DeleteCallbacks, c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
+func callbackBeforeDelete(callbacks *DeleteCallbacks, c *api.Context, params request.Params, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -106,10 +107,10 @@ func callbackBeforeDelete(callbacks *DeleteCallbacks, c *api.Context, e entity.E
 		return nil
 	}
 
-	return callbacks.Before(c, e, prepared, i, tx)
+	return callbacks.Before(c, params, e, prepared, i, tx)
 }
 
-func callbackAfterDelete(callbacks *DeleteCallbacks, c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, dbExecutor database.Executor) error {
+func callbackAfterDelete(callbacks *DeleteCallbacks, c *api.Context, params request.Params, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, dbExecutor database.Executor) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -118,10 +119,10 @@ func callbackAfterDelete(callbacks *DeleteCallbacks, c *api.Context, e entity.En
 		return nil
 	}
 
-	return callbacks.After(c, e, prepared, i, dbExecutor)
+	return callbacks.After(c, params, e, prepared, i, dbExecutor)
 }
 
-func callbackOnDeleteSuccessReturn(callbacks *DeleteCallbacks, c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure) error {
+func callbackOnDeleteSuccessReturn(callbacks *DeleteCallbacks, c *api.Context, params request.Params, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -130,10 +131,10 @@ func callbackOnDeleteSuccessReturn(callbacks *DeleteCallbacks, c *api.Context, e
 		return nil
 	}
 
-	return callbacks.OnSuccessReturn(c, e, prepared, i)
+	return callbacks.OnSuccessReturn(c, params, e, prepared, i)
 }
 
-func callbackOnDeleteErrorReturn(callbacks *DeleteCallbacks, c *api.Context, e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) error {
+func callbackOnDeleteErrorReturn(callbacks *DeleteCallbacks, c *api.Context, params request.Params, e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return err
 	}
@@ -142,18 +143,18 @@ func callbackOnDeleteErrorReturn(callbacks *DeleteCallbacks, c *api.Context, e e
 		return err
 	}
 
-	return callbacks.OnErrorReturn(c, e, prepared, err, i)
+	return callbacks.OnErrorReturn(c, params, e, prepared, err, i)
 }
 
 type UpdateCallbacks struct {
-	Prepare         func(c *api.Context, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error)
-	Before          func(c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
-	After           func(c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
-	OnSuccessReturn func(c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure) error
-	OnErrorReturn   func(c *api.Context, e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) error
+	Prepare         func(c *api.Context, params request.Params, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error)
+	Before          func(c *api.Context, params request.Params, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
+	After           func(c *api.Context, params request.Params, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
+	OnSuccessReturn func(c *api.Context, params request.Params, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure) error
+	OnErrorReturn   func(c *api.Context, params request.Params, e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) error
 }
 
-func callbackPrepareUpdate(callbacks *UpdateCallbacks, c *api.Context, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error) {
+func callbackPrepareUpdate(callbacks *UpdateCallbacks, c *api.Context, params request.Params, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error) {
 	if callbacks == nil {
 		return make(map[string]any), nil
 	}
@@ -162,10 +163,10 @@ func callbackPrepareUpdate(callbacks *UpdateCallbacks, c *api.Context, e entity.
 		return make(map[string]any), nil
 	}
 
-	return callbacks.Prepare(c, e, i)
+	return callbacks.Prepare(c, params, e, i)
 }
 
-func callbackBeforeUpdate(callbacks *UpdateCallbacks, c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
+func callbackBeforeUpdate(callbacks *UpdateCallbacks, c *api.Context, params request.Params, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -174,10 +175,10 @@ func callbackBeforeUpdate(callbacks *UpdateCallbacks, c *api.Context, e entity.E
 		return nil
 	}
 
-	return callbacks.Before(c, e, prepared, i, tx)
+	return callbacks.Before(c, params, e, prepared, i, tx)
 }
 
-func callbackAfterUpdate(callbacks *UpdateCallbacks, c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, dbExecutor database.Executor) error {
+func callbackAfterUpdate(callbacks *UpdateCallbacks, c *api.Context, params request.Params, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, dbExecutor database.Executor) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -186,10 +187,10 @@ func callbackAfterUpdate(callbacks *UpdateCallbacks, c *api.Context, e entity.En
 		return nil
 	}
 
-	return callbacks.After(c, e, prepared, i, dbExecutor)
+	return callbacks.After(c, params, e, prepared, i, dbExecutor)
 }
 
-func callbackOnUpdateSuccessReturn(callbacks *UpdateCallbacks, c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure) error {
+func callbackOnUpdateSuccessReturn(callbacks *UpdateCallbacks, c *api.Context, params request.Params, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -198,10 +199,10 @@ func callbackOnUpdateSuccessReturn(callbacks *UpdateCallbacks, c *api.Context, e
 		return nil
 	}
 
-	return callbacks.OnSuccessReturn(c, e, prepared, i)
+	return callbacks.OnSuccessReturn(c, params, e, prepared, i)
 }
 
-func callbackOnUpdateErrorReturn(callbacks *UpdateCallbacks, c *api.Context, e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) error {
+func callbackOnUpdateErrorReturn(callbacks *UpdateCallbacks, c *api.Context, params request.Params, e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return err
 	}
@@ -210,17 +211,17 @@ func callbackOnUpdateErrorReturn(callbacks *UpdateCallbacks, c *api.Context, e e
 		return err
 	}
 
-	return callbacks.OnErrorReturn(c, e, prepared, err, i)
+	return callbacks.OnErrorReturn(c, params, e, prepared, err, i)
 }
 
 type QueryCallbacks[O any] struct {
-	Before          func(c *api.Context, e entity.Entity, i *infrastructure.Infrastructure) error
-	After           func(c *api.Context, e entity.Entity, i *infrastructure.Infrastructure) error
-	OnSuccessReturn func(c *api.Context, e entity.Entity, i *infrastructure.Infrastructure, output response.InfosData[O]) (response.InfosData[O], error)
-	OnErrorReturn   func(c *api.Context, e entity.Entity, err error, i *infrastructure.Infrastructure) (response.InfosData[O], error)
+	Before          func(c *api.Context, params request.Params, e entity.Entity, i *infrastructure.Infrastructure) error
+	After           func(c *api.Context, params request.Params, e entity.Entity, i *infrastructure.Infrastructure) error
+	OnSuccessReturn func(c *api.Context, params request.Params, e entity.Entity, i *infrastructure.Infrastructure, output response.InfosData[O]) (response.InfosData[O], error)
+	OnErrorReturn   func(c *api.Context, params request.Params, e entity.Entity, err error, i *infrastructure.Infrastructure) (response.InfosData[O], error)
 }
 
-func callbackBeforeQuery[O any](callbacks *QueryCallbacks[O], c *api.Context, e entity.Entity, i *infrastructure.Infrastructure) error {
+func callbackBeforeQuery[O any](callbacks *QueryCallbacks[O], c *api.Context, params request.Params, e entity.Entity, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -229,10 +230,10 @@ func callbackBeforeQuery[O any](callbacks *QueryCallbacks[O], c *api.Context, e
 		return nil
 	}
 
-	return callbacks.Before(c, e, i)
+	return callbacks.Before(c, params, e, i)
 }
 
-func callbackAfterQuery[O any](callbacks *QueryCallbacks[O], c *api.Context, e entity.Entity, i *infrastructure.Infrastructure) error {
+func callbackAfterQuery[O any](callbacks *QueryCallbacks[O], c *api.Context, params request.Params, e entity.Entity, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -241,10 +242,10 @@ func callbackAfterQuery[O any](callbacks *QueryCallbacks[O], c *api.Context, e e
 		return nil
 	}
 
-	return callbacks.After(c, e, i)
+	return callbacks.After(c, params, e, i)
 }
 
-func callbackOnQuerySuccessReturn[O any](callbacks *QueryCallbacks[O], c *api.Context, e entity.Entity, i *infrastructure.Infrastructure, output response.InfosData[O]) (response.InfosData[O], error) {
+func callbackOnQuerySuccessReturn[O any](callbacks *QueryCallbacks[O], c *api.Context, params request.Params, e entity.Entity, i *infrastructure.Infrastructure, output response.InfosData[O]) (response.InfosData[O], error) {
 	if callbacks == nil {
 		return output, nil
 	}
@@ -253,10 +254,10 @@ func callbackOnQuerySuccessReturn[O any](callbacks *QueryCallbacks[O], c *api.Co
 		return output, nil
 	}
 
-	return callbacks.OnSuccessReturn(c, e, i, output)
+	return callbacks.OnSuccessReturn(c, params, e, i, output)
 }
 
-func callbackOnQueryErrorReturn[O any](callbacks *QueryCallbacks[O], c *api.Context, e entity.Entity, err error, i *infrastructure.Infrastructure) (response.InfosData[O], error) {
+func callbackOnQueryErrorReturn[O any](callbacks *QueryCallbacks[O], c *api.Context, params request.Params, e entity.Entity, err error, i *infrastructure.Infrastructure) (response.InfosData[O], error) {
 	if callbacks == nil {
 		return response.InfosData[O]{
 			Infos: make([]O, 0),
@@ -269,17 +270,17 @@ func callbackOnQueryErrorReturn[O any](callbacks *QueryCallbacks[O], c *api.Cont
 		}, err
 	}
 
-	return callbacks.OnErrorReturn(c, e, err, i)
+	return callbacks.OnErrorReturn(c, params, e, err, i)
 }
 
 type GetByIDCallbacks[O any] struct {
-	Before          func(c *api.Context, e entity.Entity, i *infrastructure.Infrastructure) error
-	After           func(c *api.Context, e entity.Entity, i *infrastructure.Infrastructure) error
-	OnSuccessReturn func(c *api.Context, e entity.Entity, i *infrastructure.Infrastructure, output O) (O, error)
-	OnErrorReturn   func(c *api.Context, e entity.Entity, err error, i *infrastructure.Infrastructure) (O, error)
+	Before          func(c *api.Context, params request.Params, e entity.Entity, i *infrastructure.Infrastructure) error
+	After           func(c *api.Context, params request.Params, e entity.Entity, i *infrastructure.Infrastructure) error
+	OnSuccessReturn func(c *api.Context, params request.Params, e entity.Entity, i *infrastructure.Infrastructure, output O) (O, error)
+	OnErrorReturn   func(c *api.Context, params request.Params, e entity.Entity, err error, i *infrastructure.Infrastructure) (O, error)
 }
 
-func callbackBeforeGetByID[O any](callbacks *GetByIDCallbacks[O], c *api.Context, e entity.Entity, i *infrastructure.Infrastructure) error {
+func callbackBeforeGetByID[O any](callbacks *GetByIDCallbacks[O], c *api.Context, params request.Params, e entity.Entity, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -288,10 +289,10 @@ func callbackBeforeGetByID[O any](callbacks *GetByIDCallbacks[O], c *api.Context
 		return nil
 	}
 
-	return callbacks.Before(c, e, i)
+	return callbacks.Before(c, params, e, i)
 }
 
-func callbackAfterGetByID[O any](callbacks *GetByIDCallbacks[O], c *api.Context, e entity.Entity, i *infrastructure.Infrastructure) error {
+func callbackAfterGetByID[O any](callbacks *GetByIDCallbacks[O], c *api.Context, params request.Params, e entity.Entity, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -300,10 +301,10 @@ func callbackAfterGetByID[O any](callbacks *GetByIDCallbacks[O], c *api.Context,
 		return nil
 	}
 
-	return callbacks.After(c, e, i)
+	return callbacks.After(c, params, e, i)
 }
 
-func callbackOnGetByIDSuccessReturn[O any](callbacks *GetByIDCallbacks[O], c *api.Context, e entity.Entity, i *infrastructure.Infrastructure, output O) (O, error) {
+func callbackOnGetByIDSuccessReturn[O any](callbacks *GetByIDCallbacks[O], c *api.Context, params request.Params, e entity.Entity, i *infrastructure.Infrastructure, output O) (O, error) {
 	if callbacks == nil {
 		return output, nil
 	}
@@ -312,10 +313,10 @@ func callbackOnGetByIDSuccessReturn[O any](callbacks *GetByIDCallbacks[O], c *ap
 		return output, nil
 	}
 
-	return callbacks.OnSuccessReturn(c, e, i, output)
+	return callbacks.OnSuccessReturn(c, params, e, i, output)
 }
 
-func callbackOnGetByIDErrorReturn[O any](callbacks *GetByIDCallbacks[O], c *api.Context, e entity.Entity, err error, i *infrastructure.Infrastructure) (O, error) {
+func callbackOnGetByIDErrorReturn[O any](callbacks *GetByIDCallbacks[O], c *api.Context, params request.Params, e entity.Entity, err error, i *infrastructure.Infrastructure) (O, error) {
 	if callbacks == nil {
 		return reflectutils.Zero[O](), err
 	}
@@ -324,5 +325,5 @@ func callbackOnGetByIDErrorReturn[O any](callbacks *GetByIDCallbacks[O], c *api.
 		return reflectutils.Zero[O](), err
 	}
 
-	return callbacks.OnErrorReturn(c, e, err, i)
+	return callbacks.OnErrorReturn(c, params, e, err, i)
 }

convenient/value_object_crud/service.go

@@ -29,19 +29,19 @@ func Create(tableName string, callbacks *CreateCallbacks) binding.ServiceFunc[an
 			return nil, errors.New("需要传递领域对象应该为值对象")
 		}
 
-		prepared, err := callbackPrepareCreate(callbacks, c, valueObject, i)
+		prepared, err := callbackPrepareCreate(callbacks, c, params, valueObject, i)
 		if err != nil {
-			return nil, callbackOnCreateErrorReturn(callbacks, c, valueObject, make(map[string]any), err, i)
+			return nil, callbackOnCreateErrorReturn(callbacks, c, params, valueObject, make(map[string]any), err, i)
 		}
 
 		err = domain.CheckFieldsForCreate(valueObject, valueObject.GetFieldMap())
 		if err != nil {
-			return nil, callbackOnCreateErrorReturn(callbacks, c, valueObject, make(map[string]any), err, i)
+			return nil, callbackOnCreateErrorReturn(callbacks, c, params, valueObject, make(map[string]any), err, i)
 		}
 
-		err = callbackBeforeCreate(callbacks, c, valueObject, prepared, i, nil)
+		err = callbackBeforeCreate(callbacks, c, params, valueObject, prepared, i, nil)
 		if err != nil {
-			return nil, callbackOnCreateErrorReturn(callbacks, c, valueObject, prepared, err, i)
+			return nil, callbackOnCreateErrorReturn(callbacks, c, params, valueObject, prepared, err, i)
 		}
 
 		err = database.InsertEntity(dbExecutor, tableName, valueObject)
@@ -50,15 +50,15 @@ func Create(tableName string, callbacks *CreateCallbacks) binding.ServiceFunc[an
 				err = errors.New(valueObject.DomainCNName() + "已存在")
 			}
 
-			return nil, callbackOnCreateErrorReturn(callbacks, c, valueObject, prepared, err, i)
+			return nil, callbackOnCreateErrorReturn(callbacks, c, params, valueObject, prepared, err, i)
 		}
 
-		err = callbackAfterCreate(callbacks, c, valueObject, prepared, i, nil)
+		err = callbackAfterCreate(callbacks, c, params, valueObject, prepared, i, nil)
 		if err != nil {
-			return nil, callbackOnCreateErrorReturn(callbacks, c, valueObject, prepared, err, i)
+			return nil, callbackOnCreateErrorReturn(callbacks, c, params, valueObject, prepared, err, i)
 		}
 
-		return nil, callbackOnCreateSuccessReturn(callbacks, c, valueObject, prepared, i)
+		return nil, callbackOnCreateSuccessReturn(callbacks, c, params, valueObject, prepared, i)
 	}
 }
 
@@ -76,32 +76,32 @@ func Delete(tableName string, callbacks *DeleteCallbacks) binding.ServiceFunc[an
 			return nil, errors.New("需要传递领域对象应该为值对象")
 		}
 
-		prepared, err := callbackPrepareDelete(callbacks, c, valueObject, i)
+		prepared, err := callbackPrepareDelete(callbacks, c, params, valueObject, i)
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, c, valueObject, make(map[string]any), err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, params, valueObject, make(map[string]any), err, i)
 		}
 
 		err = domain.CheckFieldsForDelete(valueObject, valueObject.GetFieldMap())
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, c, valueObject, make(map[string]any), err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, params, valueObject, make(map[string]any), err, i)
 		}
 
-		err = callbackBeforeDelete(callbacks, c, valueObject, prepared, i, nil)
+		err = callbackBeforeDelete(callbacks, c, params, valueObject, prepared, i, nil)
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, c, valueObject, make(map[string]any), err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, params, valueObject, make(map[string]any), err, i)
 		}
 
 		err = database.DeleteEntity(dbExecutor, tableName, valueObject)
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, c, valueObject, make(map[string]any), err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, params, valueObject, make(map[string]any), err, i)
 		}
 
-		err = callbackAfterDelete(callbacks, c, valueObject, prepared, i, nil)
+		err = callbackAfterDelete(callbacks, c, params, valueObject, prepared, i, nil)
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, c, valueObject, make(map[string]any), err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, params, valueObject, make(map[string]any), err, i)
 		}
 
-		return nil, callbackOnDeleteSuccessReturn(callbacks, c, valueObject, prepared, i)
+		return nil, callbackOnDeleteSuccessReturn(callbacks, c, params, valueObject, prepared, i)
 	}
 }
 
@@ -158,9 +158,9 @@ func Query[O any](tableName string, orderBy string, callbacks *QueryCallbacks[O]
 			}
 		}
 
-		err = callbackBeforeQuery(callbacks, c, valueObject, i)
+		err = callbackBeforeQuery(callbacks, c, params, valueObject, i)
 		if err != nil {
-			return callbackOnQueryErrorReturn(callbacks, c, valueObject, err, i)
+			return callbackOnQueryErrorReturn(callbacks, c, params, valueObject, err, i)
 		}
 
 		results, totalCount, err := database.Query(dbExecutor, &sql.QueryExecuteParams{
@@ -171,18 +171,18 @@ func Query[O any](tableName string, orderBy string, callbacks *QueryCallbacks[O]
 			PageSize:   queryParams.GetPageSize(),
 		})
 		if err != nil {
-			return callbackOnQueryErrorReturn(callbacks, c, valueObject, err, i)
+			return callbackOnQueryErrorReturn(callbacks, c, params, valueObject, err, i)
 		}
 
-		err = callbackAfterQuery(callbacks, c, valueObject, i)
+		err = callbackAfterQuery(callbacks, c, params, valueObject, i)
 		if err != nil {
-			return callbackOnQueryErrorReturn(callbacks, c, valueObject, err, i)
+			return callbackOnQueryErrorReturn(callbacks, c, params, valueObject, err, i)
 		}
 
 		infos := make([]O, 0)
 		err = sql.ParseSqlResult(results, &infos)
 		if err != nil {
-			return callbackOnQueryErrorReturn(callbacks, c, valueObject, err, i)
+			return callbackOnQueryErrorReturn(callbacks, c, params, valueObject, err, i)
 		}
 
 		output := response.InfosData[O]{
@@ -191,7 +191,7 @@ func Query[O any](tableName string, orderBy string, callbacks *QueryCallbacks[O]
 			PageNo:     queryParams.GetPageNo(),
 		}
 
-		return callbackOnQuerySuccessReturn(callbacks, c, valueObject, i, output)
+		return callbackOnQuerySuccessReturn(callbacks, c, params, valueObject, i, output)
 	}
 }
 
@@ -209,18 +209,18 @@ func CreateTx(tableName string, callbacks *CreateCallbacks) binding.ServiceFunc[
 			return nil, errors.New("需要传递领域对象应该为值对象")
 		}
 
-		prepared, err := callbackPrepareCreate(callbacks, c, valueObject, i)
+		prepared, err := callbackPrepareCreate(callbacks, c, params, valueObject, i)
 		if err != nil {
-			return nil, callbackOnCreateErrorReturn(callbacks, c, valueObject, make(map[string]any), err, i)
+			return nil, callbackOnCreateErrorReturn(callbacks, c, params, valueObject, make(map[string]any), err, i)
 		}
 
 		err = domain.CheckFieldsForCreate(valueObject, valueObject.GetFieldMap())
 		if err != nil {
-			return nil, callbackOnCreateErrorReturn(callbacks, c, valueObject, make(map[string]any), err, i)
+			return nil, callbackOnCreateErrorReturn(callbacks, c, params, valueObject, make(map[string]any), err, i)
 		}
 
 		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
-			err := callbackBeforeCreate(callbacks, c, valueObject, prepared, i, tx)
+			err := callbackBeforeCreate(callbacks, c, params, valueObject, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -234,7 +234,7 @@ func CreateTx(tableName string, callbacks *CreateCallbacks) binding.ServiceFunc[
 				return err
 			}
 
-			err = callbackAfterCreate(callbacks, c, valueObject, prepared, i, tx)
+			err = callbackAfterCreate(callbacks, c, params, valueObject, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -242,10 +242,10 @@ func CreateTx(tableName string, callbacks *CreateCallbacks) binding.ServiceFunc[
 			return nil
 		})
 		if err != nil {
-			return nil, callbackOnCreateErrorReturn(callbacks, c, valueObject, prepared, err, i)
+			return nil, callbackOnCreateErrorReturn(callbacks, c, params, valueObject, prepared, err, i)
 		}
 
-		return nil, callbackOnCreateSuccessReturn(callbacks, c, valueObject, prepared, i)
+		return nil, callbackOnCreateSuccessReturn(callbacks, c, params, valueObject, prepared, i)
 	}
 }
 
@@ -263,18 +263,18 @@ func DeleteTx(tableName string, callbacks *DeleteCallbacks) binding.ServiceFunc[
 			return nil, errors.New("需要传递领域对象应该为值对象")
 		}
 
-		prepared, err := callbackPrepareDelete(callbacks, c, valueObject, i)
+		prepared, err := callbackPrepareDelete(callbacks, c, params, valueObject, i)
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, c, valueObject, make(map[string]any), err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, params, valueObject, make(map[string]any), err, i)
 		}
 
 		err = domain.CheckFieldsForDelete(valueObject, valueObject.GetFieldMap())
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, c, valueObject, make(map[string]any), err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, params, valueObject, make(map[string]any), err, i)
 		}
 
 		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
-			err = callbackBeforeDelete(callbacks, c, valueObject, prepared, i, tx)
+			err = callbackBeforeDelete(callbacks, c, params, valueObject, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -284,7 +284,7 @@ func DeleteTx(tableName string, callbacks *DeleteCallbacks) binding.ServiceFunc[
 				return err
 			}
 
-			err = callbackAfterDelete(callbacks, c, valueObject, prepared, i, tx)
+			err = callbackAfterDelete(callbacks, c, params, valueObject, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -292,9 +292,9 @@ func DeleteTx(tableName string, callbacks *DeleteCallbacks) binding.ServiceFunc[
 			return nil
 		})
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, c, valueObject, prepared, err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, params, valueObject, prepared, err, i)
 		}
 
-		return nil, callbackOnDeleteSuccessReturn(callbacks, c, valueObject, prepared, i)
+		return nil, callbackOnDeleteSuccessReturn(callbacks, c, params, valueObject, prepared, i)
 	}
 }

convenient/value_object_crud/service_callbacks.go

@@ -2,6 +2,7 @@ package value_object_crud
 
 import (
 	"git.sxidc.com/go-framework/baize/framework/core/api"
+	"git.sxidc.com/go-framework/baize/framework/core/api/request"
 	"git.sxidc.com/go-framework/baize/framework/core/api/response"
 	"git.sxidc.com/go-framework/baize/framework/core/domain/value_object"
 	"git.sxidc.com/go-framework/baize/framework/core/infrastructure"
@@ -9,14 +10,14 @@ import (
 )
 
 type CreateCallbacks struct {
-	Prepare         func(c *api.Context, valueObject value_object.ValueObject, i *infrastructure.Infrastructure) (map[string]any, error)
-	Before          func(c *api.Context, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
-	After           func(c *api.Context, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
-	OnSuccessReturn func(c *api.Context, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure) error
-	OnErrorReturn   func(c *api.Context, valueObject value_object.ValueObject, prepared map[string]any, err error, i *infrastructure.Infrastructure) error
+	Prepare         func(c *api.Context, params request.Params, valueObject value_object.ValueObject, i *infrastructure.Infrastructure) (map[string]any, error)
+	Before          func(c *api.Context, params request.Params, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
+	After           func(c *api.Context, params request.Params, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
+	OnSuccessReturn func(c *api.Context, params request.Params, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure) error
+	OnErrorReturn   func(c *api.Context, params request.Params, valueObject value_object.ValueObject, prepared map[string]any, err error, i *infrastructure.Infrastructure) error
 }
 
-func callbackPrepareCreate(callbacks *CreateCallbacks, c *api.Context, valueObject value_object.ValueObject, i *infrastructure.Infrastructure) (map[string]any, error) {
+func callbackPrepareCreate(callbacks *CreateCallbacks, c *api.Context, params request.Params, valueObject value_object.ValueObject, i *infrastructure.Infrastructure) (map[string]any, error) {
 	if callbacks == nil {
 		return make(map[string]any), nil
 	}
@@ -25,10 +26,10 @@ func callbackPrepareCreate(callbacks *CreateCallbacks, c *api.Context, valueObje
 		return make(map[string]any), nil
 	}
 
-	return callbacks.Prepare(c, valueObject, i)
+	return callbacks.Prepare(c, params, valueObject, i)
 }
 
-func callbackBeforeCreate(callbacks *CreateCallbacks, c *api.Context, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
+func callbackBeforeCreate(callbacks *CreateCallbacks, c *api.Context, params request.Params, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -37,10 +38,10 @@ func callbackBeforeCreate(callbacks *CreateCallbacks, c *api.Context, valueObjec
 		return nil
 	}
 
-	return callbacks.Before(c, valueObject, prepared, i, tx)
+	return callbacks.Before(c, params, valueObject, prepared, i, tx)
 }
 
-func callbackAfterCreate(callbacks *CreateCallbacks, c *api.Context, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
+func callbackAfterCreate(callbacks *CreateCallbacks, c *api.Context, params request.Params, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -49,10 +50,10 @@ func callbackAfterCreate(callbacks *CreateCallbacks, c *api.Context, valueObject
 		return nil
 	}
 
-	return callbacks.After(c, valueObject, prepared, i, tx)
+	return callbacks.After(c, params, valueObject, prepared, i, tx)
 }
 
-func callbackOnCreateSuccessReturn(callbacks *CreateCallbacks, c *api.Context, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure) error {
+func callbackOnCreateSuccessReturn(callbacks *CreateCallbacks, c *api.Context, params request.Params, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -61,10 +62,10 @@ func callbackOnCreateSuccessReturn(callbacks *CreateCallbacks, c *api.Context, v
 		return nil
 	}
 
-	return callbacks.OnSuccessReturn(c, valueObject, prepared, i)
+	return callbacks.OnSuccessReturn(c, params, valueObject, prepared, i)
 }
 
-func callbackOnCreateErrorReturn(callbacks *CreateCallbacks, c *api.Context, valueObject value_object.ValueObject, prepared map[string]any, err error, i *infrastructure.Infrastructure) error {
+func callbackOnCreateErrorReturn(callbacks *CreateCallbacks, c *api.Context, params request.Params, valueObject value_object.ValueObject, prepared map[string]any, err error, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return err
 	}
@@ -73,18 +74,18 @@ func callbackOnCreateErrorReturn(callbacks *CreateCallbacks, c *api.Context, val
 		return err
 	}
 
-	return callbacks.OnErrorReturn(c, valueObject, prepared, err, i)
+	return callbacks.OnErrorReturn(c, params, valueObject, prepared, err, i)
 }
 
 type DeleteCallbacks struct {
-	Prepare         func(c *api.Context, valueObject value_object.ValueObject, i *infrastructure.Infrastructure) (map[string]any, error)
-	Before          func(c *api.Context, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
-	After           func(c *api.Context, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
-	OnSuccessReturn func(c *api.Context, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure) error
-	OnErrorReturn   func(c *api.Context, valueObject value_object.ValueObject, prepared map[string]any, err error, i *infrastructure.Infrastructure) error
+	Prepare         func(c *api.Context, params request.Params, valueObject value_object.ValueObject, i *infrastructure.Infrastructure) (map[string]any, error)
+	Before          func(c *api.Context, params request.Params, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
+	After           func(c *api.Context, params request.Params, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
+	OnSuccessReturn func(c *api.Context, params request.Params, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure) error
+	OnErrorReturn   func(c *api.Context, params request.Params, valueObject value_object.ValueObject, prepared map[string]any, err error, i *infrastructure.Infrastructure) error
 }
 
-func callbackPrepareDelete(callbacks *DeleteCallbacks, c *api.Context, valueObject value_object.ValueObject, i *infrastructure.Infrastructure) (map[string]any, error) {
+func callbackPrepareDelete(callbacks *DeleteCallbacks, c *api.Context, params request.Params, valueObject value_object.ValueObject, i *infrastructure.Infrastructure) (map[string]any, error) {
 	if callbacks == nil {
 		return make(map[string]any), nil
 	}
@@ -93,10 +94,10 @@ func callbackPrepareDelete(callbacks *DeleteCallbacks, c *api.Context, valueObje
 		return make(map[string]any), nil
 	}
 
-	return callbacks.Prepare(c, valueObject, i)
+	return callbacks.Prepare(c, params, valueObject, i)
 }
 
-func callbackBeforeDelete(callbacks *DeleteCallbacks, c *api.Context, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
+func callbackBeforeDelete(callbacks *DeleteCallbacks, c *api.Context, params request.Params, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -105,10 +106,10 @@ func callbackBeforeDelete(callbacks *DeleteCallbacks, c *api.Context, valueObjec
 		return nil
 	}
 
-	return callbacks.Before(c, valueObject, prepared, i, tx)
+	return callbacks.Before(c, params, valueObject, prepared, i, tx)
 }
 
-func callbackAfterDelete(callbacks *DeleteCallbacks, c *api.Context, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
+func callbackAfterDelete(callbacks *DeleteCallbacks, c *api.Context, params request.Params, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -117,10 +118,10 @@ func callbackAfterDelete(callbacks *DeleteCallbacks, c *api.Context, valueObject
 		return nil
 	}
 
-	return callbacks.After(c, valueObject, prepared, i, tx)
+	return callbacks.After(c, params, valueObject, prepared, i, tx)
 }
 
-func callbackOnDeleteSuccessReturn(callbacks *DeleteCallbacks, c *api.Context, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure) error {
+func callbackOnDeleteSuccessReturn(callbacks *DeleteCallbacks, c *api.Context, params request.Params, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -129,10 +130,10 @@ func callbackOnDeleteSuccessReturn(callbacks *DeleteCallbacks, c *api.Context, v
 		return nil
 	}
 
-	return callbacks.OnSuccessReturn(c, valueObject, prepared, i)
+	return callbacks.OnSuccessReturn(c, params, valueObject, prepared, i)
 }
 
-func callbackOnDeleteErrorReturn(callbacks *DeleteCallbacks, c *api.Context, valueObject value_object.ValueObject, prepared map[string]any, err error, i *infrastructure.Infrastructure) error {
+func callbackOnDeleteErrorReturn(callbacks *DeleteCallbacks, c *api.Context, params request.Params, valueObject value_object.ValueObject, prepared map[string]any, err error, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return err
 	}
@@ -141,17 +142,17 @@ func callbackOnDeleteErrorReturn(callbacks *DeleteCallbacks, c *api.Context, val
 		return err
 	}
 
-	return callbacks.OnErrorReturn(c, valueObject, prepared, err, i)
+	return callbacks.OnErrorReturn(c, params, valueObject, prepared, err, i)
 }
 
 type QueryCallbacks[O any] struct {
-	Before          func(c *api.Context, valueObject value_object.ValueObject, i *infrastructure.Infrastructure) error
-	After           func(c *api.Context, valueObject value_object.ValueObject, i *infrastructure.Infrastructure) error
-	OnSuccessReturn func(c *api.Context, valueObject value_object.ValueObject, i *infrastructure.Infrastructure, output response.InfosData[O]) (response.InfosData[O], error)
-	OnErrorReturn   func(c *api.Context, valueObject value_object.ValueObject, err error, i *infrastructure.Infrastructure) (response.InfosData[O], error)
+	Before          func(c *api.Context, params request.Params, valueObject value_object.ValueObject, i *infrastructure.Infrastructure) error
+	After           func(c *api.Context, params request.Params, valueObject value_object.ValueObject, i *infrastructure.Infrastructure) error
+	OnSuccessReturn func(c *api.Context, params request.Params, valueObject value_object.ValueObject, i *infrastructure.Infrastructure, output response.InfosData[O]) (response.InfosData[O], error)
+	OnErrorReturn   func(c *api.Context, params request.Params, valueObject value_object.ValueObject, err error, i *infrastructure.Infrastructure) (response.InfosData[O], error)
 }
 
-func callbackBeforeQuery[O any](callbacks *QueryCallbacks[O], c *api.Context, valueObject value_object.ValueObject, i *infrastructure.Infrastructure) error {
+func callbackBeforeQuery[O any](callbacks *QueryCallbacks[O], c *api.Context, params request.Params, valueObject value_object.ValueObject, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -160,10 +161,10 @@ func callbackBeforeQuery[O any](callbacks *QueryCallbacks[O], c *api.Context, va
 		return nil
 	}
 
-	return callbacks.Before(c, valueObject, i)
+	return callbacks.Before(c, params, valueObject, i)
 }
 
-func callbackAfterQuery[O any](callbacks *QueryCallbacks[O], c *api.Context, valueObject value_object.ValueObject, i *infrastructure.Infrastructure) error {
+func callbackAfterQuery[O any](callbacks *QueryCallbacks[O], c *api.Context, params request.Params, valueObject value_object.ValueObject, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -172,10 +173,10 @@ func callbackAfterQuery[O any](callbacks *QueryCallbacks[O], c *api.Context, val
 		return nil
 	}
 
-	return callbacks.After(c, valueObject, i)
+	return callbacks.After(c, params, valueObject, i)
 }
 
-func callbackOnQuerySuccessReturn[O any](callbacks *QueryCallbacks[O], c *api.Context, valueObject value_object.ValueObject, i *infrastructure.Infrastructure, output response.InfosData[O]) (response.InfosData[O], error) {
+func callbackOnQuerySuccessReturn[O any](callbacks *QueryCallbacks[O], c *api.Context, params request.Params, valueObject value_object.ValueObject, i *infrastructure.Infrastructure, output response.InfosData[O]) (response.InfosData[O], error) {
 	if callbacks == nil {
 		return output, nil
 	}
@@ -184,10 +185,10 @@ func callbackOnQuerySuccessReturn[O any](callbacks *QueryCallbacks[O], c *api.Co
 		return output, nil
 	}
 
-	return callbacks.OnSuccessReturn(c, valueObject, i, output)
+	return callbacks.OnSuccessReturn(c, params, valueObject, i, output)
 }
 
-func callbackOnQueryErrorReturn[O any](callbacks *QueryCallbacks[O], c *api.Context, valueObject value_object.ValueObject, err error, i *infrastructure.Infrastructure) (response.InfosData[O], error) {
+func callbackOnQueryErrorReturn[O any](callbacks *QueryCallbacks[O], c *api.Context, params request.Params, valueObject value_object.ValueObject, err error, i *infrastructure.Infrastructure) (response.InfosData[O], error) {
 	if callbacks == nil {
 		return response.InfosData[O]{
 			Infos: make([]O, 0),
@@ -200,5 +201,5 @@ func callbackOnQueryErrorReturn[O any](callbacks *QueryCallbacks[O], c *api.Cont
 		}, err
 	}
 
-	return callbacks.OnErrorReturn(c, valueObject, err, i)
+	return callbacks.OnErrorReturn(c, params, valueObject, err, i)
 }