修改bugg

convenient/domain/auth/permission/api.go

@@ -3,6 +3,11 @@ package permission
 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/domain"
+	"git.sxidc.com/go-framework/baize/framework/core/domain/entity"
+	"git.sxidc.com/go-framework/baize/framework/core/infrastructure"
+	"git.sxidc.com/go-framework/baize/framework/core/infrastructure/database"
 )
 
 // Simple Bind参数
@@ -23,5 +28,16 @@ func (simple *Simple) Bind(binder *binding.Binder) {
 		UpdateJsonBody:     &UpdatePermissionJsonBody{},
 		QueryQueryParams:   &GetPermissionsQueryParams{},
 		GetByIDQueryParams: &GetPermissionQueryParams{},
-	}, entity_crud.WithGlobalMiddlewares(simple.AuthMiddleware))
+	}, entity_crud.WithGlobalMiddlewares(simple.AuthMiddleware),
+		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 {
+				userInfo := c.GetUserInfo()
+				return domain.SetField(e, entity.FieldCreateUserID, userInfo.GetID())
+			},
+		}), entity_crud.WithUpdateCallbacks(&entity_crud.UpdateCallbacks{
+			Before: func(c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
+				userInfo := c.GetUserInfo()
+				return domain.SetField(e, entity.FieldLastUpdateUserID, userInfo.GetID())
+			},
+		}))
 }

convenient/domain/auth/permission/request_params.go

@@ -8,7 +8,6 @@ type (
 		Description string `json:"description" assign:"toField:Description"`
 		Resource    string `json:"resource" binding:"required" assign:"toField:Resource"`
 		Action      string `json:"action" binding:"required" assign:"toField:Action"`
-		request.CreateUserIDJsonBody
 	}
 
 	DeletePermissionQueryParams struct {
@@ -21,7 +20,6 @@ type (
 		Description string `json:"description" assign:"toField:Description"`
 		Resource    string `json:"resource" assign:"toField:Resource"`
 		Action      string `json:"action" assign:"toField:Action"`
-		request.UpdateUserIDJsonBody
 	}
 
 	GetPermissionsQueryParams struct {

convenient/domain/auth/permission_group/api.go

@@ -3,6 +3,11 @@ package permission_group
 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/domain"
+	"git.sxidc.com/go-framework/baize/framework/core/domain/entity"
+	"git.sxidc.com/go-framework/baize/framework/core/infrastructure"
+	"git.sxidc.com/go-framework/baize/framework/core/infrastructure/database"
 )
 
 // Simple Bind参数
@@ -23,5 +28,16 @@ func (simple *Simple) Bind(binder *binding.Binder) {
 		UpdateJsonBody:     &UpdatePermissionGroupJsonBody{},
 		QueryQueryParams:   &GetPermissionGroupsQueryParams{},
 		GetByIDQueryParams: &GetPermissionGroupQueryParams{},
-	}, entity_crud.WithGlobalMiddlewares(simple.AuthMiddleware))
+	}, entity_crud.WithGlobalMiddlewares(simple.AuthMiddleware),
+		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 {
+				userInfo := c.GetUserInfo()
+				return domain.SetField(e, entity.FieldCreateUserID, userInfo.GetID())
+			},
+		}), entity_crud.WithUpdateCallbacks(&entity_crud.UpdateCallbacks{
+			Before: func(c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
+				userInfo := c.GetUserInfo()
+				return domain.SetField(e, entity.FieldLastUpdateUserID, userInfo.GetID())
+			},
+		}))
 }

convenient/domain/auth/permission_group/request_params.go

@@ -6,7 +6,6 @@ type (
 	CreatePermissionGroupJsonBody struct {
 		Name        string `json:"name" binding:"required" assign:"toField:Name"`
 		Description string `json:"description" assign:"toField:Description"`
-		request.CreateUserIDJsonBody
 	}
 
 	DeletePermissionGroupQueryParams struct {
@@ -17,7 +16,6 @@ type (
 		request.IDJsonBody
 		Name        string `json:"name" assign:"toField:Name"`
 		Description string `json:"description" assign:"toField:Description"`
-		request.UpdateUserIDJsonBody
 	}
 
 	GetPermissionGroupsQueryParams struct {

convenient/domain/auth/role/api.go

@@ -3,6 +3,11 @@ package role
 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/domain"
+	"git.sxidc.com/go-framework/baize/framework/core/domain/entity"
+	"git.sxidc.com/go-framework/baize/framework/core/infrastructure"
+	"git.sxidc.com/go-framework/baize/framework/core/infrastructure/database"
 )
 
 // Simple Bind参数
@@ -23,5 +28,16 @@ func (simple *Simple) Bind(binder *binding.Binder) {
 		UpdateJsonBody:     &UpdateRoleJsonBody{},
 		QueryQueryParams:   &GetRolesQueryParams{},
 		GetByIDQueryParams: &GetRoleQueryParams{},
-	}, entity_crud.WithGlobalMiddlewares(simple.AuthMiddleware))
+	}, entity_crud.WithGlobalMiddlewares(simple.AuthMiddleware),
+		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 {
+				userInfo := c.GetUserInfo()
+				return domain.SetField(e, entity.FieldCreateUserID, userInfo.GetID())
+			},
+		}), entity_crud.WithUpdateCallbacks(&entity_crud.UpdateCallbacks{
+			Before: func(c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
+				userInfo := c.GetUserInfo()
+				return domain.SetField(e, entity.FieldLastUpdateUserID, userInfo.GetID())
+			},
+		}))
 }

convenient/domain/auth/role/request_params.go

