From d0b535d9e283764108b2a79d30c99a25c6165a45 Mon Sep 17 00:00:00 2001 From: liushengyang Date: Wed, 10 Sep 2025 21:54:15 +0800 Subject: [PATCH] fix(backend): evaluation feature bug --- .../coze/loop/apis/experiment_service.go | 85 +- backend/cmd/main.go | 23 +- .../modules/evaluation/domain/entity/event.go | 2 + .../domain/entity/expt_export_record.go | 9 +- .../modules/evaluation/domain/repo/expt.go | 2 +- .../evaluation/domain/repo/mocks/expt.go | 752 +++++++++--------- .../domain/service/expt_annotate_impl.go | 2 +- .../domain/service/expt_export_impl.go | 22 +- .../infra/mq/rocket/consumer/expt_export.go | 5 + .../infra/repo/experiment/annotate_record.go | 2 +- .../repo/experiment/annotate_record_test.go | 4 +- .../mysql/expt_turn_result_tag_ref.go | 10 +- .../mysql/mocks/expt_turn_result_tag_ref.go | 66 +- backend/pkg/lang/conv/unicode.go | 32 + backend/pkg/lang/conv/unicode_test.go | 99 +++ backend/pkg/lang/js_conv/json.go | 17 +- .../docker-compose/conf/evaluation.yaml | 3 + .../helm-chart/umbrella/conf/evaluation.yaml | 3 + 18 files changed, 650 insertions(+), 488 deletions(-) create mode 100644 backend/pkg/lang/conv/unicode.go create mode 100644 backend/pkg/lang/conv/unicode_test.go diff --git a/backend/api/handler/coze/loop/apis/experiment_service.go b/backend/api/handler/coze/loop/apis/experiment_service.go index 2ed2c831a..c779ca609 100644 --- a/backend/api/handler/coze/loop/apis/experiment_service.go +++ b/backend/api/handler/coze/loop/apis/experiment_service.go @@ -13,6 +13,7 @@ import ( "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/evaluation/experimentservice" expt "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/evaluation/expt" + "github.com/coze-dev/coze-loop/backend/pkg/lang/js_conv" ) var localExptSvc experimentservice.Client @@ -136,81 +137,31 @@ func UpsertExptTurnResultFilter(ctx context.Context, c *app.RequestContext) { // AssociateAnnotationTag . // @router /api/evaluation/v1/experiments/:expt_id/associate_tag [POST] func AssociateAnnotationTag(ctx context.Context, c *app.RequestContext) { - var err error - var req expt.AssociateAnnotationTagReq - err = c.BindAndValidate(&req) - if err != nil { - c.String(consts.StatusBadRequest, err.Error()) - return - } - - resp := new(expt.AssociateAnnotationTagResp) - - c.JSON(consts.StatusOK, resp) + invokeAndRender(ctx, c, localExptSvc.AssociateAnnotationTag) } // DeleteAnnotationTag . // @router /api/evaluation/v1/experiments/:expt_id/delete_tag [DELETE] func DeleteAnnotationTag(ctx context.Context, c *app.RequestContext) { - var err error - var req expt.DeleteAnnotationTagReq - err = c.BindAndValidate(&req) - if err != nil { - c.String(consts.StatusBadRequest, err.Error()) - return - } - - resp := new(expt.DeleteAnnotationTagResp) - - c.JSON(consts.StatusOK, resp) + invokeAndRender(ctx, c, localExptSvc.DeleteAnnotationTag) } // CreateAnnotateRecord . // @router /api/evaluation/v1/experiments/:expt_id/annotate_record/create [POST] func CreateAnnotateRecord(ctx context.Context, c *app.RequestContext) { - var err error - var req expt.CreateAnnotateRecordReq - err = c.BindAndValidate(&req) - if err != nil { - c.String(consts.StatusBadRequest, err.Error()) - return - } - - resp := new(expt.CreateAnnotateRecordResp) - - c.JSON(consts.StatusOK, resp) + invokeAndRender(ctx, c, localExptSvc.CreateAnnotateRecord) } // UpdateAnnotateRecord . // @router /api/evaluation/v1/experiments/:expt_id/annotate_record/update [POST] func UpdateAnnotateRecord(ctx context.Context, c *app.RequestContext) { - var err error - var req expt.UpdateAnnotateRecordReq - err = c.BindAndValidate(&req) - if err != nil { - c.String(consts.StatusBadRequest, err.Error()) - return - } - - resp := new(expt.UpdateAnnotateRecordResp) - - c.JSON(consts.StatusOK, resp) + invokeAndRender(ctx, c, localExptSvc.UpdateAnnotateRecord) } // ExportExptResult . // @router /api/evaluation/v1/experiments/:expt_id/results/export [POST] func ExportExptResult(ctx context.Context, c *app.RequestContext) { - var err error - var req expt.ExportExptResultRequest - err = c.BindAndValidate(&req) - if err != nil { - c.String(consts.StatusBadRequest, err.Error()) - return - } - - resp := new(expt.ExportExptResultResponse) - - c.JSON(consts.StatusOK, resp) + invokeAndRender(ctx, c, localExptSvc.ExportExptResult_) } // ListExptResultExportRecord . @@ -224,9 +175,17 @@ func ListExptResultExportRecord(ctx context.Context, c *app.RequestContext) { return } - resp := new(expt.ListExptResultExportRecordResponse) + resp, err := localExptSvc.ListExptResultExportRecord(ctx, &req) + if err != nil { + _ = c.Error(err) + return + } - c.JSON(consts.StatusOK, resp) + if noescaped, err := js_conv.UnescapedMarshal(resp); err == nil { + c.Data(consts.StatusOK, "application/json", noescaped) + } else { + c.JSON(consts.StatusOK, resp) + } } // GetExptResultExportRecord . @@ -240,7 +199,15 @@ func GetExptResultExportRecord(ctx context.Context, c *app.RequestContext) { return } - resp := new(expt.GetExptResultExportRecordResponse) + resp, err := localExptSvc.GetExptResultExportRecord(ctx, &req) + if err != nil { + _ = c.Error(err) + return + } - c.JSON(consts.StatusOK, resp) + if noescaped, err := js_conv.UnescapedMarshal(resp); err == nil { + c.Data(consts.StatusOK, "application/json", noescaped) + } else { + c.JSON(consts.StatusOK, resp) + } } diff --git a/backend/cmd/main.go b/backend/cmd/main.go index 6b2498411..5a5567092 100644 --- a/backend/cmd/main.go +++ b/backend/cmd/main.go @@ -185,17 +185,18 @@ func newComponent(ctx context.Context) (*component, error) { } db, err := db.NewDBFromConfig(&db.Config{ - DBHostname: getMysqlDomain(), - DBPort: getMysqlPort(), - User: getMysqlUser(), - Password: getMysqlPassword(), - DBName: getMysqlDatabase(), - Loc: "Local", - DBCharset: "utf8mb4", - Timeout: time.Minute, - ReadTimeout: time.Minute, - WriteTimeout: time.Minute, - DSNParams: url.Values{"clientFoundRows": []string{"true"}}, + DBHostname: getMysqlDomain(), + DBPort: getMysqlPort(), + User: getMysqlUser(), + Password: getMysqlPassword(), + DBName: getMysqlDatabase(), + Loc: "Local", + DBCharset: "utf8mb4", + Timeout: time.Minute, + ReadTimeout: time.Minute, + WriteTimeout: time.Minute, + DSNParams: url.Values{"clientFoundRows": []string{"true"}}, + WithReturning: true, }) if err != nil { return nil, err diff --git a/backend/modules/evaluation/domain/entity/event.go b/backend/modules/evaluation/domain/entity/event.go index 460a71fc4..e78ad1caa 100644 --- a/backend/modules/evaluation/domain/entity/event.go +++ b/backend/modules/evaluation/domain/entity/event.go @@ -119,4 +119,6 @@ type ExportCSVEvent struct { ExportID int64 ExperimentID int64 SpaceID int64 + + Session *Session } diff --git a/backend/modules/evaluation/domain/entity/expt_export_record.go b/backend/modules/evaluation/domain/entity/expt_export_record.go index 88bff3b08..ef8b88ad8 100644 --- a/backend/modules/evaluation/domain/entity/expt_export_record.go +++ b/backend/modules/evaluation/domain/entity/expt_export_record.go @@ -38,10 +38,17 @@ func DefaultExptExportWhiteList() *ExptExportWhiteList { } type ExptExportWhiteList struct { - UserIDs []int64 `json:"user_ids" mapstructure:"user_ids"` + UserIDs []int64 `json:"user_ids" mapstructure:"user_ids"` + AllowAll bool `json:"allow_all" mapstructure:"allow_all"` } func (e *ExptExportWhiteList) IsUserIDInWhiteList(userID string) bool { + if e == nil { + return false + } + if e.AllowAll { + return true + } uid, err := strconv.ParseInt(userID, 10, 64) if err != nil { return false diff --git a/backend/modules/evaluation/domain/repo/expt.go b/backend/modules/evaluation/domain/repo/expt.go index 35267730b..dabec1b78 100644 --- a/backend/modules/evaluation/domain/repo/expt.go +++ b/backend/modules/evaluation/domain/repo/expt.go @@ -119,7 +119,7 @@ type IExptAnnotateRepo interface { GetExptTurnResultTagRefs(ctx context.Context, exptID, spaceID int64) ([]*entity.ExptTurnResultTagRef, error) BatchGetExptTurnResultTagRefs(ctx context.Context, exptIDs []int64, spaceID int64) ([]*entity.ExptTurnResultTagRef, error) GetTagRefByTagKeyID(ctx context.Context, exptID, spaceID, tagKeyID int64) (*entity.ExptTurnResultTagRef, error) - UpdateCompleteCount(ctx context.Context, exptID, spaceID, tagKeyID int64, opts ...db.Option) (int32, int32, error) + UpdateCompleteCount(ctx context.Context, exptID, spaceID, tagKeyID int64, opts ...db.Option) error DeleteExptTurnResultTagRef(ctx context.Context, exptID, spaceID, tagKeyID int64, opts ...db.Option) error SaveAnnotateRecord(ctx context.Context, exptTurnResultID int64, record *entity.AnnotateRecord, opts ...db.Option) error diff --git a/backend/modules/evaluation/domain/repo/mocks/expt.go b/backend/modules/evaluation/domain/repo/mocks/expt.go index 781fdce9b..f8cee62d8 100644 --- a/backend/modules/evaluation/domain/repo/mocks/expt.go +++ b/backend/modules/evaluation/domain/repo/mocks/expt.go @@ -1,5 +1,10 @@ // Code generated by MockGen. DO NOT EDIT. // Source: github.com/coze-dev/coze-loop/backend/modules/evaluation/domain/repo (interfaces: IExperimentRepo,IExptStatsRepo,IExptItemResultRepo,IExptTurnResultRepo,IExptRunLogRepo,IExptAggrResultRepo,QuotaRepo,IExptTurnResultFilterRepo,IExptAnnotateRepo,IExptResultExportRecordRepo) +// +// Generated by this command: +// +// mockgen -destination ./mocks/expt.go --package mocks . IExperimentRepo,IExptStatsRepo,IExptItemResultRepo,IExptTurnResultRepo,IExptRunLogRepo,IExptAggrResultRepo,QuotaRepo,IExptTurnResultFilterRepo,IExptAnnotateRepo,IExptResultExportRecordRepo +// // Package mocks is a generated GoMock package. package mocks @@ -8,16 +13,16 @@ import ( context "context" reflect "reflect" - gomock "go.uber.org/mock/gomock" - db "github.com/coze-dev/coze-loop/backend/infra/db" entity "github.com/coze-dev/coze-loop/backend/modules/evaluation/domain/entity" + gomock "go.uber.org/mock/gomock" ) // MockIExperimentRepo is a mock of IExperimentRepo interface. type MockIExperimentRepo struct { ctrl *gomock.Controller recorder *MockIExperimentRepoMockRecorder + isgomock struct{} } // MockIExperimentRepoMockRecorder is the mock recorder for MockIExperimentRepo. @@ -38,52 +43,52 @@ func (m *MockIExperimentRepo) EXPECT() *MockIExperimentRepoMockRecorder { } // Create mocks base method. -func (m *MockIExperimentRepo) Create(arg0 context.Context, arg1 *entity.Experiment, arg2 []*entity.ExptEvaluatorRef) error { +func (m *MockIExperimentRepo) Create(ctx context.Context, expt *entity.Experiment, exptEvaluatorRefs []*entity.ExptEvaluatorRef) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "Create", ctx, expt, exptEvaluatorRefs) ret0, _ := ret[0].(error) return ret0 } // Create indicates an expected call of Create. -func (mr *MockIExperimentRepoMockRecorder) Create(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockIExperimentRepoMockRecorder) Create(ctx, expt, exptEvaluatorRefs any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockIExperimentRepo)(nil).Create), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockIExperimentRepo)(nil).Create), ctx, expt, exptEvaluatorRefs) } // Delete mocks base method. -func (m *MockIExperimentRepo) Delete(arg0 context.Context, arg1, arg2 int64) error { +func (m *MockIExperimentRepo) Delete(ctx context.Context, id, spaceID int64) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Delete", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "Delete", ctx, id, spaceID) ret0, _ := ret[0].(error) return ret0 } // Delete indicates an expected call of Delete. -func (mr *MockIExperimentRepoMockRecorder) Delete(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockIExperimentRepoMockRecorder) Delete(ctx, id, spaceID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockIExperimentRepo)(nil).Delete), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockIExperimentRepo)(nil).Delete), ctx, id, spaceID) } // GetByID mocks base method. -func (m *MockIExperimentRepo) GetByID(arg0 context.Context, arg1, arg2 int64) (*entity.Experiment, error) { +func (m *MockIExperimentRepo) GetByID(ctx context.Context, id, spaceID int64) (*entity.Experiment, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetByID", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "GetByID", ctx, id, spaceID) ret0, _ := ret[0].(*entity.Experiment) ret1, _ := ret[1].(error) return ret0, ret1 } // GetByID indicates an expected call of GetByID. -func (mr *MockIExperimentRepoMockRecorder) GetByID(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockIExperimentRepoMockRecorder) GetByID(ctx, id, spaceID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockIExperimentRepo)(nil).GetByID), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockIExperimentRepo)(nil).GetByID), ctx, id, spaceID) } // GetByName mocks base method. -func (m *MockIExperimentRepo) GetByName(arg0 context.Context, arg1 string, arg2 int64) (*entity.Experiment, bool, error) { +func (m *MockIExperimentRepo) GetByName(ctx context.Context, name string, spaceID int64) (*entity.Experiment, bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetByName", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "GetByName", ctx, name, spaceID) ret0, _ := ret[0].(*entity.Experiment) ret1, _ := ret[1].(bool) ret2, _ := ret[2].(error) @@ -91,30 +96,30 @@ func (m *MockIExperimentRepo) GetByName(arg0 context.Context, arg1 string, arg2 } // GetByName indicates an expected call of GetByName. -func (mr *MockIExperimentRepoMockRecorder) GetByName(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockIExperimentRepoMockRecorder) GetByName(ctx, name, spaceID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByName", reflect.TypeOf((*MockIExperimentRepo)(nil).GetByName), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByName", reflect.TypeOf((*MockIExperimentRepo)(nil).GetByName), ctx, name, spaceID) } // GetEvaluatorRefByExptIDs mocks base method. -func (m *MockIExperimentRepo) GetEvaluatorRefByExptIDs(arg0 context.Context, arg1 []int64, arg2 int64) ([]*entity.ExptEvaluatorRef, error) { +func (m *MockIExperimentRepo) GetEvaluatorRefByExptIDs(ctx context.Context, exptID []int64, spaceID int64) ([]*entity.ExptEvaluatorRef, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetEvaluatorRefByExptIDs", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "GetEvaluatorRefByExptIDs", ctx, exptID, spaceID) ret0, _ := ret[0].([]*entity.ExptEvaluatorRef) ret1, _ := ret[1].(error) return ret0, ret1 } // GetEvaluatorRefByExptIDs indicates an expected call of GetEvaluatorRefByExptIDs. -func (mr *MockIExperimentRepoMockRecorder) GetEvaluatorRefByExptIDs(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockIExperimentRepoMockRecorder) GetEvaluatorRefByExptIDs(ctx, exptID, spaceID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEvaluatorRefByExptIDs", reflect.TypeOf((*MockIExperimentRepo)(nil).GetEvaluatorRefByExptIDs), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEvaluatorRefByExptIDs", reflect.TypeOf((*MockIExperimentRepo)(nil).GetEvaluatorRefByExptIDs), ctx, exptID, spaceID) } // List mocks base method. -func (m *MockIExperimentRepo) List(arg0 context.Context, arg1, arg2 int32, arg3 *entity.ExptListFilter, arg4 []*entity.OrderBy, arg5 int64) ([]*entity.Experiment, int64, error) { +func (m *MockIExperimentRepo) List(ctx context.Context, page, size int32, filter *entity.ExptListFilter, orders []*entity.OrderBy, spaceID int64) ([]*entity.Experiment, int64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "List", arg0, arg1, arg2, arg3, arg4, arg5) + ret := m.ctrl.Call(m, "List", ctx, page, size, filter, orders, spaceID) ret0, _ := ret[0].([]*entity.Experiment) ret1, _ := ret[1].(int64) ret2, _ := ret[2].(error) @@ -122,73 +127,74 @@ func (m *MockIExperimentRepo) List(arg0 context.Context, arg1, arg2 int32, arg3 } // List indicates an expected call of List. -func (mr *MockIExperimentRepoMockRecorder) List(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call { +func (mr *MockIExperimentRepoMockRecorder) List(ctx, page, size, filter, orders, spaceID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockIExperimentRepo)(nil).List), arg0, arg1, arg2, arg3, arg4, arg5) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockIExperimentRepo)(nil).List), ctx, page, size, filter, orders, spaceID) } // MDelete mocks base method. -func (m *MockIExperimentRepo) MDelete(arg0 context.Context, arg1 []int64, arg2 int64) error { +func (m *MockIExperimentRepo) MDelete(ctx context.Context, ids []int64, spaceID int64) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "MDelete", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "MDelete", ctx, ids, spaceID) ret0, _ := ret[0].(error) return ret0 } // MDelete indicates an expected call of MDelete. -func (mr *MockIExperimentRepoMockRecorder) MDelete(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockIExperimentRepoMockRecorder) MDelete(ctx, ids, spaceID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MDelete", reflect.TypeOf((*MockIExperimentRepo)(nil).MDelete), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MDelete", reflect.TypeOf((*MockIExperimentRepo)(nil).MDelete), ctx, ids, spaceID) } // MGetBasicByID mocks base method. -func (m *MockIExperimentRepo) MGetBasicByID(arg0 context.Context, arg1 []int64) ([]*entity.Experiment, error) { +func (m *MockIExperimentRepo) MGetBasicByID(ctx context.Context, ids []int64) ([]*entity.Experiment, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "MGetBasicByID", arg0, arg1) + ret := m.ctrl.Call(m, "MGetBasicByID", ctx, ids) ret0, _ := ret[0].([]*entity.Experiment) ret1, _ := ret[1].(error) return ret0, ret1 } // MGetBasicByID indicates an expected call of MGetBasicByID. -func (mr *MockIExperimentRepoMockRecorder) MGetBasicByID(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockIExperimentRepoMockRecorder) MGetBasicByID(ctx, ids any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetBasicByID", reflect.TypeOf((*MockIExperimentRepo)(nil).MGetBasicByID), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetBasicByID", reflect.TypeOf((*MockIExperimentRepo)(nil).MGetBasicByID), ctx, ids) } // MGetByID mocks base method. -func (m *MockIExperimentRepo) MGetByID(arg0 context.Context, arg1 []int64, arg2 int64) ([]*entity.Experiment, error) { +func (m *MockIExperimentRepo) MGetByID(ctx context.Context, ids []int64, spaceID int64) ([]*entity.Experiment, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "MGetByID", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "MGetByID", ctx, ids, spaceID) ret0, _ := ret[0].([]*entity.Experiment) ret1, _ := ret[1].(error) return ret0, ret1 } // MGetByID indicates an expected call of MGetByID. -func (mr *MockIExperimentRepoMockRecorder) MGetByID(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockIExperimentRepoMockRecorder) MGetByID(ctx, ids, spaceID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetByID", reflect.TypeOf((*MockIExperimentRepo)(nil).MGetByID), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetByID", reflect.TypeOf((*MockIExperimentRepo)(nil).MGetByID), ctx, ids, spaceID) } // Update mocks base method. -func (m *MockIExperimentRepo) Update(arg0 context.Context, arg1 *entity.Experiment) error { +func (m *MockIExperimentRepo) Update(ctx context.Context, expt *entity.Experiment) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Update", arg0, arg1) + ret := m.ctrl.Call(m, "Update", ctx, expt) ret0, _ := ret[0].(error) return ret0 } // Update indicates an expected call of Update. -func (mr *MockIExperimentRepoMockRecorder) Update(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockIExperimentRepoMockRecorder) Update(ctx, expt any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockIExperimentRepo)(nil).Update), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockIExperimentRepo)(nil).Update), ctx, expt) } // MockIExptStatsRepo is a mock of IExptStatsRepo interface. type MockIExptStatsRepo struct { ctrl *gomock.Controller recorder *MockIExptStatsRepoMockRecorder + isgomock struct{} } // MockIExptStatsRepoMockRecorder is the mock recorder for MockIExptStatsRepo. @@ -209,95 +215,96 @@ func (m *MockIExptStatsRepo) EXPECT() *MockIExptStatsRepoMockRecorder { } // ArithOperateCount mocks base method. -func (m *MockIExptStatsRepo) ArithOperateCount(arg0 context.Context, arg1, arg2 int64, arg3 *entity.StatsCntArithOp) error { +func (m *MockIExptStatsRepo) ArithOperateCount(ctx context.Context, exptID, spaceID int64, cntArithOp *entity.StatsCntArithOp) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ArithOperateCount", arg0, arg1, arg2, arg3) + ret := m.ctrl.Call(m, "ArithOperateCount", ctx, exptID, spaceID, cntArithOp) ret0, _ := ret[0].(error) return ret0 } // ArithOperateCount indicates an expected call of ArithOperateCount. -func (mr *MockIExptStatsRepoMockRecorder) ArithOperateCount(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +func (mr *MockIExptStatsRepoMockRecorder) ArithOperateCount(ctx, exptID, spaceID, cntArithOp any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ArithOperateCount", reflect.TypeOf((*MockIExptStatsRepo)(nil).ArithOperateCount), arg0, arg1, arg2, arg3) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ArithOperateCount", reflect.TypeOf((*MockIExptStatsRepo)(nil).ArithOperateCount), ctx, exptID, spaceID, cntArithOp) } // Create mocks base method. -func (m *MockIExptStatsRepo) Create(arg0 context.Context, arg1 *entity.ExptStats) error { +func (m *MockIExptStatsRepo) Create(ctx context.Context, stats *entity.ExptStats) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Create", arg0, arg1) + ret := m.ctrl.Call(m, "Create", ctx, stats) ret0, _ := ret[0].(error) return ret0 } // Create indicates an expected call of Create. -func (mr *MockIExptStatsRepoMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockIExptStatsRepoMockRecorder) Create(ctx, stats any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockIExptStatsRepo)(nil).Create), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockIExptStatsRepo)(nil).Create), ctx, stats) } // Get mocks base method. -func (m *MockIExptStatsRepo) Get(arg0 context.Context, arg1, arg2 int64) (*entity.ExptStats, error) { +func (m *MockIExptStatsRepo) Get(ctx context.Context, exptID, spaceID int64) (*entity.ExptStats, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Get", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "Get", ctx, exptID, spaceID) ret0, _ := ret[0].(*entity.ExptStats) ret1, _ := ret[1].(error) return ret0, ret1 } // Get indicates an expected call of Get. -func (mr *MockIExptStatsRepoMockRecorder) Get(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockIExptStatsRepoMockRecorder) Get(ctx, exptID, spaceID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockIExptStatsRepo)(nil).Get), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockIExptStatsRepo)(nil).Get), ctx, exptID, spaceID) } // MGet mocks base method. -func (m *MockIExptStatsRepo) MGet(arg0 context.Context, arg1 []int64, arg2 int64) ([]*entity.ExptStats, error) { +func (m *MockIExptStatsRepo) MGet(ctx context.Context, exptIDs []int64, spaceID int64) ([]*entity.ExptStats, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "MGet", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "MGet", ctx, exptIDs, spaceID) ret0, _ := ret[0].([]*entity.ExptStats) ret1, _ := ret[1].(error) return ret0, ret1 } // MGet indicates an expected call of MGet. -func (mr *MockIExptStatsRepoMockRecorder) MGet(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockIExptStatsRepoMockRecorder) MGet(ctx, exptIDs, spaceID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGet", reflect.TypeOf((*MockIExptStatsRepo)(nil).MGet), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGet", reflect.TypeOf((*MockIExptStatsRepo)(nil).MGet), ctx, exptIDs, spaceID) } // Save mocks base method. -func (m *MockIExptStatsRepo) Save(arg0 context.Context, arg1 *entity.ExptStats) error { +func (m *MockIExptStatsRepo) Save(ctx context.Context, stats *entity.ExptStats) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Save", arg0, arg1) + ret := m.ctrl.Call(m, "Save", ctx, stats) ret0, _ := ret[0].(error) return ret0 } // Save indicates an expected call of Save. -func (mr *MockIExptStatsRepoMockRecorder) Save(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockIExptStatsRepoMockRecorder) Save(ctx, stats any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockIExptStatsRepo)(nil).Save), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockIExptStatsRepo)(nil).Save), ctx, stats) } // UpdateByExptID mocks base method. -func (m *MockIExptStatsRepo) UpdateByExptID(arg0 context.Context, arg1, arg2 int64, arg3 *entity.ExptStats) error { +func (m *MockIExptStatsRepo) UpdateByExptID(ctx context.Context, exptID, spaceID int64, stats *entity.ExptStats) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateByExptID", arg0, arg1, arg2, arg3) + ret := m.ctrl.Call(m, "UpdateByExptID", ctx, exptID, spaceID, stats) ret0, _ := ret[0].(error) return ret0 } // UpdateByExptID indicates an expected call of UpdateByExptID. -func (mr *MockIExptStatsRepoMockRecorder) UpdateByExptID(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +func (mr *MockIExptStatsRepoMockRecorder) UpdateByExptID(ctx, exptID, spaceID, stats any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateByExptID", reflect.TypeOf((*MockIExptStatsRepo)(nil).UpdateByExptID), arg0, arg1, arg2, arg3) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateByExptID", reflect.TypeOf((*MockIExptStatsRepo)(nil).UpdateByExptID), ctx, exptID, spaceID, stats) } // MockIExptItemResultRepo is a mock of IExptItemResultRepo interface. type MockIExptItemResultRepo struct { ctrl *gomock.Controller recorder *MockIExptItemResultRepoMockRecorder + isgomock struct{} } // MockIExptItemResultRepoMockRecorder is the mock recorder for MockIExptItemResultRepo. @@ -318,112 +325,112 @@ func (m *MockIExptItemResultRepo) EXPECT() *MockIExptItemResultRepoMockRecorder } // BatchCreateNX mocks base method. -func (m *MockIExptItemResultRepo) BatchCreateNX(arg0 context.Context, arg1 []*entity.ExptItemResult) error { +func (m *MockIExptItemResultRepo) BatchCreateNX(ctx context.Context, itemResults []*entity.ExptItemResult) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BatchCreateNX", arg0, arg1) + ret := m.ctrl.Call(m, "BatchCreateNX", ctx, itemResults) ret0, _ := ret[0].(error) return ret0 } // BatchCreateNX indicates an expected call of BatchCreateNX. -func (mr *MockIExptItemResultRepoMockRecorder) BatchCreateNX(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockIExptItemResultRepoMockRecorder) BatchCreateNX(ctx, itemResults any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCreateNX", reflect.TypeOf((*MockIExptItemResultRepo)(nil).BatchCreateNX), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCreateNX", reflect.TypeOf((*MockIExptItemResultRepo)(nil).BatchCreateNX), ctx, itemResults) } // BatchCreateNXRunLogs mocks base method. -func (m *MockIExptItemResultRepo) BatchCreateNXRunLogs(arg0 context.Context, arg1 []*entity.ExptItemResultRunLog) error { +func (m *MockIExptItemResultRepo) BatchCreateNXRunLogs(ctx context.Context, itemRunLogs []*entity.ExptItemResultRunLog) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BatchCreateNXRunLogs", arg0, arg1) + ret := m.ctrl.Call(m, "BatchCreateNXRunLogs", ctx, itemRunLogs) ret0, _ := ret[0].(error) return ret0 } // BatchCreateNXRunLogs indicates an expected call of BatchCreateNXRunLogs. -func (mr *MockIExptItemResultRepoMockRecorder) BatchCreateNXRunLogs(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockIExptItemResultRepoMockRecorder) BatchCreateNXRunLogs(ctx, itemRunLogs any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCreateNXRunLogs", reflect.TypeOf((*MockIExptItemResultRepo)(nil).BatchCreateNXRunLogs), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCreateNXRunLogs", reflect.TypeOf((*MockIExptItemResultRepo)(nil).BatchCreateNXRunLogs), ctx, itemRunLogs) } // BatchGet mocks base method. -func (m *MockIExptItemResultRepo) BatchGet(arg0 context.Context, arg1, arg2 int64, arg3 []int64) ([]*entity.ExptItemResult, error) { +func (m *MockIExptItemResultRepo) BatchGet(ctx context.Context, spaceID, exptID int64, itemIDs []int64) ([]*entity.ExptItemResult, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BatchGet", arg0, arg1, arg2, arg3) + ret := m.ctrl.Call(m, "BatchGet", ctx, spaceID, exptID, itemIDs) ret0, _ := ret[0].([]*entity.ExptItemResult) ret1, _ := ret[1].(error) return ret0, ret1 } // BatchGet indicates an expected call of BatchGet. -func (mr *MockIExptItemResultRepoMockRecorder) BatchGet(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +func (mr *MockIExptItemResultRepoMockRecorder) BatchGet(ctx, spaceID, exptID, itemIDs any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGet", reflect.TypeOf((*MockIExptItemResultRepo)(nil).BatchGet), arg0, arg1, arg2, arg3) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGet", reflect.TypeOf((*MockIExptItemResultRepo)(nil).BatchGet), ctx, spaceID, exptID, itemIDs) } // GetItemIDListByExptID mocks base method. -func (m *MockIExptItemResultRepo) GetItemIDListByExptID(arg0 context.Context, arg1, arg2 int64) ([]int64, error) { +func (m *MockIExptItemResultRepo) GetItemIDListByExptID(ctx context.Context, exptID, spaceID int64) ([]int64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetItemIDListByExptID", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "GetItemIDListByExptID", ctx, exptID, spaceID) ret0, _ := ret[0].([]int64) ret1, _ := ret[1].(error) return ret0, ret1 } // GetItemIDListByExptID indicates an expected call of GetItemIDListByExptID. -func (mr *MockIExptItemResultRepoMockRecorder) GetItemIDListByExptID(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockIExptItemResultRepoMockRecorder) GetItemIDListByExptID(ctx, exptID, spaceID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetItemIDListByExptID", reflect.TypeOf((*MockIExptItemResultRepo)(nil).GetItemIDListByExptID), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetItemIDListByExptID", reflect.TypeOf((*MockIExptItemResultRepo)(nil).GetItemIDListByExptID), ctx, exptID, spaceID) } // GetItemRunLog mocks base method. -func (m *MockIExptItemResultRepo) GetItemRunLog(arg0 context.Context, arg1, arg2, arg3, arg4 int64) (*entity.ExptItemResultRunLog, error) { +func (m *MockIExptItemResultRepo) GetItemRunLog(ctx context.Context, exptID, exptRunID, itemID, spaceID int64) (*entity.ExptItemResultRunLog, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetItemRunLog", arg0, arg1, arg2, arg3, arg4) + ret := m.ctrl.Call(m, "GetItemRunLog", ctx, exptID, exptRunID, itemID, spaceID) ret0, _ := ret[0].(*entity.ExptItemResultRunLog) ret1, _ := ret[1].(error) return ret0, ret1 } // GetItemRunLog indicates an expected call of GetItemRunLog. -func (mr *MockIExptItemResultRepoMockRecorder) GetItemRunLog(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call { +func (mr *MockIExptItemResultRepoMockRecorder) GetItemRunLog(ctx, exptID, exptRunID, itemID, spaceID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetItemRunLog", reflect.TypeOf((*MockIExptItemResultRepo)(nil).GetItemRunLog), arg0, arg1, arg2, arg3, arg4) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetItemRunLog", reflect.TypeOf((*MockIExptItemResultRepo)(nil).GetItemRunLog), ctx, exptID, exptRunID, itemID, spaceID) } // GetItemTurnResults mocks base method. -func (m *MockIExptItemResultRepo) GetItemTurnResults(arg0 context.Context, arg1, arg2, arg3 int64) ([]*entity.ExptTurnResult, error) { +func (m *MockIExptItemResultRepo) GetItemTurnResults(ctx context.Context, spaceID, exptID, itemID int64) ([]*entity.ExptTurnResult, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetItemTurnResults", arg0, arg1, arg2, arg3) + ret := m.ctrl.Call(m, "GetItemTurnResults", ctx, spaceID, exptID, itemID) ret0, _ := ret[0].([]*entity.ExptTurnResult) ret1, _ := ret[1].(error) return ret0, ret1 } // GetItemTurnResults indicates an expected call of GetItemTurnResults. -func (mr *MockIExptItemResultRepoMockRecorder) GetItemTurnResults(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +func (mr *MockIExptItemResultRepoMockRecorder) GetItemTurnResults(ctx, spaceID, exptID, itemID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetItemTurnResults", reflect.TypeOf((*MockIExptItemResultRepo)(nil).GetItemTurnResults), arg0, arg1, arg2, arg3) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetItemTurnResults", reflect.TypeOf((*MockIExptItemResultRepo)(nil).GetItemTurnResults), ctx, spaceID, exptID, itemID) } // GetMaxItemIdxByExptID mocks base method. -func (m *MockIExptItemResultRepo) GetMaxItemIdxByExptID(arg0 context.Context, arg1, arg2 int64) (int32, error) { +func (m *MockIExptItemResultRepo) GetMaxItemIdxByExptID(ctx context.Context, exptID, spaceID int64) (int32, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetMaxItemIdxByExptID", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "GetMaxItemIdxByExptID", ctx, exptID, spaceID) ret0, _ := ret[0].(int32) ret1, _ := ret[1].(error) return ret0, ret1 } // GetMaxItemIdxByExptID indicates an expected call of GetMaxItemIdxByExptID. -func (mr *MockIExptItemResultRepoMockRecorder) GetMaxItemIdxByExptID(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockIExptItemResultRepoMockRecorder) GetMaxItemIdxByExptID(ctx, exptID, spaceID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaxItemIdxByExptID", reflect.TypeOf((*MockIExptItemResultRepo)(nil).GetMaxItemIdxByExptID), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaxItemIdxByExptID", reflect.TypeOf((*MockIExptItemResultRepo)(nil).GetMaxItemIdxByExptID), ctx, exptID, spaceID) } // ListItemResultsByExptID mocks base method. -func (m *MockIExptItemResultRepo) ListItemResultsByExptID(arg0 context.Context, arg1, arg2 int64, arg3 entity.Page, arg4 bool) ([]*entity.ExptItemResult, int64, error) { +func (m *MockIExptItemResultRepo) ListItemResultsByExptID(ctx context.Context, exptID, spaceID int64, page entity.Page, desc bool) ([]*entity.ExptItemResult, int64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListItemResultsByExptID", arg0, arg1, arg2, arg3, arg4) + ret := m.ctrl.Call(m, "ListItemResultsByExptID", ctx, exptID, spaceID, page, desc) ret0, _ := ret[0].([]*entity.ExptItemResult) ret1, _ := ret[1].(int64) ret2, _ := ret[2].(error) @@ -431,44 +438,44 @@ func (m *MockIExptItemResultRepo) ListItemResultsByExptID(arg0 context.Context, } // ListItemResultsByExptID indicates an expected call of ListItemResultsByExptID. -func (mr *MockIExptItemResultRepoMockRecorder) ListItemResultsByExptID(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call { +func (mr *MockIExptItemResultRepoMockRecorder) ListItemResultsByExptID(ctx, exptID, spaceID, page, desc any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListItemResultsByExptID", reflect.TypeOf((*MockIExptItemResultRepo)(nil).ListItemResultsByExptID), arg0, arg1, arg2, arg3, arg4) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListItemResultsByExptID", reflect.TypeOf((*MockIExptItemResultRepo)(nil).ListItemResultsByExptID), ctx, exptID, spaceID, page, desc) } // MGetItemRunLog mocks base method. -func (m *MockIExptItemResultRepo) MGetItemRunLog(arg0 context.Context, arg1, arg2 int64, arg3 []int64, arg4 int64) ([]*entity.ExptItemResultRunLog, error) { +func (m *MockIExptItemResultRepo) MGetItemRunLog(ctx context.Context, exptID, exptRunID int64, itemIDs []int64, spaceID int64) ([]*entity.ExptItemResultRunLog, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "MGetItemRunLog", arg0, arg1, arg2, arg3, arg4) + ret := m.ctrl.Call(m, "MGetItemRunLog", ctx, exptID, exptRunID, itemIDs, spaceID) ret0, _ := ret[0].([]*entity.ExptItemResultRunLog) ret1, _ := ret[1].(error) return ret0, ret1 } // MGetItemRunLog indicates an expected call of MGetItemRunLog. -func (mr *MockIExptItemResultRepoMockRecorder) MGetItemRunLog(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call { +func (mr *MockIExptItemResultRepoMockRecorder) MGetItemRunLog(ctx, exptID, exptRunID, itemIDs, spaceID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetItemRunLog", reflect.TypeOf((*MockIExptItemResultRepo)(nil).MGetItemRunLog), arg0, arg1, arg2, arg3, arg4) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetItemRunLog", reflect.TypeOf((*MockIExptItemResultRepo)(nil).MGetItemRunLog), ctx, exptID, exptRunID, itemIDs, spaceID) } // SaveItemResults mocks base method. -func (m *MockIExptItemResultRepo) SaveItemResults(arg0 context.Context, arg1 []*entity.ExptItemResult) error { +func (m *MockIExptItemResultRepo) SaveItemResults(ctx context.Context, itemResults []*entity.ExptItemResult) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SaveItemResults", arg0, arg1) + ret := m.ctrl.Call(m, "SaveItemResults", ctx, itemResults) ret0, _ := ret[0].(error) return ret0 } // SaveItemResults indicates an expected call of SaveItemResults. -func (mr *MockIExptItemResultRepoMockRecorder) SaveItemResults(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockIExptItemResultRepoMockRecorder) SaveItemResults(ctx, itemResults any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveItemResults", reflect.TypeOf((*MockIExptItemResultRepo)(nil).SaveItemResults), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveItemResults", reflect.TypeOf((*MockIExptItemResultRepo)(nil).SaveItemResults), ctx, itemResults) } // ScanItemResults mocks base method. -func (m *MockIExptItemResultRepo) ScanItemResults(arg0 context.Context, arg1, arg2, arg3 int64, arg4 []int32, arg5 int64) ([]*entity.ExptItemResult, int64, error) { +func (m *MockIExptItemResultRepo) ScanItemResults(ctx context.Context, exptID, cursor, limit int64, status []int32, spaceID int64) ([]*entity.ExptItemResult, int64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ScanItemResults", arg0, arg1, arg2, arg3, arg4, arg5) + ret := m.ctrl.Call(m, "ScanItemResults", ctx, exptID, cursor, limit, status, spaceID) ret0, _ := ret[0].([]*entity.ExptItemResult) ret1, _ := ret[1].(int64) ret2, _ := ret[2].(error) @@ -476,15 +483,15 @@ func (m *MockIExptItemResultRepo) ScanItemResults(arg0 context.Context, arg1, ar } // ScanItemResults indicates an expected call of ScanItemResults. -func (mr *MockIExptItemResultRepoMockRecorder) ScanItemResults(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call { +func (mr *MockIExptItemResultRepoMockRecorder) ScanItemResults(ctx, exptID, cursor, limit, status, spaceID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanItemResults", reflect.TypeOf((*MockIExptItemResultRepo)(nil).ScanItemResults), arg0, arg1, arg2, arg3, arg4, arg5) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanItemResults", reflect.TypeOf((*MockIExptItemResultRepo)(nil).ScanItemResults), ctx, exptID, cursor, limit, status, spaceID) } // ScanItemRunLogs mocks base method. -func (m *MockIExptItemResultRepo) ScanItemRunLogs(arg0 context.Context, arg1, arg2 int64, arg3 *entity.ExptItemRunLogFilter, arg4, arg5, arg6 int64) ([]*entity.ExptItemResultRunLog, int64, error) { +func (m *MockIExptItemResultRepo) ScanItemRunLogs(ctx context.Context, exptID, exptRunID int64, filter *entity.ExptItemRunLogFilter, cursor, limit, spaceID int64) ([]*entity.ExptItemResultRunLog, int64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ScanItemRunLogs", arg0, arg1, arg2, arg3, arg4, arg5, arg6) + ret := m.ctrl.Call(m, "ScanItemRunLogs", ctx, exptID, exptRunID, filter, cursor, limit, spaceID) ret0, _ := ret[0].([]*entity.ExptItemResultRunLog) ret1, _ := ret[1].(int64) ret2, _ := ret[2].(error) @@ -492,43 +499,44 @@ func (m *MockIExptItemResultRepo) ScanItemRunLogs(arg0 context.Context, arg1, ar } // ScanItemRunLogs indicates an expected call of ScanItemRunLogs. -func (mr *MockIExptItemResultRepoMockRecorder) ScanItemRunLogs(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) *gomock.Call { +func (mr *MockIExptItemResultRepoMockRecorder) ScanItemRunLogs(ctx, exptID, exptRunID, filter, cursor, limit, spaceID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanItemRunLogs", reflect.TypeOf((*MockIExptItemResultRepo)(nil).ScanItemRunLogs), arg0, arg1, arg2, arg3, arg4, arg5, arg6) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanItemRunLogs", reflect.TypeOf((*MockIExptItemResultRepo)(nil).ScanItemRunLogs), ctx, exptID, exptRunID, filter, cursor, limit, spaceID) } // UpdateItemRunLog mocks base method. -func (m *MockIExptItemResultRepo) UpdateItemRunLog(arg0 context.Context, arg1, arg2 int64, arg3 []int64, arg4 map[string]interface{}, arg5 int64) error { +func (m *MockIExptItemResultRepo) UpdateItemRunLog(ctx context.Context, exptID, exptRunID int64, itemID []int64, ufields map[string]any, spaceID int64) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateItemRunLog", arg0, arg1, arg2, arg3, arg4, arg5) + ret := m.ctrl.Call(m, "UpdateItemRunLog", ctx, exptID, exptRunID, itemID, ufields, spaceID) ret0, _ := ret[0].(error) return ret0 } // UpdateItemRunLog indicates an expected call of UpdateItemRunLog. -func (mr *MockIExptItemResultRepoMockRecorder) UpdateItemRunLog(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call { +func (mr *MockIExptItemResultRepoMockRecorder) UpdateItemRunLog(ctx, exptID, exptRunID, itemID, ufields, spaceID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateItemRunLog", reflect.TypeOf((*MockIExptItemResultRepo)(nil).UpdateItemRunLog), arg0, arg1, arg2, arg3, arg4, arg5) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateItemRunLog", reflect.TypeOf((*MockIExptItemResultRepo)(nil).UpdateItemRunLog), ctx, exptID, exptRunID, itemID, ufields, spaceID) } // UpdateItemsResult mocks base method. -func (m *MockIExptItemResultRepo) UpdateItemsResult(arg0 context.Context, arg1, arg2 int64, arg3 []int64, arg4 map[string]interface{}) error { +func (m *MockIExptItemResultRepo) UpdateItemsResult(ctx context.Context, spaceID, exptID int64, itemID []int64, ufields map[string]any) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateItemsResult", arg0, arg1, arg2, arg3, arg4) + ret := m.ctrl.Call(m, "UpdateItemsResult", ctx, spaceID, exptID, itemID, ufields) ret0, _ := ret[0].(error) return ret0 } // UpdateItemsResult indicates an expected call of UpdateItemsResult. -func (mr *MockIExptItemResultRepoMockRecorder) UpdateItemsResult(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call { +func (mr *MockIExptItemResultRepoMockRecorder) UpdateItemsResult(ctx, spaceID, exptID, itemID, ufields any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateItemsResult", reflect.TypeOf((*MockIExptItemResultRepo)(nil).UpdateItemsResult), arg0, arg1, arg2, arg3, arg4) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateItemsResult", reflect.TypeOf((*MockIExptItemResultRepo)(nil).UpdateItemsResult), ctx, spaceID, exptID, itemID, ufields) } // MockIExptTurnResultRepo is a mock of IExptTurnResultRepo interface. type MockIExptTurnResultRepo struct { ctrl *gomock.Controller recorder *MockIExptTurnResultRepoMockRecorder + isgomock struct{} } // MockIExptTurnResultRepoMockRecorder is the mock recorder for MockIExptTurnResultRepo. @@ -549,170 +557,170 @@ func (m *MockIExptTurnResultRepo) EXPECT() *MockIExptTurnResultRepoMockRecorder } // BatchCreateNX mocks base method. -func (m *MockIExptTurnResultRepo) BatchCreateNX(arg0 context.Context, arg1 []*entity.ExptTurnResult) error { +func (m *MockIExptTurnResultRepo) BatchCreateNX(ctx context.Context, turnResults []*entity.ExptTurnResult) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BatchCreateNX", arg0, arg1) + ret := m.ctrl.Call(m, "BatchCreateNX", ctx, turnResults) ret0, _ := ret[0].(error) return ret0 } // BatchCreateNX indicates an expected call of BatchCreateNX. -func (mr *MockIExptTurnResultRepoMockRecorder) BatchCreateNX(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultRepoMockRecorder) BatchCreateNX(ctx, turnResults any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCreateNX", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).BatchCreateNX), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCreateNX", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).BatchCreateNX), ctx, turnResults) } // BatchCreateNXRunLog mocks base method. -func (m *MockIExptTurnResultRepo) BatchCreateNXRunLog(arg0 context.Context, arg1 []*entity.ExptTurnResultRunLog) error { +func (m *MockIExptTurnResultRepo) BatchCreateNXRunLog(ctx context.Context, turnResults []*entity.ExptTurnResultRunLog) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BatchCreateNXRunLog", arg0, arg1) + ret := m.ctrl.Call(m, "BatchCreateNXRunLog", ctx, turnResults) ret0, _ := ret[0].(error) return ret0 } // BatchCreateNXRunLog indicates an expected call of BatchCreateNXRunLog. -func (mr *MockIExptTurnResultRepoMockRecorder) BatchCreateNXRunLog(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultRepoMockRecorder) BatchCreateNXRunLog(ctx, turnResults any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCreateNXRunLog", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).BatchCreateNXRunLog), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCreateNXRunLog", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).BatchCreateNXRunLog), ctx, turnResults) } // BatchGet mocks base method. -func (m *MockIExptTurnResultRepo) BatchGet(arg0 context.Context, arg1, arg2 int64, arg3 []int64) ([]*entity.ExptTurnResult, error) { +func (m *MockIExptTurnResultRepo) BatchGet(ctx context.Context, spaceID, exptID int64, itemIDs []int64) ([]*entity.ExptTurnResult, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BatchGet", arg0, arg1, arg2, arg3) + ret := m.ctrl.Call(m, "BatchGet", ctx, spaceID, exptID, itemIDs) ret0, _ := ret[0].([]*entity.ExptTurnResult) ret1, _ := ret[1].(error) return ret0, ret1 } // BatchGet indicates an expected call of BatchGet. -func (mr *MockIExptTurnResultRepoMockRecorder) BatchGet(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultRepoMockRecorder) BatchGet(ctx, spaceID, exptID, itemIDs any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGet", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).BatchGet), arg0, arg1, arg2, arg3) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGet", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).BatchGet), ctx, spaceID, exptID, itemIDs) } // BatchGetTurnEvaluatorResultRef mocks base method. -func (m *MockIExptTurnResultRepo) BatchGetTurnEvaluatorResultRef(arg0 context.Context, arg1 int64, arg2 []int64) ([]*entity.ExptTurnEvaluatorResultRef, error) { +func (m *MockIExptTurnResultRepo) BatchGetTurnEvaluatorResultRef(ctx context.Context, spaceID int64, exptTurnResultIDs []int64) ([]*entity.ExptTurnEvaluatorResultRef, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BatchGetTurnEvaluatorResultRef", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "BatchGetTurnEvaluatorResultRef", ctx, spaceID, exptTurnResultIDs) ret0, _ := ret[0].([]*entity.ExptTurnEvaluatorResultRef) ret1, _ := ret[1].(error) return ret0, ret1 } // BatchGetTurnEvaluatorResultRef indicates an expected call of BatchGetTurnEvaluatorResultRef. -func (mr *MockIExptTurnResultRepoMockRecorder) BatchGetTurnEvaluatorResultRef(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultRepoMockRecorder) BatchGetTurnEvaluatorResultRef(ctx, spaceID, exptTurnResultIDs any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetTurnEvaluatorResultRef", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).BatchGetTurnEvaluatorResultRef), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetTurnEvaluatorResultRef", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).BatchGetTurnEvaluatorResultRef), ctx, spaceID, exptTurnResultIDs) } // CreateOrUpdateItemsTurnRunLogStatus mocks base method. -func (m *MockIExptTurnResultRepo) CreateOrUpdateItemsTurnRunLogStatus(arg0 context.Context, arg1, arg2, arg3 int64, arg4 []int64, arg5 entity.TurnRunState) error { +func (m *MockIExptTurnResultRepo) CreateOrUpdateItemsTurnRunLogStatus(ctx context.Context, spaceID, exptID, exptRunID int64, itemIDs []int64, status entity.TurnRunState) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateOrUpdateItemsTurnRunLogStatus", arg0, arg1, arg2, arg3, arg4, arg5) + ret := m.ctrl.Call(m, "CreateOrUpdateItemsTurnRunLogStatus", ctx, spaceID, exptID, exptRunID, itemIDs, status) ret0, _ := ret[0].(error) return ret0 } // CreateOrUpdateItemsTurnRunLogStatus indicates an expected call of CreateOrUpdateItemsTurnRunLogStatus. -func (mr *MockIExptTurnResultRepoMockRecorder) CreateOrUpdateItemsTurnRunLogStatus(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultRepoMockRecorder) CreateOrUpdateItemsTurnRunLogStatus(ctx, spaceID, exptID, exptRunID, itemIDs, status any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateItemsTurnRunLogStatus", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).CreateOrUpdateItemsTurnRunLogStatus), arg0, arg1, arg2, arg3, arg4, arg5) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateItemsTurnRunLogStatus", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).CreateOrUpdateItemsTurnRunLogStatus), ctx, spaceID, exptID, exptRunID, itemIDs, status) } // CreateTurnEvaluatorRefs mocks base method. -func (m *MockIExptTurnResultRepo) CreateTurnEvaluatorRefs(arg0 context.Context, arg1 []*entity.ExptTurnEvaluatorResultRef) error { +func (m *MockIExptTurnResultRepo) CreateTurnEvaluatorRefs(ctx context.Context, turnResults []*entity.ExptTurnEvaluatorResultRef) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTurnEvaluatorRefs", arg0, arg1) + ret := m.ctrl.Call(m, "CreateTurnEvaluatorRefs", ctx, turnResults) ret0, _ := ret[0].(error) return ret0 } // CreateTurnEvaluatorRefs indicates an expected call of CreateTurnEvaluatorRefs. -func (mr *MockIExptTurnResultRepoMockRecorder) CreateTurnEvaluatorRefs(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultRepoMockRecorder) CreateTurnEvaluatorRefs(ctx, turnResults any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTurnEvaluatorRefs", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).CreateTurnEvaluatorRefs), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTurnEvaluatorRefs", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).CreateTurnEvaluatorRefs), ctx, turnResults) } // Get mocks base method. -func (m *MockIExptTurnResultRepo) Get(arg0 context.Context, arg1, arg2, arg3, arg4 int64) (*entity.ExptTurnResult, error) { +func (m *MockIExptTurnResultRepo) Get(ctx context.Context, spaceID, exptID, itemID, turnID int64) (*entity.ExptTurnResult, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Get", arg0, arg1, arg2, arg3, arg4) + ret := m.ctrl.Call(m, "Get", ctx, spaceID, exptID, itemID, turnID) ret0, _ := ret[0].(*entity.ExptTurnResult) ret1, _ := ret[1].(error) return ret0, ret1 } // Get indicates an expected call of Get. -func (mr *MockIExptTurnResultRepoMockRecorder) Get(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultRepoMockRecorder) Get(ctx, spaceID, exptID, itemID, turnID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).Get), arg0, arg1, arg2, arg3, arg4) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).Get), ctx, spaceID, exptID, itemID, turnID) } // GetItemTurnResults mocks base method. -func (m *MockIExptTurnResultRepo) GetItemTurnResults(arg0 context.Context, arg1, arg2, arg3 int64) ([]*entity.ExptTurnResult, error) { +func (m *MockIExptTurnResultRepo) GetItemTurnResults(ctx context.Context, exptID, itemID, spaceID int64) ([]*entity.ExptTurnResult, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetItemTurnResults", arg0, arg1, arg2, arg3) + ret := m.ctrl.Call(m, "GetItemTurnResults", ctx, exptID, itemID, spaceID) ret0, _ := ret[0].([]*entity.ExptTurnResult) ret1, _ := ret[1].(error) return ret0, ret1 } // GetItemTurnResults indicates an expected call of GetItemTurnResults. -func (mr *MockIExptTurnResultRepoMockRecorder) GetItemTurnResults(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultRepoMockRecorder) GetItemTurnResults(ctx, exptID, itemID, spaceID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetItemTurnResults", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).GetItemTurnResults), arg0, arg1, arg2, arg3) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetItemTurnResults", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).GetItemTurnResults), ctx, exptID, itemID, spaceID) } // GetItemTurnRunLogs mocks base method. -func (m *MockIExptTurnResultRepo) GetItemTurnRunLogs(arg0 context.Context, arg1, arg2, arg3, arg4 int64) ([]*entity.ExptTurnResultRunLog, error) { +func (m *MockIExptTurnResultRepo) GetItemTurnRunLogs(ctx context.Context, exptID, exptRunID, itemID, spaceID int64) ([]*entity.ExptTurnResultRunLog, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetItemTurnRunLogs", arg0, arg1, arg2, arg3, arg4) + ret := m.ctrl.Call(m, "GetItemTurnRunLogs", ctx, exptID, exptRunID, itemID, spaceID) ret0, _ := ret[0].([]*entity.ExptTurnResultRunLog) ret1, _ := ret[1].(error) return ret0, ret1 } // GetItemTurnRunLogs indicates an expected call of GetItemTurnRunLogs. -func (mr *MockIExptTurnResultRepoMockRecorder) GetItemTurnRunLogs(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultRepoMockRecorder) GetItemTurnRunLogs(ctx, exptID, exptRunID, itemID, spaceID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetItemTurnRunLogs", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).GetItemTurnRunLogs), arg0, arg1, arg2, arg3, arg4) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetItemTurnRunLogs", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).GetItemTurnRunLogs), ctx, exptID, exptRunID, itemID, spaceID) } // GetTurnEvaluatorResultRefByEvaluatorVersionID mocks base method. -func (m *MockIExptTurnResultRepo) GetTurnEvaluatorResultRefByEvaluatorVersionID(arg0 context.Context, arg1, arg2, arg3 int64) ([]*entity.ExptTurnEvaluatorResultRef, error) { +func (m *MockIExptTurnResultRepo) GetTurnEvaluatorResultRefByEvaluatorVersionID(ctx context.Context, spaceID, exptID, evaluatorVersionID int64) ([]*entity.ExptTurnEvaluatorResultRef, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTurnEvaluatorResultRefByEvaluatorVersionID", arg0, arg1, arg2, arg3) + ret := m.ctrl.Call(m, "GetTurnEvaluatorResultRefByEvaluatorVersionID", ctx, spaceID, exptID, evaluatorVersionID) ret0, _ := ret[0].([]*entity.ExptTurnEvaluatorResultRef) ret1, _ := ret[1].(error) return ret0, ret1 } // GetTurnEvaluatorResultRefByEvaluatorVersionID indicates an expected call of GetTurnEvaluatorResultRefByEvaluatorVersionID. -func (mr *MockIExptTurnResultRepoMockRecorder) GetTurnEvaluatorResultRefByEvaluatorVersionID(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultRepoMockRecorder) GetTurnEvaluatorResultRefByEvaluatorVersionID(ctx, spaceID, exptID, evaluatorVersionID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTurnEvaluatorResultRefByEvaluatorVersionID", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).GetTurnEvaluatorResultRefByEvaluatorVersionID), arg0, arg1, arg2, arg3) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTurnEvaluatorResultRefByEvaluatorVersionID", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).GetTurnEvaluatorResultRefByEvaluatorVersionID), ctx, spaceID, exptID, evaluatorVersionID) } // GetTurnEvaluatorResultRefByExptID mocks base method. -func (m *MockIExptTurnResultRepo) GetTurnEvaluatorResultRefByExptID(arg0 context.Context, arg1, arg2 int64) ([]*entity.ExptTurnEvaluatorResultRef, error) { +func (m *MockIExptTurnResultRepo) GetTurnEvaluatorResultRefByExptID(ctx context.Context, spaceID, exptID int64) ([]*entity.ExptTurnEvaluatorResultRef, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTurnEvaluatorResultRefByExptID", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "GetTurnEvaluatorResultRefByExptID", ctx, spaceID, exptID) ret0, _ := ret[0].([]*entity.ExptTurnEvaluatorResultRef) ret1, _ := ret[1].(error) return ret0, ret1 } // GetTurnEvaluatorResultRefByExptID indicates an expected call of GetTurnEvaluatorResultRefByExptID. -func (mr *MockIExptTurnResultRepoMockRecorder) GetTurnEvaluatorResultRefByExptID(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultRepoMockRecorder) GetTurnEvaluatorResultRefByExptID(ctx, spaceID, exptID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTurnEvaluatorResultRefByExptID", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).GetTurnEvaluatorResultRefByExptID), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTurnEvaluatorResultRefByExptID", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).GetTurnEvaluatorResultRefByExptID), ctx, spaceID, exptID) } // ListTurnResult mocks base method. -func (m *MockIExptTurnResultRepo) ListTurnResult(arg0 context.Context, arg1, arg2 int64, arg3 *entity.ExptTurnResultFilter, arg4 entity.Page, arg5 bool) ([]*entity.ExptTurnResult, int64, error) { +func (m *MockIExptTurnResultRepo) ListTurnResult(ctx context.Context, spaceID, exptID int64, filter *entity.ExptTurnResultFilter, page entity.Page, desc bool) ([]*entity.ExptTurnResult, int64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListTurnResult", arg0, arg1, arg2, arg3, arg4, arg5) + ret := m.ctrl.Call(m, "ListTurnResult", ctx, spaceID, exptID, filter, page, desc) ret0, _ := ret[0].([]*entity.ExptTurnResult) ret1, _ := ret[1].(int64) ret2, _ := ret[2].(error) @@ -720,15 +728,15 @@ func (m *MockIExptTurnResultRepo) ListTurnResult(arg0 context.Context, arg1, arg } // ListTurnResult indicates an expected call of ListTurnResult. -func (mr *MockIExptTurnResultRepoMockRecorder) ListTurnResult(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultRepoMockRecorder) ListTurnResult(ctx, spaceID, exptID, filter, page, desc any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTurnResult", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).ListTurnResult), arg0, arg1, arg2, arg3, arg4, arg5) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTurnResult", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).ListTurnResult), ctx, spaceID, exptID, filter, page, desc) } // ListTurnResultByItemIDs mocks base method. -func (m *MockIExptTurnResultRepo) ListTurnResultByItemIDs(arg0 context.Context, arg1, arg2 int64, arg3 []int64, arg4 entity.Page, arg5 bool) ([]*entity.ExptTurnResult, int64, error) { +func (m *MockIExptTurnResultRepo) ListTurnResultByItemIDs(ctx context.Context, spaceID, exptID int64, itemIDs []int64, page entity.Page, desc bool) ([]*entity.ExptTurnResult, int64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListTurnResultByItemIDs", arg0, arg1, arg2, arg3, arg4, arg5) + ret := m.ctrl.Call(m, "ListTurnResultByItemIDs", ctx, spaceID, exptID, itemIDs, page, desc) ret0, _ := ret[0].([]*entity.ExptTurnResult) ret1, _ := ret[1].(int64) ret2, _ := ret[2].(error) @@ -736,58 +744,58 @@ func (m *MockIExptTurnResultRepo) ListTurnResultByItemIDs(arg0 context.Context, } // ListTurnResultByItemIDs indicates an expected call of ListTurnResultByItemIDs. -func (mr *MockIExptTurnResultRepoMockRecorder) ListTurnResultByItemIDs(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultRepoMockRecorder) ListTurnResultByItemIDs(ctx, spaceID, exptID, itemIDs, page, desc any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTurnResultByItemIDs", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).ListTurnResultByItemIDs), arg0, arg1, arg2, arg3, arg4, arg5) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTurnResultByItemIDs", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).ListTurnResultByItemIDs), ctx, spaceID, exptID, itemIDs, page, desc) } // MGetItemTurnRunLogs mocks base method. -func (m *MockIExptTurnResultRepo) MGetItemTurnRunLogs(arg0 context.Context, arg1, arg2 int64, arg3 []int64, arg4 int64) ([]*entity.ExptTurnResultRunLog, error) { +func (m *MockIExptTurnResultRepo) MGetItemTurnRunLogs(ctx context.Context, exptID, exptRunID int64, itemIDs []int64, spaceID int64) ([]*entity.ExptTurnResultRunLog, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "MGetItemTurnRunLogs", arg0, arg1, arg2, arg3, arg4) + ret := m.ctrl.Call(m, "MGetItemTurnRunLogs", ctx, exptID, exptRunID, itemIDs, spaceID) ret0, _ := ret[0].([]*entity.ExptTurnResultRunLog) ret1, _ := ret[1].(error) return ret0, ret1 } // MGetItemTurnRunLogs indicates an expected call of MGetItemTurnRunLogs. -func (mr *MockIExptTurnResultRepoMockRecorder) MGetItemTurnRunLogs(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultRepoMockRecorder) MGetItemTurnRunLogs(ctx, exptID, exptRunID, itemIDs, spaceID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetItemTurnRunLogs", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).MGetItemTurnRunLogs), arg0, arg1, arg2, arg3, arg4) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetItemTurnRunLogs", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).MGetItemTurnRunLogs), ctx, exptID, exptRunID, itemIDs, spaceID) } // SaveTurnResults mocks base method. -func (m *MockIExptTurnResultRepo) SaveTurnResults(arg0 context.Context, arg1 []*entity.ExptTurnResult) error { +func (m *MockIExptTurnResultRepo) SaveTurnResults(ctx context.Context, turnResults []*entity.ExptTurnResult) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SaveTurnResults", arg0, arg1) + ret := m.ctrl.Call(m, "SaveTurnResults", ctx, turnResults) ret0, _ := ret[0].(error) return ret0 } // SaveTurnResults indicates an expected call of SaveTurnResults. -func (mr *MockIExptTurnResultRepoMockRecorder) SaveTurnResults(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultRepoMockRecorder) SaveTurnResults(ctx, turnResults any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveTurnResults", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).SaveTurnResults), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveTurnResults", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).SaveTurnResults), ctx, turnResults) } // SaveTurnRunLogs mocks base method. -func (m *MockIExptTurnResultRepo) SaveTurnRunLogs(arg0 context.Context, arg1 []*entity.ExptTurnResultRunLog) error { +func (m *MockIExptTurnResultRepo) SaveTurnRunLogs(ctx context.Context, turnResults []*entity.ExptTurnResultRunLog) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SaveTurnRunLogs", arg0, arg1) + ret := m.ctrl.Call(m, "SaveTurnRunLogs", ctx, turnResults) ret0, _ := ret[0].(error) return ret0 } // SaveTurnRunLogs indicates an expected call of SaveTurnRunLogs. -func (mr *MockIExptTurnResultRepoMockRecorder) SaveTurnRunLogs(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultRepoMockRecorder) SaveTurnRunLogs(ctx, turnResults any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveTurnRunLogs", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).SaveTurnRunLogs), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveTurnRunLogs", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).SaveTurnRunLogs), ctx, turnResults) } // ScanTurnResults mocks base method. -func (m *MockIExptTurnResultRepo) ScanTurnResults(arg0 context.Context, arg1 int64, arg2 []int32, arg3, arg4, arg5 int64) ([]*entity.ExptTurnResult, int64, error) { +func (m *MockIExptTurnResultRepo) ScanTurnResults(ctx context.Context, exptID int64, status []int32, cursor, limit, spaceID int64) ([]*entity.ExptTurnResult, int64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ScanTurnResults", arg0, arg1, arg2, arg3, arg4, arg5) + ret := m.ctrl.Call(m, "ScanTurnResults", ctx, exptID, status, cursor, limit, spaceID) ret0, _ := ret[0].([]*entity.ExptTurnResult) ret1, _ := ret[1].(int64) ret2, _ := ret[2].(error) @@ -795,15 +803,15 @@ func (m *MockIExptTurnResultRepo) ScanTurnResults(arg0 context.Context, arg1 int } // ScanTurnResults indicates an expected call of ScanTurnResults. -func (mr *MockIExptTurnResultRepoMockRecorder) ScanTurnResults(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultRepoMockRecorder) ScanTurnResults(ctx, exptID, status, cursor, limit, spaceID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanTurnResults", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).ScanTurnResults), arg0, arg1, arg2, arg3, arg4, arg5) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanTurnResults", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).ScanTurnResults), ctx, exptID, status, cursor, limit, spaceID) } // ScanTurnRunLogs mocks base method. -func (m *MockIExptTurnResultRepo) ScanTurnRunLogs(arg0 context.Context, arg1, arg2, arg3, arg4 int64) ([]*entity.ExptTurnResultRunLog, int64, error) { +func (m *MockIExptTurnResultRepo) ScanTurnRunLogs(ctx context.Context, exptID, cursor, limit, spaceID int64) ([]*entity.ExptTurnResultRunLog, int64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ScanTurnRunLogs", arg0, arg1, arg2, arg3, arg4) + ret := m.ctrl.Call(m, "ScanTurnRunLogs", ctx, exptID, cursor, limit, spaceID) ret0, _ := ret[0].([]*entity.ExptTurnResultRunLog) ret1, _ := ret[1].(int64) ret2, _ := ret[2].(error) @@ -811,43 +819,44 @@ func (m *MockIExptTurnResultRepo) ScanTurnRunLogs(arg0 context.Context, arg1, ar } // ScanTurnRunLogs indicates an expected call of ScanTurnRunLogs. -func (mr *MockIExptTurnResultRepoMockRecorder) ScanTurnRunLogs(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultRepoMockRecorder) ScanTurnRunLogs(ctx, exptID, cursor, limit, spaceID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanTurnRunLogs", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).ScanTurnRunLogs), arg0, arg1, arg2, arg3, arg4) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanTurnRunLogs", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).ScanTurnRunLogs), ctx, exptID, cursor, limit, spaceID) } // UpdateTurnResults mocks base method. -func (m *MockIExptTurnResultRepo) UpdateTurnResults(arg0 context.Context, arg1 int64, arg2 []*entity.ItemTurnID, arg3 int64, arg4 map[string]interface{}) error { +func (m *MockIExptTurnResultRepo) UpdateTurnResults(ctx context.Context, exptID int64, itemTurnIDs []*entity.ItemTurnID, spaceID int64, ufields map[string]any) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateTurnResults", arg0, arg1, arg2, arg3, arg4) + ret := m.ctrl.Call(m, "UpdateTurnResults", ctx, exptID, itemTurnIDs, spaceID, ufields) ret0, _ := ret[0].(error) return ret0 } // UpdateTurnResults indicates an expected call of UpdateTurnResults. -func (mr *MockIExptTurnResultRepoMockRecorder) UpdateTurnResults(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultRepoMockRecorder) UpdateTurnResults(ctx, exptID, itemTurnIDs, spaceID, ufields any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTurnResults", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).UpdateTurnResults), arg0, arg1, arg2, arg3, arg4) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTurnResults", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).UpdateTurnResults), ctx, exptID, itemTurnIDs, spaceID, ufields) } // UpdateTurnResultsWithItemIDs mocks base method. -func (m *MockIExptTurnResultRepo) UpdateTurnResultsWithItemIDs(arg0 context.Context, arg1 int64, arg2 []int64, arg3 int64, arg4 map[string]interface{}) error { +func (m *MockIExptTurnResultRepo) UpdateTurnResultsWithItemIDs(ctx context.Context, exptID int64, itemIDs []int64, spaceID int64, ufields map[string]any) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateTurnResultsWithItemIDs", arg0, arg1, arg2, arg3, arg4) + ret := m.ctrl.Call(m, "UpdateTurnResultsWithItemIDs", ctx, exptID, itemIDs, spaceID, ufields) ret0, _ := ret[0].(error) return ret0 } // UpdateTurnResultsWithItemIDs indicates an expected call of UpdateTurnResultsWithItemIDs. -func (mr *MockIExptTurnResultRepoMockRecorder) UpdateTurnResultsWithItemIDs(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultRepoMockRecorder) UpdateTurnResultsWithItemIDs(ctx, exptID, itemIDs, spaceID, ufields any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTurnResultsWithItemIDs", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).UpdateTurnResultsWithItemIDs), arg0, arg1, arg2, arg3, arg4) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTurnResultsWithItemIDs", reflect.TypeOf((*MockIExptTurnResultRepo)(nil).UpdateTurnResultsWithItemIDs), ctx, exptID, itemIDs, spaceID, ufields) } // MockIExptRunLogRepo is a mock of IExptRunLogRepo interface. type MockIExptRunLogRepo struct { ctrl *gomock.Controller recorder *MockIExptRunLogRepoMockRecorder + isgomock struct{} } // MockIExptRunLogRepoMockRecorder is the mock recorder for MockIExptRunLogRepo. @@ -868,66 +877,67 @@ func (m *MockIExptRunLogRepo) EXPECT() *MockIExptRunLogRepoMockRecorder { } // Create mocks base method. -func (m *MockIExptRunLogRepo) Create(arg0 context.Context, arg1 *entity.ExptRunLog) error { +func (m *MockIExptRunLogRepo) Create(ctx context.Context, exptRunLog *entity.ExptRunLog) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Create", arg0, arg1) + ret := m.ctrl.Call(m, "Create", ctx, exptRunLog) ret0, _ := ret[0].(error) return ret0 } // Create indicates an expected call of Create. -func (mr *MockIExptRunLogRepoMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockIExptRunLogRepoMockRecorder) Create(ctx, exptRunLog any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockIExptRunLogRepo)(nil).Create), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockIExptRunLogRepo)(nil).Create), ctx, exptRunLog) } // Get mocks base method. -func (m *MockIExptRunLogRepo) Get(arg0 context.Context, arg1, arg2 int64) (*entity.ExptRunLog, error) { +func (m *MockIExptRunLogRepo) Get(ctx context.Context, exptID, exptRunID int64) (*entity.ExptRunLog, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Get", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "Get", ctx, exptID, exptRunID) ret0, _ := ret[0].(*entity.ExptRunLog) ret1, _ := ret[1].(error) return ret0, ret1 } // Get indicates an expected call of Get. -func (mr *MockIExptRunLogRepoMockRecorder) Get(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockIExptRunLogRepoMockRecorder) Get(ctx, exptID, exptRunID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockIExptRunLogRepo)(nil).Get), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockIExptRunLogRepo)(nil).Get), ctx, exptID, exptRunID) } // Save mocks base method. -func (m *MockIExptRunLogRepo) Save(arg0 context.Context, arg1 *entity.ExptRunLog) error { +func (m *MockIExptRunLogRepo) Save(ctx context.Context, exptRunLog *entity.ExptRunLog) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Save", arg0, arg1) + ret := m.ctrl.Call(m, "Save", ctx, exptRunLog) ret0, _ := ret[0].(error) return ret0 } // Save indicates an expected call of Save. -func (mr *MockIExptRunLogRepoMockRecorder) Save(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockIExptRunLogRepoMockRecorder) Save(ctx, exptRunLog any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockIExptRunLogRepo)(nil).Save), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockIExptRunLogRepo)(nil).Save), ctx, exptRunLog) } // Update mocks base method. -func (m *MockIExptRunLogRepo) Update(arg0 context.Context, arg1, arg2 int64, arg3 map[string]interface{}) error { +func (m *MockIExptRunLogRepo) Update(ctx context.Context, exptID, exptRunID int64, ufields map[string]any) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Update", arg0, arg1, arg2, arg3) + ret := m.ctrl.Call(m, "Update", ctx, exptID, exptRunID, ufields) ret0, _ := ret[0].(error) return ret0 } // Update indicates an expected call of Update. -func (mr *MockIExptRunLogRepoMockRecorder) Update(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +func (mr *MockIExptRunLogRepoMockRecorder) Update(ctx, exptID, exptRunID, ufields any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockIExptRunLogRepo)(nil).Update), arg0, arg1, arg2, arg3) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockIExptRunLogRepo)(nil).Update), ctx, exptID, exptRunID, ufields) } // MockIExptAggrResultRepo is a mock of IExptAggrResultRepo interface. type MockIExptAggrResultRepo struct { ctrl *gomock.Controller recorder *MockIExptAggrResultRepoMockRecorder + isgomock struct{} } // MockIExptAggrResultRepoMockRecorder is the mock recorder for MockIExptAggrResultRepo. @@ -948,53 +958,53 @@ func (m *MockIExptAggrResultRepo) EXPECT() *MockIExptAggrResultRepoMockRecorder } // BatchCreateExptAggrResult mocks base method. -func (m *MockIExptAggrResultRepo) BatchCreateExptAggrResult(arg0 context.Context, arg1 []*entity.ExptAggrResult) error { +func (m *MockIExptAggrResultRepo) BatchCreateExptAggrResult(ctx context.Context, exptAggrResults []*entity.ExptAggrResult) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BatchCreateExptAggrResult", arg0, arg1) + ret := m.ctrl.Call(m, "BatchCreateExptAggrResult", ctx, exptAggrResults) ret0, _ := ret[0].(error) return ret0 } // BatchCreateExptAggrResult indicates an expected call of BatchCreateExptAggrResult. -func (mr *MockIExptAggrResultRepoMockRecorder) BatchCreateExptAggrResult(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockIExptAggrResultRepoMockRecorder) BatchCreateExptAggrResult(ctx, exptAggrResults any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCreateExptAggrResult", reflect.TypeOf((*MockIExptAggrResultRepo)(nil).BatchCreateExptAggrResult), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCreateExptAggrResult", reflect.TypeOf((*MockIExptAggrResultRepo)(nil).BatchCreateExptAggrResult), ctx, exptAggrResults) } // BatchGetExptAggrResultByExperimentIDs mocks base method. -func (m *MockIExptAggrResultRepo) BatchGetExptAggrResultByExperimentIDs(arg0 context.Context, arg1 []int64) ([]*entity.ExptAggrResult, error) { +func (m *MockIExptAggrResultRepo) BatchGetExptAggrResultByExperimentIDs(ctx context.Context, experimentIDs []int64) ([]*entity.ExptAggrResult, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BatchGetExptAggrResultByExperimentIDs", arg0, arg1) + ret := m.ctrl.Call(m, "BatchGetExptAggrResultByExperimentIDs", ctx, experimentIDs) ret0, _ := ret[0].([]*entity.ExptAggrResult) ret1, _ := ret[1].(error) return ret0, ret1 } // BatchGetExptAggrResultByExperimentIDs indicates an expected call of BatchGetExptAggrResultByExperimentIDs. -func (mr *MockIExptAggrResultRepoMockRecorder) BatchGetExptAggrResultByExperimentIDs(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockIExptAggrResultRepoMockRecorder) BatchGetExptAggrResultByExperimentIDs(ctx, experimentIDs any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetExptAggrResultByExperimentIDs", reflect.TypeOf((*MockIExptAggrResultRepo)(nil).BatchGetExptAggrResultByExperimentIDs), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetExptAggrResultByExperimentIDs", reflect.TypeOf((*MockIExptAggrResultRepo)(nil).BatchGetExptAggrResultByExperimentIDs), ctx, experimentIDs) } // CreateExptAggrResult mocks base method. -func (m *MockIExptAggrResultRepo) CreateExptAggrResult(arg0 context.Context, arg1 *entity.ExptAggrResult) error { +func (m *MockIExptAggrResultRepo) CreateExptAggrResult(ctx context.Context, exptAggrResult *entity.ExptAggrResult) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateExptAggrResult", arg0, arg1) + ret := m.ctrl.Call(m, "CreateExptAggrResult", ctx, exptAggrResult) ret0, _ := ret[0].(error) return ret0 } // CreateExptAggrResult indicates an expected call of CreateExptAggrResult. -func (mr *MockIExptAggrResultRepoMockRecorder) CreateExptAggrResult(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockIExptAggrResultRepoMockRecorder) CreateExptAggrResult(ctx, exptAggrResult any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateExptAggrResult", reflect.TypeOf((*MockIExptAggrResultRepo)(nil).CreateExptAggrResult), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateExptAggrResult", reflect.TypeOf((*MockIExptAggrResultRepo)(nil).CreateExptAggrResult), ctx, exptAggrResult) } // DeleteExptAggrResult mocks base method. -func (m *MockIExptAggrResultRepo) DeleteExptAggrResult(arg0 context.Context, arg1 *entity.ExptAggrResult, arg2 ...db.Option) error { +func (m *MockIExptAggrResultRepo) DeleteExptAggrResult(ctx context.Context, exptAggrResult *entity.ExptAggrResult, opts ...db.Option) error { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, exptAggrResult} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DeleteExptAggrResult", varargs...) @@ -1003,75 +1013,76 @@ func (m *MockIExptAggrResultRepo) DeleteExptAggrResult(arg0 context.Context, arg } // DeleteExptAggrResult indicates an expected call of DeleteExptAggrResult. -func (mr *MockIExptAggrResultRepoMockRecorder) DeleteExptAggrResult(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +func (mr *MockIExptAggrResultRepoMockRecorder) DeleteExptAggrResult(ctx, exptAggrResult any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) + varargs := append([]any{ctx, exptAggrResult}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteExptAggrResult", reflect.TypeOf((*MockIExptAggrResultRepo)(nil).DeleteExptAggrResult), varargs...) } // GetExptAggrResult mocks base method. -func (m *MockIExptAggrResultRepo) GetExptAggrResult(arg0 context.Context, arg1 int64, arg2 int32, arg3 string) (*entity.ExptAggrResult, error) { +func (m *MockIExptAggrResultRepo) GetExptAggrResult(ctx context.Context, experimentID int64, fieldType int32, fieldKey string) (*entity.ExptAggrResult, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetExptAggrResult", arg0, arg1, arg2, arg3) + ret := m.ctrl.Call(m, "GetExptAggrResult", ctx, experimentID, fieldType, fieldKey) ret0, _ := ret[0].(*entity.ExptAggrResult) ret1, _ := ret[1].(error) return ret0, ret1 } // GetExptAggrResult indicates an expected call of GetExptAggrResult. -func (mr *MockIExptAggrResultRepoMockRecorder) GetExptAggrResult(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +func (mr *MockIExptAggrResultRepoMockRecorder) GetExptAggrResult(ctx, experimentID, fieldType, fieldKey any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExptAggrResult", reflect.TypeOf((*MockIExptAggrResultRepo)(nil).GetExptAggrResult), arg0, arg1, arg2, arg3) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExptAggrResult", reflect.TypeOf((*MockIExptAggrResultRepo)(nil).GetExptAggrResult), ctx, experimentID, fieldType, fieldKey) } // GetExptAggrResultByExperimentID mocks base method. -func (m *MockIExptAggrResultRepo) GetExptAggrResultByExperimentID(arg0 context.Context, arg1 int64) ([]*entity.ExptAggrResult, error) { +func (m *MockIExptAggrResultRepo) GetExptAggrResultByExperimentID(ctx context.Context, experimentID int64) ([]*entity.ExptAggrResult, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetExptAggrResultByExperimentID", arg0, arg1) + ret := m.ctrl.Call(m, "GetExptAggrResultByExperimentID", ctx, experimentID) ret0, _ := ret[0].([]*entity.ExptAggrResult) ret1, _ := ret[1].(error) return ret0, ret1 } // GetExptAggrResultByExperimentID indicates an expected call of GetExptAggrResultByExperimentID. -func (mr *MockIExptAggrResultRepoMockRecorder) GetExptAggrResultByExperimentID(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockIExptAggrResultRepoMockRecorder) GetExptAggrResultByExperimentID(ctx, experimentID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExptAggrResultByExperimentID", reflect.TypeOf((*MockIExptAggrResultRepo)(nil).GetExptAggrResultByExperimentID), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExptAggrResultByExperimentID", reflect.TypeOf((*MockIExptAggrResultRepo)(nil).GetExptAggrResultByExperimentID), ctx, experimentID) } // UpdateAndGetLatestVersion mocks base method. -func (m *MockIExptAggrResultRepo) UpdateAndGetLatestVersion(arg0 context.Context, arg1 int64, arg2 int32, arg3 string) (int64, error) { +func (m *MockIExptAggrResultRepo) UpdateAndGetLatestVersion(ctx context.Context, experimentID int64, fieldType int32, fieldKey string) (int64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateAndGetLatestVersion", arg0, arg1, arg2, arg3) + ret := m.ctrl.Call(m, "UpdateAndGetLatestVersion", ctx, experimentID, fieldType, fieldKey) ret0, _ := ret[0].(int64) ret1, _ := ret[1].(error) return ret0, ret1 } // UpdateAndGetLatestVersion indicates an expected call of UpdateAndGetLatestVersion. -func (mr *MockIExptAggrResultRepoMockRecorder) UpdateAndGetLatestVersion(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +func (mr *MockIExptAggrResultRepoMockRecorder) UpdateAndGetLatestVersion(ctx, experimentID, fieldType, fieldKey any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAndGetLatestVersion", reflect.TypeOf((*MockIExptAggrResultRepo)(nil).UpdateAndGetLatestVersion), arg0, arg1, arg2, arg3) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAndGetLatestVersion", reflect.TypeOf((*MockIExptAggrResultRepo)(nil).UpdateAndGetLatestVersion), ctx, experimentID, fieldType, fieldKey) } // UpdateExptAggrResultByVersion mocks base method. -func (m *MockIExptAggrResultRepo) UpdateExptAggrResultByVersion(arg0 context.Context, arg1 *entity.ExptAggrResult, arg2 int64) error { +func (m *MockIExptAggrResultRepo) UpdateExptAggrResultByVersion(ctx context.Context, exptAggrResult *entity.ExptAggrResult, taskVersion int64) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateExptAggrResultByVersion", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "UpdateExptAggrResultByVersion", ctx, exptAggrResult, taskVersion) ret0, _ := ret[0].(error) return ret0 } // UpdateExptAggrResultByVersion indicates an expected call of UpdateExptAggrResultByVersion. -func (mr *MockIExptAggrResultRepoMockRecorder) UpdateExptAggrResultByVersion(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockIExptAggrResultRepoMockRecorder) UpdateExptAggrResultByVersion(ctx, exptAggrResult, taskVersion any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateExptAggrResultByVersion", reflect.TypeOf((*MockIExptAggrResultRepo)(nil).UpdateExptAggrResultByVersion), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateExptAggrResultByVersion", reflect.TypeOf((*MockIExptAggrResultRepo)(nil).UpdateExptAggrResultByVersion), ctx, exptAggrResult, taskVersion) } // MockQuotaRepo is a mock of QuotaRepo interface. type MockQuotaRepo struct { ctrl *gomock.Controller recorder *MockQuotaRepoMockRecorder + isgomock struct{} } // MockQuotaRepoMockRecorder is the mock recorder for MockQuotaRepo. @@ -1092,23 +1103,24 @@ func (m *MockQuotaRepo) EXPECT() *MockQuotaRepoMockRecorder { } // CreateOrUpdate mocks base method. -func (m *MockQuotaRepo) CreateOrUpdate(arg0 context.Context, arg1 int64, arg2 func(*entity.QuotaSpaceExpt) (*entity.QuotaSpaceExpt, bool, error), arg3 *entity.Session) error { +func (m *MockQuotaRepo) CreateOrUpdate(ctx context.Context, spaceID int64, updater func(*entity.QuotaSpaceExpt) (*entity.QuotaSpaceExpt, bool, error), session *entity.Session) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateOrUpdate", arg0, arg1, arg2, arg3) + ret := m.ctrl.Call(m, "CreateOrUpdate", ctx, spaceID, updater, session) ret0, _ := ret[0].(error) return ret0 } // CreateOrUpdate indicates an expected call of CreateOrUpdate. -func (mr *MockQuotaRepoMockRecorder) CreateOrUpdate(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +func (mr *MockQuotaRepoMockRecorder) CreateOrUpdate(ctx, spaceID, updater, session any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdate", reflect.TypeOf((*MockQuotaRepo)(nil).CreateOrUpdate), arg0, arg1, arg2, arg3) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdate", reflect.TypeOf((*MockQuotaRepo)(nil).CreateOrUpdate), ctx, spaceID, updater, session) } // MockIExptTurnResultFilterRepo is a mock of IExptTurnResultFilterRepo interface. type MockIExptTurnResultFilterRepo struct { ctrl *gomock.Controller recorder *MockIExptTurnResultFilterRepoMockRecorder + isgomock struct{} } // MockIExptTurnResultFilterRepoMockRecorder is the mock recorder for MockIExptTurnResultFilterRepo. @@ -1129,10 +1141,10 @@ func (m *MockIExptTurnResultFilterRepo) EXPECT() *MockIExptTurnResultFilterRepoM } // DeleteExptTurnResultFilterKeyMapping mocks base method. -func (m *MockIExptTurnResultFilterRepo) DeleteExptTurnResultFilterKeyMapping(arg0 context.Context, arg1 *entity.ExptTurnResultFilterKeyMapping, arg2 ...db.Option) error { +func (m *MockIExptTurnResultFilterRepo) DeleteExptTurnResultFilterKeyMapping(ctx context.Context, mapping *entity.ExptTurnResultFilterKeyMapping, opts ...db.Option) error { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, mapping} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DeleteExptTurnResultFilterKeyMapping", varargs...) @@ -1141,60 +1153,60 @@ func (m *MockIExptTurnResultFilterRepo) DeleteExptTurnResultFilterKeyMapping(arg } // DeleteExptTurnResultFilterKeyMapping indicates an expected call of DeleteExptTurnResultFilterKeyMapping. -func (mr *MockIExptTurnResultFilterRepoMockRecorder) DeleteExptTurnResultFilterKeyMapping(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +func (mr *MockIExptTurnResultFilterRepoMockRecorder) DeleteExptTurnResultFilterKeyMapping(ctx, mapping any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) + varargs := append([]any{ctx, mapping}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteExptTurnResultFilterKeyMapping", reflect.TypeOf((*MockIExptTurnResultFilterRepo)(nil).DeleteExptTurnResultFilterKeyMapping), varargs...) } // GetByExptIDItemIDs mocks base method. -func (m *MockIExptTurnResultFilterRepo) GetByExptIDItemIDs(arg0 context.Context, arg1, arg2, arg3 string, arg4 []string) ([]*entity.ExptTurnResultFilterEntity, error) { +func (m *MockIExptTurnResultFilterRepo) GetByExptIDItemIDs(ctx context.Context, spaceID, exptID, createdDate string, itemIDs []string) ([]*entity.ExptTurnResultFilterEntity, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetByExptIDItemIDs", arg0, arg1, arg2, arg3, arg4) + ret := m.ctrl.Call(m, "GetByExptIDItemIDs", ctx, spaceID, exptID, createdDate, itemIDs) ret0, _ := ret[0].([]*entity.ExptTurnResultFilterEntity) ret1, _ := ret[1].(error) return ret0, ret1 } // GetByExptIDItemIDs indicates an expected call of GetByExptIDItemIDs. -func (mr *MockIExptTurnResultFilterRepoMockRecorder) GetByExptIDItemIDs(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultFilterRepoMockRecorder) GetByExptIDItemIDs(ctx, spaceID, exptID, createdDate, itemIDs any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByExptIDItemIDs", reflect.TypeOf((*MockIExptTurnResultFilterRepo)(nil).GetByExptIDItemIDs), arg0, arg1, arg2, arg3, arg4) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByExptIDItemIDs", reflect.TypeOf((*MockIExptTurnResultFilterRepo)(nil).GetByExptIDItemIDs), ctx, spaceID, exptID, createdDate, itemIDs) } // GetExptTurnResultFilterKeyMappings mocks base method. -func (m *MockIExptTurnResultFilterRepo) GetExptTurnResultFilterKeyMappings(arg0 context.Context, arg1, arg2 int64) ([]*entity.ExptTurnResultFilterKeyMapping, error) { +func (m *MockIExptTurnResultFilterRepo) GetExptTurnResultFilterKeyMappings(ctx context.Context, spaceID, exptID int64) ([]*entity.ExptTurnResultFilterKeyMapping, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetExptTurnResultFilterKeyMappings", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "GetExptTurnResultFilterKeyMappings", ctx, spaceID, exptID) ret0, _ := ret[0].([]*entity.ExptTurnResultFilterKeyMapping) ret1, _ := ret[1].(error) return ret0, ret1 } // GetExptTurnResultFilterKeyMappings indicates an expected call of GetExptTurnResultFilterKeyMappings. -func (mr *MockIExptTurnResultFilterRepoMockRecorder) GetExptTurnResultFilterKeyMappings(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultFilterRepoMockRecorder) GetExptTurnResultFilterKeyMappings(ctx, spaceID, exptID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExptTurnResultFilterKeyMappings", reflect.TypeOf((*MockIExptTurnResultFilterRepo)(nil).GetExptTurnResultFilterKeyMappings), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExptTurnResultFilterKeyMappings", reflect.TypeOf((*MockIExptTurnResultFilterRepo)(nil).GetExptTurnResultFilterKeyMappings), ctx, spaceID, exptID) } // InsertExptTurnResultFilterKeyMappings mocks base method. -func (m *MockIExptTurnResultFilterRepo) InsertExptTurnResultFilterKeyMappings(arg0 context.Context, arg1 []*entity.ExptTurnResultFilterKeyMapping) error { +func (m *MockIExptTurnResultFilterRepo) InsertExptTurnResultFilterKeyMappings(ctx context.Context, mappings []*entity.ExptTurnResultFilterKeyMapping) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "InsertExptTurnResultFilterKeyMappings", arg0, arg1) + ret := m.ctrl.Call(m, "InsertExptTurnResultFilterKeyMappings", ctx, mappings) ret0, _ := ret[0].(error) return ret0 } // InsertExptTurnResultFilterKeyMappings indicates an expected call of InsertExptTurnResultFilterKeyMappings. -func (mr *MockIExptTurnResultFilterRepoMockRecorder) InsertExptTurnResultFilterKeyMappings(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultFilterRepoMockRecorder) InsertExptTurnResultFilterKeyMappings(ctx, mappings any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertExptTurnResultFilterKeyMappings", reflect.TypeOf((*MockIExptTurnResultFilterRepo)(nil).InsertExptTurnResultFilterKeyMappings), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertExptTurnResultFilterKeyMappings", reflect.TypeOf((*MockIExptTurnResultFilterRepo)(nil).InsertExptTurnResultFilterKeyMappings), ctx, mappings) } // QueryItemIDStates mocks base method. -func (m *MockIExptTurnResultFilterRepo) QueryItemIDStates(arg0 context.Context, arg1 *entity.ExptTurnResultFilterAccelerator) (map[int64]entity.ItemRunState, int64, error) { +func (m *MockIExptTurnResultFilterRepo) QueryItemIDStates(ctx context.Context, filter *entity.ExptTurnResultFilterAccelerator) (map[int64]entity.ItemRunState, int64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QueryItemIDStates", arg0, arg1) + ret := m.ctrl.Call(m, "QueryItemIDStates", ctx, filter) ret0, _ := ret[0].(map[int64]entity.ItemRunState) ret1, _ := ret[1].(int64) ret2, _ := ret[2].(error) @@ -1202,29 +1214,30 @@ func (m *MockIExptTurnResultFilterRepo) QueryItemIDStates(arg0 context.Context, } // QueryItemIDStates indicates an expected call of QueryItemIDStates. -func (mr *MockIExptTurnResultFilterRepoMockRecorder) QueryItemIDStates(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultFilterRepoMockRecorder) QueryItemIDStates(ctx, filter any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryItemIDStates", reflect.TypeOf((*MockIExptTurnResultFilterRepo)(nil).QueryItemIDStates), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryItemIDStates", reflect.TypeOf((*MockIExptTurnResultFilterRepo)(nil).QueryItemIDStates), ctx, filter) } // Save mocks base method. -func (m *MockIExptTurnResultFilterRepo) Save(arg0 context.Context, arg1 []*entity.ExptTurnResultFilterEntity) error { +func (m *MockIExptTurnResultFilterRepo) Save(ctx context.Context, filters []*entity.ExptTurnResultFilterEntity) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Save", arg0, arg1) + ret := m.ctrl.Call(m, "Save", ctx, filters) ret0, _ := ret[0].(error) return ret0 } // Save indicates an expected call of Save. -func (mr *MockIExptTurnResultFilterRepoMockRecorder) Save(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultFilterRepoMockRecorder) Save(ctx, filters any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockIExptTurnResultFilterRepo)(nil).Save), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockIExptTurnResultFilterRepo)(nil).Save), ctx, filters) } // MockIExptAnnotateRepo is a mock of IExptAnnotateRepo interface. type MockIExptAnnotateRepo struct { ctrl *gomock.Controller recorder *MockIExptAnnotateRepoMockRecorder + isgomock struct{} } // MockIExptAnnotateRepoMockRecorder is the mock recorder for MockIExptAnnotateRepo. @@ -1245,68 +1258,68 @@ func (m *MockIExptAnnotateRepo) EXPECT() *MockIExptAnnotateRepoMockRecorder { } // BatchGetExptTurnAnnotateRecordRefs mocks base method. -func (m *MockIExptAnnotateRepo) BatchGetExptTurnAnnotateRecordRefs(arg0 context.Context, arg1 []int64, arg2 int64) ([]*entity.ExptTurnAnnotateRecordRef, error) { +func (m *MockIExptAnnotateRepo) BatchGetExptTurnAnnotateRecordRefs(ctx context.Context, exptIDs []int64, spaceID int64) ([]*entity.ExptTurnAnnotateRecordRef, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BatchGetExptTurnAnnotateRecordRefs", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "BatchGetExptTurnAnnotateRecordRefs", ctx, exptIDs, spaceID) ret0, _ := ret[0].([]*entity.ExptTurnAnnotateRecordRef) ret1, _ := ret[1].(error) return ret0, ret1 } // BatchGetExptTurnAnnotateRecordRefs indicates an expected call of BatchGetExptTurnAnnotateRecordRefs. -func (mr *MockIExptAnnotateRepoMockRecorder) BatchGetExptTurnAnnotateRecordRefs(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockIExptAnnotateRepoMockRecorder) BatchGetExptTurnAnnotateRecordRefs(ctx, exptIDs, spaceID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetExptTurnAnnotateRecordRefs", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).BatchGetExptTurnAnnotateRecordRefs), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetExptTurnAnnotateRecordRefs", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).BatchGetExptTurnAnnotateRecordRefs), ctx, exptIDs, spaceID) } // BatchGetExptTurnResultTagRefs mocks base method. -func (m *MockIExptAnnotateRepo) BatchGetExptTurnResultTagRefs(arg0 context.Context, arg1 []int64, arg2 int64) ([]*entity.ExptTurnResultTagRef, error) { +func (m *MockIExptAnnotateRepo) BatchGetExptTurnResultTagRefs(ctx context.Context, exptIDs []int64, spaceID int64) ([]*entity.ExptTurnResultTagRef, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BatchGetExptTurnResultTagRefs", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "BatchGetExptTurnResultTagRefs", ctx, exptIDs, spaceID) ret0, _ := ret[0].([]*entity.ExptTurnResultTagRef) ret1, _ := ret[1].(error) return ret0, ret1 } // BatchGetExptTurnResultTagRefs indicates an expected call of BatchGetExptTurnResultTagRefs. -func (mr *MockIExptAnnotateRepoMockRecorder) BatchGetExptTurnResultTagRefs(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockIExptAnnotateRepoMockRecorder) BatchGetExptTurnResultTagRefs(ctx, exptIDs, spaceID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetExptTurnResultTagRefs", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).BatchGetExptTurnResultTagRefs), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetExptTurnResultTagRefs", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).BatchGetExptTurnResultTagRefs), ctx, exptIDs, spaceID) } // CreateExptTurnAnnotateRecordRefs mocks base method. -func (m *MockIExptAnnotateRepo) CreateExptTurnAnnotateRecordRefs(arg0 context.Context, arg1 *entity.ExptTurnAnnotateRecordRef) error { +func (m *MockIExptAnnotateRepo) CreateExptTurnAnnotateRecordRefs(ctx context.Context, refs *entity.ExptTurnAnnotateRecordRef) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateExptTurnAnnotateRecordRefs", arg0, arg1) + ret := m.ctrl.Call(m, "CreateExptTurnAnnotateRecordRefs", ctx, refs) ret0, _ := ret[0].(error) return ret0 } // CreateExptTurnAnnotateRecordRefs indicates an expected call of CreateExptTurnAnnotateRecordRefs. -func (mr *MockIExptAnnotateRepoMockRecorder) CreateExptTurnAnnotateRecordRefs(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockIExptAnnotateRepoMockRecorder) CreateExptTurnAnnotateRecordRefs(ctx, refs any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateExptTurnAnnotateRecordRefs", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).CreateExptTurnAnnotateRecordRefs), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateExptTurnAnnotateRecordRefs", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).CreateExptTurnAnnotateRecordRefs), ctx, refs) } // CreateExptTurnResultTagRefs mocks base method. -func (m *MockIExptAnnotateRepo) CreateExptTurnResultTagRefs(arg0 context.Context, arg1 []*entity.ExptTurnResultTagRef) error { +func (m *MockIExptAnnotateRepo) CreateExptTurnResultTagRefs(ctx context.Context, refs []*entity.ExptTurnResultTagRef) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateExptTurnResultTagRefs", arg0, arg1) + ret := m.ctrl.Call(m, "CreateExptTurnResultTagRefs", ctx, refs) ret0, _ := ret[0].(error) return ret0 } // CreateExptTurnResultTagRefs indicates an expected call of CreateExptTurnResultTagRefs. -func (mr *MockIExptAnnotateRepoMockRecorder) CreateExptTurnResultTagRefs(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockIExptAnnotateRepoMockRecorder) CreateExptTurnResultTagRefs(ctx, refs any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateExptTurnResultTagRefs", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).CreateExptTurnResultTagRefs), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateExptTurnResultTagRefs", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).CreateExptTurnResultTagRefs), ctx, refs) } // DeleteExptTurnResultTagRef mocks base method. -func (m *MockIExptAnnotateRepo) DeleteExptTurnResultTagRef(arg0 context.Context, arg1, arg2, arg3 int64, arg4 ...db.Option) error { +func (m *MockIExptAnnotateRepo) DeleteExptTurnResultTagRef(ctx context.Context, exptID, spaceID, tagKeyID int64, opts ...db.Option) error { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2, arg3} - for _, a := range arg4 { + varargs := []any{ctx, exptID, spaceID, tagKeyID} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DeleteExptTurnResultTagRef", varargs...) @@ -1315,17 +1328,17 @@ func (m *MockIExptAnnotateRepo) DeleteExptTurnResultTagRef(arg0 context.Context, } // DeleteExptTurnResultTagRef indicates an expected call of DeleteExptTurnResultTagRef. -func (mr *MockIExptAnnotateRepoMockRecorder) DeleteExptTurnResultTagRef(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call { +func (mr *MockIExptAnnotateRepoMockRecorder) DeleteExptTurnResultTagRef(ctx, exptID, spaceID, tagKeyID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...) + varargs := append([]any{ctx, exptID, spaceID, tagKeyID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteExptTurnResultTagRef", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).DeleteExptTurnResultTagRef), varargs...) } // DeleteTurnAnnotateRecordRef mocks base method. -func (m *MockIExptAnnotateRepo) DeleteTurnAnnotateRecordRef(arg0 context.Context, arg1, arg2, arg3 int64, arg4 ...db.Option) error { +func (m *MockIExptAnnotateRepo) DeleteTurnAnnotateRecordRef(ctx context.Context, exptID, spaceID, tagKeyID int64, opts ...db.Option) error { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2, arg3} - for _, a := range arg4 { + varargs := []any{ctx, exptID, spaceID, tagKeyID} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DeleteTurnAnnotateRecordRef", varargs...) @@ -1334,122 +1347,122 @@ func (m *MockIExptAnnotateRepo) DeleteTurnAnnotateRecordRef(arg0 context.Context } // DeleteTurnAnnotateRecordRef indicates an expected call of DeleteTurnAnnotateRecordRef. -func (mr *MockIExptAnnotateRepoMockRecorder) DeleteTurnAnnotateRecordRef(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call { +func (mr *MockIExptAnnotateRepoMockRecorder) DeleteTurnAnnotateRecordRef(ctx, exptID, spaceID, tagKeyID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...) + varargs := append([]any{ctx, exptID, spaceID, tagKeyID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTurnAnnotateRecordRef", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).DeleteTurnAnnotateRecordRef), varargs...) } // GetAnnotateRecordByID mocks base method. -func (m *MockIExptAnnotateRepo) GetAnnotateRecordByID(arg0 context.Context, arg1, arg2 int64) (*entity.AnnotateRecord, error) { +func (m *MockIExptAnnotateRepo) GetAnnotateRecordByID(ctx context.Context, spaceID, recordID int64) (*entity.AnnotateRecord, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetAnnotateRecordByID", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "GetAnnotateRecordByID", ctx, spaceID, recordID) ret0, _ := ret[0].(*entity.AnnotateRecord) ret1, _ := ret[1].(error) return ret0, ret1 } // GetAnnotateRecordByID indicates an expected call of GetAnnotateRecordByID. -func (mr *MockIExptAnnotateRepoMockRecorder) GetAnnotateRecordByID(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockIExptAnnotateRepoMockRecorder) GetAnnotateRecordByID(ctx, spaceID, recordID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAnnotateRecordByID", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).GetAnnotateRecordByID), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAnnotateRecordByID", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).GetAnnotateRecordByID), ctx, spaceID, recordID) } // GetAnnotateRecordsByIDs mocks base method. -func (m *MockIExptAnnotateRepo) GetAnnotateRecordsByIDs(arg0 context.Context, arg1 int64, arg2 []int64) ([]*entity.AnnotateRecord, error) { +func (m *MockIExptAnnotateRepo) GetAnnotateRecordsByIDs(ctx context.Context, spaceID int64, recordIDs []int64) ([]*entity.AnnotateRecord, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetAnnotateRecordsByIDs", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "GetAnnotateRecordsByIDs", ctx, spaceID, recordIDs) ret0, _ := ret[0].([]*entity.AnnotateRecord) ret1, _ := ret[1].(error) return ret0, ret1 } // GetAnnotateRecordsByIDs indicates an expected call of GetAnnotateRecordsByIDs. -func (mr *MockIExptAnnotateRepoMockRecorder) GetAnnotateRecordsByIDs(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockIExptAnnotateRepoMockRecorder) GetAnnotateRecordsByIDs(ctx, spaceID, recordIDs any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAnnotateRecordsByIDs", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).GetAnnotateRecordsByIDs), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAnnotateRecordsByIDs", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).GetAnnotateRecordsByIDs), ctx, spaceID, recordIDs) } // GetExptTurnAnnotateRecordRefs mocks base method. -func (m *MockIExptAnnotateRepo) GetExptTurnAnnotateRecordRefs(arg0 context.Context, arg1, arg2 int64) ([]*entity.ExptTurnAnnotateRecordRef, error) { +func (m *MockIExptAnnotateRepo) GetExptTurnAnnotateRecordRefs(ctx context.Context, exptID, spaceID int64) ([]*entity.ExptTurnAnnotateRecordRef, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetExptTurnAnnotateRecordRefs", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "GetExptTurnAnnotateRecordRefs", ctx, exptID, spaceID) ret0, _ := ret[0].([]*entity.ExptTurnAnnotateRecordRef) ret1, _ := ret[1].(error) return ret0, ret1 } // GetExptTurnAnnotateRecordRefs indicates an expected call of GetExptTurnAnnotateRecordRefs. -func (mr *MockIExptAnnotateRepoMockRecorder) GetExptTurnAnnotateRecordRefs(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockIExptAnnotateRepoMockRecorder) GetExptTurnAnnotateRecordRefs(ctx, exptID, spaceID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExptTurnAnnotateRecordRefs", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).GetExptTurnAnnotateRecordRefs), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExptTurnAnnotateRecordRefs", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).GetExptTurnAnnotateRecordRefs), ctx, exptID, spaceID) } // GetExptTurnAnnotateRecordRefsByTagKeyID mocks base method. -func (m *MockIExptAnnotateRepo) GetExptTurnAnnotateRecordRefsByTagKeyID(arg0 context.Context, arg1, arg2, arg3 int64) ([]*entity.ExptTurnAnnotateRecordRef, error) { +func (m *MockIExptAnnotateRepo) GetExptTurnAnnotateRecordRefsByTagKeyID(ctx context.Context, exptID, spaceID, tagKeyID int64) ([]*entity.ExptTurnAnnotateRecordRef, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetExptTurnAnnotateRecordRefsByTagKeyID", arg0, arg1, arg2, arg3) + ret := m.ctrl.Call(m, "GetExptTurnAnnotateRecordRefsByTagKeyID", ctx, exptID, spaceID, tagKeyID) ret0, _ := ret[0].([]*entity.ExptTurnAnnotateRecordRef) ret1, _ := ret[1].(error) return ret0, ret1 } // GetExptTurnAnnotateRecordRefsByTagKeyID indicates an expected call of GetExptTurnAnnotateRecordRefsByTagKeyID. -func (mr *MockIExptAnnotateRepoMockRecorder) GetExptTurnAnnotateRecordRefsByTagKeyID(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +func (mr *MockIExptAnnotateRepoMockRecorder) GetExptTurnAnnotateRecordRefsByTagKeyID(ctx, exptID, spaceID, tagKeyID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExptTurnAnnotateRecordRefsByTagKeyID", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).GetExptTurnAnnotateRecordRefsByTagKeyID), arg0, arg1, arg2, arg3) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExptTurnAnnotateRecordRefsByTagKeyID", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).GetExptTurnAnnotateRecordRefsByTagKeyID), ctx, exptID, spaceID, tagKeyID) } // GetExptTurnAnnotateRecordRefsByTurnResultIDs mocks base method. -func (m *MockIExptAnnotateRepo) GetExptTurnAnnotateRecordRefsByTurnResultIDs(arg0 context.Context, arg1 int64, arg2 []int64) ([]*entity.ExptTurnAnnotateRecordRef, error) { +func (m *MockIExptAnnotateRepo) GetExptTurnAnnotateRecordRefsByTurnResultIDs(ctx context.Context, exptID int64, turnResultIDs []int64) ([]*entity.ExptTurnAnnotateRecordRef, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetExptTurnAnnotateRecordRefsByTurnResultIDs", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "GetExptTurnAnnotateRecordRefsByTurnResultIDs", ctx, exptID, turnResultIDs) ret0, _ := ret[0].([]*entity.ExptTurnAnnotateRecordRef) ret1, _ := ret[1].(error) return ret0, ret1 } // GetExptTurnAnnotateRecordRefsByTurnResultIDs indicates an expected call of GetExptTurnAnnotateRecordRefsByTurnResultIDs. -func (mr *MockIExptAnnotateRepoMockRecorder) GetExptTurnAnnotateRecordRefsByTurnResultIDs(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockIExptAnnotateRepoMockRecorder) GetExptTurnAnnotateRecordRefsByTurnResultIDs(ctx, exptID, turnResultIDs any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExptTurnAnnotateRecordRefsByTurnResultIDs", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).GetExptTurnAnnotateRecordRefsByTurnResultIDs), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExptTurnAnnotateRecordRefsByTurnResultIDs", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).GetExptTurnAnnotateRecordRefsByTurnResultIDs), ctx, exptID, turnResultIDs) } // GetExptTurnResultTagRefs mocks base method. -func (m *MockIExptAnnotateRepo) GetExptTurnResultTagRefs(arg0 context.Context, arg1, arg2 int64) ([]*entity.ExptTurnResultTagRef, error) { +func (m *MockIExptAnnotateRepo) GetExptTurnResultTagRefs(ctx context.Context, exptID, spaceID int64) ([]*entity.ExptTurnResultTagRef, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetExptTurnResultTagRefs", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "GetExptTurnResultTagRefs", ctx, exptID, spaceID) ret0, _ := ret[0].([]*entity.ExptTurnResultTagRef) ret1, _ := ret[1].(error) return ret0, ret1 } // GetExptTurnResultTagRefs indicates an expected call of GetExptTurnResultTagRefs. -func (mr *MockIExptAnnotateRepoMockRecorder) GetExptTurnResultTagRefs(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockIExptAnnotateRepoMockRecorder) GetExptTurnResultTagRefs(ctx, exptID, spaceID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExptTurnResultTagRefs", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).GetExptTurnResultTagRefs), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExptTurnResultTagRefs", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).GetExptTurnResultTagRefs), ctx, exptID, spaceID) } // GetTagRefByTagKeyID mocks base method. -func (m *MockIExptAnnotateRepo) GetTagRefByTagKeyID(arg0 context.Context, arg1, arg2, arg3 int64) (*entity.ExptTurnResultTagRef, error) { +func (m *MockIExptAnnotateRepo) GetTagRefByTagKeyID(ctx context.Context, exptID, spaceID, tagKeyID int64) (*entity.ExptTurnResultTagRef, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTagRefByTagKeyID", arg0, arg1, arg2, arg3) + ret := m.ctrl.Call(m, "GetTagRefByTagKeyID", ctx, exptID, spaceID, tagKeyID) ret0, _ := ret[0].(*entity.ExptTurnResultTagRef) ret1, _ := ret[1].(error) return ret0, ret1 } // GetTagRefByTagKeyID indicates an expected call of GetTagRefByTagKeyID. -func (mr *MockIExptAnnotateRepoMockRecorder) GetTagRefByTagKeyID(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +func (mr *MockIExptAnnotateRepoMockRecorder) GetTagRefByTagKeyID(ctx, exptID, spaceID, tagKeyID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTagRefByTagKeyID", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).GetTagRefByTagKeyID), arg0, arg1, arg2, arg3) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTagRefByTagKeyID", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).GetTagRefByTagKeyID), ctx, exptID, spaceID, tagKeyID) } // SaveAnnotateRecord mocks base method. -func (m *MockIExptAnnotateRepo) SaveAnnotateRecord(arg0 context.Context, arg1 int64, arg2 *entity.AnnotateRecord, arg3 ...db.Option) error { +func (m *MockIExptAnnotateRepo) SaveAnnotateRecord(ctx context.Context, exptTurnResultID int64, record *entity.AnnotateRecord, opts ...db.Option) error { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { + varargs := []any{ctx, exptTurnResultID, record} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "SaveAnnotateRecord", varargs...) @@ -1458,44 +1471,42 @@ func (m *MockIExptAnnotateRepo) SaveAnnotateRecord(arg0 context.Context, arg1 in } // SaveAnnotateRecord indicates an expected call of SaveAnnotateRecord. -func (mr *MockIExptAnnotateRepoMockRecorder) SaveAnnotateRecord(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { +func (mr *MockIExptAnnotateRepoMockRecorder) SaveAnnotateRecord(ctx, exptTurnResultID, record any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + varargs := append([]any{ctx, exptTurnResultID, record}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveAnnotateRecord", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).SaveAnnotateRecord), varargs...) } // UpdateAnnotateRecord mocks base method. -func (m *MockIExptAnnotateRepo) UpdateAnnotateRecord(arg0 context.Context, arg1 *entity.AnnotateRecord) error { +func (m *MockIExptAnnotateRepo) UpdateAnnotateRecord(ctx context.Context, record *entity.AnnotateRecord) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateAnnotateRecord", arg0, arg1) + ret := m.ctrl.Call(m, "UpdateAnnotateRecord", ctx, record) ret0, _ := ret[0].(error) return ret0 } // UpdateAnnotateRecord indicates an expected call of UpdateAnnotateRecord. -func (mr *MockIExptAnnotateRepoMockRecorder) UpdateAnnotateRecord(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockIExptAnnotateRepoMockRecorder) UpdateAnnotateRecord(ctx, record any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAnnotateRecord", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).UpdateAnnotateRecord), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAnnotateRecord", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).UpdateAnnotateRecord), ctx, record) } // UpdateCompleteCount mocks base method. -func (m *MockIExptAnnotateRepo) UpdateCompleteCount(arg0 context.Context, arg1, arg2, arg3 int64, arg4 ...db.Option) (int32, int32, error) { +func (m *MockIExptAnnotateRepo) UpdateCompleteCount(ctx context.Context, exptID, spaceID, tagKeyID int64, opts ...db.Option) error { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2, arg3} - for _, a := range arg4 { + varargs := []any{ctx, exptID, spaceID, tagKeyID} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "UpdateCompleteCount", varargs...) - ret0, _ := ret[0].(int32) - ret1, _ := ret[1].(int32) - ret2, _ := ret[2].(error) - return ret0, ret1, ret2 + ret0, _ := ret[0].(error) + return ret0 } // UpdateCompleteCount indicates an expected call of UpdateCompleteCount. -func (mr *MockIExptAnnotateRepoMockRecorder) UpdateCompleteCount(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call { +func (mr *MockIExptAnnotateRepoMockRecorder) UpdateCompleteCount(ctx, exptID, spaceID, tagKeyID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...) + varargs := append([]any{ctx, exptID, spaceID, tagKeyID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCompleteCount", reflect.TypeOf((*MockIExptAnnotateRepo)(nil).UpdateCompleteCount), varargs...) } @@ -1503,6 +1514,7 @@ func (mr *MockIExptAnnotateRepoMockRecorder) UpdateCompleteCount(arg0, arg1, arg type MockIExptResultExportRecordRepo struct { ctrl *gomock.Controller recorder *MockIExptResultExportRecordRepoMockRecorder + isgomock struct{} } // MockIExptResultExportRecordRepoMockRecorder is the mock recorder for MockIExptResultExportRecordRepo. @@ -1523,10 +1535,10 @@ func (m *MockIExptResultExportRecordRepo) EXPECT() *MockIExptResultExportRecordR } // Create mocks base method. -func (m *MockIExptResultExportRecordRepo) Create(arg0 context.Context, arg1 *entity.ExptResultExportRecord, arg2 ...db.Option) (int64, error) { +func (m *MockIExptResultExportRecordRepo) Create(ctx context.Context, exportRecord *entity.ExptResultExportRecord, opts ...db.Option) (int64, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, exportRecord} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "Create", varargs...) @@ -1536,31 +1548,31 @@ func (m *MockIExptResultExportRecordRepo) Create(arg0 context.Context, arg1 *ent } // Create indicates an expected call of Create. -func (mr *MockIExptResultExportRecordRepoMockRecorder) Create(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +func (mr *MockIExptResultExportRecordRepoMockRecorder) Create(ctx, exportRecord any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) + varargs := append([]any{ctx, exportRecord}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockIExptResultExportRecordRepo)(nil).Create), varargs...) } // Get mocks base method. -func (m *MockIExptResultExportRecordRepo) Get(arg0 context.Context, arg1, arg2 int64) (*entity.ExptResultExportRecord, error) { +func (m *MockIExptResultExportRecordRepo) Get(ctx context.Context, spaceID, exportID int64) (*entity.ExptResultExportRecord, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Get", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "Get", ctx, spaceID, exportID) ret0, _ := ret[0].(*entity.ExptResultExportRecord) ret1, _ := ret[1].(error) return ret0, ret1 } // Get indicates an expected call of Get. -func (mr *MockIExptResultExportRecordRepoMockRecorder) Get(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockIExptResultExportRecordRepoMockRecorder) Get(ctx, spaceID, exportID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockIExptResultExportRecordRepo)(nil).Get), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockIExptResultExportRecordRepo)(nil).Get), ctx, spaceID, exportID) } // List mocks base method. -func (m *MockIExptResultExportRecordRepo) List(arg0 context.Context, arg1, arg2 int64, arg3 entity.Page, arg4 *int32) ([]*entity.ExptResultExportRecord, int64, error) { +func (m *MockIExptResultExportRecordRepo) List(ctx context.Context, spaceID, exptID int64, page entity.Page, csvExportStatus *int32) ([]*entity.ExptResultExportRecord, int64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "List", arg0, arg1, arg2, arg3, arg4) + ret := m.ctrl.Call(m, "List", ctx, spaceID, exptID, page, csvExportStatus) ret0, _ := ret[0].([]*entity.ExptResultExportRecord) ret1, _ := ret[1].(int64) ret2, _ := ret[2].(error) @@ -1568,16 +1580,16 @@ func (m *MockIExptResultExportRecordRepo) List(arg0 context.Context, arg1, arg2 } // List indicates an expected call of List. -func (mr *MockIExptResultExportRecordRepoMockRecorder) List(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call { +func (mr *MockIExptResultExportRecordRepoMockRecorder) List(ctx, spaceID, exptID, page, csvExportStatus any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockIExptResultExportRecordRepo)(nil).List), arg0, arg1, arg2, arg3, arg4) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockIExptResultExportRecordRepo)(nil).List), ctx, spaceID, exptID, page, csvExportStatus) } // Update mocks base method. -func (m *MockIExptResultExportRecordRepo) Update(arg0 context.Context, arg1 *entity.ExptResultExportRecord, arg2 ...db.Option) error { +func (m *MockIExptResultExportRecordRepo) Update(ctx context.Context, exportRecord *entity.ExptResultExportRecord, opts ...db.Option) error { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, exportRecord} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "Update", varargs...) @@ -1586,8 +1598,8 @@ func (m *MockIExptResultExportRecordRepo) Update(arg0 context.Context, arg1 *ent } // Update indicates an expected call of Update. -func (mr *MockIExptResultExportRecordRepoMockRecorder) Update(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +func (mr *MockIExptResultExportRecordRepoMockRecorder) Update(ctx, exportRecord any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) + varargs := append([]any{ctx, exportRecord}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockIExptResultExportRecordRepo)(nil).Update), varargs...) } diff --git a/backend/modules/evaluation/domain/service/expt_annotate_impl.go b/backend/modules/evaluation/domain/service/expt_annotate_impl.go index b12049e0d..2f0cad89d 100644 --- a/backend/modules/evaluation/domain/service/expt_annotate_impl.go +++ b/backend/modules/evaluation/domain/service/expt_annotate_impl.go @@ -185,7 +185,7 @@ func (e ExptAnnotateServiceImpl) SaveAnnotateRecord(ctx context.Context, exptID } // calculate aggregate result - _, _, err = e.repo.UpdateCompleteCount(ctx, exptID, record.SpaceID, record.TagKeyID, opts...) + err := e.repo.UpdateCompleteCount(ctx, exptID, record.SpaceID, record.TagKeyID, opts...) if err != nil { return err } diff --git a/backend/modules/evaluation/domain/service/expt_export_impl.go b/backend/modules/evaluation/domain/service/expt_export_impl.go index 6e087f617..08cd5d953 100644 --- a/backend/modules/evaluation/domain/service/expt_export_impl.go +++ b/backend/modules/evaluation/domain/service/expt_export_impl.go @@ -9,6 +9,7 @@ import ( "encoding/csv" "fmt" "io" + "net/url" "os" "strconv" "strings" @@ -27,8 +28,10 @@ import ( "github.com/coze-dev/coze-loop/backend/modules/evaluation/domain/repo" "github.com/coze-dev/coze-loop/backend/modules/evaluation/pkg/errno" "github.com/coze-dev/coze-loop/backend/pkg/errorx" + "github.com/coze-dev/coze-loop/backend/pkg/lang/conv" "github.com/coze-dev/coze-loop/backend/pkg/lang/ptr" "github.com/coze-dev/coze-loop/backend/pkg/lang/slices" + "github.com/coze-dev/coze-loop/backend/pkg/localos" "github.com/coze-dev/coze-loop/backend/pkg/logs" ) @@ -120,6 +123,7 @@ func (e ExptResultExportService) ExportCSV(ctx context.Context, spaceID, exptID ExportID: exportID, ExperimentID: exptID, SpaceID: spaceID, + Session: session, } err = e.exptPublisher.PublishExptExportCSVEvent(ctx, exportEvent, nil) if err != nil { @@ -140,12 +144,26 @@ func (e ExptResultExportService) GetExptExportRecord(ctx context.Context, spaceI var ttl int64 = 24 * 60 * 60 signOpt := fileserver.SignWithTTL(time.Duration(ttl) * time.Second) - url, _, err := e.fileClient.SignDownloadReq(ctx, exportRecord.FilePath, signOpt) + signURL, _, err := e.fileClient.SignDownloadReq(ctx, exportRecord.FilePath, signOpt) if err != nil { return nil, err } - exportRecord.URL = ptr.Of(url) + unescaped, err := url.QueryUnescape(conv.UnescapeUnicode(signURL)) + if err != nil { + logs.CtxWarn(ctx, "QueryUnescape fail, raw: %v", signURL) + } else { + signURL = unescaped + } + + parsedURL, err := url.Parse(signURL) + if err == nil { + if parsedURL.Host == localos.GetLocalOSHost() { + signURL = fmt.Sprintf("%s?%s", parsedURL.Path, parsedURL.RawQuery) + } + } + + exportRecord.URL = ptr.Of(signURL) } exportRecord.Expired = isExportRecordExpired(exportRecord.StartAt) diff --git a/backend/modules/evaluation/infra/mq/rocket/consumer/expt_export.go b/backend/modules/evaluation/infra/mq/rocket/consumer/expt_export.go index 5562af65a..f41b3d433 100644 --- a/backend/modules/evaluation/infra/mq/rocket/consumer/expt_export.go +++ b/backend/modules/evaluation/infra/mq/rocket/consumer/expt_export.go @@ -8,6 +8,7 @@ import ( "github.com/bytedance/sonic" + "github.com/coze-dev/coze-loop/backend/infra/middleware/session" "github.com/coze-dev/coze-loop/backend/infra/mq" "github.com/coze-dev/coze-loop/backend/modules/evaluation/domain/entity" "github.com/coze-dev/coze-loop/backend/modules/evaluation/domain/service" @@ -40,6 +41,10 @@ func (e *ExptExportConsumer) HandleMessage(ctx context.Context, ext *mq.MessageE logs.CtxInfo(ctx, "ExptExportConsumer consume message, event: %v, msg_id: %v", string(body), ext.MsgID) + if event.Session != nil && len(event.Session.UserID) > 0 { // 链路中调用接口会依赖 ctx userID 鉴权 + ctx = session.WithCtxUser(ctx, &session.User{ID: event.Session.UserID}) + } + return e.handleEvent(ctx, event) } diff --git a/backend/modules/evaluation/infra/repo/experiment/annotate_record.go b/backend/modules/evaluation/infra/repo/experiment/annotate_record.go index 556460b40..006aab7d6 100644 --- a/backend/modules/evaluation/infra/repo/experiment/annotate_record.go +++ b/backend/modules/evaluation/infra/repo/experiment/annotate_record.go @@ -140,7 +140,7 @@ func (e ExptAnnotateRepoImpl) GetExptTurnAnnotateRecordRefsByTagKeyID(ctx contex return exptTurnAnnotateRecordRefs, nil } -func (e ExptAnnotateRepoImpl) UpdateCompleteCount(ctx context.Context, exptID, spaceID, tagKeyID int64, opts ...db.Option) (int32, int32, error) { +func (e ExptAnnotateRepoImpl) UpdateCompleteCount(ctx context.Context, exptID, spaceID, tagKeyID int64, opts ...db.Option) error { return e.exptTurnResultTagRefDAO.UpdateCompleteCount(ctx, exptID, spaceID, tagKeyID, opts...) } diff --git a/backend/modules/evaluation/infra/repo/experiment/annotate_record_test.go b/backend/modules/evaluation/infra/repo/experiment/annotate_record_test.go index 9cc4d21b6..f0ebd8d81 100644 --- a/backend/modules/evaluation/infra/repo/experiment/annotate_record_test.go +++ b/backend/modules/evaluation/infra/repo/experiment/annotate_record_test.go @@ -723,13 +723,11 @@ func TestExptAnnotateRepoImpl_UpdateCompleteCount(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { tt.mockSetup() - total, complete, err := repo.UpdateCompleteCount(context.Background(), tt.exptID, tt.spaceID, tt.tagKeyID) + err := repo.UpdateCompleteCount(context.Background(), tt.exptID, tt.spaceID, tt.tagKeyID) if tt.wantErr { assert.Error(t, err) } else { assert.NoError(t, err) - assert.Equal(t, tt.wantTotal, total) - assert.Equal(t, tt.wantComplete, complete) } }) } diff --git a/backend/modules/evaluation/infra/repo/experiment/mysql/expt_turn_result_tag_ref.go b/backend/modules/evaluation/infra/repo/experiment/mysql/expt_turn_result_tag_ref.go index beaf6424a..7bef83f0d 100644 --- a/backend/modules/evaluation/infra/repo/experiment/mysql/expt_turn_result_tag_ref.go +++ b/backend/modules/evaluation/infra/repo/experiment/mysql/expt_turn_result_tag_ref.go @@ -7,7 +7,6 @@ import ( "context" "gorm.io/gorm" - "gorm.io/gorm/clause" "gorm.io/plugin/dbresolver" "github.com/coze-dev/coze-loop/backend/infra/db" @@ -21,7 +20,7 @@ import ( //go:generate mockgen -destination=mocks/expt_turn_result_tag_ref.go -package=mocks . IExptTurnResultTagRefDAO type IExptTurnResultTagRefDAO interface { Create(ctx context.Context, refs []*model.ExptTurnResultTagRef) error - UpdateCompleteCount(ctx context.Context, exptID, spaceID, tagKeyID int64, opts ...db.Option) (int32, int32, error) + UpdateCompleteCount(ctx context.Context, exptID, spaceID, tagKeyID int64, opts ...db.Option) error Delete(ctx context.Context, exptID int64, spaceID int64, tagKeyID int64, opts ...db.Option) error GetByExptID(ctx context.Context, exptID int64, spaceID int64) ([]*model.ExptTurnResultTagRef, error) @@ -55,21 +54,20 @@ func (e exptTurnResultTagRefDAO) GetByTagKeyID(ctx context.Context, exptID int64 return found, nil } -func (e exptTurnResultTagRefDAO) UpdateCompleteCount(ctx context.Context, exptID, spaceID, tagKeyID int64, opts ...db.Option) (int32, int32, error) { +func (e exptTurnResultTagRefDAO) UpdateCompleteCount(ctx context.Context, exptID, spaceID, tagKeyID int64, opts ...db.Option) error { po := &model.ExptTurnResultTagRef{} db := e.db.NewSession(ctx, opts...) err := db.Model(po). - Clauses(clause.Returning{Columns: []clause.Column{{Name: "complete_cnt"}, {Name: "total_cnt"}}}). Where("space_id = ? AND expt_id = ? AND tag_key_id = ?", spaceID, exptID, tagKeyID). Where("complete_cnt < total_cnt"). Updates(map[string]interface{}{ "complete_cnt": gorm.Expr("complete_cnt + ?", 1), }).Error if err != nil { - return 0, 0, err + return err } - return po.CompleteCnt, po.TotalCnt, nil + return nil } func (e exptTurnResultTagRefDAO) Create(ctx context.Context, refs []*model.ExptTurnResultTagRef) error { diff --git a/backend/modules/evaluation/infra/repo/experiment/mysql/mocks/expt_turn_result_tag_ref.go b/backend/modules/evaluation/infra/repo/experiment/mysql/mocks/expt_turn_result_tag_ref.go index 4a107b8c7..e4049bece 100644 --- a/backend/modules/evaluation/infra/repo/experiment/mysql/mocks/expt_turn_result_tag_ref.go +++ b/backend/modules/evaluation/infra/repo/experiment/mysql/mocks/expt_turn_result_tag_ref.go @@ -1,5 +1,10 @@ // Code generated by MockGen. DO NOT EDIT. // Source: github.com/coze-dev/coze-loop/backend/modules/evaluation/infra/repo/experiment/mysql (interfaces: IExptTurnResultTagRefDAO) +// +// Generated by this command: +// +// mockgen -destination=mocks/expt_turn_result_tag_ref.go -package=mocks . IExptTurnResultTagRefDAO +// // Package mocks is a generated GoMock package. package mocks @@ -10,13 +15,14 @@ import ( db "github.com/coze-dev/coze-loop/backend/infra/db" model "github.com/coze-dev/coze-loop/backend/modules/evaluation/infra/repo/experiment/mysql/gorm_gen/model" - "go.uber.org/mock/gomock" + gomock "go.uber.org/mock/gomock" ) // MockIExptTurnResultTagRefDAO is a mock of IExptTurnResultTagRefDAO interface. type MockIExptTurnResultTagRefDAO struct { ctrl *gomock.Controller recorder *MockIExptTurnResultTagRefDAOMockRecorder + isgomock struct{} } // MockIExptTurnResultTagRefDAOMockRecorder is the mock recorder for MockIExptTurnResultTagRefDAO. @@ -37,39 +43,39 @@ func (m *MockIExptTurnResultTagRefDAO) EXPECT() *MockIExptTurnResultTagRefDAOMoc } // BatchGetByExptIDs mocks base method. -func (m *MockIExptTurnResultTagRefDAO) BatchGetByExptIDs(arg0 context.Context, arg1 []int64, arg2 int64) ([]*model.ExptTurnResultTagRef, error) { +func (m *MockIExptTurnResultTagRefDAO) BatchGetByExptIDs(ctx context.Context, exptIDs []int64, spaceID int64) ([]*model.ExptTurnResultTagRef, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BatchGetByExptIDs", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "BatchGetByExptIDs", ctx, exptIDs, spaceID) ret0, _ := ret[0].([]*model.ExptTurnResultTagRef) ret1, _ := ret[1].(error) return ret0, ret1 } // BatchGetByExptIDs indicates an expected call of BatchGetByExptIDs. -func (mr *MockIExptTurnResultTagRefDAOMockRecorder) BatchGetByExptIDs(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultTagRefDAOMockRecorder) BatchGetByExptIDs(ctx, exptIDs, spaceID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetByExptIDs", reflect.TypeOf((*MockIExptTurnResultTagRefDAO)(nil).BatchGetByExptIDs), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetByExptIDs", reflect.TypeOf((*MockIExptTurnResultTagRefDAO)(nil).BatchGetByExptIDs), ctx, exptIDs, spaceID) } // Create mocks base method. -func (m *MockIExptTurnResultTagRefDAO) Create(arg0 context.Context, arg1 []*model.ExptTurnResultTagRef) error { +func (m *MockIExptTurnResultTagRefDAO) Create(ctx context.Context, refs []*model.ExptTurnResultTagRef) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Create", arg0, arg1) + ret := m.ctrl.Call(m, "Create", ctx, refs) ret0, _ := ret[0].(error) return ret0 } // Create indicates an expected call of Create. -func (mr *MockIExptTurnResultTagRefDAOMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultTagRefDAOMockRecorder) Create(ctx, refs any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockIExptTurnResultTagRefDAO)(nil).Create), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockIExptTurnResultTagRefDAO)(nil).Create), ctx, refs) } // Delete mocks base method. -func (m *MockIExptTurnResultTagRefDAO) Delete(arg0 context.Context, arg1, arg2, arg3 int64, arg4 ...db.Option) error { +func (m *MockIExptTurnResultTagRefDAO) Delete(ctx context.Context, exptID, spaceID, tagKeyID int64, opts ...db.Option) error { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2, arg3} - for _, a := range arg4 { + varargs := []any{ctx, exptID, spaceID, tagKeyID} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "Delete", varargs...) @@ -78,59 +84,57 @@ func (m *MockIExptTurnResultTagRefDAO) Delete(arg0 context.Context, arg1, arg2, } // Delete indicates an expected call of Delete. -func (mr *MockIExptTurnResultTagRefDAOMockRecorder) Delete(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call { +func (mr *MockIExptTurnResultTagRefDAOMockRecorder) Delete(ctx, exptID, spaceID, tagKeyID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...) + varargs := append([]any{ctx, exptID, spaceID, tagKeyID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockIExptTurnResultTagRefDAO)(nil).Delete), varargs...) } // GetByExptID mocks base method. -func (m *MockIExptTurnResultTagRefDAO) GetByExptID(arg0 context.Context, arg1, arg2 int64) ([]*model.ExptTurnResultTagRef, error) { +func (m *MockIExptTurnResultTagRefDAO) GetByExptID(ctx context.Context, exptID, spaceID int64) ([]*model.ExptTurnResultTagRef, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetByExptID", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "GetByExptID", ctx, exptID, spaceID) ret0, _ := ret[0].([]*model.ExptTurnResultTagRef) ret1, _ := ret[1].(error) return ret0, ret1 } // GetByExptID indicates an expected call of GetByExptID. -func (mr *MockIExptTurnResultTagRefDAOMockRecorder) GetByExptID(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultTagRefDAOMockRecorder) GetByExptID(ctx, exptID, spaceID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByExptID", reflect.TypeOf((*MockIExptTurnResultTagRefDAO)(nil).GetByExptID), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByExptID", reflect.TypeOf((*MockIExptTurnResultTagRefDAO)(nil).GetByExptID), ctx, exptID, spaceID) } // GetByTagKeyID mocks base method. -func (m *MockIExptTurnResultTagRefDAO) GetByTagKeyID(arg0 context.Context, arg1, arg2, arg3 int64) (*model.ExptTurnResultTagRef, error) { +func (m *MockIExptTurnResultTagRefDAO) GetByTagKeyID(ctx context.Context, exptID, spaceID, tagKeyID int64) (*model.ExptTurnResultTagRef, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetByTagKeyID", arg0, arg1, arg2, arg3) + ret := m.ctrl.Call(m, "GetByTagKeyID", ctx, exptID, spaceID, tagKeyID) ret0, _ := ret[0].(*model.ExptTurnResultTagRef) ret1, _ := ret[1].(error) return ret0, ret1 } // GetByTagKeyID indicates an expected call of GetByTagKeyID. -func (mr *MockIExptTurnResultTagRefDAOMockRecorder) GetByTagKeyID(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +func (mr *MockIExptTurnResultTagRefDAOMockRecorder) GetByTagKeyID(ctx, exptID, spaceID, tagKeyID any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByTagKeyID", reflect.TypeOf((*MockIExptTurnResultTagRefDAO)(nil).GetByTagKeyID), arg0, arg1, arg2, arg3) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByTagKeyID", reflect.TypeOf((*MockIExptTurnResultTagRefDAO)(nil).GetByTagKeyID), ctx, exptID, spaceID, tagKeyID) } // UpdateCompleteCount mocks base method. -func (m *MockIExptTurnResultTagRefDAO) UpdateCompleteCount(arg0 context.Context, arg1, arg2, arg3 int64, arg4 ...db.Option) (int32, int32, error) { +func (m *MockIExptTurnResultTagRefDAO) UpdateCompleteCount(ctx context.Context, exptID, spaceID, tagKeyID int64, opts ...db.Option) error { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2, arg3} - for _, a := range arg4 { + varargs := []any{ctx, exptID, spaceID, tagKeyID} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "UpdateCompleteCount", varargs...) - ret0, _ := ret[0].(int32) - ret1, _ := ret[1].(int32) - ret2, _ := ret[2].(error) - return ret0, ret1, ret2 + ret0, _ := ret[0].(error) + return ret0 } // UpdateCompleteCount indicates an expected call of UpdateCompleteCount. -func (mr *MockIExptTurnResultTagRefDAOMockRecorder) UpdateCompleteCount(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call { +func (mr *MockIExptTurnResultTagRefDAOMockRecorder) UpdateCompleteCount(ctx, exptID, spaceID, tagKeyID any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...) + varargs := append([]any{ctx, exptID, spaceID, tagKeyID}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCompleteCount", reflect.TypeOf((*MockIExptTurnResultTagRefDAO)(nil).UpdateCompleteCount), varargs...) } diff --git a/backend/pkg/lang/conv/unicode.go b/backend/pkg/lang/conv/unicode.go new file mode 100644 index 000000000..e8c194665 --- /dev/null +++ b/backend/pkg/lang/conv/unicode.go @@ -0,0 +1,32 @@ +// Copyright (c) 2025 Bytedance Ltd. and/or its affiliates +// SPDX-License-Identifier: Apache-2.0 + +package conv + +import ( + "regexp" + "strconv" + "unicode/utf8" +) + +// UnescapeUnicode converts Unicode escape sequences in string to actual characters +// Supports \uXXXX format Unicode escape sequences +// Example: "Hello\u0026World" -> "Hello&World" +func UnescapeUnicode(str string) string { + re := regexp.MustCompile(`\\u[0-9a-fA-F]{4}`) + + return re.ReplaceAllStringFunc(str, func(match string) string { + hexStr := match[2:] + if codePoint, err := strconv.ParseInt(hexStr, 16, 32); err == nil { + if utf8.ValidRune(rune(codePoint)) { + return string(rune(codePoint)) + } + } + return match + }) +} + +// UnescapeUnicodeBytes processes Unicode escape sequences in byte array +func UnescapeUnicodeBytes(data []byte) []byte { + return []byte(UnescapeUnicode(string(data))) +} diff --git a/backend/pkg/lang/conv/unicode_test.go b/backend/pkg/lang/conv/unicode_test.go new file mode 100644 index 000000000..4f58b2ffc --- /dev/null +++ b/backend/pkg/lang/conv/unicode_test.go @@ -0,0 +1,99 @@ +// Copyright (c) 2025 coze-dev Authors +// SPDX-License-Identifier: Apache-2.0 + +package conv + +import ( + "testing" +) + +func TestUnescapeUnicode(t *testing.T) { + tests := []struct { + name string + input string + expected string + }{ + { + name: "single unicode escape", + input: "Hello\u0026World", + expected: "Hello&World", + }, + { + name: "multiple unicode escapes", + input: "Test\u0026String\u003DValue", + expected: "Test&String=Value", + }, + { + name: "mixed content", + input: "URL: https://example.com?param\u003Dvalue\u0026other\u003Ddata", + expected: "URL: https://example.com?param=value&other=data", + }, + { + name: "no unicode escapes", + input: "Normal string without escapes", + expected: "Normal string without escapes", + }, + { + name: "empty string", + input: "", + expected: "", + }, + { + name: "only unicode escapes", + input: "\u0026\u003D\u003C\u003E", + expected: "&=<>", + }, + { + name: "chinese characters", + input: "Hello\u4E16\u754C", + expected: "Hello世界", + }, + { + name: "invalid unicode escape", + input: "Test\\uZZZZInvalid", + expected: "Test\\uZZZZInvalid", // should remain unchanged + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := UnescapeUnicode(tt.input) + if result != tt.expected { + t.Errorf("UnescapeUnicode(%q) = %q, want %q", tt.input, result, tt.expected) + } + }) + } +} + +func TestUnescapeUnicodeBytes(t *testing.T) { + tests := []struct { + name string + input []byte + expected []byte + }{ + { + name: "unicode escape in bytes", + input: []byte("Hello\u0026World"), + expected: []byte("Hello&World"), + }, + { + name: "empty bytes", + input: []byte{}, + expected: []byte{}, + }, + { + name: "mixed content bytes", + input: []byte("Data\u003Dvalue\u0026key"), + expected: []byte("Data=value&key"), + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := UnescapeUnicodeBytes(tt.input) + if string(result) != string(tt.expected) { + t.Errorf("UnescapeUnicodeBytes(%q) = %q, want %q", string(tt.input), string(result), string(tt.expected)) + } + }) + } +} diff --git a/backend/pkg/lang/js_conv/json.go b/backend/pkg/lang/js_conv/json.go index 561e4c670..2958df7cf 100644 --- a/backend/pkg/lang/js_conv/json.go +++ b/backend/pkg/lang/js_conv/json.go @@ -15,10 +15,19 @@ import ( ) var ( - once sync.Once - jsoner jsoniter.API + once sync.Once + jsoner jsoniter.API + unescapedJsoner = jsoniter.Config{ + EscapeHTML: false, + SortMapKeys: true, + ValidateJsonRawMessage: true, + }.Froze() ) +func init() { + unescapedJsoner.RegisterExtension(NewJSONIterExtension()) +} + func GetMarshaler() func(v interface{}) ([]byte, error) { once.Do(func() { initJsonMarshalerWithExtension() @@ -33,6 +42,10 @@ func GetUnmarshaler() func(data []byte, v interface{}) error { return jsoner.Unmarshal } +func UnescapedMarshal(v interface{}) ([]byte, error) { + return unescapedJsoner.Marshal(v) +} + func initJsonMarshalerWithExtension() { jsoner = jsoniter.ConfigCompatibleWithStandardLibrary jsoner.RegisterExtension(NewJSONIterExtension()) diff --git a/release/deployment/docker-compose/conf/evaluation.yaml b/release/deployment/docker-compose/conf/evaluation.yaml index 34b4d292f..23f0483a4 100644 --- a/release/deployment/docker-compose/conf/evaluation.yaml +++ b/release/deployment/docker-compose/conf/evaluation.yaml @@ -2141,3 +2141,6 @@ evaluator_template_conf_en-US: prompt_template_key: builtin_template_detail prompt_template_name: "Detail" receive_chat_history: false + +expt_export_white_list: + allow_all: true \ No newline at end of file diff --git a/release/deployment/helm-chart/umbrella/conf/evaluation.yaml b/release/deployment/helm-chart/umbrella/conf/evaluation.yaml index 34b4d292f..23f0483a4 100644 --- a/release/deployment/helm-chart/umbrella/conf/evaluation.yaml +++ b/release/deployment/helm-chart/umbrella/conf/evaluation.yaml @@ -2141,3 +2141,6 @@ evaluator_template_conf_en-US: prompt_template_key: builtin_template_detail prompt_template_name: "Detail" receive_chat_history: false + +expt_export_white_list: + allow_all: true \ No newline at end of file