修改冲突

convenient/domain/auth/user/api.go

@@ -4,6 +4,7 @@ import (
 	"git.sxidc.com/go-framework/baize/convenient/entity_crud"
 	"git.sxidc.com/go-framework/baize/framework/binding"
 	"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"
 	"git.sxidc.com/go-framework/baize/framework/core/domain/entity"
@@ -37,7 +38,7 @@ func (simple *Simple) Bind(binder *binding.Binder) {
 		GetByIDQueryParams: &GetUserQueryParams{},
 	}, entity_crud.WithGlobalMiddlewares(simple.AuthMiddleware),
 		entity_crud.WithCreateCallbacks(&entity_crud.CreateCallbacks{
-			Prepare: func(c *api.Context, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error) {
+			Prepare: func(c *api.Context, params request.Params, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error) {
 				userEntity, err := domain.ToConcrete[*Entity](e)
 				if err != nil {
 					return nil, err
@@ -71,7 +72,7 @@ func (simple *Simple) Bind(binder *binding.Binder) {
 				return nil, nil
 			},
 		}), entity_crud.WithUpdateCallbacks(&entity_crud.UpdateCallbacks{
-			Prepare: func(c *api.Context, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error) {
+			Prepare: func(c *api.Context, params request.Params, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error) {
 				userEntity, err := domain.ToConcrete[*Entity](e)
 				if err != nil {
 					return nil, err
@@ -174,7 +175,7 @@ func (simple *Simple) Bind(binder *binding.Binder) {
 				return false, nil
 			}
 		}), entity_crud.WithQueryCallbacks(&entity_crud.QueryCallbacks[Info]{
-			OnSuccessReturn: func(c *api.Context, e entity.Entity, i *infrastructure.Infrastructure, output response.InfosData[Info]) (response.InfosData[Info], error) {
+			OnSuccessReturn: func(c *api.Context, params request.Params, e entity.Entity, i *infrastructure.Infrastructure, output response.InfosData[Info]) (response.InfosData[Info], error) {
 				errResponse := response.InfosData[Info]{
 					Infos: make([]Info, 0),
 				}
@@ -211,7 +212,7 @@ func (simple *Simple) Bind(binder *binding.Binder) {
 				}, nil
 			},
 		}), entity_crud.WithGetByIDCallbacks(&entity_crud.GetByIDCallbacks[Info]{
-			OnSuccessReturn: func(c *api.Context, e entity.Entity, i *infrastructure.Infrastructure, output Info) (Info, error) {
+			OnSuccessReturn: func(c *api.Context, params request.Params, e entity.Entity, i *infrastructure.Infrastructure, output Info) (Info, error) {
 				if strutils.IsStringNotEmpty(output.Phone) {
 					decryptedPhone, err := encoding.AESDecrypt(output.Phone, simple.AESKey)
 					if err != nil {

convenient/domain/query_rule/rule/api.go

@@ -35,7 +35,7 @@ func (simple *Simple) Bind(binder *binding.Binder) {
 		entity_crud.WithDisableQuery[any](),
 		entity_crud.WithDisableGetByID[any](),
 		entity_crud.WithCreateCallbacks(&entity_crud.CreateCallbacks{
-			Before: func(c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
+			Before: func(c *api.Context, params request.Params, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
 				ruleEntity, err := domain.ToConcrete[*Entity](e)
 				if err != nil {
 					return err

convenient/entity_crud/service.go

@@ -32,42 +32,42 @@ 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)
 		}
 
 		if domain.HasField(e, entity.FieldCreateUserID) && domain.HasField(e, entity.FieldLastUpdateUserID) {
 			createUserID, err := domain.Field[string](e, entity.FieldCreateUserID)
 			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.SetField(e, entity.FieldLastUpdateUserID, createUserID)
 			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)
@@ -76,15 +76,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())
 	}
 }
 
@@ -102,32 +102,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)
 	}
 }
 
@@ -150,48 +150,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)
 	}
 }
 
@@ -248,9 +248,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{
@@ -261,18 +261,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]{
@@ -281,7 +281,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)
 	}
 }
 
@@ -303,12 +303,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{
@@ -320,21 +320,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)
 	}
 }
 
@@ -354,29 +354,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
 			}
@@ -390,7 +390,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
 			}
@@ -398,10 +398,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())
 	}
 }
 
@@ -419,18 +419,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
 			}
@@ -440,7 +440,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
 			}
@@ -448,10 +448,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)
 	}
 }
 
@@ -474,33 +474,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
 			}
@@ -510,7 +510,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
 			}
@@ -518,9 +518,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)
 }