@@ -6,7 +6,6 @@ type (
 	CreateRoleJsonBody struct {
 		Name        string `json:"name" binding:"required" assign:"toField:Name"`
 		Description string `json:"description" assign:"toField:Description"`
-		request.CreateUserIDJsonBody
 	}
 
 	DeleteRoleQueryParams struct {
@@ -17,7 +16,6 @@ type (
 		request.IDJsonBody
 		Name        string `json:"name" assign:"toField:Name"`
 		Description string `json:"description" assign:"toField:Description"`
-		request.UpdateUserIDJsonBody
 	}
 
 	GetRolesQueryParams struct {

convenient/domain/auth/user/api.go

@@ -3,6 +3,7 @@ package user
 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/response"
 	"git.sxidc.com/go-framework/baize/framework/core/domain"
 	"git.sxidc.com/go-framework/baize/framework/core/domain/entity"
@@ -38,7 +39,7 @@ func (simple *Simple) Bind(binder *binding.Binder) {
 		GetByIDQueryParams: &GetUserQueryParams{},
 	}, entity_crud.WithGlobalMiddlewares(simple.AuthMiddleware),
 		entity_crud.WithCreateCallbacks(&entity_crud.CreateCallbacks{
-			Before: func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
+			Before: func(c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
 				userEntity, err := domain.ToConcrete[*Entity](e)
 				if err != nil {
 					return err
@@ -94,7 +95,7 @@ func (simple *Simple) Bind(binder *binding.Binder) {
 				return nil
 			},
 		}), entity_crud.WithUpdateCallbacks(&entity_crud.UpdateCallbacks{
-			Before: func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
+			Before: func(c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
 				userEntity, err := domain.ToConcrete[*Entity](e)
 				if err != nil {
 					return err
@@ -227,7 +228,7 @@ func (simple *Simple) Bind(binder *binding.Binder) {
 				return false, nil
 			}
 		}), entity_crud.WithQueryCallbacks(&entity_crud.QueryCallbacks[Info]{
-			OnSuccessReturn: func(e entity.Entity, i *infrastructure.Infrastructure, output response.InfosData[Info]) (response.InfosData[Info], error) {
+			OnSuccessReturn: func(c *api.Context, e entity.Entity, i *infrastructure.Infrastructure, output response.InfosData[Info]) (response.InfosData[Info], error) {
 				errResponse := response.InfosData[Info]{
 					Infos: make([]Info, 0),
 				}
@@ -264,7 +265,7 @@ func (simple *Simple) Bind(binder *binding.Binder) {
 				}, nil
 			},
 		}), entity_crud.WithGetByIDCallbacks(&entity_crud.GetByIDCallbacks[Info]{
-			OnSuccessReturn: func(e entity.Entity, i *infrastructure.Infrastructure, output Info) (Info, error) {
+			OnSuccessReturn: func(c *api.Context, 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/entity_crud/service.go

@@ -32,22 +32,22 @@ func Create(tableName string, callbacks *CreateCallbacks) binding.ServiceFunc[st
 
 		err := e.GenerateID()
 		if err != nil {
-			return callbackOnCreateErrorReturn(callbacks, e, make(map[string]any), err, i)
+			return callbackOnCreateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
 		}
 
 		err = e.ForCreate()
 		if err != nil {
-			return callbackOnCreateErrorReturn(callbacks, e, make(map[string]any), err, i)
+			return callbackOnCreateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
 		}
 
-		prepared, err := callbackPrepareCreate(callbacks, e, i)
+		prepared, err := callbackPrepareCreate(callbacks, c, e, i)
 		if err != nil {
-			return callbackOnCreateErrorReturn(callbacks, e, make(map[string]any), err, i)
+			return callbackOnCreateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
 		}
 
-		err = callbackBeforeCreate(callbacks, e, prepared, i, nil)
+		err = callbackBeforeCreate(callbacks, c, e, prepared, i, nil)
 		if err != nil {
-			return callbackOnCreateErrorReturn(callbacks, e, prepared, err, i)
+			return callbackOnCreateErrorReturn(callbacks, c, e, prepared, err, i)
 		}
 
 		err = database.InsertEntity(dbExecutor, tableName, e)
@@ -56,15 +56,15 @@ func Create(tableName string, callbacks *CreateCallbacks) binding.ServiceFunc[st
 				err = errors.New(e.DomainCNName() + "已存在")
 			}
 
-			return callbackOnCreateErrorReturn(callbacks, e, prepared, err, i)
+			return callbackOnCreateErrorReturn(callbacks, c, e, prepared, err, i)
 		}
 
-		err = callbackAfterCreate(callbacks, e, prepared, i, nil)
+		err = callbackAfterCreate(callbacks, c, e, prepared, i, nil)
 		if err != nil {
-			return callbackOnCreateErrorReturn(callbacks, e, prepared, err, i)
+			return callbackOnCreateErrorReturn(callbacks, c, e, prepared, err, i)
 		}
 
-		return callbackOnCreateSuccessReturn(callbacks, e, prepared, i, e.GetID())
+		return callbackOnCreateSuccessReturn(callbacks, c, e, prepared, i, e.GetID())
 	}
 }
 
@@ -84,30 +84,30 @@ func Delete(tableName string, callbacks *DeleteCallbacks) binding.ServiceFunc[an
 
 		err := e.ForDelete()
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, e, make(map[string]any), err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, e, make(map[string]any), err, i)
 		}
 
-		prepared, err := callbackPrepareDelete(callbacks, e, i)
+		prepared, err := callbackPrepareDelete(callbacks, c, e, i)
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, e, make(map[string]any), err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, e, make(map[string]any), err, i)
 		}
 
-		err = callbackBeforeDelete(callbacks, e, prepared, i, nil)
+		err = callbackBeforeDelete(callbacks, c, e, prepared, i, nil)
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, e, prepared, err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, e, prepared, err, i)
 		}
 
 		err = database.DeleteEntity(dbExecutor, tableName, e)
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, e, prepared, err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, e, prepared, err, i)
 		}
 
-		err = callbackAfterDelete(callbacks, e, prepared, i, nil)
+		err = callbackAfterDelete(callbacks, c, e, prepared, i, nil)
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, e, prepared, err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, e, prepared, err, i)
 		}
 
-		return nil, callbackOnDeleteSuccessReturn(callbacks, e, prepared, i)
+		return nil, callbackOnDeleteSuccessReturn(callbacks, c, e, prepared, i)
 	}
 }
 
@@ -127,7 +127,7 @@ func Update(tableName string, callbacks *UpdateCallbacks) binding.ServiceFunc[an
 
 		err := e.ForUpdate()
 		if err != nil {
-			return nil, callbackOnUpdateErrorReturn(callbacks, e, make(map[string]any), err, i)
+			return nil, callbackOnUpdateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
 		}
 
 		exist, err := database.CheckExist(dbExecutor, &sql.CheckExistExecuteParams{
@@ -135,35 +135,35 @@ func Update(tableName string, callbacks *UpdateCallbacks) binding.ServiceFunc[an
 			Conditions: sql.NewConditions().Equal(entity.ColumnID, e.GetID()),
 		})
 		if err != nil {
-			return nil, callbackOnUpdateErrorReturn(callbacks, e, make(map[string]any), err, i)
+			return nil, callbackOnUpdateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
 		}
 
 		if !exist {
 			err := errors.New(e.DomainCNName() + "不存在")
-			return nil, callbackOnUpdateErrorReturn(callbacks, e, make(map[string]any), err, i)
+			return nil, callbackOnUpdateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
 		}
 
-		prepared, err := callbackPrepareUpdate(callbacks, e, i)
+		prepared, err := callbackPrepareUpdate(callbacks, c, e, i)
 		if err != nil {
-			return nil, callbackOnUpdateErrorReturn(callbacks, e, make(map[string]any), err, i)
+			return nil, callbackOnUpdateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
 		}
 
-		err = callbackBeforeUpdate(callbacks, e, prepared, i, nil)
+		err = callbackBeforeUpdate(callbacks, c, e, prepared, i, nil)
 		if err != nil {
-			return nil, callbackOnUpdateErrorReturn(callbacks, e, prepared, err, i)
+			return nil, callbackOnUpdateErrorReturn(callbacks, c, e, prepared, err, i)
 		}
 
 		err = database.UpdateEntity(dbExecutor, tableName, e)
 		if err != nil {
-			return nil, callbackOnUpdateErrorReturn(callbacks, e, prepared, err, i)
+			return nil, callbackOnUpdateErrorReturn(callbacks, c, e, prepared, err, i)
 		}
 
-		err = callbackAfterUpdate(callbacks, e, prepared, i, nil)
+		err = callbackAfterUpdate(callbacks, c, e, prepared, i, nil)
 		if err != nil {
-			return nil, callbackOnUpdateErrorReturn(callbacks, e, prepared, err, i)
+			return nil, callbackOnUpdateErrorReturn(callbacks, c, e, prepared, err, i)
 		}
 
-		return nil, callbackOnUpdateSuccessReturn(callbacks, e, prepared, i)
+		return nil, callbackOnUpdateSuccessReturn(callbacks, c, e, prepared, i)
 	}
 }
 
@@ -220,9 +220,9 @@ func Query[O any](tableName string, callbacks *QueryCallbacks[O], conditionField
 			}
 		}
 
-		err = callbackBeforeQuery(callbacks, e, i)
+		err = callbackBeforeQuery(callbacks, c, e, i)
 		if err != nil {
-			return callbackOnQueryErrorReturn(callbacks, e, err, i)
+			return callbackOnQueryErrorReturn(callbacks, c, e, err, i)
 		}
 
 		results, totalCount, err := database.Query(dbExecutor, &sql.QueryExecuteParams{
@@ -232,18 +232,18 @@ func Query[O any](tableName string, callbacks *QueryCallbacks[O], conditionField
 			PageSize:   queryParams.GetPageSize(),
 		})
 		if err != nil {
-			return callbackOnQueryErrorReturn(callbacks, e, err, i)
+			return callbackOnQueryErrorReturn(callbacks, c, e, err, i)
 		}
 
-		err = callbackAfterQuery(callbacks, e, i)
+		err = callbackAfterQuery(callbacks, c, e, i)
 		if err != nil {
-			return callbackOnQueryErrorReturn(callbacks, e, err, i)
+			return callbackOnQueryErrorReturn(callbacks, c, e, err, i)
 		}
 
 		infos := make([]O, 0)
 		err = sql.ParseSqlResult(results, &infos)
 		if err != nil {
-			return callbackOnQueryErrorReturn(callbacks, e, err, i)
+			return callbackOnQueryErrorReturn(callbacks, c, e, err, i)
 		}
 
 		output := response.InfosData[O]{
@@ -252,7 +252,7 @@ func Query[O any](tableName string, callbacks *QueryCallbacks[O], conditionField
 			PageNo:     queryParams.GetPageNo(),
 		}
 
-		return callbackOnQuerySuccessReturn(callbacks, e, i, output)
+		return callbackOnQuerySuccessReturn(callbacks, c, e, i, output)
 	}
 }
 
@@ -274,12 +274,12 @@ func GetByID[O any](tableName string, callbacks *GetByIDCallbacks[O]) binding.Se
 
 		err := entity.CheckFieldID(e)
 		if err != nil {
-			return callbackOnGetByIDErrorReturn(callbacks, e, err, i)
+			return callbackOnGetByIDErrorReturn(callbacks, c, e, err, i)
 		}
 
-		err = callbackBeforeGetByID(callbacks, e, i)
+		err = callbackBeforeGetByID(callbacks, c, e, i)
 		if err != nil {
-			return callbackOnGetByIDErrorReturn(callbacks, e, err, i)
+			return callbackOnGetByIDErrorReturn(callbacks, c, e, err, i)
 		}
 
 		result, err := database.QueryOne(dbExecutor, &sql.QueryOneExecuteParams{
@@ -291,21 +291,21 @@ func GetByID[O any](tableName string, callbacks *GetByIDCallbacks[O]) binding.Se
 				err = errors.New(e.DomainCNName() + "不存在")
 			}
 
-			return callbackOnGetByIDErrorReturn(callbacks, e, err, i)
+			return callbackOnGetByIDErrorReturn(callbacks, c, e, err, i)
 		}
 
-		err = callbackAfterGetByID(callbacks, e, i)
+		err = callbackAfterGetByID(callbacks, c, e, i)
 		if err != nil {
-			return callbackOnGetByIDErrorReturn(callbacks, e, err, i)
+			return callbackOnGetByIDErrorReturn(callbacks, c, e, err, i)
 		}
 
 		info := reflectutils.Zero[O]()
 		err = sql.ParseSqlResult(result, &info)
 		if err != nil {
-			return callbackOnGetByIDErrorReturn(callbacks, e, err, i)
+			return callbackOnGetByIDErrorReturn(callbacks, c, e, err, i)
 		}
 
-		return callbackOnGetByIDSuccessReturn(callbacks, e, i, info)
+		return callbackOnGetByIDSuccessReturn(callbacks, c, e, i, info)
 	}
 }
 
@@ -325,21 +325,21 @@ func CreateTx(tableName string, callbacks *CreateCallbacks) binding.ServiceFunc[
 
 		err := e.GenerateID()
 		if err != nil {
-			return callbackOnCreateErrorReturn(callbacks, e, make(map[string]any), err, i)
+			return callbackOnCreateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
 		}
 
 		err = e.ForCreate()
 		if err != nil {
-			return callbackOnCreateErrorReturn(callbacks, e, make(map[string]any), err, i)
+			return callbackOnCreateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
 		}
 
-		prepared, err := callbackPrepareCreate(callbacks, e, i)
+		prepared, err := callbackPrepareCreate(callbacks, c, e, i)
 		if err != nil {
-			return callbackOnCreateErrorReturn(callbacks, e, make(map[string]any), err, i)
+			return callbackOnCreateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
 		}
 
 		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
-			err = callbackBeforeCreate(callbacks, e, prepared, i, tx)
+			err = callbackBeforeCreate(callbacks, c, e, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -353,7 +353,7 @@ func CreateTx(tableName string, callbacks *CreateCallbacks) binding.ServiceFunc[
 				return err
 			}
 
-			err = callbackAfterCreate(callbacks, e, prepared, i, tx)
+			err = callbackAfterCreate(callbacks, c, e, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -361,10 +361,10 @@ func CreateTx(tableName string, callbacks *CreateCallbacks) binding.ServiceFunc[
 			return nil
 		})
 		if err != nil {
-			return callbackOnCreateErrorReturn(callbacks, e, prepared, err, i)
+			return callbackOnCreateErrorReturn(callbacks, c, e, prepared, err, i)
 		}
 
-		return callbackOnCreateSuccessReturn(callbacks, e, prepared, i, e.GetID())
+		return callbackOnCreateSuccessReturn(callbacks, c, e, prepared, i, e.GetID())
 	}
 }
 
@@ -384,16 +384,16 @@ func DeleteTx(tableName string, callbacks *DeleteCallbacks) binding.ServiceFunc[
 
 		err := e.ForDelete()
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, e, make(map[string]any), err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, e, make(map[string]any), err, i)
 		}
 
-		prepared, err := callbackPrepareDelete(callbacks, e, i)
+		prepared, err := callbackPrepareDelete(callbacks, c, e, i)
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, e, make(map[string]any), err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, e, make(map[string]any), err, i)
 		}
 
 		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
-			err = callbackBeforeDelete(callbacks, e, prepared, i, tx)
+			err = callbackBeforeDelete(callbacks, c, e, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -403,7 +403,7 @@ func DeleteTx(tableName string, callbacks *DeleteCallbacks) binding.ServiceFunc[
 				return err
 			}
 
-			err = callbackAfterDelete(callbacks, e, prepared, i, tx)
+			err = callbackAfterDelete(callbacks, c, e, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -411,10 +411,10 @@ func DeleteTx(tableName string, callbacks *DeleteCallbacks) binding.ServiceFunc[
 			return nil
 		})
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, e, prepared, err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, e, prepared, err, i)
 		}
 
-		return nil, callbackOnDeleteSuccessReturn(callbacks, e, prepared, i)
+		return nil, callbackOnDeleteSuccessReturn(callbacks, c, e, prepared, i)
 	}
 }
 
@@ -434,7 +434,7 @@ func UpdateTx(tableName string, callbacks *UpdateCallbacks) binding.ServiceFunc[
 
 		err := e.ForUpdate()
 		if err != nil {
-			return nil, callbackOnUpdateErrorReturn(callbacks, e, make(map[string]any), err, i)
+			return nil, callbackOnUpdateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
 		}
 
 		exist, err := database.CheckExist(dbExecutor, &sql.CheckExistExecuteParams{
@@ -442,20 +442,20 @@ func UpdateTx(tableName string, callbacks *UpdateCallbacks) binding.ServiceFunc[
 			Conditions: sql.NewConditions().Equal(entity.ColumnID, e.GetID()),
 		})
 		if err != nil {
-			return nil, callbackOnUpdateErrorReturn(callbacks, e, make(map[string]any), err, i)
+			return nil, callbackOnUpdateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
 		}
 
 		if !exist {
-			return nil, callbackOnUpdateErrorReturn(callbacks, e, make(map[string]any), errors.New(e.DomainCNName()+"不存在"), i)
+			return nil, callbackOnUpdateErrorReturn(callbacks, c, e, make(map[string]any), errors.New(e.DomainCNName()+"不存在"), i)
 		}
 
-		prepared, err := callbackPrepareUpdate(callbacks, e, i)
+		prepared, err := callbackPrepareUpdate(callbacks, c, e, i)
 		if err != nil {
-			return nil, callbackOnUpdateErrorReturn(callbacks, e, make(map[string]any), err, i)
+			return nil, callbackOnUpdateErrorReturn(callbacks, c, e, make(map[string]any), err, i)
 		}
 
 		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
-			err = callbackBeforeUpdate(callbacks, e, prepared, i, tx)
+			err = callbackBeforeUpdate(callbacks, c, e, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -465,7 +465,7 @@ func UpdateTx(tableName string, callbacks *UpdateCallbacks) binding.ServiceFunc[
 				return err
 			}
 
-			err = callbackAfterUpdate(callbacks, e, prepared, i, tx)
+			err = callbackAfterUpdate(callbacks, c, e, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -473,9 +473,9 @@ func UpdateTx(tableName string, callbacks *UpdateCallbacks) binding.ServiceFunc[
 			return nil
 		})
 		if err != nil {
-			return nil, callbackOnUpdateErrorReturn(callbacks, e, prepared, err, i)
+			return nil, callbackOnUpdateErrorReturn(callbacks, c, e, prepared, err, i)
 		}
 
-		return nil, callbackOnUpdateSuccessReturn(callbacks, e, prepared, i)
+		return nil, callbackOnUpdateSuccessReturn(callbacks, c, e, prepared, i)
 	}
 }

convenient/entity_crud/service_callbacks.go

@@ -1,6 +1,7 @@
 package entity_crud
 
 import (
+	"git.sxidc.com/go-framework/baize/framework/core/api"
 	"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"
@@ -9,14 +10,14 @@ import (
 )
 
 type CreateCallbacks struct {
-	Prepare         func(e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error)
-	Before          func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
-	After           func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
-	OnSuccessReturn func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, id string) (string, error)
-	OnErrorReturn   func(e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) (string, error)
+	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)
 }
 
-func callbackPrepareCreate(callbacks *CreateCallbacks, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error) {
+func callbackPrepareCreate(callbacks *CreateCallbacks, c *api.Context, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error) {
 	if callbacks == nil {
 		return make(map[string]any), nil
 	}
@@ -25,10 +26,10 @@ func callbackPrepareCreate(callbacks *CreateCallbacks, e entity.Entity, i *infra
 		return make(map[string]any), nil
 	}
 
-	return callbacks.Prepare(e, i)
+	return callbacks.Prepare(c, e, i)
 }
 
-func callbackBeforeCreate(callbacks *CreateCallbacks, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
+func callbackBeforeCreate(callbacks *CreateCallbacks, c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -37,10 +38,10 @@ func callbackBeforeCreate(callbacks *CreateCallbacks, e entity.Entity, prepared
 		return nil
 	}
 
-	return callbacks.Before(e, prepared, i, tx)
+	return callbacks.Before(c, e, prepared, i, tx)
 }
 
-func callbackAfterCreate(callbacks *CreateCallbacks, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, dbExecutor database.Executor) error {
+func callbackAfterCreate(callbacks *CreateCallbacks, c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, dbExecutor database.Executor) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -49,10 +50,10 @@ func callbackAfterCreate(callbacks *CreateCallbacks, e entity.Entity, prepared m
 		return nil
 	}
 
-	return callbacks.After(e, prepared, i, dbExecutor)
+	return callbacks.After(c, e, prepared, i, dbExecutor)
 }
 
-func callbackOnCreateSuccessReturn(callbacks *CreateCallbacks, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, id string) (string, error) {
+func callbackOnCreateSuccessReturn(callbacks *CreateCallbacks, c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, id string) (string, error) {
 	if callbacks == nil {
 		return id, nil
 	}
@@ -61,10 +62,10 @@ func callbackOnCreateSuccessReturn(callbacks *CreateCallbacks, e entity.Entity,
 		return id, nil
 	}
 
-	return callbacks.OnSuccessReturn(e, prepared, i, id)
+	return callbacks.OnSuccessReturn(c, e, prepared, i, id)
 }
 
-func callbackOnCreateErrorReturn(callbacks *CreateCallbacks, e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) (string, error) {
+func callbackOnCreateErrorReturn(callbacks *CreateCallbacks, c *api.Context, e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) (string, error) {
 	if callbacks == nil {
 		return "", err
 	}
@@ -73,18 +74,18 @@ func callbackOnCreateErrorReturn(callbacks *CreateCallbacks, e entity.Entity, pr
 		return "", err
 	}
 
-	return callbacks.OnErrorReturn(e, prepared, err, i)
+	return callbacks.OnErrorReturn(c, e, prepared, err, i)
 }
 
 type DeleteCallbacks struct {
-	Prepare         func(e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error)
-	Before          func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
-	After           func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
-	OnSuccessReturn func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure) error
-	OnErrorReturn   func(e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) error
+	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
 }
 
-func callbackPrepareDelete(callbacks *DeleteCallbacks, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error) {
+func callbackPrepareDelete(callbacks *DeleteCallbacks, c *api.Context, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error) {
 	if callbacks == nil {
 		return make(map[string]any), nil
 	}
@@ -93,10 +94,10 @@ func callbackPrepareDelete(callbacks *DeleteCallbacks, e entity.Entity, i *infra
 		return make(map[string]any), nil
 	}
 
-	return callbacks.Prepare(e, i)
+	return callbacks.Prepare(c, e, i)
 }
 
-func callbackBeforeDelete(callbacks *DeleteCallbacks, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
+func callbackBeforeDelete(callbacks *DeleteCallbacks, c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -105,10 +106,10 @@ func callbackBeforeDelete(callbacks *DeleteCallbacks, e entity.Entity, prepared
 		return nil
 	}
 
-	return callbacks.Before(e, prepared, i, tx)
+	return callbacks.Before(c, e, prepared, i, tx)
 }
 
-func callbackAfterDelete(callbacks *DeleteCallbacks, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, dbExecutor database.Executor) error {
+func callbackAfterDelete(callbacks *DeleteCallbacks, c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, dbExecutor database.Executor) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -117,10 +118,10 @@ func callbackAfterDelete(callbacks *DeleteCallbacks, e entity.Entity, prepared m
 		return nil
 	}
 
-	return callbacks.After(e, prepared, i, dbExecutor)
+	return callbacks.After(c, e, prepared, i, dbExecutor)
 }
 
-func callbackOnDeleteSuccessReturn(callbacks *DeleteCallbacks, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure) error {
+func callbackOnDeleteSuccessReturn(callbacks *DeleteCallbacks, c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -129,10 +130,10 @@ func callbackOnDeleteSuccessReturn(callbacks *DeleteCallbacks, e entity.Entity,
 		return nil
 	}
 
-	return callbacks.OnSuccessReturn(e, prepared, i)
+	return callbacks.OnSuccessReturn(c, e, prepared, i)
 }
 
-func callbackOnDeleteErrorReturn(callbacks *DeleteCallbacks, e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) error {
+func callbackOnDeleteErrorReturn(callbacks *DeleteCallbacks, c *api.Context, e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return err
 	}
@@ -141,18 +142,18 @@ func callbackOnDeleteErrorReturn(callbacks *DeleteCallbacks, e entity.Entity, pr
 		return err
 	}
 
-	return callbacks.OnErrorReturn(e, prepared, err, i)
+	return callbacks.OnErrorReturn(c, e, prepared, err, i)
 }
 
 type UpdateCallbacks struct {
-	Prepare         func(e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error)
-	Before          func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
-	After           func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
-	OnSuccessReturn func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure) error
-	OnErrorReturn   func(e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) error
+	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
 }
 
-func callbackPrepareUpdate(callbacks *UpdateCallbacks, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error) {
+func callbackPrepareUpdate(callbacks *UpdateCallbacks, c *api.Context, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error) {
 	if callbacks == nil {
 		return make(map[string]any), nil
 	}
@@ -161,10 +162,10 @@ func callbackPrepareUpdate(callbacks *UpdateCallbacks, e entity.Entity, i *infra
 		return make(map[string]any), nil
 	}
 
-	return callbacks.Prepare(e, i)
+	return callbacks.Prepare(c, e, i)
 }
 
-func callbackBeforeUpdate(callbacks *UpdateCallbacks, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
+func callbackBeforeUpdate(callbacks *UpdateCallbacks, c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -173,10 +174,10 @@ func callbackBeforeUpdate(callbacks *UpdateCallbacks, e entity.Entity, prepared
 		return nil
 	}
 
-	return callbacks.Before(e, prepared, i, tx)
+	return callbacks.Before(c, e, prepared, i, tx)
 }
 
-func callbackAfterUpdate(callbacks *UpdateCallbacks, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, dbExecutor database.Executor) error {
+func callbackAfterUpdate(callbacks *UpdateCallbacks, c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, dbExecutor database.Executor) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -185,10 +186,10 @@ func callbackAfterUpdate(callbacks *UpdateCallbacks, e entity.Entity, prepared m
 		return nil
 	}
 
-	return callbacks.After(e, prepared, i, dbExecutor)
+	return callbacks.After(c, e, prepared, i, dbExecutor)
 }
 
-func callbackOnUpdateSuccessReturn(callbacks *UpdateCallbacks, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure) error {
+func callbackOnUpdateSuccessReturn(callbacks *UpdateCallbacks, c *api.Context, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -197,10 +198,10 @@ func callbackOnUpdateSuccessReturn(callbacks *UpdateCallbacks, e entity.Entity,
 		return nil
 	}
 
-	return callbacks.OnSuccessReturn(e, prepared, i)
+	return callbacks.OnSuccessReturn(c, e, prepared, i)
 }
 
-func callbackOnUpdateErrorReturn(callbacks *UpdateCallbacks, e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) error {
+func callbackOnUpdateErrorReturn(callbacks *UpdateCallbacks, c *api.Context, e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return err
 	}
@@ -209,17 +210,17 @@ func callbackOnUpdateErrorReturn(callbacks *UpdateCallbacks, e entity.Entity, pr
 		return err
 	}
 
-	return callbacks.OnErrorReturn(e, prepared, err, i)
+	return callbacks.OnErrorReturn(c, e, prepared, err, i)
 }
 
 type QueryCallbacks[O any] struct {
-	Before          func(e entity.Entity, i *infrastructure.Infrastructure) error
-	After           func(e entity.Entity, i *infrastructure.Infrastructure) error
-	OnSuccessReturn func(e entity.Entity, i *infrastructure.Infrastructure, output response.InfosData[O]) (response.InfosData[O], error)
-	OnErrorReturn   func(e entity.Entity, err error, i *infrastructure.Infrastructure) (response.InfosData[O], error)
+	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)
 }
 
-func callbackBeforeQuery[O any](callbacks *QueryCallbacks[O], e entity.Entity, i *infrastructure.Infrastructure) error {
+func callbackBeforeQuery[O any](callbacks *QueryCallbacks[O], c *api.Context, e entity.Entity, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -228,10 +229,10 @@ func callbackBeforeQuery[O any](callbacks *QueryCallbacks[O], e entity.Entity, i
 		return nil
 	}
 
-	return callbacks.Before(e, i)
+	return callbacks.Before(c, e, i)
 }
 
-func callbackAfterQuery[O any](callbacks *QueryCallbacks[O], e entity.Entity, i *infrastructure.Infrastructure) error {
+func callbackAfterQuery[O any](callbacks *QueryCallbacks[O], c *api.Context, e entity.Entity, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -240,10 +241,10 @@ func callbackAfterQuery[O any](callbacks *QueryCallbacks[O], e entity.Entity, i
 		return nil
 	}
 
-	return callbacks.After(e, i)
+	return callbacks.After(c, e, i)
 }
 
-func callbackOnQuerySuccessReturn[O any](callbacks *QueryCallbacks[O], e entity.Entity, i *infrastructure.Infrastructure, output response.InfosData[O]) (response.InfosData[O], error) {
+func callbackOnQuerySuccessReturn[O any](callbacks *QueryCallbacks[O], c *api.Context, e entity.Entity, i *infrastructure.Infrastructure, output response.InfosData[O]) (response.InfosData[O], error) {
 	if callbacks == nil {
 		return output, nil
 	}
@@ -252,10 +253,10 @@ func callbackOnQuerySuccessReturn[O any](callbacks *QueryCallbacks[O], e entity.
 		return output, nil
 	}
 
-	return callbacks.OnSuccessReturn(e, i, output)
+	return callbacks.OnSuccessReturn(c, e, i, output)
 }
 
-func callbackOnQueryErrorReturn[O any](callbacks *QueryCallbacks[O], e entity.Entity, err error, i *infrastructure.Infrastructure) (response.InfosData[O], error) {
+func callbackOnQueryErrorReturn[O any](callbacks *QueryCallbacks[O], c *api.Context, e entity.Entity, err error, i *infrastructure.Infrastructure) (response.InfosData[O], error) {
 	if callbacks == nil {
 		return response.InfosData[O]{
 			Infos: make([]O, 0),
@@ -268,17 +269,17 @@ func callbackOnQueryErrorReturn[O any](callbacks *QueryCallbacks[O], e entity.En
 		}, err
 	}
 
-	return callbacks.OnErrorReturn(e, err, i)
+	return callbacks.OnErrorReturn(c, e, err, i)
 }
 
 type GetByIDCallbacks[O any] struct {
-	Before          func(e entity.Entity, i *infrastructure.Infrastructure) error
-	After           func(e entity.Entity, i *infrastructure.Infrastructure) error
-	OnSuccessReturn func(e entity.Entity, i *infrastructure.Infrastructure, output O) (O, error)
-	OnErrorReturn   func(e entity.Entity, err error, i *infrastructure.Infrastructure) (O, error)
+	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)
 }
 
-func callbackBeforeGetByID[O any](callbacks *GetByIDCallbacks[O], e entity.Entity, i *infrastructure.Infrastructure) error {
+func callbackBeforeGetByID[O any](callbacks *GetByIDCallbacks[O], c *api.Context, e entity.Entity, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -287,10 +288,10 @@ func callbackBeforeGetByID[O any](callbacks *GetByIDCallbacks[O], e entity.Entit
 		return nil
 	}
 
-	return callbacks.Before(e, i)
+	return callbacks.Before(c, e, i)
 }
 
-func callbackAfterGetByID[O any](callbacks *GetByIDCallbacks[O], e entity.Entity, i *infrastructure.Infrastructure) error {
+func callbackAfterGetByID[O any](callbacks *GetByIDCallbacks[O], c *api.Context, e entity.Entity, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -299,10 +300,10 @@ func callbackAfterGetByID[O any](callbacks *GetByIDCallbacks[O], e entity.Entity
 		return nil
 	}
 
-	return callbacks.After(e, i)
+	return callbacks.After(c, e, i)
 }
 
-func callbackOnGetByIDSuccessReturn[O any](callbacks *GetByIDCallbacks[O], e entity.Entity, i *infrastructure.Infrastructure, output O) (O, error) {
+func callbackOnGetByIDSuccessReturn[O any](callbacks *GetByIDCallbacks[O], c *api.Context, e entity.Entity, i *infrastructure.Infrastructure, output O) (O, error) {
 	if callbacks == nil {
 		return output, nil
 	}
@@ -311,10 +312,10 @@ func callbackOnGetByIDSuccessReturn[O any](callbacks *GetByIDCallbacks[O], e ent
 		return output, nil
 	}
 
-	return callbacks.OnSuccessReturn(e, i, output)
+	return callbacks.OnSuccessReturn(c, e, i, output)
 }
 
-func callbackOnGetByIDErrorReturn[O any](callbacks *GetByIDCallbacks[O], e entity.Entity, err error, i *infrastructure.Infrastructure) (O, error) {
+func callbackOnGetByIDErrorReturn[O any](callbacks *GetByIDCallbacks[O], c *api.Context, e entity.Entity, err error, i *infrastructure.Infrastructure) (O, error) {
 	if callbacks == nil {
 		return reflectutils.Zero[O](), err
 	}
@@ -323,5 +324,5 @@ func callbackOnGetByIDErrorReturn[O any](callbacks *GetByIDCallbacks[O], e entit
 		return reflectutils.Zero[O](), err
 	}
 
-	return callbacks.OnErrorReturn(e, err, i)
+	return callbacks.OnErrorReturn(c, e, err, i)
 }

convenient/value_object_crud/service.go

@@ -31,17 +31,17 @@ func Create(tableName string, callbacks *CreateCallbacks) binding.ServiceFunc[an
 
 		err := valueObject.ForCreate()
 		if err != nil {
-			return nil, callbackOnCreateErrorReturn(callbacks, valueObject, make(map[string]any), err, i)
+			return nil, callbackOnCreateErrorReturn(callbacks, c, valueObject, make(map[string]any), err, i)
 		}
 
-		prepared, err := callbackPrepareCreate(callbacks, valueObject, i)
+		prepared, err := callbackPrepareCreate(callbacks, c, valueObject, i)
 		if err != nil {
-			return nil, callbackOnCreateErrorReturn(callbacks, valueObject, make(map[string]any), err, i)
+			return nil, callbackOnCreateErrorReturn(callbacks, c, valueObject, make(map[string]any), err, i)
 		}
 
-		err = callbackBeforeCreate(callbacks, valueObject, prepared, i, nil)
+		err = callbackBeforeCreate(callbacks, c, valueObject, prepared, i, nil)
 		if err != nil {
-			return nil, callbackOnCreateErrorReturn(callbacks, valueObject, prepared, err, i)
+			return nil, callbackOnCreateErrorReturn(callbacks, c, 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, valueObject, prepared, err, i)
+			return nil, callbackOnCreateErrorReturn(callbacks, c, valueObject, prepared, err, i)
 		}
 
-		err = callbackAfterCreate(callbacks, valueObject, prepared, i, nil)
+		err = callbackAfterCreate(callbacks, c, valueObject, prepared, i, nil)
 		if err != nil {
-			return nil, callbackOnCreateErrorReturn(callbacks, valueObject, prepared, err, i)
+			return nil, callbackOnCreateErrorReturn(callbacks, c, valueObject, prepared, err, i)
 		}
 
-		return nil, callbackOnCreateSuccessReturn(callbacks, valueObject, prepared, i)
+		return nil, callbackOnCreateSuccessReturn(callbacks, c, valueObject, prepared, i)
 	}
 }
 
@@ -78,30 +78,30 @@ func Delete(tableName string, callbacks *DeleteCallbacks) binding.ServiceFunc[an
 
 		err := valueObject.CheckKeyFields()
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, valueObject, make(map[string]any), err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, valueObject, make(map[string]any), err, i)
 		}
 
-		prepared, err := callbackPrepareDelete(callbacks, valueObject, i)
+		prepared, err := callbackPrepareDelete(callbacks, c, valueObject, i)
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, valueObject, make(map[string]any), err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, valueObject, make(map[string]any), err, i)
 		}
 
-		err = callbackBeforeDelete(callbacks, valueObject, prepared, i, nil)
+		err = callbackBeforeDelete(callbacks, c, valueObject, prepared, i, nil)
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, valueObject, make(map[string]any), err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, valueObject, make(map[string]any), err, i)
 		}
 
 		err = database.DeleteEntity(dbExecutor, tableName, valueObject)
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, valueObject, make(map[string]any), err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, valueObject, make(map[string]any), err, i)
 		}
 
-		err = callbackAfterDelete(callbacks, valueObject, prepared, i, nil)
+		err = callbackAfterDelete(callbacks, c, valueObject, prepared, i, nil)
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, valueObject, make(map[string]any), err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, valueObject, make(map[string]any), err, i)
 		}
 
-		return nil, callbackOnDeleteSuccessReturn(callbacks, valueObject, prepared, i)
+		return nil, callbackOnDeleteSuccessReturn(callbacks, c, valueObject, prepared, i)
 	}
 }
 
@@ -158,9 +158,9 @@ func Query[O any](tableName string, callbacks *QueryCallbacks[O], conditionField
 			}
 		}
 
-		err = callbackBeforeQuery(callbacks, valueObject, i)
+		err = callbackBeforeQuery(callbacks, c, valueObject, i)
 		if err != nil {
-			return callbackOnQueryErrorReturn(callbacks, valueObject, err, i)
+			return callbackOnQueryErrorReturn(callbacks, c, valueObject, err, i)
 		}
 
 		results, totalCount, err := database.Query(dbExecutor, &sql.QueryExecuteParams{
@@ -170,18 +170,18 @@ func Query[O any](tableName string, callbacks *QueryCallbacks[O], conditionField
 			PageSize:   queryParams.GetPageSize(),
 		})
 		if err != nil {
-			return callbackOnQueryErrorReturn(callbacks, valueObject, err, i)
+			return callbackOnQueryErrorReturn(callbacks, c, valueObject, err, i)
 		}
 
-		err = callbackAfterQuery(callbacks, valueObject, i)
+		err = callbackAfterQuery(callbacks, c, valueObject, i)
 		if err != nil {
-			return callbackOnQueryErrorReturn(callbacks, valueObject, err, i)
+			return callbackOnQueryErrorReturn(callbacks, c, valueObject, err, i)
 		}
 
 		infos := make([]O, 0)
 		err = sql.ParseSqlResult(results, &infos)
 		if err != nil {
-			return callbackOnQueryErrorReturn(callbacks, valueObject, err, i)
+			return callbackOnQueryErrorReturn(callbacks, c, valueObject, err, i)
 		}
 
 		output := response.InfosData[O]{
@@ -190,7 +190,7 @@ func Query[O any](tableName string, callbacks *QueryCallbacks[O], conditionField
 			PageNo:     queryParams.GetPageNo(),
 		}
 
-		return callbackOnQuerySuccessReturn(callbacks, valueObject, i, output)
+		return callbackOnQuerySuccessReturn(callbacks, c, valueObject, i, output)
 	}
 }
 
@@ -208,13 +208,13 @@ func CreateTx(tableName string, callbacks *CreateCallbacks) binding.ServiceFunc[
 			return nil, errors.New("需要传递领域对象应该为值对象")
 		}
 
-		prepared, err := callbackPrepareCreate(callbacks, valueObject, i)
+		prepared, err := callbackPrepareCreate(callbacks, c, valueObject, i)
 		if err != nil {
-			return nil, callbackOnCreateErrorReturn(callbacks, valueObject, make(map[string]any), err, i)
+			return nil, callbackOnCreateErrorReturn(callbacks, c, valueObject, make(map[string]any), err, i)
 		}
 
 		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
-			err := callbackBeforeCreate(callbacks, valueObject, prepared, i, tx)
+			err := callbackBeforeCreate(callbacks, c, valueObject, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -228,7 +228,7 @@ func CreateTx(tableName string, callbacks *CreateCallbacks) binding.ServiceFunc[
 				return err
 			}
 
-			err = callbackAfterCreate(callbacks, valueObject, prepared, i, tx)
+			err = callbackAfterCreate(callbacks, c, valueObject, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -236,10 +236,10 @@ func CreateTx(tableName string, callbacks *CreateCallbacks) binding.ServiceFunc[
 			return nil
 		})
 		if err != nil {
-			return nil, callbackOnCreateErrorReturn(callbacks, valueObject, prepared, err, i)
+			return nil, callbackOnCreateErrorReturn(callbacks, c, valueObject, prepared, err, i)
 		}
 
-		return nil, callbackOnCreateSuccessReturn(callbacks, valueObject, prepared, i)
+		return nil, callbackOnCreateSuccessReturn(callbacks, c, valueObject, prepared, i)
 	}
 }
 
@@ -259,16 +259,16 @@ func DeleteTx(tableName string, callbacks *DeleteCallbacks) binding.ServiceFunc[
 
 		err := valueObject.CheckKeyFields()
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, valueObject, make(map[string]any), err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, valueObject, make(map[string]any), err, i)
 		}
 
-		prepared, err := callbackPrepareDelete(callbacks, valueObject, i)
+		prepared, err := callbackPrepareDelete(callbacks, c, valueObject, i)
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, valueObject, make(map[string]any), err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, valueObject, make(map[string]any), err, i)
 		}
 
 		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
-			err = callbackBeforeDelete(callbacks, valueObject, prepared, i, tx)
+			err = callbackBeforeDelete(callbacks, c, valueObject, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -278,7 +278,7 @@ func DeleteTx(tableName string, callbacks *DeleteCallbacks) binding.ServiceFunc[
 				return err
 			}
 
-			err = callbackAfterDelete(callbacks, valueObject, prepared, i, tx)
+			err = callbackAfterDelete(callbacks, c, valueObject, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -286,9 +286,9 @@ func DeleteTx(tableName string, callbacks *DeleteCallbacks) binding.ServiceFunc[
 			return nil
 		})
 		if err != nil {
-			return nil, callbackOnDeleteErrorReturn(callbacks, valueObject, prepared, err, i)
+			return nil, callbackOnDeleteErrorReturn(callbacks, c, valueObject, prepared, err, i)
 		}
 
-		return nil, callbackOnDeleteSuccessReturn(callbacks, valueObject, prepared, i)
+		return nil, callbackOnDeleteSuccessReturn(callbacks, c, valueObject, prepared, i)
 	}
 }

convenient/value_object_crud/service_callbacks.go

@@ -1,6 +1,7 @@
 package value_object_crud
 
 import (
+	"git.sxidc.com/go-framework/baize/framework/core/api"
 	"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"
@@ -8,14 +9,14 @@ import (
 )
 
 type CreateCallbacks struct {
-	Prepare         func(valueObject value_object.ValueObject, i *infrastructure.Infrastructure) (map[string]any, error)
-	Before          func(valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
-	After           func(valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
-	OnSuccessReturn func(valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure) error
-	OnErrorReturn   func(valueObject value_object.ValueObject, prepared map[string]any, err error, i *infrastructure.Infrastructure) error
+	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
 }
 
-func callbackPrepareCreate(callbacks *CreateCallbacks, valueObject value_object.ValueObject, i *infrastructure.Infrastructure) (map[string]any, error) {
+func callbackPrepareCreate(callbacks *CreateCallbacks, c *api.Context, valueObject value_object.ValueObject, i *infrastructure.Infrastructure) (map[string]any, error) {
 	if callbacks == nil {
 		return make(map[string]any), nil
 	}
@@ -24,10 +25,10 @@ func callbackPrepareCreate(callbacks *CreateCallbacks, valueObject value_object.
 		return make(map[string]any), nil
 	}
 
-	return callbacks.Prepare(valueObject, i)
+	return callbacks.Prepare(c, valueObject, i)
 }
 
-func callbackBeforeCreate(callbacks *CreateCallbacks, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
+func callbackBeforeCreate(callbacks *CreateCallbacks, c *api.Context, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -36,10 +37,10 @@ func callbackBeforeCreate(callbacks *CreateCallbacks, valueObject value_object.V
 		return nil
 	}
 
-	return callbacks.Before(valueObject, prepared, i, tx)
+	return callbacks.Before(c, valueObject, prepared, i, tx)
 }
 
-func callbackAfterCreate(callbacks *CreateCallbacks, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
+func callbackAfterCreate(callbacks *CreateCallbacks, c *api.Context, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -48,10 +49,10 @@ func callbackAfterCreate(callbacks *CreateCallbacks, valueObject value_object.Va
 		return nil
 	}
 
-	return callbacks.After(valueObject, prepared, i, tx)
+	return callbacks.After(c, valueObject, prepared, i, tx)
 }
 
-func callbackOnCreateSuccessReturn(callbacks *CreateCallbacks, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure) error {
+func callbackOnCreateSuccessReturn(callbacks *CreateCallbacks, c *api.Context, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -60,10 +61,10 @@ func callbackOnCreateSuccessReturn(callbacks *CreateCallbacks, valueObject value
 		return nil
 	}
 
-	return callbacks.OnSuccessReturn(valueObject, prepared, i)
+	return callbacks.OnSuccessReturn(c, valueObject, prepared, i)
 }
 
-func callbackOnCreateErrorReturn(callbacks *CreateCallbacks, valueObject value_object.ValueObject, prepared map[string]any, err error, i *infrastructure.Infrastructure) error {
+func callbackOnCreateErrorReturn(callbacks *CreateCallbacks, c *api.Context, valueObject value_object.ValueObject, prepared map[string]any, err error, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return err
 	}
@@ -72,18 +73,18 @@ func callbackOnCreateErrorReturn(callbacks *CreateCallbacks, valueObject value_o
 		return err
 	}
 
-	return callbacks.OnErrorReturn(valueObject, prepared, err, i)
+	return callbacks.OnErrorReturn(c, valueObject, prepared, err, i)
 }
 
 type DeleteCallbacks struct {
-	Prepare         func(valueObject value_object.ValueObject, i *infrastructure.Infrastructure) (map[string]any, error)
-	Before          func(valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
-	After           func(valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
-	OnSuccessReturn func(valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure) error
-	OnErrorReturn   func(valueObject value_object.ValueObject, prepared map[string]any, err error, i *infrastructure.Infrastructure) error
+	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
 }
 
-func callbackPrepareDelete(callbacks *DeleteCallbacks, valueObject value_object.ValueObject, i *infrastructure.Infrastructure) (map[string]any, error) {
+func callbackPrepareDelete(callbacks *DeleteCallbacks, c *api.Context, valueObject value_object.ValueObject, i *infrastructure.Infrastructure) (map[string]any, error) {
 	if callbacks == nil {
 		return make(map[string]any), nil
 	}
@@ -92,10 +93,10 @@ func callbackPrepareDelete(callbacks *DeleteCallbacks, valueObject value_object.
 		return make(map[string]any), nil
 	}
 
-	return callbacks.Prepare(valueObject, i)
+	return callbacks.Prepare(c, valueObject, i)
 }
 
-func callbackBeforeDelete(callbacks *DeleteCallbacks, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
+func callbackBeforeDelete(callbacks *DeleteCallbacks, c *api.Context, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -104,10 +105,10 @@ func callbackBeforeDelete(callbacks *DeleteCallbacks, valueObject value_object.V
 		return nil
 	}
 
-	return callbacks.Before(valueObject, prepared, i, tx)
+	return callbacks.Before(c, valueObject, prepared, i, tx)
 }
 
-func callbackAfterDelete(callbacks *DeleteCallbacks, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
+func callbackAfterDelete(callbacks *DeleteCallbacks, c *api.Context, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -116,10 +117,10 @@ func callbackAfterDelete(callbacks *DeleteCallbacks, valueObject value_object.Va
 		return nil
 	}
 
-	return callbacks.After(valueObject, prepared, i, tx)
+	return callbacks.After(c, valueObject, prepared, i, tx)
 }
 
-func callbackOnDeleteSuccessReturn(callbacks *DeleteCallbacks, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure) error {
+func callbackOnDeleteSuccessReturn(callbacks *DeleteCallbacks, c *api.Context, valueObject value_object.ValueObject, prepared map[string]any, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -128,10 +129,10 @@ func callbackOnDeleteSuccessReturn(callbacks *DeleteCallbacks, valueObject value
 		return nil
 	}
 
-	return callbacks.OnSuccessReturn(valueObject, prepared, i)
+	return callbacks.OnSuccessReturn(c, valueObject, prepared, i)
 }
 
-func callbackOnDeleteErrorReturn(callbacks *DeleteCallbacks, valueObject value_object.ValueObject, prepared map[string]any, err error, i *infrastructure.Infrastructure) error {
+func callbackOnDeleteErrorReturn(callbacks *DeleteCallbacks, c *api.Context, valueObject value_object.ValueObject, prepared map[string]any, err error, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return err
 	}
@@ -140,17 +141,17 @@ func callbackOnDeleteErrorReturn(callbacks *DeleteCallbacks, valueObject value_o
 		return err
 	}
 
-	return callbacks.OnErrorReturn(valueObject, prepared, err, i)
+	return callbacks.OnErrorReturn(c, valueObject, prepared, err, i)
 }
 
 type QueryCallbacks[O any] struct {
-	Before          func(valueObject value_object.ValueObject, i *infrastructure.Infrastructure) error
-	After           func(valueObject value_object.ValueObject, i *infrastructure.Infrastructure) error
-	OnSuccessReturn func(valueObject value_object.ValueObject, i *infrastructure.Infrastructure, output response.InfosData[O]) (response.InfosData[O], error)
-	OnErrorReturn   func(valueObject value_object.ValueObject, err error, i *infrastructure.Infrastructure) (response.InfosData[O], error)
+	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)
 }
 
-func callbackBeforeQuery[O any](callbacks *QueryCallbacks[O], valueObject value_object.ValueObject, i *infrastructure.Infrastructure) error {
+func callbackBeforeQuery[O any](callbacks *QueryCallbacks[O], c *api.Context, valueObject value_object.ValueObject, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -159,10 +160,10 @@ func callbackBeforeQuery[O any](callbacks *QueryCallbacks[O], valueObject value_
 		return nil
 	}
 
-	return callbacks.Before(valueObject, i)
+	return callbacks.Before(c, valueObject, i)
 }
 
-func callbackAfterQuery[O any](callbacks *QueryCallbacks[O], valueObject value_object.ValueObject, i *infrastructure.Infrastructure) error {
+func callbackAfterQuery[O any](callbacks *QueryCallbacks[O], c *api.Context, valueObject value_object.ValueObject, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return nil
 	}
@@ -171,10 +172,10 @@ func callbackAfterQuery[O any](callbacks *QueryCallbacks[O], valueObject value_o
 		return nil
 	}
 
-	return callbacks.After(valueObject, i)
+	return callbacks.After(c, valueObject, i)
 }
 
-func callbackOnQuerySuccessReturn[O any](callbacks *QueryCallbacks[O], 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, valueObject value_object.ValueObject, i *infrastructure.Infrastructure, output response.InfosData[O]) (response.InfosData[O], error) {
 	if callbacks == nil {
 		return output, nil
 	}
@@ -183,10 +184,10 @@ func callbackOnQuerySuccessReturn[O any](callbacks *QueryCallbacks[O], valueObje
 		return output, nil
 	}
 
-	return callbacks.OnSuccessReturn(valueObject, i, output)
+	return callbacks.OnSuccessReturn(c, valueObject, i, output)
 }
 
-func callbackOnQueryErrorReturn[O any](callbacks *QueryCallbacks[O], valueObject value_object.ValueObject, err error, i *infrastructure.Infrastructure) (response.InfosData[O], error) {
+func callbackOnQueryErrorReturn[O any](callbacks *QueryCallbacks[O], c *api.Context, valueObject value_object.ValueObject, err error, i *infrastructure.Infrastructure) (response.InfosData[O], error) {
 	if callbacks == nil {
 		return response.InfosData[O]{
 			Infos: make([]O, 0),
@@ -199,5 +200,5 @@ func callbackOnQueryErrorReturn[O any](callbacks *QueryCallbacks[O], valueObject
 		}, err
 	}
 
-	return callbacks.OnErrorReturn(valueObject, err, i)
+	return callbacks.OnErrorReturn(c, valueObject, err, i)
 }