From 2690b6080d390c3e7564fb742ea583b6f059cf0e Mon Sep 17 00:00:00 2001 From: "wangluming.wlm" Date: Tue, 24 Mar 2026 15:16:51 +0800 Subject: [PATCH 1/8] feat:tool --- backend/api/handler/coze/loop/apis/handler.go | 6 + .../coze/loop/apis/tool_manage_service.go | 49 + backend/api/handler/coze/loop/apis/wire.go | 1 + .../api/handler/coze/loop/apis/wire_gen.go | 9 +- .../router/coze/loop/apis/coze.loop.apis.go | 14 + .../api/router/coze/loop/apis/middleware.go | 50 + backend/go.sum | 1 + .../platestwrite/latest_write_tracker.go | 2 + .../coze/loop/apis/coze.loop.apis.go | 52 +- .../coze/loop/apis/k-coze.loop.apis.go | 6 +- .../loop/apis/toolmanageservice/client.go | 79 + .../loop/apis/toolmanageservice/server.go | 25 + .../toolmanageservice/toolmanageservice.go | 276 + .../loop/observability/ingestion/ingestion.go | 3 + .../coze/loop/prompt/coze.loop.prompt.go | 36 + .../coze/loop/prompt/domain/tool/k-consts.go | 4 + .../coze/loop/prompt/domain/tool/k-tool.go | 1581 ++++ .../coze/loop/prompt/domain/tool/tool.go | 2178 +++++ .../loop/prompt/domain/tool/tool_validator.go | 58 + .../coze/loop/prompt/k-coze.loop.prompt.go | 2 + .../manage/coze.loop.prompt.tool.manage.go | 7935 +++++++++++++++++ .../coze.loop.prompt.tool.manage_validator.go | 222 + .../coze/loop/prompt/tool/manage/k-consts.go | 4 + .../manage/k-coze.loop.prompt.tool.manage.go | 5377 +++++++++++ .../tool/manage/toolmanageservice/client.go | 79 + .../tool/manage/toolmanageservice/server.go | 25 + .../toolmanageservice/toolmanageservice.go | 275 + .../loop/prompt/toolmanageservice/client.go | 79 + .../loop/prompt/toolmanageservice/server.go | 25 + .../toolmanageservice/toolmanageservice.go | 276 + .../loingestion/local_ingestionservice.go | 34 + .../tool/lomanage/local_toolmanageservice.go | 161 + .../prompt/application/convertor/toolmgmt.go | 83 + .../modules/prompt/application/tool_manage.go | 381 + backend/modules/prompt/application/wire.go | 23 + .../modules/prompt/application/wire_gen.go | 16 + .../prompt/domain/entity/toolmgmt/tool.go | 43 + backend/modules/prompt/domain/repo/tool.go | 77 + .../prompt/infra/repo/mysql/convertor/tool.go | 65 + .../mysql/gorm_gen/model/tool_basic.gen.go | 33 + .../mysql/gorm_gen/model/tool_commit.gen.go | 30 + .../infra/repo/mysql/gorm_gen/query/gen.go | 12 + .../mysql/gorm_gen/query/tool_basic.gen.go | 370 + .../mysql/gorm_gen/query/tool_commit.gen.go | 366 + .../prompt/infra/repo/mysql/tool_basic.go | 180 + .../prompt/infra/repo/mysql/tool_commit.go | 151 + backend/modules/prompt/infra/repo/tool.go | 301 + backend/script/gorm_gen/generate.go | 3 +- .../loop-base/api-schema/api.config.js | 1 + .../coze/loop/apis/coze.loop.apis.thrift | 2 + .../coze/loop/prompt/coze.loop.prompt.thrift | 4 +- .../coze.loop.prompt.tool.manage.thrift | 131 + .../coze/loop/prompt/domain/tool.thrift | 41 + .../mysql-init/init-sql/tool_basic.sql | 18 + .../mysql-init/init-sql/tool_commit.sql | 17 + 55 files changed, 21257 insertions(+), 15 deletions(-) create mode 100644 backend/api/handler/coze/loop/apis/tool_manage_service.go create mode 100644 backend/kitex_gen/coze/loop/apis/toolmanageservice/client.go create mode 100644 backend/kitex_gen/coze/loop/apis/toolmanageservice/server.go create mode 100644 backend/kitex_gen/coze/loop/apis/toolmanageservice/toolmanageservice.go create mode 100644 backend/kitex_gen/coze/loop/observability/ingestion/ingestion.go create mode 100644 backend/kitex_gen/coze/loop/prompt/domain/tool/k-consts.go create mode 100644 backend/kitex_gen/coze/loop/prompt/domain/tool/k-tool.go create mode 100644 backend/kitex_gen/coze/loop/prompt/domain/tool/tool.go create mode 100644 backend/kitex_gen/coze/loop/prompt/domain/tool/tool_validator.go create mode 100644 backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool.manage.go create mode 100644 backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool.manage_validator.go create mode 100644 backend/kitex_gen/coze/loop/prompt/tool/manage/k-consts.go create mode 100644 backend/kitex_gen/coze/loop/prompt/tool/manage/k-coze.loop.prompt.tool.manage.go create mode 100644 backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/client.go create mode 100644 backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/server.go create mode 100644 backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/toolmanageservice.go create mode 100644 backend/kitex_gen/coze/loop/prompt/toolmanageservice/client.go create mode 100644 backend/kitex_gen/coze/loop/prompt/toolmanageservice/server.go create mode 100644 backend/kitex_gen/coze/loop/prompt/toolmanageservice/toolmanageservice.go create mode 100644 backend/loop_gen/coze/loop/observability/loingestion/local_ingestionservice.go create mode 100644 backend/loop_gen/coze/loop/prompt/tool/lomanage/local_toolmanageservice.go create mode 100644 backend/modules/prompt/application/convertor/toolmgmt.go create mode 100644 backend/modules/prompt/application/tool_manage.go create mode 100644 backend/modules/prompt/domain/entity/toolmgmt/tool.go create mode 100644 backend/modules/prompt/domain/repo/tool.go create mode 100644 backend/modules/prompt/infra/repo/mysql/convertor/tool.go create mode 100644 backend/modules/prompt/infra/repo/mysql/gorm_gen/model/tool_basic.gen.go create mode 100644 backend/modules/prompt/infra/repo/mysql/gorm_gen/model/tool_commit.gen.go create mode 100644 backend/modules/prompt/infra/repo/mysql/gorm_gen/query/tool_basic.gen.go create mode 100644 backend/modules/prompt/infra/repo/mysql/gorm_gen/query/tool_commit.gen.go create mode 100644 backend/modules/prompt/infra/repo/mysql/tool_basic.go create mode 100644 backend/modules/prompt/infra/repo/mysql/tool_commit.go create mode 100644 backend/modules/prompt/infra/repo/tool.go create mode 100644 idl/thrift/coze/loop/prompt/coze.loop.prompt.tool.manage.thrift create mode 100644 idl/thrift/coze/loop/prompt/domain/tool.thrift create mode 100644 release/deployment/docker-compose/bootstrap/mysql-init/init-sql/tool_basic.sql create mode 100644 release/deployment/docker-compose/bootstrap/mysql-init/init-sql/tool_commit.sql diff --git a/backend/api/handler/coze/loop/apis/handler.go b/backend/api/handler/coze/loop/apis/handler.go index 71ab82116..163151901 100644 --- a/backend/api/handler/coze/loop/apis/handler.go +++ b/backend/api/handler/coze/loop/apis/handler.go @@ -42,6 +42,7 @@ import ( "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/execute" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/manage" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/openapi" + toolmanage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" "github.com/coze-dev/coze-loop/backend/loop_gen/coze/loop/data/lodataset" "github.com/coze-dev/coze-loop/backend/loop_gen/coze/loop/data/lotag" "github.com/coze-dev/coze-loop/backend/loop_gen/coze/loop/evaluation/loeval_set" @@ -62,6 +63,7 @@ import ( "github.com/coze-dev/coze-loop/backend/loop_gen/coze/loop/prompt/lodebug" "github.com/coze-dev/coze-loop/backend/loop_gen/coze/loop/prompt/lomanage" "github.com/coze-dev/coze-loop/backend/loop_gen/coze/loop/prompt/loopenapi" + lotoolmanage "github.com/coze-dev/coze-loop/backend/loop_gen/coze/loop/prompt/tool/lomanage" dataapp "github.com/coze-dev/coze-loop/backend/modules/data/application" evalapp "github.com/coze-dev/coze-loop/backend/modules/evaluation/application" "github.com/coze-dev/coze-loop/backend/modules/foundation/pkg/errno" @@ -160,6 +162,7 @@ func NewDataHandler(dataApp dataapp.IDatasetApplication, tagApp tag.TagService) type PromptHandler struct { manage.PromptManageService + toolmanage.ToolManageService debug.PromptDebugService execute.PromptExecuteService openapi.PromptOpenAPIService @@ -167,17 +170,20 @@ type PromptHandler struct { func NewPromptHandler( manageApp manage.PromptManageService, + toolManageApp toolmanage.ToolManageService, debugApp debug.PromptDebugService, executeApp execute.PromptExecuteService, openAPIApp openapi.PromptOpenAPIService, ) *PromptHandler { h := &PromptHandler{ PromptManageService: manageApp, + ToolManageService: toolManageApp, PromptDebugService: debugApp, PromptExecuteService: executeApp, PromptOpenAPIService: openAPIApp, } bindLocalCallClient(manage.PromptManageService(h), &promptManageSvc, lomanage.NewLocalPromptManageService) + bindLocalCallClient(toolmanage.ToolManageService(h), &toolManageSvc, lotoolmanage.NewLocalToolManageService) bindLocalCallClient(debug.PromptDebugService(h), &promptDebugSvc, lodebug.NewLocalPromptDebugService) bindLocalCallClient(openapi.PromptOpenAPIService(h), &promptOpenAPISvc, loopenapi.NewLocalPromptOpenAPIService) return h diff --git a/backend/api/handler/coze/loop/apis/tool_manage_service.go b/backend/api/handler/coze/loop/apis/tool_manage_service.go new file mode 100644 index 000000000..31d4fa215 --- /dev/null +++ b/backend/api/handler/coze/loop/apis/tool_manage_service.go @@ -0,0 +1,49 @@ +// Code generated by hertz generator. + +package apis + +import ( + "context" + + "github.com/cloudwego/hertz/pkg/app" + + "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice" +) + +var toolManageSvc toolmanageservice.Client + +// CreateTool . +// @router /api/prompt/v1/tools [POST] +func CreateTool(ctx context.Context, c *app.RequestContext) { + invokeAndRender(ctx, c, toolManageSvc.CreateTool) +} + +// GetToolDetail . +// @router /api/prompt/v1/tools/:tool_id [GET] +func GetToolDetail(ctx context.Context, c *app.RequestContext) { + invokeAndRender(ctx, c, toolManageSvc.GetToolDetail) +} + +// ListTool . +// @router /api/prompt/v1/tools/list [POST] +func ListTool(ctx context.Context, c *app.RequestContext) { + invokeAndRender(ctx, c, toolManageSvc.ListTool) +} + +// SaveToolDetail . +// @router /api/prompt/v1/tools/:tool_id/drafts/save [POST] +func SaveToolDetail(ctx context.Context, c *app.RequestContext) { + invokeAndRender(ctx, c, toolManageSvc.SaveToolDetail) +} + +// CommitToolDraft . +// @router /api/prompt/v1/tools/:tool_id/drafts/commit [POST] +func CommitToolDraft(ctx context.Context, c *app.RequestContext) { + invokeAndRender(ctx, c, toolManageSvc.CommitToolDraft) +} + +// ListToolCommit . +// @router /api/prompt/v1/tools/:tool_id/commits/list [POST] +func ListToolCommit(ctx context.Context, c *app.RequestContext) { + invokeAndRender(ctx, c, toolManageSvc.ListToolCommit) +} diff --git a/backend/api/handler/coze/loop/apis/wire.go b/backend/api/handler/coze/loop/apis/wire.go index dd6677640..966ec9775 100644 --- a/backend/api/handler/coze/loop/apis/wire.go +++ b/backend/api/handler/coze/loop/apis/wire.go @@ -72,6 +72,7 @@ var ( promptSet = wire.NewSet( NewPromptHandler, promptapp.InitPromptManageApplication, + promptapp.InitToolManageApplication, promptapp.InitPromptDebugApplication, promptapp.InitPromptExecuteApplication, promptapp.InitPromptOpenAPIApplication, diff --git a/backend/api/handler/coze/loop/apis/wire_gen.go b/backend/api/handler/coze/loop/apis/wire_gen.go index 966af231a..076d302e7 100644 --- a/backend/api/handler/coze/loop/apis/wire_gen.go +++ b/backend/api/handler/coze/loop/apis/wire_gen.go @@ -8,7 +8,6 @@ package apis import ( "context" - "github.com/cloudwego/kitex/pkg/endpoint" "github.com/coze-dev/coze-loop/backend/infra/ck" "github.com/coze-dev/coze-loop/backend/infra/db" @@ -92,6 +91,10 @@ func InitPromptHandler(ctx context.Context, idgen2 idgen.IIDGenerator, db2 db.Pr if err != nil { return nil, err } + toolManageService, err := application2.InitToolManageApplication(idgen2, db2, redisCli, authClient, userClient) + if err != nil { + return nil, err + } promptDebugService, err := application2.InitPromptDebugApplication(idgen2, db2, redisCli, meter, configFactory, llmClient, authClient, fileClient, benefitSvc) if err != nil { return nil, err @@ -104,7 +107,7 @@ func InitPromptHandler(ctx context.Context, idgen2 idgen.IIDGenerator, db2 db.Pr if err != nil { return nil, err } - promptHandler := NewPromptHandler(promptManageService, promptDebugService, promptExecuteService, promptOpenAPIService) + promptHandler := NewPromptHandler(promptManageService, toolManageService, promptDebugService, promptExecuteService, promptOpenAPIService) return promptHandler, nil } @@ -197,7 +200,7 @@ var ( NewLLMHandler, application3.InitManageApplication, application3.InitRuntimeApplication, ) promptSet = wire.NewSet( - NewPromptHandler, application2.InitPromptManageApplication, application2.InitPromptDebugApplication, application2.InitPromptExecuteApplication, application2.InitPromptOpenAPIApplication, + NewPromptHandler, application2.InitPromptManageApplication, application2.InitToolManageApplication, application2.InitPromptDebugApplication, application2.InitPromptExecuteApplication, application2.InitPromptOpenAPIApplication, ) evaluationSet = wire.NewSet( NewEvaluationHandler, data.NewDatasetRPCAdapter, prompt.NewPromptRPCAdapter, trajectory.TrajectoryRPCSet, application4.InitExperimentApplication, application4.InitEvaluatorApplication, application4.InitEvaluationSetApplication, application4.InitEvalTargetApplication, application4.InitEvalOpenAPIApplication, diff --git a/backend/api/router/coze/loop/apis/coze.loop.apis.go b/backend/api/router/coze/loop/apis/coze.loop.apis.go index 352d7b1ff..355123544 100644 --- a/backend/api/router/coze/loop/apis/coze.loop.apis.go +++ b/backend/api/router/coze/loop/apis/coze.loop.apis.go @@ -416,6 +416,20 @@ func Register(r *server.Hertz, handler *apis.APIHandler) { _prompt_id0 := _prompts.Group("/:prompt_id", _prompt_id0Mw(handler)...) _prompt_id0.POST("/clone", append(_clonepromptMw(handler), apis.ClonePrompt)...) } + _v15.POST("/tools", append(_toolsMw(handler), apis.CreateTool)...) + _tools := _v15.Group("/tools", _toolsMw(handler)...) + _tools.POST("/list", append(_listtoolMw(handler), apis.ListTool)...) + _tools.GET("/:tool_id", append(_tool_idMw(handler), apis.GetToolDetail)...) + _tool_id := _tools.Group("/:tool_id", _tool_idMw(handler)...) + { + _commits0 := _tool_id.Group("/commits", _commits0Mw(handler)...) + _commits0.POST("/list", append(_listtoolcommitMw(handler), apis.ListToolCommit)...) + } + { + _drafts0 := _tool_id.Group("/drafts", _drafts0Mw(handler)...) + _drafts0.POST("/commit", append(_committooldraftMw(handler), apis.CommitToolDraft)...) + _drafts0.POST("/save", append(_savetooldetailMw(handler), apis.SaveToolDetail)...) + } } } } diff --git a/backend/api/router/coze/loop/apis/middleware.go b/backend/api/router/coze/loop/apis/middleware.go index 662027519..aac2638bf 100644 --- a/backend/api/router/coze/loop/apis/middleware.go +++ b/backend/api/router/coze/loop/apis/middleware.go @@ -2019,3 +2019,53 @@ func _io_jobMw(handler *apis.APIHandler) []app.HandlerFunc { // your code... return nil } + +func _toolsMw(handler *apis.APIHandler) []app.HandlerFunc { + // your code... + return nil +} + +func _createtoolMw(handler *apis.APIHandler) []app.HandlerFunc { + // your code... + return nil +} + +func _listtoolMw(handler *apis.APIHandler) []app.HandlerFunc { + // your code... + return nil +} + +func _tool_idMw(handler *apis.APIHandler) []app.HandlerFunc { + // your code... + return nil +} + +func _gettooldetailMw(handler *apis.APIHandler) []app.HandlerFunc { + // your code... + return nil +} + +func _commits0Mw(handler *apis.APIHandler) []app.HandlerFunc { + // your code... + return nil +} + +func _listtoolcommitMw(handler *apis.APIHandler) []app.HandlerFunc { + // your code... + return nil +} + +func _drafts0Mw(handler *apis.APIHandler) []app.HandlerFunc { + // your code... + return nil +} + +func _committooldraftMw(handler *apis.APIHandler) []app.HandlerFunc { + // your code... + return nil +} + +func _savetooldetailMw(handler *apis.APIHandler) []app.HandlerFunc { + // your code... + return nil +} diff --git a/backend/go.sum b/backend/go.sum index fc81856af..5cc939c73 100644 --- a/backend/go.sum +++ b/backend/go.sum @@ -473,6 +473,7 @@ github.com/google/pprof v0.0.0-20240827171923-fa2c70bbbfe5/go.mod h1:vavhavw2zAx github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= github.com/google/s2a-go v0.1.8 h1:zZDs9gcbt9ZPLV0ndSyQk6Kacx2g/X+SKYovpnz3SMM= github.com/google/s2a-go v0.1.8/go.mod h1:6iNWHTpQ+nfNRN5E00MSdfDwVesa8hhS32PhPO8deJA= +github.com/google/subcommands v1.2.0 h1:vWQspBTo2nEqTUFita5/KeEWlUL8kQObDFbub/EN9oE= github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk= github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= diff --git a/backend/infra/platestwrite/latest_write_tracker.go b/backend/infra/platestwrite/latest_write_tracker.go index fcc568b15..d1e9c08df 100644 --- a/backend/infra/platestwrite/latest_write_tracker.go +++ b/backend/infra/platestwrite/latest_write_tracker.go @@ -131,6 +131,8 @@ const ( ResourceTypePromptCommitLabelMapping ResourceType = "prompt_commit_label_mapping" ResourceTypeCozeloopOptimizeTask ResourceType = "cozeloop_optimize_task" // 外场智能优化 ResourceTypePromptRelation ResourceType = "prompt_relation" + ResourceTypeToolBasic ResourceType = "tool_basic" + ResourceTypeToolCommit ResourceType = "tool_commit" ResourceTypeExperiment ResourceType = "experiment" ResourceTypeEvalSet ResourceType = "eval_set" diff --git a/backend/kitex_gen/coze/loop/apis/coze.loop.apis.go b/backend/kitex_gen/coze/loop/apis/coze.loop.apis.go index 843d56ec7..7414baef0 100644 --- a/backend/kitex_gen/coze/loop/apis/coze.loop.apis.go +++ b/backend/kitex_gen/coze/loop/apis/coze.loop.apis.go @@ -17,7 +17,7 @@ import ( "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/foundation/openapi" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/foundation/space" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/foundation/user" - manage0 "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/llm/manage" + manage1 "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/llm/manage" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/llm/runtime" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/observability/metric" openapi2 "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/observability/openapi" @@ -27,6 +27,7 @@ import ( "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/execute" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/manage" openapi1 "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/openapi" + manage0 "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" ) type EvaluationSetService interface { @@ -237,6 +238,32 @@ func NewPromptManageServiceClient(c thrift.TClient) *PromptManageServiceClient { } } +type ToolManageService interface { + manage0.ToolManageService +} + +type ToolManageServiceClient struct { + *manage0.ToolManageServiceClient +} + +func NewToolManageServiceClientFactory(t thrift.TTransport, f thrift.TProtocolFactory) *ToolManageServiceClient { + return &ToolManageServiceClient{ + ToolManageServiceClient: manage0.NewToolManageServiceClientFactory(t, f), + } +} + +func NewToolManageServiceClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *ToolManageServiceClient { + return &ToolManageServiceClient{ + ToolManageServiceClient: manage0.NewToolManageServiceClientProtocol(t, iprot, oprot), + } +} + +func NewToolManageServiceClient(c thrift.TClient) *ToolManageServiceClient { + return &ToolManageServiceClient{ + ToolManageServiceClient: manage0.NewToolManageServiceClient(c), + } +} + type PromptDebugService interface { debug.PromptDebugService } @@ -316,28 +343,28 @@ func NewPromptOpenAPIServiceClient(c thrift.TClient) *PromptOpenAPIServiceClient } type LLMManageService interface { - manage0.LLMManageService + manage1.LLMManageService } type LLMManageServiceClient struct { - *manage0.LLMManageServiceClient + *manage1.LLMManageServiceClient } func NewLLMManageServiceClientFactory(t thrift.TTransport, f thrift.TProtocolFactory) *LLMManageServiceClient { return &LLMManageServiceClient{ - LLMManageServiceClient: manage0.NewLLMManageServiceClientFactory(t, f), + LLMManageServiceClient: manage1.NewLLMManageServiceClientFactory(t, f), } } func NewLLMManageServiceClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *LLMManageServiceClient { return &LLMManageServiceClient{ - LLMManageServiceClient: manage0.NewLLMManageServiceClientProtocol(t, iprot, oprot), + LLMManageServiceClient: manage1.NewLLMManageServiceClientProtocol(t, iprot, oprot), } } func NewLLMManageServiceClient(c thrift.TClient) *LLMManageServiceClient { return &LLMManageServiceClient{ - LLMManageServiceClient: manage0.NewLLMManageServiceClient(c), + LLMManageServiceClient: manage1.NewLLMManageServiceClient(c), } } @@ -699,6 +726,15 @@ func NewPromptManageServiceProcessor(handler PromptManageService) *PromptManageS return self } +type ToolManageServiceProcessor struct { + *manage0.ToolManageServiceProcessor +} + +func NewToolManageServiceProcessor(handler ToolManageService) *ToolManageServiceProcessor { + self := &ToolManageServiceProcessor{manage0.NewToolManageServiceProcessor(handler)} + return self +} + type PromptDebugServiceProcessor struct { *debug.PromptDebugServiceProcessor } @@ -727,11 +763,11 @@ func NewPromptOpenAPIServiceProcessor(handler PromptOpenAPIService) *PromptOpenA } type LLMManageServiceProcessor struct { - *manage0.LLMManageServiceProcessor + *manage1.LLMManageServiceProcessor } func NewLLMManageServiceProcessor(handler LLMManageService) *LLMManageServiceProcessor { - self := &LLMManageServiceProcessor{manage0.NewLLMManageServiceProcessor(handler)} + self := &LLMManageServiceProcessor{manage1.NewLLMManageServiceProcessor(handler)} return self } diff --git a/backend/kitex_gen/coze/loop/apis/k-coze.loop.apis.go b/backend/kitex_gen/coze/loop/apis/k-coze.loop.apis.go index 418783992..afb881e30 100644 --- a/backend/kitex_gen/coze/loop/apis/k-coze.loop.apis.go +++ b/backend/kitex_gen/coze/loop/apis/k-coze.loop.apis.go @@ -23,7 +23,7 @@ import ( "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/foundation/openapi" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/foundation/space" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/foundation/user" - manage0 "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/llm/manage" + manage1 "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/llm/manage" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/llm/runtime" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/observability/metric" openapi2 "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/observability/openapi" @@ -33,6 +33,7 @@ import ( "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/execute" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/manage" openapi1 "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/openapi" + manage0 "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" ) var ( @@ -49,7 +50,7 @@ var ( _ = openapi.KitexUnusedProtection _ = space.KitexUnusedProtection _ = user.KitexUnusedProtection - _ = manage0.KitexUnusedProtection + _ = manage1.KitexUnusedProtection _ = runtime.KitexUnusedProtection _ = metric.KitexUnusedProtection _ = openapi2.KitexUnusedProtection @@ -59,6 +60,7 @@ var ( _ = execute.KitexUnusedProtection _ = manage.KitexUnusedProtection _ = openapi1.KitexUnusedProtection + _ = manage0.KitexUnusedProtection ) // unused protection diff --git a/backend/kitex_gen/coze/loop/apis/toolmanageservice/client.go b/backend/kitex_gen/coze/loop/apis/toolmanageservice/client.go new file mode 100644 index 000000000..27f94eaad --- /dev/null +++ b/backend/kitex_gen/coze/loop/apis/toolmanageservice/client.go @@ -0,0 +1,79 @@ +// Code generated by Kitex v0.13.1. DO NOT EDIT. + +package toolmanageservice + +import ( + "context" + client "github.com/cloudwego/kitex/client" + callopt "github.com/cloudwego/kitex/client/callopt" + manage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" +) + +// Client is designed to provide IDL-compatible methods with call-option parameter for kitex framework. +type Client interface { + CreateTool(ctx context.Context, request *manage.CreateToolRequest, callOptions ...callopt.Option) (r *manage.CreateToolResponse, err error) + GetToolDetail(ctx context.Context, request *manage.GetToolDetailRequest, callOptions ...callopt.Option) (r *manage.GetToolDetailResponse, err error) + ListTool(ctx context.Context, request *manage.ListToolRequest, callOptions ...callopt.Option) (r *manage.ListToolResponse, err error) + SaveToolDetail(ctx context.Context, request *manage.SaveToolDetailRequest, callOptions ...callopt.Option) (r *manage.SaveToolDetailResponse, err error) + CommitToolDraft(ctx context.Context, request *manage.CommitToolDraftRequest, callOptions ...callopt.Option) (r *manage.CommitToolDraftResponse, err error) + ListToolCommit(ctx context.Context, request *manage.ListToolCommitRequest, callOptions ...callopt.Option) (r *manage.ListToolCommitResponse, err error) +} + +// NewClient creates a client for the service defined in IDL. +func NewClient(destService string, opts ...client.Option) (Client, error) { + var options []client.Option + options = append(options, client.WithDestService(destService)) + + options = append(options, opts...) + + kc, err := client.NewClient(serviceInfo(), options...) + if err != nil { + return nil, err + } + return &kToolManageServiceClient{ + kClient: newServiceClient(kc), + }, nil +} + +// MustNewClient creates a client for the service defined in IDL. It panics if any error occurs. +func MustNewClient(destService string, opts ...client.Option) Client { + kc, err := NewClient(destService, opts...) + if err != nil { + panic(err) + } + return kc +} + +type kToolManageServiceClient struct { + *kClient +} + +func (p *kToolManageServiceClient) CreateTool(ctx context.Context, request *manage.CreateToolRequest, callOptions ...callopt.Option) (r *manage.CreateToolResponse, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.CreateTool(ctx, request) +} + +func (p *kToolManageServiceClient) GetToolDetail(ctx context.Context, request *manage.GetToolDetailRequest, callOptions ...callopt.Option) (r *manage.GetToolDetailResponse, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.GetToolDetail(ctx, request) +} + +func (p *kToolManageServiceClient) ListTool(ctx context.Context, request *manage.ListToolRequest, callOptions ...callopt.Option) (r *manage.ListToolResponse, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.ListTool(ctx, request) +} + +func (p *kToolManageServiceClient) SaveToolDetail(ctx context.Context, request *manage.SaveToolDetailRequest, callOptions ...callopt.Option) (r *manage.SaveToolDetailResponse, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.SaveToolDetail(ctx, request) +} + +func (p *kToolManageServiceClient) CommitToolDraft(ctx context.Context, request *manage.CommitToolDraftRequest, callOptions ...callopt.Option) (r *manage.CommitToolDraftResponse, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.CommitToolDraft(ctx, request) +} + +func (p *kToolManageServiceClient) ListToolCommit(ctx context.Context, request *manage.ListToolCommitRequest, callOptions ...callopt.Option) (r *manage.ListToolCommitResponse, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.ListToolCommit(ctx, request) +} diff --git a/backend/kitex_gen/coze/loop/apis/toolmanageservice/server.go b/backend/kitex_gen/coze/loop/apis/toolmanageservice/server.go new file mode 100644 index 000000000..28e906ea5 --- /dev/null +++ b/backend/kitex_gen/coze/loop/apis/toolmanageservice/server.go @@ -0,0 +1,25 @@ +// Code generated by Kitex v0.13.1. DO NOT EDIT. +package toolmanageservice + +import ( + server "github.com/cloudwego/kitex/server" + apis "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/apis" +) + +// NewServer creates a server.Server with the given handler and options. +func NewServer(handler apis.ToolManageService, opts ...server.Option) server.Server { + var options []server.Option + + options = append(options, opts...) + options = append(options, server.WithCompatibleMiddlewareForUnary()) + + svr := server.NewServer(options...) + if err := svr.RegisterService(serviceInfo(), handler); err != nil { + panic(err) + } + return svr +} + +func RegisterService(svr server.Server, handler apis.ToolManageService, opts ...server.RegisterOption) error { + return svr.RegisterService(serviceInfo(), handler, opts...) +} diff --git a/backend/kitex_gen/coze/loop/apis/toolmanageservice/toolmanageservice.go b/backend/kitex_gen/coze/loop/apis/toolmanageservice/toolmanageservice.go new file mode 100644 index 000000000..af3eed184 --- /dev/null +++ b/backend/kitex_gen/coze/loop/apis/toolmanageservice/toolmanageservice.go @@ -0,0 +1,276 @@ +// Code generated by Kitex v0.13.1. DO NOT EDIT. + +package toolmanageservice + +import ( + "context" + "errors" + client "github.com/cloudwego/kitex/client" + kitex "github.com/cloudwego/kitex/pkg/serviceinfo" + apis "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/apis" + manage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" +) + +var errInvalidMessageType = errors.New("invalid message type for service method handler") + +var serviceMethods = map[string]kitex.MethodInfo{ + "CreateTool": kitex.NewMethodInfo( + createToolHandler, + newToolManageServiceCreateToolArgs, + newToolManageServiceCreateToolResult, + false, + kitex.WithStreamingMode(kitex.StreamingNone), + ), + "GetToolDetail": kitex.NewMethodInfo( + getToolDetailHandler, + newToolManageServiceGetToolDetailArgs, + newToolManageServiceGetToolDetailResult, + false, + kitex.WithStreamingMode(kitex.StreamingNone), + ), + "ListTool": kitex.NewMethodInfo( + listToolHandler, + newToolManageServiceListToolArgs, + newToolManageServiceListToolResult, + false, + kitex.WithStreamingMode(kitex.StreamingNone), + ), + "SaveToolDetail": kitex.NewMethodInfo( + saveToolDetailHandler, + newToolManageServiceSaveToolDetailArgs, + newToolManageServiceSaveToolDetailResult, + false, + kitex.WithStreamingMode(kitex.StreamingNone), + ), + "CommitToolDraft": kitex.NewMethodInfo( + commitToolDraftHandler, + newToolManageServiceCommitToolDraftArgs, + newToolManageServiceCommitToolDraftResult, + false, + kitex.WithStreamingMode(kitex.StreamingNone), + ), + "ListToolCommit": kitex.NewMethodInfo( + listToolCommitHandler, + newToolManageServiceListToolCommitArgs, + newToolManageServiceListToolCommitResult, + false, + kitex.WithStreamingMode(kitex.StreamingNone), + ), +} + +var ( + toolManageServiceServiceInfo = NewServiceInfo() +) + +// for server +func serviceInfo() *kitex.ServiceInfo { + return toolManageServiceServiceInfo +} + +// NewServiceInfo creates a new ServiceInfo +func NewServiceInfo() *kitex.ServiceInfo { + return newServiceInfo() +} + +func newServiceInfo() *kitex.ServiceInfo { + serviceName := "ToolManageService" + handlerType := (*apis.ToolManageService)(nil) + extra := map[string]interface{}{ + "PackageName": "apis", + } + svcInfo := &kitex.ServiceInfo{ + ServiceName: serviceName, + HandlerType: handlerType, + Methods: serviceMethods, + PayloadCodec: kitex.Thrift, + KiteXGenVersion: "v0.13.1", + Extra: extra, + } + return svcInfo +} + +func createToolHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*manage.ToolManageServiceCreateToolArgs) + realResult := result.(*manage.ToolManageServiceCreateToolResult) + success, err := handler.(manage.ToolManageService).CreateTool(ctx, realArg.Request) + if err != nil { + return err + } + realResult.Success = success + return nil +} + +func newToolManageServiceCreateToolArgs() interface{} { + return manage.NewToolManageServiceCreateToolArgs() +} + +func newToolManageServiceCreateToolResult() interface{} { + return manage.NewToolManageServiceCreateToolResult() +} + +func getToolDetailHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*manage.ToolManageServiceGetToolDetailArgs) + realResult := result.(*manage.ToolManageServiceGetToolDetailResult) + success, err := handler.(manage.ToolManageService).GetToolDetail(ctx, realArg.Request) + if err != nil { + return err + } + realResult.Success = success + return nil +} + +func newToolManageServiceGetToolDetailArgs() interface{} { + return manage.NewToolManageServiceGetToolDetailArgs() +} + +func newToolManageServiceGetToolDetailResult() interface{} { + return manage.NewToolManageServiceGetToolDetailResult() +} + +func listToolHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*manage.ToolManageServiceListToolArgs) + realResult := result.(*manage.ToolManageServiceListToolResult) + success, err := handler.(manage.ToolManageService).ListTool(ctx, realArg.Request) + if err != nil { + return err + } + realResult.Success = success + return nil +} + +func newToolManageServiceListToolArgs() interface{} { + return manage.NewToolManageServiceListToolArgs() +} + +func newToolManageServiceListToolResult() interface{} { + return manage.NewToolManageServiceListToolResult() +} + +func saveToolDetailHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*manage.ToolManageServiceSaveToolDetailArgs) + realResult := result.(*manage.ToolManageServiceSaveToolDetailResult) + success, err := handler.(manage.ToolManageService).SaveToolDetail(ctx, realArg.Request) + if err != nil { + return err + } + realResult.Success = success + return nil +} + +func newToolManageServiceSaveToolDetailArgs() interface{} { + return manage.NewToolManageServiceSaveToolDetailArgs() +} + +func newToolManageServiceSaveToolDetailResult() interface{} { + return manage.NewToolManageServiceSaveToolDetailResult() +} + +func commitToolDraftHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*manage.ToolManageServiceCommitToolDraftArgs) + realResult := result.(*manage.ToolManageServiceCommitToolDraftResult) + success, err := handler.(manage.ToolManageService).CommitToolDraft(ctx, realArg.Request) + if err != nil { + return err + } + realResult.Success = success + return nil +} + +func newToolManageServiceCommitToolDraftArgs() interface{} { + return manage.NewToolManageServiceCommitToolDraftArgs() +} + +func newToolManageServiceCommitToolDraftResult() interface{} { + return manage.NewToolManageServiceCommitToolDraftResult() +} + +func listToolCommitHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*manage.ToolManageServiceListToolCommitArgs) + realResult := result.(*manage.ToolManageServiceListToolCommitResult) + success, err := handler.(manage.ToolManageService).ListToolCommit(ctx, realArg.Request) + if err != nil { + return err + } + realResult.Success = success + return nil +} + +func newToolManageServiceListToolCommitArgs() interface{} { + return manage.NewToolManageServiceListToolCommitArgs() +} + +func newToolManageServiceListToolCommitResult() interface{} { + return manage.NewToolManageServiceListToolCommitResult() +} + +type kClient struct { + c client.Client + sc client.Streaming +} + +func newServiceClient(c client.Client) *kClient { + return &kClient{ + c: c, + sc: c.(client.Streaming), + } +} + +func (p *kClient) CreateTool(ctx context.Context, request *manage.CreateToolRequest) (r *manage.CreateToolResponse, err error) { + var _args manage.ToolManageServiceCreateToolArgs + _args.Request = request + var _result manage.ToolManageServiceCreateToolResult + if err = p.c.Call(ctx, "CreateTool", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} + +func (p *kClient) GetToolDetail(ctx context.Context, request *manage.GetToolDetailRequest) (r *manage.GetToolDetailResponse, err error) { + var _args manage.ToolManageServiceGetToolDetailArgs + _args.Request = request + var _result manage.ToolManageServiceGetToolDetailResult + if err = p.c.Call(ctx, "GetToolDetail", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} + +func (p *kClient) ListTool(ctx context.Context, request *manage.ListToolRequest) (r *manage.ListToolResponse, err error) { + var _args manage.ToolManageServiceListToolArgs + _args.Request = request + var _result manage.ToolManageServiceListToolResult + if err = p.c.Call(ctx, "ListTool", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} + +func (p *kClient) SaveToolDetail(ctx context.Context, request *manage.SaveToolDetailRequest) (r *manage.SaveToolDetailResponse, err error) { + var _args manage.ToolManageServiceSaveToolDetailArgs + _args.Request = request + var _result manage.ToolManageServiceSaveToolDetailResult + if err = p.c.Call(ctx, "SaveToolDetail", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} + +func (p *kClient) CommitToolDraft(ctx context.Context, request *manage.CommitToolDraftRequest) (r *manage.CommitToolDraftResponse, err error) { + var _args manage.ToolManageServiceCommitToolDraftArgs + _args.Request = request + var _result manage.ToolManageServiceCommitToolDraftResult + if err = p.c.Call(ctx, "CommitToolDraft", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} + +func (p *kClient) ListToolCommit(ctx context.Context, request *manage.ListToolCommitRequest) (r *manage.ListToolCommitResponse, err error) { + var _args manage.ToolManageServiceListToolCommitArgs + _args.Request = request + var _result manage.ToolManageServiceListToolCommitResult + if err = p.c.Call(ctx, "ListToolCommit", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} diff --git a/backend/kitex_gen/coze/loop/observability/ingestion/ingestion.go b/backend/kitex_gen/coze/loop/observability/ingestion/ingestion.go new file mode 100644 index 000000000..8e5ddcf35 --- /dev/null +++ b/backend/kitex_gen/coze/loop/observability/ingestion/ingestion.go @@ -0,0 +1,3 @@ +package ingestion + +type IngestionService interface{} diff --git a/backend/kitex_gen/coze/loop/prompt/coze.loop.prompt.go b/backend/kitex_gen/coze/loop/prompt/coze.loop.prompt.go index 8fe26c222..bed5d4d7c 100644 --- a/backend/kitex_gen/coze/loop/prompt/coze.loop.prompt.go +++ b/backend/kitex_gen/coze/loop/prompt/coze.loop.prompt.go @@ -8,6 +8,7 @@ import ( "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/execute" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/manage" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/openapi" + manage0 "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" ) type PromptManageService interface { @@ -36,6 +37,32 @@ func NewPromptManageServiceClient(c thrift.TClient) *PromptManageServiceClient { } } +type ToolManageService interface { + manage0.ToolManageService +} + +type ToolManageServiceClient struct { + *manage0.ToolManageServiceClient +} + +func NewToolManageServiceClientFactory(t thrift.TTransport, f thrift.TProtocolFactory) *ToolManageServiceClient { + return &ToolManageServiceClient{ + ToolManageServiceClient: manage0.NewToolManageServiceClientFactory(t, f), + } +} + +func NewToolManageServiceClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *ToolManageServiceClient { + return &ToolManageServiceClient{ + ToolManageServiceClient: manage0.NewToolManageServiceClientProtocol(t, iprot, oprot), + } +} + +func NewToolManageServiceClient(c thrift.TClient) *ToolManageServiceClient { + return &ToolManageServiceClient{ + ToolManageServiceClient: manage0.NewToolManageServiceClient(c), + } +} + type PromptDebugService interface { debug.PromptDebugService } @@ -123,6 +150,15 @@ func NewPromptManageServiceProcessor(handler PromptManageService) *PromptManageS return self } +type ToolManageServiceProcessor struct { + *manage0.ToolManageServiceProcessor +} + +func NewToolManageServiceProcessor(handler ToolManageService) *ToolManageServiceProcessor { + self := &ToolManageServiceProcessor{manage0.NewToolManageServiceProcessor(handler)} + return self +} + type PromptDebugServiceProcessor struct { *debug.PromptDebugServiceProcessor } diff --git a/backend/kitex_gen/coze/loop/prompt/domain/tool/k-consts.go b/backend/kitex_gen/coze/loop/prompt/domain/tool/k-consts.go new file mode 100644 index 000000000..414cc4f88 --- /dev/null +++ b/backend/kitex_gen/coze/loop/prompt/domain/tool/k-consts.go @@ -0,0 +1,4 @@ +package tool + +// KitexUnusedProtection is used to prevent 'imported and not used' error. +var KitexUnusedProtection = struct{}{} diff --git a/backend/kitex_gen/coze/loop/prompt/domain/tool/k-tool.go b/backend/kitex_gen/coze/loop/prompt/domain/tool/k-tool.go new file mode 100644 index 000000000..99ff6b556 --- /dev/null +++ b/backend/kitex_gen/coze/loop/prompt/domain/tool/k-tool.go @@ -0,0 +1,1581 @@ +// Code generated by Kitex v0.13.1. DO NOT EDIT. + +package tool + +import ( + "bytes" + "fmt" + "reflect" + "strings" + + "github.com/cloudwego/gopkg/protocol/thrift" + kutils "github.com/cloudwego/kitex/pkg/utils" +) + +// unused protection +var ( + _ = fmt.Formatter(nil) + _ = (*bytes.Buffer)(nil) + _ = (*strings.Builder)(nil) + _ = reflect.Type(nil) + _ = thrift.STOP +) + +func (p *Tool) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.I64 { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 2: + if fieldTypeId == thrift.I64 { + l, err = p.FastReadField2(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 3: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField3(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 4: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField4(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 255: + if fieldTypeId == thrift.MAP { + l, err = p.FastReadField255(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_Tool[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *Tool) FastReadField1(buf []byte) (int, error) { + offset := 0 + + var _field *int64 + if v, l, err := thrift.Binary.ReadI64(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.ID = _field + return offset, nil +} + +func (p *Tool) FastReadField2(buf []byte) (int, error) { + offset := 0 + + var _field *int64 + if v, l, err := thrift.Binary.ReadI64(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.WorkspaceID = _field + return offset, nil +} + +func (p *Tool) FastReadField3(buf []byte) (int, error) { + offset := 0 + _field := NewToolBasic() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.ToolBasic = _field + return offset, nil +} + +func (p *Tool) FastReadField4(buf []byte) (int, error) { + offset := 0 + _field := NewToolCommit() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.ToolCommit = _field + return offset, nil +} + +func (p *Tool) FastReadField255(buf []byte) (int, error) { + offset := 0 + + _, _, size, l, err := thrift.Binary.ReadMapBegin(buf[offset:]) + offset += l + if err != nil { + return offset, err + } + _field := make(map[string]string, size) + for i := 0; i < size; i++ { + var _key string + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _key = v + } + + var _val string + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _val = v + } + + _field[_key] = _val + } + p.ExtInfos = _field + return offset, nil +} + +func (p *Tool) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *Tool) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField1(buf[offset:], w) + offset += p.fastWriteField2(buf[offset:], w) + offset += p.fastWriteField3(buf[offset:], w) + offset += p.fastWriteField4(buf[offset:], w) + offset += p.fastWriteField255(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *Tool) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + l += p.field2Length() + l += p.field3Length() + l += p.field4Length() + l += p.field255Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *Tool) fastWriteField1(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetID() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.I64, 1) + offset += thrift.Binary.WriteI64(buf[offset:], *p.ID) + } + return offset +} + +func (p *Tool) fastWriteField2(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetWorkspaceID() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.I64, 2) + offset += thrift.Binary.WriteI64(buf[offset:], *p.WorkspaceID) + } + return offset +} + +func (p *Tool) fastWriteField3(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetToolBasic() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 3) + offset += p.ToolBasic.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *Tool) fastWriteField4(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetToolCommit() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 4) + offset += p.ToolCommit.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *Tool) fastWriteField255(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetExtInfos() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.MAP, 255) + mapBeginOffset := offset + offset += thrift.Binary.MapBeginLength() + var length int + for k, v := range p.ExtInfos { + length++ + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, k) + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, v) + } + thrift.Binary.WriteMapBegin(buf[mapBeginOffset:], thrift.STRING, thrift.STRING, length) + } + return offset +} + +func (p *Tool) field1Length() int { + l := 0 + if p.IsSetID() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.I64Length() + } + return l +} + +func (p *Tool) field2Length() int { + l := 0 + if p.IsSetWorkspaceID() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.I64Length() + } + return l +} + +func (p *Tool) field3Length() int { + l := 0 + if p.IsSetToolBasic() { + l += thrift.Binary.FieldBeginLength() + l += p.ToolBasic.BLength() + } + return l +} + +func (p *Tool) field4Length() int { + l := 0 + if p.IsSetToolCommit() { + l += thrift.Binary.FieldBeginLength() + l += p.ToolCommit.BLength() + } + return l +} + +func (p *Tool) field255Length() int { + l := 0 + if p.IsSetExtInfos() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.MapBeginLength() + for k, v := range p.ExtInfos { + _, _ = k, v + + l += thrift.Binary.StringLengthNocopy(k) + l += thrift.Binary.StringLengthNocopy(v) + } + } + return l +} + +func (p *Tool) DeepCopy(s interface{}) error { + src, ok := s.(*Tool) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + if src.ID != nil { + tmp := *src.ID + p.ID = &tmp + } + + if src.WorkspaceID != nil { + tmp := *src.WorkspaceID + p.WorkspaceID = &tmp + } + + var _toolBasic *ToolBasic + if src.ToolBasic != nil { + _toolBasic = &ToolBasic{} + if err := _toolBasic.DeepCopy(src.ToolBasic); err != nil { + return err + } + } + p.ToolBasic = _toolBasic + + var _toolCommit *ToolCommit + if src.ToolCommit != nil { + _toolCommit = &ToolCommit{} + if err := _toolCommit.DeepCopy(src.ToolCommit); err != nil { + return err + } + } + p.ToolCommit = _toolCommit + + if src.ExtInfos != nil { + p.ExtInfos = make(map[string]string, len(src.ExtInfos)) + for key, val := range src.ExtInfos { + var _key string + if key != "" { + _key = kutils.StringDeepCopy(key) + } + + var _val string + if val != "" { + _val = kutils.StringDeepCopy(val) + } + + p.ExtInfos[_key] = _val + } + } + + return nil +} + +func (p *ToolBasic) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 2: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField2(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 3: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField3(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 4: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField4(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 5: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField5(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 6: + if fieldTypeId == thrift.I64 { + l, err = p.FastReadField6(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 7: + if fieldTypeId == thrift.I64 { + l, err = p.FastReadField7(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolBasic[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *ToolBasic) FastReadField1(buf []byte) (int, error) { + offset := 0 + + var _field *string + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.Name = _field + return offset, nil +} + +func (p *ToolBasic) FastReadField2(buf []byte) (int, error) { + offset := 0 + + var _field *string + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.Description = _field + return offset, nil +} + +func (p *ToolBasic) FastReadField3(buf []byte) (int, error) { + offset := 0 + + var _field *string + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.LatestCommittedVersion = _field + return offset, nil +} + +func (p *ToolBasic) FastReadField4(buf []byte) (int, error) { + offset := 0 + + var _field *string + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.CreatedBy = _field + return offset, nil +} + +func (p *ToolBasic) FastReadField5(buf []byte) (int, error) { + offset := 0 + + var _field *string + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.UpdatedBy = _field + return offset, nil +} + +func (p *ToolBasic) FastReadField6(buf []byte) (int, error) { + offset := 0 + + var _field *int64 + if v, l, err := thrift.Binary.ReadI64(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.CreatedAt = _field + return offset, nil +} + +func (p *ToolBasic) FastReadField7(buf []byte) (int, error) { + offset := 0 + + var _field *int64 + if v, l, err := thrift.Binary.ReadI64(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.UpdatedAt = _field + return offset, nil +} + +func (p *ToolBasic) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *ToolBasic) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField6(buf[offset:], w) + offset += p.fastWriteField7(buf[offset:], w) + offset += p.fastWriteField1(buf[offset:], w) + offset += p.fastWriteField2(buf[offset:], w) + offset += p.fastWriteField3(buf[offset:], w) + offset += p.fastWriteField4(buf[offset:], w) + offset += p.fastWriteField5(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *ToolBasic) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + l += p.field2Length() + l += p.field3Length() + l += p.field4Length() + l += p.field5Length() + l += p.field6Length() + l += p.field7Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *ToolBasic) fastWriteField1(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetName() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRING, 1) + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, *p.Name) + } + return offset +} + +func (p *ToolBasic) fastWriteField2(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetDescription() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRING, 2) + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, *p.Description) + } + return offset +} + +func (p *ToolBasic) fastWriteField3(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetLatestCommittedVersion() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRING, 3) + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, *p.LatestCommittedVersion) + } + return offset +} + +func (p *ToolBasic) fastWriteField4(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetCreatedBy() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRING, 4) + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, *p.CreatedBy) + } + return offset +} + +func (p *ToolBasic) fastWriteField5(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetUpdatedBy() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRING, 5) + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, *p.UpdatedBy) + } + return offset +} + +func (p *ToolBasic) fastWriteField6(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetCreatedAt() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.I64, 6) + offset += thrift.Binary.WriteI64(buf[offset:], *p.CreatedAt) + } + return offset +} + +func (p *ToolBasic) fastWriteField7(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetUpdatedAt() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.I64, 7) + offset += thrift.Binary.WriteI64(buf[offset:], *p.UpdatedAt) + } + return offset +} + +func (p *ToolBasic) field1Length() int { + l := 0 + if p.IsSetName() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.StringLengthNocopy(*p.Name) + } + return l +} + +func (p *ToolBasic) field2Length() int { + l := 0 + if p.IsSetDescription() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.StringLengthNocopy(*p.Description) + } + return l +} + +func (p *ToolBasic) field3Length() int { + l := 0 + if p.IsSetLatestCommittedVersion() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.StringLengthNocopy(*p.LatestCommittedVersion) + } + return l +} + +func (p *ToolBasic) field4Length() int { + l := 0 + if p.IsSetCreatedBy() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.StringLengthNocopy(*p.CreatedBy) + } + return l +} + +func (p *ToolBasic) field5Length() int { + l := 0 + if p.IsSetUpdatedBy() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.StringLengthNocopy(*p.UpdatedBy) + } + return l +} + +func (p *ToolBasic) field6Length() int { + l := 0 + if p.IsSetCreatedAt() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.I64Length() + } + return l +} + +func (p *ToolBasic) field7Length() int { + l := 0 + if p.IsSetUpdatedAt() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.I64Length() + } + return l +} + +func (p *ToolBasic) DeepCopy(s interface{}) error { + src, ok := s.(*ToolBasic) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + if src.Name != nil { + var tmp string + if *src.Name != "" { + tmp = kutils.StringDeepCopy(*src.Name) + } + p.Name = &tmp + } + + if src.Description != nil { + var tmp string + if *src.Description != "" { + tmp = kutils.StringDeepCopy(*src.Description) + } + p.Description = &tmp + } + + if src.LatestCommittedVersion != nil { + var tmp string + if *src.LatestCommittedVersion != "" { + tmp = kutils.StringDeepCopy(*src.LatestCommittedVersion) + } + p.LatestCommittedVersion = &tmp + } + + if src.CreatedBy != nil { + var tmp string + if *src.CreatedBy != "" { + tmp = kutils.StringDeepCopy(*src.CreatedBy) + } + p.CreatedBy = &tmp + } + + if src.UpdatedBy != nil { + var tmp string + if *src.UpdatedBy != "" { + tmp = kutils.StringDeepCopy(*src.UpdatedBy) + } + p.UpdatedBy = &tmp + } + + if src.CreatedAt != nil { + tmp := *src.CreatedAt + p.CreatedAt = &tmp + } + + if src.UpdatedAt != nil { + tmp := *src.UpdatedAt + p.UpdatedAt = &tmp + } + + return nil +} + +func (p *ToolCommit) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 2: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField2(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolCommit[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *ToolCommit) FastReadField1(buf []byte) (int, error) { + offset := 0 + _field := NewToolDetail() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Detail = _field + return offset, nil +} + +func (p *ToolCommit) FastReadField2(buf []byte) (int, error) { + offset := 0 + _field := NewCommitInfo() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.CommitInfo = _field + return offset, nil +} + +func (p *ToolCommit) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *ToolCommit) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField1(buf[offset:], w) + offset += p.fastWriteField2(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *ToolCommit) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + l += p.field2Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *ToolCommit) fastWriteField1(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetDetail() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 1) + offset += p.Detail.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *ToolCommit) fastWriteField2(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetCommitInfo() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 2) + offset += p.CommitInfo.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *ToolCommit) field1Length() int { + l := 0 + if p.IsSetDetail() { + l += thrift.Binary.FieldBeginLength() + l += p.Detail.BLength() + } + return l +} + +func (p *ToolCommit) field2Length() int { + l := 0 + if p.IsSetCommitInfo() { + l += thrift.Binary.FieldBeginLength() + l += p.CommitInfo.BLength() + } + return l +} + +func (p *ToolCommit) DeepCopy(s interface{}) error { + src, ok := s.(*ToolCommit) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + var _detail *ToolDetail + if src.Detail != nil { + _detail = &ToolDetail{} + if err := _detail.DeepCopy(src.Detail); err != nil { + return err + } + } + p.Detail = _detail + + var _commitInfo *CommitInfo + if src.CommitInfo != nil { + _commitInfo = &CommitInfo{} + if err := _commitInfo.DeepCopy(src.CommitInfo); err != nil { + return err + } + } + p.CommitInfo = _commitInfo + + return nil +} + +func (p *CommitInfo) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 2: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField2(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 3: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField3(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 4: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField4(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 5: + if fieldTypeId == thrift.I64 { + l, err = p.FastReadField5(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_CommitInfo[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *CommitInfo) FastReadField1(buf []byte) (int, error) { + offset := 0 + + var _field *string + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.Version = _field + return offset, nil +} + +func (p *CommitInfo) FastReadField2(buf []byte) (int, error) { + offset := 0 + + var _field *string + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.BaseVersion = _field + return offset, nil +} + +func (p *CommitInfo) FastReadField3(buf []byte) (int, error) { + offset := 0 + + var _field *string + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.Description = _field + return offset, nil +} + +func (p *CommitInfo) FastReadField4(buf []byte) (int, error) { + offset := 0 + + var _field *string + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.CommittedBy = _field + return offset, nil +} + +func (p *CommitInfo) FastReadField5(buf []byte) (int, error) { + offset := 0 + + var _field *int64 + if v, l, err := thrift.Binary.ReadI64(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.CommittedAt = _field + return offset, nil +} + +func (p *CommitInfo) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *CommitInfo) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField5(buf[offset:], w) + offset += p.fastWriteField1(buf[offset:], w) + offset += p.fastWriteField2(buf[offset:], w) + offset += p.fastWriteField3(buf[offset:], w) + offset += p.fastWriteField4(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *CommitInfo) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + l += p.field2Length() + l += p.field3Length() + l += p.field4Length() + l += p.field5Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *CommitInfo) fastWriteField1(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetVersion() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRING, 1) + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, *p.Version) + } + return offset +} + +func (p *CommitInfo) fastWriteField2(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetBaseVersion() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRING, 2) + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, *p.BaseVersion) + } + return offset +} + +func (p *CommitInfo) fastWriteField3(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetDescription() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRING, 3) + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, *p.Description) + } + return offset +} + +func (p *CommitInfo) fastWriteField4(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetCommittedBy() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRING, 4) + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, *p.CommittedBy) + } + return offset +} + +func (p *CommitInfo) fastWriteField5(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetCommittedAt() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.I64, 5) + offset += thrift.Binary.WriteI64(buf[offset:], *p.CommittedAt) + } + return offset +} + +func (p *CommitInfo) field1Length() int { + l := 0 + if p.IsSetVersion() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.StringLengthNocopy(*p.Version) + } + return l +} + +func (p *CommitInfo) field2Length() int { + l := 0 + if p.IsSetBaseVersion() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.StringLengthNocopy(*p.BaseVersion) + } + return l +} + +func (p *CommitInfo) field3Length() int { + l := 0 + if p.IsSetDescription() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.StringLengthNocopy(*p.Description) + } + return l +} + +func (p *CommitInfo) field4Length() int { + l := 0 + if p.IsSetCommittedBy() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.StringLengthNocopy(*p.CommittedBy) + } + return l +} + +func (p *CommitInfo) field5Length() int { + l := 0 + if p.IsSetCommittedAt() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.I64Length() + } + return l +} + +func (p *CommitInfo) DeepCopy(s interface{}) error { + src, ok := s.(*CommitInfo) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + if src.Version != nil { + var tmp string + if *src.Version != "" { + tmp = kutils.StringDeepCopy(*src.Version) + } + p.Version = &tmp + } + + if src.BaseVersion != nil { + var tmp string + if *src.BaseVersion != "" { + tmp = kutils.StringDeepCopy(*src.BaseVersion) + } + p.BaseVersion = &tmp + } + + if src.Description != nil { + var tmp string + if *src.Description != "" { + tmp = kutils.StringDeepCopy(*src.Description) + } + p.Description = &tmp + } + + if src.CommittedBy != nil { + var tmp string + if *src.CommittedBy != "" { + tmp = kutils.StringDeepCopy(*src.CommittedBy) + } + p.CommittedBy = &tmp + } + + if src.CommittedAt != nil { + tmp := *src.CommittedAt + p.CommittedAt = &tmp + } + + return nil +} + +func (p *ToolDetail) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 255: + if fieldTypeId == thrift.MAP { + l, err = p.FastReadField255(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolDetail[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *ToolDetail) FastReadField1(buf []byte) (int, error) { + offset := 0 + + var _field *string + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.Content = _field + return offset, nil +} + +func (p *ToolDetail) FastReadField255(buf []byte) (int, error) { + offset := 0 + + _, _, size, l, err := thrift.Binary.ReadMapBegin(buf[offset:]) + offset += l + if err != nil { + return offset, err + } + _field := make(map[string]string, size) + for i := 0; i < size; i++ { + var _key string + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _key = v + } + + var _val string + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _val = v + } + + _field[_key] = _val + } + p.ExtInfos = _field + return offset, nil +} + +func (p *ToolDetail) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *ToolDetail) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField1(buf[offset:], w) + offset += p.fastWriteField255(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *ToolDetail) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + l += p.field255Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *ToolDetail) fastWriteField1(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetContent() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRING, 1) + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, *p.Content) + } + return offset +} + +func (p *ToolDetail) fastWriteField255(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetExtInfos() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.MAP, 255) + mapBeginOffset := offset + offset += thrift.Binary.MapBeginLength() + var length int + for k, v := range p.ExtInfos { + length++ + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, k) + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, v) + } + thrift.Binary.WriteMapBegin(buf[mapBeginOffset:], thrift.STRING, thrift.STRING, length) + } + return offset +} + +func (p *ToolDetail) field1Length() int { + l := 0 + if p.IsSetContent() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.StringLengthNocopy(*p.Content) + } + return l +} + +func (p *ToolDetail) field255Length() int { + l := 0 + if p.IsSetExtInfos() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.MapBeginLength() + for k, v := range p.ExtInfos { + _, _ = k, v + + l += thrift.Binary.StringLengthNocopy(k) + l += thrift.Binary.StringLengthNocopy(v) + } + } + return l +} + +func (p *ToolDetail) DeepCopy(s interface{}) error { + src, ok := s.(*ToolDetail) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + if src.Content != nil { + var tmp string + if *src.Content != "" { + tmp = kutils.StringDeepCopy(*src.Content) + } + p.Content = &tmp + } + + if src.ExtInfos != nil { + p.ExtInfos = make(map[string]string, len(src.ExtInfos)) + for key, val := range src.ExtInfos { + var _key string + if key != "" { + _key = kutils.StringDeepCopy(key) + } + + var _val string + if val != "" { + _val = kutils.StringDeepCopy(val) + } + + p.ExtInfos[_key] = _val + } + } + + return nil +} diff --git a/backend/kitex_gen/coze/loop/prompt/domain/tool/tool.go b/backend/kitex_gen/coze/loop/prompt/domain/tool/tool.go new file mode 100644 index 000000000..ebb97d44f --- /dev/null +++ b/backend/kitex_gen/coze/loop/prompt/domain/tool/tool.go @@ -0,0 +1,2178 @@ +// Code generated by thriftgo (0.4.1). DO NOT EDIT. + +package tool + +import ( + "fmt" + "github.com/apache/thrift/lib/go/thrift" + "strings" +) + +const ( + PublicDraftVersion = "$PublicDraft" +) + +type Tool struct { + ID *int64 `thrift:"id,1,optional" frugal:"1,optional,i64" json:"id" form:"id" query:"id"` + WorkspaceID *int64 `thrift:"workspace_id,2,optional" frugal:"2,optional,i64" json:"workspace_id" form:"workspace_id" query:"workspace_id"` + ToolBasic *ToolBasic `thrift:"tool_basic,3,optional" frugal:"3,optional,ToolBasic" form:"tool_basic" json:"tool_basic,omitempty" query:"tool_basic"` + ToolCommit *ToolCommit `thrift:"tool_commit,4,optional" frugal:"4,optional,ToolCommit" form:"tool_commit" json:"tool_commit,omitempty" query:"tool_commit"` + ExtInfos map[string]string `thrift:"ext_infos,255,optional" frugal:"255,optional,map" form:"ext_infos" json:"ext_infos,omitempty" query:"ext_infos"` +} + +func NewTool() *Tool { + return &Tool{} +} + +func (p *Tool) InitDefault() { +} + +var Tool_ID_DEFAULT int64 + +func (p *Tool) GetID() (v int64) { + if p == nil { + return + } + if !p.IsSetID() { + return Tool_ID_DEFAULT + } + return *p.ID +} + +var Tool_WorkspaceID_DEFAULT int64 + +func (p *Tool) GetWorkspaceID() (v int64) { + if p == nil { + return + } + if !p.IsSetWorkspaceID() { + return Tool_WorkspaceID_DEFAULT + } + return *p.WorkspaceID +} + +var Tool_ToolBasic_DEFAULT *ToolBasic + +func (p *Tool) GetToolBasic() (v *ToolBasic) { + if p == nil { + return + } + if !p.IsSetToolBasic() { + return Tool_ToolBasic_DEFAULT + } + return p.ToolBasic +} + +var Tool_ToolCommit_DEFAULT *ToolCommit + +func (p *Tool) GetToolCommit() (v *ToolCommit) { + if p == nil { + return + } + if !p.IsSetToolCommit() { + return Tool_ToolCommit_DEFAULT + } + return p.ToolCommit +} + +var Tool_ExtInfos_DEFAULT map[string]string + +func (p *Tool) GetExtInfos() (v map[string]string) { + if p == nil { + return + } + if !p.IsSetExtInfos() { + return Tool_ExtInfos_DEFAULT + } + return p.ExtInfos +} +func (p *Tool) SetID(val *int64) { + p.ID = val +} +func (p *Tool) SetWorkspaceID(val *int64) { + p.WorkspaceID = val +} +func (p *Tool) SetToolBasic(val *ToolBasic) { + p.ToolBasic = val +} +func (p *Tool) SetToolCommit(val *ToolCommit) { + p.ToolCommit = val +} +func (p *Tool) SetExtInfos(val map[string]string) { + p.ExtInfos = val +} + +var fieldIDToName_Tool = map[int16]string{ + 1: "id", + 2: "workspace_id", + 3: "tool_basic", + 4: "tool_commit", + 255: "ext_infos", +} + +func (p *Tool) IsSetID() bool { + return p.ID != nil +} + +func (p *Tool) IsSetWorkspaceID() bool { + return p.WorkspaceID != nil +} + +func (p *Tool) IsSetToolBasic() bool { + return p.ToolBasic != nil +} + +func (p *Tool) IsSetToolCommit() bool { + return p.ToolCommit != nil +} + +func (p *Tool) IsSetExtInfos() bool { + return p.ExtInfos != nil +} + +func (p *Tool) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.I64 { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 2: + if fieldTypeId == thrift.I64 { + if err = p.ReadField2(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 3: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField3(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 4: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField4(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 255: + if fieldTypeId == thrift.MAP { + if err = p.ReadField255(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_Tool[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *Tool) ReadField1(iprot thrift.TProtocol) error { + + var _field *int64 + if v, err := iprot.ReadI64(); err != nil { + return err + } else { + _field = &v + } + p.ID = _field + return nil +} +func (p *Tool) ReadField2(iprot thrift.TProtocol) error { + + var _field *int64 + if v, err := iprot.ReadI64(); err != nil { + return err + } else { + _field = &v + } + p.WorkspaceID = _field + return nil +} +func (p *Tool) ReadField3(iprot thrift.TProtocol) error { + _field := NewToolBasic() + if err := _field.Read(iprot); err != nil { + return err + } + p.ToolBasic = _field + return nil +} +func (p *Tool) ReadField4(iprot thrift.TProtocol) error { + _field := NewToolCommit() + if err := _field.Read(iprot); err != nil { + return err + } + p.ToolCommit = _field + return nil +} +func (p *Tool) ReadField255(iprot thrift.TProtocol) error { + _, _, size, err := iprot.ReadMapBegin() + if err != nil { + return err + } + _field := make(map[string]string, size) + for i := 0; i < size; i++ { + var _key string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _key = v + } + + var _val string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _val = v + } + + _field[_key] = _val + } + if err := iprot.ReadMapEnd(); err != nil { + return err + } + p.ExtInfos = _field + return nil +} + +func (p *Tool) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("Tool"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + if err = p.writeField2(oprot); err != nil { + fieldId = 2 + goto WriteFieldError + } + if err = p.writeField3(oprot); err != nil { + fieldId = 3 + goto WriteFieldError + } + if err = p.writeField4(oprot); err != nil { + fieldId = 4 + goto WriteFieldError + } + if err = p.writeField255(oprot); err != nil { + fieldId = 255 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *Tool) writeField1(oprot thrift.TProtocol) (err error) { + if p.IsSetID() { + if err = oprot.WriteFieldBegin("id", thrift.I64, 1); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI64(*p.ID); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} +func (p *Tool) writeField2(oprot thrift.TProtocol) (err error) { + if p.IsSetWorkspaceID() { + if err = oprot.WriteFieldBegin("workspace_id", thrift.I64, 2); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI64(*p.WorkspaceID); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err) +} +func (p *Tool) writeField3(oprot thrift.TProtocol) (err error) { + if p.IsSetToolBasic() { + if err = oprot.WriteFieldBegin("tool_basic", thrift.STRUCT, 3); err != nil { + goto WriteFieldBeginError + } + if err := p.ToolBasic.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 3 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 3 end error: ", p), err) +} +func (p *Tool) writeField4(oprot thrift.TProtocol) (err error) { + if p.IsSetToolCommit() { + if err = oprot.WriteFieldBegin("tool_commit", thrift.STRUCT, 4); err != nil { + goto WriteFieldBeginError + } + if err := p.ToolCommit.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 4 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 4 end error: ", p), err) +} +func (p *Tool) writeField255(oprot thrift.TProtocol) (err error) { + if p.IsSetExtInfos() { + if err = oprot.WriteFieldBegin("ext_infos", thrift.MAP, 255); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteMapBegin(thrift.STRING, thrift.STRING, len(p.ExtInfos)); err != nil { + return err + } + for k, v := range p.ExtInfos { + if err := oprot.WriteString(k); err != nil { + return err + } + if err := oprot.WriteString(v); err != nil { + return err + } + } + if err := oprot.WriteMapEnd(); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 end error: ", p), err) +} + +func (p *Tool) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("Tool(%+v)", *p) + +} + +func (p *Tool) DeepEqual(ano *Tool) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.ID) { + return false + } + if !p.Field2DeepEqual(ano.WorkspaceID) { + return false + } + if !p.Field3DeepEqual(ano.ToolBasic) { + return false + } + if !p.Field4DeepEqual(ano.ToolCommit) { + return false + } + if !p.Field255DeepEqual(ano.ExtInfos) { + return false + } + return true +} + +func (p *Tool) Field1DeepEqual(src *int64) bool { + + if p.ID == src { + return true + } else if p.ID == nil || src == nil { + return false + } + if *p.ID != *src { + return false + } + return true +} +func (p *Tool) Field2DeepEqual(src *int64) bool { + + if p.WorkspaceID == src { + return true + } else if p.WorkspaceID == nil || src == nil { + return false + } + if *p.WorkspaceID != *src { + return false + } + return true +} +func (p *Tool) Field3DeepEqual(src *ToolBasic) bool { + + if !p.ToolBasic.DeepEqual(src) { + return false + } + return true +} +func (p *Tool) Field4DeepEqual(src *ToolCommit) bool { + + if !p.ToolCommit.DeepEqual(src) { + return false + } + return true +} +func (p *Tool) Field255DeepEqual(src map[string]string) bool { + + if len(p.ExtInfos) != len(src) { + return false + } + for k, v := range p.ExtInfos { + _src := src[k] + if strings.Compare(v, _src) != 0 { + return false + } + } + return true +} + +type ToolBasic struct { + Name *string `thrift:"name,1,optional" frugal:"1,optional,string" form:"name" json:"name,omitempty" query:"name"` + Description *string `thrift:"description,2,optional" frugal:"2,optional,string" form:"description" json:"description,omitempty" query:"description"` + LatestCommittedVersion *string `thrift:"latest_committed_version,3,optional" frugal:"3,optional,string" form:"latest_committed_version" json:"latest_committed_version,omitempty" query:"latest_committed_version"` + CreatedBy *string `thrift:"created_by,4,optional" frugal:"4,optional,string" form:"created_by" json:"created_by,omitempty" query:"created_by"` + UpdatedBy *string `thrift:"updated_by,5,optional" frugal:"5,optional,string" form:"updated_by" json:"updated_by,omitempty" query:"updated_by"` + CreatedAt *int64 `thrift:"created_at,6,optional" frugal:"6,optional,i64" json:"created_at" form:"created_at" query:"created_at"` + UpdatedAt *int64 `thrift:"updated_at,7,optional" frugal:"7,optional,i64" json:"updated_at" form:"updated_at" query:"updated_at"` +} + +func NewToolBasic() *ToolBasic { + return &ToolBasic{} +} + +func (p *ToolBasic) InitDefault() { +} + +var ToolBasic_Name_DEFAULT string + +func (p *ToolBasic) GetName() (v string) { + if p == nil { + return + } + if !p.IsSetName() { + return ToolBasic_Name_DEFAULT + } + return *p.Name +} + +var ToolBasic_Description_DEFAULT string + +func (p *ToolBasic) GetDescription() (v string) { + if p == nil { + return + } + if !p.IsSetDescription() { + return ToolBasic_Description_DEFAULT + } + return *p.Description +} + +var ToolBasic_LatestCommittedVersion_DEFAULT string + +func (p *ToolBasic) GetLatestCommittedVersion() (v string) { + if p == nil { + return + } + if !p.IsSetLatestCommittedVersion() { + return ToolBasic_LatestCommittedVersion_DEFAULT + } + return *p.LatestCommittedVersion +} + +var ToolBasic_CreatedBy_DEFAULT string + +func (p *ToolBasic) GetCreatedBy() (v string) { + if p == nil { + return + } + if !p.IsSetCreatedBy() { + return ToolBasic_CreatedBy_DEFAULT + } + return *p.CreatedBy +} + +var ToolBasic_UpdatedBy_DEFAULT string + +func (p *ToolBasic) GetUpdatedBy() (v string) { + if p == nil { + return + } + if !p.IsSetUpdatedBy() { + return ToolBasic_UpdatedBy_DEFAULT + } + return *p.UpdatedBy +} + +var ToolBasic_CreatedAt_DEFAULT int64 + +func (p *ToolBasic) GetCreatedAt() (v int64) { + if p == nil { + return + } + if !p.IsSetCreatedAt() { + return ToolBasic_CreatedAt_DEFAULT + } + return *p.CreatedAt +} + +var ToolBasic_UpdatedAt_DEFAULT int64 + +func (p *ToolBasic) GetUpdatedAt() (v int64) { + if p == nil { + return + } + if !p.IsSetUpdatedAt() { + return ToolBasic_UpdatedAt_DEFAULT + } + return *p.UpdatedAt +} +func (p *ToolBasic) SetName(val *string) { + p.Name = val +} +func (p *ToolBasic) SetDescription(val *string) { + p.Description = val +} +func (p *ToolBasic) SetLatestCommittedVersion(val *string) { + p.LatestCommittedVersion = val +} +func (p *ToolBasic) SetCreatedBy(val *string) { + p.CreatedBy = val +} +func (p *ToolBasic) SetUpdatedBy(val *string) { + p.UpdatedBy = val +} +func (p *ToolBasic) SetCreatedAt(val *int64) { + p.CreatedAt = val +} +func (p *ToolBasic) SetUpdatedAt(val *int64) { + p.UpdatedAt = val +} + +var fieldIDToName_ToolBasic = map[int16]string{ + 1: "name", + 2: "description", + 3: "latest_committed_version", + 4: "created_by", + 5: "updated_by", + 6: "created_at", + 7: "updated_at", +} + +func (p *ToolBasic) IsSetName() bool { + return p.Name != nil +} + +func (p *ToolBasic) IsSetDescription() bool { + return p.Description != nil +} + +func (p *ToolBasic) IsSetLatestCommittedVersion() bool { + return p.LatestCommittedVersion != nil +} + +func (p *ToolBasic) IsSetCreatedBy() bool { + return p.CreatedBy != nil +} + +func (p *ToolBasic) IsSetUpdatedBy() bool { + return p.UpdatedBy != nil +} + +func (p *ToolBasic) IsSetCreatedAt() bool { + return p.CreatedAt != nil +} + +func (p *ToolBasic) IsSetUpdatedAt() bool { + return p.UpdatedAt != nil +} + +func (p *ToolBasic) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.STRING { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 2: + if fieldTypeId == thrift.STRING { + if err = p.ReadField2(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 3: + if fieldTypeId == thrift.STRING { + if err = p.ReadField3(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 4: + if fieldTypeId == thrift.STRING { + if err = p.ReadField4(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 5: + if fieldTypeId == thrift.STRING { + if err = p.ReadField5(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 6: + if fieldTypeId == thrift.I64 { + if err = p.ReadField6(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 7: + if fieldTypeId == thrift.I64 { + if err = p.ReadField7(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolBasic[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *ToolBasic) ReadField1(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.Name = _field + return nil +} +func (p *ToolBasic) ReadField2(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.Description = _field + return nil +} +func (p *ToolBasic) ReadField3(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.LatestCommittedVersion = _field + return nil +} +func (p *ToolBasic) ReadField4(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.CreatedBy = _field + return nil +} +func (p *ToolBasic) ReadField5(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.UpdatedBy = _field + return nil +} +func (p *ToolBasic) ReadField6(iprot thrift.TProtocol) error { + + var _field *int64 + if v, err := iprot.ReadI64(); err != nil { + return err + } else { + _field = &v + } + p.CreatedAt = _field + return nil +} +func (p *ToolBasic) ReadField7(iprot thrift.TProtocol) error { + + var _field *int64 + if v, err := iprot.ReadI64(); err != nil { + return err + } else { + _field = &v + } + p.UpdatedAt = _field + return nil +} + +func (p *ToolBasic) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("ToolBasic"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + if err = p.writeField2(oprot); err != nil { + fieldId = 2 + goto WriteFieldError + } + if err = p.writeField3(oprot); err != nil { + fieldId = 3 + goto WriteFieldError + } + if err = p.writeField4(oprot); err != nil { + fieldId = 4 + goto WriteFieldError + } + if err = p.writeField5(oprot); err != nil { + fieldId = 5 + goto WriteFieldError + } + if err = p.writeField6(oprot); err != nil { + fieldId = 6 + goto WriteFieldError + } + if err = p.writeField7(oprot); err != nil { + fieldId = 7 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *ToolBasic) writeField1(oprot thrift.TProtocol) (err error) { + if p.IsSetName() { + if err = oprot.WriteFieldBegin("name", thrift.STRING, 1); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.Name); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} +func (p *ToolBasic) writeField2(oprot thrift.TProtocol) (err error) { + if p.IsSetDescription() { + if err = oprot.WriteFieldBegin("description", thrift.STRING, 2); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.Description); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err) +} +func (p *ToolBasic) writeField3(oprot thrift.TProtocol) (err error) { + if p.IsSetLatestCommittedVersion() { + if err = oprot.WriteFieldBegin("latest_committed_version", thrift.STRING, 3); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.LatestCommittedVersion); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 3 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 3 end error: ", p), err) +} +func (p *ToolBasic) writeField4(oprot thrift.TProtocol) (err error) { + if p.IsSetCreatedBy() { + if err = oprot.WriteFieldBegin("created_by", thrift.STRING, 4); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.CreatedBy); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 4 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 4 end error: ", p), err) +} +func (p *ToolBasic) writeField5(oprot thrift.TProtocol) (err error) { + if p.IsSetUpdatedBy() { + if err = oprot.WriteFieldBegin("updated_by", thrift.STRING, 5); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.UpdatedBy); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 5 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 5 end error: ", p), err) +} +func (p *ToolBasic) writeField6(oprot thrift.TProtocol) (err error) { + if p.IsSetCreatedAt() { + if err = oprot.WriteFieldBegin("created_at", thrift.I64, 6); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI64(*p.CreatedAt); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 6 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 6 end error: ", p), err) +} +func (p *ToolBasic) writeField7(oprot thrift.TProtocol) (err error) { + if p.IsSetUpdatedAt() { + if err = oprot.WriteFieldBegin("updated_at", thrift.I64, 7); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI64(*p.UpdatedAt); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 7 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 7 end error: ", p), err) +} + +func (p *ToolBasic) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("ToolBasic(%+v)", *p) + +} + +func (p *ToolBasic) DeepEqual(ano *ToolBasic) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.Name) { + return false + } + if !p.Field2DeepEqual(ano.Description) { + return false + } + if !p.Field3DeepEqual(ano.LatestCommittedVersion) { + return false + } + if !p.Field4DeepEqual(ano.CreatedBy) { + return false + } + if !p.Field5DeepEqual(ano.UpdatedBy) { + return false + } + if !p.Field6DeepEqual(ano.CreatedAt) { + return false + } + if !p.Field7DeepEqual(ano.UpdatedAt) { + return false + } + return true +} + +func (p *ToolBasic) Field1DeepEqual(src *string) bool { + + if p.Name == src { + return true + } else if p.Name == nil || src == nil { + return false + } + if strings.Compare(*p.Name, *src) != 0 { + return false + } + return true +} +func (p *ToolBasic) Field2DeepEqual(src *string) bool { + + if p.Description == src { + return true + } else if p.Description == nil || src == nil { + return false + } + if strings.Compare(*p.Description, *src) != 0 { + return false + } + return true +} +func (p *ToolBasic) Field3DeepEqual(src *string) bool { + + if p.LatestCommittedVersion == src { + return true + } else if p.LatestCommittedVersion == nil || src == nil { + return false + } + if strings.Compare(*p.LatestCommittedVersion, *src) != 0 { + return false + } + return true +} +func (p *ToolBasic) Field4DeepEqual(src *string) bool { + + if p.CreatedBy == src { + return true + } else if p.CreatedBy == nil || src == nil { + return false + } + if strings.Compare(*p.CreatedBy, *src) != 0 { + return false + } + return true +} +func (p *ToolBasic) Field5DeepEqual(src *string) bool { + + if p.UpdatedBy == src { + return true + } else if p.UpdatedBy == nil || src == nil { + return false + } + if strings.Compare(*p.UpdatedBy, *src) != 0 { + return false + } + return true +} +func (p *ToolBasic) Field6DeepEqual(src *int64) bool { + + if p.CreatedAt == src { + return true + } else if p.CreatedAt == nil || src == nil { + return false + } + if *p.CreatedAt != *src { + return false + } + return true +} +func (p *ToolBasic) Field7DeepEqual(src *int64) bool { + + if p.UpdatedAt == src { + return true + } else if p.UpdatedAt == nil || src == nil { + return false + } + if *p.UpdatedAt != *src { + return false + } + return true +} + +type ToolCommit struct { + Detail *ToolDetail `thrift:"detail,1,optional" frugal:"1,optional,ToolDetail" form:"detail" json:"detail,omitempty" query:"detail"` + CommitInfo *CommitInfo `thrift:"commit_info,2,optional" frugal:"2,optional,CommitInfo" form:"commit_info" json:"commit_info,omitempty" query:"commit_info"` +} + +func NewToolCommit() *ToolCommit { + return &ToolCommit{} +} + +func (p *ToolCommit) InitDefault() { +} + +var ToolCommit_Detail_DEFAULT *ToolDetail + +func (p *ToolCommit) GetDetail() (v *ToolDetail) { + if p == nil { + return + } + if !p.IsSetDetail() { + return ToolCommit_Detail_DEFAULT + } + return p.Detail +} + +var ToolCommit_CommitInfo_DEFAULT *CommitInfo + +func (p *ToolCommit) GetCommitInfo() (v *CommitInfo) { + if p == nil { + return + } + if !p.IsSetCommitInfo() { + return ToolCommit_CommitInfo_DEFAULT + } + return p.CommitInfo +} +func (p *ToolCommit) SetDetail(val *ToolDetail) { + p.Detail = val +} +func (p *ToolCommit) SetCommitInfo(val *CommitInfo) { + p.CommitInfo = val +} + +var fieldIDToName_ToolCommit = map[int16]string{ + 1: "detail", + 2: "commit_info", +} + +func (p *ToolCommit) IsSetDetail() bool { + return p.Detail != nil +} + +func (p *ToolCommit) IsSetCommitInfo() bool { + return p.CommitInfo != nil +} + +func (p *ToolCommit) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 2: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField2(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolCommit[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *ToolCommit) ReadField1(iprot thrift.TProtocol) error { + _field := NewToolDetail() + if err := _field.Read(iprot); err != nil { + return err + } + p.Detail = _field + return nil +} +func (p *ToolCommit) ReadField2(iprot thrift.TProtocol) error { + _field := NewCommitInfo() + if err := _field.Read(iprot); err != nil { + return err + } + p.CommitInfo = _field + return nil +} + +func (p *ToolCommit) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("ToolCommit"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + if err = p.writeField2(oprot); err != nil { + fieldId = 2 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *ToolCommit) writeField1(oprot thrift.TProtocol) (err error) { + if p.IsSetDetail() { + if err = oprot.WriteFieldBegin("detail", thrift.STRUCT, 1); err != nil { + goto WriteFieldBeginError + } + if err := p.Detail.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} +func (p *ToolCommit) writeField2(oprot thrift.TProtocol) (err error) { + if p.IsSetCommitInfo() { + if err = oprot.WriteFieldBegin("commit_info", thrift.STRUCT, 2); err != nil { + goto WriteFieldBeginError + } + if err := p.CommitInfo.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err) +} + +func (p *ToolCommit) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("ToolCommit(%+v)", *p) + +} + +func (p *ToolCommit) DeepEqual(ano *ToolCommit) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.Detail) { + return false + } + if !p.Field2DeepEqual(ano.CommitInfo) { + return false + } + return true +} + +func (p *ToolCommit) Field1DeepEqual(src *ToolDetail) bool { + + if !p.Detail.DeepEqual(src) { + return false + } + return true +} +func (p *ToolCommit) Field2DeepEqual(src *CommitInfo) bool { + + if !p.CommitInfo.DeepEqual(src) { + return false + } + return true +} + +type CommitInfo struct { + Version *string `thrift:"version,1,optional" frugal:"1,optional,string" form:"version" json:"version,omitempty" query:"version"` + BaseVersion *string `thrift:"base_version,2,optional" frugal:"2,optional,string" form:"base_version" json:"base_version,omitempty" query:"base_version"` + Description *string `thrift:"description,3,optional" frugal:"3,optional,string" form:"description" json:"description,omitempty" query:"description"` + CommittedBy *string `thrift:"committed_by,4,optional" frugal:"4,optional,string" form:"committed_by" json:"committed_by,omitempty" query:"committed_by"` + CommittedAt *int64 `thrift:"committed_at,5,optional" frugal:"5,optional,i64" json:"committed_at" form:"committed_at" query:"committed_at"` +} + +func NewCommitInfo() *CommitInfo { + return &CommitInfo{} +} + +func (p *CommitInfo) InitDefault() { +} + +var CommitInfo_Version_DEFAULT string + +func (p *CommitInfo) GetVersion() (v string) { + if p == nil { + return + } + if !p.IsSetVersion() { + return CommitInfo_Version_DEFAULT + } + return *p.Version +} + +var CommitInfo_BaseVersion_DEFAULT string + +func (p *CommitInfo) GetBaseVersion() (v string) { + if p == nil { + return + } + if !p.IsSetBaseVersion() { + return CommitInfo_BaseVersion_DEFAULT + } + return *p.BaseVersion +} + +var CommitInfo_Description_DEFAULT string + +func (p *CommitInfo) GetDescription() (v string) { + if p == nil { + return + } + if !p.IsSetDescription() { + return CommitInfo_Description_DEFAULT + } + return *p.Description +} + +var CommitInfo_CommittedBy_DEFAULT string + +func (p *CommitInfo) GetCommittedBy() (v string) { + if p == nil { + return + } + if !p.IsSetCommittedBy() { + return CommitInfo_CommittedBy_DEFAULT + } + return *p.CommittedBy +} + +var CommitInfo_CommittedAt_DEFAULT int64 + +func (p *CommitInfo) GetCommittedAt() (v int64) { + if p == nil { + return + } + if !p.IsSetCommittedAt() { + return CommitInfo_CommittedAt_DEFAULT + } + return *p.CommittedAt +} +func (p *CommitInfo) SetVersion(val *string) { + p.Version = val +} +func (p *CommitInfo) SetBaseVersion(val *string) { + p.BaseVersion = val +} +func (p *CommitInfo) SetDescription(val *string) { + p.Description = val +} +func (p *CommitInfo) SetCommittedBy(val *string) { + p.CommittedBy = val +} +func (p *CommitInfo) SetCommittedAt(val *int64) { + p.CommittedAt = val +} + +var fieldIDToName_CommitInfo = map[int16]string{ + 1: "version", + 2: "base_version", + 3: "description", + 4: "committed_by", + 5: "committed_at", +} + +func (p *CommitInfo) IsSetVersion() bool { + return p.Version != nil +} + +func (p *CommitInfo) IsSetBaseVersion() bool { + return p.BaseVersion != nil +} + +func (p *CommitInfo) IsSetDescription() bool { + return p.Description != nil +} + +func (p *CommitInfo) IsSetCommittedBy() bool { + return p.CommittedBy != nil +} + +func (p *CommitInfo) IsSetCommittedAt() bool { + return p.CommittedAt != nil +} + +func (p *CommitInfo) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.STRING { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 2: + if fieldTypeId == thrift.STRING { + if err = p.ReadField2(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 3: + if fieldTypeId == thrift.STRING { + if err = p.ReadField3(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 4: + if fieldTypeId == thrift.STRING { + if err = p.ReadField4(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 5: + if fieldTypeId == thrift.I64 { + if err = p.ReadField5(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_CommitInfo[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *CommitInfo) ReadField1(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.Version = _field + return nil +} +func (p *CommitInfo) ReadField2(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.BaseVersion = _field + return nil +} +func (p *CommitInfo) ReadField3(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.Description = _field + return nil +} +func (p *CommitInfo) ReadField4(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.CommittedBy = _field + return nil +} +func (p *CommitInfo) ReadField5(iprot thrift.TProtocol) error { + + var _field *int64 + if v, err := iprot.ReadI64(); err != nil { + return err + } else { + _field = &v + } + p.CommittedAt = _field + return nil +} + +func (p *CommitInfo) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("CommitInfo"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + if err = p.writeField2(oprot); err != nil { + fieldId = 2 + goto WriteFieldError + } + if err = p.writeField3(oprot); err != nil { + fieldId = 3 + goto WriteFieldError + } + if err = p.writeField4(oprot); err != nil { + fieldId = 4 + goto WriteFieldError + } + if err = p.writeField5(oprot); err != nil { + fieldId = 5 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *CommitInfo) writeField1(oprot thrift.TProtocol) (err error) { + if p.IsSetVersion() { + if err = oprot.WriteFieldBegin("version", thrift.STRING, 1); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.Version); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} +func (p *CommitInfo) writeField2(oprot thrift.TProtocol) (err error) { + if p.IsSetBaseVersion() { + if err = oprot.WriteFieldBegin("base_version", thrift.STRING, 2); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.BaseVersion); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err) +} +func (p *CommitInfo) writeField3(oprot thrift.TProtocol) (err error) { + if p.IsSetDescription() { + if err = oprot.WriteFieldBegin("description", thrift.STRING, 3); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.Description); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 3 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 3 end error: ", p), err) +} +func (p *CommitInfo) writeField4(oprot thrift.TProtocol) (err error) { + if p.IsSetCommittedBy() { + if err = oprot.WriteFieldBegin("committed_by", thrift.STRING, 4); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.CommittedBy); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 4 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 4 end error: ", p), err) +} +func (p *CommitInfo) writeField5(oprot thrift.TProtocol) (err error) { + if p.IsSetCommittedAt() { + if err = oprot.WriteFieldBegin("committed_at", thrift.I64, 5); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI64(*p.CommittedAt); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 5 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 5 end error: ", p), err) +} + +func (p *CommitInfo) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("CommitInfo(%+v)", *p) + +} + +func (p *CommitInfo) DeepEqual(ano *CommitInfo) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.Version) { + return false + } + if !p.Field2DeepEqual(ano.BaseVersion) { + return false + } + if !p.Field3DeepEqual(ano.Description) { + return false + } + if !p.Field4DeepEqual(ano.CommittedBy) { + return false + } + if !p.Field5DeepEqual(ano.CommittedAt) { + return false + } + return true +} + +func (p *CommitInfo) Field1DeepEqual(src *string) bool { + + if p.Version == src { + return true + } else if p.Version == nil || src == nil { + return false + } + if strings.Compare(*p.Version, *src) != 0 { + return false + } + return true +} +func (p *CommitInfo) Field2DeepEqual(src *string) bool { + + if p.BaseVersion == src { + return true + } else if p.BaseVersion == nil || src == nil { + return false + } + if strings.Compare(*p.BaseVersion, *src) != 0 { + return false + } + return true +} +func (p *CommitInfo) Field3DeepEqual(src *string) bool { + + if p.Description == src { + return true + } else if p.Description == nil || src == nil { + return false + } + if strings.Compare(*p.Description, *src) != 0 { + return false + } + return true +} +func (p *CommitInfo) Field4DeepEqual(src *string) bool { + + if p.CommittedBy == src { + return true + } else if p.CommittedBy == nil || src == nil { + return false + } + if strings.Compare(*p.CommittedBy, *src) != 0 { + return false + } + return true +} +func (p *CommitInfo) Field5DeepEqual(src *int64) bool { + + if p.CommittedAt == src { + return true + } else if p.CommittedAt == nil || src == nil { + return false + } + if *p.CommittedAt != *src { + return false + } + return true +} + +type ToolDetail struct { + Content *string `thrift:"content,1,optional" frugal:"1,optional,string" form:"content" json:"content,omitempty" query:"content"` + ExtInfos map[string]string `thrift:"ext_infos,255,optional" frugal:"255,optional,map" form:"ext_infos" json:"ext_infos,omitempty" query:"ext_infos"` +} + +func NewToolDetail() *ToolDetail { + return &ToolDetail{} +} + +func (p *ToolDetail) InitDefault() { +} + +var ToolDetail_Content_DEFAULT string + +func (p *ToolDetail) GetContent() (v string) { + if p == nil { + return + } + if !p.IsSetContent() { + return ToolDetail_Content_DEFAULT + } + return *p.Content +} + +var ToolDetail_ExtInfos_DEFAULT map[string]string + +func (p *ToolDetail) GetExtInfos() (v map[string]string) { + if p == nil { + return + } + if !p.IsSetExtInfos() { + return ToolDetail_ExtInfos_DEFAULT + } + return p.ExtInfos +} +func (p *ToolDetail) SetContent(val *string) { + p.Content = val +} +func (p *ToolDetail) SetExtInfos(val map[string]string) { + p.ExtInfos = val +} + +var fieldIDToName_ToolDetail = map[int16]string{ + 1: "content", + 255: "ext_infos", +} + +func (p *ToolDetail) IsSetContent() bool { + return p.Content != nil +} + +func (p *ToolDetail) IsSetExtInfos() bool { + return p.ExtInfos != nil +} + +func (p *ToolDetail) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.STRING { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 255: + if fieldTypeId == thrift.MAP { + if err = p.ReadField255(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolDetail[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *ToolDetail) ReadField1(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.Content = _field + return nil +} +func (p *ToolDetail) ReadField255(iprot thrift.TProtocol) error { + _, _, size, err := iprot.ReadMapBegin() + if err != nil { + return err + } + _field := make(map[string]string, size) + for i := 0; i < size; i++ { + var _key string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _key = v + } + + var _val string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _val = v + } + + _field[_key] = _val + } + if err := iprot.ReadMapEnd(); err != nil { + return err + } + p.ExtInfos = _field + return nil +} + +func (p *ToolDetail) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("ToolDetail"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + if err = p.writeField255(oprot); err != nil { + fieldId = 255 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *ToolDetail) writeField1(oprot thrift.TProtocol) (err error) { + if p.IsSetContent() { + if err = oprot.WriteFieldBegin("content", thrift.STRING, 1); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.Content); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} +func (p *ToolDetail) writeField255(oprot thrift.TProtocol) (err error) { + if p.IsSetExtInfos() { + if err = oprot.WriteFieldBegin("ext_infos", thrift.MAP, 255); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteMapBegin(thrift.STRING, thrift.STRING, len(p.ExtInfos)); err != nil { + return err + } + for k, v := range p.ExtInfos { + if err := oprot.WriteString(k); err != nil { + return err + } + if err := oprot.WriteString(v); err != nil { + return err + } + } + if err := oprot.WriteMapEnd(); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 end error: ", p), err) +} + +func (p *ToolDetail) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("ToolDetail(%+v)", *p) + +} + +func (p *ToolDetail) DeepEqual(ano *ToolDetail) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.Content) { + return false + } + if !p.Field255DeepEqual(ano.ExtInfos) { + return false + } + return true +} + +func (p *ToolDetail) Field1DeepEqual(src *string) bool { + + if p.Content == src { + return true + } else if p.Content == nil || src == nil { + return false + } + if strings.Compare(*p.Content, *src) != 0 { + return false + } + return true +} +func (p *ToolDetail) Field255DeepEqual(src map[string]string) bool { + + if len(p.ExtInfos) != len(src) { + return false + } + for k, v := range p.ExtInfos { + _src := src[k] + if strings.Compare(v, _src) != 0 { + return false + } + } + return true +} diff --git a/backend/kitex_gen/coze/loop/prompt/domain/tool/tool_validator.go b/backend/kitex_gen/coze/loop/prompt/domain/tool/tool_validator.go new file mode 100644 index 000000000..c5cea2f76 --- /dev/null +++ b/backend/kitex_gen/coze/loop/prompt/domain/tool/tool_validator.go @@ -0,0 +1,58 @@ +// Code generated by Validator v0.2.6. DO NOT EDIT. + +package tool + +import ( + "bytes" + "fmt" + "reflect" + "regexp" + "strings" + "time" +) + +// unused protection +var ( + _ = fmt.Formatter(nil) + _ = (*bytes.Buffer)(nil) + _ = (*strings.Builder)(nil) + _ = reflect.Type(nil) + _ = (*regexp.Regexp)(nil) + _ = time.Nanosecond +) + +func (p *Tool) IsValid() error { + if p.ToolBasic != nil { + if err := p.ToolBasic.IsValid(); err != nil { + return fmt.Errorf("field ToolBasic not valid, %w", err) + } + } + if p.ToolCommit != nil { + if err := p.ToolCommit.IsValid(); err != nil { + return fmt.Errorf("field ToolCommit not valid, %w", err) + } + } + return nil +} +func (p *ToolBasic) IsValid() error { + return nil +} +func (p *ToolCommit) IsValid() error { + if p.Detail != nil { + if err := p.Detail.IsValid(); err != nil { + return fmt.Errorf("field Detail not valid, %w", err) + } + } + if p.CommitInfo != nil { + if err := p.CommitInfo.IsValid(); err != nil { + return fmt.Errorf("field CommitInfo not valid, %w", err) + } + } + return nil +} +func (p *CommitInfo) IsValid() error { + return nil +} +func (p *ToolDetail) IsValid() error { + return nil +} diff --git a/backend/kitex_gen/coze/loop/prompt/k-coze.loop.prompt.go b/backend/kitex_gen/coze/loop/prompt/k-coze.loop.prompt.go index 48cda3063..23bee6fdb 100644 --- a/backend/kitex_gen/coze/loop/prompt/k-coze.loop.prompt.go +++ b/backend/kitex_gen/coze/loop/prompt/k-coze.loop.prompt.go @@ -14,6 +14,7 @@ import ( "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/execute" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/manage" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/openapi" + manage0 "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" ) var ( @@ -21,6 +22,7 @@ var ( _ = execute.KitexUnusedProtection _ = manage.KitexUnusedProtection _ = openapi.KitexUnusedProtection + _ = manage0.KitexUnusedProtection ) // unused protection diff --git a/backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool.manage.go b/backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool.manage.go new file mode 100644 index 000000000..89cd7ff38 --- /dev/null +++ b/backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool.manage.go @@ -0,0 +1,7935 @@ +// Code generated by thriftgo (0.4.1). DO NOT EDIT. + +package manage + +import ( + "context" + "fmt" + "github.com/apache/thrift/lib/go/thrift" + "github.com/coze-dev/coze-loop/backend/kitex_gen/base" + "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/domain/tool" + "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/domain/user" + "strings" +) + +const ( + ListToolOrderByCommittedAt = "committed_at" + + ListToolOrderByCreatedAt = "created_at" +) + +type ListToolOrderBy = string + +type CreateToolRequest struct { + WorkspaceID *int64 `thrift:"workspace_id,1,optional" frugal:"1,optional,i64" json:"workspace_id" form:"workspace_id" query:"workspace_id"` + ToolName *string `thrift:"tool_name,11,optional" frugal:"11,optional,string" form:"tool_name" json:"tool_name,omitempty" query:"tool_name"` + ToolDescription *string `thrift:"tool_description,12,optional" frugal:"12,optional,string" form:"tool_description" json:"tool_description,omitempty" query:"tool_description"` + DraftDetail *tool.ToolDetail `thrift:"draft_detail,21,optional" frugal:"21,optional,tool.ToolDetail" form:"draft_detail" json:"draft_detail,omitempty" query:"draft_detail"` + Base *base.Base `thrift:"Base,255,optional" frugal:"255,optional,base.Base" form:"Base" json:"Base,omitempty" query:"Base"` +} + +func NewCreateToolRequest() *CreateToolRequest { + return &CreateToolRequest{} +} + +func (p *CreateToolRequest) InitDefault() { +} + +var CreateToolRequest_WorkspaceID_DEFAULT int64 + +func (p *CreateToolRequest) GetWorkspaceID() (v int64) { + if p == nil { + return + } + if !p.IsSetWorkspaceID() { + return CreateToolRequest_WorkspaceID_DEFAULT + } + return *p.WorkspaceID +} + +var CreateToolRequest_ToolName_DEFAULT string + +func (p *CreateToolRequest) GetToolName() (v string) { + if p == nil { + return + } + if !p.IsSetToolName() { + return CreateToolRequest_ToolName_DEFAULT + } + return *p.ToolName +} + +var CreateToolRequest_ToolDescription_DEFAULT string + +func (p *CreateToolRequest) GetToolDescription() (v string) { + if p == nil { + return + } + if !p.IsSetToolDescription() { + return CreateToolRequest_ToolDescription_DEFAULT + } + return *p.ToolDescription +} + +var CreateToolRequest_DraftDetail_DEFAULT *tool.ToolDetail + +func (p *CreateToolRequest) GetDraftDetail() (v *tool.ToolDetail) { + if p == nil { + return + } + if !p.IsSetDraftDetail() { + return CreateToolRequest_DraftDetail_DEFAULT + } + return p.DraftDetail +} + +var CreateToolRequest_Base_DEFAULT *base.Base + +func (p *CreateToolRequest) GetBase() (v *base.Base) { + if p == nil { + return + } + if !p.IsSetBase() { + return CreateToolRequest_Base_DEFAULT + } + return p.Base +} +func (p *CreateToolRequest) SetWorkspaceID(val *int64) { + p.WorkspaceID = val +} +func (p *CreateToolRequest) SetToolName(val *string) { + p.ToolName = val +} +func (p *CreateToolRequest) SetToolDescription(val *string) { + p.ToolDescription = val +} +func (p *CreateToolRequest) SetDraftDetail(val *tool.ToolDetail) { + p.DraftDetail = val +} +func (p *CreateToolRequest) SetBase(val *base.Base) { + p.Base = val +} + +var fieldIDToName_CreateToolRequest = map[int16]string{ + 1: "workspace_id", + 11: "tool_name", + 12: "tool_description", + 21: "draft_detail", + 255: "Base", +} + +func (p *CreateToolRequest) IsSetWorkspaceID() bool { + return p.WorkspaceID != nil +} + +func (p *CreateToolRequest) IsSetToolName() bool { + return p.ToolName != nil +} + +func (p *CreateToolRequest) IsSetToolDescription() bool { + return p.ToolDescription != nil +} + +func (p *CreateToolRequest) IsSetDraftDetail() bool { + return p.DraftDetail != nil +} + +func (p *CreateToolRequest) IsSetBase() bool { + return p.Base != nil +} + +func (p *CreateToolRequest) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.I64 { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 11: + if fieldTypeId == thrift.STRING { + if err = p.ReadField11(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 12: + if fieldTypeId == thrift.STRING { + if err = p.ReadField12(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 21: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField21(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 255: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField255(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_CreateToolRequest[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *CreateToolRequest) ReadField1(iprot thrift.TProtocol) error { + + var _field *int64 + if v, err := iprot.ReadI64(); err != nil { + return err + } else { + _field = &v + } + p.WorkspaceID = _field + return nil +} +func (p *CreateToolRequest) ReadField11(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.ToolName = _field + return nil +} +func (p *CreateToolRequest) ReadField12(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.ToolDescription = _field + return nil +} +func (p *CreateToolRequest) ReadField21(iprot thrift.TProtocol) error { + _field := tool.NewToolDetail() + if err := _field.Read(iprot); err != nil { + return err + } + p.DraftDetail = _field + return nil +} +func (p *CreateToolRequest) ReadField255(iprot thrift.TProtocol) error { + _field := base.NewBase() + if err := _field.Read(iprot); err != nil { + return err + } + p.Base = _field + return nil +} + +func (p *CreateToolRequest) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("CreateToolRequest"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + if err = p.writeField11(oprot); err != nil { + fieldId = 11 + goto WriteFieldError + } + if err = p.writeField12(oprot); err != nil { + fieldId = 12 + goto WriteFieldError + } + if err = p.writeField21(oprot); err != nil { + fieldId = 21 + goto WriteFieldError + } + if err = p.writeField255(oprot); err != nil { + fieldId = 255 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *CreateToolRequest) writeField1(oprot thrift.TProtocol) (err error) { + if p.IsSetWorkspaceID() { + if err = oprot.WriteFieldBegin("workspace_id", thrift.I64, 1); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI64(*p.WorkspaceID); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} +func (p *CreateToolRequest) writeField11(oprot thrift.TProtocol) (err error) { + if p.IsSetToolName() { + if err = oprot.WriteFieldBegin("tool_name", thrift.STRING, 11); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.ToolName); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 11 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 11 end error: ", p), err) +} +func (p *CreateToolRequest) writeField12(oprot thrift.TProtocol) (err error) { + if p.IsSetToolDescription() { + if err = oprot.WriteFieldBegin("tool_description", thrift.STRING, 12); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.ToolDescription); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 12 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 12 end error: ", p), err) +} +func (p *CreateToolRequest) writeField21(oprot thrift.TProtocol) (err error) { + if p.IsSetDraftDetail() { + if err = oprot.WriteFieldBegin("draft_detail", thrift.STRUCT, 21); err != nil { + goto WriteFieldBeginError + } + if err := p.DraftDetail.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 21 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 21 end error: ", p), err) +} +func (p *CreateToolRequest) writeField255(oprot thrift.TProtocol) (err error) { + if p.IsSetBase() { + if err = oprot.WriteFieldBegin("Base", thrift.STRUCT, 255); err != nil { + goto WriteFieldBeginError + } + if err := p.Base.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 end error: ", p), err) +} + +func (p *CreateToolRequest) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("CreateToolRequest(%+v)", *p) + +} + +func (p *CreateToolRequest) DeepEqual(ano *CreateToolRequest) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.WorkspaceID) { + return false + } + if !p.Field11DeepEqual(ano.ToolName) { + return false + } + if !p.Field12DeepEqual(ano.ToolDescription) { + return false + } + if !p.Field21DeepEqual(ano.DraftDetail) { + return false + } + if !p.Field255DeepEqual(ano.Base) { + return false + } + return true +} + +func (p *CreateToolRequest) Field1DeepEqual(src *int64) bool { + + if p.WorkspaceID == src { + return true + } else if p.WorkspaceID == nil || src == nil { + return false + } + if *p.WorkspaceID != *src { + return false + } + return true +} +func (p *CreateToolRequest) Field11DeepEqual(src *string) bool { + + if p.ToolName == src { + return true + } else if p.ToolName == nil || src == nil { + return false + } + if strings.Compare(*p.ToolName, *src) != 0 { + return false + } + return true +} +func (p *CreateToolRequest) Field12DeepEqual(src *string) bool { + + if p.ToolDescription == src { + return true + } else if p.ToolDescription == nil || src == nil { + return false + } + if strings.Compare(*p.ToolDescription, *src) != 0 { + return false + } + return true +} +func (p *CreateToolRequest) Field21DeepEqual(src *tool.ToolDetail) bool { + + if !p.DraftDetail.DeepEqual(src) { + return false + } + return true +} +func (p *CreateToolRequest) Field255DeepEqual(src *base.Base) bool { + + if !p.Base.DeepEqual(src) { + return false + } + return true +} + +type CreateToolResponse struct { + ToolID *int64 `thrift:"tool_id,1,optional" frugal:"1,optional,i64" json:"tool_id" form:"tool_id" query:"tool_id"` + BaseResp *base.BaseResp `thrift:"BaseResp,255,optional" frugal:"255,optional,base.BaseResp" form:"BaseResp" json:"BaseResp,omitempty" query:"BaseResp"` +} + +func NewCreateToolResponse() *CreateToolResponse { + return &CreateToolResponse{} +} + +func (p *CreateToolResponse) InitDefault() { +} + +var CreateToolResponse_ToolID_DEFAULT int64 + +func (p *CreateToolResponse) GetToolID() (v int64) { + if p == nil { + return + } + if !p.IsSetToolID() { + return CreateToolResponse_ToolID_DEFAULT + } + return *p.ToolID +} + +var CreateToolResponse_BaseResp_DEFAULT *base.BaseResp + +func (p *CreateToolResponse) GetBaseResp() (v *base.BaseResp) { + if p == nil { + return + } + if !p.IsSetBaseResp() { + return CreateToolResponse_BaseResp_DEFAULT + } + return p.BaseResp +} +func (p *CreateToolResponse) SetToolID(val *int64) { + p.ToolID = val +} +func (p *CreateToolResponse) SetBaseResp(val *base.BaseResp) { + p.BaseResp = val +} + +var fieldIDToName_CreateToolResponse = map[int16]string{ + 1: "tool_id", + 255: "BaseResp", +} + +func (p *CreateToolResponse) IsSetToolID() bool { + return p.ToolID != nil +} + +func (p *CreateToolResponse) IsSetBaseResp() bool { + return p.BaseResp != nil +} + +func (p *CreateToolResponse) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.I64 { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 255: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField255(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_CreateToolResponse[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *CreateToolResponse) ReadField1(iprot thrift.TProtocol) error { + + var _field *int64 + if v, err := iprot.ReadI64(); err != nil { + return err + } else { + _field = &v + } + p.ToolID = _field + return nil +} +func (p *CreateToolResponse) ReadField255(iprot thrift.TProtocol) error { + _field := base.NewBaseResp() + if err := _field.Read(iprot); err != nil { + return err + } + p.BaseResp = _field + return nil +} + +func (p *CreateToolResponse) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("CreateToolResponse"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + if err = p.writeField255(oprot); err != nil { + fieldId = 255 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *CreateToolResponse) writeField1(oprot thrift.TProtocol) (err error) { + if p.IsSetToolID() { + if err = oprot.WriteFieldBegin("tool_id", thrift.I64, 1); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI64(*p.ToolID); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} +func (p *CreateToolResponse) writeField255(oprot thrift.TProtocol) (err error) { + if p.IsSetBaseResp() { + if err = oprot.WriteFieldBegin("BaseResp", thrift.STRUCT, 255); err != nil { + goto WriteFieldBeginError + } + if err := p.BaseResp.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 end error: ", p), err) +} + +func (p *CreateToolResponse) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("CreateToolResponse(%+v)", *p) + +} + +func (p *CreateToolResponse) DeepEqual(ano *CreateToolResponse) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.ToolID) { + return false + } + if !p.Field255DeepEqual(ano.BaseResp) { + return false + } + return true +} + +func (p *CreateToolResponse) Field1DeepEqual(src *int64) bool { + + if p.ToolID == src { + return true + } else if p.ToolID == nil || src == nil { + return false + } + if *p.ToolID != *src { + return false + } + return true +} +func (p *CreateToolResponse) Field255DeepEqual(src *base.BaseResp) bool { + + if !p.BaseResp.DeepEqual(src) { + return false + } + return true +} + +type GetToolDetailRequest struct { + ToolID *int64 `thrift:"tool_id,1,optional" frugal:"1,optional,i64" json:"tool_id" path:"tool_id" ` + WorkspaceID *int64 `thrift:"workspace_id,2,optional" frugal:"2,optional,i64" json:"workspace_id" query:"workspace_id" ` + WithCommit *bool `thrift:"with_commit,11,optional" frugal:"11,optional,bool" json:"with_commit,omitempty" query:"with_commit"` + CommitVersion *string `thrift:"commit_version,12,optional" frugal:"12,optional,string" json:"commit_version,omitempty" query:"commit_version"` + WithDraft *bool `thrift:"with_draft,21,optional" frugal:"21,optional,bool" json:"with_draft,omitempty" query:"with_draft"` + Base *base.Base `thrift:"Base,255,optional" frugal:"255,optional,base.Base" form:"Base" json:"Base,omitempty" query:"Base"` +} + +func NewGetToolDetailRequest() *GetToolDetailRequest { + return &GetToolDetailRequest{} +} + +func (p *GetToolDetailRequest) InitDefault() { +} + +var GetToolDetailRequest_ToolID_DEFAULT int64 + +func (p *GetToolDetailRequest) GetToolID() (v int64) { + if p == nil { + return + } + if !p.IsSetToolID() { + return GetToolDetailRequest_ToolID_DEFAULT + } + return *p.ToolID +} + +var GetToolDetailRequest_WorkspaceID_DEFAULT int64 + +func (p *GetToolDetailRequest) GetWorkspaceID() (v int64) { + if p == nil { + return + } + if !p.IsSetWorkspaceID() { + return GetToolDetailRequest_WorkspaceID_DEFAULT + } + return *p.WorkspaceID +} + +var GetToolDetailRequest_WithCommit_DEFAULT bool + +func (p *GetToolDetailRequest) GetWithCommit() (v bool) { + if p == nil { + return + } + if !p.IsSetWithCommit() { + return GetToolDetailRequest_WithCommit_DEFAULT + } + return *p.WithCommit +} + +var GetToolDetailRequest_CommitVersion_DEFAULT string + +func (p *GetToolDetailRequest) GetCommitVersion() (v string) { + if p == nil { + return + } + if !p.IsSetCommitVersion() { + return GetToolDetailRequest_CommitVersion_DEFAULT + } + return *p.CommitVersion +} + +var GetToolDetailRequest_WithDraft_DEFAULT bool + +func (p *GetToolDetailRequest) GetWithDraft() (v bool) { + if p == nil { + return + } + if !p.IsSetWithDraft() { + return GetToolDetailRequest_WithDraft_DEFAULT + } + return *p.WithDraft +} + +var GetToolDetailRequest_Base_DEFAULT *base.Base + +func (p *GetToolDetailRequest) GetBase() (v *base.Base) { + if p == nil { + return + } + if !p.IsSetBase() { + return GetToolDetailRequest_Base_DEFAULT + } + return p.Base +} +func (p *GetToolDetailRequest) SetToolID(val *int64) { + p.ToolID = val +} +func (p *GetToolDetailRequest) SetWorkspaceID(val *int64) { + p.WorkspaceID = val +} +func (p *GetToolDetailRequest) SetWithCommit(val *bool) { + p.WithCommit = val +} +func (p *GetToolDetailRequest) SetCommitVersion(val *string) { + p.CommitVersion = val +} +func (p *GetToolDetailRequest) SetWithDraft(val *bool) { + p.WithDraft = val +} +func (p *GetToolDetailRequest) SetBase(val *base.Base) { + p.Base = val +} + +var fieldIDToName_GetToolDetailRequest = map[int16]string{ + 1: "tool_id", + 2: "workspace_id", + 11: "with_commit", + 12: "commit_version", + 21: "with_draft", + 255: "Base", +} + +func (p *GetToolDetailRequest) IsSetToolID() bool { + return p.ToolID != nil +} + +func (p *GetToolDetailRequest) IsSetWorkspaceID() bool { + return p.WorkspaceID != nil +} + +func (p *GetToolDetailRequest) IsSetWithCommit() bool { + return p.WithCommit != nil +} + +func (p *GetToolDetailRequest) IsSetCommitVersion() bool { + return p.CommitVersion != nil +} + +func (p *GetToolDetailRequest) IsSetWithDraft() bool { + return p.WithDraft != nil +} + +func (p *GetToolDetailRequest) IsSetBase() bool { + return p.Base != nil +} + +func (p *GetToolDetailRequest) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.I64 { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 2: + if fieldTypeId == thrift.I64 { + if err = p.ReadField2(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 11: + if fieldTypeId == thrift.BOOL { + if err = p.ReadField11(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 12: + if fieldTypeId == thrift.STRING { + if err = p.ReadField12(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 21: + if fieldTypeId == thrift.BOOL { + if err = p.ReadField21(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 255: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField255(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_GetToolDetailRequest[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *GetToolDetailRequest) ReadField1(iprot thrift.TProtocol) error { + + var _field *int64 + if v, err := iprot.ReadI64(); err != nil { + return err + } else { + _field = &v + } + p.ToolID = _field + return nil +} +func (p *GetToolDetailRequest) ReadField2(iprot thrift.TProtocol) error { + + var _field *int64 + if v, err := iprot.ReadI64(); err != nil { + return err + } else { + _field = &v + } + p.WorkspaceID = _field + return nil +} +func (p *GetToolDetailRequest) ReadField11(iprot thrift.TProtocol) error { + + var _field *bool + if v, err := iprot.ReadBool(); err != nil { + return err + } else { + _field = &v + } + p.WithCommit = _field + return nil +} +func (p *GetToolDetailRequest) ReadField12(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.CommitVersion = _field + return nil +} +func (p *GetToolDetailRequest) ReadField21(iprot thrift.TProtocol) error { + + var _field *bool + if v, err := iprot.ReadBool(); err != nil { + return err + } else { + _field = &v + } + p.WithDraft = _field + return nil +} +func (p *GetToolDetailRequest) ReadField255(iprot thrift.TProtocol) error { + _field := base.NewBase() + if err := _field.Read(iprot); err != nil { + return err + } + p.Base = _field + return nil +} + +func (p *GetToolDetailRequest) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("GetToolDetailRequest"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + if err = p.writeField2(oprot); err != nil { + fieldId = 2 + goto WriteFieldError + } + if err = p.writeField11(oprot); err != nil { + fieldId = 11 + goto WriteFieldError + } + if err = p.writeField12(oprot); err != nil { + fieldId = 12 + goto WriteFieldError + } + if err = p.writeField21(oprot); err != nil { + fieldId = 21 + goto WriteFieldError + } + if err = p.writeField255(oprot); err != nil { + fieldId = 255 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *GetToolDetailRequest) writeField1(oprot thrift.TProtocol) (err error) { + if p.IsSetToolID() { + if err = oprot.WriteFieldBegin("tool_id", thrift.I64, 1); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI64(*p.ToolID); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} +func (p *GetToolDetailRequest) writeField2(oprot thrift.TProtocol) (err error) { + if p.IsSetWorkspaceID() { + if err = oprot.WriteFieldBegin("workspace_id", thrift.I64, 2); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI64(*p.WorkspaceID); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err) +} +func (p *GetToolDetailRequest) writeField11(oprot thrift.TProtocol) (err error) { + if p.IsSetWithCommit() { + if err = oprot.WriteFieldBegin("with_commit", thrift.BOOL, 11); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteBool(*p.WithCommit); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 11 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 11 end error: ", p), err) +} +func (p *GetToolDetailRequest) writeField12(oprot thrift.TProtocol) (err error) { + if p.IsSetCommitVersion() { + if err = oprot.WriteFieldBegin("commit_version", thrift.STRING, 12); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.CommitVersion); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 12 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 12 end error: ", p), err) +} +func (p *GetToolDetailRequest) writeField21(oprot thrift.TProtocol) (err error) { + if p.IsSetWithDraft() { + if err = oprot.WriteFieldBegin("with_draft", thrift.BOOL, 21); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteBool(*p.WithDraft); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 21 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 21 end error: ", p), err) +} +func (p *GetToolDetailRequest) writeField255(oprot thrift.TProtocol) (err error) { + if p.IsSetBase() { + if err = oprot.WriteFieldBegin("Base", thrift.STRUCT, 255); err != nil { + goto WriteFieldBeginError + } + if err := p.Base.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 end error: ", p), err) +} + +func (p *GetToolDetailRequest) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("GetToolDetailRequest(%+v)", *p) + +} + +func (p *GetToolDetailRequest) DeepEqual(ano *GetToolDetailRequest) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.ToolID) { + return false + } + if !p.Field2DeepEqual(ano.WorkspaceID) { + return false + } + if !p.Field11DeepEqual(ano.WithCommit) { + return false + } + if !p.Field12DeepEqual(ano.CommitVersion) { + return false + } + if !p.Field21DeepEqual(ano.WithDraft) { + return false + } + if !p.Field255DeepEqual(ano.Base) { + return false + } + return true +} + +func (p *GetToolDetailRequest) Field1DeepEqual(src *int64) bool { + + if p.ToolID == src { + return true + } else if p.ToolID == nil || src == nil { + return false + } + if *p.ToolID != *src { + return false + } + return true +} +func (p *GetToolDetailRequest) Field2DeepEqual(src *int64) bool { + + if p.WorkspaceID == src { + return true + } else if p.WorkspaceID == nil || src == nil { + return false + } + if *p.WorkspaceID != *src { + return false + } + return true +} +func (p *GetToolDetailRequest) Field11DeepEqual(src *bool) bool { + + if p.WithCommit == src { + return true + } else if p.WithCommit == nil || src == nil { + return false + } + if *p.WithCommit != *src { + return false + } + return true +} +func (p *GetToolDetailRequest) Field12DeepEqual(src *string) bool { + + if p.CommitVersion == src { + return true + } else if p.CommitVersion == nil || src == nil { + return false + } + if strings.Compare(*p.CommitVersion, *src) != 0 { + return false + } + return true +} +func (p *GetToolDetailRequest) Field21DeepEqual(src *bool) bool { + + if p.WithDraft == src { + return true + } else if p.WithDraft == nil || src == nil { + return false + } + if *p.WithDraft != *src { + return false + } + return true +} +func (p *GetToolDetailRequest) Field255DeepEqual(src *base.Base) bool { + + if !p.Base.DeepEqual(src) { + return false + } + return true +} + +type GetToolDetailResponse struct { + Tool *tool.Tool `thrift:"tool,1,optional" frugal:"1,optional,tool.Tool" form:"tool" json:"tool,omitempty" query:"tool"` + BaseResp *base.BaseResp `thrift:"BaseResp,255,optional" frugal:"255,optional,base.BaseResp" form:"BaseResp" json:"BaseResp,omitempty" query:"BaseResp"` +} + +func NewGetToolDetailResponse() *GetToolDetailResponse { + return &GetToolDetailResponse{} +} + +func (p *GetToolDetailResponse) InitDefault() { +} + +var GetToolDetailResponse_Tool_DEFAULT *tool.Tool + +func (p *GetToolDetailResponse) GetTool() (v *tool.Tool) { + if p == nil { + return + } + if !p.IsSetTool() { + return GetToolDetailResponse_Tool_DEFAULT + } + return p.Tool +} + +var GetToolDetailResponse_BaseResp_DEFAULT *base.BaseResp + +func (p *GetToolDetailResponse) GetBaseResp() (v *base.BaseResp) { + if p == nil { + return + } + if !p.IsSetBaseResp() { + return GetToolDetailResponse_BaseResp_DEFAULT + } + return p.BaseResp +} +func (p *GetToolDetailResponse) SetTool(val *tool.Tool) { + p.Tool = val +} +func (p *GetToolDetailResponse) SetBaseResp(val *base.BaseResp) { + p.BaseResp = val +} + +var fieldIDToName_GetToolDetailResponse = map[int16]string{ + 1: "tool", + 255: "BaseResp", +} + +func (p *GetToolDetailResponse) IsSetTool() bool { + return p.Tool != nil +} + +func (p *GetToolDetailResponse) IsSetBaseResp() bool { + return p.BaseResp != nil +} + +func (p *GetToolDetailResponse) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 255: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField255(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_GetToolDetailResponse[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *GetToolDetailResponse) ReadField1(iprot thrift.TProtocol) error { + _field := tool.NewTool() + if err := _field.Read(iprot); err != nil { + return err + } + p.Tool = _field + return nil +} +func (p *GetToolDetailResponse) ReadField255(iprot thrift.TProtocol) error { + _field := base.NewBaseResp() + if err := _field.Read(iprot); err != nil { + return err + } + p.BaseResp = _field + return nil +} + +func (p *GetToolDetailResponse) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("GetToolDetailResponse"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + if err = p.writeField255(oprot); err != nil { + fieldId = 255 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *GetToolDetailResponse) writeField1(oprot thrift.TProtocol) (err error) { + if p.IsSetTool() { + if err = oprot.WriteFieldBegin("tool", thrift.STRUCT, 1); err != nil { + goto WriteFieldBeginError + } + if err := p.Tool.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} +func (p *GetToolDetailResponse) writeField255(oprot thrift.TProtocol) (err error) { + if p.IsSetBaseResp() { + if err = oprot.WriteFieldBegin("BaseResp", thrift.STRUCT, 255); err != nil { + goto WriteFieldBeginError + } + if err := p.BaseResp.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 end error: ", p), err) +} + +func (p *GetToolDetailResponse) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("GetToolDetailResponse(%+v)", *p) + +} + +func (p *GetToolDetailResponse) DeepEqual(ano *GetToolDetailResponse) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.Tool) { + return false + } + if !p.Field255DeepEqual(ano.BaseResp) { + return false + } + return true +} + +func (p *GetToolDetailResponse) Field1DeepEqual(src *tool.Tool) bool { + + if !p.Tool.DeepEqual(src) { + return false + } + return true +} +func (p *GetToolDetailResponse) Field255DeepEqual(src *base.BaseResp) bool { + + if !p.BaseResp.DeepEqual(src) { + return false + } + return true +} + +type ListToolRequest struct { + WorkspaceID *int64 `thrift:"workspace_id,1,optional" frugal:"1,optional,i64" json:"workspace_id" form:"workspace_id" query:"workspace_id"` + KeyWord *string `thrift:"key_word,11,optional" frugal:"11,optional,string" form:"key_word" json:"key_word,omitempty" query:"key_word"` + CreatedBys []string `thrift:"created_bys,12,optional" frugal:"12,optional,list" form:"created_bys" json:"created_bys,omitempty" query:"created_bys"` + CommittedOnly *bool `thrift:"committed_only,13,optional" frugal:"13,optional,bool" form:"committed_only" json:"committed_only,omitempty" query:"committed_only"` + PageNum *int32 `thrift:"page_num,127,optional" frugal:"127,optional,i32" form:"page_num" json:"page_num,omitempty" query:"page_num"` + PageSize *int32 `thrift:"page_size,128,optional" frugal:"128,optional,i32" form:"page_size" json:"page_size,omitempty" query:"page_size"` + OrderBy *ListToolOrderBy `thrift:"order_by,129,optional" frugal:"129,optional,string" form:"order_by" json:"order_by,omitempty" query:"order_by"` + Asc *bool `thrift:"asc,130,optional" frugal:"130,optional,bool" form:"asc" json:"asc,omitempty" query:"asc"` + Base *base.Base `thrift:"Base,255,optional" frugal:"255,optional,base.Base" form:"Base" json:"Base,omitempty" query:"Base"` +} + +func NewListToolRequest() *ListToolRequest { + return &ListToolRequest{} +} + +func (p *ListToolRequest) InitDefault() { +} + +var ListToolRequest_WorkspaceID_DEFAULT int64 + +func (p *ListToolRequest) GetWorkspaceID() (v int64) { + if p == nil { + return + } + if !p.IsSetWorkspaceID() { + return ListToolRequest_WorkspaceID_DEFAULT + } + return *p.WorkspaceID +} + +var ListToolRequest_KeyWord_DEFAULT string + +func (p *ListToolRequest) GetKeyWord() (v string) { + if p == nil { + return + } + if !p.IsSetKeyWord() { + return ListToolRequest_KeyWord_DEFAULT + } + return *p.KeyWord +} + +var ListToolRequest_CreatedBys_DEFAULT []string + +func (p *ListToolRequest) GetCreatedBys() (v []string) { + if p == nil { + return + } + if !p.IsSetCreatedBys() { + return ListToolRequest_CreatedBys_DEFAULT + } + return p.CreatedBys +} + +var ListToolRequest_CommittedOnly_DEFAULT bool + +func (p *ListToolRequest) GetCommittedOnly() (v bool) { + if p == nil { + return + } + if !p.IsSetCommittedOnly() { + return ListToolRequest_CommittedOnly_DEFAULT + } + return *p.CommittedOnly +} + +var ListToolRequest_PageNum_DEFAULT int32 + +func (p *ListToolRequest) GetPageNum() (v int32) { + if p == nil { + return + } + if !p.IsSetPageNum() { + return ListToolRequest_PageNum_DEFAULT + } + return *p.PageNum +} + +var ListToolRequest_PageSize_DEFAULT int32 + +func (p *ListToolRequest) GetPageSize() (v int32) { + if p == nil { + return + } + if !p.IsSetPageSize() { + return ListToolRequest_PageSize_DEFAULT + } + return *p.PageSize +} + +var ListToolRequest_OrderBy_DEFAULT ListToolOrderBy + +func (p *ListToolRequest) GetOrderBy() (v ListToolOrderBy) { + if p == nil { + return + } + if !p.IsSetOrderBy() { + return ListToolRequest_OrderBy_DEFAULT + } + return *p.OrderBy +} + +var ListToolRequest_Asc_DEFAULT bool + +func (p *ListToolRequest) GetAsc() (v bool) { + if p == nil { + return + } + if !p.IsSetAsc() { + return ListToolRequest_Asc_DEFAULT + } + return *p.Asc +} + +var ListToolRequest_Base_DEFAULT *base.Base + +func (p *ListToolRequest) GetBase() (v *base.Base) { + if p == nil { + return + } + if !p.IsSetBase() { + return ListToolRequest_Base_DEFAULT + } + return p.Base +} +func (p *ListToolRequest) SetWorkspaceID(val *int64) { + p.WorkspaceID = val +} +func (p *ListToolRequest) SetKeyWord(val *string) { + p.KeyWord = val +} +func (p *ListToolRequest) SetCreatedBys(val []string) { + p.CreatedBys = val +} +func (p *ListToolRequest) SetCommittedOnly(val *bool) { + p.CommittedOnly = val +} +func (p *ListToolRequest) SetPageNum(val *int32) { + p.PageNum = val +} +func (p *ListToolRequest) SetPageSize(val *int32) { + p.PageSize = val +} +func (p *ListToolRequest) SetOrderBy(val *ListToolOrderBy) { + p.OrderBy = val +} +func (p *ListToolRequest) SetAsc(val *bool) { + p.Asc = val +} +func (p *ListToolRequest) SetBase(val *base.Base) { + p.Base = val +} + +var fieldIDToName_ListToolRequest = map[int16]string{ + 1: "workspace_id", + 11: "key_word", + 12: "created_bys", + 13: "committed_only", + 127: "page_num", + 128: "page_size", + 129: "order_by", + 130: "asc", + 255: "Base", +} + +func (p *ListToolRequest) IsSetWorkspaceID() bool { + return p.WorkspaceID != nil +} + +func (p *ListToolRequest) IsSetKeyWord() bool { + return p.KeyWord != nil +} + +func (p *ListToolRequest) IsSetCreatedBys() bool { + return p.CreatedBys != nil +} + +func (p *ListToolRequest) IsSetCommittedOnly() bool { + return p.CommittedOnly != nil +} + +func (p *ListToolRequest) IsSetPageNum() bool { + return p.PageNum != nil +} + +func (p *ListToolRequest) IsSetPageSize() bool { + return p.PageSize != nil +} + +func (p *ListToolRequest) IsSetOrderBy() bool { + return p.OrderBy != nil +} + +func (p *ListToolRequest) IsSetAsc() bool { + return p.Asc != nil +} + +func (p *ListToolRequest) IsSetBase() bool { + return p.Base != nil +} + +func (p *ListToolRequest) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.I64 { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 11: + if fieldTypeId == thrift.STRING { + if err = p.ReadField11(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 12: + if fieldTypeId == thrift.LIST { + if err = p.ReadField12(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 13: + if fieldTypeId == thrift.BOOL { + if err = p.ReadField13(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 127: + if fieldTypeId == thrift.I32 { + if err = p.ReadField127(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 128: + if fieldTypeId == thrift.I32 { + if err = p.ReadField128(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 129: + if fieldTypeId == thrift.STRING { + if err = p.ReadField129(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 130: + if fieldTypeId == thrift.BOOL { + if err = p.ReadField130(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 255: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField255(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ListToolRequest[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *ListToolRequest) ReadField1(iprot thrift.TProtocol) error { + + var _field *int64 + if v, err := iprot.ReadI64(); err != nil { + return err + } else { + _field = &v + } + p.WorkspaceID = _field + return nil +} +func (p *ListToolRequest) ReadField11(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.KeyWord = _field + return nil +} +func (p *ListToolRequest) ReadField12(iprot thrift.TProtocol) error { + _, size, err := iprot.ReadListBegin() + if err != nil { + return err + } + _field := make([]string, 0, size) + for i := 0; i < size; i++ { + + var _elem string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _elem = v + } + + _field = append(_field, _elem) + } + if err := iprot.ReadListEnd(); err != nil { + return err + } + p.CreatedBys = _field + return nil +} +func (p *ListToolRequest) ReadField13(iprot thrift.TProtocol) error { + + var _field *bool + if v, err := iprot.ReadBool(); err != nil { + return err + } else { + _field = &v + } + p.CommittedOnly = _field + return nil +} +func (p *ListToolRequest) ReadField127(iprot thrift.TProtocol) error { + + var _field *int32 + if v, err := iprot.ReadI32(); err != nil { + return err + } else { + _field = &v + } + p.PageNum = _field + return nil +} +func (p *ListToolRequest) ReadField128(iprot thrift.TProtocol) error { + + var _field *int32 + if v, err := iprot.ReadI32(); err != nil { + return err + } else { + _field = &v + } + p.PageSize = _field + return nil +} +func (p *ListToolRequest) ReadField129(iprot thrift.TProtocol) error { + + var _field *ListToolOrderBy + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.OrderBy = _field + return nil +} +func (p *ListToolRequest) ReadField130(iprot thrift.TProtocol) error { + + var _field *bool + if v, err := iprot.ReadBool(); err != nil { + return err + } else { + _field = &v + } + p.Asc = _field + return nil +} +func (p *ListToolRequest) ReadField255(iprot thrift.TProtocol) error { + _field := base.NewBase() + if err := _field.Read(iprot); err != nil { + return err + } + p.Base = _field + return nil +} + +func (p *ListToolRequest) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("ListToolRequest"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + if err = p.writeField11(oprot); err != nil { + fieldId = 11 + goto WriteFieldError + } + if err = p.writeField12(oprot); err != nil { + fieldId = 12 + goto WriteFieldError + } + if err = p.writeField13(oprot); err != nil { + fieldId = 13 + goto WriteFieldError + } + if err = p.writeField127(oprot); err != nil { + fieldId = 127 + goto WriteFieldError + } + if err = p.writeField128(oprot); err != nil { + fieldId = 128 + goto WriteFieldError + } + if err = p.writeField129(oprot); err != nil { + fieldId = 129 + goto WriteFieldError + } + if err = p.writeField130(oprot); err != nil { + fieldId = 130 + goto WriteFieldError + } + if err = p.writeField255(oprot); err != nil { + fieldId = 255 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *ListToolRequest) writeField1(oprot thrift.TProtocol) (err error) { + if p.IsSetWorkspaceID() { + if err = oprot.WriteFieldBegin("workspace_id", thrift.I64, 1); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI64(*p.WorkspaceID); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} +func (p *ListToolRequest) writeField11(oprot thrift.TProtocol) (err error) { + if p.IsSetKeyWord() { + if err = oprot.WriteFieldBegin("key_word", thrift.STRING, 11); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.KeyWord); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 11 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 11 end error: ", p), err) +} +func (p *ListToolRequest) writeField12(oprot thrift.TProtocol) (err error) { + if p.IsSetCreatedBys() { + if err = oprot.WriteFieldBegin("created_bys", thrift.LIST, 12); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteListBegin(thrift.STRING, len(p.CreatedBys)); err != nil { + return err + } + for _, v := range p.CreatedBys { + if err := oprot.WriteString(v); err != nil { + return err + } + } + if err := oprot.WriteListEnd(); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 12 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 12 end error: ", p), err) +} +func (p *ListToolRequest) writeField13(oprot thrift.TProtocol) (err error) { + if p.IsSetCommittedOnly() { + if err = oprot.WriteFieldBegin("committed_only", thrift.BOOL, 13); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteBool(*p.CommittedOnly); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 13 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 13 end error: ", p), err) +} +func (p *ListToolRequest) writeField127(oprot thrift.TProtocol) (err error) { + if p.IsSetPageNum() { + if err = oprot.WriteFieldBegin("page_num", thrift.I32, 127); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI32(*p.PageNum); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 127 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 127 end error: ", p), err) +} +func (p *ListToolRequest) writeField128(oprot thrift.TProtocol) (err error) { + if p.IsSetPageSize() { + if err = oprot.WriteFieldBegin("page_size", thrift.I32, 128); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI32(*p.PageSize); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 128 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 128 end error: ", p), err) +} +func (p *ListToolRequest) writeField129(oprot thrift.TProtocol) (err error) { + if p.IsSetOrderBy() { + if err = oprot.WriteFieldBegin("order_by", thrift.STRING, 129); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.OrderBy); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 129 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 129 end error: ", p), err) +} +func (p *ListToolRequest) writeField130(oprot thrift.TProtocol) (err error) { + if p.IsSetAsc() { + if err = oprot.WriteFieldBegin("asc", thrift.BOOL, 130); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteBool(*p.Asc); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 130 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 130 end error: ", p), err) +} +func (p *ListToolRequest) writeField255(oprot thrift.TProtocol) (err error) { + if p.IsSetBase() { + if err = oprot.WriteFieldBegin("Base", thrift.STRUCT, 255); err != nil { + goto WriteFieldBeginError + } + if err := p.Base.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 end error: ", p), err) +} + +func (p *ListToolRequest) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("ListToolRequest(%+v)", *p) + +} + +func (p *ListToolRequest) DeepEqual(ano *ListToolRequest) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.WorkspaceID) { + return false + } + if !p.Field11DeepEqual(ano.KeyWord) { + return false + } + if !p.Field12DeepEqual(ano.CreatedBys) { + return false + } + if !p.Field13DeepEqual(ano.CommittedOnly) { + return false + } + if !p.Field127DeepEqual(ano.PageNum) { + return false + } + if !p.Field128DeepEqual(ano.PageSize) { + return false + } + if !p.Field129DeepEqual(ano.OrderBy) { + return false + } + if !p.Field130DeepEqual(ano.Asc) { + return false + } + if !p.Field255DeepEqual(ano.Base) { + return false + } + return true +} + +func (p *ListToolRequest) Field1DeepEqual(src *int64) bool { + + if p.WorkspaceID == src { + return true + } else if p.WorkspaceID == nil || src == nil { + return false + } + if *p.WorkspaceID != *src { + return false + } + return true +} +func (p *ListToolRequest) Field11DeepEqual(src *string) bool { + + if p.KeyWord == src { + return true + } else if p.KeyWord == nil || src == nil { + return false + } + if strings.Compare(*p.KeyWord, *src) != 0 { + return false + } + return true +} +func (p *ListToolRequest) Field12DeepEqual(src []string) bool { + + if len(p.CreatedBys) != len(src) { + return false + } + for i, v := range p.CreatedBys { + _src := src[i] + if strings.Compare(v, _src) != 0 { + return false + } + } + return true +} +func (p *ListToolRequest) Field13DeepEqual(src *bool) bool { + + if p.CommittedOnly == src { + return true + } else if p.CommittedOnly == nil || src == nil { + return false + } + if *p.CommittedOnly != *src { + return false + } + return true +} +func (p *ListToolRequest) Field127DeepEqual(src *int32) bool { + + if p.PageNum == src { + return true + } else if p.PageNum == nil || src == nil { + return false + } + if *p.PageNum != *src { + return false + } + return true +} +func (p *ListToolRequest) Field128DeepEqual(src *int32) bool { + + if p.PageSize == src { + return true + } else if p.PageSize == nil || src == nil { + return false + } + if *p.PageSize != *src { + return false + } + return true +} +func (p *ListToolRequest) Field129DeepEqual(src *ListToolOrderBy) bool { + + if p.OrderBy == src { + return true + } else if p.OrderBy == nil || src == nil { + return false + } + if strings.Compare(*p.OrderBy, *src) != 0 { + return false + } + return true +} +func (p *ListToolRequest) Field130DeepEqual(src *bool) bool { + + if p.Asc == src { + return true + } else if p.Asc == nil || src == nil { + return false + } + if *p.Asc != *src { + return false + } + return true +} +func (p *ListToolRequest) Field255DeepEqual(src *base.Base) bool { + + if !p.Base.DeepEqual(src) { + return false + } + return true +} + +type ListToolResponse struct { + Tools []*tool.Tool `thrift:"tools,1,optional" frugal:"1,optional,list" form:"tools" json:"tools,omitempty" query:"tools"` + Users []*user.UserInfoDetail `thrift:"users,11,optional" frugal:"11,optional,list" form:"users" json:"users,omitempty" query:"users"` + Total *int32 `thrift:"total,127,optional" frugal:"127,optional,i32" form:"total" json:"total,omitempty" query:"total"` + BaseResp *base.BaseResp `thrift:"BaseResp,255,optional" frugal:"255,optional,base.BaseResp" form:"BaseResp" json:"BaseResp,omitempty" query:"BaseResp"` +} + +func NewListToolResponse() *ListToolResponse { + return &ListToolResponse{} +} + +func (p *ListToolResponse) InitDefault() { +} + +var ListToolResponse_Tools_DEFAULT []*tool.Tool + +func (p *ListToolResponse) GetTools() (v []*tool.Tool) { + if p == nil { + return + } + if !p.IsSetTools() { + return ListToolResponse_Tools_DEFAULT + } + return p.Tools +} + +var ListToolResponse_Users_DEFAULT []*user.UserInfoDetail + +func (p *ListToolResponse) GetUsers() (v []*user.UserInfoDetail) { + if p == nil { + return + } + if !p.IsSetUsers() { + return ListToolResponse_Users_DEFAULT + } + return p.Users +} + +var ListToolResponse_Total_DEFAULT int32 + +func (p *ListToolResponse) GetTotal() (v int32) { + if p == nil { + return + } + if !p.IsSetTotal() { + return ListToolResponse_Total_DEFAULT + } + return *p.Total +} + +var ListToolResponse_BaseResp_DEFAULT *base.BaseResp + +func (p *ListToolResponse) GetBaseResp() (v *base.BaseResp) { + if p == nil { + return + } + if !p.IsSetBaseResp() { + return ListToolResponse_BaseResp_DEFAULT + } + return p.BaseResp +} +func (p *ListToolResponse) SetTools(val []*tool.Tool) { + p.Tools = val +} +func (p *ListToolResponse) SetUsers(val []*user.UserInfoDetail) { + p.Users = val +} +func (p *ListToolResponse) SetTotal(val *int32) { + p.Total = val +} +func (p *ListToolResponse) SetBaseResp(val *base.BaseResp) { + p.BaseResp = val +} + +var fieldIDToName_ListToolResponse = map[int16]string{ + 1: "tools", + 11: "users", + 127: "total", + 255: "BaseResp", +} + +func (p *ListToolResponse) IsSetTools() bool { + return p.Tools != nil +} + +func (p *ListToolResponse) IsSetUsers() bool { + return p.Users != nil +} + +func (p *ListToolResponse) IsSetTotal() bool { + return p.Total != nil +} + +func (p *ListToolResponse) IsSetBaseResp() bool { + return p.BaseResp != nil +} + +func (p *ListToolResponse) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.LIST { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 11: + if fieldTypeId == thrift.LIST { + if err = p.ReadField11(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 127: + if fieldTypeId == thrift.I32 { + if err = p.ReadField127(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 255: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField255(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ListToolResponse[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *ListToolResponse) ReadField1(iprot thrift.TProtocol) error { + _, size, err := iprot.ReadListBegin() + if err != nil { + return err + } + _field := make([]*tool.Tool, 0, size) + values := make([]tool.Tool, size) + for i := 0; i < size; i++ { + _elem := &values[i] + _elem.InitDefault() + + if err := _elem.Read(iprot); err != nil { + return err + } + + _field = append(_field, _elem) + } + if err := iprot.ReadListEnd(); err != nil { + return err + } + p.Tools = _field + return nil +} +func (p *ListToolResponse) ReadField11(iprot thrift.TProtocol) error { + _, size, err := iprot.ReadListBegin() + if err != nil { + return err + } + _field := make([]*user.UserInfoDetail, 0, size) + values := make([]user.UserInfoDetail, size) + for i := 0; i < size; i++ { + _elem := &values[i] + _elem.InitDefault() + + if err := _elem.Read(iprot); err != nil { + return err + } + + _field = append(_field, _elem) + } + if err := iprot.ReadListEnd(); err != nil { + return err + } + p.Users = _field + return nil +} +func (p *ListToolResponse) ReadField127(iprot thrift.TProtocol) error { + + var _field *int32 + if v, err := iprot.ReadI32(); err != nil { + return err + } else { + _field = &v + } + p.Total = _field + return nil +} +func (p *ListToolResponse) ReadField255(iprot thrift.TProtocol) error { + _field := base.NewBaseResp() + if err := _field.Read(iprot); err != nil { + return err + } + p.BaseResp = _field + return nil +} + +func (p *ListToolResponse) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("ListToolResponse"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + if err = p.writeField11(oprot); err != nil { + fieldId = 11 + goto WriteFieldError + } + if err = p.writeField127(oprot); err != nil { + fieldId = 127 + goto WriteFieldError + } + if err = p.writeField255(oprot); err != nil { + fieldId = 255 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *ListToolResponse) writeField1(oprot thrift.TProtocol) (err error) { + if p.IsSetTools() { + if err = oprot.WriteFieldBegin("tools", thrift.LIST, 1); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteListBegin(thrift.STRUCT, len(p.Tools)); err != nil { + return err + } + for _, v := range p.Tools { + if err := v.Write(oprot); err != nil { + return err + } + } + if err := oprot.WriteListEnd(); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} +func (p *ListToolResponse) writeField11(oprot thrift.TProtocol) (err error) { + if p.IsSetUsers() { + if err = oprot.WriteFieldBegin("users", thrift.LIST, 11); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteListBegin(thrift.STRUCT, len(p.Users)); err != nil { + return err + } + for _, v := range p.Users { + if err := v.Write(oprot); err != nil { + return err + } + } + if err := oprot.WriteListEnd(); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 11 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 11 end error: ", p), err) +} +func (p *ListToolResponse) writeField127(oprot thrift.TProtocol) (err error) { + if p.IsSetTotal() { + if err = oprot.WriteFieldBegin("total", thrift.I32, 127); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI32(*p.Total); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 127 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 127 end error: ", p), err) +} +func (p *ListToolResponse) writeField255(oprot thrift.TProtocol) (err error) { + if p.IsSetBaseResp() { + if err = oprot.WriteFieldBegin("BaseResp", thrift.STRUCT, 255); err != nil { + goto WriteFieldBeginError + } + if err := p.BaseResp.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 end error: ", p), err) +} + +func (p *ListToolResponse) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("ListToolResponse(%+v)", *p) + +} + +func (p *ListToolResponse) DeepEqual(ano *ListToolResponse) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.Tools) { + return false + } + if !p.Field11DeepEqual(ano.Users) { + return false + } + if !p.Field127DeepEqual(ano.Total) { + return false + } + if !p.Field255DeepEqual(ano.BaseResp) { + return false + } + return true +} + +func (p *ListToolResponse) Field1DeepEqual(src []*tool.Tool) bool { + + if len(p.Tools) != len(src) { + return false + } + for i, v := range p.Tools { + _src := src[i] + if !v.DeepEqual(_src) { + return false + } + } + return true +} +func (p *ListToolResponse) Field11DeepEqual(src []*user.UserInfoDetail) bool { + + if len(p.Users) != len(src) { + return false + } + for i, v := range p.Users { + _src := src[i] + if !v.DeepEqual(_src) { + return false + } + } + return true +} +func (p *ListToolResponse) Field127DeepEqual(src *int32) bool { + + if p.Total == src { + return true + } else if p.Total == nil || src == nil { + return false + } + if *p.Total != *src { + return false + } + return true +} +func (p *ListToolResponse) Field255DeepEqual(src *base.BaseResp) bool { + + if !p.BaseResp.DeepEqual(src) { + return false + } + return true +} + +type SaveToolDetailRequest struct { + ToolID *int64 `thrift:"tool_id,1,optional" frugal:"1,optional,i64" json:"tool_id" path:"tool_id" ` + WorkspaceID *int64 `thrift:"workspace_id,2,optional" frugal:"2,optional,i64" json:"workspace_id" query:"workspace_id" ` + ToolDetail *tool.ToolDetail `thrift:"tool_detail,11,optional" frugal:"11,optional,tool.ToolDetail" form:"tool_detail" json:"tool_detail,omitempty" query:"tool_detail"` + BaseVersion *string `thrift:"base_version,12,optional" frugal:"12,optional,string" form:"base_version" json:"base_version,omitempty" query:"base_version"` + Base *base.Base `thrift:"Base,255,optional" frugal:"255,optional,base.Base" form:"Base" json:"Base,omitempty" query:"Base"` +} + +func NewSaveToolDetailRequest() *SaveToolDetailRequest { + return &SaveToolDetailRequest{} +} + +func (p *SaveToolDetailRequest) InitDefault() { +} + +var SaveToolDetailRequest_ToolID_DEFAULT int64 + +func (p *SaveToolDetailRequest) GetToolID() (v int64) { + if p == nil { + return + } + if !p.IsSetToolID() { + return SaveToolDetailRequest_ToolID_DEFAULT + } + return *p.ToolID +} + +var SaveToolDetailRequest_WorkspaceID_DEFAULT int64 + +func (p *SaveToolDetailRequest) GetWorkspaceID() (v int64) { + if p == nil { + return + } + if !p.IsSetWorkspaceID() { + return SaveToolDetailRequest_WorkspaceID_DEFAULT + } + return *p.WorkspaceID +} + +var SaveToolDetailRequest_ToolDetail_DEFAULT *tool.ToolDetail + +func (p *SaveToolDetailRequest) GetToolDetail() (v *tool.ToolDetail) { + if p == nil { + return + } + if !p.IsSetToolDetail() { + return SaveToolDetailRequest_ToolDetail_DEFAULT + } + return p.ToolDetail +} + +var SaveToolDetailRequest_BaseVersion_DEFAULT string + +func (p *SaveToolDetailRequest) GetBaseVersion() (v string) { + if p == nil { + return + } + if !p.IsSetBaseVersion() { + return SaveToolDetailRequest_BaseVersion_DEFAULT + } + return *p.BaseVersion +} + +var SaveToolDetailRequest_Base_DEFAULT *base.Base + +func (p *SaveToolDetailRequest) GetBase() (v *base.Base) { + if p == nil { + return + } + if !p.IsSetBase() { + return SaveToolDetailRequest_Base_DEFAULT + } + return p.Base +} +func (p *SaveToolDetailRequest) SetToolID(val *int64) { + p.ToolID = val +} +func (p *SaveToolDetailRequest) SetWorkspaceID(val *int64) { + p.WorkspaceID = val +} +func (p *SaveToolDetailRequest) SetToolDetail(val *tool.ToolDetail) { + p.ToolDetail = val +} +func (p *SaveToolDetailRequest) SetBaseVersion(val *string) { + p.BaseVersion = val +} +func (p *SaveToolDetailRequest) SetBase(val *base.Base) { + p.Base = val +} + +var fieldIDToName_SaveToolDetailRequest = map[int16]string{ + 1: "tool_id", + 2: "workspace_id", + 11: "tool_detail", + 12: "base_version", + 255: "Base", +} + +func (p *SaveToolDetailRequest) IsSetToolID() bool { + return p.ToolID != nil +} + +func (p *SaveToolDetailRequest) IsSetWorkspaceID() bool { + return p.WorkspaceID != nil +} + +func (p *SaveToolDetailRequest) IsSetToolDetail() bool { + return p.ToolDetail != nil +} + +func (p *SaveToolDetailRequest) IsSetBaseVersion() bool { + return p.BaseVersion != nil +} + +func (p *SaveToolDetailRequest) IsSetBase() bool { + return p.Base != nil +} + +func (p *SaveToolDetailRequest) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.I64 { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 2: + if fieldTypeId == thrift.I64 { + if err = p.ReadField2(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 11: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField11(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 12: + if fieldTypeId == thrift.STRING { + if err = p.ReadField12(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 255: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField255(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_SaveToolDetailRequest[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *SaveToolDetailRequest) ReadField1(iprot thrift.TProtocol) error { + + var _field *int64 + if v, err := iprot.ReadI64(); err != nil { + return err + } else { + _field = &v + } + p.ToolID = _field + return nil +} +func (p *SaveToolDetailRequest) ReadField2(iprot thrift.TProtocol) error { + + var _field *int64 + if v, err := iprot.ReadI64(); err != nil { + return err + } else { + _field = &v + } + p.WorkspaceID = _field + return nil +} +func (p *SaveToolDetailRequest) ReadField11(iprot thrift.TProtocol) error { + _field := tool.NewToolDetail() + if err := _field.Read(iprot); err != nil { + return err + } + p.ToolDetail = _field + return nil +} +func (p *SaveToolDetailRequest) ReadField12(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.BaseVersion = _field + return nil +} +func (p *SaveToolDetailRequest) ReadField255(iprot thrift.TProtocol) error { + _field := base.NewBase() + if err := _field.Read(iprot); err != nil { + return err + } + p.Base = _field + return nil +} + +func (p *SaveToolDetailRequest) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("SaveToolDetailRequest"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + if err = p.writeField2(oprot); err != nil { + fieldId = 2 + goto WriteFieldError + } + if err = p.writeField11(oprot); err != nil { + fieldId = 11 + goto WriteFieldError + } + if err = p.writeField12(oprot); err != nil { + fieldId = 12 + goto WriteFieldError + } + if err = p.writeField255(oprot); err != nil { + fieldId = 255 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *SaveToolDetailRequest) writeField1(oprot thrift.TProtocol) (err error) { + if p.IsSetToolID() { + if err = oprot.WriteFieldBegin("tool_id", thrift.I64, 1); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI64(*p.ToolID); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} +func (p *SaveToolDetailRequest) writeField2(oprot thrift.TProtocol) (err error) { + if p.IsSetWorkspaceID() { + if err = oprot.WriteFieldBegin("workspace_id", thrift.I64, 2); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI64(*p.WorkspaceID); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err) +} +func (p *SaveToolDetailRequest) writeField11(oprot thrift.TProtocol) (err error) { + if p.IsSetToolDetail() { + if err = oprot.WriteFieldBegin("tool_detail", thrift.STRUCT, 11); err != nil { + goto WriteFieldBeginError + } + if err := p.ToolDetail.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 11 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 11 end error: ", p), err) +} +func (p *SaveToolDetailRequest) writeField12(oprot thrift.TProtocol) (err error) { + if p.IsSetBaseVersion() { + if err = oprot.WriteFieldBegin("base_version", thrift.STRING, 12); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.BaseVersion); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 12 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 12 end error: ", p), err) +} +func (p *SaveToolDetailRequest) writeField255(oprot thrift.TProtocol) (err error) { + if p.IsSetBase() { + if err = oprot.WriteFieldBegin("Base", thrift.STRUCT, 255); err != nil { + goto WriteFieldBeginError + } + if err := p.Base.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 end error: ", p), err) +} + +func (p *SaveToolDetailRequest) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("SaveToolDetailRequest(%+v)", *p) + +} + +func (p *SaveToolDetailRequest) DeepEqual(ano *SaveToolDetailRequest) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.ToolID) { + return false + } + if !p.Field2DeepEqual(ano.WorkspaceID) { + return false + } + if !p.Field11DeepEqual(ano.ToolDetail) { + return false + } + if !p.Field12DeepEqual(ano.BaseVersion) { + return false + } + if !p.Field255DeepEqual(ano.Base) { + return false + } + return true +} + +func (p *SaveToolDetailRequest) Field1DeepEqual(src *int64) bool { + + if p.ToolID == src { + return true + } else if p.ToolID == nil || src == nil { + return false + } + if *p.ToolID != *src { + return false + } + return true +} +func (p *SaveToolDetailRequest) Field2DeepEqual(src *int64) bool { + + if p.WorkspaceID == src { + return true + } else if p.WorkspaceID == nil || src == nil { + return false + } + if *p.WorkspaceID != *src { + return false + } + return true +} +func (p *SaveToolDetailRequest) Field11DeepEqual(src *tool.ToolDetail) bool { + + if !p.ToolDetail.DeepEqual(src) { + return false + } + return true +} +func (p *SaveToolDetailRequest) Field12DeepEqual(src *string) bool { + + if p.BaseVersion == src { + return true + } else if p.BaseVersion == nil || src == nil { + return false + } + if strings.Compare(*p.BaseVersion, *src) != 0 { + return false + } + return true +} +func (p *SaveToolDetailRequest) Field255DeepEqual(src *base.Base) bool { + + if !p.Base.DeepEqual(src) { + return false + } + return true +} + +type SaveToolDetailResponse struct { + BaseResp *base.BaseResp `thrift:"BaseResp,255,optional" frugal:"255,optional,base.BaseResp" form:"BaseResp" json:"BaseResp,omitempty" query:"BaseResp"` +} + +func NewSaveToolDetailResponse() *SaveToolDetailResponse { + return &SaveToolDetailResponse{} +} + +func (p *SaveToolDetailResponse) InitDefault() { +} + +var SaveToolDetailResponse_BaseResp_DEFAULT *base.BaseResp + +func (p *SaveToolDetailResponse) GetBaseResp() (v *base.BaseResp) { + if p == nil { + return + } + if !p.IsSetBaseResp() { + return SaveToolDetailResponse_BaseResp_DEFAULT + } + return p.BaseResp +} +func (p *SaveToolDetailResponse) SetBaseResp(val *base.BaseResp) { + p.BaseResp = val +} + +var fieldIDToName_SaveToolDetailResponse = map[int16]string{ + 255: "BaseResp", +} + +func (p *SaveToolDetailResponse) IsSetBaseResp() bool { + return p.BaseResp != nil +} + +func (p *SaveToolDetailResponse) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 255: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField255(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_SaveToolDetailResponse[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *SaveToolDetailResponse) ReadField255(iprot thrift.TProtocol) error { + _field := base.NewBaseResp() + if err := _field.Read(iprot); err != nil { + return err + } + p.BaseResp = _field + return nil +} + +func (p *SaveToolDetailResponse) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("SaveToolDetailResponse"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField255(oprot); err != nil { + fieldId = 255 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *SaveToolDetailResponse) writeField255(oprot thrift.TProtocol) (err error) { + if p.IsSetBaseResp() { + if err = oprot.WriteFieldBegin("BaseResp", thrift.STRUCT, 255); err != nil { + goto WriteFieldBeginError + } + if err := p.BaseResp.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 end error: ", p), err) +} + +func (p *SaveToolDetailResponse) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("SaveToolDetailResponse(%+v)", *p) + +} + +func (p *SaveToolDetailResponse) DeepEqual(ano *SaveToolDetailResponse) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field255DeepEqual(ano.BaseResp) { + return false + } + return true +} + +func (p *SaveToolDetailResponse) Field255DeepEqual(src *base.BaseResp) bool { + + if !p.BaseResp.DeepEqual(src) { + return false + } + return true +} + +type CommitToolDraftRequest struct { + ToolID *int64 `thrift:"tool_id,1,optional" frugal:"1,optional,i64" json:"tool_id" path:"tool_id" ` + WorkspaceID *int64 `thrift:"workspace_id,2,optional" frugal:"2,optional,i64" json:"workspace_id" query:"workspace_id" ` + CommitVersion *string `thrift:"commit_version,11,optional" frugal:"11,optional,string" form:"commit_version" json:"commit_version,omitempty" query:"commit_version"` + CommitDescription *string `thrift:"commit_description,12,optional" frugal:"12,optional,string" form:"commit_description" json:"commit_description,omitempty" query:"commit_description"` + BaseVersion *string `thrift:"base_version,13,optional" frugal:"13,optional,string" form:"base_version" json:"base_version,omitempty" query:"base_version"` + Base *base.Base `thrift:"Base,255,optional" frugal:"255,optional,base.Base" form:"Base" json:"Base,omitempty" query:"Base"` +} + +func NewCommitToolDraftRequest() *CommitToolDraftRequest { + return &CommitToolDraftRequest{} +} + +func (p *CommitToolDraftRequest) InitDefault() { +} + +var CommitToolDraftRequest_ToolID_DEFAULT int64 + +func (p *CommitToolDraftRequest) GetToolID() (v int64) { + if p == nil { + return + } + if !p.IsSetToolID() { + return CommitToolDraftRequest_ToolID_DEFAULT + } + return *p.ToolID +} + +var CommitToolDraftRequest_WorkspaceID_DEFAULT int64 + +func (p *CommitToolDraftRequest) GetWorkspaceID() (v int64) { + if p == nil { + return + } + if !p.IsSetWorkspaceID() { + return CommitToolDraftRequest_WorkspaceID_DEFAULT + } + return *p.WorkspaceID +} + +var CommitToolDraftRequest_CommitVersion_DEFAULT string + +func (p *CommitToolDraftRequest) GetCommitVersion() (v string) { + if p == nil { + return + } + if !p.IsSetCommitVersion() { + return CommitToolDraftRequest_CommitVersion_DEFAULT + } + return *p.CommitVersion +} + +var CommitToolDraftRequest_CommitDescription_DEFAULT string + +func (p *CommitToolDraftRequest) GetCommitDescription() (v string) { + if p == nil { + return + } + if !p.IsSetCommitDescription() { + return CommitToolDraftRequest_CommitDescription_DEFAULT + } + return *p.CommitDescription +} + +var CommitToolDraftRequest_BaseVersion_DEFAULT string + +func (p *CommitToolDraftRequest) GetBaseVersion() (v string) { + if p == nil { + return + } + if !p.IsSetBaseVersion() { + return CommitToolDraftRequest_BaseVersion_DEFAULT + } + return *p.BaseVersion +} + +var CommitToolDraftRequest_Base_DEFAULT *base.Base + +func (p *CommitToolDraftRequest) GetBase() (v *base.Base) { + if p == nil { + return + } + if !p.IsSetBase() { + return CommitToolDraftRequest_Base_DEFAULT + } + return p.Base +} +func (p *CommitToolDraftRequest) SetToolID(val *int64) { + p.ToolID = val +} +func (p *CommitToolDraftRequest) SetWorkspaceID(val *int64) { + p.WorkspaceID = val +} +func (p *CommitToolDraftRequest) SetCommitVersion(val *string) { + p.CommitVersion = val +} +func (p *CommitToolDraftRequest) SetCommitDescription(val *string) { + p.CommitDescription = val +} +func (p *CommitToolDraftRequest) SetBaseVersion(val *string) { + p.BaseVersion = val +} +func (p *CommitToolDraftRequest) SetBase(val *base.Base) { + p.Base = val +} + +var fieldIDToName_CommitToolDraftRequest = map[int16]string{ + 1: "tool_id", + 2: "workspace_id", + 11: "commit_version", + 12: "commit_description", + 13: "base_version", + 255: "Base", +} + +func (p *CommitToolDraftRequest) IsSetToolID() bool { + return p.ToolID != nil +} + +func (p *CommitToolDraftRequest) IsSetWorkspaceID() bool { + return p.WorkspaceID != nil +} + +func (p *CommitToolDraftRequest) IsSetCommitVersion() bool { + return p.CommitVersion != nil +} + +func (p *CommitToolDraftRequest) IsSetCommitDescription() bool { + return p.CommitDescription != nil +} + +func (p *CommitToolDraftRequest) IsSetBaseVersion() bool { + return p.BaseVersion != nil +} + +func (p *CommitToolDraftRequest) IsSetBase() bool { + return p.Base != nil +} + +func (p *CommitToolDraftRequest) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.I64 { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 2: + if fieldTypeId == thrift.I64 { + if err = p.ReadField2(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 11: + if fieldTypeId == thrift.STRING { + if err = p.ReadField11(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 12: + if fieldTypeId == thrift.STRING { + if err = p.ReadField12(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 13: + if fieldTypeId == thrift.STRING { + if err = p.ReadField13(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 255: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField255(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_CommitToolDraftRequest[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *CommitToolDraftRequest) ReadField1(iprot thrift.TProtocol) error { + + var _field *int64 + if v, err := iprot.ReadI64(); err != nil { + return err + } else { + _field = &v + } + p.ToolID = _field + return nil +} +func (p *CommitToolDraftRequest) ReadField2(iprot thrift.TProtocol) error { + + var _field *int64 + if v, err := iprot.ReadI64(); err != nil { + return err + } else { + _field = &v + } + p.WorkspaceID = _field + return nil +} +func (p *CommitToolDraftRequest) ReadField11(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.CommitVersion = _field + return nil +} +func (p *CommitToolDraftRequest) ReadField12(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.CommitDescription = _field + return nil +} +func (p *CommitToolDraftRequest) ReadField13(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.BaseVersion = _field + return nil +} +func (p *CommitToolDraftRequest) ReadField255(iprot thrift.TProtocol) error { + _field := base.NewBase() + if err := _field.Read(iprot); err != nil { + return err + } + p.Base = _field + return nil +} + +func (p *CommitToolDraftRequest) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("CommitToolDraftRequest"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + if err = p.writeField2(oprot); err != nil { + fieldId = 2 + goto WriteFieldError + } + if err = p.writeField11(oprot); err != nil { + fieldId = 11 + goto WriteFieldError + } + if err = p.writeField12(oprot); err != nil { + fieldId = 12 + goto WriteFieldError + } + if err = p.writeField13(oprot); err != nil { + fieldId = 13 + goto WriteFieldError + } + if err = p.writeField255(oprot); err != nil { + fieldId = 255 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *CommitToolDraftRequest) writeField1(oprot thrift.TProtocol) (err error) { + if p.IsSetToolID() { + if err = oprot.WriteFieldBegin("tool_id", thrift.I64, 1); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI64(*p.ToolID); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} +func (p *CommitToolDraftRequest) writeField2(oprot thrift.TProtocol) (err error) { + if p.IsSetWorkspaceID() { + if err = oprot.WriteFieldBegin("workspace_id", thrift.I64, 2); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI64(*p.WorkspaceID); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err) +} +func (p *CommitToolDraftRequest) writeField11(oprot thrift.TProtocol) (err error) { + if p.IsSetCommitVersion() { + if err = oprot.WriteFieldBegin("commit_version", thrift.STRING, 11); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.CommitVersion); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 11 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 11 end error: ", p), err) +} +func (p *CommitToolDraftRequest) writeField12(oprot thrift.TProtocol) (err error) { + if p.IsSetCommitDescription() { + if err = oprot.WriteFieldBegin("commit_description", thrift.STRING, 12); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.CommitDescription); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 12 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 12 end error: ", p), err) +} +func (p *CommitToolDraftRequest) writeField13(oprot thrift.TProtocol) (err error) { + if p.IsSetBaseVersion() { + if err = oprot.WriteFieldBegin("base_version", thrift.STRING, 13); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.BaseVersion); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 13 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 13 end error: ", p), err) +} +func (p *CommitToolDraftRequest) writeField255(oprot thrift.TProtocol) (err error) { + if p.IsSetBase() { + if err = oprot.WriteFieldBegin("Base", thrift.STRUCT, 255); err != nil { + goto WriteFieldBeginError + } + if err := p.Base.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 end error: ", p), err) +} + +func (p *CommitToolDraftRequest) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("CommitToolDraftRequest(%+v)", *p) + +} + +func (p *CommitToolDraftRequest) DeepEqual(ano *CommitToolDraftRequest) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.ToolID) { + return false + } + if !p.Field2DeepEqual(ano.WorkspaceID) { + return false + } + if !p.Field11DeepEqual(ano.CommitVersion) { + return false + } + if !p.Field12DeepEqual(ano.CommitDescription) { + return false + } + if !p.Field13DeepEqual(ano.BaseVersion) { + return false + } + if !p.Field255DeepEqual(ano.Base) { + return false + } + return true +} + +func (p *CommitToolDraftRequest) Field1DeepEqual(src *int64) bool { + + if p.ToolID == src { + return true + } else if p.ToolID == nil || src == nil { + return false + } + if *p.ToolID != *src { + return false + } + return true +} +func (p *CommitToolDraftRequest) Field2DeepEqual(src *int64) bool { + + if p.WorkspaceID == src { + return true + } else if p.WorkspaceID == nil || src == nil { + return false + } + if *p.WorkspaceID != *src { + return false + } + return true +} +func (p *CommitToolDraftRequest) Field11DeepEqual(src *string) bool { + + if p.CommitVersion == src { + return true + } else if p.CommitVersion == nil || src == nil { + return false + } + if strings.Compare(*p.CommitVersion, *src) != 0 { + return false + } + return true +} +func (p *CommitToolDraftRequest) Field12DeepEqual(src *string) bool { + + if p.CommitDescription == src { + return true + } else if p.CommitDescription == nil || src == nil { + return false + } + if strings.Compare(*p.CommitDescription, *src) != 0 { + return false + } + return true +} +func (p *CommitToolDraftRequest) Field13DeepEqual(src *string) bool { + + if p.BaseVersion == src { + return true + } else if p.BaseVersion == nil || src == nil { + return false + } + if strings.Compare(*p.BaseVersion, *src) != 0 { + return false + } + return true +} +func (p *CommitToolDraftRequest) Field255DeepEqual(src *base.Base) bool { + + if !p.Base.DeepEqual(src) { + return false + } + return true +} + +type CommitToolDraftResponse struct { + BaseResp *base.BaseResp `thrift:"BaseResp,255,optional" frugal:"255,optional,base.BaseResp" form:"BaseResp" json:"BaseResp,omitempty" query:"BaseResp"` +} + +func NewCommitToolDraftResponse() *CommitToolDraftResponse { + return &CommitToolDraftResponse{} +} + +func (p *CommitToolDraftResponse) InitDefault() { +} + +var CommitToolDraftResponse_BaseResp_DEFAULT *base.BaseResp + +func (p *CommitToolDraftResponse) GetBaseResp() (v *base.BaseResp) { + if p == nil { + return + } + if !p.IsSetBaseResp() { + return CommitToolDraftResponse_BaseResp_DEFAULT + } + return p.BaseResp +} +func (p *CommitToolDraftResponse) SetBaseResp(val *base.BaseResp) { + p.BaseResp = val +} + +var fieldIDToName_CommitToolDraftResponse = map[int16]string{ + 255: "BaseResp", +} + +func (p *CommitToolDraftResponse) IsSetBaseResp() bool { + return p.BaseResp != nil +} + +func (p *CommitToolDraftResponse) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 255: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField255(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_CommitToolDraftResponse[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *CommitToolDraftResponse) ReadField255(iprot thrift.TProtocol) error { + _field := base.NewBaseResp() + if err := _field.Read(iprot); err != nil { + return err + } + p.BaseResp = _field + return nil +} + +func (p *CommitToolDraftResponse) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("CommitToolDraftResponse"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField255(oprot); err != nil { + fieldId = 255 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *CommitToolDraftResponse) writeField255(oprot thrift.TProtocol) (err error) { + if p.IsSetBaseResp() { + if err = oprot.WriteFieldBegin("BaseResp", thrift.STRUCT, 255); err != nil { + goto WriteFieldBeginError + } + if err := p.BaseResp.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 end error: ", p), err) +} + +func (p *CommitToolDraftResponse) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("CommitToolDraftResponse(%+v)", *p) + +} + +func (p *CommitToolDraftResponse) DeepEqual(ano *CommitToolDraftResponse) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field255DeepEqual(ano.BaseResp) { + return false + } + return true +} + +func (p *CommitToolDraftResponse) Field255DeepEqual(src *base.BaseResp) bool { + + if !p.BaseResp.DeepEqual(src) { + return false + } + return true +} + +type ListToolCommitRequest struct { + ToolID *int64 `thrift:"tool_id,1,optional" frugal:"1,optional,i64" json:"tool_id" path:"tool_id" ` + WorkspaceID *int64 `thrift:"workspace_id,2,optional" frugal:"2,optional,i64" json:"workspace_id" query:"workspace_id" ` + WithCommitDetail *bool `thrift:"with_commit_detail,3,optional" frugal:"3,optional,bool" json:"with_commit_detail,omitempty" query:"with_commit_detail"` + PageSize *int32 `thrift:"page_size,127,optional" frugal:"127,optional,i32" form:"page_size" json:"page_size,omitempty" query:"page_size"` + PageToken *string `thrift:"page_token,128,optional" frugal:"128,optional,string" form:"page_token" json:"page_token,omitempty" query:"page_token"` + Asc *bool `thrift:"asc,129,optional" frugal:"129,optional,bool" form:"asc" json:"asc,omitempty" query:"asc"` + Base *base.Base `thrift:"Base,255,optional" frugal:"255,optional,base.Base" form:"Base" json:"Base,omitempty" query:"Base"` +} + +func NewListToolCommitRequest() *ListToolCommitRequest { + return &ListToolCommitRequest{} +} + +func (p *ListToolCommitRequest) InitDefault() { +} + +var ListToolCommitRequest_ToolID_DEFAULT int64 + +func (p *ListToolCommitRequest) GetToolID() (v int64) { + if p == nil { + return + } + if !p.IsSetToolID() { + return ListToolCommitRequest_ToolID_DEFAULT + } + return *p.ToolID +} + +var ListToolCommitRequest_WorkspaceID_DEFAULT int64 + +func (p *ListToolCommitRequest) GetWorkspaceID() (v int64) { + if p == nil { + return + } + if !p.IsSetWorkspaceID() { + return ListToolCommitRequest_WorkspaceID_DEFAULT + } + return *p.WorkspaceID +} + +var ListToolCommitRequest_WithCommitDetail_DEFAULT bool + +func (p *ListToolCommitRequest) GetWithCommitDetail() (v bool) { + if p == nil { + return + } + if !p.IsSetWithCommitDetail() { + return ListToolCommitRequest_WithCommitDetail_DEFAULT + } + return *p.WithCommitDetail +} + +var ListToolCommitRequest_PageSize_DEFAULT int32 + +func (p *ListToolCommitRequest) GetPageSize() (v int32) { + if p == nil { + return + } + if !p.IsSetPageSize() { + return ListToolCommitRequest_PageSize_DEFAULT + } + return *p.PageSize +} + +var ListToolCommitRequest_PageToken_DEFAULT string + +func (p *ListToolCommitRequest) GetPageToken() (v string) { + if p == nil { + return + } + if !p.IsSetPageToken() { + return ListToolCommitRequest_PageToken_DEFAULT + } + return *p.PageToken +} + +var ListToolCommitRequest_Asc_DEFAULT bool + +func (p *ListToolCommitRequest) GetAsc() (v bool) { + if p == nil { + return + } + if !p.IsSetAsc() { + return ListToolCommitRequest_Asc_DEFAULT + } + return *p.Asc +} + +var ListToolCommitRequest_Base_DEFAULT *base.Base + +func (p *ListToolCommitRequest) GetBase() (v *base.Base) { + if p == nil { + return + } + if !p.IsSetBase() { + return ListToolCommitRequest_Base_DEFAULT + } + return p.Base +} +func (p *ListToolCommitRequest) SetToolID(val *int64) { + p.ToolID = val +} +func (p *ListToolCommitRequest) SetWorkspaceID(val *int64) { + p.WorkspaceID = val +} +func (p *ListToolCommitRequest) SetWithCommitDetail(val *bool) { + p.WithCommitDetail = val +} +func (p *ListToolCommitRequest) SetPageSize(val *int32) { + p.PageSize = val +} +func (p *ListToolCommitRequest) SetPageToken(val *string) { + p.PageToken = val +} +func (p *ListToolCommitRequest) SetAsc(val *bool) { + p.Asc = val +} +func (p *ListToolCommitRequest) SetBase(val *base.Base) { + p.Base = val +} + +var fieldIDToName_ListToolCommitRequest = map[int16]string{ + 1: "tool_id", + 2: "workspace_id", + 3: "with_commit_detail", + 127: "page_size", + 128: "page_token", + 129: "asc", + 255: "Base", +} + +func (p *ListToolCommitRequest) IsSetToolID() bool { + return p.ToolID != nil +} + +func (p *ListToolCommitRequest) IsSetWorkspaceID() bool { + return p.WorkspaceID != nil +} + +func (p *ListToolCommitRequest) IsSetWithCommitDetail() bool { + return p.WithCommitDetail != nil +} + +func (p *ListToolCommitRequest) IsSetPageSize() bool { + return p.PageSize != nil +} + +func (p *ListToolCommitRequest) IsSetPageToken() bool { + return p.PageToken != nil +} + +func (p *ListToolCommitRequest) IsSetAsc() bool { + return p.Asc != nil +} + +func (p *ListToolCommitRequest) IsSetBase() bool { + return p.Base != nil +} + +func (p *ListToolCommitRequest) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.I64 { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 2: + if fieldTypeId == thrift.I64 { + if err = p.ReadField2(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 3: + if fieldTypeId == thrift.BOOL { + if err = p.ReadField3(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 127: + if fieldTypeId == thrift.I32 { + if err = p.ReadField127(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 128: + if fieldTypeId == thrift.STRING { + if err = p.ReadField128(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 129: + if fieldTypeId == thrift.BOOL { + if err = p.ReadField129(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 255: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField255(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ListToolCommitRequest[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *ListToolCommitRequest) ReadField1(iprot thrift.TProtocol) error { + + var _field *int64 + if v, err := iprot.ReadI64(); err != nil { + return err + } else { + _field = &v + } + p.ToolID = _field + return nil +} +func (p *ListToolCommitRequest) ReadField2(iprot thrift.TProtocol) error { + + var _field *int64 + if v, err := iprot.ReadI64(); err != nil { + return err + } else { + _field = &v + } + p.WorkspaceID = _field + return nil +} +func (p *ListToolCommitRequest) ReadField3(iprot thrift.TProtocol) error { + + var _field *bool + if v, err := iprot.ReadBool(); err != nil { + return err + } else { + _field = &v + } + p.WithCommitDetail = _field + return nil +} +func (p *ListToolCommitRequest) ReadField127(iprot thrift.TProtocol) error { + + var _field *int32 + if v, err := iprot.ReadI32(); err != nil { + return err + } else { + _field = &v + } + p.PageSize = _field + return nil +} +func (p *ListToolCommitRequest) ReadField128(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.PageToken = _field + return nil +} +func (p *ListToolCommitRequest) ReadField129(iprot thrift.TProtocol) error { + + var _field *bool + if v, err := iprot.ReadBool(); err != nil { + return err + } else { + _field = &v + } + p.Asc = _field + return nil +} +func (p *ListToolCommitRequest) ReadField255(iprot thrift.TProtocol) error { + _field := base.NewBase() + if err := _field.Read(iprot); err != nil { + return err + } + p.Base = _field + return nil +} + +func (p *ListToolCommitRequest) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("ListToolCommitRequest"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + if err = p.writeField2(oprot); err != nil { + fieldId = 2 + goto WriteFieldError + } + if err = p.writeField3(oprot); err != nil { + fieldId = 3 + goto WriteFieldError + } + if err = p.writeField127(oprot); err != nil { + fieldId = 127 + goto WriteFieldError + } + if err = p.writeField128(oprot); err != nil { + fieldId = 128 + goto WriteFieldError + } + if err = p.writeField129(oprot); err != nil { + fieldId = 129 + goto WriteFieldError + } + if err = p.writeField255(oprot); err != nil { + fieldId = 255 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *ListToolCommitRequest) writeField1(oprot thrift.TProtocol) (err error) { + if p.IsSetToolID() { + if err = oprot.WriteFieldBegin("tool_id", thrift.I64, 1); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI64(*p.ToolID); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} +func (p *ListToolCommitRequest) writeField2(oprot thrift.TProtocol) (err error) { + if p.IsSetWorkspaceID() { + if err = oprot.WriteFieldBegin("workspace_id", thrift.I64, 2); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI64(*p.WorkspaceID); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err) +} +func (p *ListToolCommitRequest) writeField3(oprot thrift.TProtocol) (err error) { + if p.IsSetWithCommitDetail() { + if err = oprot.WriteFieldBegin("with_commit_detail", thrift.BOOL, 3); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteBool(*p.WithCommitDetail); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 3 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 3 end error: ", p), err) +} +func (p *ListToolCommitRequest) writeField127(oprot thrift.TProtocol) (err error) { + if p.IsSetPageSize() { + if err = oprot.WriteFieldBegin("page_size", thrift.I32, 127); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI32(*p.PageSize); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 127 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 127 end error: ", p), err) +} +func (p *ListToolCommitRequest) writeField128(oprot thrift.TProtocol) (err error) { + if p.IsSetPageToken() { + if err = oprot.WriteFieldBegin("page_token", thrift.STRING, 128); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.PageToken); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 128 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 128 end error: ", p), err) +} +func (p *ListToolCommitRequest) writeField129(oprot thrift.TProtocol) (err error) { + if p.IsSetAsc() { + if err = oprot.WriteFieldBegin("asc", thrift.BOOL, 129); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteBool(*p.Asc); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 129 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 129 end error: ", p), err) +} +func (p *ListToolCommitRequest) writeField255(oprot thrift.TProtocol) (err error) { + if p.IsSetBase() { + if err = oprot.WriteFieldBegin("Base", thrift.STRUCT, 255); err != nil { + goto WriteFieldBeginError + } + if err := p.Base.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 end error: ", p), err) +} + +func (p *ListToolCommitRequest) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("ListToolCommitRequest(%+v)", *p) + +} + +func (p *ListToolCommitRequest) DeepEqual(ano *ListToolCommitRequest) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.ToolID) { + return false + } + if !p.Field2DeepEqual(ano.WorkspaceID) { + return false + } + if !p.Field3DeepEqual(ano.WithCommitDetail) { + return false + } + if !p.Field127DeepEqual(ano.PageSize) { + return false + } + if !p.Field128DeepEqual(ano.PageToken) { + return false + } + if !p.Field129DeepEqual(ano.Asc) { + return false + } + if !p.Field255DeepEqual(ano.Base) { + return false + } + return true +} + +func (p *ListToolCommitRequest) Field1DeepEqual(src *int64) bool { + + if p.ToolID == src { + return true + } else if p.ToolID == nil || src == nil { + return false + } + if *p.ToolID != *src { + return false + } + return true +} +func (p *ListToolCommitRequest) Field2DeepEqual(src *int64) bool { + + if p.WorkspaceID == src { + return true + } else if p.WorkspaceID == nil || src == nil { + return false + } + if *p.WorkspaceID != *src { + return false + } + return true +} +func (p *ListToolCommitRequest) Field3DeepEqual(src *bool) bool { + + if p.WithCommitDetail == src { + return true + } else if p.WithCommitDetail == nil || src == nil { + return false + } + if *p.WithCommitDetail != *src { + return false + } + return true +} +func (p *ListToolCommitRequest) Field127DeepEqual(src *int32) bool { + + if p.PageSize == src { + return true + } else if p.PageSize == nil || src == nil { + return false + } + if *p.PageSize != *src { + return false + } + return true +} +func (p *ListToolCommitRequest) Field128DeepEqual(src *string) bool { + + if p.PageToken == src { + return true + } else if p.PageToken == nil || src == nil { + return false + } + if strings.Compare(*p.PageToken, *src) != 0 { + return false + } + return true +} +func (p *ListToolCommitRequest) Field129DeepEqual(src *bool) bool { + + if p.Asc == src { + return true + } else if p.Asc == nil || src == nil { + return false + } + if *p.Asc != *src { + return false + } + return true +} +func (p *ListToolCommitRequest) Field255DeepEqual(src *base.Base) bool { + + if !p.Base.DeepEqual(src) { + return false + } + return true +} + +type ListToolCommitResponse struct { + ToolCommitInfos []*tool.CommitInfo `thrift:"tool_commit_infos,1,optional" frugal:"1,optional,list" form:"tool_commit_infos" json:"tool_commit_infos,omitempty" query:"tool_commit_infos"` + ToolCommitDetailMapping map[string]*tool.ToolDetail `thrift:"tool_commit_detail_mapping,2,optional" frugal:"2,optional,map" form:"tool_commit_detail_mapping" json:"tool_commit_detail_mapping,omitempty" query:"tool_commit_detail_mapping"` + Users []*user.UserInfoDetail `thrift:"users,11,optional" frugal:"11,optional,list" form:"users" json:"users,omitempty" query:"users"` + HasMore *bool `thrift:"has_more,127,optional" frugal:"127,optional,bool" form:"has_more" json:"has_more,omitempty" query:"has_more"` + NextPageToken *string `thrift:"next_page_token,128,optional" frugal:"128,optional,string" form:"next_page_token" json:"next_page_token,omitempty" query:"next_page_token"` + BaseResp *base.BaseResp `thrift:"BaseResp,255,optional" frugal:"255,optional,base.BaseResp" form:"BaseResp" json:"BaseResp,omitempty" query:"BaseResp"` +} + +func NewListToolCommitResponse() *ListToolCommitResponse { + return &ListToolCommitResponse{} +} + +func (p *ListToolCommitResponse) InitDefault() { +} + +var ListToolCommitResponse_ToolCommitInfos_DEFAULT []*tool.CommitInfo + +func (p *ListToolCommitResponse) GetToolCommitInfos() (v []*tool.CommitInfo) { + if p == nil { + return + } + if !p.IsSetToolCommitInfos() { + return ListToolCommitResponse_ToolCommitInfos_DEFAULT + } + return p.ToolCommitInfos +} + +var ListToolCommitResponse_ToolCommitDetailMapping_DEFAULT map[string]*tool.ToolDetail + +func (p *ListToolCommitResponse) GetToolCommitDetailMapping() (v map[string]*tool.ToolDetail) { + if p == nil { + return + } + if !p.IsSetToolCommitDetailMapping() { + return ListToolCommitResponse_ToolCommitDetailMapping_DEFAULT + } + return p.ToolCommitDetailMapping +} + +var ListToolCommitResponse_Users_DEFAULT []*user.UserInfoDetail + +func (p *ListToolCommitResponse) GetUsers() (v []*user.UserInfoDetail) { + if p == nil { + return + } + if !p.IsSetUsers() { + return ListToolCommitResponse_Users_DEFAULT + } + return p.Users +} + +var ListToolCommitResponse_HasMore_DEFAULT bool + +func (p *ListToolCommitResponse) GetHasMore() (v bool) { + if p == nil { + return + } + if !p.IsSetHasMore() { + return ListToolCommitResponse_HasMore_DEFAULT + } + return *p.HasMore +} + +var ListToolCommitResponse_NextPageToken_DEFAULT string + +func (p *ListToolCommitResponse) GetNextPageToken() (v string) { + if p == nil { + return + } + if !p.IsSetNextPageToken() { + return ListToolCommitResponse_NextPageToken_DEFAULT + } + return *p.NextPageToken +} + +var ListToolCommitResponse_BaseResp_DEFAULT *base.BaseResp + +func (p *ListToolCommitResponse) GetBaseResp() (v *base.BaseResp) { + if p == nil { + return + } + if !p.IsSetBaseResp() { + return ListToolCommitResponse_BaseResp_DEFAULT + } + return p.BaseResp +} +func (p *ListToolCommitResponse) SetToolCommitInfos(val []*tool.CommitInfo) { + p.ToolCommitInfos = val +} +func (p *ListToolCommitResponse) SetToolCommitDetailMapping(val map[string]*tool.ToolDetail) { + p.ToolCommitDetailMapping = val +} +func (p *ListToolCommitResponse) SetUsers(val []*user.UserInfoDetail) { + p.Users = val +} +func (p *ListToolCommitResponse) SetHasMore(val *bool) { + p.HasMore = val +} +func (p *ListToolCommitResponse) SetNextPageToken(val *string) { + p.NextPageToken = val +} +func (p *ListToolCommitResponse) SetBaseResp(val *base.BaseResp) { + p.BaseResp = val +} + +var fieldIDToName_ListToolCommitResponse = map[int16]string{ + 1: "tool_commit_infos", + 2: "tool_commit_detail_mapping", + 11: "users", + 127: "has_more", + 128: "next_page_token", + 255: "BaseResp", +} + +func (p *ListToolCommitResponse) IsSetToolCommitInfos() bool { + return p.ToolCommitInfos != nil +} + +func (p *ListToolCommitResponse) IsSetToolCommitDetailMapping() bool { + return p.ToolCommitDetailMapping != nil +} + +func (p *ListToolCommitResponse) IsSetUsers() bool { + return p.Users != nil +} + +func (p *ListToolCommitResponse) IsSetHasMore() bool { + return p.HasMore != nil +} + +func (p *ListToolCommitResponse) IsSetNextPageToken() bool { + return p.NextPageToken != nil +} + +func (p *ListToolCommitResponse) IsSetBaseResp() bool { + return p.BaseResp != nil +} + +func (p *ListToolCommitResponse) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.LIST { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 2: + if fieldTypeId == thrift.MAP { + if err = p.ReadField2(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 11: + if fieldTypeId == thrift.LIST { + if err = p.ReadField11(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 127: + if fieldTypeId == thrift.BOOL { + if err = p.ReadField127(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 128: + if fieldTypeId == thrift.STRING { + if err = p.ReadField128(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 255: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField255(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ListToolCommitResponse[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *ListToolCommitResponse) ReadField1(iprot thrift.TProtocol) error { + _, size, err := iprot.ReadListBegin() + if err != nil { + return err + } + _field := make([]*tool.CommitInfo, 0, size) + values := make([]tool.CommitInfo, size) + for i := 0; i < size; i++ { + _elem := &values[i] + _elem.InitDefault() + + if err := _elem.Read(iprot); err != nil { + return err + } + + _field = append(_field, _elem) + } + if err := iprot.ReadListEnd(); err != nil { + return err + } + p.ToolCommitInfos = _field + return nil +} +func (p *ListToolCommitResponse) ReadField2(iprot thrift.TProtocol) error { + _, _, size, err := iprot.ReadMapBegin() + if err != nil { + return err + } + _field := make(map[string]*tool.ToolDetail, size) + values := make([]tool.ToolDetail, size) + for i := 0; i < size; i++ { + var _key string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _key = v + } + + _val := &values[i] + _val.InitDefault() + if err := _val.Read(iprot); err != nil { + return err + } + + _field[_key] = _val + } + if err := iprot.ReadMapEnd(); err != nil { + return err + } + p.ToolCommitDetailMapping = _field + return nil +} +func (p *ListToolCommitResponse) ReadField11(iprot thrift.TProtocol) error { + _, size, err := iprot.ReadListBegin() + if err != nil { + return err + } + _field := make([]*user.UserInfoDetail, 0, size) + values := make([]user.UserInfoDetail, size) + for i := 0; i < size; i++ { + _elem := &values[i] + _elem.InitDefault() + + if err := _elem.Read(iprot); err != nil { + return err + } + + _field = append(_field, _elem) + } + if err := iprot.ReadListEnd(); err != nil { + return err + } + p.Users = _field + return nil +} +func (p *ListToolCommitResponse) ReadField127(iprot thrift.TProtocol) error { + + var _field *bool + if v, err := iprot.ReadBool(); err != nil { + return err + } else { + _field = &v + } + p.HasMore = _field + return nil +} +func (p *ListToolCommitResponse) ReadField128(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.NextPageToken = _field + return nil +} +func (p *ListToolCommitResponse) ReadField255(iprot thrift.TProtocol) error { + _field := base.NewBaseResp() + if err := _field.Read(iprot); err != nil { + return err + } + p.BaseResp = _field + return nil +} + +func (p *ListToolCommitResponse) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("ListToolCommitResponse"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + if err = p.writeField2(oprot); err != nil { + fieldId = 2 + goto WriteFieldError + } + if err = p.writeField11(oprot); err != nil { + fieldId = 11 + goto WriteFieldError + } + if err = p.writeField127(oprot); err != nil { + fieldId = 127 + goto WriteFieldError + } + if err = p.writeField128(oprot); err != nil { + fieldId = 128 + goto WriteFieldError + } + if err = p.writeField255(oprot); err != nil { + fieldId = 255 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *ListToolCommitResponse) writeField1(oprot thrift.TProtocol) (err error) { + if p.IsSetToolCommitInfos() { + if err = oprot.WriteFieldBegin("tool_commit_infos", thrift.LIST, 1); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteListBegin(thrift.STRUCT, len(p.ToolCommitInfos)); err != nil { + return err + } + for _, v := range p.ToolCommitInfos { + if err := v.Write(oprot); err != nil { + return err + } + } + if err := oprot.WriteListEnd(); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} +func (p *ListToolCommitResponse) writeField2(oprot thrift.TProtocol) (err error) { + if p.IsSetToolCommitDetailMapping() { + if err = oprot.WriteFieldBegin("tool_commit_detail_mapping", thrift.MAP, 2); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteMapBegin(thrift.STRING, thrift.STRUCT, len(p.ToolCommitDetailMapping)); err != nil { + return err + } + for k, v := range p.ToolCommitDetailMapping { + if err := oprot.WriteString(k); err != nil { + return err + } + if err := v.Write(oprot); err != nil { + return err + } + } + if err := oprot.WriteMapEnd(); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err) +} +func (p *ListToolCommitResponse) writeField11(oprot thrift.TProtocol) (err error) { + if p.IsSetUsers() { + if err = oprot.WriteFieldBegin("users", thrift.LIST, 11); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteListBegin(thrift.STRUCT, len(p.Users)); err != nil { + return err + } + for _, v := range p.Users { + if err := v.Write(oprot); err != nil { + return err + } + } + if err := oprot.WriteListEnd(); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 11 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 11 end error: ", p), err) +} +func (p *ListToolCommitResponse) writeField127(oprot thrift.TProtocol) (err error) { + if p.IsSetHasMore() { + if err = oprot.WriteFieldBegin("has_more", thrift.BOOL, 127); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteBool(*p.HasMore); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 127 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 127 end error: ", p), err) +} +func (p *ListToolCommitResponse) writeField128(oprot thrift.TProtocol) (err error) { + if p.IsSetNextPageToken() { + if err = oprot.WriteFieldBegin("next_page_token", thrift.STRING, 128); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.NextPageToken); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 128 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 128 end error: ", p), err) +} +func (p *ListToolCommitResponse) writeField255(oprot thrift.TProtocol) (err error) { + if p.IsSetBaseResp() { + if err = oprot.WriteFieldBegin("BaseResp", thrift.STRUCT, 255); err != nil { + goto WriteFieldBeginError + } + if err := p.BaseResp.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 end error: ", p), err) +} + +func (p *ListToolCommitResponse) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("ListToolCommitResponse(%+v)", *p) + +} + +func (p *ListToolCommitResponse) DeepEqual(ano *ListToolCommitResponse) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.ToolCommitInfos) { + return false + } + if !p.Field2DeepEqual(ano.ToolCommitDetailMapping) { + return false + } + if !p.Field11DeepEqual(ano.Users) { + return false + } + if !p.Field127DeepEqual(ano.HasMore) { + return false + } + if !p.Field128DeepEqual(ano.NextPageToken) { + return false + } + if !p.Field255DeepEqual(ano.BaseResp) { + return false + } + return true +} + +func (p *ListToolCommitResponse) Field1DeepEqual(src []*tool.CommitInfo) bool { + + if len(p.ToolCommitInfos) != len(src) { + return false + } + for i, v := range p.ToolCommitInfos { + _src := src[i] + if !v.DeepEqual(_src) { + return false + } + } + return true +} +func (p *ListToolCommitResponse) Field2DeepEqual(src map[string]*tool.ToolDetail) bool { + + if len(p.ToolCommitDetailMapping) != len(src) { + return false + } + for k, v := range p.ToolCommitDetailMapping { + _src := src[k] + if !v.DeepEqual(_src) { + return false + } + } + return true +} +func (p *ListToolCommitResponse) Field11DeepEqual(src []*user.UserInfoDetail) bool { + + if len(p.Users) != len(src) { + return false + } + for i, v := range p.Users { + _src := src[i] + if !v.DeepEqual(_src) { + return false + } + } + return true +} +func (p *ListToolCommitResponse) Field127DeepEqual(src *bool) bool { + + if p.HasMore == src { + return true + } else if p.HasMore == nil || src == nil { + return false + } + if *p.HasMore != *src { + return false + } + return true +} +func (p *ListToolCommitResponse) Field128DeepEqual(src *string) bool { + + if p.NextPageToken == src { + return true + } else if p.NextPageToken == nil || src == nil { + return false + } + if strings.Compare(*p.NextPageToken, *src) != 0 { + return false + } + return true +} +func (p *ListToolCommitResponse) Field255DeepEqual(src *base.BaseResp) bool { + + if !p.BaseResp.DeepEqual(src) { + return false + } + return true +} + +type ToolManageService interface { + CreateTool(ctx context.Context, request *CreateToolRequest) (r *CreateToolResponse, err error) + + GetToolDetail(ctx context.Context, request *GetToolDetailRequest) (r *GetToolDetailResponse, err error) + + ListTool(ctx context.Context, request *ListToolRequest) (r *ListToolResponse, err error) + + SaveToolDetail(ctx context.Context, request *SaveToolDetailRequest) (r *SaveToolDetailResponse, err error) + + CommitToolDraft(ctx context.Context, request *CommitToolDraftRequest) (r *CommitToolDraftResponse, err error) + + ListToolCommit(ctx context.Context, request *ListToolCommitRequest) (r *ListToolCommitResponse, err error) +} + +type ToolManageServiceClient struct { + c thrift.TClient +} + +func NewToolManageServiceClientFactory(t thrift.TTransport, f thrift.TProtocolFactory) *ToolManageServiceClient { + return &ToolManageServiceClient{ + c: thrift.NewTStandardClient(f.GetProtocol(t), f.GetProtocol(t)), + } +} + +func NewToolManageServiceClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *ToolManageServiceClient { + return &ToolManageServiceClient{ + c: thrift.NewTStandardClient(iprot, oprot), + } +} + +func NewToolManageServiceClient(c thrift.TClient) *ToolManageServiceClient { + return &ToolManageServiceClient{ + c: c, + } +} + +func (p *ToolManageServiceClient) Client_() thrift.TClient { + return p.c +} + +func (p *ToolManageServiceClient) CreateTool(ctx context.Context, request *CreateToolRequest) (r *CreateToolResponse, err error) { + var _args ToolManageServiceCreateToolArgs + _args.Request = request + var _result ToolManageServiceCreateToolResult + if err = p.Client_().Call(ctx, "CreateTool", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} +func (p *ToolManageServiceClient) GetToolDetail(ctx context.Context, request *GetToolDetailRequest) (r *GetToolDetailResponse, err error) { + var _args ToolManageServiceGetToolDetailArgs + _args.Request = request + var _result ToolManageServiceGetToolDetailResult + if err = p.Client_().Call(ctx, "GetToolDetail", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} +func (p *ToolManageServiceClient) ListTool(ctx context.Context, request *ListToolRequest) (r *ListToolResponse, err error) { + var _args ToolManageServiceListToolArgs + _args.Request = request + var _result ToolManageServiceListToolResult + if err = p.Client_().Call(ctx, "ListTool", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} +func (p *ToolManageServiceClient) SaveToolDetail(ctx context.Context, request *SaveToolDetailRequest) (r *SaveToolDetailResponse, err error) { + var _args ToolManageServiceSaveToolDetailArgs + _args.Request = request + var _result ToolManageServiceSaveToolDetailResult + if err = p.Client_().Call(ctx, "SaveToolDetail", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} +func (p *ToolManageServiceClient) CommitToolDraft(ctx context.Context, request *CommitToolDraftRequest) (r *CommitToolDraftResponse, err error) { + var _args ToolManageServiceCommitToolDraftArgs + _args.Request = request + var _result ToolManageServiceCommitToolDraftResult + if err = p.Client_().Call(ctx, "CommitToolDraft", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} +func (p *ToolManageServiceClient) ListToolCommit(ctx context.Context, request *ListToolCommitRequest) (r *ListToolCommitResponse, err error) { + var _args ToolManageServiceListToolCommitArgs + _args.Request = request + var _result ToolManageServiceListToolCommitResult + if err = p.Client_().Call(ctx, "ListToolCommit", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} + +type ToolManageServiceProcessor struct { + processorMap map[string]thrift.TProcessorFunction + handler ToolManageService +} + +func (p *ToolManageServiceProcessor) AddToProcessorMap(key string, processor thrift.TProcessorFunction) { + p.processorMap[key] = processor +} + +func (p *ToolManageServiceProcessor) GetProcessorFunction(key string) (processor thrift.TProcessorFunction, ok bool) { + processor, ok = p.processorMap[key] + return processor, ok +} + +func (p *ToolManageServiceProcessor) ProcessorMap() map[string]thrift.TProcessorFunction { + return p.processorMap +} + +func NewToolManageServiceProcessor(handler ToolManageService) *ToolManageServiceProcessor { + self := &ToolManageServiceProcessor{handler: handler, processorMap: make(map[string]thrift.TProcessorFunction)} + self.AddToProcessorMap("CreateTool", &toolManageServiceProcessorCreateTool{handler: handler}) + self.AddToProcessorMap("GetToolDetail", &toolManageServiceProcessorGetToolDetail{handler: handler}) + self.AddToProcessorMap("ListTool", &toolManageServiceProcessorListTool{handler: handler}) + self.AddToProcessorMap("SaveToolDetail", &toolManageServiceProcessorSaveToolDetail{handler: handler}) + self.AddToProcessorMap("CommitToolDraft", &toolManageServiceProcessorCommitToolDraft{handler: handler}) + self.AddToProcessorMap("ListToolCommit", &toolManageServiceProcessorListToolCommit{handler: handler}) + return self +} +func (p *ToolManageServiceProcessor) Process(ctx context.Context, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + name, _, seqId, err := iprot.ReadMessageBegin() + if err != nil { + return false, err + } + if processor, ok := p.GetProcessorFunction(name); ok { + return processor.Process(ctx, seqId, iprot, oprot) + } + iprot.Skip(thrift.STRUCT) + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.UNKNOWN_METHOD, "Unknown function "+name) + oprot.WriteMessageBegin(name, thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return false, x +} + +type toolManageServiceProcessorCreateTool struct { + handler ToolManageService +} + +func (p *toolManageServiceProcessorCreateTool) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := ToolManageServiceCreateToolArgs{} + if err = args.Read(iprot); err != nil { + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) + oprot.WriteMessageBegin("CreateTool", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return false, err + } + + iprot.ReadMessageEnd() + var err2 error + result := ToolManageServiceCreateToolResult{} + var retval *CreateToolResponse + if retval, err2 = p.handler.CreateTool(ctx, args.Request); err2 != nil { + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing CreateTool: "+err2.Error()) + oprot.WriteMessageBegin("CreateTool", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return true, err2 + } else { + result.Success = retval + } + if err2 = oprot.WriteMessageBegin("CreateTool", thrift.REPLY, seqId); err2 != nil { + err = err2 + } + if err2 = result.Write(oprot); err == nil && err2 != nil { + err = err2 + } + if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil { + err = err2 + } + if err2 = oprot.Flush(ctx); err == nil && err2 != nil { + err = err2 + } + if err != nil { + return + } + return true, err +} + +type toolManageServiceProcessorGetToolDetail struct { + handler ToolManageService +} + +func (p *toolManageServiceProcessorGetToolDetail) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := ToolManageServiceGetToolDetailArgs{} + if err = args.Read(iprot); err != nil { + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) + oprot.WriteMessageBegin("GetToolDetail", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return false, err + } + + iprot.ReadMessageEnd() + var err2 error + result := ToolManageServiceGetToolDetailResult{} + var retval *GetToolDetailResponse + if retval, err2 = p.handler.GetToolDetail(ctx, args.Request); err2 != nil { + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing GetToolDetail: "+err2.Error()) + oprot.WriteMessageBegin("GetToolDetail", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return true, err2 + } else { + result.Success = retval + } + if err2 = oprot.WriteMessageBegin("GetToolDetail", thrift.REPLY, seqId); err2 != nil { + err = err2 + } + if err2 = result.Write(oprot); err == nil && err2 != nil { + err = err2 + } + if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil { + err = err2 + } + if err2 = oprot.Flush(ctx); err == nil && err2 != nil { + err = err2 + } + if err != nil { + return + } + return true, err +} + +type toolManageServiceProcessorListTool struct { + handler ToolManageService +} + +func (p *toolManageServiceProcessorListTool) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := ToolManageServiceListToolArgs{} + if err = args.Read(iprot); err != nil { + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) + oprot.WriteMessageBegin("ListTool", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return false, err + } + + iprot.ReadMessageEnd() + var err2 error + result := ToolManageServiceListToolResult{} + var retval *ListToolResponse + if retval, err2 = p.handler.ListTool(ctx, args.Request); err2 != nil { + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing ListTool: "+err2.Error()) + oprot.WriteMessageBegin("ListTool", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return true, err2 + } else { + result.Success = retval + } + if err2 = oprot.WriteMessageBegin("ListTool", thrift.REPLY, seqId); err2 != nil { + err = err2 + } + if err2 = result.Write(oprot); err == nil && err2 != nil { + err = err2 + } + if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil { + err = err2 + } + if err2 = oprot.Flush(ctx); err == nil && err2 != nil { + err = err2 + } + if err != nil { + return + } + return true, err +} + +type toolManageServiceProcessorSaveToolDetail struct { + handler ToolManageService +} + +func (p *toolManageServiceProcessorSaveToolDetail) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := ToolManageServiceSaveToolDetailArgs{} + if err = args.Read(iprot); err != nil { + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) + oprot.WriteMessageBegin("SaveToolDetail", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return false, err + } + + iprot.ReadMessageEnd() + var err2 error + result := ToolManageServiceSaveToolDetailResult{} + var retval *SaveToolDetailResponse + if retval, err2 = p.handler.SaveToolDetail(ctx, args.Request); err2 != nil { + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing SaveToolDetail: "+err2.Error()) + oprot.WriteMessageBegin("SaveToolDetail", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return true, err2 + } else { + result.Success = retval + } + if err2 = oprot.WriteMessageBegin("SaveToolDetail", thrift.REPLY, seqId); err2 != nil { + err = err2 + } + if err2 = result.Write(oprot); err == nil && err2 != nil { + err = err2 + } + if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil { + err = err2 + } + if err2 = oprot.Flush(ctx); err == nil && err2 != nil { + err = err2 + } + if err != nil { + return + } + return true, err +} + +type toolManageServiceProcessorCommitToolDraft struct { + handler ToolManageService +} + +func (p *toolManageServiceProcessorCommitToolDraft) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := ToolManageServiceCommitToolDraftArgs{} + if err = args.Read(iprot); err != nil { + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) + oprot.WriteMessageBegin("CommitToolDraft", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return false, err + } + + iprot.ReadMessageEnd() + var err2 error + result := ToolManageServiceCommitToolDraftResult{} + var retval *CommitToolDraftResponse + if retval, err2 = p.handler.CommitToolDraft(ctx, args.Request); err2 != nil { + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing CommitToolDraft: "+err2.Error()) + oprot.WriteMessageBegin("CommitToolDraft", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return true, err2 + } else { + result.Success = retval + } + if err2 = oprot.WriteMessageBegin("CommitToolDraft", thrift.REPLY, seqId); err2 != nil { + err = err2 + } + if err2 = result.Write(oprot); err == nil && err2 != nil { + err = err2 + } + if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil { + err = err2 + } + if err2 = oprot.Flush(ctx); err == nil && err2 != nil { + err = err2 + } + if err != nil { + return + } + return true, err +} + +type toolManageServiceProcessorListToolCommit struct { + handler ToolManageService +} + +func (p *toolManageServiceProcessorListToolCommit) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := ToolManageServiceListToolCommitArgs{} + if err = args.Read(iprot); err != nil { + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) + oprot.WriteMessageBegin("ListToolCommit", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return false, err + } + + iprot.ReadMessageEnd() + var err2 error + result := ToolManageServiceListToolCommitResult{} + var retval *ListToolCommitResponse + if retval, err2 = p.handler.ListToolCommit(ctx, args.Request); err2 != nil { + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing ListToolCommit: "+err2.Error()) + oprot.WriteMessageBegin("ListToolCommit", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return true, err2 + } else { + result.Success = retval + } + if err2 = oprot.WriteMessageBegin("ListToolCommit", thrift.REPLY, seqId); err2 != nil { + err = err2 + } + if err2 = result.Write(oprot); err == nil && err2 != nil { + err = err2 + } + if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil { + err = err2 + } + if err2 = oprot.Flush(ctx); err == nil && err2 != nil { + err = err2 + } + if err != nil { + return + } + return true, err +} + +type ToolManageServiceCreateToolArgs struct { + Request *CreateToolRequest `thrift:"request,1" frugal:"1,default,CreateToolRequest"` +} + +func NewToolManageServiceCreateToolArgs() *ToolManageServiceCreateToolArgs { + return &ToolManageServiceCreateToolArgs{} +} + +func (p *ToolManageServiceCreateToolArgs) InitDefault() { +} + +var ToolManageServiceCreateToolArgs_Request_DEFAULT *CreateToolRequest + +func (p *ToolManageServiceCreateToolArgs) GetRequest() (v *CreateToolRequest) { + if p == nil { + return + } + if !p.IsSetRequest() { + return ToolManageServiceCreateToolArgs_Request_DEFAULT + } + return p.Request +} +func (p *ToolManageServiceCreateToolArgs) SetRequest(val *CreateToolRequest) { + p.Request = val +} + +var fieldIDToName_ToolManageServiceCreateToolArgs = map[int16]string{ + 1: "request", +} + +func (p *ToolManageServiceCreateToolArgs) IsSetRequest() bool { + return p.Request != nil +} + +func (p *ToolManageServiceCreateToolArgs) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceCreateToolArgs[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *ToolManageServiceCreateToolArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewCreateToolRequest() + if err := _field.Read(iprot); err != nil { + return err + } + p.Request = _field + return nil +} + +func (p *ToolManageServiceCreateToolArgs) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("CreateTool_args"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *ToolManageServiceCreateToolArgs) writeField1(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { + goto WriteFieldBeginError + } + if err := p.Request.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} + +func (p *ToolManageServiceCreateToolArgs) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("ToolManageServiceCreateToolArgs(%+v)", *p) + +} + +func (p *ToolManageServiceCreateToolArgs) DeepEqual(ano *ToolManageServiceCreateToolArgs) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.Request) { + return false + } + return true +} + +func (p *ToolManageServiceCreateToolArgs) Field1DeepEqual(src *CreateToolRequest) bool { + + if !p.Request.DeepEqual(src) { + return false + } + return true +} + +type ToolManageServiceCreateToolResult struct { + Success *CreateToolResponse `thrift:"success,0,optional" frugal:"0,optional,CreateToolResponse"` +} + +func NewToolManageServiceCreateToolResult() *ToolManageServiceCreateToolResult { + return &ToolManageServiceCreateToolResult{} +} + +func (p *ToolManageServiceCreateToolResult) InitDefault() { +} + +var ToolManageServiceCreateToolResult_Success_DEFAULT *CreateToolResponse + +func (p *ToolManageServiceCreateToolResult) GetSuccess() (v *CreateToolResponse) { + if p == nil { + return + } + if !p.IsSetSuccess() { + return ToolManageServiceCreateToolResult_Success_DEFAULT + } + return p.Success +} +func (p *ToolManageServiceCreateToolResult) SetSuccess(x interface{}) { + p.Success = x.(*CreateToolResponse) +} + +var fieldIDToName_ToolManageServiceCreateToolResult = map[int16]string{ + 0: "success", +} + +func (p *ToolManageServiceCreateToolResult) IsSetSuccess() bool { + return p.Success != nil +} + +func (p *ToolManageServiceCreateToolResult) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 0: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField0(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceCreateToolResult[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *ToolManageServiceCreateToolResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewCreateToolResponse() + if err := _field.Read(iprot); err != nil { + return err + } + p.Success = _field + return nil +} + +func (p *ToolManageServiceCreateToolResult) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("CreateTool_result"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField0(oprot); err != nil { + fieldId = 0 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *ToolManageServiceCreateToolResult) writeField0(oprot thrift.TProtocol) (err error) { + if p.IsSetSuccess() { + if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { + goto WriteFieldBeginError + } + if err := p.Success.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 0 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) +} + +func (p *ToolManageServiceCreateToolResult) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("ToolManageServiceCreateToolResult(%+v)", *p) + +} + +func (p *ToolManageServiceCreateToolResult) DeepEqual(ano *ToolManageServiceCreateToolResult) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field0DeepEqual(ano.Success) { + return false + } + return true +} + +func (p *ToolManageServiceCreateToolResult) Field0DeepEqual(src *CreateToolResponse) bool { + + if !p.Success.DeepEqual(src) { + return false + } + return true +} + +type ToolManageServiceGetToolDetailArgs struct { + Request *GetToolDetailRequest `thrift:"request,1" frugal:"1,default,GetToolDetailRequest"` +} + +func NewToolManageServiceGetToolDetailArgs() *ToolManageServiceGetToolDetailArgs { + return &ToolManageServiceGetToolDetailArgs{} +} + +func (p *ToolManageServiceGetToolDetailArgs) InitDefault() { +} + +var ToolManageServiceGetToolDetailArgs_Request_DEFAULT *GetToolDetailRequest + +func (p *ToolManageServiceGetToolDetailArgs) GetRequest() (v *GetToolDetailRequest) { + if p == nil { + return + } + if !p.IsSetRequest() { + return ToolManageServiceGetToolDetailArgs_Request_DEFAULT + } + return p.Request +} +func (p *ToolManageServiceGetToolDetailArgs) SetRequest(val *GetToolDetailRequest) { + p.Request = val +} + +var fieldIDToName_ToolManageServiceGetToolDetailArgs = map[int16]string{ + 1: "request", +} + +func (p *ToolManageServiceGetToolDetailArgs) IsSetRequest() bool { + return p.Request != nil +} + +func (p *ToolManageServiceGetToolDetailArgs) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceGetToolDetailArgs[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *ToolManageServiceGetToolDetailArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewGetToolDetailRequest() + if err := _field.Read(iprot); err != nil { + return err + } + p.Request = _field + return nil +} + +func (p *ToolManageServiceGetToolDetailArgs) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("GetToolDetail_args"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *ToolManageServiceGetToolDetailArgs) writeField1(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { + goto WriteFieldBeginError + } + if err := p.Request.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} + +func (p *ToolManageServiceGetToolDetailArgs) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("ToolManageServiceGetToolDetailArgs(%+v)", *p) + +} + +func (p *ToolManageServiceGetToolDetailArgs) DeepEqual(ano *ToolManageServiceGetToolDetailArgs) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.Request) { + return false + } + return true +} + +func (p *ToolManageServiceGetToolDetailArgs) Field1DeepEqual(src *GetToolDetailRequest) bool { + + if !p.Request.DeepEqual(src) { + return false + } + return true +} + +type ToolManageServiceGetToolDetailResult struct { + Success *GetToolDetailResponse `thrift:"success,0,optional" frugal:"0,optional,GetToolDetailResponse"` +} + +func NewToolManageServiceGetToolDetailResult() *ToolManageServiceGetToolDetailResult { + return &ToolManageServiceGetToolDetailResult{} +} + +func (p *ToolManageServiceGetToolDetailResult) InitDefault() { +} + +var ToolManageServiceGetToolDetailResult_Success_DEFAULT *GetToolDetailResponse + +func (p *ToolManageServiceGetToolDetailResult) GetSuccess() (v *GetToolDetailResponse) { + if p == nil { + return + } + if !p.IsSetSuccess() { + return ToolManageServiceGetToolDetailResult_Success_DEFAULT + } + return p.Success +} +func (p *ToolManageServiceGetToolDetailResult) SetSuccess(x interface{}) { + p.Success = x.(*GetToolDetailResponse) +} + +var fieldIDToName_ToolManageServiceGetToolDetailResult = map[int16]string{ + 0: "success", +} + +func (p *ToolManageServiceGetToolDetailResult) IsSetSuccess() bool { + return p.Success != nil +} + +func (p *ToolManageServiceGetToolDetailResult) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 0: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField0(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceGetToolDetailResult[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *ToolManageServiceGetToolDetailResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewGetToolDetailResponse() + if err := _field.Read(iprot); err != nil { + return err + } + p.Success = _field + return nil +} + +func (p *ToolManageServiceGetToolDetailResult) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("GetToolDetail_result"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField0(oprot); err != nil { + fieldId = 0 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *ToolManageServiceGetToolDetailResult) writeField0(oprot thrift.TProtocol) (err error) { + if p.IsSetSuccess() { + if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { + goto WriteFieldBeginError + } + if err := p.Success.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 0 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) +} + +func (p *ToolManageServiceGetToolDetailResult) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("ToolManageServiceGetToolDetailResult(%+v)", *p) + +} + +func (p *ToolManageServiceGetToolDetailResult) DeepEqual(ano *ToolManageServiceGetToolDetailResult) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field0DeepEqual(ano.Success) { + return false + } + return true +} + +func (p *ToolManageServiceGetToolDetailResult) Field0DeepEqual(src *GetToolDetailResponse) bool { + + if !p.Success.DeepEqual(src) { + return false + } + return true +} + +type ToolManageServiceListToolArgs struct { + Request *ListToolRequest `thrift:"request,1" frugal:"1,default,ListToolRequest"` +} + +func NewToolManageServiceListToolArgs() *ToolManageServiceListToolArgs { + return &ToolManageServiceListToolArgs{} +} + +func (p *ToolManageServiceListToolArgs) InitDefault() { +} + +var ToolManageServiceListToolArgs_Request_DEFAULT *ListToolRequest + +func (p *ToolManageServiceListToolArgs) GetRequest() (v *ListToolRequest) { + if p == nil { + return + } + if !p.IsSetRequest() { + return ToolManageServiceListToolArgs_Request_DEFAULT + } + return p.Request +} +func (p *ToolManageServiceListToolArgs) SetRequest(val *ListToolRequest) { + p.Request = val +} + +var fieldIDToName_ToolManageServiceListToolArgs = map[int16]string{ + 1: "request", +} + +func (p *ToolManageServiceListToolArgs) IsSetRequest() bool { + return p.Request != nil +} + +func (p *ToolManageServiceListToolArgs) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceListToolArgs[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *ToolManageServiceListToolArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewListToolRequest() + if err := _field.Read(iprot); err != nil { + return err + } + p.Request = _field + return nil +} + +func (p *ToolManageServiceListToolArgs) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("ListTool_args"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *ToolManageServiceListToolArgs) writeField1(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { + goto WriteFieldBeginError + } + if err := p.Request.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} + +func (p *ToolManageServiceListToolArgs) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("ToolManageServiceListToolArgs(%+v)", *p) + +} + +func (p *ToolManageServiceListToolArgs) DeepEqual(ano *ToolManageServiceListToolArgs) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.Request) { + return false + } + return true +} + +func (p *ToolManageServiceListToolArgs) Field1DeepEqual(src *ListToolRequest) bool { + + if !p.Request.DeepEqual(src) { + return false + } + return true +} + +type ToolManageServiceListToolResult struct { + Success *ListToolResponse `thrift:"success,0,optional" frugal:"0,optional,ListToolResponse"` +} + +func NewToolManageServiceListToolResult() *ToolManageServiceListToolResult { + return &ToolManageServiceListToolResult{} +} + +func (p *ToolManageServiceListToolResult) InitDefault() { +} + +var ToolManageServiceListToolResult_Success_DEFAULT *ListToolResponse + +func (p *ToolManageServiceListToolResult) GetSuccess() (v *ListToolResponse) { + if p == nil { + return + } + if !p.IsSetSuccess() { + return ToolManageServiceListToolResult_Success_DEFAULT + } + return p.Success +} +func (p *ToolManageServiceListToolResult) SetSuccess(x interface{}) { + p.Success = x.(*ListToolResponse) +} + +var fieldIDToName_ToolManageServiceListToolResult = map[int16]string{ + 0: "success", +} + +func (p *ToolManageServiceListToolResult) IsSetSuccess() bool { + return p.Success != nil +} + +func (p *ToolManageServiceListToolResult) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 0: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField0(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceListToolResult[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *ToolManageServiceListToolResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewListToolResponse() + if err := _field.Read(iprot); err != nil { + return err + } + p.Success = _field + return nil +} + +func (p *ToolManageServiceListToolResult) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("ListTool_result"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField0(oprot); err != nil { + fieldId = 0 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *ToolManageServiceListToolResult) writeField0(oprot thrift.TProtocol) (err error) { + if p.IsSetSuccess() { + if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { + goto WriteFieldBeginError + } + if err := p.Success.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 0 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) +} + +func (p *ToolManageServiceListToolResult) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("ToolManageServiceListToolResult(%+v)", *p) + +} + +func (p *ToolManageServiceListToolResult) DeepEqual(ano *ToolManageServiceListToolResult) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field0DeepEqual(ano.Success) { + return false + } + return true +} + +func (p *ToolManageServiceListToolResult) Field0DeepEqual(src *ListToolResponse) bool { + + if !p.Success.DeepEqual(src) { + return false + } + return true +} + +type ToolManageServiceSaveToolDetailArgs struct { + Request *SaveToolDetailRequest `thrift:"request,1" frugal:"1,default,SaveToolDetailRequest"` +} + +func NewToolManageServiceSaveToolDetailArgs() *ToolManageServiceSaveToolDetailArgs { + return &ToolManageServiceSaveToolDetailArgs{} +} + +func (p *ToolManageServiceSaveToolDetailArgs) InitDefault() { +} + +var ToolManageServiceSaveToolDetailArgs_Request_DEFAULT *SaveToolDetailRequest + +func (p *ToolManageServiceSaveToolDetailArgs) GetRequest() (v *SaveToolDetailRequest) { + if p == nil { + return + } + if !p.IsSetRequest() { + return ToolManageServiceSaveToolDetailArgs_Request_DEFAULT + } + return p.Request +} +func (p *ToolManageServiceSaveToolDetailArgs) SetRequest(val *SaveToolDetailRequest) { + p.Request = val +} + +var fieldIDToName_ToolManageServiceSaveToolDetailArgs = map[int16]string{ + 1: "request", +} + +func (p *ToolManageServiceSaveToolDetailArgs) IsSetRequest() bool { + return p.Request != nil +} + +func (p *ToolManageServiceSaveToolDetailArgs) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceSaveToolDetailArgs[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *ToolManageServiceSaveToolDetailArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewSaveToolDetailRequest() + if err := _field.Read(iprot); err != nil { + return err + } + p.Request = _field + return nil +} + +func (p *ToolManageServiceSaveToolDetailArgs) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("SaveToolDetail_args"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *ToolManageServiceSaveToolDetailArgs) writeField1(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { + goto WriteFieldBeginError + } + if err := p.Request.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} + +func (p *ToolManageServiceSaveToolDetailArgs) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("ToolManageServiceSaveToolDetailArgs(%+v)", *p) + +} + +func (p *ToolManageServiceSaveToolDetailArgs) DeepEqual(ano *ToolManageServiceSaveToolDetailArgs) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.Request) { + return false + } + return true +} + +func (p *ToolManageServiceSaveToolDetailArgs) Field1DeepEqual(src *SaveToolDetailRequest) bool { + + if !p.Request.DeepEqual(src) { + return false + } + return true +} + +type ToolManageServiceSaveToolDetailResult struct { + Success *SaveToolDetailResponse `thrift:"success,0,optional" frugal:"0,optional,SaveToolDetailResponse"` +} + +func NewToolManageServiceSaveToolDetailResult() *ToolManageServiceSaveToolDetailResult { + return &ToolManageServiceSaveToolDetailResult{} +} + +func (p *ToolManageServiceSaveToolDetailResult) InitDefault() { +} + +var ToolManageServiceSaveToolDetailResult_Success_DEFAULT *SaveToolDetailResponse + +func (p *ToolManageServiceSaveToolDetailResult) GetSuccess() (v *SaveToolDetailResponse) { + if p == nil { + return + } + if !p.IsSetSuccess() { + return ToolManageServiceSaveToolDetailResult_Success_DEFAULT + } + return p.Success +} +func (p *ToolManageServiceSaveToolDetailResult) SetSuccess(x interface{}) { + p.Success = x.(*SaveToolDetailResponse) +} + +var fieldIDToName_ToolManageServiceSaveToolDetailResult = map[int16]string{ + 0: "success", +} + +func (p *ToolManageServiceSaveToolDetailResult) IsSetSuccess() bool { + return p.Success != nil +} + +func (p *ToolManageServiceSaveToolDetailResult) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 0: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField0(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceSaveToolDetailResult[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *ToolManageServiceSaveToolDetailResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewSaveToolDetailResponse() + if err := _field.Read(iprot); err != nil { + return err + } + p.Success = _field + return nil +} + +func (p *ToolManageServiceSaveToolDetailResult) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("SaveToolDetail_result"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField0(oprot); err != nil { + fieldId = 0 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *ToolManageServiceSaveToolDetailResult) writeField0(oprot thrift.TProtocol) (err error) { + if p.IsSetSuccess() { + if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { + goto WriteFieldBeginError + } + if err := p.Success.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 0 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) +} + +func (p *ToolManageServiceSaveToolDetailResult) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("ToolManageServiceSaveToolDetailResult(%+v)", *p) + +} + +func (p *ToolManageServiceSaveToolDetailResult) DeepEqual(ano *ToolManageServiceSaveToolDetailResult) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field0DeepEqual(ano.Success) { + return false + } + return true +} + +func (p *ToolManageServiceSaveToolDetailResult) Field0DeepEqual(src *SaveToolDetailResponse) bool { + + if !p.Success.DeepEqual(src) { + return false + } + return true +} + +type ToolManageServiceCommitToolDraftArgs struct { + Request *CommitToolDraftRequest `thrift:"request,1" frugal:"1,default,CommitToolDraftRequest"` +} + +func NewToolManageServiceCommitToolDraftArgs() *ToolManageServiceCommitToolDraftArgs { + return &ToolManageServiceCommitToolDraftArgs{} +} + +func (p *ToolManageServiceCommitToolDraftArgs) InitDefault() { +} + +var ToolManageServiceCommitToolDraftArgs_Request_DEFAULT *CommitToolDraftRequest + +func (p *ToolManageServiceCommitToolDraftArgs) GetRequest() (v *CommitToolDraftRequest) { + if p == nil { + return + } + if !p.IsSetRequest() { + return ToolManageServiceCommitToolDraftArgs_Request_DEFAULT + } + return p.Request +} +func (p *ToolManageServiceCommitToolDraftArgs) SetRequest(val *CommitToolDraftRequest) { + p.Request = val +} + +var fieldIDToName_ToolManageServiceCommitToolDraftArgs = map[int16]string{ + 1: "request", +} + +func (p *ToolManageServiceCommitToolDraftArgs) IsSetRequest() bool { + return p.Request != nil +} + +func (p *ToolManageServiceCommitToolDraftArgs) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceCommitToolDraftArgs[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *ToolManageServiceCommitToolDraftArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewCommitToolDraftRequest() + if err := _field.Read(iprot); err != nil { + return err + } + p.Request = _field + return nil +} + +func (p *ToolManageServiceCommitToolDraftArgs) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("CommitToolDraft_args"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *ToolManageServiceCommitToolDraftArgs) writeField1(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { + goto WriteFieldBeginError + } + if err := p.Request.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} + +func (p *ToolManageServiceCommitToolDraftArgs) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("ToolManageServiceCommitToolDraftArgs(%+v)", *p) + +} + +func (p *ToolManageServiceCommitToolDraftArgs) DeepEqual(ano *ToolManageServiceCommitToolDraftArgs) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.Request) { + return false + } + return true +} + +func (p *ToolManageServiceCommitToolDraftArgs) Field1DeepEqual(src *CommitToolDraftRequest) bool { + + if !p.Request.DeepEqual(src) { + return false + } + return true +} + +type ToolManageServiceCommitToolDraftResult struct { + Success *CommitToolDraftResponse `thrift:"success,0,optional" frugal:"0,optional,CommitToolDraftResponse"` +} + +func NewToolManageServiceCommitToolDraftResult() *ToolManageServiceCommitToolDraftResult { + return &ToolManageServiceCommitToolDraftResult{} +} + +func (p *ToolManageServiceCommitToolDraftResult) InitDefault() { +} + +var ToolManageServiceCommitToolDraftResult_Success_DEFAULT *CommitToolDraftResponse + +func (p *ToolManageServiceCommitToolDraftResult) GetSuccess() (v *CommitToolDraftResponse) { + if p == nil { + return + } + if !p.IsSetSuccess() { + return ToolManageServiceCommitToolDraftResult_Success_DEFAULT + } + return p.Success +} +func (p *ToolManageServiceCommitToolDraftResult) SetSuccess(x interface{}) { + p.Success = x.(*CommitToolDraftResponse) +} + +var fieldIDToName_ToolManageServiceCommitToolDraftResult = map[int16]string{ + 0: "success", +} + +func (p *ToolManageServiceCommitToolDraftResult) IsSetSuccess() bool { + return p.Success != nil +} + +func (p *ToolManageServiceCommitToolDraftResult) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 0: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField0(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceCommitToolDraftResult[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *ToolManageServiceCommitToolDraftResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewCommitToolDraftResponse() + if err := _field.Read(iprot); err != nil { + return err + } + p.Success = _field + return nil +} + +func (p *ToolManageServiceCommitToolDraftResult) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("CommitToolDraft_result"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField0(oprot); err != nil { + fieldId = 0 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *ToolManageServiceCommitToolDraftResult) writeField0(oprot thrift.TProtocol) (err error) { + if p.IsSetSuccess() { + if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { + goto WriteFieldBeginError + } + if err := p.Success.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 0 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) +} + +func (p *ToolManageServiceCommitToolDraftResult) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("ToolManageServiceCommitToolDraftResult(%+v)", *p) + +} + +func (p *ToolManageServiceCommitToolDraftResult) DeepEqual(ano *ToolManageServiceCommitToolDraftResult) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field0DeepEqual(ano.Success) { + return false + } + return true +} + +func (p *ToolManageServiceCommitToolDraftResult) Field0DeepEqual(src *CommitToolDraftResponse) bool { + + if !p.Success.DeepEqual(src) { + return false + } + return true +} + +type ToolManageServiceListToolCommitArgs struct { + Request *ListToolCommitRequest `thrift:"request,1" frugal:"1,default,ListToolCommitRequest"` +} + +func NewToolManageServiceListToolCommitArgs() *ToolManageServiceListToolCommitArgs { + return &ToolManageServiceListToolCommitArgs{} +} + +func (p *ToolManageServiceListToolCommitArgs) InitDefault() { +} + +var ToolManageServiceListToolCommitArgs_Request_DEFAULT *ListToolCommitRequest + +func (p *ToolManageServiceListToolCommitArgs) GetRequest() (v *ListToolCommitRequest) { + if p == nil { + return + } + if !p.IsSetRequest() { + return ToolManageServiceListToolCommitArgs_Request_DEFAULT + } + return p.Request +} +func (p *ToolManageServiceListToolCommitArgs) SetRequest(val *ListToolCommitRequest) { + p.Request = val +} + +var fieldIDToName_ToolManageServiceListToolCommitArgs = map[int16]string{ + 1: "request", +} + +func (p *ToolManageServiceListToolCommitArgs) IsSetRequest() bool { + return p.Request != nil +} + +func (p *ToolManageServiceListToolCommitArgs) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceListToolCommitArgs[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *ToolManageServiceListToolCommitArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewListToolCommitRequest() + if err := _field.Read(iprot); err != nil { + return err + } + p.Request = _field + return nil +} + +func (p *ToolManageServiceListToolCommitArgs) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("ListToolCommit_args"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *ToolManageServiceListToolCommitArgs) writeField1(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { + goto WriteFieldBeginError + } + if err := p.Request.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} + +func (p *ToolManageServiceListToolCommitArgs) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("ToolManageServiceListToolCommitArgs(%+v)", *p) + +} + +func (p *ToolManageServiceListToolCommitArgs) DeepEqual(ano *ToolManageServiceListToolCommitArgs) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.Request) { + return false + } + return true +} + +func (p *ToolManageServiceListToolCommitArgs) Field1DeepEqual(src *ListToolCommitRequest) bool { + + if !p.Request.DeepEqual(src) { + return false + } + return true +} + +type ToolManageServiceListToolCommitResult struct { + Success *ListToolCommitResponse `thrift:"success,0,optional" frugal:"0,optional,ListToolCommitResponse"` +} + +func NewToolManageServiceListToolCommitResult() *ToolManageServiceListToolCommitResult { + return &ToolManageServiceListToolCommitResult{} +} + +func (p *ToolManageServiceListToolCommitResult) InitDefault() { +} + +var ToolManageServiceListToolCommitResult_Success_DEFAULT *ListToolCommitResponse + +func (p *ToolManageServiceListToolCommitResult) GetSuccess() (v *ListToolCommitResponse) { + if p == nil { + return + } + if !p.IsSetSuccess() { + return ToolManageServiceListToolCommitResult_Success_DEFAULT + } + return p.Success +} +func (p *ToolManageServiceListToolCommitResult) SetSuccess(x interface{}) { + p.Success = x.(*ListToolCommitResponse) +} + +var fieldIDToName_ToolManageServiceListToolCommitResult = map[int16]string{ + 0: "success", +} + +func (p *ToolManageServiceListToolCommitResult) IsSetSuccess() bool { + return p.Success != nil +} + +func (p *ToolManageServiceListToolCommitResult) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 0: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField0(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceListToolCommitResult[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *ToolManageServiceListToolCommitResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewListToolCommitResponse() + if err := _field.Read(iprot); err != nil { + return err + } + p.Success = _field + return nil +} + +func (p *ToolManageServiceListToolCommitResult) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("ListToolCommit_result"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField0(oprot); err != nil { + fieldId = 0 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *ToolManageServiceListToolCommitResult) writeField0(oprot thrift.TProtocol) (err error) { + if p.IsSetSuccess() { + if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { + goto WriteFieldBeginError + } + if err := p.Success.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 0 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) +} + +func (p *ToolManageServiceListToolCommitResult) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("ToolManageServiceListToolCommitResult(%+v)", *p) + +} + +func (p *ToolManageServiceListToolCommitResult) DeepEqual(ano *ToolManageServiceListToolCommitResult) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field0DeepEqual(ano.Success) { + return false + } + return true +} + +func (p *ToolManageServiceListToolCommitResult) Field0DeepEqual(src *ListToolCommitResponse) bool { + + if !p.Success.DeepEqual(src) { + return false + } + return true +} diff --git a/backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool.manage_validator.go b/backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool.manage_validator.go new file mode 100644 index 000000000..ea8ba12cb --- /dev/null +++ b/backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool.manage_validator.go @@ -0,0 +1,222 @@ +// Code generated by Validator v0.2.6. DO NOT EDIT. + +package manage + +import ( + "bytes" + "fmt" + "reflect" + "regexp" + "strings" + "time" +) + +// unused protection +var ( + _ = fmt.Formatter(nil) + _ = (*bytes.Buffer)(nil) + _ = (*strings.Builder)(nil) + _ = reflect.Type(nil) + _ = (*regexp.Regexp)(nil) + _ = time.Nanosecond +) + +func (p *CreateToolRequest) IsValid() error { + if p.WorkspaceID == nil { + return fmt.Errorf("field WorkspaceID not_nil rule failed") + } + if *p.WorkspaceID <= int64(0) { + return fmt.Errorf("field WorkspaceID gt rule failed, current value: %v", *p.WorkspaceID) + } + if p.ToolName == nil { + return fmt.Errorf("field ToolName not_nil rule failed") + } + if len(*p.ToolName) < int(1) { + return fmt.Errorf("field ToolName min_len rule failed, current value: %d", len(*p.ToolName)) + } + if p.DraftDetail != nil { + if err := p.DraftDetail.IsValid(); err != nil { + return fmt.Errorf("field DraftDetail not valid, %w", err) + } + } + if p.Base != nil { + if err := p.Base.IsValid(); err != nil { + return fmt.Errorf("field Base not valid, %w", err) + } + } + return nil +} +func (p *CreateToolResponse) IsValid() error { + if p.BaseResp != nil { + if err := p.BaseResp.IsValid(); err != nil { + return fmt.Errorf("field BaseResp not valid, %w", err) + } + } + return nil +} +func (p *GetToolDetailRequest) IsValid() error { + if p.ToolID == nil { + return fmt.Errorf("field ToolID not_nil rule failed") + } + if *p.ToolID <= int64(0) { + return fmt.Errorf("field ToolID gt rule failed, current value: %v", *p.ToolID) + } + if p.Base != nil { + if err := p.Base.IsValid(); err != nil { + return fmt.Errorf("field Base not valid, %w", err) + } + } + return nil +} +func (p *GetToolDetailResponse) IsValid() error { + if p.Tool != nil { + if err := p.Tool.IsValid(); err != nil { + return fmt.Errorf("field Tool not valid, %w", err) + } + } + if p.BaseResp != nil { + if err := p.BaseResp.IsValid(); err != nil { + return fmt.Errorf("field BaseResp not valid, %w", err) + } + } + return nil +} +func (p *ListToolRequest) IsValid() error { + if p.WorkspaceID == nil { + return fmt.Errorf("field WorkspaceID not_nil rule failed") + } + if *p.WorkspaceID <= int64(0) { + return fmt.Errorf("field WorkspaceID gt rule failed, current value: %v", *p.WorkspaceID) + } + if p.PageNum == nil { + return fmt.Errorf("field PageNum not_nil rule failed") + } + if *p.PageNum <= int32(0) { + return fmt.Errorf("field PageNum gt rule failed, current value: %v", *p.PageNum) + } + if p.PageSize == nil { + return fmt.Errorf("field PageSize not_nil rule failed") + } + if *p.PageSize <= int32(0) { + return fmt.Errorf("field PageSize gt rule failed, current value: %v", *p.PageSize) + } + if *p.PageSize > int32(100) { + return fmt.Errorf("field PageSize le rule failed, current value: %v", *p.PageSize) + } + if p.Base != nil { + if err := p.Base.IsValid(); err != nil { + return fmt.Errorf("field Base not valid, %w", err) + } + } + return nil +} +func (p *ListToolResponse) IsValid() error { + if p.BaseResp != nil { + if err := p.BaseResp.IsValid(); err != nil { + return fmt.Errorf("field BaseResp not valid, %w", err) + } + } + return nil +} +func (p *SaveToolDetailRequest) IsValid() error { + if p.ToolID == nil { + return fmt.Errorf("field ToolID not_nil rule failed") + } + if *p.ToolID <= int64(0) { + return fmt.Errorf("field ToolID gt rule failed, current value: %v", *p.ToolID) + } + if p.WorkspaceID == nil { + return fmt.Errorf("field WorkspaceID not_nil rule failed") + } + if *p.WorkspaceID <= int64(0) { + return fmt.Errorf("field WorkspaceID gt rule failed, current value: %v", *p.WorkspaceID) + } + if p.ToolDetail == nil { + return fmt.Errorf("field ToolDetail not_nil rule failed") + } + if err := p.ToolDetail.IsValid(); err != nil { + return fmt.Errorf("field ToolDetail not valid, %w", err) + } + if p.Base != nil { + if err := p.Base.IsValid(); err != nil { + return fmt.Errorf("field Base not valid, %w", err) + } + } + return nil +} +func (p *SaveToolDetailResponse) IsValid() error { + if p.BaseResp != nil { + if err := p.BaseResp.IsValid(); err != nil { + return fmt.Errorf("field BaseResp not valid, %w", err) + } + } + return nil +} +func (p *CommitToolDraftRequest) IsValid() error { + if p.ToolID == nil { + return fmt.Errorf("field ToolID not_nil rule failed") + } + if *p.ToolID <= int64(0) { + return fmt.Errorf("field ToolID gt rule failed, current value: %v", *p.ToolID) + } + if p.WorkspaceID == nil { + return fmt.Errorf("field WorkspaceID not_nil rule failed") + } + if *p.WorkspaceID <= int64(0) { + return fmt.Errorf("field WorkspaceID gt rule failed, current value: %v", *p.WorkspaceID) + } + if p.CommitVersion == nil { + return fmt.Errorf("field CommitVersion not_nil rule failed") + } + if len(*p.CommitVersion) < int(1) { + return fmt.Errorf("field CommitVersion min_len rule failed, current value: %d", len(*p.CommitVersion)) + } + if p.Base != nil { + if err := p.Base.IsValid(); err != nil { + return fmt.Errorf("field Base not valid, %w", err) + } + } + return nil +} +func (p *CommitToolDraftResponse) IsValid() error { + if p.BaseResp != nil { + if err := p.BaseResp.IsValid(); err != nil { + return fmt.Errorf("field BaseResp not valid, %w", err) + } + } + return nil +} +func (p *ListToolCommitRequest) IsValid() error { + if p.ToolID == nil { + return fmt.Errorf("field ToolID not_nil rule failed") + } + if *p.ToolID <= int64(0) { + return fmt.Errorf("field ToolID gt rule failed, current value: %v", *p.ToolID) + } + if p.WorkspaceID == nil { + return fmt.Errorf("field WorkspaceID not_nil rule failed") + } + if *p.WorkspaceID <= int64(0) { + return fmt.Errorf("field WorkspaceID gt rule failed, current value: %v", *p.WorkspaceID) + } + if p.PageSize == nil { + return fmt.Errorf("field PageSize not_nil rule failed") + } + if *p.PageSize <= int32(0) { + return fmt.Errorf("field PageSize gt rule failed, current value: %v", *p.PageSize) + } + if p.Base != nil { + if err := p.Base.IsValid(); err != nil { + return fmt.Errorf("field Base not valid, %w", err) + } + } + return nil +} +func (p *ListToolCommitResponse) IsValid() error { + if p.BaseResp != nil { + if err := p.BaseResp.IsValid(); err != nil { + return fmt.Errorf("field BaseResp not valid, %w", err) + } + } + return nil +} diff --git a/backend/kitex_gen/coze/loop/prompt/tool/manage/k-consts.go b/backend/kitex_gen/coze/loop/prompt/tool/manage/k-consts.go new file mode 100644 index 000000000..9fd241a66 --- /dev/null +++ b/backend/kitex_gen/coze/loop/prompt/tool/manage/k-consts.go @@ -0,0 +1,4 @@ +package manage + +// KitexUnusedProtection is used to prevent 'imported and not used' error. +var KitexUnusedProtection = struct{}{} diff --git a/backend/kitex_gen/coze/loop/prompt/tool/manage/k-coze.loop.prompt.tool.manage.go b/backend/kitex_gen/coze/loop/prompt/tool/manage/k-coze.loop.prompt.tool.manage.go new file mode 100644 index 000000000..8808de655 --- /dev/null +++ b/backend/kitex_gen/coze/loop/prompt/tool/manage/k-coze.loop.prompt.tool.manage.go @@ -0,0 +1,5377 @@ +// Code generated by Kitex v0.13.1. DO NOT EDIT. + +package manage + +import ( + "bytes" + "fmt" + "reflect" + "strings" + + "github.com/cloudwego/gopkg/protocol/thrift" + kutils "github.com/cloudwego/kitex/pkg/utils" + + "github.com/coze-dev/coze-loop/backend/kitex_gen/base" + "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/domain/tool" + "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/domain/user" +) + +var ( + _ = base.KitexUnusedProtection + _ = tool.KitexUnusedProtection + _ = user.KitexUnusedProtection +) + +// unused protection +var ( + _ = fmt.Formatter(nil) + _ = (*bytes.Buffer)(nil) + _ = (*strings.Builder)(nil) + _ = reflect.Type(nil) + _ = thrift.STOP +) + +func (p *CreateToolRequest) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.I64 { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 11: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField11(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 12: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField12(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 21: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField21(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 255: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField255(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_CreateToolRequest[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *CreateToolRequest) FastReadField1(buf []byte) (int, error) { + offset := 0 + + var _field *int64 + if v, l, err := thrift.Binary.ReadI64(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.WorkspaceID = _field + return offset, nil +} + +func (p *CreateToolRequest) FastReadField11(buf []byte) (int, error) { + offset := 0 + + var _field *string + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.ToolName = _field + return offset, nil +} + +func (p *CreateToolRequest) FastReadField12(buf []byte) (int, error) { + offset := 0 + + var _field *string + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.ToolDescription = _field + return offset, nil +} + +func (p *CreateToolRequest) FastReadField21(buf []byte) (int, error) { + offset := 0 + _field := tool.NewToolDetail() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.DraftDetail = _field + return offset, nil +} + +func (p *CreateToolRequest) FastReadField255(buf []byte) (int, error) { + offset := 0 + _field := base.NewBase() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Base = _field + return offset, nil +} + +func (p *CreateToolRequest) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *CreateToolRequest) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField1(buf[offset:], w) + offset += p.fastWriteField11(buf[offset:], w) + offset += p.fastWriteField12(buf[offset:], w) + offset += p.fastWriteField21(buf[offset:], w) + offset += p.fastWriteField255(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *CreateToolRequest) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + l += p.field11Length() + l += p.field12Length() + l += p.field21Length() + l += p.field255Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *CreateToolRequest) fastWriteField1(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetWorkspaceID() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.I64, 1) + offset += thrift.Binary.WriteI64(buf[offset:], *p.WorkspaceID) + } + return offset +} + +func (p *CreateToolRequest) fastWriteField11(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetToolName() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRING, 11) + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, *p.ToolName) + } + return offset +} + +func (p *CreateToolRequest) fastWriteField12(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetToolDescription() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRING, 12) + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, *p.ToolDescription) + } + return offset +} + +func (p *CreateToolRequest) fastWriteField21(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetDraftDetail() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 21) + offset += p.DraftDetail.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *CreateToolRequest) fastWriteField255(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetBase() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 255) + offset += p.Base.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *CreateToolRequest) field1Length() int { + l := 0 + if p.IsSetWorkspaceID() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.I64Length() + } + return l +} + +func (p *CreateToolRequest) field11Length() int { + l := 0 + if p.IsSetToolName() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.StringLengthNocopy(*p.ToolName) + } + return l +} + +func (p *CreateToolRequest) field12Length() int { + l := 0 + if p.IsSetToolDescription() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.StringLengthNocopy(*p.ToolDescription) + } + return l +} + +func (p *CreateToolRequest) field21Length() int { + l := 0 + if p.IsSetDraftDetail() { + l += thrift.Binary.FieldBeginLength() + l += p.DraftDetail.BLength() + } + return l +} + +func (p *CreateToolRequest) field255Length() int { + l := 0 + if p.IsSetBase() { + l += thrift.Binary.FieldBeginLength() + l += p.Base.BLength() + } + return l +} + +func (p *CreateToolRequest) DeepCopy(s interface{}) error { + src, ok := s.(*CreateToolRequest) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + if src.WorkspaceID != nil { + tmp := *src.WorkspaceID + p.WorkspaceID = &tmp + } + + if src.ToolName != nil { + var tmp string + if *src.ToolName != "" { + tmp = kutils.StringDeepCopy(*src.ToolName) + } + p.ToolName = &tmp + } + + if src.ToolDescription != nil { + var tmp string + if *src.ToolDescription != "" { + tmp = kutils.StringDeepCopy(*src.ToolDescription) + } + p.ToolDescription = &tmp + } + + var _draftDetail *tool.ToolDetail + if src.DraftDetail != nil { + _draftDetail = &tool.ToolDetail{} + if err := _draftDetail.DeepCopy(src.DraftDetail); err != nil { + return err + } + } + p.DraftDetail = _draftDetail + + var _base *base.Base + if src.Base != nil { + _base = &base.Base{} + if err := _base.DeepCopy(src.Base); err != nil { + return err + } + } + p.Base = _base + + return nil +} + +func (p *CreateToolResponse) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.I64 { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 255: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField255(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_CreateToolResponse[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *CreateToolResponse) FastReadField1(buf []byte) (int, error) { + offset := 0 + + var _field *int64 + if v, l, err := thrift.Binary.ReadI64(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.ToolID = _field + return offset, nil +} + +func (p *CreateToolResponse) FastReadField255(buf []byte) (int, error) { + offset := 0 + _field := base.NewBaseResp() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.BaseResp = _field + return offset, nil +} + +func (p *CreateToolResponse) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *CreateToolResponse) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField1(buf[offset:], w) + offset += p.fastWriteField255(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *CreateToolResponse) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + l += p.field255Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *CreateToolResponse) fastWriteField1(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetToolID() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.I64, 1) + offset += thrift.Binary.WriteI64(buf[offset:], *p.ToolID) + } + return offset +} + +func (p *CreateToolResponse) fastWriteField255(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetBaseResp() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 255) + offset += p.BaseResp.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *CreateToolResponse) field1Length() int { + l := 0 + if p.IsSetToolID() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.I64Length() + } + return l +} + +func (p *CreateToolResponse) field255Length() int { + l := 0 + if p.IsSetBaseResp() { + l += thrift.Binary.FieldBeginLength() + l += p.BaseResp.BLength() + } + return l +} + +func (p *CreateToolResponse) DeepCopy(s interface{}) error { + src, ok := s.(*CreateToolResponse) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + if src.ToolID != nil { + tmp := *src.ToolID + p.ToolID = &tmp + } + + var _baseResp *base.BaseResp + if src.BaseResp != nil { + _baseResp = &base.BaseResp{} + if err := _baseResp.DeepCopy(src.BaseResp); err != nil { + return err + } + } + p.BaseResp = _baseResp + + return nil +} + +func (p *GetToolDetailRequest) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.I64 { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 2: + if fieldTypeId == thrift.I64 { + l, err = p.FastReadField2(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 11: + if fieldTypeId == thrift.BOOL { + l, err = p.FastReadField11(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 12: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField12(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 21: + if fieldTypeId == thrift.BOOL { + l, err = p.FastReadField21(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 255: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField255(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_GetToolDetailRequest[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *GetToolDetailRequest) FastReadField1(buf []byte) (int, error) { + offset := 0 + + var _field *int64 + if v, l, err := thrift.Binary.ReadI64(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.ToolID = _field + return offset, nil +} + +func (p *GetToolDetailRequest) FastReadField2(buf []byte) (int, error) { + offset := 0 + + var _field *int64 + if v, l, err := thrift.Binary.ReadI64(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.WorkspaceID = _field + return offset, nil +} + +func (p *GetToolDetailRequest) FastReadField11(buf []byte) (int, error) { + offset := 0 + + var _field *bool + if v, l, err := thrift.Binary.ReadBool(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.WithCommit = _field + return offset, nil +} + +func (p *GetToolDetailRequest) FastReadField12(buf []byte) (int, error) { + offset := 0 + + var _field *string + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.CommitVersion = _field + return offset, nil +} + +func (p *GetToolDetailRequest) FastReadField21(buf []byte) (int, error) { + offset := 0 + + var _field *bool + if v, l, err := thrift.Binary.ReadBool(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.WithDraft = _field + return offset, nil +} + +func (p *GetToolDetailRequest) FastReadField255(buf []byte) (int, error) { + offset := 0 + _field := base.NewBase() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Base = _field + return offset, nil +} + +func (p *GetToolDetailRequest) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *GetToolDetailRequest) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField1(buf[offset:], w) + offset += p.fastWriteField2(buf[offset:], w) + offset += p.fastWriteField11(buf[offset:], w) + offset += p.fastWriteField21(buf[offset:], w) + offset += p.fastWriteField12(buf[offset:], w) + offset += p.fastWriteField255(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *GetToolDetailRequest) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + l += p.field2Length() + l += p.field11Length() + l += p.field12Length() + l += p.field21Length() + l += p.field255Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *GetToolDetailRequest) fastWriteField1(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetToolID() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.I64, 1) + offset += thrift.Binary.WriteI64(buf[offset:], *p.ToolID) + } + return offset +} + +func (p *GetToolDetailRequest) fastWriteField2(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetWorkspaceID() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.I64, 2) + offset += thrift.Binary.WriteI64(buf[offset:], *p.WorkspaceID) + } + return offset +} + +func (p *GetToolDetailRequest) fastWriteField11(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetWithCommit() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.BOOL, 11) + offset += thrift.Binary.WriteBool(buf[offset:], *p.WithCommit) + } + return offset +} + +func (p *GetToolDetailRequest) fastWriteField12(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetCommitVersion() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRING, 12) + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, *p.CommitVersion) + } + return offset +} + +func (p *GetToolDetailRequest) fastWriteField21(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetWithDraft() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.BOOL, 21) + offset += thrift.Binary.WriteBool(buf[offset:], *p.WithDraft) + } + return offset +} + +func (p *GetToolDetailRequest) fastWriteField255(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetBase() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 255) + offset += p.Base.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *GetToolDetailRequest) field1Length() int { + l := 0 + if p.IsSetToolID() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.I64Length() + } + return l +} + +func (p *GetToolDetailRequest) field2Length() int { + l := 0 + if p.IsSetWorkspaceID() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.I64Length() + } + return l +} + +func (p *GetToolDetailRequest) field11Length() int { + l := 0 + if p.IsSetWithCommit() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.BoolLength() + } + return l +} + +func (p *GetToolDetailRequest) field12Length() int { + l := 0 + if p.IsSetCommitVersion() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.StringLengthNocopy(*p.CommitVersion) + } + return l +} + +func (p *GetToolDetailRequest) field21Length() int { + l := 0 + if p.IsSetWithDraft() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.BoolLength() + } + return l +} + +func (p *GetToolDetailRequest) field255Length() int { + l := 0 + if p.IsSetBase() { + l += thrift.Binary.FieldBeginLength() + l += p.Base.BLength() + } + return l +} + +func (p *GetToolDetailRequest) DeepCopy(s interface{}) error { + src, ok := s.(*GetToolDetailRequest) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + if src.ToolID != nil { + tmp := *src.ToolID + p.ToolID = &tmp + } + + if src.WorkspaceID != nil { + tmp := *src.WorkspaceID + p.WorkspaceID = &tmp + } + + if src.WithCommit != nil { + tmp := *src.WithCommit + p.WithCommit = &tmp + } + + if src.CommitVersion != nil { + var tmp string + if *src.CommitVersion != "" { + tmp = kutils.StringDeepCopy(*src.CommitVersion) + } + p.CommitVersion = &tmp + } + + if src.WithDraft != nil { + tmp := *src.WithDraft + p.WithDraft = &tmp + } + + var _base *base.Base + if src.Base != nil { + _base = &base.Base{} + if err := _base.DeepCopy(src.Base); err != nil { + return err + } + } + p.Base = _base + + return nil +} + +func (p *GetToolDetailResponse) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 255: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField255(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_GetToolDetailResponse[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *GetToolDetailResponse) FastReadField1(buf []byte) (int, error) { + offset := 0 + _field := tool.NewTool() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Tool = _field + return offset, nil +} + +func (p *GetToolDetailResponse) FastReadField255(buf []byte) (int, error) { + offset := 0 + _field := base.NewBaseResp() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.BaseResp = _field + return offset, nil +} + +func (p *GetToolDetailResponse) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *GetToolDetailResponse) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField1(buf[offset:], w) + offset += p.fastWriteField255(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *GetToolDetailResponse) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + l += p.field255Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *GetToolDetailResponse) fastWriteField1(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetTool() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 1) + offset += p.Tool.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *GetToolDetailResponse) fastWriteField255(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetBaseResp() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 255) + offset += p.BaseResp.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *GetToolDetailResponse) field1Length() int { + l := 0 + if p.IsSetTool() { + l += thrift.Binary.FieldBeginLength() + l += p.Tool.BLength() + } + return l +} + +func (p *GetToolDetailResponse) field255Length() int { + l := 0 + if p.IsSetBaseResp() { + l += thrift.Binary.FieldBeginLength() + l += p.BaseResp.BLength() + } + return l +} + +func (p *GetToolDetailResponse) DeepCopy(s interface{}) error { + src, ok := s.(*GetToolDetailResponse) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + var _tool *tool.Tool + if src.Tool != nil { + _tool = &tool.Tool{} + if err := _tool.DeepCopy(src.Tool); err != nil { + return err + } + } + p.Tool = _tool + + var _baseResp *base.BaseResp + if src.BaseResp != nil { + _baseResp = &base.BaseResp{} + if err := _baseResp.DeepCopy(src.BaseResp); err != nil { + return err + } + } + p.BaseResp = _baseResp + + return nil +} + +func (p *ListToolRequest) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.I64 { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 11: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField11(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 12: + if fieldTypeId == thrift.LIST { + l, err = p.FastReadField12(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 13: + if fieldTypeId == thrift.BOOL { + l, err = p.FastReadField13(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 127: + if fieldTypeId == thrift.I32 { + l, err = p.FastReadField127(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 128: + if fieldTypeId == thrift.I32 { + l, err = p.FastReadField128(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 129: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField129(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 130: + if fieldTypeId == thrift.BOOL { + l, err = p.FastReadField130(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 255: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField255(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ListToolRequest[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *ListToolRequest) FastReadField1(buf []byte) (int, error) { + offset := 0 + + var _field *int64 + if v, l, err := thrift.Binary.ReadI64(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.WorkspaceID = _field + return offset, nil +} + +func (p *ListToolRequest) FastReadField11(buf []byte) (int, error) { + offset := 0 + + var _field *string + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.KeyWord = _field + return offset, nil +} + +func (p *ListToolRequest) FastReadField12(buf []byte) (int, error) { + offset := 0 + + _, size, l, err := thrift.Binary.ReadListBegin(buf[offset:]) + offset += l + if err != nil { + return offset, err + } + _field := make([]string, 0, size) + for i := 0; i < size; i++ { + var _elem string + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _elem = v + } + + _field = append(_field, _elem) + } + p.CreatedBys = _field + return offset, nil +} + +func (p *ListToolRequest) FastReadField13(buf []byte) (int, error) { + offset := 0 + + var _field *bool + if v, l, err := thrift.Binary.ReadBool(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.CommittedOnly = _field + return offset, nil +} + +func (p *ListToolRequest) FastReadField127(buf []byte) (int, error) { + offset := 0 + + var _field *int32 + if v, l, err := thrift.Binary.ReadI32(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.PageNum = _field + return offset, nil +} + +func (p *ListToolRequest) FastReadField128(buf []byte) (int, error) { + offset := 0 + + var _field *int32 + if v, l, err := thrift.Binary.ReadI32(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.PageSize = _field + return offset, nil +} + +func (p *ListToolRequest) FastReadField129(buf []byte) (int, error) { + offset := 0 + + var _field *ListToolOrderBy + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.OrderBy = _field + return offset, nil +} + +func (p *ListToolRequest) FastReadField130(buf []byte) (int, error) { + offset := 0 + + var _field *bool + if v, l, err := thrift.Binary.ReadBool(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.Asc = _field + return offset, nil +} + +func (p *ListToolRequest) FastReadField255(buf []byte) (int, error) { + offset := 0 + _field := base.NewBase() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Base = _field + return offset, nil +} + +func (p *ListToolRequest) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *ListToolRequest) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField1(buf[offset:], w) + offset += p.fastWriteField13(buf[offset:], w) + offset += p.fastWriteField127(buf[offset:], w) + offset += p.fastWriteField128(buf[offset:], w) + offset += p.fastWriteField130(buf[offset:], w) + offset += p.fastWriteField11(buf[offset:], w) + offset += p.fastWriteField12(buf[offset:], w) + offset += p.fastWriteField129(buf[offset:], w) + offset += p.fastWriteField255(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *ListToolRequest) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + l += p.field11Length() + l += p.field12Length() + l += p.field13Length() + l += p.field127Length() + l += p.field128Length() + l += p.field129Length() + l += p.field130Length() + l += p.field255Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *ListToolRequest) fastWriteField1(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetWorkspaceID() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.I64, 1) + offset += thrift.Binary.WriteI64(buf[offset:], *p.WorkspaceID) + } + return offset +} + +func (p *ListToolRequest) fastWriteField11(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetKeyWord() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRING, 11) + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, *p.KeyWord) + } + return offset +} + +func (p *ListToolRequest) fastWriteField12(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetCreatedBys() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.LIST, 12) + listBeginOffset := offset + offset += thrift.Binary.ListBeginLength() + var length int + for _, v := range p.CreatedBys { + length++ + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, v) + } + thrift.Binary.WriteListBegin(buf[listBeginOffset:], thrift.STRING, length) + } + return offset +} + +func (p *ListToolRequest) fastWriteField13(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetCommittedOnly() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.BOOL, 13) + offset += thrift.Binary.WriteBool(buf[offset:], *p.CommittedOnly) + } + return offset +} + +func (p *ListToolRequest) fastWriteField127(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetPageNum() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.I32, 127) + offset += thrift.Binary.WriteI32(buf[offset:], *p.PageNum) + } + return offset +} + +func (p *ListToolRequest) fastWriteField128(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetPageSize() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.I32, 128) + offset += thrift.Binary.WriteI32(buf[offset:], *p.PageSize) + } + return offset +} + +func (p *ListToolRequest) fastWriteField129(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetOrderBy() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRING, 129) + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, *p.OrderBy) + } + return offset +} + +func (p *ListToolRequest) fastWriteField130(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetAsc() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.BOOL, 130) + offset += thrift.Binary.WriteBool(buf[offset:], *p.Asc) + } + return offset +} + +func (p *ListToolRequest) fastWriteField255(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetBase() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 255) + offset += p.Base.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *ListToolRequest) field1Length() int { + l := 0 + if p.IsSetWorkspaceID() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.I64Length() + } + return l +} + +func (p *ListToolRequest) field11Length() int { + l := 0 + if p.IsSetKeyWord() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.StringLengthNocopy(*p.KeyWord) + } + return l +} + +func (p *ListToolRequest) field12Length() int { + l := 0 + if p.IsSetCreatedBys() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.ListBeginLength() + for _, v := range p.CreatedBys { + _ = v + l += thrift.Binary.StringLengthNocopy(v) + } + } + return l +} + +func (p *ListToolRequest) field13Length() int { + l := 0 + if p.IsSetCommittedOnly() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.BoolLength() + } + return l +} + +func (p *ListToolRequest) field127Length() int { + l := 0 + if p.IsSetPageNum() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.I32Length() + } + return l +} + +func (p *ListToolRequest) field128Length() int { + l := 0 + if p.IsSetPageSize() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.I32Length() + } + return l +} + +func (p *ListToolRequest) field129Length() int { + l := 0 + if p.IsSetOrderBy() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.StringLengthNocopy(*p.OrderBy) + } + return l +} + +func (p *ListToolRequest) field130Length() int { + l := 0 + if p.IsSetAsc() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.BoolLength() + } + return l +} + +func (p *ListToolRequest) field255Length() int { + l := 0 + if p.IsSetBase() { + l += thrift.Binary.FieldBeginLength() + l += p.Base.BLength() + } + return l +} + +func (p *ListToolRequest) DeepCopy(s interface{}) error { + src, ok := s.(*ListToolRequest) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + if src.WorkspaceID != nil { + tmp := *src.WorkspaceID + p.WorkspaceID = &tmp + } + + if src.KeyWord != nil { + var tmp string + if *src.KeyWord != "" { + tmp = kutils.StringDeepCopy(*src.KeyWord) + } + p.KeyWord = &tmp + } + + if src.CreatedBys != nil { + p.CreatedBys = make([]string, 0, len(src.CreatedBys)) + for _, elem := range src.CreatedBys { + var _elem string + if elem != "" { + _elem = kutils.StringDeepCopy(elem) + } + p.CreatedBys = append(p.CreatedBys, _elem) + } + } + + if src.CommittedOnly != nil { + tmp := *src.CommittedOnly + p.CommittedOnly = &tmp + } + + if src.PageNum != nil { + tmp := *src.PageNum + p.PageNum = &tmp + } + + if src.PageSize != nil { + tmp := *src.PageSize + p.PageSize = &tmp + } + + if src.OrderBy != nil { + tmp := *src.OrderBy + p.OrderBy = &tmp + } + + if src.Asc != nil { + tmp := *src.Asc + p.Asc = &tmp + } + + var _base *base.Base + if src.Base != nil { + _base = &base.Base{} + if err := _base.DeepCopy(src.Base); err != nil { + return err + } + } + p.Base = _base + + return nil +} + +func (p *ListToolResponse) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.LIST { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 11: + if fieldTypeId == thrift.LIST { + l, err = p.FastReadField11(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 127: + if fieldTypeId == thrift.I32 { + l, err = p.FastReadField127(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 255: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField255(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ListToolResponse[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *ListToolResponse) FastReadField1(buf []byte) (int, error) { + offset := 0 + + _, size, l, err := thrift.Binary.ReadListBegin(buf[offset:]) + offset += l + if err != nil { + return offset, err + } + _field := make([]*tool.Tool, 0, size) + values := make([]tool.Tool, size) + for i := 0; i < size; i++ { + _elem := &values[i] + _elem.InitDefault() + if l, err := _elem.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + + _field = append(_field, _elem) + } + p.Tools = _field + return offset, nil +} + +func (p *ListToolResponse) FastReadField11(buf []byte) (int, error) { + offset := 0 + + _, size, l, err := thrift.Binary.ReadListBegin(buf[offset:]) + offset += l + if err != nil { + return offset, err + } + _field := make([]*user.UserInfoDetail, 0, size) + values := make([]user.UserInfoDetail, size) + for i := 0; i < size; i++ { + _elem := &values[i] + _elem.InitDefault() + if l, err := _elem.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + + _field = append(_field, _elem) + } + p.Users = _field + return offset, nil +} + +func (p *ListToolResponse) FastReadField127(buf []byte) (int, error) { + offset := 0 + + var _field *int32 + if v, l, err := thrift.Binary.ReadI32(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.Total = _field + return offset, nil +} + +func (p *ListToolResponse) FastReadField255(buf []byte) (int, error) { + offset := 0 + _field := base.NewBaseResp() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.BaseResp = _field + return offset, nil +} + +func (p *ListToolResponse) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *ListToolResponse) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField127(buf[offset:], w) + offset += p.fastWriteField1(buf[offset:], w) + offset += p.fastWriteField11(buf[offset:], w) + offset += p.fastWriteField255(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *ListToolResponse) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + l += p.field11Length() + l += p.field127Length() + l += p.field255Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *ListToolResponse) fastWriteField1(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetTools() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.LIST, 1) + listBeginOffset := offset + offset += thrift.Binary.ListBeginLength() + var length int + for _, v := range p.Tools { + length++ + offset += v.FastWriteNocopy(buf[offset:], w) + } + thrift.Binary.WriteListBegin(buf[listBeginOffset:], thrift.STRUCT, length) + } + return offset +} + +func (p *ListToolResponse) fastWriteField11(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetUsers() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.LIST, 11) + listBeginOffset := offset + offset += thrift.Binary.ListBeginLength() + var length int + for _, v := range p.Users { + length++ + offset += v.FastWriteNocopy(buf[offset:], w) + } + thrift.Binary.WriteListBegin(buf[listBeginOffset:], thrift.STRUCT, length) + } + return offset +} + +func (p *ListToolResponse) fastWriteField127(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetTotal() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.I32, 127) + offset += thrift.Binary.WriteI32(buf[offset:], *p.Total) + } + return offset +} + +func (p *ListToolResponse) fastWriteField255(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetBaseResp() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 255) + offset += p.BaseResp.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *ListToolResponse) field1Length() int { + l := 0 + if p.IsSetTools() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.ListBeginLength() + for _, v := range p.Tools { + _ = v + l += v.BLength() + } + } + return l +} + +func (p *ListToolResponse) field11Length() int { + l := 0 + if p.IsSetUsers() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.ListBeginLength() + for _, v := range p.Users { + _ = v + l += v.BLength() + } + } + return l +} + +func (p *ListToolResponse) field127Length() int { + l := 0 + if p.IsSetTotal() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.I32Length() + } + return l +} + +func (p *ListToolResponse) field255Length() int { + l := 0 + if p.IsSetBaseResp() { + l += thrift.Binary.FieldBeginLength() + l += p.BaseResp.BLength() + } + return l +} + +func (p *ListToolResponse) DeepCopy(s interface{}) error { + src, ok := s.(*ListToolResponse) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + if src.Tools != nil { + p.Tools = make([]*tool.Tool, 0, len(src.Tools)) + for _, elem := range src.Tools { + var _elem *tool.Tool + if elem != nil { + _elem = &tool.Tool{} + if err := _elem.DeepCopy(elem); err != nil { + return err + } + } + + p.Tools = append(p.Tools, _elem) + } + } + + if src.Users != nil { + p.Users = make([]*user.UserInfoDetail, 0, len(src.Users)) + for _, elem := range src.Users { + var _elem *user.UserInfoDetail + if elem != nil { + _elem = &user.UserInfoDetail{} + if err := _elem.DeepCopy(elem); err != nil { + return err + } + } + + p.Users = append(p.Users, _elem) + } + } + + if src.Total != nil { + tmp := *src.Total + p.Total = &tmp + } + + var _baseResp *base.BaseResp + if src.BaseResp != nil { + _baseResp = &base.BaseResp{} + if err := _baseResp.DeepCopy(src.BaseResp); err != nil { + return err + } + } + p.BaseResp = _baseResp + + return nil +} + +func (p *SaveToolDetailRequest) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.I64 { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 2: + if fieldTypeId == thrift.I64 { + l, err = p.FastReadField2(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 11: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField11(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 12: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField12(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 255: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField255(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_SaveToolDetailRequest[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *SaveToolDetailRequest) FastReadField1(buf []byte) (int, error) { + offset := 0 + + var _field *int64 + if v, l, err := thrift.Binary.ReadI64(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.ToolID = _field + return offset, nil +} + +func (p *SaveToolDetailRequest) FastReadField2(buf []byte) (int, error) { + offset := 0 + + var _field *int64 + if v, l, err := thrift.Binary.ReadI64(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.WorkspaceID = _field + return offset, nil +} + +func (p *SaveToolDetailRequest) FastReadField11(buf []byte) (int, error) { + offset := 0 + _field := tool.NewToolDetail() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.ToolDetail = _field + return offset, nil +} + +func (p *SaveToolDetailRequest) FastReadField12(buf []byte) (int, error) { + offset := 0 + + var _field *string + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.BaseVersion = _field + return offset, nil +} + +func (p *SaveToolDetailRequest) FastReadField255(buf []byte) (int, error) { + offset := 0 + _field := base.NewBase() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Base = _field + return offset, nil +} + +func (p *SaveToolDetailRequest) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *SaveToolDetailRequest) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField1(buf[offset:], w) + offset += p.fastWriteField2(buf[offset:], w) + offset += p.fastWriteField11(buf[offset:], w) + offset += p.fastWriteField12(buf[offset:], w) + offset += p.fastWriteField255(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *SaveToolDetailRequest) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + l += p.field2Length() + l += p.field11Length() + l += p.field12Length() + l += p.field255Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *SaveToolDetailRequest) fastWriteField1(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetToolID() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.I64, 1) + offset += thrift.Binary.WriteI64(buf[offset:], *p.ToolID) + } + return offset +} + +func (p *SaveToolDetailRequest) fastWriteField2(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetWorkspaceID() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.I64, 2) + offset += thrift.Binary.WriteI64(buf[offset:], *p.WorkspaceID) + } + return offset +} + +func (p *SaveToolDetailRequest) fastWriteField11(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetToolDetail() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 11) + offset += p.ToolDetail.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *SaveToolDetailRequest) fastWriteField12(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetBaseVersion() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRING, 12) + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, *p.BaseVersion) + } + return offset +} + +func (p *SaveToolDetailRequest) fastWriteField255(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetBase() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 255) + offset += p.Base.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *SaveToolDetailRequest) field1Length() int { + l := 0 + if p.IsSetToolID() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.I64Length() + } + return l +} + +func (p *SaveToolDetailRequest) field2Length() int { + l := 0 + if p.IsSetWorkspaceID() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.I64Length() + } + return l +} + +func (p *SaveToolDetailRequest) field11Length() int { + l := 0 + if p.IsSetToolDetail() { + l += thrift.Binary.FieldBeginLength() + l += p.ToolDetail.BLength() + } + return l +} + +func (p *SaveToolDetailRequest) field12Length() int { + l := 0 + if p.IsSetBaseVersion() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.StringLengthNocopy(*p.BaseVersion) + } + return l +} + +func (p *SaveToolDetailRequest) field255Length() int { + l := 0 + if p.IsSetBase() { + l += thrift.Binary.FieldBeginLength() + l += p.Base.BLength() + } + return l +} + +func (p *SaveToolDetailRequest) DeepCopy(s interface{}) error { + src, ok := s.(*SaveToolDetailRequest) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + if src.ToolID != nil { + tmp := *src.ToolID + p.ToolID = &tmp + } + + if src.WorkspaceID != nil { + tmp := *src.WorkspaceID + p.WorkspaceID = &tmp + } + + var _toolDetail *tool.ToolDetail + if src.ToolDetail != nil { + _toolDetail = &tool.ToolDetail{} + if err := _toolDetail.DeepCopy(src.ToolDetail); err != nil { + return err + } + } + p.ToolDetail = _toolDetail + + if src.BaseVersion != nil { + var tmp string + if *src.BaseVersion != "" { + tmp = kutils.StringDeepCopy(*src.BaseVersion) + } + p.BaseVersion = &tmp + } + + var _base *base.Base + if src.Base != nil { + _base = &base.Base{} + if err := _base.DeepCopy(src.Base); err != nil { + return err + } + } + p.Base = _base + + return nil +} + +func (p *SaveToolDetailResponse) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 255: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField255(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_SaveToolDetailResponse[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *SaveToolDetailResponse) FastReadField255(buf []byte) (int, error) { + offset := 0 + _field := base.NewBaseResp() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.BaseResp = _field + return offset, nil +} + +func (p *SaveToolDetailResponse) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *SaveToolDetailResponse) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField255(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *SaveToolDetailResponse) BLength() int { + l := 0 + if p != nil { + l += p.field255Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *SaveToolDetailResponse) fastWriteField255(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetBaseResp() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 255) + offset += p.BaseResp.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *SaveToolDetailResponse) field255Length() int { + l := 0 + if p.IsSetBaseResp() { + l += thrift.Binary.FieldBeginLength() + l += p.BaseResp.BLength() + } + return l +} + +func (p *SaveToolDetailResponse) DeepCopy(s interface{}) error { + src, ok := s.(*SaveToolDetailResponse) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + var _baseResp *base.BaseResp + if src.BaseResp != nil { + _baseResp = &base.BaseResp{} + if err := _baseResp.DeepCopy(src.BaseResp); err != nil { + return err + } + } + p.BaseResp = _baseResp + + return nil +} + +func (p *CommitToolDraftRequest) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.I64 { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 2: + if fieldTypeId == thrift.I64 { + l, err = p.FastReadField2(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 11: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField11(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 12: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField12(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 13: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField13(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 255: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField255(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_CommitToolDraftRequest[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *CommitToolDraftRequest) FastReadField1(buf []byte) (int, error) { + offset := 0 + + var _field *int64 + if v, l, err := thrift.Binary.ReadI64(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.ToolID = _field + return offset, nil +} + +func (p *CommitToolDraftRequest) FastReadField2(buf []byte) (int, error) { + offset := 0 + + var _field *int64 + if v, l, err := thrift.Binary.ReadI64(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.WorkspaceID = _field + return offset, nil +} + +func (p *CommitToolDraftRequest) FastReadField11(buf []byte) (int, error) { + offset := 0 + + var _field *string + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.CommitVersion = _field + return offset, nil +} + +func (p *CommitToolDraftRequest) FastReadField12(buf []byte) (int, error) { + offset := 0 + + var _field *string + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.CommitDescription = _field + return offset, nil +} + +func (p *CommitToolDraftRequest) FastReadField13(buf []byte) (int, error) { + offset := 0 + + var _field *string + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.BaseVersion = _field + return offset, nil +} + +func (p *CommitToolDraftRequest) FastReadField255(buf []byte) (int, error) { + offset := 0 + _field := base.NewBase() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Base = _field + return offset, nil +} + +func (p *CommitToolDraftRequest) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *CommitToolDraftRequest) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField1(buf[offset:], w) + offset += p.fastWriteField2(buf[offset:], w) + offset += p.fastWriteField11(buf[offset:], w) + offset += p.fastWriteField12(buf[offset:], w) + offset += p.fastWriteField13(buf[offset:], w) + offset += p.fastWriteField255(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *CommitToolDraftRequest) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + l += p.field2Length() + l += p.field11Length() + l += p.field12Length() + l += p.field13Length() + l += p.field255Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *CommitToolDraftRequest) fastWriteField1(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetToolID() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.I64, 1) + offset += thrift.Binary.WriteI64(buf[offset:], *p.ToolID) + } + return offset +} + +func (p *CommitToolDraftRequest) fastWriteField2(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetWorkspaceID() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.I64, 2) + offset += thrift.Binary.WriteI64(buf[offset:], *p.WorkspaceID) + } + return offset +} + +func (p *CommitToolDraftRequest) fastWriteField11(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetCommitVersion() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRING, 11) + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, *p.CommitVersion) + } + return offset +} + +func (p *CommitToolDraftRequest) fastWriteField12(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetCommitDescription() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRING, 12) + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, *p.CommitDescription) + } + return offset +} + +func (p *CommitToolDraftRequest) fastWriteField13(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetBaseVersion() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRING, 13) + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, *p.BaseVersion) + } + return offset +} + +func (p *CommitToolDraftRequest) fastWriteField255(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetBase() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 255) + offset += p.Base.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *CommitToolDraftRequest) field1Length() int { + l := 0 + if p.IsSetToolID() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.I64Length() + } + return l +} + +func (p *CommitToolDraftRequest) field2Length() int { + l := 0 + if p.IsSetWorkspaceID() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.I64Length() + } + return l +} + +func (p *CommitToolDraftRequest) field11Length() int { + l := 0 + if p.IsSetCommitVersion() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.StringLengthNocopy(*p.CommitVersion) + } + return l +} + +func (p *CommitToolDraftRequest) field12Length() int { + l := 0 + if p.IsSetCommitDescription() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.StringLengthNocopy(*p.CommitDescription) + } + return l +} + +func (p *CommitToolDraftRequest) field13Length() int { + l := 0 + if p.IsSetBaseVersion() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.StringLengthNocopy(*p.BaseVersion) + } + return l +} + +func (p *CommitToolDraftRequest) field255Length() int { + l := 0 + if p.IsSetBase() { + l += thrift.Binary.FieldBeginLength() + l += p.Base.BLength() + } + return l +} + +func (p *CommitToolDraftRequest) DeepCopy(s interface{}) error { + src, ok := s.(*CommitToolDraftRequest) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + if src.ToolID != nil { + tmp := *src.ToolID + p.ToolID = &tmp + } + + if src.WorkspaceID != nil { + tmp := *src.WorkspaceID + p.WorkspaceID = &tmp + } + + if src.CommitVersion != nil { + var tmp string + if *src.CommitVersion != "" { + tmp = kutils.StringDeepCopy(*src.CommitVersion) + } + p.CommitVersion = &tmp + } + + if src.CommitDescription != nil { + var tmp string + if *src.CommitDescription != "" { + tmp = kutils.StringDeepCopy(*src.CommitDescription) + } + p.CommitDescription = &tmp + } + + if src.BaseVersion != nil { + var tmp string + if *src.BaseVersion != "" { + tmp = kutils.StringDeepCopy(*src.BaseVersion) + } + p.BaseVersion = &tmp + } + + var _base *base.Base + if src.Base != nil { + _base = &base.Base{} + if err := _base.DeepCopy(src.Base); err != nil { + return err + } + } + p.Base = _base + + return nil +} + +func (p *CommitToolDraftResponse) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 255: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField255(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_CommitToolDraftResponse[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *CommitToolDraftResponse) FastReadField255(buf []byte) (int, error) { + offset := 0 + _field := base.NewBaseResp() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.BaseResp = _field + return offset, nil +} + +func (p *CommitToolDraftResponse) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *CommitToolDraftResponse) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField255(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *CommitToolDraftResponse) BLength() int { + l := 0 + if p != nil { + l += p.field255Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *CommitToolDraftResponse) fastWriteField255(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetBaseResp() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 255) + offset += p.BaseResp.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *CommitToolDraftResponse) field255Length() int { + l := 0 + if p.IsSetBaseResp() { + l += thrift.Binary.FieldBeginLength() + l += p.BaseResp.BLength() + } + return l +} + +func (p *CommitToolDraftResponse) DeepCopy(s interface{}) error { + src, ok := s.(*CommitToolDraftResponse) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + var _baseResp *base.BaseResp + if src.BaseResp != nil { + _baseResp = &base.BaseResp{} + if err := _baseResp.DeepCopy(src.BaseResp); err != nil { + return err + } + } + p.BaseResp = _baseResp + + return nil +} + +func (p *ListToolCommitRequest) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.I64 { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 2: + if fieldTypeId == thrift.I64 { + l, err = p.FastReadField2(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 3: + if fieldTypeId == thrift.BOOL { + l, err = p.FastReadField3(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 127: + if fieldTypeId == thrift.I32 { + l, err = p.FastReadField127(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 128: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField128(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 129: + if fieldTypeId == thrift.BOOL { + l, err = p.FastReadField129(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 255: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField255(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ListToolCommitRequest[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *ListToolCommitRequest) FastReadField1(buf []byte) (int, error) { + offset := 0 + + var _field *int64 + if v, l, err := thrift.Binary.ReadI64(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.ToolID = _field + return offset, nil +} + +func (p *ListToolCommitRequest) FastReadField2(buf []byte) (int, error) { + offset := 0 + + var _field *int64 + if v, l, err := thrift.Binary.ReadI64(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.WorkspaceID = _field + return offset, nil +} + +func (p *ListToolCommitRequest) FastReadField3(buf []byte) (int, error) { + offset := 0 + + var _field *bool + if v, l, err := thrift.Binary.ReadBool(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.WithCommitDetail = _field + return offset, nil +} + +func (p *ListToolCommitRequest) FastReadField127(buf []byte) (int, error) { + offset := 0 + + var _field *int32 + if v, l, err := thrift.Binary.ReadI32(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.PageSize = _field + return offset, nil +} + +func (p *ListToolCommitRequest) FastReadField128(buf []byte) (int, error) { + offset := 0 + + var _field *string + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.PageToken = _field + return offset, nil +} + +func (p *ListToolCommitRequest) FastReadField129(buf []byte) (int, error) { + offset := 0 + + var _field *bool + if v, l, err := thrift.Binary.ReadBool(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.Asc = _field + return offset, nil +} + +func (p *ListToolCommitRequest) FastReadField255(buf []byte) (int, error) { + offset := 0 + _field := base.NewBase() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Base = _field + return offset, nil +} + +func (p *ListToolCommitRequest) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *ListToolCommitRequest) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField1(buf[offset:], w) + offset += p.fastWriteField2(buf[offset:], w) + offset += p.fastWriteField3(buf[offset:], w) + offset += p.fastWriteField127(buf[offset:], w) + offset += p.fastWriteField129(buf[offset:], w) + offset += p.fastWriteField128(buf[offset:], w) + offset += p.fastWriteField255(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *ListToolCommitRequest) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + l += p.field2Length() + l += p.field3Length() + l += p.field127Length() + l += p.field128Length() + l += p.field129Length() + l += p.field255Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *ListToolCommitRequest) fastWriteField1(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetToolID() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.I64, 1) + offset += thrift.Binary.WriteI64(buf[offset:], *p.ToolID) + } + return offset +} + +func (p *ListToolCommitRequest) fastWriteField2(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetWorkspaceID() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.I64, 2) + offset += thrift.Binary.WriteI64(buf[offset:], *p.WorkspaceID) + } + return offset +} + +func (p *ListToolCommitRequest) fastWriteField3(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetWithCommitDetail() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.BOOL, 3) + offset += thrift.Binary.WriteBool(buf[offset:], *p.WithCommitDetail) + } + return offset +} + +func (p *ListToolCommitRequest) fastWriteField127(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetPageSize() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.I32, 127) + offset += thrift.Binary.WriteI32(buf[offset:], *p.PageSize) + } + return offset +} + +func (p *ListToolCommitRequest) fastWriteField128(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetPageToken() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRING, 128) + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, *p.PageToken) + } + return offset +} + +func (p *ListToolCommitRequest) fastWriteField129(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetAsc() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.BOOL, 129) + offset += thrift.Binary.WriteBool(buf[offset:], *p.Asc) + } + return offset +} + +func (p *ListToolCommitRequest) fastWriteField255(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetBase() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 255) + offset += p.Base.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *ListToolCommitRequest) field1Length() int { + l := 0 + if p.IsSetToolID() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.I64Length() + } + return l +} + +func (p *ListToolCommitRequest) field2Length() int { + l := 0 + if p.IsSetWorkspaceID() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.I64Length() + } + return l +} + +func (p *ListToolCommitRequest) field3Length() int { + l := 0 + if p.IsSetWithCommitDetail() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.BoolLength() + } + return l +} + +func (p *ListToolCommitRequest) field127Length() int { + l := 0 + if p.IsSetPageSize() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.I32Length() + } + return l +} + +func (p *ListToolCommitRequest) field128Length() int { + l := 0 + if p.IsSetPageToken() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.StringLengthNocopy(*p.PageToken) + } + return l +} + +func (p *ListToolCommitRequest) field129Length() int { + l := 0 + if p.IsSetAsc() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.BoolLength() + } + return l +} + +func (p *ListToolCommitRequest) field255Length() int { + l := 0 + if p.IsSetBase() { + l += thrift.Binary.FieldBeginLength() + l += p.Base.BLength() + } + return l +} + +func (p *ListToolCommitRequest) DeepCopy(s interface{}) error { + src, ok := s.(*ListToolCommitRequest) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + if src.ToolID != nil { + tmp := *src.ToolID + p.ToolID = &tmp + } + + if src.WorkspaceID != nil { + tmp := *src.WorkspaceID + p.WorkspaceID = &tmp + } + + if src.WithCommitDetail != nil { + tmp := *src.WithCommitDetail + p.WithCommitDetail = &tmp + } + + if src.PageSize != nil { + tmp := *src.PageSize + p.PageSize = &tmp + } + + if src.PageToken != nil { + var tmp string + if *src.PageToken != "" { + tmp = kutils.StringDeepCopy(*src.PageToken) + } + p.PageToken = &tmp + } + + if src.Asc != nil { + tmp := *src.Asc + p.Asc = &tmp + } + + var _base *base.Base + if src.Base != nil { + _base = &base.Base{} + if err := _base.DeepCopy(src.Base); err != nil { + return err + } + } + p.Base = _base + + return nil +} + +func (p *ListToolCommitResponse) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.LIST { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 2: + if fieldTypeId == thrift.MAP { + l, err = p.FastReadField2(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 11: + if fieldTypeId == thrift.LIST { + l, err = p.FastReadField11(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 127: + if fieldTypeId == thrift.BOOL { + l, err = p.FastReadField127(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 128: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField128(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 255: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField255(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ListToolCommitResponse[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *ListToolCommitResponse) FastReadField1(buf []byte) (int, error) { + offset := 0 + + _, size, l, err := thrift.Binary.ReadListBegin(buf[offset:]) + offset += l + if err != nil { + return offset, err + } + _field := make([]*tool.CommitInfo, 0, size) + values := make([]tool.CommitInfo, size) + for i := 0; i < size; i++ { + _elem := &values[i] + _elem.InitDefault() + if l, err := _elem.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + + _field = append(_field, _elem) + } + p.ToolCommitInfos = _field + return offset, nil +} + +func (p *ListToolCommitResponse) FastReadField2(buf []byte) (int, error) { + offset := 0 + + _, _, size, l, err := thrift.Binary.ReadMapBegin(buf[offset:]) + offset += l + if err != nil { + return offset, err + } + _field := make(map[string]*tool.ToolDetail, size) + values := make([]tool.ToolDetail, size) + for i := 0; i < size; i++ { + var _key string + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _key = v + } + + _val := &values[i] + _val.InitDefault() + if l, err := _val.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + + _field[_key] = _val + } + p.ToolCommitDetailMapping = _field + return offset, nil +} + +func (p *ListToolCommitResponse) FastReadField11(buf []byte) (int, error) { + offset := 0 + + _, size, l, err := thrift.Binary.ReadListBegin(buf[offset:]) + offset += l + if err != nil { + return offset, err + } + _field := make([]*user.UserInfoDetail, 0, size) + values := make([]user.UserInfoDetail, size) + for i := 0; i < size; i++ { + _elem := &values[i] + _elem.InitDefault() + if l, err := _elem.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + + _field = append(_field, _elem) + } + p.Users = _field + return offset, nil +} + +func (p *ListToolCommitResponse) FastReadField127(buf []byte) (int, error) { + offset := 0 + + var _field *bool + if v, l, err := thrift.Binary.ReadBool(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.HasMore = _field + return offset, nil +} + +func (p *ListToolCommitResponse) FastReadField128(buf []byte) (int, error) { + offset := 0 + + var _field *string + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.NextPageToken = _field + return offset, nil +} + +func (p *ListToolCommitResponse) FastReadField255(buf []byte) (int, error) { + offset := 0 + _field := base.NewBaseResp() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.BaseResp = _field + return offset, nil +} + +func (p *ListToolCommitResponse) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *ListToolCommitResponse) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField127(buf[offset:], w) + offset += p.fastWriteField1(buf[offset:], w) + offset += p.fastWriteField2(buf[offset:], w) + offset += p.fastWriteField11(buf[offset:], w) + offset += p.fastWriteField128(buf[offset:], w) + offset += p.fastWriteField255(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *ListToolCommitResponse) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + l += p.field2Length() + l += p.field11Length() + l += p.field127Length() + l += p.field128Length() + l += p.field255Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *ListToolCommitResponse) fastWriteField1(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetToolCommitInfos() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.LIST, 1) + listBeginOffset := offset + offset += thrift.Binary.ListBeginLength() + var length int + for _, v := range p.ToolCommitInfos { + length++ + offset += v.FastWriteNocopy(buf[offset:], w) + } + thrift.Binary.WriteListBegin(buf[listBeginOffset:], thrift.STRUCT, length) + } + return offset +} + +func (p *ListToolCommitResponse) fastWriteField2(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetToolCommitDetailMapping() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.MAP, 2) + mapBeginOffset := offset + offset += thrift.Binary.MapBeginLength() + var length int + for k, v := range p.ToolCommitDetailMapping { + length++ + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, k) + offset += v.FastWriteNocopy(buf[offset:], w) + } + thrift.Binary.WriteMapBegin(buf[mapBeginOffset:], thrift.STRING, thrift.STRUCT, length) + } + return offset +} + +func (p *ListToolCommitResponse) fastWriteField11(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetUsers() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.LIST, 11) + listBeginOffset := offset + offset += thrift.Binary.ListBeginLength() + var length int + for _, v := range p.Users { + length++ + offset += v.FastWriteNocopy(buf[offset:], w) + } + thrift.Binary.WriteListBegin(buf[listBeginOffset:], thrift.STRUCT, length) + } + return offset +} + +func (p *ListToolCommitResponse) fastWriteField127(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetHasMore() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.BOOL, 127) + offset += thrift.Binary.WriteBool(buf[offset:], *p.HasMore) + } + return offset +} + +func (p *ListToolCommitResponse) fastWriteField128(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetNextPageToken() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRING, 128) + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, *p.NextPageToken) + } + return offset +} + +func (p *ListToolCommitResponse) fastWriteField255(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetBaseResp() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 255) + offset += p.BaseResp.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *ListToolCommitResponse) field1Length() int { + l := 0 + if p.IsSetToolCommitInfos() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.ListBeginLength() + for _, v := range p.ToolCommitInfos { + _ = v + l += v.BLength() + } + } + return l +} + +func (p *ListToolCommitResponse) field2Length() int { + l := 0 + if p.IsSetToolCommitDetailMapping() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.MapBeginLength() + for k, v := range p.ToolCommitDetailMapping { + _, _ = k, v + + l += thrift.Binary.StringLengthNocopy(k) + l += v.BLength() + } + } + return l +} + +func (p *ListToolCommitResponse) field11Length() int { + l := 0 + if p.IsSetUsers() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.ListBeginLength() + for _, v := range p.Users { + _ = v + l += v.BLength() + } + } + return l +} + +func (p *ListToolCommitResponse) field127Length() int { + l := 0 + if p.IsSetHasMore() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.BoolLength() + } + return l +} + +func (p *ListToolCommitResponse) field128Length() int { + l := 0 + if p.IsSetNextPageToken() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.StringLengthNocopy(*p.NextPageToken) + } + return l +} + +func (p *ListToolCommitResponse) field255Length() int { + l := 0 + if p.IsSetBaseResp() { + l += thrift.Binary.FieldBeginLength() + l += p.BaseResp.BLength() + } + return l +} + +func (p *ListToolCommitResponse) DeepCopy(s interface{}) error { + src, ok := s.(*ListToolCommitResponse) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + if src.ToolCommitInfos != nil { + p.ToolCommitInfos = make([]*tool.CommitInfo, 0, len(src.ToolCommitInfos)) + for _, elem := range src.ToolCommitInfos { + var _elem *tool.CommitInfo + if elem != nil { + _elem = &tool.CommitInfo{} + if err := _elem.DeepCopy(elem); err != nil { + return err + } + } + + p.ToolCommitInfos = append(p.ToolCommitInfos, _elem) + } + } + + if src.ToolCommitDetailMapping != nil { + p.ToolCommitDetailMapping = make(map[string]*tool.ToolDetail, len(src.ToolCommitDetailMapping)) + for key, val := range src.ToolCommitDetailMapping { + var _key string + if key != "" { + _key = kutils.StringDeepCopy(key) + } + + var _val *tool.ToolDetail + if val != nil { + _val = &tool.ToolDetail{} + if err := _val.DeepCopy(val); err != nil { + return err + } + } + + p.ToolCommitDetailMapping[_key] = _val + } + } + + if src.Users != nil { + p.Users = make([]*user.UserInfoDetail, 0, len(src.Users)) + for _, elem := range src.Users { + var _elem *user.UserInfoDetail + if elem != nil { + _elem = &user.UserInfoDetail{} + if err := _elem.DeepCopy(elem); err != nil { + return err + } + } + + p.Users = append(p.Users, _elem) + } + } + + if src.HasMore != nil { + tmp := *src.HasMore + p.HasMore = &tmp + } + + if src.NextPageToken != nil { + var tmp string + if *src.NextPageToken != "" { + tmp = kutils.StringDeepCopy(*src.NextPageToken) + } + p.NextPageToken = &tmp + } + + var _baseResp *base.BaseResp + if src.BaseResp != nil { + _baseResp = &base.BaseResp{} + if err := _baseResp.DeepCopy(src.BaseResp); err != nil { + return err + } + } + p.BaseResp = _baseResp + + return nil +} + +func (p *ToolManageServiceCreateToolArgs) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceCreateToolArgs[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *ToolManageServiceCreateToolArgs) FastReadField1(buf []byte) (int, error) { + offset := 0 + _field := NewCreateToolRequest() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Request = _field + return offset, nil +} + +func (p *ToolManageServiceCreateToolArgs) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *ToolManageServiceCreateToolArgs) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField1(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *ToolManageServiceCreateToolArgs) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *ToolManageServiceCreateToolArgs) fastWriteField1(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 1) + offset += p.Request.FastWriteNocopy(buf[offset:], w) + return offset +} + +func (p *ToolManageServiceCreateToolArgs) field1Length() int { + l := 0 + l += thrift.Binary.FieldBeginLength() + l += p.Request.BLength() + return l +} + +func (p *ToolManageServiceCreateToolArgs) DeepCopy(s interface{}) error { + src, ok := s.(*ToolManageServiceCreateToolArgs) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + var _request *CreateToolRequest + if src.Request != nil { + _request = &CreateToolRequest{} + if err := _request.DeepCopy(src.Request); err != nil { + return err + } + } + p.Request = _request + + return nil +} + +func (p *ToolManageServiceCreateToolResult) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 0: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField0(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceCreateToolResult[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *ToolManageServiceCreateToolResult) FastReadField0(buf []byte) (int, error) { + offset := 0 + _field := NewCreateToolResponse() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Success = _field + return offset, nil +} + +func (p *ToolManageServiceCreateToolResult) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *ToolManageServiceCreateToolResult) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField0(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *ToolManageServiceCreateToolResult) BLength() int { + l := 0 + if p != nil { + l += p.field0Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *ToolManageServiceCreateToolResult) fastWriteField0(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetSuccess() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 0) + offset += p.Success.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *ToolManageServiceCreateToolResult) field0Length() int { + l := 0 + if p.IsSetSuccess() { + l += thrift.Binary.FieldBeginLength() + l += p.Success.BLength() + } + return l +} + +func (p *ToolManageServiceCreateToolResult) DeepCopy(s interface{}) error { + src, ok := s.(*ToolManageServiceCreateToolResult) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + var _success *CreateToolResponse + if src.Success != nil { + _success = &CreateToolResponse{} + if err := _success.DeepCopy(src.Success); err != nil { + return err + } + } + p.Success = _success + + return nil +} + +func (p *ToolManageServiceGetToolDetailArgs) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceGetToolDetailArgs[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *ToolManageServiceGetToolDetailArgs) FastReadField1(buf []byte) (int, error) { + offset := 0 + _field := NewGetToolDetailRequest() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Request = _field + return offset, nil +} + +func (p *ToolManageServiceGetToolDetailArgs) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *ToolManageServiceGetToolDetailArgs) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField1(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *ToolManageServiceGetToolDetailArgs) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *ToolManageServiceGetToolDetailArgs) fastWriteField1(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 1) + offset += p.Request.FastWriteNocopy(buf[offset:], w) + return offset +} + +func (p *ToolManageServiceGetToolDetailArgs) field1Length() int { + l := 0 + l += thrift.Binary.FieldBeginLength() + l += p.Request.BLength() + return l +} + +func (p *ToolManageServiceGetToolDetailArgs) DeepCopy(s interface{}) error { + src, ok := s.(*ToolManageServiceGetToolDetailArgs) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + var _request *GetToolDetailRequest + if src.Request != nil { + _request = &GetToolDetailRequest{} + if err := _request.DeepCopy(src.Request); err != nil { + return err + } + } + p.Request = _request + + return nil +} + +func (p *ToolManageServiceGetToolDetailResult) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 0: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField0(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceGetToolDetailResult[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *ToolManageServiceGetToolDetailResult) FastReadField0(buf []byte) (int, error) { + offset := 0 + _field := NewGetToolDetailResponse() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Success = _field + return offset, nil +} + +func (p *ToolManageServiceGetToolDetailResult) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *ToolManageServiceGetToolDetailResult) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField0(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *ToolManageServiceGetToolDetailResult) BLength() int { + l := 0 + if p != nil { + l += p.field0Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *ToolManageServiceGetToolDetailResult) fastWriteField0(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetSuccess() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 0) + offset += p.Success.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *ToolManageServiceGetToolDetailResult) field0Length() int { + l := 0 + if p.IsSetSuccess() { + l += thrift.Binary.FieldBeginLength() + l += p.Success.BLength() + } + return l +} + +func (p *ToolManageServiceGetToolDetailResult) DeepCopy(s interface{}) error { + src, ok := s.(*ToolManageServiceGetToolDetailResult) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + var _success *GetToolDetailResponse + if src.Success != nil { + _success = &GetToolDetailResponse{} + if err := _success.DeepCopy(src.Success); err != nil { + return err + } + } + p.Success = _success + + return nil +} + +func (p *ToolManageServiceListToolArgs) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceListToolArgs[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *ToolManageServiceListToolArgs) FastReadField1(buf []byte) (int, error) { + offset := 0 + _field := NewListToolRequest() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Request = _field + return offset, nil +} + +func (p *ToolManageServiceListToolArgs) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *ToolManageServiceListToolArgs) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField1(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *ToolManageServiceListToolArgs) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *ToolManageServiceListToolArgs) fastWriteField1(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 1) + offset += p.Request.FastWriteNocopy(buf[offset:], w) + return offset +} + +func (p *ToolManageServiceListToolArgs) field1Length() int { + l := 0 + l += thrift.Binary.FieldBeginLength() + l += p.Request.BLength() + return l +} + +func (p *ToolManageServiceListToolArgs) DeepCopy(s interface{}) error { + src, ok := s.(*ToolManageServiceListToolArgs) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + var _request *ListToolRequest + if src.Request != nil { + _request = &ListToolRequest{} + if err := _request.DeepCopy(src.Request); err != nil { + return err + } + } + p.Request = _request + + return nil +} + +func (p *ToolManageServiceListToolResult) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 0: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField0(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceListToolResult[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *ToolManageServiceListToolResult) FastReadField0(buf []byte) (int, error) { + offset := 0 + _field := NewListToolResponse() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Success = _field + return offset, nil +} + +func (p *ToolManageServiceListToolResult) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *ToolManageServiceListToolResult) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField0(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *ToolManageServiceListToolResult) BLength() int { + l := 0 + if p != nil { + l += p.field0Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *ToolManageServiceListToolResult) fastWriteField0(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetSuccess() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 0) + offset += p.Success.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *ToolManageServiceListToolResult) field0Length() int { + l := 0 + if p.IsSetSuccess() { + l += thrift.Binary.FieldBeginLength() + l += p.Success.BLength() + } + return l +} + +func (p *ToolManageServiceListToolResult) DeepCopy(s interface{}) error { + src, ok := s.(*ToolManageServiceListToolResult) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + var _success *ListToolResponse + if src.Success != nil { + _success = &ListToolResponse{} + if err := _success.DeepCopy(src.Success); err != nil { + return err + } + } + p.Success = _success + + return nil +} + +func (p *ToolManageServiceSaveToolDetailArgs) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceSaveToolDetailArgs[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *ToolManageServiceSaveToolDetailArgs) FastReadField1(buf []byte) (int, error) { + offset := 0 + _field := NewSaveToolDetailRequest() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Request = _field + return offset, nil +} + +func (p *ToolManageServiceSaveToolDetailArgs) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *ToolManageServiceSaveToolDetailArgs) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField1(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *ToolManageServiceSaveToolDetailArgs) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *ToolManageServiceSaveToolDetailArgs) fastWriteField1(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 1) + offset += p.Request.FastWriteNocopy(buf[offset:], w) + return offset +} + +func (p *ToolManageServiceSaveToolDetailArgs) field1Length() int { + l := 0 + l += thrift.Binary.FieldBeginLength() + l += p.Request.BLength() + return l +} + +func (p *ToolManageServiceSaveToolDetailArgs) DeepCopy(s interface{}) error { + src, ok := s.(*ToolManageServiceSaveToolDetailArgs) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + var _request *SaveToolDetailRequest + if src.Request != nil { + _request = &SaveToolDetailRequest{} + if err := _request.DeepCopy(src.Request); err != nil { + return err + } + } + p.Request = _request + + return nil +} + +func (p *ToolManageServiceSaveToolDetailResult) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 0: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField0(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceSaveToolDetailResult[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *ToolManageServiceSaveToolDetailResult) FastReadField0(buf []byte) (int, error) { + offset := 0 + _field := NewSaveToolDetailResponse() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Success = _field + return offset, nil +} + +func (p *ToolManageServiceSaveToolDetailResult) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *ToolManageServiceSaveToolDetailResult) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField0(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *ToolManageServiceSaveToolDetailResult) BLength() int { + l := 0 + if p != nil { + l += p.field0Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *ToolManageServiceSaveToolDetailResult) fastWriteField0(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetSuccess() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 0) + offset += p.Success.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *ToolManageServiceSaveToolDetailResult) field0Length() int { + l := 0 + if p.IsSetSuccess() { + l += thrift.Binary.FieldBeginLength() + l += p.Success.BLength() + } + return l +} + +func (p *ToolManageServiceSaveToolDetailResult) DeepCopy(s interface{}) error { + src, ok := s.(*ToolManageServiceSaveToolDetailResult) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + var _success *SaveToolDetailResponse + if src.Success != nil { + _success = &SaveToolDetailResponse{} + if err := _success.DeepCopy(src.Success); err != nil { + return err + } + } + p.Success = _success + + return nil +} + +func (p *ToolManageServiceCommitToolDraftArgs) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceCommitToolDraftArgs[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *ToolManageServiceCommitToolDraftArgs) FastReadField1(buf []byte) (int, error) { + offset := 0 + _field := NewCommitToolDraftRequest() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Request = _field + return offset, nil +} + +func (p *ToolManageServiceCommitToolDraftArgs) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *ToolManageServiceCommitToolDraftArgs) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField1(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *ToolManageServiceCommitToolDraftArgs) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *ToolManageServiceCommitToolDraftArgs) fastWriteField1(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 1) + offset += p.Request.FastWriteNocopy(buf[offset:], w) + return offset +} + +func (p *ToolManageServiceCommitToolDraftArgs) field1Length() int { + l := 0 + l += thrift.Binary.FieldBeginLength() + l += p.Request.BLength() + return l +} + +func (p *ToolManageServiceCommitToolDraftArgs) DeepCopy(s interface{}) error { + src, ok := s.(*ToolManageServiceCommitToolDraftArgs) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + var _request *CommitToolDraftRequest + if src.Request != nil { + _request = &CommitToolDraftRequest{} + if err := _request.DeepCopy(src.Request); err != nil { + return err + } + } + p.Request = _request + + return nil +} + +func (p *ToolManageServiceCommitToolDraftResult) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 0: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField0(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceCommitToolDraftResult[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *ToolManageServiceCommitToolDraftResult) FastReadField0(buf []byte) (int, error) { + offset := 0 + _field := NewCommitToolDraftResponse() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Success = _field + return offset, nil +} + +func (p *ToolManageServiceCommitToolDraftResult) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *ToolManageServiceCommitToolDraftResult) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField0(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *ToolManageServiceCommitToolDraftResult) BLength() int { + l := 0 + if p != nil { + l += p.field0Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *ToolManageServiceCommitToolDraftResult) fastWriteField0(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetSuccess() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 0) + offset += p.Success.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *ToolManageServiceCommitToolDraftResult) field0Length() int { + l := 0 + if p.IsSetSuccess() { + l += thrift.Binary.FieldBeginLength() + l += p.Success.BLength() + } + return l +} + +func (p *ToolManageServiceCommitToolDraftResult) DeepCopy(s interface{}) error { + src, ok := s.(*ToolManageServiceCommitToolDraftResult) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + var _success *CommitToolDraftResponse + if src.Success != nil { + _success = &CommitToolDraftResponse{} + if err := _success.DeepCopy(src.Success); err != nil { + return err + } + } + p.Success = _success + + return nil +} + +func (p *ToolManageServiceListToolCommitArgs) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceListToolCommitArgs[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *ToolManageServiceListToolCommitArgs) FastReadField1(buf []byte) (int, error) { + offset := 0 + _field := NewListToolCommitRequest() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Request = _field + return offset, nil +} + +func (p *ToolManageServiceListToolCommitArgs) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *ToolManageServiceListToolCommitArgs) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField1(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *ToolManageServiceListToolCommitArgs) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *ToolManageServiceListToolCommitArgs) fastWriteField1(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 1) + offset += p.Request.FastWriteNocopy(buf[offset:], w) + return offset +} + +func (p *ToolManageServiceListToolCommitArgs) field1Length() int { + l := 0 + l += thrift.Binary.FieldBeginLength() + l += p.Request.BLength() + return l +} + +func (p *ToolManageServiceListToolCommitArgs) DeepCopy(s interface{}) error { + src, ok := s.(*ToolManageServiceListToolCommitArgs) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + var _request *ListToolCommitRequest + if src.Request != nil { + _request = &ListToolCommitRequest{} + if err := _request.DeepCopy(src.Request); err != nil { + return err + } + } + p.Request = _request + + return nil +} + +func (p *ToolManageServiceListToolCommitResult) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 0: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField0(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceListToolCommitResult[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *ToolManageServiceListToolCommitResult) FastReadField0(buf []byte) (int, error) { + offset := 0 + _field := NewListToolCommitResponse() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Success = _field + return offset, nil +} + +func (p *ToolManageServiceListToolCommitResult) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *ToolManageServiceListToolCommitResult) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField0(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *ToolManageServiceListToolCommitResult) BLength() int { + l := 0 + if p != nil { + l += p.field0Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *ToolManageServiceListToolCommitResult) fastWriteField0(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetSuccess() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 0) + offset += p.Success.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *ToolManageServiceListToolCommitResult) field0Length() int { + l := 0 + if p.IsSetSuccess() { + l += thrift.Binary.FieldBeginLength() + l += p.Success.BLength() + } + return l +} + +func (p *ToolManageServiceListToolCommitResult) DeepCopy(s interface{}) error { + src, ok := s.(*ToolManageServiceListToolCommitResult) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + var _success *ListToolCommitResponse + if src.Success != nil { + _success = &ListToolCommitResponse{} + if err := _success.DeepCopy(src.Success); err != nil { + return err + } + } + p.Success = _success + + return nil +} + +func (p *ToolManageServiceCreateToolArgs) GetFirstArgument() interface{} { + return p.Request +} + +func (p *ToolManageServiceCreateToolResult) GetResult() interface{} { + return p.Success +} + +func (p *ToolManageServiceGetToolDetailArgs) GetFirstArgument() interface{} { + return p.Request +} + +func (p *ToolManageServiceGetToolDetailResult) GetResult() interface{} { + return p.Success +} + +func (p *ToolManageServiceListToolArgs) GetFirstArgument() interface{} { + return p.Request +} + +func (p *ToolManageServiceListToolResult) GetResult() interface{} { + return p.Success +} + +func (p *ToolManageServiceSaveToolDetailArgs) GetFirstArgument() interface{} { + return p.Request +} + +func (p *ToolManageServiceSaveToolDetailResult) GetResult() interface{} { + return p.Success +} + +func (p *ToolManageServiceCommitToolDraftArgs) GetFirstArgument() interface{} { + return p.Request +} + +func (p *ToolManageServiceCommitToolDraftResult) GetResult() interface{} { + return p.Success +} + +func (p *ToolManageServiceListToolCommitArgs) GetFirstArgument() interface{} { + return p.Request +} + +func (p *ToolManageServiceListToolCommitResult) GetResult() interface{} { + return p.Success +} diff --git a/backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/client.go b/backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/client.go new file mode 100644 index 000000000..27f94eaad --- /dev/null +++ b/backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/client.go @@ -0,0 +1,79 @@ +// Code generated by Kitex v0.13.1. DO NOT EDIT. + +package toolmanageservice + +import ( + "context" + client "github.com/cloudwego/kitex/client" + callopt "github.com/cloudwego/kitex/client/callopt" + manage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" +) + +// Client is designed to provide IDL-compatible methods with call-option parameter for kitex framework. +type Client interface { + CreateTool(ctx context.Context, request *manage.CreateToolRequest, callOptions ...callopt.Option) (r *manage.CreateToolResponse, err error) + GetToolDetail(ctx context.Context, request *manage.GetToolDetailRequest, callOptions ...callopt.Option) (r *manage.GetToolDetailResponse, err error) + ListTool(ctx context.Context, request *manage.ListToolRequest, callOptions ...callopt.Option) (r *manage.ListToolResponse, err error) + SaveToolDetail(ctx context.Context, request *manage.SaveToolDetailRequest, callOptions ...callopt.Option) (r *manage.SaveToolDetailResponse, err error) + CommitToolDraft(ctx context.Context, request *manage.CommitToolDraftRequest, callOptions ...callopt.Option) (r *manage.CommitToolDraftResponse, err error) + ListToolCommit(ctx context.Context, request *manage.ListToolCommitRequest, callOptions ...callopt.Option) (r *manage.ListToolCommitResponse, err error) +} + +// NewClient creates a client for the service defined in IDL. +func NewClient(destService string, opts ...client.Option) (Client, error) { + var options []client.Option + options = append(options, client.WithDestService(destService)) + + options = append(options, opts...) + + kc, err := client.NewClient(serviceInfo(), options...) + if err != nil { + return nil, err + } + return &kToolManageServiceClient{ + kClient: newServiceClient(kc), + }, nil +} + +// MustNewClient creates a client for the service defined in IDL. It panics if any error occurs. +func MustNewClient(destService string, opts ...client.Option) Client { + kc, err := NewClient(destService, opts...) + if err != nil { + panic(err) + } + return kc +} + +type kToolManageServiceClient struct { + *kClient +} + +func (p *kToolManageServiceClient) CreateTool(ctx context.Context, request *manage.CreateToolRequest, callOptions ...callopt.Option) (r *manage.CreateToolResponse, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.CreateTool(ctx, request) +} + +func (p *kToolManageServiceClient) GetToolDetail(ctx context.Context, request *manage.GetToolDetailRequest, callOptions ...callopt.Option) (r *manage.GetToolDetailResponse, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.GetToolDetail(ctx, request) +} + +func (p *kToolManageServiceClient) ListTool(ctx context.Context, request *manage.ListToolRequest, callOptions ...callopt.Option) (r *manage.ListToolResponse, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.ListTool(ctx, request) +} + +func (p *kToolManageServiceClient) SaveToolDetail(ctx context.Context, request *manage.SaveToolDetailRequest, callOptions ...callopt.Option) (r *manage.SaveToolDetailResponse, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.SaveToolDetail(ctx, request) +} + +func (p *kToolManageServiceClient) CommitToolDraft(ctx context.Context, request *manage.CommitToolDraftRequest, callOptions ...callopt.Option) (r *manage.CommitToolDraftResponse, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.CommitToolDraft(ctx, request) +} + +func (p *kToolManageServiceClient) ListToolCommit(ctx context.Context, request *manage.ListToolCommitRequest, callOptions ...callopt.Option) (r *manage.ListToolCommitResponse, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.ListToolCommit(ctx, request) +} diff --git a/backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/server.go b/backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/server.go new file mode 100644 index 000000000..7fed1bd14 --- /dev/null +++ b/backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/server.go @@ -0,0 +1,25 @@ +// Code generated by Kitex v0.13.1. DO NOT EDIT. +package toolmanageservice + +import ( + server "github.com/cloudwego/kitex/server" + manage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" +) + +// NewServer creates a server.Server with the given handler and options. +func NewServer(handler manage.ToolManageService, opts ...server.Option) server.Server { + var options []server.Option + + options = append(options, opts...) + options = append(options, server.WithCompatibleMiddlewareForUnary()) + + svr := server.NewServer(options...) + if err := svr.RegisterService(serviceInfo(), handler); err != nil { + panic(err) + } + return svr +} + +func RegisterService(svr server.Server, handler manage.ToolManageService, opts ...server.RegisterOption) error { + return svr.RegisterService(serviceInfo(), handler, opts...) +} diff --git a/backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/toolmanageservice.go b/backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/toolmanageservice.go new file mode 100644 index 000000000..258a2d690 --- /dev/null +++ b/backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/toolmanageservice.go @@ -0,0 +1,275 @@ +// Code generated by Kitex v0.13.1. DO NOT EDIT. + +package toolmanageservice + +import ( + "context" + "errors" + client "github.com/cloudwego/kitex/client" + kitex "github.com/cloudwego/kitex/pkg/serviceinfo" + manage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" +) + +var errInvalidMessageType = errors.New("invalid message type for service method handler") + +var serviceMethods = map[string]kitex.MethodInfo{ + "CreateTool": kitex.NewMethodInfo( + createToolHandler, + newToolManageServiceCreateToolArgs, + newToolManageServiceCreateToolResult, + false, + kitex.WithStreamingMode(kitex.StreamingNone), + ), + "GetToolDetail": kitex.NewMethodInfo( + getToolDetailHandler, + newToolManageServiceGetToolDetailArgs, + newToolManageServiceGetToolDetailResult, + false, + kitex.WithStreamingMode(kitex.StreamingNone), + ), + "ListTool": kitex.NewMethodInfo( + listToolHandler, + newToolManageServiceListToolArgs, + newToolManageServiceListToolResult, + false, + kitex.WithStreamingMode(kitex.StreamingNone), + ), + "SaveToolDetail": kitex.NewMethodInfo( + saveToolDetailHandler, + newToolManageServiceSaveToolDetailArgs, + newToolManageServiceSaveToolDetailResult, + false, + kitex.WithStreamingMode(kitex.StreamingNone), + ), + "CommitToolDraft": kitex.NewMethodInfo( + commitToolDraftHandler, + newToolManageServiceCommitToolDraftArgs, + newToolManageServiceCommitToolDraftResult, + false, + kitex.WithStreamingMode(kitex.StreamingNone), + ), + "ListToolCommit": kitex.NewMethodInfo( + listToolCommitHandler, + newToolManageServiceListToolCommitArgs, + newToolManageServiceListToolCommitResult, + false, + kitex.WithStreamingMode(kitex.StreamingNone), + ), +} + +var ( + toolManageServiceServiceInfo = NewServiceInfo() +) + +// for server +func serviceInfo() *kitex.ServiceInfo { + return toolManageServiceServiceInfo +} + +// NewServiceInfo creates a new ServiceInfo +func NewServiceInfo() *kitex.ServiceInfo { + return newServiceInfo() +} + +func newServiceInfo() *kitex.ServiceInfo { + serviceName := "ToolManageService" + handlerType := (*manage.ToolManageService)(nil) + extra := map[string]interface{}{ + "PackageName": "manage", + } + svcInfo := &kitex.ServiceInfo{ + ServiceName: serviceName, + HandlerType: handlerType, + Methods: serviceMethods, + PayloadCodec: kitex.Thrift, + KiteXGenVersion: "v0.13.1", + Extra: extra, + } + return svcInfo +} + +func createToolHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*manage.ToolManageServiceCreateToolArgs) + realResult := result.(*manage.ToolManageServiceCreateToolResult) + success, err := handler.(manage.ToolManageService).CreateTool(ctx, realArg.Request) + if err != nil { + return err + } + realResult.Success = success + return nil +} + +func newToolManageServiceCreateToolArgs() interface{} { + return manage.NewToolManageServiceCreateToolArgs() +} + +func newToolManageServiceCreateToolResult() interface{} { + return manage.NewToolManageServiceCreateToolResult() +} + +func getToolDetailHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*manage.ToolManageServiceGetToolDetailArgs) + realResult := result.(*manage.ToolManageServiceGetToolDetailResult) + success, err := handler.(manage.ToolManageService).GetToolDetail(ctx, realArg.Request) + if err != nil { + return err + } + realResult.Success = success + return nil +} + +func newToolManageServiceGetToolDetailArgs() interface{} { + return manage.NewToolManageServiceGetToolDetailArgs() +} + +func newToolManageServiceGetToolDetailResult() interface{} { + return manage.NewToolManageServiceGetToolDetailResult() +} + +func listToolHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*manage.ToolManageServiceListToolArgs) + realResult := result.(*manage.ToolManageServiceListToolResult) + success, err := handler.(manage.ToolManageService).ListTool(ctx, realArg.Request) + if err != nil { + return err + } + realResult.Success = success + return nil +} + +func newToolManageServiceListToolArgs() interface{} { + return manage.NewToolManageServiceListToolArgs() +} + +func newToolManageServiceListToolResult() interface{} { + return manage.NewToolManageServiceListToolResult() +} + +func saveToolDetailHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*manage.ToolManageServiceSaveToolDetailArgs) + realResult := result.(*manage.ToolManageServiceSaveToolDetailResult) + success, err := handler.(manage.ToolManageService).SaveToolDetail(ctx, realArg.Request) + if err != nil { + return err + } + realResult.Success = success + return nil +} + +func newToolManageServiceSaveToolDetailArgs() interface{} { + return manage.NewToolManageServiceSaveToolDetailArgs() +} + +func newToolManageServiceSaveToolDetailResult() interface{} { + return manage.NewToolManageServiceSaveToolDetailResult() +} + +func commitToolDraftHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*manage.ToolManageServiceCommitToolDraftArgs) + realResult := result.(*manage.ToolManageServiceCommitToolDraftResult) + success, err := handler.(manage.ToolManageService).CommitToolDraft(ctx, realArg.Request) + if err != nil { + return err + } + realResult.Success = success + return nil +} + +func newToolManageServiceCommitToolDraftArgs() interface{} { + return manage.NewToolManageServiceCommitToolDraftArgs() +} + +func newToolManageServiceCommitToolDraftResult() interface{} { + return manage.NewToolManageServiceCommitToolDraftResult() +} + +func listToolCommitHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*manage.ToolManageServiceListToolCommitArgs) + realResult := result.(*manage.ToolManageServiceListToolCommitResult) + success, err := handler.(manage.ToolManageService).ListToolCommit(ctx, realArg.Request) + if err != nil { + return err + } + realResult.Success = success + return nil +} + +func newToolManageServiceListToolCommitArgs() interface{} { + return manage.NewToolManageServiceListToolCommitArgs() +} + +func newToolManageServiceListToolCommitResult() interface{} { + return manage.NewToolManageServiceListToolCommitResult() +} + +type kClient struct { + c client.Client + sc client.Streaming +} + +func newServiceClient(c client.Client) *kClient { + return &kClient{ + c: c, + sc: c.(client.Streaming), + } +} + +func (p *kClient) CreateTool(ctx context.Context, request *manage.CreateToolRequest) (r *manage.CreateToolResponse, err error) { + var _args manage.ToolManageServiceCreateToolArgs + _args.Request = request + var _result manage.ToolManageServiceCreateToolResult + if err = p.c.Call(ctx, "CreateTool", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} + +func (p *kClient) GetToolDetail(ctx context.Context, request *manage.GetToolDetailRequest) (r *manage.GetToolDetailResponse, err error) { + var _args manage.ToolManageServiceGetToolDetailArgs + _args.Request = request + var _result manage.ToolManageServiceGetToolDetailResult + if err = p.c.Call(ctx, "GetToolDetail", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} + +func (p *kClient) ListTool(ctx context.Context, request *manage.ListToolRequest) (r *manage.ListToolResponse, err error) { + var _args manage.ToolManageServiceListToolArgs + _args.Request = request + var _result manage.ToolManageServiceListToolResult + if err = p.c.Call(ctx, "ListTool", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} + +func (p *kClient) SaveToolDetail(ctx context.Context, request *manage.SaveToolDetailRequest) (r *manage.SaveToolDetailResponse, err error) { + var _args manage.ToolManageServiceSaveToolDetailArgs + _args.Request = request + var _result manage.ToolManageServiceSaveToolDetailResult + if err = p.c.Call(ctx, "SaveToolDetail", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} + +func (p *kClient) CommitToolDraft(ctx context.Context, request *manage.CommitToolDraftRequest) (r *manage.CommitToolDraftResponse, err error) { + var _args manage.ToolManageServiceCommitToolDraftArgs + _args.Request = request + var _result manage.ToolManageServiceCommitToolDraftResult + if err = p.c.Call(ctx, "CommitToolDraft", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} + +func (p *kClient) ListToolCommit(ctx context.Context, request *manage.ListToolCommitRequest) (r *manage.ListToolCommitResponse, err error) { + var _args manage.ToolManageServiceListToolCommitArgs + _args.Request = request + var _result manage.ToolManageServiceListToolCommitResult + if err = p.c.Call(ctx, "ListToolCommit", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} diff --git a/backend/kitex_gen/coze/loop/prompt/toolmanageservice/client.go b/backend/kitex_gen/coze/loop/prompt/toolmanageservice/client.go new file mode 100644 index 000000000..27f94eaad --- /dev/null +++ b/backend/kitex_gen/coze/loop/prompt/toolmanageservice/client.go @@ -0,0 +1,79 @@ +// Code generated by Kitex v0.13.1. DO NOT EDIT. + +package toolmanageservice + +import ( + "context" + client "github.com/cloudwego/kitex/client" + callopt "github.com/cloudwego/kitex/client/callopt" + manage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" +) + +// Client is designed to provide IDL-compatible methods with call-option parameter for kitex framework. +type Client interface { + CreateTool(ctx context.Context, request *manage.CreateToolRequest, callOptions ...callopt.Option) (r *manage.CreateToolResponse, err error) + GetToolDetail(ctx context.Context, request *manage.GetToolDetailRequest, callOptions ...callopt.Option) (r *manage.GetToolDetailResponse, err error) + ListTool(ctx context.Context, request *manage.ListToolRequest, callOptions ...callopt.Option) (r *manage.ListToolResponse, err error) + SaveToolDetail(ctx context.Context, request *manage.SaveToolDetailRequest, callOptions ...callopt.Option) (r *manage.SaveToolDetailResponse, err error) + CommitToolDraft(ctx context.Context, request *manage.CommitToolDraftRequest, callOptions ...callopt.Option) (r *manage.CommitToolDraftResponse, err error) + ListToolCommit(ctx context.Context, request *manage.ListToolCommitRequest, callOptions ...callopt.Option) (r *manage.ListToolCommitResponse, err error) +} + +// NewClient creates a client for the service defined in IDL. +func NewClient(destService string, opts ...client.Option) (Client, error) { + var options []client.Option + options = append(options, client.WithDestService(destService)) + + options = append(options, opts...) + + kc, err := client.NewClient(serviceInfo(), options...) + if err != nil { + return nil, err + } + return &kToolManageServiceClient{ + kClient: newServiceClient(kc), + }, nil +} + +// MustNewClient creates a client for the service defined in IDL. It panics if any error occurs. +func MustNewClient(destService string, opts ...client.Option) Client { + kc, err := NewClient(destService, opts...) + if err != nil { + panic(err) + } + return kc +} + +type kToolManageServiceClient struct { + *kClient +} + +func (p *kToolManageServiceClient) CreateTool(ctx context.Context, request *manage.CreateToolRequest, callOptions ...callopt.Option) (r *manage.CreateToolResponse, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.CreateTool(ctx, request) +} + +func (p *kToolManageServiceClient) GetToolDetail(ctx context.Context, request *manage.GetToolDetailRequest, callOptions ...callopt.Option) (r *manage.GetToolDetailResponse, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.GetToolDetail(ctx, request) +} + +func (p *kToolManageServiceClient) ListTool(ctx context.Context, request *manage.ListToolRequest, callOptions ...callopt.Option) (r *manage.ListToolResponse, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.ListTool(ctx, request) +} + +func (p *kToolManageServiceClient) SaveToolDetail(ctx context.Context, request *manage.SaveToolDetailRequest, callOptions ...callopt.Option) (r *manage.SaveToolDetailResponse, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.SaveToolDetail(ctx, request) +} + +func (p *kToolManageServiceClient) CommitToolDraft(ctx context.Context, request *manage.CommitToolDraftRequest, callOptions ...callopt.Option) (r *manage.CommitToolDraftResponse, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.CommitToolDraft(ctx, request) +} + +func (p *kToolManageServiceClient) ListToolCommit(ctx context.Context, request *manage.ListToolCommitRequest, callOptions ...callopt.Option) (r *manage.ListToolCommitResponse, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.ListToolCommit(ctx, request) +} diff --git a/backend/kitex_gen/coze/loop/prompt/toolmanageservice/server.go b/backend/kitex_gen/coze/loop/prompt/toolmanageservice/server.go new file mode 100644 index 000000000..60e7cb8a0 --- /dev/null +++ b/backend/kitex_gen/coze/loop/prompt/toolmanageservice/server.go @@ -0,0 +1,25 @@ +// Code generated by Kitex v0.13.1. DO NOT EDIT. +package toolmanageservice + +import ( + server "github.com/cloudwego/kitex/server" + prompt "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt" +) + +// NewServer creates a server.Server with the given handler and options. +func NewServer(handler prompt.ToolManageService, opts ...server.Option) server.Server { + var options []server.Option + + options = append(options, opts...) + options = append(options, server.WithCompatibleMiddlewareForUnary()) + + svr := server.NewServer(options...) + if err := svr.RegisterService(serviceInfo(), handler); err != nil { + panic(err) + } + return svr +} + +func RegisterService(svr server.Server, handler prompt.ToolManageService, opts ...server.RegisterOption) error { + return svr.RegisterService(serviceInfo(), handler, opts...) +} diff --git a/backend/kitex_gen/coze/loop/prompt/toolmanageservice/toolmanageservice.go b/backend/kitex_gen/coze/loop/prompt/toolmanageservice/toolmanageservice.go new file mode 100644 index 000000000..736d425d6 --- /dev/null +++ b/backend/kitex_gen/coze/loop/prompt/toolmanageservice/toolmanageservice.go @@ -0,0 +1,276 @@ +// Code generated by Kitex v0.13.1. DO NOT EDIT. + +package toolmanageservice + +import ( + "context" + "errors" + client "github.com/cloudwego/kitex/client" + kitex "github.com/cloudwego/kitex/pkg/serviceinfo" + prompt "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt" + manage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" +) + +var errInvalidMessageType = errors.New("invalid message type for service method handler") + +var serviceMethods = map[string]kitex.MethodInfo{ + "CreateTool": kitex.NewMethodInfo( + createToolHandler, + newToolManageServiceCreateToolArgs, + newToolManageServiceCreateToolResult, + false, + kitex.WithStreamingMode(kitex.StreamingNone), + ), + "GetToolDetail": kitex.NewMethodInfo( + getToolDetailHandler, + newToolManageServiceGetToolDetailArgs, + newToolManageServiceGetToolDetailResult, + false, + kitex.WithStreamingMode(kitex.StreamingNone), + ), + "ListTool": kitex.NewMethodInfo( + listToolHandler, + newToolManageServiceListToolArgs, + newToolManageServiceListToolResult, + false, + kitex.WithStreamingMode(kitex.StreamingNone), + ), + "SaveToolDetail": kitex.NewMethodInfo( + saveToolDetailHandler, + newToolManageServiceSaveToolDetailArgs, + newToolManageServiceSaveToolDetailResult, + false, + kitex.WithStreamingMode(kitex.StreamingNone), + ), + "CommitToolDraft": kitex.NewMethodInfo( + commitToolDraftHandler, + newToolManageServiceCommitToolDraftArgs, + newToolManageServiceCommitToolDraftResult, + false, + kitex.WithStreamingMode(kitex.StreamingNone), + ), + "ListToolCommit": kitex.NewMethodInfo( + listToolCommitHandler, + newToolManageServiceListToolCommitArgs, + newToolManageServiceListToolCommitResult, + false, + kitex.WithStreamingMode(kitex.StreamingNone), + ), +} + +var ( + toolManageServiceServiceInfo = NewServiceInfo() +) + +// for server +func serviceInfo() *kitex.ServiceInfo { + return toolManageServiceServiceInfo +} + +// NewServiceInfo creates a new ServiceInfo +func NewServiceInfo() *kitex.ServiceInfo { + return newServiceInfo() +} + +func newServiceInfo() *kitex.ServiceInfo { + serviceName := "ToolManageService" + handlerType := (*prompt.ToolManageService)(nil) + extra := map[string]interface{}{ + "PackageName": "prompt", + } + svcInfo := &kitex.ServiceInfo{ + ServiceName: serviceName, + HandlerType: handlerType, + Methods: serviceMethods, + PayloadCodec: kitex.Thrift, + KiteXGenVersion: "v0.13.1", + Extra: extra, + } + return svcInfo +} + +func createToolHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*manage.ToolManageServiceCreateToolArgs) + realResult := result.(*manage.ToolManageServiceCreateToolResult) + success, err := handler.(manage.ToolManageService).CreateTool(ctx, realArg.Request) + if err != nil { + return err + } + realResult.Success = success + return nil +} + +func newToolManageServiceCreateToolArgs() interface{} { + return manage.NewToolManageServiceCreateToolArgs() +} + +func newToolManageServiceCreateToolResult() interface{} { + return manage.NewToolManageServiceCreateToolResult() +} + +func getToolDetailHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*manage.ToolManageServiceGetToolDetailArgs) + realResult := result.(*manage.ToolManageServiceGetToolDetailResult) + success, err := handler.(manage.ToolManageService).GetToolDetail(ctx, realArg.Request) + if err != nil { + return err + } + realResult.Success = success + return nil +} + +func newToolManageServiceGetToolDetailArgs() interface{} { + return manage.NewToolManageServiceGetToolDetailArgs() +} + +func newToolManageServiceGetToolDetailResult() interface{} { + return manage.NewToolManageServiceGetToolDetailResult() +} + +func listToolHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*manage.ToolManageServiceListToolArgs) + realResult := result.(*manage.ToolManageServiceListToolResult) + success, err := handler.(manage.ToolManageService).ListTool(ctx, realArg.Request) + if err != nil { + return err + } + realResult.Success = success + return nil +} + +func newToolManageServiceListToolArgs() interface{} { + return manage.NewToolManageServiceListToolArgs() +} + +func newToolManageServiceListToolResult() interface{} { + return manage.NewToolManageServiceListToolResult() +} + +func saveToolDetailHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*manage.ToolManageServiceSaveToolDetailArgs) + realResult := result.(*manage.ToolManageServiceSaveToolDetailResult) + success, err := handler.(manage.ToolManageService).SaveToolDetail(ctx, realArg.Request) + if err != nil { + return err + } + realResult.Success = success + return nil +} + +func newToolManageServiceSaveToolDetailArgs() interface{} { + return manage.NewToolManageServiceSaveToolDetailArgs() +} + +func newToolManageServiceSaveToolDetailResult() interface{} { + return manage.NewToolManageServiceSaveToolDetailResult() +} + +func commitToolDraftHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*manage.ToolManageServiceCommitToolDraftArgs) + realResult := result.(*manage.ToolManageServiceCommitToolDraftResult) + success, err := handler.(manage.ToolManageService).CommitToolDraft(ctx, realArg.Request) + if err != nil { + return err + } + realResult.Success = success + return nil +} + +func newToolManageServiceCommitToolDraftArgs() interface{} { + return manage.NewToolManageServiceCommitToolDraftArgs() +} + +func newToolManageServiceCommitToolDraftResult() interface{} { + return manage.NewToolManageServiceCommitToolDraftResult() +} + +func listToolCommitHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*manage.ToolManageServiceListToolCommitArgs) + realResult := result.(*manage.ToolManageServiceListToolCommitResult) + success, err := handler.(manage.ToolManageService).ListToolCommit(ctx, realArg.Request) + if err != nil { + return err + } + realResult.Success = success + return nil +} + +func newToolManageServiceListToolCommitArgs() interface{} { + return manage.NewToolManageServiceListToolCommitArgs() +} + +func newToolManageServiceListToolCommitResult() interface{} { + return manage.NewToolManageServiceListToolCommitResult() +} + +type kClient struct { + c client.Client + sc client.Streaming +} + +func newServiceClient(c client.Client) *kClient { + return &kClient{ + c: c, + sc: c.(client.Streaming), + } +} + +func (p *kClient) CreateTool(ctx context.Context, request *manage.CreateToolRequest) (r *manage.CreateToolResponse, err error) { + var _args manage.ToolManageServiceCreateToolArgs + _args.Request = request + var _result manage.ToolManageServiceCreateToolResult + if err = p.c.Call(ctx, "CreateTool", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} + +func (p *kClient) GetToolDetail(ctx context.Context, request *manage.GetToolDetailRequest) (r *manage.GetToolDetailResponse, err error) { + var _args manage.ToolManageServiceGetToolDetailArgs + _args.Request = request + var _result manage.ToolManageServiceGetToolDetailResult + if err = p.c.Call(ctx, "GetToolDetail", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} + +func (p *kClient) ListTool(ctx context.Context, request *manage.ListToolRequest) (r *manage.ListToolResponse, err error) { + var _args manage.ToolManageServiceListToolArgs + _args.Request = request + var _result manage.ToolManageServiceListToolResult + if err = p.c.Call(ctx, "ListTool", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} + +func (p *kClient) SaveToolDetail(ctx context.Context, request *manage.SaveToolDetailRequest) (r *manage.SaveToolDetailResponse, err error) { + var _args manage.ToolManageServiceSaveToolDetailArgs + _args.Request = request + var _result manage.ToolManageServiceSaveToolDetailResult + if err = p.c.Call(ctx, "SaveToolDetail", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} + +func (p *kClient) CommitToolDraft(ctx context.Context, request *manage.CommitToolDraftRequest) (r *manage.CommitToolDraftResponse, err error) { + var _args manage.ToolManageServiceCommitToolDraftArgs + _args.Request = request + var _result manage.ToolManageServiceCommitToolDraftResult + if err = p.c.Call(ctx, "CommitToolDraft", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} + +func (p *kClient) ListToolCommit(ctx context.Context, request *manage.ListToolCommitRequest) (r *manage.ListToolCommitResponse, err error) { + var _args manage.ToolManageServiceListToolCommitArgs + _args.Request = request + var _result manage.ToolManageServiceListToolCommitResult + if err = p.c.Call(ctx, "ListToolCommit", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} diff --git a/backend/loop_gen/coze/loop/observability/loingestion/local_ingestionservice.go b/backend/loop_gen/coze/loop/observability/loingestion/local_ingestionservice.go new file mode 100644 index 000000000..e93d66820 --- /dev/null +++ b/backend/loop_gen/coze/loop/observability/loingestion/local_ingestionservice.go @@ -0,0 +1,34 @@ +// Code generated by cozeloop. DO NOT EDIT. +package loingestion // import github.com/coze-dev/coze-loop/backend/loingestion + +import ( + "context" + + "github.com/cloudwego/kitex/pkg/endpoint" + "github.com/cloudwego/kitex/pkg/rpcinfo" + "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/observability/ingestion" +) + +type LocalIngestionService struct { + impl ingestion.IngestionService // the service implementation + mds endpoint.Middleware +} + +func NewLocalIngestionService(impl ingestion.IngestionService, mds ...endpoint.Middleware) *LocalIngestionService { + return &LocalIngestionService{ + impl: impl, + mds: endpoint.Chain(mds...), + } +} + +func (l *LocalIngestionService) injectRPCInfo(ctx context.Context, method string) context.Context { + rpcStats := rpcinfo.AsMutableRPCStats(rpcinfo.NewRPCStats()) + ri := rpcinfo.NewRPCInfo( + rpcinfo.NewEndpointInfo("IngestionService", method, nil, nil), + rpcinfo.NewEndpointInfo("IngestionService", method, nil, nil), + rpcinfo.NewServerInvocation(), + nil, + rpcStats.ImmutableView(), + ) + return rpcinfo.NewCtxWithRPCInfo(ctx, ri) +} diff --git a/backend/loop_gen/coze/loop/prompt/tool/lomanage/local_toolmanageservice.go b/backend/loop_gen/coze/loop/prompt/tool/lomanage/local_toolmanageservice.go new file mode 100644 index 000000000..716c6a6e4 --- /dev/null +++ b/backend/loop_gen/coze/loop/prompt/tool/lomanage/local_toolmanageservice.go @@ -0,0 +1,161 @@ +// Code generated by cozeloop. DO NOT EDIT. +package lomanage // import github.com/coze-dev/coze-loop/backend/lomanage + +import ( + "context" + + "github.com/cloudwego/kitex/client/callopt" + "github.com/cloudwego/kitex/pkg/endpoint" + "github.com/cloudwego/kitex/pkg/rpcinfo" + "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" +) + +type LocalToolManageService struct { + impl manage.ToolManageService // the service implementation + mds endpoint.Middleware +} + +func NewLocalToolManageService(impl manage.ToolManageService, mds ...endpoint.Middleware) *LocalToolManageService { + return &LocalToolManageService{ + impl: impl, + mds: endpoint.Chain(mds...), + } +} + +func (l *LocalToolManageService) CreateTool(ctx context.Context, request *manage.CreateToolRequest, callOptions ...callopt.Option) (*manage.CreateToolResponse, error) { + chain := l.mds(func(ctx context.Context, in, out interface{}) error { + arg := in.(*manage.ToolManageServiceCreateToolArgs) + result := out.(*manage.ToolManageServiceCreateToolResult) + resp, err := l.impl.CreateTool(ctx, arg.Request) + if err != nil { + return err + } + result.SetSuccess(resp) + return nil + }) + + arg := &manage.ToolManageServiceCreateToolArgs{Request: request} + result := &manage.ToolManageServiceCreateToolResult{} + ctx = l.injectRPCInfo(ctx, "CreateTool") + if err := chain(ctx, arg, result); err != nil { + return nil, err + } + return result.GetSuccess(), nil +} + +func (l *LocalToolManageService) GetToolDetail(ctx context.Context, request *manage.GetToolDetailRequest, callOptions ...callopt.Option) (*manage.GetToolDetailResponse, error) { + chain := l.mds(func(ctx context.Context, in, out interface{}) error { + arg := in.(*manage.ToolManageServiceGetToolDetailArgs) + result := out.(*manage.ToolManageServiceGetToolDetailResult) + resp, err := l.impl.GetToolDetail(ctx, arg.Request) + if err != nil { + return err + } + result.SetSuccess(resp) + return nil + }) + + arg := &manage.ToolManageServiceGetToolDetailArgs{Request: request} + result := &manage.ToolManageServiceGetToolDetailResult{} + ctx = l.injectRPCInfo(ctx, "GetToolDetail") + if err := chain(ctx, arg, result); err != nil { + return nil, err + } + return result.GetSuccess(), nil +} + +func (l *LocalToolManageService) ListTool(ctx context.Context, request *manage.ListToolRequest, callOptions ...callopt.Option) (*manage.ListToolResponse, error) { + chain := l.mds(func(ctx context.Context, in, out interface{}) error { + arg := in.(*manage.ToolManageServiceListToolArgs) + result := out.(*manage.ToolManageServiceListToolResult) + resp, err := l.impl.ListTool(ctx, arg.Request) + if err != nil { + return err + } + result.SetSuccess(resp) + return nil + }) + + arg := &manage.ToolManageServiceListToolArgs{Request: request} + result := &manage.ToolManageServiceListToolResult{} + ctx = l.injectRPCInfo(ctx, "ListTool") + if err := chain(ctx, arg, result); err != nil { + return nil, err + } + return result.GetSuccess(), nil +} + +func (l *LocalToolManageService) SaveToolDetail(ctx context.Context, request *manage.SaveToolDetailRequest, callOptions ...callopt.Option) (*manage.SaveToolDetailResponse, error) { + chain := l.mds(func(ctx context.Context, in, out interface{}) error { + arg := in.(*manage.ToolManageServiceSaveToolDetailArgs) + result := out.(*manage.ToolManageServiceSaveToolDetailResult) + resp, err := l.impl.SaveToolDetail(ctx, arg.Request) + if err != nil { + return err + } + result.SetSuccess(resp) + return nil + }) + + arg := &manage.ToolManageServiceSaveToolDetailArgs{Request: request} + result := &manage.ToolManageServiceSaveToolDetailResult{} + ctx = l.injectRPCInfo(ctx, "SaveToolDetail") + if err := chain(ctx, arg, result); err != nil { + return nil, err + } + return result.GetSuccess(), nil +} + +func (l *LocalToolManageService) CommitToolDraft(ctx context.Context, request *manage.CommitToolDraftRequest, callOptions ...callopt.Option) (*manage.CommitToolDraftResponse, error) { + chain := l.mds(func(ctx context.Context, in, out interface{}) error { + arg := in.(*manage.ToolManageServiceCommitToolDraftArgs) + result := out.(*manage.ToolManageServiceCommitToolDraftResult) + resp, err := l.impl.CommitToolDraft(ctx, arg.Request) + if err != nil { + return err + } + result.SetSuccess(resp) + return nil + }) + + arg := &manage.ToolManageServiceCommitToolDraftArgs{Request: request} + result := &manage.ToolManageServiceCommitToolDraftResult{} + ctx = l.injectRPCInfo(ctx, "CommitToolDraft") + if err := chain(ctx, arg, result); err != nil { + return nil, err + } + return result.GetSuccess(), nil +} + +func (l *LocalToolManageService) ListToolCommit(ctx context.Context, request *manage.ListToolCommitRequest, callOptions ...callopt.Option) (*manage.ListToolCommitResponse, error) { + chain := l.mds(func(ctx context.Context, in, out interface{}) error { + arg := in.(*manage.ToolManageServiceListToolCommitArgs) + result := out.(*manage.ToolManageServiceListToolCommitResult) + resp, err := l.impl.ListToolCommit(ctx, arg.Request) + if err != nil { + return err + } + result.SetSuccess(resp) + return nil + }) + + arg := &manage.ToolManageServiceListToolCommitArgs{Request: request} + result := &manage.ToolManageServiceListToolCommitResult{} + ctx = l.injectRPCInfo(ctx, "ListToolCommit") + if err := chain(ctx, arg, result); err != nil { + return nil, err + } + return result.GetSuccess(), nil +} + +func (l *LocalToolManageService) injectRPCInfo(ctx context.Context, method string) context.Context { + rpcStats := rpcinfo.AsMutableRPCStats(rpcinfo.NewRPCStats()) + ri := rpcinfo.NewRPCInfo( + rpcinfo.NewEndpointInfo("ToolManageService", method, nil, nil), + rpcinfo.NewEndpointInfo("ToolManageService", method, nil, nil), + rpcinfo.NewServerInvocation(), + nil, + rpcStats.ImmutableView(), + ) + return rpcinfo.NewCtxWithRPCInfo(ctx, ri) +} diff --git a/backend/modules/prompt/application/convertor/toolmgmt.go b/backend/modules/prompt/application/convertor/toolmgmt.go new file mode 100644 index 000000000..4f1b2fd9c --- /dev/null +++ b/backend/modules/prompt/application/convertor/toolmgmt.go @@ -0,0 +1,83 @@ +package convertor + +import ( + "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/domain/tool" + "github.com/coze-dev/coze-loop/backend/modules/prompt/domain/entity/toolmgmt" + "github.com/coze-dev/coze-loop/backend/pkg/lang/ptr" +) + +func ToolMgmtDO2DTO(do *toolmgmt.Tool) *tool.Tool { + if do == nil { + return nil + } + return &tool.Tool{ + ID: ptr.Of(do.ID), + WorkspaceID: ptr.Of(do.SpaceID), + ToolBasic: ToolMgmtBasicDO2DTO(do.ToolBasic), + ToolCommit: ToolMgmtCommitDO2DTO(do.ToolCommit), + } +} + +func ToolMgmtBasicDO2DTO(do *toolmgmt.ToolBasic) *tool.ToolBasic { + if do == nil { + return nil + } + return &tool.ToolBasic{ + Name: ptr.Of(do.Name), + Description: ptr.Of(do.Description), + LatestCommittedVersion: ptr.Of(do.LatestCommittedVersion), + CreatedBy: ptr.Of(do.CreatedBy), + UpdatedBy: ptr.Of(do.UpdatedBy), + CreatedAt: ptr.Of(do.CreatedAt.UnixMilli()), + UpdatedAt: ptr.Of(do.UpdatedAt.UnixMilli()), + } +} + +func ToolMgmtCommitDO2DTO(do *toolmgmt.ToolCommit) *tool.ToolCommit { + if do == nil { + return nil + } + return &tool.ToolCommit{ + CommitInfo: ToolMgmtCommitInfoDO2DTO(do.CommitInfo), + Detail: ToolMgmtDetailDO2DTO(do.ToolDetail), + } +} + +func ToolMgmtCommitInfoDO2DTO(do *toolmgmt.CommitInfo) *tool.CommitInfo { + if do == nil { + return nil + } + return &tool.CommitInfo{ + Version: ptr.Of(do.Version), + BaseVersion: ptr.Of(do.BaseVersion), + Description: ptr.Of(do.Description), + CommittedBy: ptr.Of(do.CommittedBy), + CommittedAt: ptr.Of(do.CommittedAt.UnixMilli()), + } +} + +func ToolMgmtDetailDO2DTO(do *toolmgmt.ToolDetail) *tool.ToolDetail { + if do == nil { + return nil + } + return &tool.ToolDetail{ + Content: ptr.Of(do.Content), + } +} + +func BatchToolMgmtDO2DTO(dos []*toolmgmt.Tool) []*tool.Tool { + if len(dos) == 0 { + return nil + } + dtos := make([]*tool.Tool, 0, len(dos)) + for _, do := range dos { + if do == nil { + continue + } + dtos = append(dtos, ToolMgmtDO2DTO(do)) + } + if len(dtos) == 0 { + return nil + } + return dtos +} diff --git a/backend/modules/prompt/application/tool_manage.go b/backend/modules/prompt/application/tool_manage.go new file mode 100644 index 000000000..f6c341a58 --- /dev/null +++ b/backend/modules/prompt/application/tool_manage.go @@ -0,0 +1,381 @@ +package application + +import ( + "context" + "fmt" + "strconv" + + "github.com/Masterminds/semver/v3" + "github.com/samber/lo" + "golang.org/x/exp/maps" + + "github.com/coze-dev/coze-loop/backend/infra/middleware/session" + "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/domain/tool" + toolmanage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" + "github.com/coze-dev/coze-loop/backend/modules/prompt/application/convertor" + "github.com/coze-dev/coze-loop/backend/modules/prompt/domain/component/rpc" + "github.com/coze-dev/coze-loop/backend/modules/prompt/domain/entity/toolmgmt" + "github.com/coze-dev/coze-loop/backend/modules/prompt/domain/repo" + "github.com/coze-dev/coze-loop/backend/modules/prompt/infra/repo/mysql" + "github.com/coze-dev/coze-loop/backend/modules/prompt/pkg/consts" + prompterr "github.com/coze-dev/coze-loop/backend/modules/prompt/pkg/errno" + "github.com/coze-dev/coze-loop/backend/pkg/errorx" + "github.com/coze-dev/coze-loop/backend/pkg/lang/ptr" +) + +func NewToolManageApplication( + toolRepo repo.IToolRepo, + authRPCProvider rpc.IAuthProvider, + userRPCProvider rpc.IUserProvider, +) toolmanage.ToolManageService { + return &ToolManageApplicationImpl{ + toolRepo: toolRepo, + authRPCProvider: authRPCProvider, + userRPCProvider: userRPCProvider, + } +} + +type ToolManageApplicationImpl struct { + toolRepo repo.IToolRepo + authRPCProvider rpc.IAuthProvider + userRPCProvider rpc.IUserProvider +} + +func (app *ToolManageApplicationImpl) CreateTool(ctx context.Context, request *toolmanage.CreateToolRequest) (r *toolmanage.CreateToolResponse, err error) { + r = toolmanage.NewCreateToolResponse() + + userID, ok := session.UserIDInCtx(ctx) + if !ok || lo.IsEmpty(userID) { + return r, errorx.NewByCode(prompterr.CommonInvalidParamCode, errorx.WithExtraMsg("User not found")) + } + + if request.GetWorkspaceID() <= 0 { + return r, errorx.NewByCode(prompterr.CommonInvalidParamCode, errorx.WithExtraMsg("Workspace ID is required")) + } + + err = app.authRPCProvider.CheckSpacePermission(ctx, request.GetWorkspaceID(), consts.ActionWorkspaceCreateLoopPrompt) + if err != nil { + return r, err + } + + toolDO := &toolmgmt.Tool{ + SpaceID: request.GetWorkspaceID(), + ToolBasic: &toolmgmt.ToolBasic{ + Name: request.GetToolName(), + Description: request.GetToolDescription(), + CreatedBy: userID, + UpdatedBy: userID, + }, + ToolCommit: &toolmgmt.ToolCommit{ + ToolDetail: &toolmgmt.ToolDetail{ + Content: func() string { + if request.DraftDetail == nil { + return "" + } + return request.DraftDetail.GetContent() + }(), + }, + CommitInfo: &toolmgmt.CommitInfo{ + Version: toolmgmt.PublicDraftVersion, + BaseVersion: "", + Description: "", + CommittedBy: userID, + }, + }, + } + + toolID, err := app.toolRepo.CreateTool(ctx, toolDO) + if err != nil { + return r, err + } + r.ToolID = ptr.Of(toolID) + return r, nil +} + +func (app *ToolManageApplicationImpl) GetToolDetail(ctx context.Context, request *toolmanage.GetToolDetailRequest) (r *toolmanage.GetToolDetailResponse, err error) { + r = toolmanage.NewGetToolDetailResponse() + + _, ok := session.UserIDInCtx(ctx) + if !ok { + return r, errorx.NewByCode(prompterr.CommonInvalidParamCode, errorx.WithExtraMsg("User not found")) + } + + if request.GetToolID() <= 0 { + return r, errorx.NewByCode(prompterr.CommonInvalidParamCode, errorx.WithExtraMsg("Tool ID is required")) + } + if request.GetWorkspaceID() <= 0 { + return r, errorx.NewByCode(prompterr.CommonInvalidParamCode, errorx.WithExtraMsg("Workspace ID is required")) + } + err = app.authRPCProvider.CheckSpacePermission(ctx, request.GetWorkspaceID(), consts.ActionLoopPromptRead) + if err != nil { + return r, err + } + + getParam := repo.GetToolParam{ + ToolID: request.GetToolID(), + WithCommit: request.GetWithCommit(), + WithDraft: request.GetWithDraft(), + CommitVersion: request.GetCommitVersion(), + } + toolDO, err := app.toolRepo.GetTool(ctx, getParam) + if err != nil { + return r, err + } + if toolDO == nil { + return r, errorx.NewByCode(prompterr.ResourceNotFoundCode, errorx.WithExtraMsg(fmt.Sprintf("tool id = %d", request.GetToolID()))) + } + if toolDO.SpaceID != request.GetWorkspaceID() { + return r, errorx.NewByCode(prompterr.ResourceNotFoundCode, errorx.WithExtraMsg(fmt.Sprintf("tool id = %d", request.GetToolID()))) + } + r.Tool = convertor.ToolMgmtDO2DTO(toolDO) + return r, nil +} + +func (app *ToolManageApplicationImpl) ListTool(ctx context.Context, request *toolmanage.ListToolRequest) (r *toolmanage.ListToolResponse, err error) { + r = toolmanage.NewListToolResponse() + + _, ok := session.UserIDInCtx(ctx) + if !ok { + return r, errorx.NewByCode(prompterr.CommonInvalidParamCode, errorx.WithExtraMsg("User not found")) + } + + if request.GetWorkspaceID() <= 0 { + return r, errorx.NewByCode(prompterr.CommonInvalidParamCode, errorx.WithExtraMsg("Workspace ID is required")) + } + if request.GetPageNum() <= 0 || request.GetPageSize() <= 0 { + return r, errorx.NewByCode(prompterr.CommonInvalidParamCode, errorx.WithExtraMsg("PageNum or PageSize is invalid")) + } + + err = app.authRPCProvider.CheckSpacePermission(ctx, request.GetWorkspaceID(), consts.ActionWorkspaceListLoopPrompt) + if err != nil { + return r, err + } + + listParam := repo.ListToolParam{ + SpaceID: request.GetWorkspaceID(), + + KeyWord: request.GetKeyWord(), + CreatedBys: request.GetCreatedBys(), + CommittedOnly: request.GetCommittedOnly(), + + PageNum: int(request.GetPageNum()), + PageSize: int(request.GetPageSize()), + OrderBy: app.listToolOrderBy(request.OrderBy), + Asc: request.GetAsc(), + } + listResult, err := app.toolRepo.ListTool(ctx, listParam) + if err != nil { + return r, err + } + if listResult == nil { + return r, nil + } + r.Total = ptr.Of(int32(listResult.Total)) + r.Tools = convertor.BatchToolMgmtDO2DTO(listResult.Tools) + + userIDSet := make(map[string]struct{}) + for _, toolDTO := range r.Tools { + if toolDTO == nil || toolDTO.ToolBasic == nil || lo.IsEmpty(toolDTO.ToolBasic.GetCreatedBy()) { + continue + } + userIDSet[toolDTO.ToolBasic.GetCreatedBy()] = struct{}{} + if lo.IsNotEmpty(toolDTO.ToolBasic.GetUpdatedBy()) { + userIDSet[toolDTO.ToolBasic.GetUpdatedBy()] = struct{}{} + } + } + userDOs, err := app.userRPCProvider.MGetUserInfo(ctx, maps.Keys(userIDSet)) + if err != nil { + return r, err + } + r.Users = convertor.BatchUserInfoDO2DTO(userDOs) + return r, nil +} + +func (app *ToolManageApplicationImpl) SaveToolDetail(ctx context.Context, request *toolmanage.SaveToolDetailRequest) (r *toolmanage.SaveToolDetailResponse, err error) { + r = toolmanage.NewSaveToolDetailResponse() + + userID, ok := session.UserIDInCtx(ctx) + if !ok || lo.IsEmpty(userID) { + return r, errorx.NewByCode(prompterr.CommonInvalidParamCode, errorx.WithExtraMsg("User not found")) + } + + if request.GetToolID() <= 0 || request.ToolDetail == nil { + return r, errorx.NewByCode(prompterr.CommonInvalidParamCode, errorx.WithExtraMsg("Tool ID or ToolDetail is required")) + } + if request.GetWorkspaceID() <= 0 { + return r, errorx.NewByCode(prompterr.CommonInvalidParamCode, errorx.WithExtraMsg("Workspace ID is required")) + } + err = app.authRPCProvider.CheckSpacePermission(ctx, request.GetWorkspaceID(), consts.ActionLoopPromptEdit) + if err != nil { + return r, err + } + + toolDO, err := app.toolRepo.GetTool(ctx, repo.GetToolParam{ToolID: request.GetToolID()}) + if err != nil { + return r, err + } + if toolDO == nil { + return r, errorx.NewByCode(prompterr.ResourceNotFoundCode, errorx.WithExtraMsg(fmt.Sprintf("tool id = %d", request.GetToolID()))) + } + if toolDO.SpaceID != request.GetWorkspaceID() { + return r, errorx.NewByCode(prompterr.ResourceNotFoundCode, errorx.WithExtraMsg(fmt.Sprintf("tool id = %d", request.GetToolID()))) + } + + err = app.toolRepo.SaveToolDetail(ctx, repo.SaveToolDetailParam{ + ToolID: request.GetToolID(), + BaseVersion: request.GetBaseVersion(), + Content: request.ToolDetail.GetContent(), + UpdatedBy: userID, + }) + if err != nil { + return r, err + } + return r, nil +} + +func (app *ToolManageApplicationImpl) CommitToolDraft(ctx context.Context, request *toolmanage.CommitToolDraftRequest) (r *toolmanage.CommitToolDraftResponse, err error) { + r = toolmanage.NewCommitToolDraftResponse() + + userID, ok := session.UserIDInCtx(ctx) + if !ok || lo.IsEmpty(userID) { + return r, errorx.NewByCode(prompterr.CommonInvalidParamCode, errorx.WithExtraMsg("User not found")) + } + + _, err = semver.StrictNewVersion(request.GetCommitVersion()) + if err != nil { + return r, err + } + + if request.GetToolID() <= 0 { + return r, errorx.NewByCode(prompterr.CommonInvalidParamCode, errorx.WithExtraMsg("Tool ID is required")) + } + if request.GetWorkspaceID() <= 0 { + return r, errorx.NewByCode(prompterr.CommonInvalidParamCode, errorx.WithExtraMsg("Workspace ID is required")) + } + err = app.authRPCProvider.CheckSpacePermission(ctx, request.GetWorkspaceID(), consts.ActionLoopPromptEdit) + if err != nil { + return r, err + } + + toolDO, err := app.toolRepo.GetTool(ctx, repo.GetToolParam{ToolID: request.GetToolID()}) + if err != nil { + return r, err + } + if toolDO == nil { + return r, errorx.NewByCode(prompterr.ResourceNotFoundCode, errorx.WithExtraMsg(fmt.Sprintf("tool id = %d", request.GetToolID()))) + } + if toolDO.SpaceID != request.GetWorkspaceID() { + return r, errorx.NewByCode(prompterr.ResourceNotFoundCode, errorx.WithExtraMsg(fmt.Sprintf("tool id = %d", request.GetToolID()))) + } + + err = app.toolRepo.CommitToolDraft(ctx, repo.CommitToolDraftParam{ + ToolID: request.GetToolID(), + CommitVersion: request.GetCommitVersion(), + CommitDescription: request.GetCommitDescription(), + BaseVersion: request.GetBaseVersion(), + CommittedBy: userID, + }) + if err != nil { + return r, err + } + return r, nil +} + +func (app *ToolManageApplicationImpl) ListToolCommit(ctx context.Context, request *toolmanage.ListToolCommitRequest) (r *toolmanage.ListToolCommitResponse, err error) { + r = toolmanage.NewListToolCommitResponse() + + _, ok := session.UserIDInCtx(ctx) + if !ok { + return r, errorx.NewByCode(prompterr.CommonInvalidParamCode, errorx.WithExtraMsg("User not found")) + } + + if request.GetToolID() <= 0 { + return r, errorx.NewByCode(prompterr.CommonInvalidParamCode, errorx.WithExtraMsg("Tool ID is required")) + } + if request.GetWorkspaceID() <= 0 { + return r, errorx.NewByCode(prompterr.CommonInvalidParamCode, errorx.WithExtraMsg("Workspace ID is required")) + } + err = app.authRPCProvider.CheckSpacePermission(ctx, request.GetWorkspaceID(), consts.ActionLoopPromptRead) + if err != nil { + return r, err + } + + toolDO, err := app.toolRepo.GetTool(ctx, repo.GetToolParam{ToolID: request.GetToolID()}) + if err != nil { + return r, err + } + if toolDO == nil { + return r, errorx.NewByCode(prompterr.ResourceNotFoundCode, errorx.WithExtraMsg(fmt.Sprintf("tool id = %d", request.GetToolID()))) + } + if toolDO.SpaceID != request.GetWorkspaceID() { + return r, errorx.NewByCode(prompterr.ResourceNotFoundCode, errorx.WithExtraMsg(fmt.Sprintf("tool id = %d", request.GetToolID()))) + } + + var pageTokenPtr *int64 + if request.PageToken != nil { + pageToken, err := strconv.ParseInt(request.GetPageToken(), 10, 64) + if err != nil { + return r, errorx.NewByCode(prompterr.CommonInvalidParamCode, errorx.WithExtraMsg( + fmt.Sprintf("Page token is invalid, page token = %s", request.GetPageToken()))) + } + pageTokenPtr = ptr.Of(pageToken) + } + + listResult, err := app.toolRepo.ListToolCommit(ctx, repo.ListToolCommitParam{ + ToolID: request.GetToolID(), + PageSize: int(request.GetPageSize()), + PageToken: pageTokenPtr, + Asc: request.GetAsc(), + WithCommitDetail: request.GetWithCommitDetail(), + }) + if err != nil { + return r, err + } + if listResult == nil { + return r, nil + } + if listResult.NextPageToken > 0 { + r.NextPageToken = ptr.Of(strconv.FormatInt(listResult.NextPageToken, 10)) + r.HasMore = ptr.Of(true) + } + + r.ToolCommitInfos = make([]*tool.CommitInfo, 0, len(listResult.CommitInfos)) + userIDSet := make(map[string]struct{}) + for _, ci := range listResult.CommitInfos { + if ci == nil { + continue + } + r.ToolCommitInfos = append(r.ToolCommitInfos, convertor.ToolMgmtCommitInfoDO2DTO(ci)) + if lo.IsNotEmpty(ci.CommittedBy) { + userIDSet[ci.CommittedBy] = struct{}{} + } + } + if request.GetWithCommitDetail() && len(listResult.CommitDetails) > 0 { + mapping := make(map[string]*tool.ToolDetail, len(listResult.CommitDetails)) + for version, detail := range listResult.CommitDetails { + mapping[version] = convertor.ToolMgmtDetailDO2DTO(detail) + } + r.ToolCommitDetailMapping = mapping + } + + userDOs, err := app.userRPCProvider.MGetUserInfo(ctx, maps.Keys(userIDSet)) + if err != nil { + return toolmanage.NewListToolCommitResponse(), err + } + r.Users = convertor.BatchUserInfoDO2DTO(userDOs) + return r, nil +} + +func (app *ToolManageApplicationImpl) listToolOrderBy(orderBy *toolmanage.ListToolOrderBy) int { + if orderBy == nil { + return mysql.ListToolBasicOrderByID + } + switch *orderBy { + case toolmanage.ListToolOrderByCommittedAt: + return mysql.ListToolBasicOrderByCommittedAt + case toolmanage.ListToolOrderByCreatedAt: + return mysql.ListToolBasicOrderByCreatedAt + default: + return mysql.ListToolBasicOrderByID + } +} diff --git a/backend/modules/prompt/application/wire.go b/backend/modules/prompt/application/wire.go index bc3584c24..7528e8089 100644 --- a/backend/modules/prompt/application/wire.go +++ b/backend/modules/prompt/application/wire.go @@ -24,6 +24,7 @@ import ( "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/execute" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/manage" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/openapi" + toolmanage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" "github.com/coze-dev/coze-loop/backend/modules/prompt/domain/service" "github.com/coze-dev/coze-loop/backend/modules/prompt/infra/collector" promptconf "github.com/coze-dev/coze-loop/backend/modules/prompt/infra/conf" @@ -78,6 +79,17 @@ var ( NewPromptOpenAPIApplication, promptDomainSet, ) + toolDomainSet = wire.NewSet( + repo.NewToolRepo, + mysql.NewToolBasicDAO, + mysql.NewToolCommitDAO, + rpc.NewAuthRPCProvider, + rpc.NewUserRPCProvider, + ) + toolManageSet = wire.NewSet( + NewToolManageApplication, + toolDomainSet, + ) ) func InitPromptManageApplication( @@ -138,3 +150,14 @@ func InitPromptOpenAPIApplication( wire.Build(openAPISet) return nil, nil } + +func InitToolManageApplication( + idgen idgen.IIDGenerator, + db db.Provider, + redisCli redis.Cmdable, + authClient authservice.Client, + userClient userservice.Client, +) (toolmanage.ToolManageService, error) { + wire.Build(toolManageSet) + return nil, nil +} diff --git a/backend/modules/prompt/application/wire_gen.go b/backend/modules/prompt/application/wire_gen.go index acd15bcee..30efbdf3d 100644 --- a/backend/modules/prompt/application/wire_gen.go +++ b/backend/modules/prompt/application/wire_gen.go @@ -22,6 +22,7 @@ import ( "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/execute" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/manage" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/openapi" + manage2 "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" "github.com/coze-dev/coze-loop/backend/modules/prompt/domain/service" "github.com/coze-dev/coze-loop/backend/modules/prompt/infra/collector" conf2 "github.com/coze-dev/coze-loop/backend/modules/prompt/infra/conf" @@ -160,6 +161,16 @@ func InitPromptOpenAPIApplication(idgen2 idgen.IIDGenerator, db2 db.Provider, re return promptOpenAPIService, nil } +func InitToolManageApplication(idgen2 idgen.IIDGenerator, db2 db.Provider, redisCli redis.Cmdable, authClient authservice.Client, userClient userservice.Client) (manage2.ToolManageService, error) { + iToolBasicDAO := mysql.NewToolBasicDAO(db2, redisCli) + iToolCommitDAO := mysql.NewToolCommitDAO(db2, redisCli) + iToolRepo := repo.NewToolRepo(db2, idgen2, iToolBasicDAO, iToolCommitDAO) + iAuthProvider := rpc.NewAuthRPCProvider(authClient) + iUserProvider := rpc.NewUserRPCProvider(userClient) + toolManageService := NewToolManageApplication(iToolRepo, iAuthProvider, iUserProvider) + return toolManageService, nil +} + // wire.go: var ( @@ -180,4 +191,9 @@ var ( NewPromptOpenAPIApplication, promptDomainSet, ) + toolDomainSet = wire.NewSet(repo.NewToolRepo, mysql.NewToolBasicDAO, mysql.NewToolCommitDAO, rpc.NewAuthRPCProvider, rpc.NewUserRPCProvider) + toolManageSet = wire.NewSet( + NewToolManageApplication, + toolDomainSet, + ) ) diff --git a/backend/modules/prompt/domain/entity/toolmgmt/tool.go b/backend/modules/prompt/domain/entity/toolmgmt/tool.go new file mode 100644 index 000000000..38bf3a372 --- /dev/null +++ b/backend/modules/prompt/domain/entity/toolmgmt/tool.go @@ -0,0 +1,43 @@ +package toolmgmt + +import "time" + +const PublicDraftVersion = "$PublicDraft" + +type Tool struct { + ID int64 `json:"id"` + SpaceID int64 `json:"space_id"` + ToolBasic *ToolBasic `json:"tool_basic,omitempty"` + ToolCommit *ToolCommit `json:"tool_commit,omitempty"` +} + +type ToolBasic struct { + Name string `json:"name"` + Description string `json:"description"` + LatestCommittedVersion string `json:"latest_committed_version"` + CreatedAt time.Time `json:"created_at"` + CreatedBy string `json:"created_by"` + UpdatedAt time.Time `json:"updated_at"` + UpdatedBy string `json:"updated_by"` +} + +type ToolCommit struct { + ToolDetail *ToolDetail `json:"tool_detail,omitempty"` + CommitInfo *CommitInfo `json:"commit_info,omitempty"` +} + +type CommitInfo struct { + Version string `json:"version"` + BaseVersion string `json:"base_version"` + Description string `json:"description"` + CommittedBy string `json:"committed_by"` + CommittedAt time.Time `json:"committed_at"` +} + +func (v CommitInfo) IsPublicDraft() bool { + return v.Version == PublicDraftVersion +} + +type ToolDetail struct { + Content string `json:"content"` +} diff --git a/backend/modules/prompt/domain/repo/tool.go b/backend/modules/prompt/domain/repo/tool.go new file mode 100644 index 000000000..8b2e61f46 --- /dev/null +++ b/backend/modules/prompt/domain/repo/tool.go @@ -0,0 +1,77 @@ +package repo + +import ( + "context" + + "github.com/coze-dev/coze-loop/backend/modules/prompt/domain/entity/toolmgmt" +) + +type IToolRepo interface { + CreateTool(ctx context.Context, tool *toolmgmt.Tool) (toolID int64, err error) + DeleteTool(ctx context.Context, toolID int64) (err error) + GetTool(ctx context.Context, param GetToolParam) (tool *toolmgmt.Tool, err error) + ListTool(ctx context.Context, param ListToolParam) (result *ListToolResult, err error) + SaveToolDetail(ctx context.Context, param SaveToolDetailParam) (err error) + CommitToolDraft(ctx context.Context, param CommitToolDraftParam) (err error) + ListToolCommit(ctx context.Context, param ListToolCommitParam) (result *ListToolCommitResult, err error) +} + +type GetToolParam struct { + ToolID int64 + + WithCommit bool + CommitVersion string + + WithDraft bool +} + +type ListToolParam struct { + SpaceID int64 + + KeyWord string + CreatedBys []string + CommittedOnly bool + + PageNum int + PageSize int + OrderBy int + Asc bool +} + +type ListToolResult struct { + Total int64 + Tools []*toolmgmt.Tool +} + +type SaveToolDetailParam struct { + ToolID int64 + + BaseVersion string + Content string + UpdatedBy string +} + +type CommitToolDraftParam struct { + ToolID int64 + + CommitVersion string + CommitDescription string + BaseVersion string + CommittedBy string +} + +type ListToolCommitParam struct { + ToolID int64 + + PageSize int + PageToken *int64 + Asc bool + + WithCommitDetail bool +} + +type ListToolCommitResult struct { + CommitInfos []*toolmgmt.CommitInfo + CommitDetails map[string]*toolmgmt.ToolDetail + NextPageToken int64 +} diff --git a/backend/modules/prompt/infra/repo/mysql/convertor/tool.go b/backend/modules/prompt/infra/repo/mysql/convertor/tool.go new file mode 100644 index 000000000..36df6cc33 --- /dev/null +++ b/backend/modules/prompt/infra/repo/mysql/convertor/tool.go @@ -0,0 +1,65 @@ +package convertor + +import ( + "github.com/coze-dev/coze-loop/backend/modules/prompt/domain/entity/toolmgmt" + "github.com/coze-dev/coze-loop/backend/modules/prompt/infra/repo/mysql/gorm_gen/model" + "github.com/coze-dev/coze-loop/backend/pkg/lang/ptr" +) + +func ToolPO2DO(basicPO *model.ToolBasic, commitPO *model.ToolCommit) *toolmgmt.Tool { + if basicPO == nil { + return nil + } + do := &toolmgmt.Tool{ + ID: basicPO.ID, + SpaceID: basicPO.SpaceID, + ToolBasic: &toolmgmt.ToolBasic{ + Name: basicPO.Name, + Description: basicPO.Description, + LatestCommittedVersion: basicPO.LatestCommittedVersion, + CreatedAt: basicPO.CreatedAt, + CreatedBy: basicPO.CreatedBy, + UpdatedAt: basicPO.UpdatedAt, + UpdatedBy: basicPO.UpdatedBy, + }, + } + if commitPO != nil { + do.ToolCommit = ToolCommitPO2DO(commitPO) + } + return do +} + +func ToolCommitPO2DO(commitPO *model.ToolCommit) *toolmgmt.ToolCommit { + if commitPO == nil { + return nil + } + return &toolmgmt.ToolCommit{ + CommitInfo: &toolmgmt.CommitInfo{ + Version: commitPO.Version, + BaseVersion: commitPO.BaseVersion, + Description: ptr.From(commitPO.Description), + CommittedBy: commitPO.CommittedBy, + CommittedAt: commitPO.CreatedAt, + }, + ToolDetail: &toolmgmt.ToolDetail{ + Content: ptr.From(commitPO.Content), + }, + } +} + +func ToolDO2BasicPO(do *toolmgmt.Tool) *model.ToolBasic { + if do == nil || do.ToolBasic == nil { + return nil + } + return &model.ToolBasic{ + ID: do.ID, + SpaceID: do.SpaceID, + Name: do.ToolBasic.Name, + Description: do.ToolBasic.Description, + LatestCommittedVersion: do.ToolBasic.LatestCommittedVersion, + CreatedBy: do.ToolBasic.CreatedBy, + UpdatedBy: do.ToolBasic.UpdatedBy, + CreatedAt: do.ToolBasic.CreatedAt, + UpdatedAt: do.ToolBasic.UpdatedAt, + } +} diff --git a/backend/modules/prompt/infra/repo/mysql/gorm_gen/model/tool_basic.gen.go b/backend/modules/prompt/infra/repo/mysql/gorm_gen/model/tool_basic.gen.go new file mode 100644 index 000000000..134b11717 --- /dev/null +++ b/backend/modules/prompt/infra/repo/mysql/gorm_gen/model/tool_basic.gen.go @@ -0,0 +1,33 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package model + +import ( + "time" + + "gorm.io/plugin/soft_delete" +) + +const TableNameToolBasic = "tool_basic" + +// ToolBasic 工具主体 +type ToolBasic struct { + ID int64 `gorm:"column:id;type:bigint(20) unsigned;primaryKey;autoIncrement:true;comment:主键ID" json:"id"` // 主键ID + SpaceID int64 `gorm:"column:space_id;type:bigint(20) unsigned;not null;index:idx_spaceid_name_delat,priority:1;comment:空间ID" json:"space_id"` // 空间ID + Name string `gorm:"column:name;type:varchar(128);not null;index:idx_spaceid_name_delat,priority:2;comment:名称" json:"name"` // 名称 + Description string `gorm:"column:description;type:varchar(1024);not null;comment:描述" json:"description"` // 描述 + LatestCommittedVersion string `gorm:"column:latest_committed_version;type:varchar(128);not null;comment:最新版本" json:"latest_committed_version"` // 最新版本 + LatestCommittedAt *time.Time `gorm:"column:latest_committed_at;type:datetime;comment:最新提交时间" json:"latest_committed_at"` // 最新提交时间 + CreatedBy string `gorm:"column:created_by;type:varchar(128);not null;comment:创建人" json:"created_by"` // 创建人 + UpdatedBy string `gorm:"column:updated_by;type:varchar(128);not null;comment:更新人" json:"updated_by"` // 更新人 + CreatedAt time.Time `gorm:"column:created_at;type:datetime;not null;default:CURRENT_TIMESTAMP;comment:创建时间" json:"created_at"` // 创建时间 + UpdatedAt time.Time `gorm:"column:updated_at;type:datetime;not null;default:CURRENT_TIMESTAMP;comment:更新时间" json:"updated_at"` // 更新时间 + DeletedAt soft_delete.DeletedAt `gorm:"column:deleted_at;type:bigint(20);not null;index:idx_spaceid_name_delat,priority:3;column:deleted_at;not null;default:0;softDelete:milli;comment:删除时间" json:"deleted_at"` // 删除时间 +} + +// TableName ToolBasic's table name +func (*ToolBasic) TableName() string { + return TableNameToolBasic +} diff --git a/backend/modules/prompt/infra/repo/mysql/gorm_gen/model/tool_commit.gen.go b/backend/modules/prompt/infra/repo/mysql/gorm_gen/model/tool_commit.gen.go new file mode 100644 index 000000000..7db8d4b7e --- /dev/null +++ b/backend/modules/prompt/infra/repo/mysql/gorm_gen/model/tool_commit.gen.go @@ -0,0 +1,30 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package model + +import ( + "time" +) + +const TableNameToolCommit = "tool_commit" + +// ToolCommit 工具版本 +type ToolCommit struct { + ID int64 `gorm:"column:id;type:bigint(20) unsigned;primaryKey;autoIncrement:true;comment:主键ID" json:"id"` // 主键ID + SpaceID int64 `gorm:"column:space_id;type:bigint(20) unsigned;not null;comment:空间ID" json:"space_id"` // 空间ID + ToolID int64 `gorm:"column:tool_id;type:bigint(20) unsigned;not null;uniqueIndex:uk_tool_version,priority:1;comment:Tool ID" json:"tool_id"` // Tool ID + Content *string `gorm:"column:content;type:longtext;comment:工具内容" json:"content"` // 工具内容 + Version string `gorm:"column:version;type:varchar(128);not null;uniqueIndex:uk_tool_version,priority:2;comment:版本" json:"version"` // 版本 + BaseVersion string `gorm:"column:base_version;type:varchar(128);not null;comment:来源版本" json:"base_version"` // 来源版本 + CommittedBy string `gorm:"column:committed_by;type:varchar(128);not null;comment:提交人" json:"committed_by"` // 提交人 + Description *string `gorm:"column:description;type:text;comment:提交版本描述" json:"description"` // 提交版本描述 + CreatedAt time.Time `gorm:"column:created_at;type:datetime;not null;default:CURRENT_TIMESTAMP;comment:创建时间" json:"created_at"` // 创建时间 + UpdatedAt time.Time `gorm:"column:updated_at;type:datetime;not null;default:CURRENT_TIMESTAMP;comment:更新时间" json:"updated_at"` // 更新时间 +} + +// TableName ToolCommit's table name +func (*ToolCommit) TableName() string { + return TableNameToolCommit +} diff --git a/backend/modules/prompt/infra/repo/mysql/gorm_gen/query/gen.go b/backend/modules/prompt/infra/repo/mysql/gorm_gen/query/gen.go index f757cbe12..9c199bf44 100644 --- a/backend/modules/prompt/infra/repo/mysql/gorm_gen/query/gen.go +++ b/backend/modules/prompt/infra/repo/mysql/gorm_gen/query/gen.go @@ -26,6 +26,8 @@ func Use(db *gorm.DB, opts ...gen.DOOption) *Query { PromptLabel: newPromptLabel(db, opts...), PromptRelation: newPromptRelation(db, opts...), PromptUserDraft: newPromptUserDraft(db, opts...), + ToolBasic: newToolBasic(db, opts...), + ToolCommit: newToolCommit(db, opts...), } } @@ -40,6 +42,8 @@ type Query struct { PromptLabel promptLabel PromptRelation promptRelation PromptUserDraft promptUserDraft + ToolBasic toolBasic + ToolCommit toolCommit } func (q *Query) Available() bool { return q.db != nil } @@ -55,6 +59,8 @@ func (q *Query) clone(db *gorm.DB) *Query { PromptLabel: q.PromptLabel.clone(db), PromptRelation: q.PromptRelation.clone(db), PromptUserDraft: q.PromptUserDraft.clone(db), + ToolBasic: q.ToolBasic.clone(db), + ToolCommit: q.ToolCommit.clone(db), } } @@ -77,6 +83,8 @@ func (q *Query) ReplaceDB(db *gorm.DB) *Query { PromptLabel: q.PromptLabel.replaceDB(db), PromptRelation: q.PromptRelation.replaceDB(db), PromptUserDraft: q.PromptUserDraft.replaceDB(db), + ToolBasic: q.ToolBasic.replaceDB(db), + ToolCommit: q.ToolCommit.replaceDB(db), } } @@ -89,6 +97,8 @@ type queryCtx struct { PromptLabel *promptLabelDo PromptRelation *promptRelationDo PromptUserDraft *promptUserDraftDo + ToolBasic *toolBasicDo + ToolCommit *toolCommitDo } func (q *Query) WithContext(ctx context.Context) *queryCtx { @@ -101,6 +111,8 @@ func (q *Query) WithContext(ctx context.Context) *queryCtx { PromptLabel: q.PromptLabel.WithContext(ctx), PromptRelation: q.PromptRelation.WithContext(ctx), PromptUserDraft: q.PromptUserDraft.WithContext(ctx), + ToolBasic: q.ToolBasic.WithContext(ctx), + ToolCommit: q.ToolCommit.WithContext(ctx), } } diff --git a/backend/modules/prompt/infra/repo/mysql/gorm_gen/query/tool_basic.gen.go b/backend/modules/prompt/infra/repo/mysql/gorm_gen/query/tool_basic.gen.go new file mode 100644 index 000000000..e36c61c1f --- /dev/null +++ b/backend/modules/prompt/infra/repo/mysql/gorm_gen/query/tool_basic.gen.go @@ -0,0 +1,370 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "github.com/coze-dev/coze-loop/backend/modules/prompt/infra/repo/mysql/gorm_gen/model" +) + +func newToolBasic(db *gorm.DB, opts ...gen.DOOption) toolBasic { + _toolBasic := toolBasic{} + + _toolBasic.toolBasicDo.UseDB(db, opts...) + _toolBasic.toolBasicDo.UseModel(&model.ToolBasic{}) + + tableName := _toolBasic.toolBasicDo.TableName() + _toolBasic.ALL = field.NewAsterisk(tableName) + _toolBasic.ID = field.NewInt64(tableName, "id") + _toolBasic.SpaceID = field.NewInt64(tableName, "space_id") + _toolBasic.Name = field.NewString(tableName, "name") + _toolBasic.Description = field.NewString(tableName, "description") + _toolBasic.LatestCommittedVersion = field.NewString(tableName, "latest_committed_version") + _toolBasic.LatestCommittedAt = field.NewTime(tableName, "latest_committed_at") + _toolBasic.CreatedBy = field.NewString(tableName, "created_by") + _toolBasic.UpdatedBy = field.NewString(tableName, "updated_by") + _toolBasic.CreatedAt = field.NewTime(tableName, "created_at") + _toolBasic.UpdatedAt = field.NewTime(tableName, "updated_at") + _toolBasic.DeletedAt = field.NewField(tableName, "deleted_at") + + _toolBasic.fillFieldMap() + + return _toolBasic +} + +// toolBasic 工具主体 +type toolBasic struct { + toolBasicDo toolBasicDo + + ALL field.Asterisk + ID field.Int64 // 主键ID + SpaceID field.Int64 // 空间ID + Name field.String // 名称 + Description field.String // 描述 + LatestCommittedVersion field.String // 最新版本 + LatestCommittedAt field.Time // 最新提交时间 + CreatedBy field.String // 创建人 + UpdatedBy field.String // 更新人 + CreatedAt field.Time // 创建时间 + UpdatedAt field.Time // 更新时间 + DeletedAt field.Field // 删除时间 + + fieldMap map[string]field.Expr +} + +func (t toolBasic) Table(newTableName string) *toolBasic { + t.toolBasicDo.UseTable(newTableName) + return t.updateTableName(newTableName) +} + +func (t toolBasic) As(alias string) *toolBasic { + t.toolBasicDo.DO = *(t.toolBasicDo.As(alias).(*gen.DO)) + return t.updateTableName(alias) +} + +func (t *toolBasic) updateTableName(table string) *toolBasic { + t.ALL = field.NewAsterisk(table) + t.ID = field.NewInt64(table, "id") + t.SpaceID = field.NewInt64(table, "space_id") + t.Name = field.NewString(table, "name") + t.Description = field.NewString(table, "description") + t.LatestCommittedVersion = field.NewString(table, "latest_committed_version") + t.LatestCommittedAt = field.NewTime(table, "latest_committed_at") + t.CreatedBy = field.NewString(table, "created_by") + t.UpdatedBy = field.NewString(table, "updated_by") + t.CreatedAt = field.NewTime(table, "created_at") + t.UpdatedAt = field.NewTime(table, "updated_at") + t.DeletedAt = field.NewField(table, "deleted_at") + + t.fillFieldMap() + + return t +} + +func (t *toolBasic) WithContext(ctx context.Context) *toolBasicDo { + return t.toolBasicDo.WithContext(ctx) +} + +func (t toolBasic) TableName() string { return t.toolBasicDo.TableName() } + +func (t toolBasic) Alias() string { return t.toolBasicDo.Alias() } + +func (t toolBasic) Columns(cols ...field.Expr) gen.Columns { return t.toolBasicDo.Columns(cols...) } + +func (t *toolBasic) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := t.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (t *toolBasic) fillFieldMap() { + t.fieldMap = make(map[string]field.Expr, 11) + t.fieldMap["id"] = t.ID + t.fieldMap["space_id"] = t.SpaceID + t.fieldMap["name"] = t.Name + t.fieldMap["description"] = t.Description + t.fieldMap["latest_committed_version"] = t.LatestCommittedVersion + t.fieldMap["latest_committed_at"] = t.LatestCommittedAt + t.fieldMap["created_by"] = t.CreatedBy + t.fieldMap["updated_by"] = t.UpdatedBy + t.fieldMap["created_at"] = t.CreatedAt + t.fieldMap["updated_at"] = t.UpdatedAt + t.fieldMap["deleted_at"] = t.DeletedAt +} + +func (t toolBasic) clone(db *gorm.DB) toolBasic { + t.toolBasicDo.ReplaceConnPool(db.Statement.ConnPool) + return t +} + +func (t toolBasic) replaceDB(db *gorm.DB) toolBasic { + t.toolBasicDo.ReplaceDB(db) + return t +} + +type toolBasicDo struct{ gen.DO } + +func (t toolBasicDo) Debug() *toolBasicDo { + return t.withDO(t.DO.Debug()) +} + +func (t toolBasicDo) WithContext(ctx context.Context) *toolBasicDo { + return t.withDO(t.DO.WithContext(ctx)) +} + +func (t toolBasicDo) ReadDB() *toolBasicDo { + return t.Clauses(dbresolver.Read) +} + +func (t toolBasicDo) WriteDB() *toolBasicDo { + return t.Clauses(dbresolver.Write) +} + +func (t toolBasicDo) Session(config *gorm.Session) *toolBasicDo { + return t.withDO(t.DO.Session(config)) +} + +func (t toolBasicDo) Clauses(conds ...clause.Expression) *toolBasicDo { + return t.withDO(t.DO.Clauses(conds...)) +} + +func (t toolBasicDo) Returning(value interface{}, columns ...string) *toolBasicDo { + return t.withDO(t.DO.Returning(value, columns...)) +} + +func (t toolBasicDo) Not(conds ...gen.Condition) *toolBasicDo { + return t.withDO(t.DO.Not(conds...)) +} + +func (t toolBasicDo) Or(conds ...gen.Condition) *toolBasicDo { + return t.withDO(t.DO.Or(conds...)) +} + +func (t toolBasicDo) Select(conds ...field.Expr) *toolBasicDo { + return t.withDO(t.DO.Select(conds...)) +} + +func (t toolBasicDo) Where(conds ...gen.Condition) *toolBasicDo { + return t.withDO(t.DO.Where(conds...)) +} + +func (t toolBasicDo) Order(conds ...field.Expr) *toolBasicDo { + return t.withDO(t.DO.Order(conds...)) +} + +func (t toolBasicDo) Distinct(cols ...field.Expr) *toolBasicDo { + return t.withDO(t.DO.Distinct(cols...)) +} + +func (t toolBasicDo) Omit(cols ...field.Expr) *toolBasicDo { + return t.withDO(t.DO.Omit(cols...)) +} + +func (t toolBasicDo) Join(table schema.Tabler, on ...field.Expr) *toolBasicDo { + return t.withDO(t.DO.Join(table, on...)) +} + +func (t toolBasicDo) LeftJoin(table schema.Tabler, on ...field.Expr) *toolBasicDo { + return t.withDO(t.DO.LeftJoin(table, on...)) +} + +func (t toolBasicDo) RightJoin(table schema.Tabler, on ...field.Expr) *toolBasicDo { + return t.withDO(t.DO.RightJoin(table, on...)) +} + +func (t toolBasicDo) Group(cols ...field.Expr) *toolBasicDo { + return t.withDO(t.DO.Group(cols...)) +} + +func (t toolBasicDo) Having(conds ...gen.Condition) *toolBasicDo { + return t.withDO(t.DO.Having(conds...)) +} + +func (t toolBasicDo) Limit(limit int) *toolBasicDo { + return t.withDO(t.DO.Limit(limit)) +} + +func (t toolBasicDo) Offset(offset int) *toolBasicDo { + return t.withDO(t.DO.Offset(offset)) +} + +func (t toolBasicDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *toolBasicDo { + return t.withDO(t.DO.Scopes(funcs...)) +} + +func (t toolBasicDo) Unscoped() *toolBasicDo { + return t.withDO(t.DO.Unscoped()) +} + +func (t toolBasicDo) Create(values ...*model.ToolBasic) error { + if len(values) == 0 { + return nil + } + return t.DO.Create(values) +} + +func (t toolBasicDo) CreateInBatches(values []*model.ToolBasic, batchSize int) error { + return t.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (t toolBasicDo) Save(values ...*model.ToolBasic) error { + if len(values) == 0 { + return nil + } + return t.DO.Save(values) +} + +func (t toolBasicDo) First() (*model.ToolBasic, error) { + if result, err := t.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.ToolBasic), nil + } +} + +func (t toolBasicDo) Take() (*model.ToolBasic, error) { + if result, err := t.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.ToolBasic), nil + } +} + +func (t toolBasicDo) Last() (*model.ToolBasic, error) { + if result, err := t.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.ToolBasic), nil + } +} + +func (t toolBasicDo) Find() ([]*model.ToolBasic, error) { + result, err := t.DO.Find() + return result.([]*model.ToolBasic), err +} + +func (t toolBasicDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ToolBasic, err error) { + buf := make([]*model.ToolBasic, 0, batchSize) + err = t.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (t toolBasicDo) FindInBatches(result *[]*model.ToolBasic, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return t.DO.FindInBatches(result, batchSize, fc) +} + +func (t toolBasicDo) Attrs(attrs ...field.AssignExpr) *toolBasicDo { + return t.withDO(t.DO.Attrs(attrs...)) +} + +func (t toolBasicDo) Assign(attrs ...field.AssignExpr) *toolBasicDo { + return t.withDO(t.DO.Assign(attrs...)) +} + +func (t toolBasicDo) Joins(fields ...field.RelationField) *toolBasicDo { + for _, _f := range fields { + t = *t.withDO(t.DO.Joins(_f)) + } + return &t +} + +func (t toolBasicDo) Preload(fields ...field.RelationField) *toolBasicDo { + for _, _f := range fields { + t = *t.withDO(t.DO.Preload(_f)) + } + return &t +} + +func (t toolBasicDo) FirstOrInit() (*model.ToolBasic, error) { + if result, err := t.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.ToolBasic), nil + } +} + +func (t toolBasicDo) FirstOrCreate() (*model.ToolBasic, error) { + if result, err := t.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.ToolBasic), nil + } +} + +func (t toolBasicDo) FindByPage(offset int, limit int) (result []*model.ToolBasic, count int64, err error) { + result, err = t.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = t.Offset(-1).Limit(-1).Count() + return +} + +func (t toolBasicDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = t.Count() + if err != nil { + return + } + + err = t.Offset(offset).Limit(limit).Scan(result) + return +} + +func (t toolBasicDo) Scan(result interface{}) (err error) { + return t.DO.Scan(result) +} + +func (t toolBasicDo) Delete(models ...*model.ToolBasic) (result gen.ResultInfo, err error) { + return t.DO.Delete(models) +} + +func (t *toolBasicDo) withDO(do gen.Dao) *toolBasicDo { + t.DO = *do.(*gen.DO) + return t +} diff --git a/backend/modules/prompt/infra/repo/mysql/gorm_gen/query/tool_commit.gen.go b/backend/modules/prompt/infra/repo/mysql/gorm_gen/query/tool_commit.gen.go new file mode 100644 index 000000000..04d87615f --- /dev/null +++ b/backend/modules/prompt/infra/repo/mysql/gorm_gen/query/tool_commit.gen.go @@ -0,0 +1,366 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "github.com/coze-dev/coze-loop/backend/modules/prompt/infra/repo/mysql/gorm_gen/model" +) + +func newToolCommit(db *gorm.DB, opts ...gen.DOOption) toolCommit { + _toolCommit := toolCommit{} + + _toolCommit.toolCommitDo.UseDB(db, opts...) + _toolCommit.toolCommitDo.UseModel(&model.ToolCommit{}) + + tableName := _toolCommit.toolCommitDo.TableName() + _toolCommit.ALL = field.NewAsterisk(tableName) + _toolCommit.ID = field.NewInt64(tableName, "id") + _toolCommit.SpaceID = field.NewInt64(tableName, "space_id") + _toolCommit.ToolID = field.NewInt64(tableName, "tool_id") + _toolCommit.Content = field.NewString(tableName, "content") + _toolCommit.Version = field.NewString(tableName, "version") + _toolCommit.BaseVersion = field.NewString(tableName, "base_version") + _toolCommit.CommittedBy = field.NewString(tableName, "committed_by") + _toolCommit.Description = field.NewString(tableName, "description") + _toolCommit.CreatedAt = field.NewTime(tableName, "created_at") + _toolCommit.UpdatedAt = field.NewTime(tableName, "updated_at") + + _toolCommit.fillFieldMap() + + return _toolCommit +} + +// toolCommit 工具版本 +type toolCommit struct { + toolCommitDo toolCommitDo + + ALL field.Asterisk + ID field.Int64 // 主键ID + SpaceID field.Int64 // 空间ID + ToolID field.Int64 // Tool ID + Content field.String // 工具内容 + Version field.String // 版本 + BaseVersion field.String // 来源版本 + CommittedBy field.String // 提交人 + Description field.String // 提交版本描述 + CreatedAt field.Time // 创建时间 + UpdatedAt field.Time // 更新时间 + + fieldMap map[string]field.Expr +} + +func (t toolCommit) Table(newTableName string) *toolCommit { + t.toolCommitDo.UseTable(newTableName) + return t.updateTableName(newTableName) +} + +func (t toolCommit) As(alias string) *toolCommit { + t.toolCommitDo.DO = *(t.toolCommitDo.As(alias).(*gen.DO)) + return t.updateTableName(alias) +} + +func (t *toolCommit) updateTableName(table string) *toolCommit { + t.ALL = field.NewAsterisk(table) + t.ID = field.NewInt64(table, "id") + t.SpaceID = field.NewInt64(table, "space_id") + t.ToolID = field.NewInt64(table, "tool_id") + t.Content = field.NewString(table, "content") + t.Version = field.NewString(table, "version") + t.BaseVersion = field.NewString(table, "base_version") + t.CommittedBy = field.NewString(table, "committed_by") + t.Description = field.NewString(table, "description") + t.CreatedAt = field.NewTime(table, "created_at") + t.UpdatedAt = field.NewTime(table, "updated_at") + + t.fillFieldMap() + + return t +} + +func (t *toolCommit) WithContext(ctx context.Context) *toolCommitDo { + return t.toolCommitDo.WithContext(ctx) +} + +func (t toolCommit) TableName() string { return t.toolCommitDo.TableName() } + +func (t toolCommit) Alias() string { return t.toolCommitDo.Alias() } + +func (t toolCommit) Columns(cols ...field.Expr) gen.Columns { return t.toolCommitDo.Columns(cols...) } + +func (t *toolCommit) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := t.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (t *toolCommit) fillFieldMap() { + t.fieldMap = make(map[string]field.Expr, 10) + t.fieldMap["id"] = t.ID + t.fieldMap["space_id"] = t.SpaceID + t.fieldMap["tool_id"] = t.ToolID + t.fieldMap["content"] = t.Content + t.fieldMap["version"] = t.Version + t.fieldMap["base_version"] = t.BaseVersion + t.fieldMap["committed_by"] = t.CommittedBy + t.fieldMap["description"] = t.Description + t.fieldMap["created_at"] = t.CreatedAt + t.fieldMap["updated_at"] = t.UpdatedAt +} + +func (t toolCommit) clone(db *gorm.DB) toolCommit { + t.toolCommitDo.ReplaceConnPool(db.Statement.ConnPool) + return t +} + +func (t toolCommit) replaceDB(db *gorm.DB) toolCommit { + t.toolCommitDo.ReplaceDB(db) + return t +} + +type toolCommitDo struct{ gen.DO } + +func (t toolCommitDo) Debug() *toolCommitDo { + return t.withDO(t.DO.Debug()) +} + +func (t toolCommitDo) WithContext(ctx context.Context) *toolCommitDo { + return t.withDO(t.DO.WithContext(ctx)) +} + +func (t toolCommitDo) ReadDB() *toolCommitDo { + return t.Clauses(dbresolver.Read) +} + +func (t toolCommitDo) WriteDB() *toolCommitDo { + return t.Clauses(dbresolver.Write) +} + +func (t toolCommitDo) Session(config *gorm.Session) *toolCommitDo { + return t.withDO(t.DO.Session(config)) +} + +func (t toolCommitDo) Clauses(conds ...clause.Expression) *toolCommitDo { + return t.withDO(t.DO.Clauses(conds...)) +} + +func (t toolCommitDo) Returning(value interface{}, columns ...string) *toolCommitDo { + return t.withDO(t.DO.Returning(value, columns...)) +} + +func (t toolCommitDo) Not(conds ...gen.Condition) *toolCommitDo { + return t.withDO(t.DO.Not(conds...)) +} + +func (t toolCommitDo) Or(conds ...gen.Condition) *toolCommitDo { + return t.withDO(t.DO.Or(conds...)) +} + +func (t toolCommitDo) Select(conds ...field.Expr) *toolCommitDo { + return t.withDO(t.DO.Select(conds...)) +} + +func (t toolCommitDo) Where(conds ...gen.Condition) *toolCommitDo { + return t.withDO(t.DO.Where(conds...)) +} + +func (t toolCommitDo) Order(conds ...field.Expr) *toolCommitDo { + return t.withDO(t.DO.Order(conds...)) +} + +func (t toolCommitDo) Distinct(cols ...field.Expr) *toolCommitDo { + return t.withDO(t.DO.Distinct(cols...)) +} + +func (t toolCommitDo) Omit(cols ...field.Expr) *toolCommitDo { + return t.withDO(t.DO.Omit(cols...)) +} + +func (t toolCommitDo) Join(table schema.Tabler, on ...field.Expr) *toolCommitDo { + return t.withDO(t.DO.Join(table, on...)) +} + +func (t toolCommitDo) LeftJoin(table schema.Tabler, on ...field.Expr) *toolCommitDo { + return t.withDO(t.DO.LeftJoin(table, on...)) +} + +func (t toolCommitDo) RightJoin(table schema.Tabler, on ...field.Expr) *toolCommitDo { + return t.withDO(t.DO.RightJoin(table, on...)) +} + +func (t toolCommitDo) Group(cols ...field.Expr) *toolCommitDo { + return t.withDO(t.DO.Group(cols...)) +} + +func (t toolCommitDo) Having(conds ...gen.Condition) *toolCommitDo { + return t.withDO(t.DO.Having(conds...)) +} + +func (t toolCommitDo) Limit(limit int) *toolCommitDo { + return t.withDO(t.DO.Limit(limit)) +} + +func (t toolCommitDo) Offset(offset int) *toolCommitDo { + return t.withDO(t.DO.Offset(offset)) +} + +func (t toolCommitDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *toolCommitDo { + return t.withDO(t.DO.Scopes(funcs...)) +} + +func (t toolCommitDo) Unscoped() *toolCommitDo { + return t.withDO(t.DO.Unscoped()) +} + +func (t toolCommitDo) Create(values ...*model.ToolCommit) error { + if len(values) == 0 { + return nil + } + return t.DO.Create(values) +} + +func (t toolCommitDo) CreateInBatches(values []*model.ToolCommit, batchSize int) error { + return t.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (t toolCommitDo) Save(values ...*model.ToolCommit) error { + if len(values) == 0 { + return nil + } + return t.DO.Save(values) +} + +func (t toolCommitDo) First() (*model.ToolCommit, error) { + if result, err := t.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.ToolCommit), nil + } +} + +func (t toolCommitDo) Take() (*model.ToolCommit, error) { + if result, err := t.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.ToolCommit), nil + } +} + +func (t toolCommitDo) Last() (*model.ToolCommit, error) { + if result, err := t.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.ToolCommit), nil + } +} + +func (t toolCommitDo) Find() ([]*model.ToolCommit, error) { + result, err := t.DO.Find() + return result.([]*model.ToolCommit), err +} + +func (t toolCommitDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ToolCommit, err error) { + buf := make([]*model.ToolCommit, 0, batchSize) + err = t.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (t toolCommitDo) FindInBatches(result *[]*model.ToolCommit, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return t.DO.FindInBatches(result, batchSize, fc) +} + +func (t toolCommitDo) Attrs(attrs ...field.AssignExpr) *toolCommitDo { + return t.withDO(t.DO.Attrs(attrs...)) +} + +func (t toolCommitDo) Assign(attrs ...field.AssignExpr) *toolCommitDo { + return t.withDO(t.DO.Assign(attrs...)) +} + +func (t toolCommitDo) Joins(fields ...field.RelationField) *toolCommitDo { + for _, _f := range fields { + t = *t.withDO(t.DO.Joins(_f)) + } + return &t +} + +func (t toolCommitDo) Preload(fields ...field.RelationField) *toolCommitDo { + for _, _f := range fields { + t = *t.withDO(t.DO.Preload(_f)) + } + return &t +} + +func (t toolCommitDo) FirstOrInit() (*model.ToolCommit, error) { + if result, err := t.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.ToolCommit), nil + } +} + +func (t toolCommitDo) FirstOrCreate() (*model.ToolCommit, error) { + if result, err := t.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.ToolCommit), nil + } +} + +func (t toolCommitDo) FindByPage(offset int, limit int) (result []*model.ToolCommit, count int64, err error) { + result, err = t.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = t.Offset(-1).Limit(-1).Count() + return +} + +func (t toolCommitDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = t.Count() + if err != nil { + return + } + + err = t.Offset(offset).Limit(limit).Scan(result) + return +} + +func (t toolCommitDo) Scan(result interface{}) (err error) { + return t.DO.Scan(result) +} + +func (t toolCommitDo) Delete(models ...*model.ToolCommit) (result gen.ResultInfo, err error) { + return t.DO.Delete(models) +} + +func (t *toolCommitDo) withDO(do gen.Dao) *toolCommitDo { + t.DO = *do.(*gen.DO) + return t +} diff --git a/backend/modules/prompt/infra/repo/mysql/tool_basic.go b/backend/modules/prompt/infra/repo/mysql/tool_basic.go new file mode 100644 index 000000000..f91458830 --- /dev/null +++ b/backend/modules/prompt/infra/repo/mysql/tool_basic.go @@ -0,0 +1,180 @@ +package mysql + +import ( + "context" + "fmt" + "strconv" + "time" + + "github.com/samber/lo" + "gorm.io/gen/field" + + "github.com/coze-dev/coze-loop/backend/infra/db" + "github.com/coze-dev/coze-loop/backend/infra/platestwrite" + "github.com/coze-dev/coze-loop/backend/infra/redis" + "github.com/coze-dev/coze-loop/backend/modules/prompt/infra/repo/mysql/gorm_gen/model" + "github.com/coze-dev/coze-loop/backend/modules/prompt/infra/repo/mysql/gorm_gen/query" + prompterr "github.com/coze-dev/coze-loop/backend/modules/prompt/pkg/errno" + "github.com/coze-dev/coze-loop/backend/pkg/errorx" + "github.com/coze-dev/coze-loop/backend/pkg/json" +) + +type IToolBasicDAO interface { + Create(ctx context.Context, basicPO *model.ToolBasic, opts ...db.Option) (err error) + Delete(ctx context.Context, toolID int64, spaceID int64, opts ...db.Option) (err error) + Get(ctx context.Context, toolID int64, opts ...db.Option) (basicPO *model.ToolBasic, err error) + List(ctx context.Context, param ListToolBasicParam, opts ...db.Option) (basicPOs []*model.ToolBasic, total int64, err error) + Update(ctx context.Context, toolID int64, updateFields map[string]interface{}, opts ...db.Option) (err error) +} + +type ListToolBasicParam struct { + SpaceID int64 + + KeyWord string + CreatedBys []string + CommittedOnly bool + + Offset int + Limit int + OrderBy int + Asc bool +} + +const ( + ListToolBasicOrderByID = 1 + ListToolBasicOrderByCreatedAt = 2 + ListToolBasicOrderByUpdatedAt = 3 + ListToolBasicOrderByCommittedAt = 4 +) + +func NewToolBasicDAO(db db.Provider, redisCli redis.Cmdable) IToolBasicDAO { + return &ToolBasicDAOImpl{ + db: db, + writeTracker: platestwrite.NewLatestWriteTracker(redisCli), + } +} + +type ToolBasicDAOImpl struct { + db db.Provider + writeTracker platestwrite.ILatestWriteTracker +} + +func (d *ToolBasicDAOImpl) Create(ctx context.Context, basicPO *model.ToolBasic, opts ...db.Option) (err error) { + if basicPO == nil { + return errorx.New("basicPO is empty") + } + q := query.Use(d.db.NewSession(ctx, opts...)).WithContext(ctx) + basicPO.CreatedAt = time.Time{} + basicPO.UpdatedAt = time.Time{} + err = q.ToolBasic.Create(basicPO) + if err != nil { + return errorx.WrapByCode(err, prompterr.CommonMySqlErrorCode) + } + d.writeTracker.SetWriteFlag(ctx, platestwrite.ResourceTypeToolBasic, basicPO.ID, platestwrite.SetWithSearchParam(strconv.FormatInt(basicPO.SpaceID, 10))) + return nil +} + +func (d *ToolBasicDAOImpl) Delete(ctx context.Context, toolID int64, spaceID int64, opts ...db.Option) (err error) { + if toolID <= 0 { + return errorx.New("toolID is invalid, toolID = %d", toolID) + } + q := query.Use(d.db.NewSession(ctx, opts...)) + tx := q.WithContext(ctx).ToolBasic + tx = tx.Where(q.ToolBasic.ID.Eq(toolID)) + _, err = tx.Delete(&model.ToolBasic{}) + if err != nil { + return errorx.WrapByCode(err, prompterr.CommonMySqlErrorCode) + } + d.writeTracker.SetWriteFlag(ctx, platestwrite.ResourceTypeToolBasic, toolID, platestwrite.SetWithSearchParam(strconv.FormatInt(spaceID, 10))) + return nil +} + +func (d *ToolBasicDAOImpl) Get(ctx context.Context, toolID int64, opts ...db.Option) (basicPO *model.ToolBasic, err error) { + if toolID <= 0 { + return nil, errorx.New("toolID is invalid, toolID = %d", toolID) + } + if d.writeTracker.CheckWriteFlagByID(ctx, platestwrite.ResourceTypeToolBasic, toolID) { + opts = append(opts, db.WithMaster()) + } + q := query.Use(d.db.NewSession(ctx, opts...)) + tx := q.WithContext(ctx).ToolBasic + basicPOs, err := tx.Where(q.ToolBasic.ID.Eq(toolID)).Find() + if err != nil { + return nil, errorx.WrapByCode(err, prompterr.CommonMySqlErrorCode) + } + if len(basicPOs) == 0 { + return nil, nil + } + return basicPOs[0], nil +} + +func (d *ToolBasicDAOImpl) List(ctx context.Context, param ListToolBasicParam, opts ...db.Option) (basicPOs []*model.ToolBasic, total int64, err error) { + if param.SpaceID <= 0 || param.Offset < 0 || param.Limit <= 0 { + return nil, 0, errorx.New("param(SpaceID or Offset or Limit) is invalid, param = %s", json.Jsonify(param)) + } + if d.writeTracker.CheckWriteFlagBySearchParam(ctx, platestwrite.ResourceTypeToolBasic, strconv.FormatInt(param.SpaceID, 10)) { + opts = append(opts, db.WithMaster()) + } + + q := query.Use(d.db.NewSession(ctx, opts...)) + tx := q.WithContext(ctx).ToolBasic + tx = tx.Where(q.ToolBasic.SpaceID.Eq(param.SpaceID)) + if len(param.CreatedBys) > 0 { + tx = tx.Where(q.ToolBasic.CreatedBy.In(param.CreatedBys...)) + } + if !lo.IsEmpty(param.KeyWord) { + likeExpr := field.Or( + q.ToolBasic.Name.Like(fmt.Sprintf("%%%s%%", param.KeyWord)), + q.ToolBasic.Description.Like(fmt.Sprintf("%%%s%%", param.KeyWord)), + ) + tx = tx.Where(likeExpr) + } + if param.CommittedOnly { + tx = tx.Where(q.ToolBasic.LatestCommittedVersion.Neq("")) + } + total, err = tx.Count() + if err != nil { + return nil, 0, errorx.WrapByCode(err, prompterr.CommonMySqlErrorCode) + } + tx = tx.Order(d.order(q, param.OrderBy, param.Asc)).Offset(param.Offset).Limit(param.Limit) + basicPOs, err = tx.Find() + if err != nil { + return nil, 0, errorx.WrapByCode(err, prompterr.CommonMySqlErrorCode) + } + return basicPOs, total, nil +} + +func (d *ToolBasicDAOImpl) Update(ctx context.Context, toolID int64, updateFields map[string]interface{}, opts ...db.Option) (err error) { + if toolID <= 0 { + return errorx.New("toolID is invalid, toolID = %d", toolID) + } + q := query.Use(d.db.NewSession(ctx, opts...)) + tx := q.WithContext(ctx).ToolBasic + tx = tx.Where(q.ToolBasic.ID.Eq(toolID)) + _, err = tx.Updates(updateFields) + if err != nil { + return errorx.WrapByCode(err, prompterr.CommonMySqlErrorCode) + } + d.writeTracker.SetWriteFlag(ctx, platestwrite.ResourceTypeToolBasic, toolID) + return nil +} + +func (d *ToolBasicDAOImpl) order(q *query.Query, orderBy int, asc bool) field.Expr { + var orderExpr field.OrderExpr + switch orderBy { + case ListToolBasicOrderByID: + orderExpr = q.ToolBasic.ID + case ListToolBasicOrderByCreatedAt: + orderExpr = q.ToolBasic.CreatedAt + case ListToolBasicOrderByCommittedAt: + orderExpr = q.ToolBasic.LatestCommittedAt + case ListToolBasicOrderByUpdatedAt: + orderExpr = q.ToolBasic.UpdatedAt + default: + orderExpr = q.ToolBasic.ID + } + if asc { + return orderExpr.Asc() + } + return orderExpr.Desc() +} diff --git a/backend/modules/prompt/infra/repo/mysql/tool_commit.go b/backend/modules/prompt/infra/repo/mysql/tool_commit.go new file mode 100644 index 000000000..74c63c632 --- /dev/null +++ b/backend/modules/prompt/infra/repo/mysql/tool_commit.go @@ -0,0 +1,151 @@ +package mysql + +import ( + "context" + "errors" + "fmt" + "time" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + + "github.com/coze-dev/coze-loop/backend/infra/db" + "github.com/coze-dev/coze-loop/backend/infra/platestwrite" + "github.com/coze-dev/coze-loop/backend/infra/redis" + "github.com/coze-dev/coze-loop/backend/modules/prompt/infra/repo/mysql/gorm_gen/model" + "github.com/coze-dev/coze-loop/backend/modules/prompt/infra/repo/mysql/gorm_gen/query" + prompterr "github.com/coze-dev/coze-loop/backend/modules/prompt/pkg/errno" + "github.com/coze-dev/coze-loop/backend/pkg/errorx" + "github.com/coze-dev/coze-loop/backend/pkg/json" +) + +type IToolCommitDAO interface { + Create(ctx context.Context, toolCommitPO *model.ToolCommit, timeNow time.Time, opts ...db.Option) (err error) + UpsertDraft(ctx context.Context, toolCommitPO *model.ToolCommit, timeNow time.Time, opts ...db.Option) (err error) + Get(ctx context.Context, toolID int64, version string, opts ...db.Option) (toolCommitPO *model.ToolCommit, err error) + List(ctx context.Context, param ListToolCommitParam, opts ...db.Option) (commitPOs []*model.ToolCommit, err error) +} + +type ListToolCommitParam struct { + ToolID int64 + + Cursor *int64 + Limit int + Asc bool + + ExcludeVersion string +} + +type ToolCommitDAOImpl struct { + db db.Provider + writeTracker platestwrite.ILatestWriteTracker +} + +func NewToolCommitDAO(db db.Provider, redisCli redis.Cmdable) IToolCommitDAO { + return &ToolCommitDAOImpl{ + db: db, + writeTracker: platestwrite.NewLatestWriteTracker(redisCli), + } +} + +func (d *ToolCommitDAOImpl) Create(ctx context.Context, toolCommitPO *model.ToolCommit, timeNow time.Time, opts ...db.Option) (err error) { + if toolCommitPO == nil { + return errorx.New("toolCommitPO is empty") + } + q := query.Use(d.db.NewSession(ctx, opts...)).WithContext(ctx) + toolCommitPO.CreatedAt = timeNow + toolCommitPO.UpdatedAt = timeNow + err = q.ToolCommit.Create(toolCommitPO) + if err != nil { + if errors.Is(err, gorm.ErrDuplicatedKey) { + return errorx.WrapByCode(err, prompterr.CommonResourceDuplicatedCode) + } + return errorx.WrapByCode(err, prompterr.CommonMySqlErrorCode) + } + d.writeTracker.SetWriteFlag(ctx, platestwrite.ResourceTypeToolCommit, toolCommitPO.ToolID, platestwrite.SetWithSearchParam(fmt.Sprintf("%d:%s", toolCommitPO.ToolID, toolCommitPO.Version))) + return nil +} + +func (d *ToolCommitDAOImpl) UpsertDraft(ctx context.Context, toolCommitPO *model.ToolCommit, timeNow time.Time, opts ...db.Option) (err error) { + if toolCommitPO == nil { + return errorx.New("toolCommitPO is empty") + } + q := query.Use(d.db.NewSession(ctx, opts...)).WithContext(ctx) + toolCommitPO.UpdatedAt = timeNow + toolCommitPO.CreatedAt = timeNow + + tx := q.ToolCommit.Clauses(clause.OnConflict{ + Columns: []clause.Column{ + {Name: "tool_id"}, + {Name: "version"}, + }, + DoUpdates: clause.AssignmentColumns([]string{ + "content", + "base_version", + "committed_by", + "description", + "updated_at", + }), + }) + err = tx.Create(toolCommitPO) + if err != nil { + return errorx.WrapByCode(err, prompterr.CommonMySqlErrorCode) + } + d.writeTracker.SetWriteFlag(ctx, platestwrite.ResourceTypeToolCommit, toolCommitPO.ToolID, platestwrite.SetWithSearchParam(fmt.Sprintf("%d:%s", toolCommitPO.ToolID, toolCommitPO.Version))) + return nil +} + +func (d *ToolCommitDAOImpl) Get(ctx context.Context, toolID int64, version string, opts ...db.Option) (toolCommitPO *model.ToolCommit, err error) { + if toolID <= 0 { + return nil, errorx.New("toolID is invalid, toolID = %d", toolID) + } + d.writeTracker.CheckWriteFlagBySearchParam(ctx, platestwrite.ResourceTypeToolCommit, fmt.Sprintf("%d:%s", toolID, version)) + + q := query.Use(d.db.NewSession(ctx, opts...)) + tx := q.WithContext(ctx).ToolCommit + tx = tx.Where(q.ToolCommit.ToolID.Eq(toolID), q.ToolCommit.Version.Eq(version)) + toolCommitPOs, err := tx.Find() + if err != nil { + return nil, errorx.WrapByCode(err, prompterr.CommonMySqlErrorCode) + } + if len(toolCommitPOs) == 0 { + return nil, nil + } + return toolCommitPOs[0], nil +} + +func (d *ToolCommitDAOImpl) List(ctx context.Context, param ListToolCommitParam, opts ...db.Option) (commitPOs []*model.ToolCommit, err error) { + if param.ToolID <= 0 || param.Limit <= 0 { + return nil, errorx.New("Param(ToolID or Limit) is invalid, param = %s", json.Jsonify(param)) + } + if d.writeTracker.CheckWriteFlagByID(ctx, platestwrite.ResourceTypeToolCommit, param.ToolID) { + opts = append(opts, db.WithMaster()) + } + + q := query.Use(d.db.NewSession(ctx, opts...)) + tx := q.WithContext(ctx).ToolCommit + tx = tx.Where(q.ToolCommit.ToolID.Eq(param.ToolID)) + if param.ExcludeVersion != "" { + tx = tx.Where(q.ToolCommit.Version.Neq(param.ExcludeVersion)) + } + + if param.Cursor == nil { + if param.Asc { + tx = tx.Order(q.ToolCommit.CreatedAt.Asc()) + } else { + tx = tx.Order(q.ToolCommit.CreatedAt.Desc()) + } + } else { + if param.Asc { + tx = tx.Where(q.ToolCommit.CreatedAt.Gte(time.Unix(*param.Cursor, 0))).Order(q.ToolCommit.CreatedAt.Asc()) + } else { + tx = tx.Where(q.ToolCommit.CreatedAt.Lte(time.Unix(*param.Cursor, 0))).Order(q.ToolCommit.CreatedAt.Desc()) + } + } + tx = tx.Limit(param.Limit) + commitPOs, err = tx.Find() + if err != nil { + return nil, errorx.WrapByCode(err, prompterr.CommonMySqlErrorCode) + } + return commitPOs, nil +} diff --git a/backend/modules/prompt/infra/repo/tool.go b/backend/modules/prompt/infra/repo/tool.go new file mode 100644 index 000000000..8c5c9d305 --- /dev/null +++ b/backend/modules/prompt/infra/repo/tool.go @@ -0,0 +1,301 @@ +package repo + +import ( + "context" + "fmt" + "time" + + "github.com/samber/lo" + "gorm.io/gorm" + + "github.com/coze-dev/coze-loop/backend/infra/db" + "github.com/coze-dev/coze-loop/backend/infra/idgen" + "github.com/coze-dev/coze-loop/backend/modules/prompt/domain/entity/toolmgmt" + "github.com/coze-dev/coze-loop/backend/modules/prompt/domain/repo" + "github.com/coze-dev/coze-loop/backend/modules/prompt/infra/repo/mysql" + "github.com/coze-dev/coze-loop/backend/modules/prompt/infra/repo/mysql/convertor" + mysqlmodel "github.com/coze-dev/coze-loop/backend/modules/prompt/infra/repo/mysql/gorm_gen/model" + prompterr "github.com/coze-dev/coze-loop/backend/modules/prompt/pkg/errno" + "github.com/coze-dev/coze-loop/backend/pkg/errorx" + "github.com/coze-dev/coze-loop/backend/pkg/json" +) + +type ToolRepoImpl struct { + db db.Provider + idgen idgen.IIDGenerator + + toolBasicDAO mysql.IToolBasicDAO + toolCommitDAO mysql.IToolCommitDAO +} + +func NewToolRepo( + db db.Provider, + idgen idgen.IIDGenerator, + toolBasicDAO mysql.IToolBasicDAO, + toolCommitDAO mysql.IToolCommitDAO, +) repo.IToolRepo { + return &ToolRepoImpl{ + db: db, + idgen: idgen, + toolBasicDAO: toolBasicDAO, + toolCommitDAO: toolCommitDAO, + } +} + +func (d *ToolRepoImpl) CreateTool(ctx context.Context, tool *toolmgmt.Tool) (toolID int64, err error) { + if tool == nil || tool.ToolBasic == nil { + return 0, errorx.New("tool or tool.ToolBasic is empty") + } + toolID, err = d.idgen.GenID(ctx) + if err != nil { + return 0, err + } + return toolID, d.db.Transaction(ctx, func(tx *gorm.DB) error { + opt := db.WithTransaction(tx) + + basicPO := convertor.ToolDO2BasicPO(tool) + basicPO.ID = toolID + if err := d.toolBasicDAO.Create(ctx, basicPO, opt); err != nil { + return err + } + + var draftContent string + if tool.ToolCommit != nil && tool.ToolCommit.ToolDetail != nil { + draftContent = tool.ToolCommit.ToolDetail.Content + } + draftPO := &mysqlmodel.ToolCommit{ + SpaceID: tool.SpaceID, + ToolID: toolID, + Version: toolmgmt.PublicDraftVersion, + BaseVersion: "", + CommittedBy: tool.ToolBasic.CreatedBy, + Content: lo.ToPtr(draftContent), + Description: nil, + } + if err := d.toolCommitDAO.UpsertDraft(ctx, draftPO, time.Now(), opt); err != nil { + return err + } + return nil + }) +} + +func (d *ToolRepoImpl) DeleteTool(ctx context.Context, toolID int64) (err error) { + if toolID <= 0 { + return errorx.New("toolID is invalid, toolID = %d", toolID) + } + basicPO, err := d.toolBasicDAO.Get(ctx, toolID) + if err != nil { + return err + } + if basicPO == nil { + return errorx.NewByCode(prompterr.ResourceNotFoundCode, errorx.WithExtraMsg(fmt.Sprintf("tool is not found, tool id = %d", toolID))) + } + return d.toolBasicDAO.Delete(ctx, toolID, basicPO.SpaceID) +} + +func (d *ToolRepoImpl) GetTool(ctx context.Context, param repo.GetToolParam) (tool *toolmgmt.Tool, err error) { + if param.ToolID <= 0 { + return nil, errorx.New("param.ToolID is invalid, param = %s", json.Jsonify(param)) + } + if param.WithCommit && lo.IsEmpty(param.CommitVersion) { + return nil, errorx.New("Get with commit, but param.CommitVersion is empty, param = %s", json.Jsonify(param)) + } + + err = d.db.Transaction(ctx, func(tx *gorm.DB) error { + opt := db.WithTransaction(tx) + + basicPO, err := d.toolBasicDAO.Get(ctx, param.ToolID, opt) + if err != nil { + return err + } + if basicPO == nil { + return errorx.NewByCode(prompterr.ResourceNotFoundCode, errorx.WithExtraMsg(fmt.Sprintf("tool id = %d", param.ToolID))) + } + + var commitPO *mysqlmodel.ToolCommit + if param.WithCommit { + commitPO, err = d.toolCommitDAO.Get(ctx, param.ToolID, param.CommitVersion, opt) + if err != nil { + return err + } + if commitPO == nil { + return errorx.NewByCode(prompterr.ResourceNotFoundCode, errorx.WithExtraMsg(fmt.Sprintf("tool commit is not found, tool id = %d, version = %s", param.ToolID, param.CommitVersion))) + } + } else if param.WithDraft { + commitPO, err = d.toolCommitDAO.Get(ctx, param.ToolID, toolmgmt.PublicDraftVersion, opt) + if err != nil { + return err + } + } + tool = convertor.ToolPO2DO(basicPO, commitPO) + return nil + }) + if err != nil { + return nil, err + } + return tool, nil +} + +func (d *ToolRepoImpl) ListTool(ctx context.Context, param repo.ListToolParam) (result *repo.ListToolResult, err error) { + if param.SpaceID <= 0 || param.PageNum <= 0 || param.PageSize <= 0 { + return nil, errorx.New("param is invalid, param = %s", json.Jsonify(param)) + } + offset := (param.PageNum - 1) * param.PageSize + basicPOs, total, err := d.toolBasicDAO.List(ctx, mysql.ListToolBasicParam{ + SpaceID: param.SpaceID, + KeyWord: param.KeyWord, + CreatedBys: param.CreatedBys, + CommittedOnly: param.CommittedOnly, + Offset: offset, + Limit: param.PageSize, + OrderBy: param.OrderBy, + Asc: param.Asc, + }) + if err != nil { + return nil, err + } + tools := make([]*toolmgmt.Tool, 0, len(basicPOs)) + for _, po := range basicPOs { + if po == nil { + continue + } + tools = append(tools, convertor.ToolPO2DO(po, nil)) + } + return &repo.ListToolResult{ + Total: total, + Tools: tools, + }, nil +} + +func (d *ToolRepoImpl) SaveToolDetail(ctx context.Context, param repo.SaveToolDetailParam) (err error) { + if param.ToolID <= 0 { + return errorx.New("param.ToolID is invalid, param = %s", json.Jsonify(param)) + } + return d.db.Transaction(ctx, func(tx *gorm.DB) error { + opt := db.WithTransaction(tx) + + basicPO, err := d.toolBasicDAO.Get(ctx, param.ToolID, opt) + if err != nil { + return err + } + if basicPO == nil { + return errorx.NewByCode(prompterr.ResourceNotFoundCode, errorx.WithExtraMsg(fmt.Sprintf("tool id = %d", param.ToolID))) + } + + if err := d.toolCommitDAO.UpsertDraft(ctx, &mysqlmodel.ToolCommit{ + SpaceID: basicPO.SpaceID, + ToolID: param.ToolID, + Version: toolmgmt.PublicDraftVersion, + BaseVersion: param.BaseVersion, + CommittedBy: param.UpdatedBy, + Content: lo.ToPtr(param.Content), + Description: nil, + }, time.Now(), opt); err != nil { + return err + } + + if !lo.IsEmpty(param.UpdatedBy) { + if err := d.toolBasicDAO.Update(ctx, param.ToolID, map[string]interface{}{ + "updated_by": param.UpdatedBy, + }, opt); err != nil { + return err + } + } + return nil + }) +} + +func (d *ToolRepoImpl) CommitToolDraft(ctx context.Context, param repo.CommitToolDraftParam) (err error) { + if param.ToolID <= 0 || lo.IsEmpty(param.CommitVersion) { + return errorx.New("param is invalid, param = %s", json.Jsonify(param)) + } + if param.CommitVersion == toolmgmt.PublicDraftVersion { + return errorx.NewByCode(prompterr.CommonInvalidParamCode, errorx.WithExtraMsg("commit_version is invalid")) + } + + return d.db.Transaction(ctx, func(tx *gorm.DB) error { + opt := db.WithTransaction(tx) + + basicPO, err := d.toolBasicDAO.Get(ctx, param.ToolID, opt) + if err != nil { + return err + } + if basicPO == nil { + return errorx.NewByCode(prompterr.ResourceNotFoundCode, errorx.WithExtraMsg(fmt.Sprintf("tool id = %d", param.ToolID))) + } + + draftPO, err := d.toolCommitDAO.Get(ctx, param.ToolID, toolmgmt.PublicDraftVersion, opt) + if err != nil { + return err + } + if draftPO == nil { + return errorx.NewByCode(prompterr.ResourceNotFoundCode, errorx.WithExtraMsg(fmt.Sprintf("tool draft is not found, tool id = %d", param.ToolID))) + } + + commitPO := &mysqlmodel.ToolCommit{ + SpaceID: basicPO.SpaceID, + ToolID: param.ToolID, + Version: param.CommitVersion, + BaseVersion: param.BaseVersion, + CommittedBy: param.CommittedBy, + Content: draftPO.Content, + Description: lo.ToPtr(param.CommitDescription), + } + if err := d.toolCommitDAO.Create(ctx, commitPO, time.Now(), opt); err != nil { + return err + } + if err := d.toolBasicDAO.Update(ctx, param.ToolID, map[string]interface{}{ + "latest_committed_version": param.CommitVersion, + "latest_committed_at": time.Now(), + "updated_by": param.CommittedBy, + }, opt); err != nil { + return err + } + return nil + }) +} + +func (d *ToolRepoImpl) ListToolCommit(ctx context.Context, param repo.ListToolCommitParam) (result *repo.ListToolCommitResult, err error) { + if param.ToolID <= 0 || param.PageSize <= 0 { + return nil, errorx.New("param is invalid, param = %s", json.Jsonify(param)) + } + commitPOs, err := d.toolCommitDAO.List(ctx, mysql.ListToolCommitParam{ + ToolID: param.ToolID, + Cursor: param.PageToken, + Limit: param.PageSize, + Asc: param.Asc, + ExcludeVersion: toolmgmt.PublicDraftVersion, + }) + if err != nil { + return nil, err + } + commitInfos := make([]*toolmgmt.CommitInfo, 0, len(commitPOs)) + var commitDetails map[string]*toolmgmt.ToolDetail + if param.WithCommitDetail { + commitDetails = make(map[string]*toolmgmt.ToolDetail, len(commitPOs)) + } + var nextToken int64 + for _, po := range commitPOs { + if po == nil { + continue + } + nextToken = po.CreatedAt.Unix() + commitInfos = append(commitInfos, &toolmgmt.CommitInfo{ + Version: po.Version, + BaseVersion: po.BaseVersion, + Description: lo.FromPtr(po.Description), + CommittedBy: po.CommittedBy, + CommittedAt: po.CreatedAt, + }) + if param.WithCommitDetail { + commitDetails[po.Version] = &toolmgmt.ToolDetail{ + Content: lo.FromPtr(po.Content), + } + } + } + return &repo.ListToolCommitResult{ + CommitInfos: commitInfos, + CommitDetails: commitDetails, + NextPageToken: nextToken, + }, nil +} diff --git a/backend/script/gorm_gen/generate.go b/backend/script/gorm_gen/generate.go index 11822ff6a..9d2ca0e29 100644 --- a/backend/script/gorm_gen/generate.go +++ b/backend/script/gorm_gen/generate.go @@ -56,6 +56,7 @@ func generateForPrompt(db *gorm.DB) { for _, table := range []string{ "prompt_basic", "prompt_user_draft", "prompt_debug_log", "prompt_debug_context", "prompt_label", "prompt_commit_label_mapping", + "tool_basic", } { models = append(models, g.GenerateModel(table, // 添加软删除字段 @@ -68,7 +69,7 @@ func generateForPrompt(db *gorm.DB) { }))) } - for _, table := range []string{"prompt_commit", "prompt_relation"} { + for _, table := range []string{"prompt_commit", "prompt_relation", "tool_commit"} { models = append(models, g.GenerateModel(table, gen.FieldGORMTag("*", func(tag field.GormTag) field.GormTag { return tag.Set("charset=utf8mb4") diff --git a/frontend/packages/loop-base/api-schema/api.config.js b/frontend/packages/loop-base/api-schema/api.config.js index cceaa90ef..05394893e 100644 --- a/frontend/packages/loop-base/api-schema/api.config.js +++ b/frontend/packages/loop-base/api-schema/api.config.js @@ -13,6 +13,7 @@ const config = [ entries: { promptDebug: './prompt/coze.loop.prompt.debug.thrift', promptManage: './prompt/coze.loop.prompt.manage.thrift', + toolManage: './prompt/coze.loop.prompt.tool.manage.thrift', observabilityTrace: './observability/coze.loop.observability.trace.thrift', observabilityTask: './observability/coze.loop.observability.task.thrift', diff --git a/idl/thrift/coze/loop/apis/coze.loop.apis.thrift b/idl/thrift/coze/loop/apis/coze.loop.apis.thrift index 97630e1b5..80384ad1b 100644 --- a/idl/thrift/coze/loop/apis/coze.loop.apis.thrift +++ b/idl/thrift/coze/loop/apis/coze.loop.apis.thrift @@ -13,6 +13,7 @@ include "../evaluation/coze.loop.evaluation.expt.thrift" include "../evaluation/coze.loop.evaluation.openapi.thrift" include "../data/coze.loop.data.dataset.thrift" include "../prompt/coze.loop.prompt.manage.thrift" +include "../prompt/coze.loop.prompt.tool.manage.thrift" include "../prompt/coze.loop.prompt.debug.thrift" include "../prompt/coze.loop.prompt.execute.thrift" include "../prompt/coze.loop.prompt.openapi.thrift" @@ -34,6 +35,7 @@ service DatasetService extends coze.loop.data.dataset.DatasetService{} service TagService extends coze.loop.data.tag.TagService{} service PromptManageService extends coze.loop.prompt.manage.PromptManageService{} +service ToolManageService extends coze.loop.prompt.tool.manage.ToolManageService{} service PromptDebugService extends coze.loop.prompt.debug.PromptDebugService{} service PromptExecuteService extends coze.loop.prompt.execute.PromptExecuteService{} service PromptOpenAPIService extends coze.loop.prompt.openapi.PromptOpenAPIService{} diff --git a/idl/thrift/coze/loop/prompt/coze.loop.prompt.thrift b/idl/thrift/coze/loop/prompt/coze.loop.prompt.thrift index eb0522b7b..2e5ac9cae 100644 --- a/idl/thrift/coze/loop/prompt/coze.loop.prompt.thrift +++ b/idl/thrift/coze/loop/prompt/coze.loop.prompt.thrift @@ -1,11 +1,13 @@ namespace go coze.loop.prompt include "coze.loop.prompt.manage.thrift" +include "coze.loop.prompt.tool.manage.thrift" include "coze.loop.prompt.debug.thrift" include "coze.loop.prompt.openapi.thrift" include "coze.loop.prompt.execute.thrift" service PromptManageService extends coze.loop.prompt.manage.PromptManageService{} +service ToolManageService extends coze.loop.prompt.tool.manage.ToolManageService{} service PromptDebugService extends coze.loop.prompt.debug.PromptDebugService{} service PromptExecuteService extends coze.loop.prompt.execute.PromptExecuteService{} -service PromptOpenAPIService extends coze.loop.prompt.openapi.PromptOpenAPIService{} \ No newline at end of file +service PromptOpenAPIService extends coze.loop.prompt.openapi.PromptOpenAPIService{} diff --git a/idl/thrift/coze/loop/prompt/coze.loop.prompt.tool.manage.thrift b/idl/thrift/coze/loop/prompt/coze.loop.prompt.tool.manage.thrift new file mode 100644 index 000000000..0622c00fe --- /dev/null +++ b/idl/thrift/coze/loop/prompt/coze.loop.prompt.tool.manage.thrift @@ -0,0 +1,131 @@ +namespace go coze.loop.prompt.tool.manage + +include "../../../base.thrift" +include "./domain/tool.thrift" +include "./domain/user.thrift" + +service ToolManageService { + CreateToolResponse CreateTool(1: CreateToolRequest request) (api.post = '/api/prompt/v1/tools') + GetToolDetailResponse GetToolDetail(1: GetToolDetailRequest request) (api.get = '/api/prompt/v1/tools/:tool_id') + ListToolResponse ListTool(1: ListToolRequest request) (api.post = '/api/prompt/v1/tools/list') + SaveToolDetailResponse SaveToolDetail(1: SaveToolDetailRequest request) (api.post = '/api/prompt/v1/tools/:tool_id/drafts/save') + CommitToolDraftResponse CommitToolDraft(1: CommitToolDraftRequest request) (api.post = '/api/prompt/v1/tools/:tool_id/drafts/commit') + ListToolCommitResponse ListToolCommit(1: ListToolCommitRequest request) (api.post = '/api/prompt/v1/tools/:tool_id/commits/list') +} + +struct CreateToolRequest { + 1: optional i64 workspace_id (api.js_conv='true', vt.not_nil='true', vt.gt='0', go.tag='json:"workspace_id"') + + 11: optional string tool_name (vt.not_nil="true", vt.min_size="1") + 12: optional string tool_description + + 21: optional tool.ToolDetail draft_detail + + 255: optional base.Base Base +} + +struct CreateToolResponse { + 1: optional i64 tool_id (api.js_conv="true", go.tag='json:"tool_id"') + + 255: optional base.BaseResp BaseResp +} + +struct GetToolDetailRequest { + 1: optional i64 tool_id (api.path='tool_id', api.js_conv='true', vt.not_nil='true', vt.gt='0', go.tag='json:"tool_id"') + 2: optional i64 workspace_id (api.query="workspace_id", api.js_conv='true', go.tag='json:"workspace_id"') + + 11: optional bool with_commit (api.query="with_commit") + 12: optional string commit_version (api.query="commit_version") + + 21: optional bool with_draft (api.query="with_draft") + + 255: optional base.Base Base +} + +struct GetToolDetailResponse { + 1: optional tool.Tool tool + + 255: optional base.BaseResp BaseResp +} + +struct ListToolRequest { + 1: optional i64 workspace_id (api.js_conv='true', vt.not_nil='true', vt.gt='0', go.tag='json:"workspace_id"') + + 11: optional string key_word + 12: optional list created_bys + 13: optional bool committed_only + + 127: optional i32 page_num (vt.not_nil="true", vt.gt="0") + 128: optional i32 page_size (vt.not_nil="true", vt.gt="0", vt.le="100") + 129: optional ListToolOrderBy order_by + 130: optional bool asc + + 255: optional base.Base Base +} + +struct ListToolResponse { + 1: optional list tools + + 11: optional list users + + 127: optional i32 total + + 255: optional base.BaseResp BaseResp +} + +typedef string ListToolOrderBy (ts.enum="true") +const ListToolOrderBy ListToolOrderBy_CommittedAt = "committed_at" +const ListToolOrderBy ListToolOrderBy_CreatedAt = "created_at" + +struct SaveToolDetailRequest { + 1: optional i64 tool_id (api.path='tool_id', api.js_conv='true', vt.not_nil='true', vt.gt='0', go.tag='json:"tool_id"') + 2: optional i64 workspace_id (api.query="workspace_id", api.js_conv='true', vt.not_nil='true', vt.gt='0', go.tag='json:"workspace_id"') + + 11: optional tool.ToolDetail tool_detail (vt.not_nil = "true") + 12: optional string base_version + + 255: optional base.Base Base +} + +struct SaveToolDetailResponse { + 255: optional base.BaseResp BaseResp +} + +struct CommitToolDraftRequest { + 1: optional i64 tool_id (api.path='tool_id', api.js_conv='true', vt.not_nil='true', vt.gt='0', go.tag='json:"tool_id"') + 2: optional i64 workspace_id (api.query="workspace_id", api.js_conv='true', vt.not_nil='true', vt.gt='0', go.tag='json:"workspace_id"') + + 11: optional string commit_version (vt.not_nil="true", vt.min_size="1") + 12: optional string commit_description + 13: optional string base_version + + 255: optional base.Base Base +} + +struct CommitToolDraftResponse { + 255: optional base.BaseResp BaseResp +} + +struct ListToolCommitRequest { + 1: optional i64 tool_id (api.path='tool_id', api.js_conv='true', vt.not_nil='true', vt.gt='0', go.tag='json:"tool_id"') + 2: optional i64 workspace_id (api.query="workspace_id", api.js_conv='true', vt.not_nil='true', vt.gt='0', go.tag='json:"workspace_id"') + 3: optional bool with_commit_detail (api.query="with_commit_detail") + + 127: optional i32 page_size (vt.not_nil="true", vt.gt="0") + 128: optional string page_token + 129: optional bool asc + + 255: optional base.Base Base +} + +struct ListToolCommitResponse { + 1: optional list tool_commit_infos + 2: optional map tool_commit_detail_mapping + + 11: optional list users + + 127: optional bool has_more + 128: optional string next_page_token + + 255: optional base.BaseResp BaseResp +} diff --git a/idl/thrift/coze/loop/prompt/domain/tool.thrift b/idl/thrift/coze/loop/prompt/domain/tool.thrift new file mode 100644 index 000000000..283f50ff6 --- /dev/null +++ b/idl/thrift/coze/loop/prompt/domain/tool.thrift @@ -0,0 +1,41 @@ +namespace go coze.loop.prompt.domain.tool + +const string PublicDraftVersion = "$PublicDraft" + +struct Tool { + 1: optional i64 id (api.js_conv="true", go.tag='json:"id"') + 2: optional i64 workspace_id (api.js_conv="true", go.tag='json:"workspace_id"') + 3: optional ToolBasic tool_basic + 4: optional ToolCommit tool_commit + + 255: optional map ext_infos +} + +struct ToolBasic { + 1: optional string name + 2: optional string description + 3: optional string latest_committed_version + 4: optional string created_by + 5: optional string updated_by + 6: optional i64 created_at (api.js_conv="true", go.tag='json:"created_at"') + 7: optional i64 updated_at (api.js_conv="true", go.tag='json:"updated_at"') +} + +struct ToolCommit { + 1: optional ToolDetail detail + 2: optional CommitInfo commit_info +} + +struct CommitInfo { + 1: optional string version + 2: optional string base_version + 3: optional string description + 4: optional string committed_by + 5: optional i64 committed_at (api.js_conv="true", go.tag='json:"committed_at"') +} + +struct ToolDetail { + 1: optional string content + + 255: optional map ext_infos +} diff --git a/release/deployment/docker-compose/bootstrap/mysql-init/init-sql/tool_basic.sql b/release/deployment/docker-compose/bootstrap/mysql-init/init-sql/tool_basic.sql new file mode 100644 index 000000000..9b54fb0a7 --- /dev/null +++ b/release/deployment/docker-compose/bootstrap/mysql-init/init-sql/tool_basic.sql @@ -0,0 +1,18 @@ +CREATE TABLE IF NOT EXISTS `tool_basic` +( + `id` bigint unsigned NOT NULL AUTO_INCREMENT COMMENT '主键ID', + `space_id` bigint unsigned NOT NULL COMMENT '空间ID', + `name` varchar(128) COLLATE utf8mb4_bin NOT NULL DEFAULT '' COMMENT '名称', + `description` varchar(1024) COLLATE utf8mb4_bin NOT NULL DEFAULT '' COMMENT '描述', + `latest_committed_version` varchar(128) COLLATE utf8mb4_bin NOT NULL DEFAULT '' COMMENT '最新版本', + `latest_committed_at` datetime NULL DEFAULT NULL COMMENT '最新提交时间', + `created_by` varchar(128) COLLATE utf8mb4_bin NOT NULL DEFAULT '' COMMENT '创建人', + `updated_by` varchar(128) COLLATE utf8mb4_bin NOT NULL DEFAULT '' COMMENT '更新人', + `created_at` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', + `updated_at` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间', + `deleted_at` bigint NOT NULL DEFAULT '0' COMMENT '删除时间', + PRIMARY KEY (`id`), + KEY `idx_spaceid_name_delat` (`space_id`, `name`, `deleted_at`) USING BTREE +) ENGINE = InnoDB + DEFAULT CHARSET = utf8mb4 + COLLATE = utf8mb4_general_ci COMMENT ='工具主体'; diff --git a/release/deployment/docker-compose/bootstrap/mysql-init/init-sql/tool_commit.sql b/release/deployment/docker-compose/bootstrap/mysql-init/init-sql/tool_commit.sql new file mode 100644 index 000000000..5a1ffd9ff --- /dev/null +++ b/release/deployment/docker-compose/bootstrap/mysql-init/init-sql/tool_commit.sql @@ -0,0 +1,17 @@ +CREATE TABLE IF NOT EXISTS `tool_commit` +( + `id` bigint unsigned NOT NULL AUTO_INCREMENT COMMENT '主键ID', + `space_id` bigint unsigned NOT NULL COMMENT '空间ID', + `tool_id` bigint unsigned NOT NULL COMMENT 'Tool ID', + `content` longtext COLLATE utf8mb4_general_ci COMMENT '工具内容', + `version` varchar(128) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '版本', + `base_version` varchar(128) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '来源版本', + `committed_by` varchar(128) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '提交人', + `description` text COLLATE utf8mb4_general_ci COMMENT '提交版本描述', + `created_at` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', + `updated_at` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间', + PRIMARY KEY (`id`), + UNIQUE KEY `uk_tool_version` (`tool_id`, `version`) +) ENGINE = InnoDB + DEFAULT CHARSET = utf8mb4 + COLLATE = utf8mb4_general_ci COMMENT ='工具版本'; From d867bc6c8ef455d9a789d7e65970c0f09b3303ca Mon Sep 17 00:00:00 2001 From: "wangluming.wlm" Date: Tue, 24 Mar 2026 17:23:37 +0800 Subject: [PATCH 2/8] feat:tool --- .../loop/apis/toolmanageservice/client.go | 6 + .../toolmanageservice/toolmanageservice.go | 36 + .../loop/observability/ingestion/ingestion.go | 3 - .../manage/coze.loop.prompt.tool.manage.go | 1337 +++++++++++++++++ .../coze.loop.prompt.tool.manage_validator.go | 41 + .../manage/k-coze.loop.prompt.tool.manage.go | 1050 +++++++++++++ .../toolmanageservice/toolmanageservice.go | 36 + .../loop/prompt/toolmanageservice/client.go | 6 + .../toolmanageservice/toolmanageservice.go | 36 + .../tool/lomanage/local_toolmanageservice.go | 21 + .../modules/prompt/application/tool_manage.go | 56 + backend/modules/prompt/domain/repo/tool.go | 16 + .../prompt/infra/repo/mysql/tool_basic.go | 14 + .../prompt/infra/repo/mysql/tool_commit.go | 26 + backend/modules/prompt/infra/repo/tool.go | 71 + .../coze.loop.prompt.tool.manage.thrift | 24 + 16 files changed, 2776 insertions(+), 3 deletions(-) delete mode 100644 backend/kitex_gen/coze/loop/observability/ingestion/ingestion.go diff --git a/backend/kitex_gen/coze/loop/apis/toolmanageservice/client.go b/backend/kitex_gen/coze/loop/apis/toolmanageservice/client.go index 27f94eaad..19916ba88 100644 --- a/backend/kitex_gen/coze/loop/apis/toolmanageservice/client.go +++ b/backend/kitex_gen/coze/loop/apis/toolmanageservice/client.go @@ -17,6 +17,7 @@ type Client interface { SaveToolDetail(ctx context.Context, request *manage.SaveToolDetailRequest, callOptions ...callopt.Option) (r *manage.SaveToolDetailResponse, err error) CommitToolDraft(ctx context.Context, request *manage.CommitToolDraftRequest, callOptions ...callopt.Option) (r *manage.CommitToolDraftResponse, err error) ListToolCommit(ctx context.Context, request *manage.ListToolCommitRequest, callOptions ...callopt.Option) (r *manage.ListToolCommitResponse, err error) + BatchGetTools(ctx context.Context, request *manage.BatchGetToolsRequest, callOptions ...callopt.Option) (r *manage.BatchGetToolsResponse, err error) } // NewClient creates a client for the service defined in IDL. @@ -77,3 +78,8 @@ func (p *kToolManageServiceClient) ListToolCommit(ctx context.Context, request * ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.ListToolCommit(ctx, request) } + +func (p *kToolManageServiceClient) BatchGetTools(ctx context.Context, request *manage.BatchGetToolsRequest, callOptions ...callopt.Option) (r *manage.BatchGetToolsResponse, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.BatchGetTools(ctx, request) +} diff --git a/backend/kitex_gen/coze/loop/apis/toolmanageservice/toolmanageservice.go b/backend/kitex_gen/coze/loop/apis/toolmanageservice/toolmanageservice.go index af3eed184..26e2f3bff 100644 --- a/backend/kitex_gen/coze/loop/apis/toolmanageservice/toolmanageservice.go +++ b/backend/kitex_gen/coze/loop/apis/toolmanageservice/toolmanageservice.go @@ -56,6 +56,13 @@ var serviceMethods = map[string]kitex.MethodInfo{ false, kitex.WithStreamingMode(kitex.StreamingNone), ), + "BatchGetTools": kitex.NewMethodInfo( + batchGetToolsHandler, + newToolManageServiceBatchGetToolsArgs, + newToolManageServiceBatchGetToolsResult, + false, + kitex.WithStreamingMode(kitex.StreamingNone), + ), } var ( @@ -203,6 +210,25 @@ func newToolManageServiceListToolCommitResult() interface{} { return manage.NewToolManageServiceListToolCommitResult() } +func batchGetToolsHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*manage.ToolManageServiceBatchGetToolsArgs) + realResult := result.(*manage.ToolManageServiceBatchGetToolsResult) + success, err := handler.(manage.ToolManageService).BatchGetTools(ctx, realArg.Request) + if err != nil { + return err + } + realResult.Success = success + return nil +} + +func newToolManageServiceBatchGetToolsArgs() interface{} { + return manage.NewToolManageServiceBatchGetToolsArgs() +} + +func newToolManageServiceBatchGetToolsResult() interface{} { + return manage.NewToolManageServiceBatchGetToolsResult() +} + type kClient struct { c client.Client sc client.Streaming @@ -274,3 +300,13 @@ func (p *kClient) ListToolCommit(ctx context.Context, request *manage.ListToolCo } return _result.GetSuccess(), nil } + +func (p *kClient) BatchGetTools(ctx context.Context, request *manage.BatchGetToolsRequest) (r *manage.BatchGetToolsResponse, err error) { + var _args manage.ToolManageServiceBatchGetToolsArgs + _args.Request = request + var _result manage.ToolManageServiceBatchGetToolsResult + if err = p.c.Call(ctx, "BatchGetTools", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} diff --git a/backend/kitex_gen/coze/loop/observability/ingestion/ingestion.go b/backend/kitex_gen/coze/loop/observability/ingestion/ingestion.go deleted file mode 100644 index 8e5ddcf35..000000000 --- a/backend/kitex_gen/coze/loop/observability/ingestion/ingestion.go +++ /dev/null @@ -1,3 +0,0 @@ -package ingestion - -type IngestionService interface{} diff --git a/backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool.manage.go b/backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool.manage.go index 89cd7ff38..d1c218468 100644 --- a/backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool.manage.go +++ b/backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool.manage.go @@ -5441,6 +5441,1279 @@ func (p *ListToolCommitResponse) Field255DeepEqual(src *base.BaseResp) bool { return true } +type ToolQuery struct { + ToolID *int64 `thrift:"tool_id,1,optional" frugal:"1,optional,i64" json:"tool_id" form:"tool_id" query:"tool_id"` + Version *string `thrift:"version,2,optional" frugal:"2,optional,string" form:"version" json:"version,omitempty" query:"version"` +} + +func NewToolQuery() *ToolQuery { + return &ToolQuery{} +} + +func (p *ToolQuery) InitDefault() { +} + +var ToolQuery_ToolID_DEFAULT int64 + +func (p *ToolQuery) GetToolID() (v int64) { + if p == nil { + return + } + if !p.IsSetToolID() { + return ToolQuery_ToolID_DEFAULT + } + return *p.ToolID +} + +var ToolQuery_Version_DEFAULT string + +func (p *ToolQuery) GetVersion() (v string) { + if p == nil { + return + } + if !p.IsSetVersion() { + return ToolQuery_Version_DEFAULT + } + return *p.Version +} +func (p *ToolQuery) SetToolID(val *int64) { + p.ToolID = val +} +func (p *ToolQuery) SetVersion(val *string) { + p.Version = val +} + +var fieldIDToName_ToolQuery = map[int16]string{ + 1: "tool_id", + 2: "version", +} + +func (p *ToolQuery) IsSetToolID() bool { + return p.ToolID != nil +} + +func (p *ToolQuery) IsSetVersion() bool { + return p.Version != nil +} + +func (p *ToolQuery) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.I64 { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 2: + if fieldTypeId == thrift.STRING { + if err = p.ReadField2(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolQuery[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *ToolQuery) ReadField1(iprot thrift.TProtocol) error { + + var _field *int64 + if v, err := iprot.ReadI64(); err != nil { + return err + } else { + _field = &v + } + p.ToolID = _field + return nil +} +func (p *ToolQuery) ReadField2(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.Version = _field + return nil +} + +func (p *ToolQuery) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("ToolQuery"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + if err = p.writeField2(oprot); err != nil { + fieldId = 2 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *ToolQuery) writeField1(oprot thrift.TProtocol) (err error) { + if p.IsSetToolID() { + if err = oprot.WriteFieldBegin("tool_id", thrift.I64, 1); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI64(*p.ToolID); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} +func (p *ToolQuery) writeField2(oprot thrift.TProtocol) (err error) { + if p.IsSetVersion() { + if err = oprot.WriteFieldBegin("version", thrift.STRING, 2); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.Version); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err) +} + +func (p *ToolQuery) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("ToolQuery(%+v)", *p) + +} + +func (p *ToolQuery) DeepEqual(ano *ToolQuery) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.ToolID) { + return false + } + if !p.Field2DeepEqual(ano.Version) { + return false + } + return true +} + +func (p *ToolQuery) Field1DeepEqual(src *int64) bool { + + if p.ToolID == src { + return true + } else if p.ToolID == nil || src == nil { + return false + } + if *p.ToolID != *src { + return false + } + return true +} +func (p *ToolQuery) Field2DeepEqual(src *string) bool { + + if p.Version == src { + return true + } else if p.Version == nil || src == nil { + return false + } + if strings.Compare(*p.Version, *src) != 0 { + return false + } + return true +} + +type ToolResult_ struct { + Query *ToolQuery `thrift:"query,1,optional" frugal:"1,optional,ToolQuery" form:"query" json:"query,omitempty" query:"query"` + Tool *tool.Tool `thrift:"tool,2,optional" frugal:"2,optional,tool.Tool" form:"tool" json:"tool,omitempty" query:"tool"` +} + +func NewToolResult_() *ToolResult_ { + return &ToolResult_{} +} + +func (p *ToolResult_) InitDefault() { +} + +var ToolResult__Query_DEFAULT *ToolQuery + +func (p *ToolResult_) GetQuery() (v *ToolQuery) { + if p == nil { + return + } + if !p.IsSetQuery() { + return ToolResult__Query_DEFAULT + } + return p.Query +} + +var ToolResult__Tool_DEFAULT *tool.Tool + +func (p *ToolResult_) GetTool() (v *tool.Tool) { + if p == nil { + return + } + if !p.IsSetTool() { + return ToolResult__Tool_DEFAULT + } + return p.Tool +} +func (p *ToolResult_) SetQuery(val *ToolQuery) { + p.Query = val +} +func (p *ToolResult_) SetTool(val *tool.Tool) { + p.Tool = val +} + +var fieldIDToName_ToolResult_ = map[int16]string{ + 1: "query", + 2: "tool", +} + +func (p *ToolResult_) IsSetQuery() bool { + return p.Query != nil +} + +func (p *ToolResult_) IsSetTool() bool { + return p.Tool != nil +} + +func (p *ToolResult_) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 2: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField2(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolResult_[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *ToolResult_) ReadField1(iprot thrift.TProtocol) error { + _field := NewToolQuery() + if err := _field.Read(iprot); err != nil { + return err + } + p.Query = _field + return nil +} +func (p *ToolResult_) ReadField2(iprot thrift.TProtocol) error { + _field := tool.NewTool() + if err := _field.Read(iprot); err != nil { + return err + } + p.Tool = _field + return nil +} + +func (p *ToolResult_) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("ToolResult"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + if err = p.writeField2(oprot); err != nil { + fieldId = 2 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *ToolResult_) writeField1(oprot thrift.TProtocol) (err error) { + if p.IsSetQuery() { + if err = oprot.WriteFieldBegin("query", thrift.STRUCT, 1); err != nil { + goto WriteFieldBeginError + } + if err := p.Query.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} +func (p *ToolResult_) writeField2(oprot thrift.TProtocol) (err error) { + if p.IsSetTool() { + if err = oprot.WriteFieldBegin("tool", thrift.STRUCT, 2); err != nil { + goto WriteFieldBeginError + } + if err := p.Tool.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err) +} + +func (p *ToolResult_) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("ToolResult_(%+v)", *p) + +} + +func (p *ToolResult_) DeepEqual(ano *ToolResult_) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.Query) { + return false + } + if !p.Field2DeepEqual(ano.Tool) { + return false + } + return true +} + +func (p *ToolResult_) Field1DeepEqual(src *ToolQuery) bool { + + if !p.Query.DeepEqual(src) { + return false + } + return true +} +func (p *ToolResult_) Field2DeepEqual(src *tool.Tool) bool { + + if !p.Tool.DeepEqual(src) { + return false + } + return true +} + +type BatchGetToolsRequest struct { + WorkspaceID *int64 `thrift:"workspace_id,1,optional" frugal:"1,optional,i64" json:"workspace_id" form:"workspace_id" query:"workspace_id"` + Queries []*ToolQuery `thrift:"queries,2,optional" frugal:"2,optional,list" form:"queries" json:"queries,omitempty" query:"queries"` + Base *base.Base `thrift:"Base,255,optional" frugal:"255,optional,base.Base" form:"Base" json:"Base,omitempty" query:"Base"` +} + +func NewBatchGetToolsRequest() *BatchGetToolsRequest { + return &BatchGetToolsRequest{} +} + +func (p *BatchGetToolsRequest) InitDefault() { +} + +var BatchGetToolsRequest_WorkspaceID_DEFAULT int64 + +func (p *BatchGetToolsRequest) GetWorkspaceID() (v int64) { + if p == nil { + return + } + if !p.IsSetWorkspaceID() { + return BatchGetToolsRequest_WorkspaceID_DEFAULT + } + return *p.WorkspaceID +} + +var BatchGetToolsRequest_Queries_DEFAULT []*ToolQuery + +func (p *BatchGetToolsRequest) GetQueries() (v []*ToolQuery) { + if p == nil { + return + } + if !p.IsSetQueries() { + return BatchGetToolsRequest_Queries_DEFAULT + } + return p.Queries +} + +var BatchGetToolsRequest_Base_DEFAULT *base.Base + +func (p *BatchGetToolsRequest) GetBase() (v *base.Base) { + if p == nil { + return + } + if !p.IsSetBase() { + return BatchGetToolsRequest_Base_DEFAULT + } + return p.Base +} +func (p *BatchGetToolsRequest) SetWorkspaceID(val *int64) { + p.WorkspaceID = val +} +func (p *BatchGetToolsRequest) SetQueries(val []*ToolQuery) { + p.Queries = val +} +func (p *BatchGetToolsRequest) SetBase(val *base.Base) { + p.Base = val +} + +var fieldIDToName_BatchGetToolsRequest = map[int16]string{ + 1: "workspace_id", + 2: "queries", + 255: "Base", +} + +func (p *BatchGetToolsRequest) IsSetWorkspaceID() bool { + return p.WorkspaceID != nil +} + +func (p *BatchGetToolsRequest) IsSetQueries() bool { + return p.Queries != nil +} + +func (p *BatchGetToolsRequest) IsSetBase() bool { + return p.Base != nil +} + +func (p *BatchGetToolsRequest) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.I64 { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 2: + if fieldTypeId == thrift.LIST { + if err = p.ReadField2(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 255: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField255(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_BatchGetToolsRequest[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *BatchGetToolsRequest) ReadField1(iprot thrift.TProtocol) error { + + var _field *int64 + if v, err := iprot.ReadI64(); err != nil { + return err + } else { + _field = &v + } + p.WorkspaceID = _field + return nil +} +func (p *BatchGetToolsRequest) ReadField2(iprot thrift.TProtocol) error { + _, size, err := iprot.ReadListBegin() + if err != nil { + return err + } + _field := make([]*ToolQuery, 0, size) + values := make([]ToolQuery, size) + for i := 0; i < size; i++ { + _elem := &values[i] + _elem.InitDefault() + + if err := _elem.Read(iprot); err != nil { + return err + } + + _field = append(_field, _elem) + } + if err := iprot.ReadListEnd(); err != nil { + return err + } + p.Queries = _field + return nil +} +func (p *BatchGetToolsRequest) ReadField255(iprot thrift.TProtocol) error { + _field := base.NewBase() + if err := _field.Read(iprot); err != nil { + return err + } + p.Base = _field + return nil +} + +func (p *BatchGetToolsRequest) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("BatchGetToolsRequest"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + if err = p.writeField2(oprot); err != nil { + fieldId = 2 + goto WriteFieldError + } + if err = p.writeField255(oprot); err != nil { + fieldId = 255 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *BatchGetToolsRequest) writeField1(oprot thrift.TProtocol) (err error) { + if p.IsSetWorkspaceID() { + if err = oprot.WriteFieldBegin("workspace_id", thrift.I64, 1); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI64(*p.WorkspaceID); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} +func (p *BatchGetToolsRequest) writeField2(oprot thrift.TProtocol) (err error) { + if p.IsSetQueries() { + if err = oprot.WriteFieldBegin("queries", thrift.LIST, 2); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteListBegin(thrift.STRUCT, len(p.Queries)); err != nil { + return err + } + for _, v := range p.Queries { + if err := v.Write(oprot); err != nil { + return err + } + } + if err := oprot.WriteListEnd(); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err) +} +func (p *BatchGetToolsRequest) writeField255(oprot thrift.TProtocol) (err error) { + if p.IsSetBase() { + if err = oprot.WriteFieldBegin("Base", thrift.STRUCT, 255); err != nil { + goto WriteFieldBeginError + } + if err := p.Base.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 end error: ", p), err) +} + +func (p *BatchGetToolsRequest) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("BatchGetToolsRequest(%+v)", *p) + +} + +func (p *BatchGetToolsRequest) DeepEqual(ano *BatchGetToolsRequest) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.WorkspaceID) { + return false + } + if !p.Field2DeepEqual(ano.Queries) { + return false + } + if !p.Field255DeepEqual(ano.Base) { + return false + } + return true +} + +func (p *BatchGetToolsRequest) Field1DeepEqual(src *int64) bool { + + if p.WorkspaceID == src { + return true + } else if p.WorkspaceID == nil || src == nil { + return false + } + if *p.WorkspaceID != *src { + return false + } + return true +} +func (p *BatchGetToolsRequest) Field2DeepEqual(src []*ToolQuery) bool { + + if len(p.Queries) != len(src) { + return false + } + for i, v := range p.Queries { + _src := src[i] + if !v.DeepEqual(_src) { + return false + } + } + return true +} +func (p *BatchGetToolsRequest) Field255DeepEqual(src *base.Base) bool { + + if !p.Base.DeepEqual(src) { + return false + } + return true +} + +type BatchGetToolsResponse struct { + Items []*ToolResult_ `thrift:"items,1,optional" frugal:"1,optional,list" form:"items" json:"items,omitempty" query:"items"` + BaseResp *base.BaseResp `thrift:"BaseResp,255,optional" frugal:"255,optional,base.BaseResp" form:"BaseResp" json:"BaseResp,omitempty" query:"BaseResp"` +} + +func NewBatchGetToolsResponse() *BatchGetToolsResponse { + return &BatchGetToolsResponse{} +} + +func (p *BatchGetToolsResponse) InitDefault() { +} + +var BatchGetToolsResponse_Items_DEFAULT []*ToolResult_ + +func (p *BatchGetToolsResponse) GetItems() (v []*ToolResult_) { + if p == nil { + return + } + if !p.IsSetItems() { + return BatchGetToolsResponse_Items_DEFAULT + } + return p.Items +} + +var BatchGetToolsResponse_BaseResp_DEFAULT *base.BaseResp + +func (p *BatchGetToolsResponse) GetBaseResp() (v *base.BaseResp) { + if p == nil { + return + } + if !p.IsSetBaseResp() { + return BatchGetToolsResponse_BaseResp_DEFAULT + } + return p.BaseResp +} +func (p *BatchGetToolsResponse) SetItems(val []*ToolResult_) { + p.Items = val +} +func (p *BatchGetToolsResponse) SetBaseResp(val *base.BaseResp) { + p.BaseResp = val +} + +var fieldIDToName_BatchGetToolsResponse = map[int16]string{ + 1: "items", + 255: "BaseResp", +} + +func (p *BatchGetToolsResponse) IsSetItems() bool { + return p.Items != nil +} + +func (p *BatchGetToolsResponse) IsSetBaseResp() bool { + return p.BaseResp != nil +} + +func (p *BatchGetToolsResponse) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.LIST { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 255: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField255(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_BatchGetToolsResponse[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *BatchGetToolsResponse) ReadField1(iprot thrift.TProtocol) error { + _, size, err := iprot.ReadListBegin() + if err != nil { + return err + } + _field := make([]*ToolResult_, 0, size) + values := make([]ToolResult_, size) + for i := 0; i < size; i++ { + _elem := &values[i] + _elem.InitDefault() + + if err := _elem.Read(iprot); err != nil { + return err + } + + _field = append(_field, _elem) + } + if err := iprot.ReadListEnd(); err != nil { + return err + } + p.Items = _field + return nil +} +func (p *BatchGetToolsResponse) ReadField255(iprot thrift.TProtocol) error { + _field := base.NewBaseResp() + if err := _field.Read(iprot); err != nil { + return err + } + p.BaseResp = _field + return nil +} + +func (p *BatchGetToolsResponse) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("BatchGetToolsResponse"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + if err = p.writeField255(oprot); err != nil { + fieldId = 255 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *BatchGetToolsResponse) writeField1(oprot thrift.TProtocol) (err error) { + if p.IsSetItems() { + if err = oprot.WriteFieldBegin("items", thrift.LIST, 1); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteListBegin(thrift.STRUCT, len(p.Items)); err != nil { + return err + } + for _, v := range p.Items { + if err := v.Write(oprot); err != nil { + return err + } + } + if err := oprot.WriteListEnd(); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} +func (p *BatchGetToolsResponse) writeField255(oprot thrift.TProtocol) (err error) { + if p.IsSetBaseResp() { + if err = oprot.WriteFieldBegin("BaseResp", thrift.STRUCT, 255); err != nil { + goto WriteFieldBeginError + } + if err := p.BaseResp.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 255 end error: ", p), err) +} + +func (p *BatchGetToolsResponse) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("BatchGetToolsResponse(%+v)", *p) + +} + +func (p *BatchGetToolsResponse) DeepEqual(ano *BatchGetToolsResponse) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.Items) { + return false + } + if !p.Field255DeepEqual(ano.BaseResp) { + return false + } + return true +} + +func (p *BatchGetToolsResponse) Field1DeepEqual(src []*ToolResult_) bool { + + if len(p.Items) != len(src) { + return false + } + for i, v := range p.Items { + _src := src[i] + if !v.DeepEqual(_src) { + return false + } + } + return true +} +func (p *BatchGetToolsResponse) Field255DeepEqual(src *base.BaseResp) bool { + + if !p.BaseResp.DeepEqual(src) { + return false + } + return true +} + +type ToolManageService interface { + CreateTool(ctx context.Context, request *CreateToolRequest) (r *CreateToolResponse, err error) + + GetToolDetail(ctx context.Context, request *GetToolDetailRequest) (r *GetToolDetailResponse, err error) + + ListTool(ctx context.Context, request *ListToolRequest) (r *ListToolResponse, err error) + + SaveToolDetail(ctx context.Context, request *SaveToolDetailRequest) (r *SaveToolDetailResponse, err error) + + CommitToolDraft(ctx context.Context, request *CommitToolDraftRequest) (r *CommitToolDraftResponse, err error) + + ListToolCommit(ctx context.Context, request *ListToolCommitRequest) (r *ListToolCommitResponse, err error) + + BatchGetTools(ctx context.Context, request *BatchGetToolsRequest) (r *BatchGetToolsResponse, err error) + + BatchGetTools(ctx context.Context, request *BatchGetToolsRequest) (r *BatchGetToolsResponse, err error) +} + +type ToolManageServiceClient struct { + c thrift.TClient +} + +func NewToolManageServiceClientFactory(t thrift.TTransport, f thrift.TProtocolFactory) *ToolManageServiceClient { + return &ToolManageServiceClient{ + c: thrift.NewTStandardClient(f.GetProtocol(t), f.GetProtocol(t)), + } +} + +func NewToolManageServiceClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *ToolManageServiceClient { + return &ToolManageServiceClient{ + c: thrift.NewTStandardClient(iprot, oprot), + } +} + +func NewToolManageServiceClient(c thrift.TClient) *ToolManageServiceClient { + return &ToolManageServiceClient{ + c: c, + } +} + +func (p *ToolManageServiceClient) Client_() thrift.TClient { + return p.c +} + +func (p *ToolManageServiceClient) CreateTool(ctx context.Context, request *CreateToolRequest) (r *CreateToolResponse, err error) { + var _args ToolManageServiceCreateToolArgs + _args.Request = request + var _result ToolManageServiceCreateToolResult + if err = p.Client_().Call(ctx, "CreateTool", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} +func (p *ToolManageServiceClient) GetToolDetail(ctx context.Context, request *GetToolDetailRequest) (r *GetToolDetailResponse, err error) { + var _args ToolManageServiceGetToolDetailArgs + _args.Request = request + var _result ToolManageServiceGetToolDetailResult + if err = p.Client_().Call(ctx, "GetToolDetail", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} +func (p *ToolManageServiceClient) ListTool(ctx context.Context, request *ListToolRequest) (r *ListToolResponse, err error) { + var _args ToolManageServiceListToolArgs + _args.Request = request + var _result ToolManageServiceListToolResult + if err = p.Client_().Call(ctx, "ListTool", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} +func (p *ToolManageServiceClient) SaveToolDetail(ctx context.Context, request *SaveToolDetailRequest) (r *SaveToolDetailResponse, err error) { + var _args ToolManageServiceSaveToolDetailArgs + _args.Request = request + var _result ToolManageServiceSaveToolDetailResult + if err = p.Client_().Call(ctx, "SaveToolDetail", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} +func (p *ToolManageServiceClient) CommitToolDraft(ctx context.Context, request *CommitToolDraftRequest) (r *CommitToolDraftResponse, err error) { + var _args ToolManageServiceCommitToolDraftArgs + _args.Request = request + var _result ToolManageServiceCommitToolDraftResult + if err = p.Client_().Call(ctx, "CommitToolDraft", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} +func (p *ToolManageServiceClient) ListToolCommit(ctx context.Context, request *ListToolCommitRequest) (r *ListToolCommitResponse, err error) { + var _args ToolManageServiceListToolCommitArgs + _args.Request = request + var _result ToolManageServiceListToolCommitResult + if err = p.Client_().Call(ctx, "ListToolCommit", &_args, &_result); err != nil { + return + } +equest *BatchGetToolsRequest) (r *BatchGetToolsResponse, err error) { + var _args ToolManageServiceBatchGetToolsArgs + _args.Request = request + var _result ToolManageServiceBatchGetToolsResult + if err = p.Client_().Call(ctx, "BatchGetTools", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} + +type ToolManageServiceProcessor struct { + processorMap map[string]th + return _result.GetSuccess(), nil +} +func (p *ToolManageServiceClient) BatchGetTools(ctx context.Context, request *BatchGetToolsRequest) (r *BatchGetToolsResponse, err error) { + var _args ToolManageServiceBatchGetToolsArgs + _args.Request = request + var _result ToolManageServiceBatchGetToolsResult + if err = p.Client_().Call(ctx, "BatchGetTools", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} + +type ToolManageServiceProcessor struct { + processorMap map[string]thrift.TProcessorFunction + handler ToolManageService +} + +func (p *ToolManageServiceProcessor) AddToProcessorMap(key string, processor thrift.TProcessorFunction) { + p.processorMap[key] = processor +} + +func (p *ToolManageServiceProcessor) GetProcessorFunction(key string) (processor thrift.TProcessorFunction, ok bool) { + processor, ok = p.processorMap[key] + return processor, ok +e +} + +func (p *ToolManageServiceProcessor) ProcessorMap() map[string]thrift.TProcessorFunction { + return p.processorMap +} + +func NewToolManageServiceProcessor(handler ToolManageService) *ToolManageServiceProcessor { + self := &ToolManageServiceProcessor{handler: handler, processorMap: make(map[string]thrift.TProcessorFunction)} + self.AddToProcessorMap("CreateTool", &toolManageServiceProcessorCreateTool{handler: handler}) + self.AddToProcessorMap("GetToolDetail", &toolManageServiceProcessorGetToolDetail{handler: handler}) + self.AddToProcessorMap("ListTool", &toolManageServiceProcessorListTool{handler: handler}) + self.AddToProcessorMap("SaveToolDetail", &toolManageServiceProcessorSaveToolDetail{handler: handler}) + self.AddToProcessorMap("CommitToolDraft", &toolManageServiceProcessorCommitToolDraft{handler: handler}) + self.AddToProcessorMap("ListToolCommit", &toolManageServiceProcessorListToolCommit{handler: handler}) + self.AddToProcessorMap("BatchGetTools", &toolManageServiceProcessorBatchGetTools{handler: handler}) + retu + return false + } + return true +} + type ToolManageService interface { CreateTool(ctx context.Context, request *CreateToolRequest) (r *CreateToolResponse, err error) @@ -5728,6 +7001,70 @@ func (p *toolManageServiceProcessorListTool) Process(ctx context.Context, seqId type toolManageServiceProcessorSaveToolDetail struct { handler ToolManageService + + err = err2 + } + if err2 = result.Write(oprot); err == nil && err2 != nil { + err = err2 + } + if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil { + err = err2 + } + if err2 = oprot.Flush(ctx); err == nil && err2 != nil { + err = err2 + } + if err != nil { + return + } + return true, err +} + +type ToolManageServiceCreateToolArgs struct { + Request *CreateToolRequest `thrift:"request,1" frugal:"1,default,CreateToolRequest"` +} + +func NewToolManageServiceCreateToolArgs() *ToolManageServiceCreateToolArgs { + return &ToolManageServiceCreateToolArgs{} +} + +func (p *ToolManageServiceCreateToolArgs) InitDefault() { +} + +var ToolManageServiceCreateToolArgs_Request_DEFAULT *CreateToolRequest + +func (p *ToolManageServiceCreateToolArgs) GetRequest() (v *CreateToolRequest) { + if p == nil { + return + } + if !p.IsSetRequest() { + return ToolManageServiceCreateToolArgs_Request_DEFAULT + } + return p.Request +} +func (p *ToolManageServiceCreateToolArgs) SetRequest(val *CreateToolRequest) { + p.Request = val +} + +var fieldIDToName_ToolManageServiceCreateToolArgs = map[int16]string{ + 1: "request", +} + +func (p *ToolManageServiceCreateToolArgs) IsSetRequest() bool { + return p.Request != nil +} + +func (p *ToolManageServiceCreateToolArgs) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFiel } func (p *toolManageServiceProcessorSaveToolDetail) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { diff --git a/backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool.manage_validator.go b/backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool.manage_validator.go index ea8ba12cb..8fd97515b 100644 --- a/backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool.manage_validator.go +++ b/backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool.manage_validator.go @@ -220,3 +220,44 @@ func (p *ListToolCommitResponse) IsValid() error { } return nil } +func (p *ToolQuery) IsValid() error { + return nil +} +func (p *ToolResult_) IsValid() error { + if p.Query != nil { + if err := p.Query.IsValid(); err != nil { + return fmt.Errorf("field Query not valid, %w", err) + } + } + if p.Tool != nil { + if err := p.Tool.IsValid(); err != nil { + return fmt.Errorf("field Tool not valid, %w", err) + } + } + return nil +} +func (p *BatchGetToolsRequest) IsValid() error { + if p.WorkspaceID == nil { + return fmt.Errorf("field WorkspaceID not_nil rule failed") + } + if *p.WorkspaceID <= int64(0) { + return fmt.Errorf("field WorkspaceID gt rule failed, current value: %v", *p.WorkspaceID) + } + if len(p.Queries) < int(1) { + return fmt.Errorf("field Queries MinLen rule failed, current value: %v", p.Queries) + } + if p.Base != nil { + if err := p.Base.IsValid(); err != nil { + return fmt.Errorf("field Base not valid, %w", err) + } + } + return nil +} +func (p *BatchGetToolsResponse) IsValid() error { + if p.BaseResp != nil { + if err := p.BaseResp.IsValid(); err != nil { + return fmt.Errorf("field BaseResp not valid, %w", err) + } + } + return nil +} diff --git a/backend/kitex_gen/coze/loop/prompt/tool/manage/k-coze.loop.prompt.tool.manage.go b/backend/kitex_gen/coze/loop/prompt/tool/manage/k-coze.loop.prompt.tool.manage.go index 8808de655..4123658a2 100644 --- a/backend/kitex_gen/coze/loop/prompt/tool/manage/k-coze.loop.prompt.tool.manage.go +++ b/backend/kitex_gen/coze/loop/prompt/tool/manage/k-coze.loop.prompt.tool.manage.go @@ -3924,6 +3924,814 @@ func (p *ListToolCommitResponse) DeepCopy(s interface{}) error { return nil } +func (p *ToolQuery) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.I64 { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 2: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField2(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolQuery[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *ToolQuery) FastReadField1(buf []byte) (int, error) { + offset := 0 + + var _field *int64 + if v, l, err := thrift.Binary.ReadI64(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.ToolID = _field + return offset, nil +} + +func (p *ToolQuery) FastReadField2(buf []byte) (int, error) { + offset := 0 + + var _field *string + if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.Version = _field + return offset, nil +} + +func (p *ToolQuery) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *ToolQuery) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField1(buf[offset:], w) + offset += p.fastWriteField2(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *ToolQuery) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + l += p.field2Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *ToolQuery) fastWriteField1(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetToolID() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.I64, 1) + offset += thrift.Binary.WriteI64(buf[offset:], *p.ToolID) + } + return offset +} + +func (p *ToolQuery) fastWriteField2(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetVersion() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRING, 2) + offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, *p.Version) + } + return offset +} + +func (p *ToolQuery) field1Length() int { + l := 0 + if p.IsSetToolID() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.I64Length() + } + return l +} + +func (p *ToolQuery) field2Length() int { + l := 0 + if p.IsSetVersion() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.StringLengthNocopy(*p.Version) + } + return l +} + +func (p *ToolQuery) DeepCopy(s interface{}) error { + src, ok := s.(*ToolQuery) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + if src.ToolID != nil { + tmp := *src.ToolID + p.ToolID = &tmp + } + + if src.Version != nil { + var tmp string + if *src.Version != "" { + tmp = kutils.StringDeepCopy(*src.Version) + } + p.Version = &tmp + } + + return nil +} + +func (p *ToolResult_) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 2: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField2(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolResult_[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *ToolResult_) FastReadField1(buf []byte) (int, error) { + offset := 0 + _field := NewToolQuery() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Query = _field + return offset, nil +} + +func (p *ToolResult_) FastReadField2(buf []byte) (int, error) { + offset := 0 + _field := tool.NewTool() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Tool = _field + return offset, nil +} + +func (p *ToolResult_) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *ToolResult_) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField1(buf[offset:], w) + offset += p.fastWriteField2(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *ToolResult_) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + l += p.field2Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *ToolResult_) fastWriteField1(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetQuery() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 1) + offset += p.Query.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *ToolResult_) fastWriteField2(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetTool() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 2) + offset += p.Tool.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *ToolResult_) field1Length() int { + l := 0 + if p.IsSetQuery() { + l += thrift.Binary.FieldBeginLength() + l += p.Query.BLength() + } + return l +} + +func (p *ToolResult_) field2Length() int { + l := 0 + if p.IsSetTool() { + l += thrift.Binary.FieldBeginLength() + l += p.Tool.BLength() + } + return l +} + +func (p *ToolResult_) DeepCopy(s interface{}) error { + src, ok := s.(*ToolResult_) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + var _query *ToolQuery + if src.Query != nil { + _query = &ToolQuery{} + if err := _query.DeepCopy(src.Query); err != nil { + return err + } + } + p.Query = _query + + var _tool *tool.Tool + if src.Tool != nil { + _tool = &tool.Tool{} + if err := _tool.DeepCopy(src.Tool); err != nil { + return err + } + } + p.Tool = _tool + + return nil +} + +func (p *BatchGetToolsRequest) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.I64 { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 2: + if fieldTypeId == thrift.LIST { + l, err = p.FastReadField2(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 255: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField255(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_BatchGetToolsRequest[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *BatchGetToolsRequest) FastReadField1(buf []byte) (int, error) { + offset := 0 + + var _field *int64 + if v, l, err := thrift.Binary.ReadI64(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _field = &v + } + p.WorkspaceID = _field + return offset, nil +} + +func (p *BatchGetToolsRequest) FastReadField2(buf []byte) (int, error) { + offset := 0 + + _, size, l, err := thrift.Binary.ReadListBegin(buf[offset:]) + offset += l + if err != nil { + return offset, err + } + _field := make([]*ToolQuery, 0, size) + values := make([]ToolQuery, size) + for i := 0; i < size; i++ { + _elem := &values[i] + _elem.InitDefault() + if l, err := _elem.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + + _field = append(_field, _elem) + } + p.Queries = _field + return offset, nil +} + +func (p *BatchGetToolsRequest) FastReadField255(buf []byte) (int, error) { + offset := 0 + _field := base.NewBase() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Base = _field + return offset, nil +} + +func (p *BatchGetToolsRequest) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *BatchGetToolsRequest) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField1(buf[offset:], w) + offset += p.fastWriteField2(buf[offset:], w) + offset += p.fastWriteField255(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *BatchGetToolsRequest) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + l += p.field2Length() + l += p.field255Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *BatchGetToolsRequest) fastWriteField1(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetWorkspaceID() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.I64, 1) + offset += thrift.Binary.WriteI64(buf[offset:], *p.WorkspaceID) + } + return offset +} + +func (p *BatchGetToolsRequest) fastWriteField2(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetQueries() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.LIST, 2) + listBeginOffset := offset + offset += thrift.Binary.ListBeginLength() + var length int + for _, v := range p.Queries { + length++ + offset += v.FastWriteNocopy(buf[offset:], w) + } + thrift.Binary.WriteListBegin(buf[listBeginOffset:], thrift.STRUCT, length) + } + return offset +} + +func (p *BatchGetToolsRequest) fastWriteField255(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetBase() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 255) + offset += p.Base.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *BatchGetToolsRequest) field1Length() int { + l := 0 + if p.IsSetWorkspaceID() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.I64Length() + } + return l +} + +func (p *BatchGetToolsRequest) field2Length() int { + l := 0 + if p.IsSetQueries() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.ListBeginLength() + for _, v := range p.Queries { + _ = v + l += v.BLength() + } + } + return l +} + +func (p *BatchGetToolsRequest) field255Length() int { + l := 0 + if p.IsSetBase() { + l += thrift.Binary.FieldBeginLength() + l += p.Base.BLength() + } + return l +} + +func (p *BatchGetToolsRequest) DeepCopy(s interface{}) error { + src, ok := s.(*BatchGetToolsRequest) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + if src.WorkspaceID != nil { + tmp := *src.WorkspaceID + p.WorkspaceID = &tmp + } + + if src.Queries != nil { + p.Queries = make([]*ToolQuery, 0, len(src.Queries)) + for _, elem := range src.Queries { + var _elem *ToolQuery + if elem != nil { + _elem = &ToolQuery{} + if err := _elem.DeepCopy(elem); err != nil { + return err + } + } + + p.Queries = append(p.Queries, _elem) + } + } + + var _base *base.Base + if src.Base != nil { + _base = &base.Base{} + if err := _base.DeepCopy(src.Base); err != nil { + return err + } + } + p.Base = _base + + return nil +} + +func (p *BatchGetToolsResponse) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.LIST { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 255: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField255(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_BatchGetToolsResponse[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *BatchGetToolsResponse) FastReadField1(buf []byte) (int, error) { + offset := 0 + + _, size, l, err := thrift.Binary.ReadListBegin(buf[offset:]) + offset += l + if err != nil { + return offset, err + } + _field := make([]*ToolResult_, 0, size) + values := make([]ToolResult_, size) + for i := 0; i < size; i++ { + _elem := &values[i] + _elem.InitDefault() + if l, err := _elem.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + + _field = append(_field, _elem) + } + p.Items = _field + return offset, nil +} + +func (p *BatchGetToolsResponse) FastReadField255(buf []byte) (int, error) { + offset := 0 + _field := base.NewBaseResp() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.BaseResp = _field + return offset, nil +} + +func (p *BatchGetToolsResponse) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *BatchGetToolsResponse) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField1(buf[offset:], w) + offset += p.fastWriteField255(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *BatchGetToolsResponse) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + l += p.field255Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *BatchGetToolsResponse) fastWriteField1(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetItems() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.LIST, 1) + listBeginOffset := offset + offset += thrift.Binary.ListBeginLength() + var length int + for _, v := range p.Items { + length++ + offset += v.FastWriteNocopy(buf[offset:], w) + } + thrift.Binary.WriteListBegin(buf[listBeginOffset:], thrift.STRUCT, length) + } + return offset +} + +func (p *BatchGetToolsResponse) fastWriteField255(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetBaseResp() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 255) + offset += p.BaseResp.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *BatchGetToolsResponse) field1Length() int { + l := 0 + if p.IsSetItems() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.ListBeginLength() + for _, v := range p.Items { + _ = v + l += v.BLength() + } + } + return l +} + +func (p *BatchGetToolsResponse) field255Length() int { + l := 0 + if p.IsSetBaseResp() { + l += thrift.Binary.FieldBeginLength() + l += p.BaseResp.BLength() + } + return l +} + +func (p *BatchGetToolsResponse) DeepCopy(s interface{}) error { + src, ok := s.(*BatchGetToolsResponse) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + if src.Items != nil { + p.Items = make([]*ToolResult_, 0, len(src.Items)) + for _, elem := range src.Items { + var _elem *ToolResult_ + if elem != nil { + _elem = &ToolResult_{} + if err := _elem.DeepCopy(elem); err != nil { + return err + } + } + + p.Items = append(p.Items, _elem) + } + } + + var _baseResp *base.BaseResp + if src.BaseResp != nil { + _baseResp = &base.BaseResp{} + if err := _baseResp.DeepCopy(src.BaseResp); err != nil { + return err + } + } + p.BaseResp = _baseResp + + return nil +} + func (p *ToolManageServiceCreateToolArgs) FastRead(buf []byte) (int, error) { var err error @@ -5328,6 +6136,240 @@ func (p *ToolManageServiceListToolCommitResult) DeepCopy(s interface{}) error { return nil } +func (p *ToolManageServiceBatchGetToolsArgs) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceBatchGetToolsArgs[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *ToolManageServiceBatchGetToolsArgs) FastReadField1(buf []byte) (int, error) { + offset := 0 + _field := NewBatchGetToolsRequest() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Request = _field + return offset, nil +} + +func (p *ToolManageServiceBatchGetToolsArgs) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *ToolManageServiceBatchGetToolsArgs) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField1(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *ToolManageServiceBatchGetToolsArgs) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *ToolManageServiceBatchGetToolsArgs) fastWriteField1(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 1) + offset += p.Request.FastWriteNocopy(buf[offset:], w) + return offset +} + +func (p *ToolManageServiceBatchGetToolsArgs) field1Length() int { + l := 0 + l += thrift.Binary.FieldBeginLength() + l += p.Request.BLength() + return l +} + +func (p *ToolManageServiceBatchGetToolsArgs) DeepCopy(s interface{}) error { + src, ok := s.(*ToolManageServiceBatchGetToolsArgs) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + var _request *BatchGetToolsRequest + if src.Request != nil { + _request = &BatchGetToolsRequest{} + if err := _request.DeepCopy(src.Request); err != nil { + return err + } + } + p.Request = _request + + return nil +} + +func (p *ToolManageServiceBatchGetToolsResult) FastRead(buf []byte) (int, error) { + + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + for { + fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 0: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField0(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + } + + return offset, nil +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceBatchGetToolsResult[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *ToolManageServiceBatchGetToolsResult) FastReadField0(buf []byte) (int, error) { + offset := 0 + _field := NewBatchGetToolsResponse() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Success = _field + return offset, nil +} + +func (p *ToolManageServiceBatchGetToolsResult) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *ToolManageServiceBatchGetToolsResult) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p != nil { + offset += p.fastWriteField0(buf[offset:], w) + } + offset += thrift.Binary.WriteFieldStop(buf[offset:]) + return offset +} + +func (p *ToolManageServiceBatchGetToolsResult) BLength() int { + l := 0 + if p != nil { + l += p.field0Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *ToolManageServiceBatchGetToolsResult) fastWriteField0(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetSuccess() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 0) + offset += p.Success.FastWriteNocopy(buf[offset:], w) + } + return offset +} + +func (p *ToolManageServiceBatchGetToolsResult) field0Length() int { + l := 0 + if p.IsSetSuccess() { + l += thrift.Binary.FieldBeginLength() + l += p.Success.BLength() + } + return l +} + +func (p *ToolManageServiceBatchGetToolsResult) DeepCopy(s interface{}) error { + src, ok := s.(*ToolManageServiceBatchGetToolsResult) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + var _success *BatchGetToolsResponse + if src.Success != nil { + _success = &BatchGetToolsResponse{} + if err := _success.DeepCopy(src.Success); err != nil { + return err + } + } + p.Success = _success + + return nil +} + func (p *ToolManageServiceCreateToolArgs) GetFirstArgument() interface{} { return p.Request } @@ -5375,3 +6417,11 @@ func (p *ToolManageServiceListToolCommitArgs) GetFirstArgument() interface{} { func (p *ToolManageServiceListToolCommitResult) GetResult() interface{} { return p.Success } + +func (p *ToolManageServiceBatchGetToolsArgs) GetFirstArgument() interface{} { + return p.Request +} + +func (p *ToolManageServiceBatchGetToolsResult) GetResult() interface{} { + return p.Success +} diff --git a/backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/toolmanageservice.go b/backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/toolmanageservice.go index 258a2d690..31f178824 100644 --- a/backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/toolmanageservice.go +++ b/backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/toolmanageservice.go @@ -55,6 +55,13 @@ var serviceMethods = map[string]kitex.MethodInfo{ false, kitex.WithStreamingMode(kitex.StreamingNone), ), + "BatchGetTools": kitex.NewMethodInfo( + batchGetToolsHandler, + newToolManageServiceBatchGetToolsArgs, + newToolManageServiceBatchGetToolsResult, + false, + kitex.WithStreamingMode(kitex.StreamingNone), + ), } var ( @@ -202,6 +209,25 @@ func newToolManageServiceListToolCommitResult() interface{} { return manage.NewToolManageServiceListToolCommitResult() } +func batchGetToolsHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*manage.ToolManageServiceBatchGetToolsArgs) + realResult := result.(*manage.ToolManageServiceBatchGetToolsResult) + success, err := handler.(manage.ToolManageService).BatchGetTools(ctx, realArg.Request) + if err != nil { + return err + } + realResult.Success = success + return nil +} + +func newToolManageServiceBatchGetToolsArgs() interface{} { + return manage.NewToolManageServiceBatchGetToolsArgs() +} + +func newToolManageServiceBatchGetToolsResult() interface{} { + return manage.NewToolManageServiceBatchGetToolsResult() +} + type kClient struct { c client.Client sc client.Streaming @@ -273,3 +299,13 @@ func (p *kClient) ListToolCommit(ctx context.Context, request *manage.ListToolCo } return _result.GetSuccess(), nil } + +func (p *kClient) BatchGetTools(ctx context.Context, request *manage.BatchGetToolsRequest) (r *manage.BatchGetToolsResponse, err error) { + var _args manage.ToolManageServiceBatchGetToolsArgs + _args.Request = request + var _result manage.ToolManageServiceBatchGetToolsResult + if err = p.c.Call(ctx, "BatchGetTools", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} diff --git a/backend/kitex_gen/coze/loop/prompt/toolmanageservice/client.go b/backend/kitex_gen/coze/loop/prompt/toolmanageservice/client.go index 27f94eaad..19916ba88 100644 --- a/backend/kitex_gen/coze/loop/prompt/toolmanageservice/client.go +++ b/backend/kitex_gen/coze/loop/prompt/toolmanageservice/client.go @@ -17,6 +17,7 @@ type Client interface { SaveToolDetail(ctx context.Context, request *manage.SaveToolDetailRequest, callOptions ...callopt.Option) (r *manage.SaveToolDetailResponse, err error) CommitToolDraft(ctx context.Context, request *manage.CommitToolDraftRequest, callOptions ...callopt.Option) (r *manage.CommitToolDraftResponse, err error) ListToolCommit(ctx context.Context, request *manage.ListToolCommitRequest, callOptions ...callopt.Option) (r *manage.ListToolCommitResponse, err error) + BatchGetTools(ctx context.Context, request *manage.BatchGetToolsRequest, callOptions ...callopt.Option) (r *manage.BatchGetToolsResponse, err error) } // NewClient creates a client for the service defined in IDL. @@ -77,3 +78,8 @@ func (p *kToolManageServiceClient) ListToolCommit(ctx context.Context, request * ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.ListToolCommit(ctx, request) } + +func (p *kToolManageServiceClient) BatchGetTools(ctx context.Context, request *manage.BatchGetToolsRequest, callOptions ...callopt.Option) (r *manage.BatchGetToolsResponse, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.BatchGetTools(ctx, request) +} diff --git a/backend/kitex_gen/coze/loop/prompt/toolmanageservice/toolmanageservice.go b/backend/kitex_gen/coze/loop/prompt/toolmanageservice/toolmanageservice.go index 736d425d6..a2e36208d 100644 --- a/backend/kitex_gen/coze/loop/prompt/toolmanageservice/toolmanageservice.go +++ b/backend/kitex_gen/coze/loop/prompt/toolmanageservice/toolmanageservice.go @@ -56,6 +56,13 @@ var serviceMethods = map[string]kitex.MethodInfo{ false, kitex.WithStreamingMode(kitex.StreamingNone), ), + "BatchGetTools": kitex.NewMethodInfo( + batchGetToolsHandler, + newToolManageServiceBatchGetToolsArgs, + newToolManageServiceBatchGetToolsResult, + false, + kitex.WithStreamingMode(kitex.StreamingNone), + ), } var ( @@ -203,6 +210,25 @@ func newToolManageServiceListToolCommitResult() interface{} { return manage.NewToolManageServiceListToolCommitResult() } +func batchGetToolsHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*manage.ToolManageServiceBatchGetToolsArgs) + realResult := result.(*manage.ToolManageServiceBatchGetToolsResult) + success, err := handler.(manage.ToolManageService).BatchGetTools(ctx, realArg.Request) + if err != nil { + return err + } + realResult.Success = success + return nil +} + +func newToolManageServiceBatchGetToolsArgs() interface{} { + return manage.NewToolManageServiceBatchGetToolsArgs() +} + +func newToolManageServiceBatchGetToolsResult() interface{} { + return manage.NewToolManageServiceBatchGetToolsResult() +} + type kClient struct { c client.Client sc client.Streaming @@ -274,3 +300,13 @@ func (p *kClient) ListToolCommit(ctx context.Context, request *manage.ListToolCo } return _result.GetSuccess(), nil } + +func (p *kClient) BatchGetTools(ctx context.Context, request *manage.BatchGetToolsRequest) (r *manage.BatchGetToolsResponse, err error) { + var _args manage.ToolManageServiceBatchGetToolsArgs + _args.Request = request + var _result manage.ToolManageServiceBatchGetToolsResult + if err = p.c.Call(ctx, "BatchGetTools", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} diff --git a/backend/loop_gen/coze/loop/prompt/tool/lomanage/local_toolmanageservice.go b/backend/loop_gen/coze/loop/prompt/tool/lomanage/local_toolmanageservice.go index 716c6a6e4..b1784274a 100644 --- a/backend/loop_gen/coze/loop/prompt/tool/lomanage/local_toolmanageservice.go +++ b/backend/loop_gen/coze/loop/prompt/tool/lomanage/local_toolmanageservice.go @@ -148,6 +148,27 @@ func (l *LocalToolManageService) ListToolCommit(ctx context.Context, request *ma return result.GetSuccess(), nil } +func (l *LocalToolManageService) BatchGetTools(ctx context.Context, request *manage.BatchGetToolsRequest, callOptions ...callopt.Option) (*manage.BatchGetToolsResponse, error) { + chain := l.mds(func(ctx context.Context, in, out interface{}) error { + arg := in.(*manage.ToolManageServiceBatchGetToolsArgs) + result := out.(*manage.ToolManageServiceBatchGetToolsResult) + resp, err := l.impl.BatchGetTools(ctx, arg.Request) + if err != nil { + return err + } + result.SetSuccess(resp) + return nil + }) + + arg := &manage.ToolManageServiceBatchGetToolsArgs{Request: request} + result := &manage.ToolManageServiceBatchGetToolsResult{} + ctx = l.injectRPCInfo(ctx, "BatchGetTools") + if err := chain(ctx, arg, result); err != nil { + return nil, err + } + return result.GetSuccess(), nil +} + func (l *LocalToolManageService) injectRPCInfo(ctx context.Context, method string) context.Context { rpcStats := rpcinfo.AsMutableRPCStats(rpcinfo.NewRPCStats()) ri := rpcinfo.NewRPCInfo( diff --git a/backend/modules/prompt/application/tool_manage.go b/backend/modules/prompt/application/tool_manage.go index f6c341a58..769638eaa 100644 --- a/backend/modules/prompt/application/tool_manage.go +++ b/backend/modules/prompt/application/tool_manage.go @@ -366,6 +366,62 @@ func (app *ToolManageApplicationImpl) ListToolCommit(ctx context.Context, reques return r, nil } +func (app *ToolManageApplicationImpl) BatchGetTools(ctx context.Context, request *toolmanage.BatchGetToolsRequest) (r *toolmanage.BatchGetToolsResponse, err error) { + r = toolmanage.NewBatchGetToolsResponse() + + _, ok := session.UserIDInCtx(ctx) + if !ok { + return r, errorx.NewByCode(prompterr.CommonInvalidParamCode, errorx.WithExtraMsg("User not found")) + } + + if request.GetWorkspaceID() <= 0 { + return r, errorx.NewByCode(prompterr.CommonInvalidParamCode, errorx.WithExtraMsg("Workspace ID is required")) + } + if len(request.GetQueries()) == 0 { + return r, errorx.NewByCode(prompterr.CommonInvalidParamCode, errorx.WithExtraMsg("Queries is required")) + } + + err = app.authRPCProvider.CheckSpacePermission(ctx, request.GetWorkspaceID(), consts.ActionLoopPromptRead) + if err != nil { + return r, err + } + + queries := make([]repo.BatchGetToolsQuery, 0, len(request.GetQueries())) + for _, q := range request.GetQueries() { + if q == nil { + continue + } + queries = append(queries, repo.BatchGetToolsQuery{ + ToolID: q.GetToolID(), + Version: q.GetVersion(), + }) + } + + results, err := app.toolRepo.BatchGetTools(ctx, repo.BatchGetToolsParam{ + SpaceID: request.GetWorkspaceID(), + Queries: queries, + }) + if err != nil { + return r, err + } + + items := make([]*toolmanage.ToolResult_, 0, len(results)) + for _, result := range results { + if result == nil || result.Tool == nil { + continue + } + items = append(items, &toolmanage.ToolResult_{ + Query: &toolmanage.ToolQuery{ + ToolID: ptr.Of(result.Query.ToolID), + Version: ptr.Of(result.Query.Version), + }, + Tool: convertor.ToolMgmtDO2DTO(result.Tool), + }) + } + r.Items = items + return r, nil +} + func (app *ToolManageApplicationImpl) listToolOrderBy(orderBy *toolmanage.ListToolOrderBy) int { if orderBy == nil { return mysql.ListToolBasicOrderByID diff --git a/backend/modules/prompt/domain/repo/tool.go b/backend/modules/prompt/domain/repo/tool.go index 8b2e61f46..363d7a829 100644 --- a/backend/modules/prompt/domain/repo/tool.go +++ b/backend/modules/prompt/domain/repo/tool.go @@ -10,6 +10,7 @@ type IToolRepo interface { CreateTool(ctx context.Context, tool *toolmgmt.Tool) (toolID int64, err error) DeleteTool(ctx context.Context, toolID int64) (err error) GetTool(ctx context.Context, param GetToolParam) (tool *toolmgmt.Tool, err error) + BatchGetTools(ctx context.Context, param BatchGetToolsParam) (result []*BatchGetToolsResult, err error) ListTool(ctx context.Context, param ListToolParam) (result *ListToolResult, err error) SaveToolDetail(ctx context.Context, param SaveToolDetailParam) (err error) CommitToolDraft(ctx context.Context, param CommitToolDraftParam) (err error) @@ -75,3 +76,18 @@ type ListToolCommitResult struct { CommitDetails map[string]*toolmgmt.ToolDetail NextPageToken int64 } + +type BatchGetToolsQuery struct { + ToolID int64 + Version string +} + +type BatchGetToolsParam struct { + SpaceID int64 + Queries []BatchGetToolsQuery +} + +type BatchGetToolsResult struct { + Query BatchGetToolsQuery + Tool *toolmgmt.Tool +} diff --git a/backend/modules/prompt/infra/repo/mysql/tool_basic.go b/backend/modules/prompt/infra/repo/mysql/tool_basic.go index f91458830..18f9651af 100644 --- a/backend/modules/prompt/infra/repo/mysql/tool_basic.go +++ b/backend/modules/prompt/infra/repo/mysql/tool_basic.go @@ -23,6 +23,7 @@ type IToolBasicDAO interface { Create(ctx context.Context, basicPO *model.ToolBasic, opts ...db.Option) (err error) Delete(ctx context.Context, toolID int64, spaceID int64, opts ...db.Option) (err error) Get(ctx context.Context, toolID int64, opts ...db.Option) (basicPO *model.ToolBasic, err error) + BatchGet(ctx context.Context, toolIDs []int64, opts ...db.Option) (basicPOs []*model.ToolBasic, err error) List(ctx context.Context, param ListToolBasicParam, opts ...db.Option) (basicPOs []*model.ToolBasic, total int64, err error) Update(ctx context.Context, toolID int64, updateFields map[string]interface{}, opts ...db.Option) (err error) } @@ -108,6 +109,19 @@ func (d *ToolBasicDAOImpl) Get(ctx context.Context, toolID int64, opts ...db.Opt return basicPOs[0], nil } +func (d *ToolBasicDAOImpl) BatchGet(ctx context.Context, toolIDs []int64, opts ...db.Option) (basicPOs []*model.ToolBasic, err error) { + if len(toolIDs) == 0 { + return nil, nil + } + q := query.Use(d.db.NewSession(ctx, opts...)) + tx := q.WithContext(ctx).ToolBasic + basicPOs, err = tx.Where(q.ToolBasic.ID.In(toolIDs...)).Find() + if err != nil { + return nil, errorx.WrapByCode(err, prompterr.CommonMySqlErrorCode) + } + return basicPOs, nil +} + func (d *ToolBasicDAOImpl) List(ctx context.Context, param ListToolBasicParam, opts ...db.Option) (basicPOs []*model.ToolBasic, total int64, err error) { if param.SpaceID <= 0 || param.Offset < 0 || param.Limit <= 0 { return nil, 0, errorx.New("param(SpaceID or Offset or Limit) is invalid, param = %s", json.Jsonify(param)) diff --git a/backend/modules/prompt/infra/repo/mysql/tool_commit.go b/backend/modules/prompt/infra/repo/mysql/tool_commit.go index 74c63c632..be016d978 100644 --- a/backend/modules/prompt/infra/repo/mysql/tool_commit.go +++ b/backend/modules/prompt/infra/repo/mysql/tool_commit.go @@ -6,6 +6,7 @@ import ( "fmt" "time" + "gorm.io/gen/field" "gorm.io/gorm" "gorm.io/gorm/clause" @@ -23,9 +24,15 @@ type IToolCommitDAO interface { Create(ctx context.Context, toolCommitPO *model.ToolCommit, timeNow time.Time, opts ...db.Option) (err error) UpsertDraft(ctx context.Context, toolCommitPO *model.ToolCommit, timeNow time.Time, opts ...db.Option) (err error) Get(ctx context.Context, toolID int64, version string, opts ...db.Option) (toolCommitPO *model.ToolCommit, err error) + BatchGet(ctx context.Context, toolIDVersionPairs []ToolIDVersionPair, opts ...db.Option) (commitPOs []*model.ToolCommit, err error) List(ctx context.Context, param ListToolCommitParam, opts ...db.Option) (commitPOs []*model.ToolCommit, err error) } +type ToolIDVersionPair struct { + ToolID int64 + Version string +} + type ListToolCommitParam struct { ToolID int64 @@ -114,6 +121,25 @@ func (d *ToolCommitDAOImpl) Get(ctx context.Context, toolID int64, version strin return toolCommitPOs[0], nil } +func (d *ToolCommitDAOImpl) BatchGet(ctx context.Context, toolIDVersionPairs []ToolIDVersionPair, opts ...db.Option) (commitPOs []*model.ToolCommit, err error) { + if len(toolIDVersionPairs) == 0 { + return nil, nil + } + q := query.Use(d.db.NewSession(ctx, opts...)) + tx := q.WithContext(ctx).ToolCommit + + conditions := make([]field.Expr, 0, len(toolIDVersionPairs)) + for _, pair := range toolIDVersionPairs { + conditions = append(conditions, field.And(q.ToolCommit.ToolID.Eq(pair.ToolID), q.ToolCommit.Version.Eq(pair.Version))) + } + tx = tx.Where(field.Or(conditions...)) + commitPOs, err = tx.Find() + if err != nil { + return nil, errorx.WrapByCode(err, prompterr.CommonMySqlErrorCode) + } + return commitPOs, nil +} + func (d *ToolCommitDAOImpl) List(ctx context.Context, param ListToolCommitParam, opts ...db.Option) (commitPOs []*model.ToolCommit, err error) { if param.ToolID <= 0 || param.Limit <= 0 { return nil, errorx.New("Param(ToolID or Limit) is invalid, param = %s", json.Jsonify(param)) diff --git a/backend/modules/prompt/infra/repo/tool.go b/backend/modules/prompt/infra/repo/tool.go index 8c5c9d305..c9b19154c 100644 --- a/backend/modules/prompt/infra/repo/tool.go +++ b/backend/modules/prompt/infra/repo/tool.go @@ -255,6 +255,77 @@ func (d *ToolRepoImpl) CommitToolDraft(ctx context.Context, param repo.CommitToo }) } +func (d *ToolRepoImpl) BatchGetTools(ctx context.Context, param repo.BatchGetToolsParam) (result []*repo.BatchGetToolsResult, err error) { + if len(param.Queries) == 0 { + return nil, nil + } + + toolIDSet := make(map[int64]struct{}, len(param.Queries)) + for _, q := range param.Queries { + toolIDSet[q.ToolID] = struct{}{} + } + toolIDs := make([]int64, 0, len(toolIDSet)) + for id := range toolIDSet { + toolIDs = append(toolIDs, id) + } + + basicPOs, err := d.toolBasicDAO.BatchGet(ctx, toolIDs) + if err != nil { + return nil, err + } + basicMap := make(map[int64]*mysqlmodel.ToolBasic, len(basicPOs)) + for _, po := range basicPOs { + if po == nil { + continue + } + basicMap[po.ID] = po + } + + var commitPairs []mysql.ToolIDVersionPair + for _, q := range param.Queries { + basicPO, ok := basicMap[q.ToolID] + if !ok { + continue + } + version := q.Version + if lo.IsEmpty(version) { + version = basicPO.LatestCommittedVersion + } + if lo.IsEmpty(version) { + continue + } + commitPairs = append(commitPairs, mysql.ToolIDVersionPair{ToolID: q.ToolID, Version: version}) + } + + commitMap := make(map[int64]*mysqlmodel.ToolCommit) + if len(commitPairs) > 0 { + commitPOs, err := d.toolCommitDAO.BatchGet(ctx, commitPairs) + if err != nil { + return nil, err + } + for _, po := range commitPOs { + if po == nil { + continue + } + commitMap[po.ToolID] = po + } + } + + result = make([]*repo.BatchGetToolsResult, 0, len(param.Queries)) + for _, q := range param.Queries { + basicPO, ok := basicMap[q.ToolID] + if !ok || (param.SpaceID > 0 && basicPO.SpaceID != param.SpaceID) { + continue + } + tool := convertor.ToolPO2DO(basicPO, commitMap[q.ToolID]) + result = append(result, &repo.BatchGetToolsResult{ + Query: q, + Tool: tool, + }) + } + return result, nil +} + func (d *ToolRepoImpl) ListToolCommit(ctx context.Context, param repo.ListToolCommitParam) (result *repo.ListToolCommitResult, err error) { if param.ToolID <= 0 || param.PageSize <= 0 { return nil, errorx.New("param is invalid, param = %s", json.Jsonify(param)) diff --git a/idl/thrift/coze/loop/prompt/coze.loop.prompt.tool.manage.thrift b/idl/thrift/coze/loop/prompt/coze.loop.prompt.tool.manage.thrift index 0622c00fe..2871a0654 100644 --- a/idl/thrift/coze/loop/prompt/coze.loop.prompt.tool.manage.thrift +++ b/idl/thrift/coze/loop/prompt/coze.loop.prompt.tool.manage.thrift @@ -11,6 +11,7 @@ service ToolManageService { SaveToolDetailResponse SaveToolDetail(1: SaveToolDetailRequest request) (api.post = '/api/prompt/v1/tools/:tool_id/drafts/save') CommitToolDraftResponse CommitToolDraft(1: CommitToolDraftRequest request) (api.post = '/api/prompt/v1/tools/:tool_id/drafts/commit') ListToolCommitResponse ListToolCommit(1: ListToolCommitRequest request) (api.post = '/api/prompt/v1/tools/:tool_id/commits/list') + BatchGetToolsResponse BatchGetTools(1: BatchGetToolsRequest request) (api.post = '/api/prompt/v1/tools/mget') } struct CreateToolRequest { @@ -129,3 +130,26 @@ struct ListToolCommitResponse { 255: optional base.BaseResp BaseResp } + +struct ToolQuery { + 1: optional i64 tool_id (api.js_conv='true', go.tag='json:"tool_id"') + 2: optional string version +} + +struct ToolResult { + 1: optional ToolQuery query + 2: optional tool.Tool tool +} + +struct BatchGetToolsRequest { + 1: optional i64 workspace_id (api.js_conv='true', vt.not_nil='true', vt.gt='0', go.tag='json:"workspace_id"') + 2: optional list queries (vt.min_size="1") + + 255: optional base.Base Base +} + +struct BatchGetToolsResponse { + 1: optional list items + + 255: optional base.BaseResp BaseResp +} From c665ddb6a33c4f9eba10890ec367c376408b3c0b Mon Sep 17 00:00:00 2001 From: "wangluming.wlm" Date: Tue, 24 Mar 2026 17:43:34 +0800 Subject: [PATCH 3/8] feat:tool --- ...age.go => coze.loop.prompt.tool_manage.go} | 598 ++++++++++++------ ...coze.loop.prompt.tool_manage_validator.go} | 0 ...e.go => k-coze.loop.prompt.tool_manage.go} | 0 .../tool/manage/toolmanageservice/client.go | 6 + .../coze/loop/apis/coze.loop.apis.thrift | 4 +- .../coze/loop/prompt/coze.loop.prompt.thrift | 4 +- ...ft => coze.loop.prompt.tool_manage.thrift} | 0 7 files changed, 402 insertions(+), 210 deletions(-) rename backend/kitex_gen/coze/loop/prompt/tool/manage/{coze.loop.prompt.tool.manage.go => coze.loop.prompt.tool_manage.go} (95%) rename backend/kitex_gen/coze/loop/prompt/tool/manage/{coze.loop.prompt.tool.manage_validator.go => coze.loop.prompt.tool_manage_validator.go} (100%) rename backend/kitex_gen/coze/loop/prompt/tool/manage/{k-coze.loop.prompt.tool.manage.go => k-coze.loop.prompt.tool_manage.go} (100%) rename idl/thrift/coze/loop/prompt/{coze.loop.prompt.tool.manage.thrift => coze.loop.prompt.tool_manage.thrift} (100%) diff --git a/backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool.manage.go b/backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool_manage.go similarity index 95% rename from backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool.manage.go rename to backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool_manage.go index d1c218468..105da993b 100644 --- a/backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool.manage.go +++ b/backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool_manage.go @@ -6574,8 +6574,6 @@ type ToolManageService interface { ListToolCommit(ctx context.Context, request *ListToolCommitRequest) (r *ListToolCommitResponse, err error) BatchGetTools(ctx context.Context, request *BatchGetToolsRequest) (r *BatchGetToolsResponse, err error) - - BatchGetTools(ctx context.Context, request *BatchGetToolsRequest) (r *BatchGetToolsResponse, err error) } type ToolManageServiceClient struct { @@ -6656,18 +6654,6 @@ func (p *ToolManageServiceClient) ListToolCommit(ctx context.Context, request *L if err = p.Client_().Call(ctx, "ListToolCommit", &_args, &_result); err != nil { return } -equest *BatchGetToolsRequest) (r *BatchGetToolsResponse, err error) { - var _args ToolManageServiceBatchGetToolsArgs - _args.Request = request - var _result ToolManageServiceBatchGetToolsResult - if err = p.Client_().Call(ctx, "BatchGetTools", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} - -type ToolManageServiceProcessor struct { - processorMap map[string]th return _result.GetSuccess(), nil } func (p *ToolManageServiceClient) BatchGetTools(ctx context.Context, request *BatchGetToolsRequest) (r *BatchGetToolsResponse, err error) { @@ -6692,7 +6678,6 @@ func (p *ToolManageServiceProcessor) AddToProcessorMap(key string, processor thr func (p *ToolManageServiceProcessor) GetProcessorFunction(key string) (processor thrift.TProcessorFunction, ok bool) { processor, ok = p.processorMap[key] return processor, ok -e } func (p *ToolManageServiceProcessor) ProcessorMap() map[string]thrift.TProcessorFunction { @@ -6708,133 +6693,6 @@ func NewToolManageServiceProcessor(handler ToolManageService) *ToolManageService self.AddToProcessorMap("CommitToolDraft", &toolManageServiceProcessorCommitToolDraft{handler: handler}) self.AddToProcessorMap("ListToolCommit", &toolManageServiceProcessorListToolCommit{handler: handler}) self.AddToProcessorMap("BatchGetTools", &toolManageServiceProcessorBatchGetTools{handler: handler}) - retu - return false - } - return true -} - -type ToolManageService interface { - CreateTool(ctx context.Context, request *CreateToolRequest) (r *CreateToolResponse, err error) - - GetToolDetail(ctx context.Context, request *GetToolDetailRequest) (r *GetToolDetailResponse, err error) - - ListTool(ctx context.Context, request *ListToolRequest) (r *ListToolResponse, err error) - - SaveToolDetail(ctx context.Context, request *SaveToolDetailRequest) (r *SaveToolDetailResponse, err error) - - CommitToolDraft(ctx context.Context, request *CommitToolDraftRequest) (r *CommitToolDraftResponse, err error) - - ListToolCommit(ctx context.Context, request *ListToolCommitRequest) (r *ListToolCommitResponse, err error) -} - -type ToolManageServiceClient struct { - c thrift.TClient -} - -func NewToolManageServiceClientFactory(t thrift.TTransport, f thrift.TProtocolFactory) *ToolManageServiceClient { - return &ToolManageServiceClient{ - c: thrift.NewTStandardClient(f.GetProtocol(t), f.GetProtocol(t)), - } -} - -func NewToolManageServiceClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *ToolManageServiceClient { - return &ToolManageServiceClient{ - c: thrift.NewTStandardClient(iprot, oprot), - } -} - -func NewToolManageServiceClient(c thrift.TClient) *ToolManageServiceClient { - return &ToolManageServiceClient{ - c: c, - } -} - -func (p *ToolManageServiceClient) Client_() thrift.TClient { - return p.c -} - -func (p *ToolManageServiceClient) CreateTool(ctx context.Context, request *CreateToolRequest) (r *CreateToolResponse, err error) { - var _args ToolManageServiceCreateToolArgs - _args.Request = request - var _result ToolManageServiceCreateToolResult - if err = p.Client_().Call(ctx, "CreateTool", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} -func (p *ToolManageServiceClient) GetToolDetail(ctx context.Context, request *GetToolDetailRequest) (r *GetToolDetailResponse, err error) { - var _args ToolManageServiceGetToolDetailArgs - _args.Request = request - var _result ToolManageServiceGetToolDetailResult - if err = p.Client_().Call(ctx, "GetToolDetail", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} -func (p *ToolManageServiceClient) ListTool(ctx context.Context, request *ListToolRequest) (r *ListToolResponse, err error) { - var _args ToolManageServiceListToolArgs - _args.Request = request - var _result ToolManageServiceListToolResult - if err = p.Client_().Call(ctx, "ListTool", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} -func (p *ToolManageServiceClient) SaveToolDetail(ctx context.Context, request *SaveToolDetailRequest) (r *SaveToolDetailResponse, err error) { - var _args ToolManageServiceSaveToolDetailArgs - _args.Request = request - var _result ToolManageServiceSaveToolDetailResult - if err = p.Client_().Call(ctx, "SaveToolDetail", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} -func (p *ToolManageServiceClient) CommitToolDraft(ctx context.Context, request *CommitToolDraftRequest) (r *CommitToolDraftResponse, err error) { - var _args ToolManageServiceCommitToolDraftArgs - _args.Request = request - var _result ToolManageServiceCommitToolDraftResult - if err = p.Client_().Call(ctx, "CommitToolDraft", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} -func (p *ToolManageServiceClient) ListToolCommit(ctx context.Context, request *ListToolCommitRequest) (r *ListToolCommitResponse, err error) { - var _args ToolManageServiceListToolCommitArgs - _args.Request = request - var _result ToolManageServiceListToolCommitResult - if err = p.Client_().Call(ctx, "ListToolCommit", &_args, &_result); err != nil { - return - } - return _result.GetSuccess(), nil -} - -type ToolManageServiceProcessor struct { - processorMap map[string]thrift.TProcessorFunction - handler ToolManageService -} - -func (p *ToolManageServiceProcessor) AddToProcessorMap(key string, processor thrift.TProcessorFunction) { - p.processorMap[key] = processor -} - -func (p *ToolManageServiceProcessor) GetProcessorFunction(key string) (processor thrift.TProcessorFunction, ok bool) { - processor, ok = p.processorMap[key] - return processor, ok -} - -func (p *ToolManageServiceProcessor) ProcessorMap() map[string]thrift.TProcessorFunction { - return p.processorMap -} - -func NewToolManageServiceProcessor(handler ToolManageService) *ToolManageServiceProcessor { - self := &ToolManageServiceProcessor{handler: handler, processorMap: make(map[string]thrift.TProcessorFunction)} - self.AddToProcessorMap("CreateTool", &toolManageServiceProcessorCreateTool{handler: handler}) - self.AddToProcessorMap("GetToolDetail", &toolManageServiceProcessorGetToolDetail{handler: handler}) - self.AddToProcessorMap("ListTool", &toolManageServiceProcessorListTool{handler: handler}) - self.AddToProcessorMap("SaveToolDetail", &toolManageServiceProcessorSaveToolDetail{handler: handler}) - self.AddToProcessorMap("CommitToolDraft", &toolManageServiceProcessorCommitToolDraft{handler: handler}) - self.AddToProcessorMap("ListToolCommit", &toolManageServiceProcessorListToolCommit{handler: handler}) return self } func (p *ToolManageServiceProcessor) Process(ctx context.Context, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { @@ -7001,70 +6859,6 @@ func (p *toolManageServiceProcessorListTool) Process(ctx context.Context, seqId type toolManageServiceProcessorSaveToolDetail struct { handler ToolManageService - - err = err2 - } - if err2 = result.Write(oprot); err == nil && err2 != nil { - err = err2 - } - if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil { - err = err2 - } - if err2 = oprot.Flush(ctx); err == nil && err2 != nil { - err = err2 - } - if err != nil { - return - } - return true, err -} - -type ToolManageServiceCreateToolArgs struct { - Request *CreateToolRequest `thrift:"request,1" frugal:"1,default,CreateToolRequest"` -} - -func NewToolManageServiceCreateToolArgs() *ToolManageServiceCreateToolArgs { - return &ToolManageServiceCreateToolArgs{} -} - -func (p *ToolManageServiceCreateToolArgs) InitDefault() { -} - -var ToolManageServiceCreateToolArgs_Request_DEFAULT *CreateToolRequest - -func (p *ToolManageServiceCreateToolArgs) GetRequest() (v *CreateToolRequest) { - if p == nil { - return - } - if !p.IsSetRequest() { - return ToolManageServiceCreateToolArgs_Request_DEFAULT - } - return p.Request -} -func (p *ToolManageServiceCreateToolArgs) SetRequest(val *CreateToolRequest) { - p.Request = val -} - -var fieldIDToName_ToolManageServiceCreateToolArgs = map[int16]string{ - 1: "request", -} - -func (p *ToolManageServiceCreateToolArgs) IsSetRequest() bool { - return p.Request != nil -} - -func (p *ToolManageServiceCreateToolArgs) Read(iprot thrift.TProtocol) (err error) { - var fieldTypeId thrift.TType - var fieldId int16 - - if _, err = iprot.ReadStructBegin(); err != nil { - goto ReadStructBeginError - } - - for { - _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() - if err != nil { - goto ReadFiel } func (p *toolManageServiceProcessorSaveToolDetail) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { @@ -7207,6 +7001,54 @@ func (p *toolManageServiceProcessorListToolCommit) Process(ctx context.Context, return true, err } +type toolManageServiceProcessorBatchGetTools struct { + handler ToolManageService +} + +func (p *toolManageServiceProcessorBatchGetTools) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := ToolManageServiceBatchGetToolsArgs{} + if err = args.Read(iprot); err != nil { + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) + oprot.WriteMessageBegin("BatchGetTools", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return false, err + } + + iprot.ReadMessageEnd() + var err2 error + result := ToolManageServiceBatchGetToolsResult{} + var retval *BatchGetToolsResponse + if retval, err2 = p.handler.BatchGetTools(ctx, args.Request); err2 != nil { + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing BatchGetTools: "+err2.Error()) + oprot.WriteMessageBegin("BatchGetTools", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return true, err2 + } else { + result.Success = retval + } + if err2 = oprot.WriteMessageBegin("BatchGetTools", thrift.REPLY, seqId); err2 != nil { + err = err2 + } + if err2 = result.Write(oprot); err == nil && err2 != nil { + err = err2 + } + if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil { + err = err2 + } + if err2 = oprot.Flush(ctx); err == nil && err2 != nil { + err = err2 + } + if err != nil { + return + } + return true, err +} + type ToolManageServiceCreateToolArgs struct { Request *CreateToolRequest `thrift:"request,1" frugal:"1,default,CreateToolRequest"` } @@ -9270,3 +9112,347 @@ func (p *ToolManageServiceListToolCommitResult) Field0DeepEqual(src *ListToolCom } return true } + +type ToolManageServiceBatchGetToolsArgs struct { + Request *BatchGetToolsRequest `thrift:"request,1" frugal:"1,default,BatchGetToolsRequest"` +} + +func NewToolManageServiceBatchGetToolsArgs() *ToolManageServiceBatchGetToolsArgs { + return &ToolManageServiceBatchGetToolsArgs{} +} + +func (p *ToolManageServiceBatchGetToolsArgs) InitDefault() { +} + +var ToolManageServiceBatchGetToolsArgs_Request_DEFAULT *BatchGetToolsRequest + +func (p *ToolManageServiceBatchGetToolsArgs) GetRequest() (v *BatchGetToolsRequest) { + if p == nil { + return + } + if !p.IsSetRequest() { + return ToolManageServiceBatchGetToolsArgs_Request_DEFAULT + } + return p.Request +} +func (p *ToolManageServiceBatchGetToolsArgs) SetRequest(val *BatchGetToolsRequest) { + p.Request = val +} + +var fieldIDToName_ToolManageServiceBatchGetToolsArgs = map[int16]string{ + 1: "request", +} + +func (p *ToolManageServiceBatchGetToolsArgs) IsSetRequest() bool { + return p.Request != nil +} + +func (p *ToolManageServiceBatchGetToolsArgs) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceBatchGetToolsArgs[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *ToolManageServiceBatchGetToolsArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewBatchGetToolsRequest() + if err := _field.Read(iprot); err != nil { + return err + } + p.Request = _field + return nil +} + +func (p *ToolManageServiceBatchGetToolsArgs) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("BatchGetTools_args"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *ToolManageServiceBatchGetToolsArgs) writeField1(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { + goto WriteFieldBeginError + } + if err := p.Request.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} + +func (p *ToolManageServiceBatchGetToolsArgs) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("ToolManageServiceBatchGetToolsArgs(%+v)", *p) + +} + +func (p *ToolManageServiceBatchGetToolsArgs) DeepEqual(ano *ToolManageServiceBatchGetToolsArgs) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.Request) { + return false + } + return true +} + +func (p *ToolManageServiceBatchGetToolsArgs) Field1DeepEqual(src *BatchGetToolsRequest) bool { + + if !p.Request.DeepEqual(src) { + return false + } + return true +} + +type ToolManageServiceBatchGetToolsResult struct { + Success *BatchGetToolsResponse `thrift:"success,0,optional" frugal:"0,optional,BatchGetToolsResponse"` +} + +func NewToolManageServiceBatchGetToolsResult() *ToolManageServiceBatchGetToolsResult { + return &ToolManageServiceBatchGetToolsResult{} +} + +func (p *ToolManageServiceBatchGetToolsResult) InitDefault() { +} + +var ToolManageServiceBatchGetToolsResult_Success_DEFAULT *BatchGetToolsResponse + +func (p *ToolManageServiceBatchGetToolsResult) GetSuccess() (v *BatchGetToolsResponse) { + if p == nil { + return + } + if !p.IsSetSuccess() { + return ToolManageServiceBatchGetToolsResult_Success_DEFAULT + } + return p.Success +} +func (p *ToolManageServiceBatchGetToolsResult) SetSuccess(x interface{}) { + p.Success = x.(*BatchGetToolsResponse) +} + +var fieldIDToName_ToolManageServiceBatchGetToolsResult = map[int16]string{ + 0: "success", +} + +func (p *ToolManageServiceBatchGetToolsResult) IsSetSuccess() bool { + return p.Success != nil +} + +func (p *ToolManageServiceBatchGetToolsResult) Read(iprot thrift.TProtocol) (err error) { + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 0: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField0(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_ToolManageServiceBatchGetToolsResult[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *ToolManageServiceBatchGetToolsResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewBatchGetToolsResponse() + if err := _field.Read(iprot); err != nil { + return err + } + p.Success = _field + return nil +} + +func (p *ToolManageServiceBatchGetToolsResult) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("BatchGetTools_result"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField0(oprot); err != nil { + fieldId = 0 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *ToolManageServiceBatchGetToolsResult) writeField0(oprot thrift.TProtocol) (err error) { + if p.IsSetSuccess() { + if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { + goto WriteFieldBeginError + } + if err := p.Success.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 0 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) +} + +func (p *ToolManageServiceBatchGetToolsResult) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("ToolManageServiceBatchGetToolsResult(%+v)", *p) + +} + +func (p *ToolManageServiceBatchGetToolsResult) DeepEqual(ano *ToolManageServiceBatchGetToolsResult) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field0DeepEqual(ano.Success) { + return false + } + return true +} + +func (p *ToolManageServiceBatchGetToolsResult) Field0DeepEqual(src *BatchGetToolsResponse) bool { + + if !p.Success.DeepEqual(src) { + return false + } + return true +} diff --git a/backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool.manage_validator.go b/backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool_manage_validator.go similarity index 100% rename from backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool.manage_validator.go rename to backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool_manage_validator.go diff --git a/backend/kitex_gen/coze/loop/prompt/tool/manage/k-coze.loop.prompt.tool.manage.go b/backend/kitex_gen/coze/loop/prompt/tool/manage/k-coze.loop.prompt.tool_manage.go similarity index 100% rename from backend/kitex_gen/coze/loop/prompt/tool/manage/k-coze.loop.prompt.tool.manage.go rename to backend/kitex_gen/coze/loop/prompt/tool/manage/k-coze.loop.prompt.tool_manage.go diff --git a/backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/client.go b/backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/client.go index 27f94eaad..19916ba88 100644 --- a/backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/client.go +++ b/backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/client.go @@ -17,6 +17,7 @@ type Client interface { SaveToolDetail(ctx context.Context, request *manage.SaveToolDetailRequest, callOptions ...callopt.Option) (r *manage.SaveToolDetailResponse, err error) CommitToolDraft(ctx context.Context, request *manage.CommitToolDraftRequest, callOptions ...callopt.Option) (r *manage.CommitToolDraftResponse, err error) ListToolCommit(ctx context.Context, request *manage.ListToolCommitRequest, callOptions ...callopt.Option) (r *manage.ListToolCommitResponse, err error) + BatchGetTools(ctx context.Context, request *manage.BatchGetToolsRequest, callOptions ...callopt.Option) (r *manage.BatchGetToolsResponse, err error) } // NewClient creates a client for the service defined in IDL. @@ -77,3 +78,8 @@ func (p *kToolManageServiceClient) ListToolCommit(ctx context.Context, request * ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.ListToolCommit(ctx, request) } + +func (p *kToolManageServiceClient) BatchGetTools(ctx context.Context, request *manage.BatchGetToolsRequest, callOptions ...callopt.Option) (r *manage.BatchGetToolsResponse, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.BatchGetTools(ctx, request) +} diff --git a/idl/thrift/coze/loop/apis/coze.loop.apis.thrift b/idl/thrift/coze/loop/apis/coze.loop.apis.thrift index 80384ad1b..381000f3b 100644 --- a/idl/thrift/coze/loop/apis/coze.loop.apis.thrift +++ b/idl/thrift/coze/loop/apis/coze.loop.apis.thrift @@ -13,7 +13,7 @@ include "../evaluation/coze.loop.evaluation.expt.thrift" include "../evaluation/coze.loop.evaluation.openapi.thrift" include "../data/coze.loop.data.dataset.thrift" include "../prompt/coze.loop.prompt.manage.thrift" -include "../prompt/coze.loop.prompt.tool.manage.thrift" +include "../prompt/coze.loop.prompt.tool_manage.thrift" include "../prompt/coze.loop.prompt.debug.thrift" include "../prompt/coze.loop.prompt.execute.thrift" include "../prompt/coze.loop.prompt.openapi.thrift" @@ -35,7 +35,7 @@ service DatasetService extends coze.loop.data.dataset.DatasetService{} service TagService extends coze.loop.data.tag.TagService{} service PromptManageService extends coze.loop.prompt.manage.PromptManageService{} -service ToolManageService extends coze.loop.prompt.tool.manage.ToolManageService{} +service ToolManageService extends coze.loop.prompt.tool_manage.ToolManageService{} service PromptDebugService extends coze.loop.prompt.debug.PromptDebugService{} service PromptExecuteService extends coze.loop.prompt.execute.PromptExecuteService{} service PromptOpenAPIService extends coze.loop.prompt.openapi.PromptOpenAPIService{} diff --git a/idl/thrift/coze/loop/prompt/coze.loop.prompt.thrift b/idl/thrift/coze/loop/prompt/coze.loop.prompt.thrift index 2e5ac9cae..5db63a849 100644 --- a/idl/thrift/coze/loop/prompt/coze.loop.prompt.thrift +++ b/idl/thrift/coze/loop/prompt/coze.loop.prompt.thrift @@ -1,13 +1,13 @@ namespace go coze.loop.prompt include "coze.loop.prompt.manage.thrift" -include "coze.loop.prompt.tool.manage.thrift" +include "coze.loop.prompt.tool_manage.thrift" include "coze.loop.prompt.debug.thrift" include "coze.loop.prompt.openapi.thrift" include "coze.loop.prompt.execute.thrift" service PromptManageService extends coze.loop.prompt.manage.PromptManageService{} -service ToolManageService extends coze.loop.prompt.tool.manage.ToolManageService{} +service ToolManageService extends coze.loop.prompt.tool_manage.ToolManageService{} service PromptDebugService extends coze.loop.prompt.debug.PromptDebugService{} service PromptExecuteService extends coze.loop.prompt.execute.PromptExecuteService{} service PromptOpenAPIService extends coze.loop.prompt.openapi.PromptOpenAPIService{} diff --git a/idl/thrift/coze/loop/prompt/coze.loop.prompt.tool.manage.thrift b/idl/thrift/coze/loop/prompt/coze.loop.prompt.tool_manage.thrift similarity index 100% rename from idl/thrift/coze/loop/prompt/coze.loop.prompt.tool.manage.thrift rename to idl/thrift/coze/loop/prompt/coze.loop.prompt.tool_manage.thrift From 04d34c36689f1503970e51b1687253edc4c01f3e Mon Sep 17 00:00:00 2001 From: "wangluming.wlm" Date: Tue, 24 Mar 2026 17:55:15 +0800 Subject: [PATCH 4/8] feat:tool --- backend/api/handler/coze/loop/apis/handler.go | 4 +- .../coze/loop/apis/tool_manage_service.go | 2 +- .../coze/loop/apis/coze.loop.apis.go | 32 ++--- .../coze/loop/apis/k-coze.loop.apis.go | 8 +- .../loop/apis/toolmanageservice/client.go | 30 ++--- .../toolmanageservice/toolmanageservice.go | 114 ++++++++--------- .../coze/loop/prompt/coze.loop.prompt.go | 16 +-- .../coze/loop/prompt/k-coze.loop.prompt.go | 4 +- .../coze.loop.prompt.tool_manage.go | 2 +- .../coze.loop.prompt.tool_manage_validator.go | 2 +- .../{tool/manage => tool_manage}/k-consts.go | 2 +- .../k-coze.loop.prompt.tool_manage.go | 2 +- .../toolmanageservice/client.go | 30 ++--- .../toolmanageservice/server.go | 6 +- .../toolmanageservice/toolmanageservice.go | 118 +++++++++--------- .../loop/prompt/toolmanageservice/client.go | 30 ++--- .../toolmanageservice/toolmanageservice.go | 114 ++++++++--------- .../local_toolmanageservice.go | 78 ++++++------ .../modules/prompt/application/tool_manage.go | 2 +- backend/modules/prompt/application/wire.go | 2 +- .../modules/prompt/application/wire_gen.go | 2 +- .../coze.loop.prompt.tool_manage.thrift | 2 +- 22 files changed, 301 insertions(+), 301 deletions(-) rename backend/kitex_gen/coze/loop/prompt/{tool/manage => tool_manage}/coze.loop.prompt.tool_manage.go (99%) rename backend/kitex_gen/coze/loop/prompt/{tool/manage => tool_manage}/coze.loop.prompt.tool_manage_validator.go (99%) rename backend/kitex_gen/coze/loop/prompt/{tool/manage => tool_manage}/k-consts.go (85%) rename backend/kitex_gen/coze/loop/prompt/{tool/manage => tool_manage}/k-coze.loop.prompt.tool_manage.go (99%) rename backend/kitex_gen/coze/loop/prompt/{tool/manage => tool_manage}/toolmanageservice/client.go (51%) rename backend/kitex_gen/coze/loop/prompt/{tool/manage => tool_manage}/toolmanageservice/server.go (64%) rename backend/kitex_gen/coze/loop/prompt/{tool/manage => tool_manage}/toolmanageservice/toolmanageservice.go (57%) rename backend/loop_gen/coze/loop/prompt/{tool/lomanage => lotool_manage}/local_toolmanageservice.go (56%) diff --git a/backend/api/handler/coze/loop/apis/handler.go b/backend/api/handler/coze/loop/apis/handler.go index 163151901..a180d0242 100644 --- a/backend/api/handler/coze/loop/apis/handler.go +++ b/backend/api/handler/coze/loop/apis/handler.go @@ -42,7 +42,7 @@ import ( "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/execute" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/manage" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/openapi" - toolmanage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" + toolmanage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool_manage" "github.com/coze-dev/coze-loop/backend/loop_gen/coze/loop/data/lodataset" "github.com/coze-dev/coze-loop/backend/loop_gen/coze/loop/data/lotag" "github.com/coze-dev/coze-loop/backend/loop_gen/coze/loop/evaluation/loeval_set" @@ -63,7 +63,7 @@ import ( "github.com/coze-dev/coze-loop/backend/loop_gen/coze/loop/prompt/lodebug" "github.com/coze-dev/coze-loop/backend/loop_gen/coze/loop/prompt/lomanage" "github.com/coze-dev/coze-loop/backend/loop_gen/coze/loop/prompt/loopenapi" - lotoolmanage "github.com/coze-dev/coze-loop/backend/loop_gen/coze/loop/prompt/tool/lomanage" + lotoolmanage "github.com/coze-dev/coze-loop/backend/loop_gen/coze/loop/prompt/lotool_manage" dataapp "github.com/coze-dev/coze-loop/backend/modules/data/application" evalapp "github.com/coze-dev/coze-loop/backend/modules/evaluation/application" "github.com/coze-dev/coze-loop/backend/modules/foundation/pkg/errno" diff --git a/backend/api/handler/coze/loop/apis/tool_manage_service.go b/backend/api/handler/coze/loop/apis/tool_manage_service.go index 31d4fa215..723c8f398 100644 --- a/backend/api/handler/coze/loop/apis/tool_manage_service.go +++ b/backend/api/handler/coze/loop/apis/tool_manage_service.go @@ -7,7 +7,7 @@ import ( "github.com/cloudwego/hertz/pkg/app" - "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice" + "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool_manage/toolmanageservice" ) var toolManageSvc toolmanageservice.Client diff --git a/backend/kitex_gen/coze/loop/apis/coze.loop.apis.go b/backend/kitex_gen/coze/loop/apis/coze.loop.apis.go index 7414baef0..b6a619adc 100644 --- a/backend/kitex_gen/coze/loop/apis/coze.loop.apis.go +++ b/backend/kitex_gen/coze/loop/apis/coze.loop.apis.go @@ -17,7 +17,7 @@ import ( "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/foundation/openapi" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/foundation/space" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/foundation/user" - manage1 "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/llm/manage" + manage0 "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/llm/manage" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/llm/runtime" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/observability/metric" openapi2 "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/observability/openapi" @@ -27,7 +27,7 @@ import ( "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/execute" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/manage" openapi1 "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/openapi" - manage0 "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" + "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool_manage" ) type EvaluationSetService interface { @@ -239,28 +239,28 @@ func NewPromptManageServiceClient(c thrift.TClient) *PromptManageServiceClient { } type ToolManageService interface { - manage0.ToolManageService + tool_manage.ToolManageService } type ToolManageServiceClient struct { - *manage0.ToolManageServiceClient + *tool_manage.ToolManageServiceClient } func NewToolManageServiceClientFactory(t thrift.TTransport, f thrift.TProtocolFactory) *ToolManageServiceClient { return &ToolManageServiceClient{ - ToolManageServiceClient: manage0.NewToolManageServiceClientFactory(t, f), + ToolManageServiceClient: tool_manage.NewToolManageServiceClientFactory(t, f), } } func NewToolManageServiceClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *ToolManageServiceClient { return &ToolManageServiceClient{ - ToolManageServiceClient: manage0.NewToolManageServiceClientProtocol(t, iprot, oprot), + ToolManageServiceClient: tool_manage.NewToolManageServiceClientProtocol(t, iprot, oprot), } } func NewToolManageServiceClient(c thrift.TClient) *ToolManageServiceClient { return &ToolManageServiceClient{ - ToolManageServiceClient: manage0.NewToolManageServiceClient(c), + ToolManageServiceClient: tool_manage.NewToolManageServiceClient(c), } } @@ -343,28 +343,28 @@ func NewPromptOpenAPIServiceClient(c thrift.TClient) *PromptOpenAPIServiceClient } type LLMManageService interface { - manage1.LLMManageService + manage0.LLMManageService } type LLMManageServiceClient struct { - *manage1.LLMManageServiceClient + *manage0.LLMManageServiceClient } func NewLLMManageServiceClientFactory(t thrift.TTransport, f thrift.TProtocolFactory) *LLMManageServiceClient { return &LLMManageServiceClient{ - LLMManageServiceClient: manage1.NewLLMManageServiceClientFactory(t, f), + LLMManageServiceClient: manage0.NewLLMManageServiceClientFactory(t, f), } } func NewLLMManageServiceClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *LLMManageServiceClient { return &LLMManageServiceClient{ - LLMManageServiceClient: manage1.NewLLMManageServiceClientProtocol(t, iprot, oprot), + LLMManageServiceClient: manage0.NewLLMManageServiceClientProtocol(t, iprot, oprot), } } func NewLLMManageServiceClient(c thrift.TClient) *LLMManageServiceClient { return &LLMManageServiceClient{ - LLMManageServiceClient: manage1.NewLLMManageServiceClient(c), + LLMManageServiceClient: manage0.NewLLMManageServiceClient(c), } } @@ -727,11 +727,11 @@ func NewPromptManageServiceProcessor(handler PromptManageService) *PromptManageS } type ToolManageServiceProcessor struct { - *manage0.ToolManageServiceProcessor + *tool_manage.ToolManageServiceProcessor } func NewToolManageServiceProcessor(handler ToolManageService) *ToolManageServiceProcessor { - self := &ToolManageServiceProcessor{manage0.NewToolManageServiceProcessor(handler)} + self := &ToolManageServiceProcessor{tool_manage.NewToolManageServiceProcessor(handler)} return self } @@ -763,11 +763,11 @@ func NewPromptOpenAPIServiceProcessor(handler PromptOpenAPIService) *PromptOpenA } type LLMManageServiceProcessor struct { - *manage1.LLMManageServiceProcessor + *manage0.LLMManageServiceProcessor } func NewLLMManageServiceProcessor(handler LLMManageService) *LLMManageServiceProcessor { - self := &LLMManageServiceProcessor{manage1.NewLLMManageServiceProcessor(handler)} + self := &LLMManageServiceProcessor{manage0.NewLLMManageServiceProcessor(handler)} return self } diff --git a/backend/kitex_gen/coze/loop/apis/k-coze.loop.apis.go b/backend/kitex_gen/coze/loop/apis/k-coze.loop.apis.go index afb881e30..eb78053cf 100644 --- a/backend/kitex_gen/coze/loop/apis/k-coze.loop.apis.go +++ b/backend/kitex_gen/coze/loop/apis/k-coze.loop.apis.go @@ -23,7 +23,7 @@ import ( "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/foundation/openapi" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/foundation/space" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/foundation/user" - manage1 "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/llm/manage" + manage0 "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/llm/manage" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/llm/runtime" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/observability/metric" openapi2 "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/observability/openapi" @@ -33,7 +33,7 @@ import ( "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/execute" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/manage" openapi1 "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/openapi" - manage0 "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" + "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool_manage" ) var ( @@ -50,7 +50,7 @@ var ( _ = openapi.KitexUnusedProtection _ = space.KitexUnusedProtection _ = user.KitexUnusedProtection - _ = manage1.KitexUnusedProtection + _ = manage0.KitexUnusedProtection _ = runtime.KitexUnusedProtection _ = metric.KitexUnusedProtection _ = openapi2.KitexUnusedProtection @@ -60,7 +60,7 @@ var ( _ = execute.KitexUnusedProtection _ = manage.KitexUnusedProtection _ = openapi1.KitexUnusedProtection - _ = manage0.KitexUnusedProtection + _ = tool_manage.KitexUnusedProtection ) // unused protection diff --git a/backend/kitex_gen/coze/loop/apis/toolmanageservice/client.go b/backend/kitex_gen/coze/loop/apis/toolmanageservice/client.go index 19916ba88..34c5b6023 100644 --- a/backend/kitex_gen/coze/loop/apis/toolmanageservice/client.go +++ b/backend/kitex_gen/coze/loop/apis/toolmanageservice/client.go @@ -6,18 +6,18 @@ import ( "context" client "github.com/cloudwego/kitex/client" callopt "github.com/cloudwego/kitex/client/callopt" - manage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" + tool_manage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool_manage" ) // Client is designed to provide IDL-compatible methods with call-option parameter for kitex framework. type Client interface { - CreateTool(ctx context.Context, request *manage.CreateToolRequest, callOptions ...callopt.Option) (r *manage.CreateToolResponse, err error) - GetToolDetail(ctx context.Context, request *manage.GetToolDetailRequest, callOptions ...callopt.Option) (r *manage.GetToolDetailResponse, err error) - ListTool(ctx context.Context, request *manage.ListToolRequest, callOptions ...callopt.Option) (r *manage.ListToolResponse, err error) - SaveToolDetail(ctx context.Context, request *manage.SaveToolDetailRequest, callOptions ...callopt.Option) (r *manage.SaveToolDetailResponse, err error) - CommitToolDraft(ctx context.Context, request *manage.CommitToolDraftRequest, callOptions ...callopt.Option) (r *manage.CommitToolDraftResponse, err error) - ListToolCommit(ctx context.Context, request *manage.ListToolCommitRequest, callOptions ...callopt.Option) (r *manage.ListToolCommitResponse, err error) - BatchGetTools(ctx context.Context, request *manage.BatchGetToolsRequest, callOptions ...callopt.Option) (r *manage.BatchGetToolsResponse, err error) + CreateTool(ctx context.Context, request *tool_manage.CreateToolRequest, callOptions ...callopt.Option) (r *tool_manage.CreateToolResponse, err error) + GetToolDetail(ctx context.Context, request *tool_manage.GetToolDetailRequest, callOptions ...callopt.Option) (r *tool_manage.GetToolDetailResponse, err error) + ListTool(ctx context.Context, request *tool_manage.ListToolRequest, callOptions ...callopt.Option) (r *tool_manage.ListToolResponse, err error) + SaveToolDetail(ctx context.Context, request *tool_manage.SaveToolDetailRequest, callOptions ...callopt.Option) (r *tool_manage.SaveToolDetailResponse, err error) + CommitToolDraft(ctx context.Context, request *tool_manage.CommitToolDraftRequest, callOptions ...callopt.Option) (r *tool_manage.CommitToolDraftResponse, err error) + ListToolCommit(ctx context.Context, request *tool_manage.ListToolCommitRequest, callOptions ...callopt.Option) (r *tool_manage.ListToolCommitResponse, err error) + BatchGetTools(ctx context.Context, request *tool_manage.BatchGetToolsRequest, callOptions ...callopt.Option) (r *tool_manage.BatchGetToolsResponse, err error) } // NewClient creates a client for the service defined in IDL. @@ -49,37 +49,37 @@ type kToolManageServiceClient struct { *kClient } -func (p *kToolManageServiceClient) CreateTool(ctx context.Context, request *manage.CreateToolRequest, callOptions ...callopt.Option) (r *manage.CreateToolResponse, err error) { +func (p *kToolManageServiceClient) CreateTool(ctx context.Context, request *tool_manage.CreateToolRequest, callOptions ...callopt.Option) (r *tool_manage.CreateToolResponse, err error) { ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.CreateTool(ctx, request) } -func (p *kToolManageServiceClient) GetToolDetail(ctx context.Context, request *manage.GetToolDetailRequest, callOptions ...callopt.Option) (r *manage.GetToolDetailResponse, err error) { +func (p *kToolManageServiceClient) GetToolDetail(ctx context.Context, request *tool_manage.GetToolDetailRequest, callOptions ...callopt.Option) (r *tool_manage.GetToolDetailResponse, err error) { ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.GetToolDetail(ctx, request) } -func (p *kToolManageServiceClient) ListTool(ctx context.Context, request *manage.ListToolRequest, callOptions ...callopt.Option) (r *manage.ListToolResponse, err error) { +func (p *kToolManageServiceClient) ListTool(ctx context.Context, request *tool_manage.ListToolRequest, callOptions ...callopt.Option) (r *tool_manage.ListToolResponse, err error) { ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.ListTool(ctx, request) } -func (p *kToolManageServiceClient) SaveToolDetail(ctx context.Context, request *manage.SaveToolDetailRequest, callOptions ...callopt.Option) (r *manage.SaveToolDetailResponse, err error) { +func (p *kToolManageServiceClient) SaveToolDetail(ctx context.Context, request *tool_manage.SaveToolDetailRequest, callOptions ...callopt.Option) (r *tool_manage.SaveToolDetailResponse, err error) { ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.SaveToolDetail(ctx, request) } -func (p *kToolManageServiceClient) CommitToolDraft(ctx context.Context, request *manage.CommitToolDraftRequest, callOptions ...callopt.Option) (r *manage.CommitToolDraftResponse, err error) { +func (p *kToolManageServiceClient) CommitToolDraft(ctx context.Context, request *tool_manage.CommitToolDraftRequest, callOptions ...callopt.Option) (r *tool_manage.CommitToolDraftResponse, err error) { ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.CommitToolDraft(ctx, request) } -func (p *kToolManageServiceClient) ListToolCommit(ctx context.Context, request *manage.ListToolCommitRequest, callOptions ...callopt.Option) (r *manage.ListToolCommitResponse, err error) { +func (p *kToolManageServiceClient) ListToolCommit(ctx context.Context, request *tool_manage.ListToolCommitRequest, callOptions ...callopt.Option) (r *tool_manage.ListToolCommitResponse, err error) { ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.ListToolCommit(ctx, request) } -func (p *kToolManageServiceClient) BatchGetTools(ctx context.Context, request *manage.BatchGetToolsRequest, callOptions ...callopt.Option) (r *manage.BatchGetToolsResponse, err error) { +func (p *kToolManageServiceClient) BatchGetTools(ctx context.Context, request *tool_manage.BatchGetToolsRequest, callOptions ...callopt.Option) (r *tool_manage.BatchGetToolsResponse, err error) { ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.BatchGetTools(ctx, request) } diff --git a/backend/kitex_gen/coze/loop/apis/toolmanageservice/toolmanageservice.go b/backend/kitex_gen/coze/loop/apis/toolmanageservice/toolmanageservice.go index 26e2f3bff..7b7da5f89 100644 --- a/backend/kitex_gen/coze/loop/apis/toolmanageservice/toolmanageservice.go +++ b/backend/kitex_gen/coze/loop/apis/toolmanageservice/toolmanageservice.go @@ -8,7 +8,7 @@ import ( client "github.com/cloudwego/kitex/client" kitex "github.com/cloudwego/kitex/pkg/serviceinfo" apis "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/apis" - manage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" + tool_manage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool_manage" ) var errInvalidMessageType = errors.New("invalid message type for service method handler") @@ -97,9 +97,9 @@ func newServiceInfo() *kitex.ServiceInfo { } func createToolHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - realArg := arg.(*manage.ToolManageServiceCreateToolArgs) - realResult := result.(*manage.ToolManageServiceCreateToolResult) - success, err := handler.(manage.ToolManageService).CreateTool(ctx, realArg.Request) + realArg := arg.(*tool_manage.ToolManageServiceCreateToolArgs) + realResult := result.(*tool_manage.ToolManageServiceCreateToolResult) + success, err := handler.(tool_manage.ToolManageService).CreateTool(ctx, realArg.Request) if err != nil { return err } @@ -108,17 +108,17 @@ func createToolHandler(ctx context.Context, handler interface{}, arg, result int } func newToolManageServiceCreateToolArgs() interface{} { - return manage.NewToolManageServiceCreateToolArgs() + return tool_manage.NewToolManageServiceCreateToolArgs() } func newToolManageServiceCreateToolResult() interface{} { - return manage.NewToolManageServiceCreateToolResult() + return tool_manage.NewToolManageServiceCreateToolResult() } func getToolDetailHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - realArg := arg.(*manage.ToolManageServiceGetToolDetailArgs) - realResult := result.(*manage.ToolManageServiceGetToolDetailResult) - success, err := handler.(manage.ToolManageService).GetToolDetail(ctx, realArg.Request) + realArg := arg.(*tool_manage.ToolManageServiceGetToolDetailArgs) + realResult := result.(*tool_manage.ToolManageServiceGetToolDetailResult) + success, err := handler.(tool_manage.ToolManageService).GetToolDetail(ctx, realArg.Request) if err != nil { return err } @@ -127,17 +127,17 @@ func getToolDetailHandler(ctx context.Context, handler interface{}, arg, result } func newToolManageServiceGetToolDetailArgs() interface{} { - return manage.NewToolManageServiceGetToolDetailArgs() + return tool_manage.NewToolManageServiceGetToolDetailArgs() } func newToolManageServiceGetToolDetailResult() interface{} { - return manage.NewToolManageServiceGetToolDetailResult() + return tool_manage.NewToolManageServiceGetToolDetailResult() } func listToolHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - realArg := arg.(*manage.ToolManageServiceListToolArgs) - realResult := result.(*manage.ToolManageServiceListToolResult) - success, err := handler.(manage.ToolManageService).ListTool(ctx, realArg.Request) + realArg := arg.(*tool_manage.ToolManageServiceListToolArgs) + realResult := result.(*tool_manage.ToolManageServiceListToolResult) + success, err := handler.(tool_manage.ToolManageService).ListTool(ctx, realArg.Request) if err != nil { return err } @@ -146,17 +146,17 @@ func listToolHandler(ctx context.Context, handler interface{}, arg, result inter } func newToolManageServiceListToolArgs() interface{} { - return manage.NewToolManageServiceListToolArgs() + return tool_manage.NewToolManageServiceListToolArgs() } func newToolManageServiceListToolResult() interface{} { - return manage.NewToolManageServiceListToolResult() + return tool_manage.NewToolManageServiceListToolResult() } func saveToolDetailHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - realArg := arg.(*manage.ToolManageServiceSaveToolDetailArgs) - realResult := result.(*manage.ToolManageServiceSaveToolDetailResult) - success, err := handler.(manage.ToolManageService).SaveToolDetail(ctx, realArg.Request) + realArg := arg.(*tool_manage.ToolManageServiceSaveToolDetailArgs) + realResult := result.(*tool_manage.ToolManageServiceSaveToolDetailResult) + success, err := handler.(tool_manage.ToolManageService).SaveToolDetail(ctx, realArg.Request) if err != nil { return err } @@ -165,17 +165,17 @@ func saveToolDetailHandler(ctx context.Context, handler interface{}, arg, result } func newToolManageServiceSaveToolDetailArgs() interface{} { - return manage.NewToolManageServiceSaveToolDetailArgs() + return tool_manage.NewToolManageServiceSaveToolDetailArgs() } func newToolManageServiceSaveToolDetailResult() interface{} { - return manage.NewToolManageServiceSaveToolDetailResult() + return tool_manage.NewToolManageServiceSaveToolDetailResult() } func commitToolDraftHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - realArg := arg.(*manage.ToolManageServiceCommitToolDraftArgs) - realResult := result.(*manage.ToolManageServiceCommitToolDraftResult) - success, err := handler.(manage.ToolManageService).CommitToolDraft(ctx, realArg.Request) + realArg := arg.(*tool_manage.ToolManageServiceCommitToolDraftArgs) + realResult := result.(*tool_manage.ToolManageServiceCommitToolDraftResult) + success, err := handler.(tool_manage.ToolManageService).CommitToolDraft(ctx, realArg.Request) if err != nil { return err } @@ -184,17 +184,17 @@ func commitToolDraftHandler(ctx context.Context, handler interface{}, arg, resul } func newToolManageServiceCommitToolDraftArgs() interface{} { - return manage.NewToolManageServiceCommitToolDraftArgs() + return tool_manage.NewToolManageServiceCommitToolDraftArgs() } func newToolManageServiceCommitToolDraftResult() interface{} { - return manage.NewToolManageServiceCommitToolDraftResult() + return tool_manage.NewToolManageServiceCommitToolDraftResult() } func listToolCommitHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - realArg := arg.(*manage.ToolManageServiceListToolCommitArgs) - realResult := result.(*manage.ToolManageServiceListToolCommitResult) - success, err := handler.(manage.ToolManageService).ListToolCommit(ctx, realArg.Request) + realArg := arg.(*tool_manage.ToolManageServiceListToolCommitArgs) + realResult := result.(*tool_manage.ToolManageServiceListToolCommitResult) + success, err := handler.(tool_manage.ToolManageService).ListToolCommit(ctx, realArg.Request) if err != nil { return err } @@ -203,17 +203,17 @@ func listToolCommitHandler(ctx context.Context, handler interface{}, arg, result } func newToolManageServiceListToolCommitArgs() interface{} { - return manage.NewToolManageServiceListToolCommitArgs() + return tool_manage.NewToolManageServiceListToolCommitArgs() } func newToolManageServiceListToolCommitResult() interface{} { - return manage.NewToolManageServiceListToolCommitResult() + return tool_manage.NewToolManageServiceListToolCommitResult() } func batchGetToolsHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - realArg := arg.(*manage.ToolManageServiceBatchGetToolsArgs) - realResult := result.(*manage.ToolManageServiceBatchGetToolsResult) - success, err := handler.(manage.ToolManageService).BatchGetTools(ctx, realArg.Request) + realArg := arg.(*tool_manage.ToolManageServiceBatchGetToolsArgs) + realResult := result.(*tool_manage.ToolManageServiceBatchGetToolsResult) + success, err := handler.(tool_manage.ToolManageService).BatchGetTools(ctx, realArg.Request) if err != nil { return err } @@ -222,11 +222,11 @@ func batchGetToolsHandler(ctx context.Context, handler interface{}, arg, result } func newToolManageServiceBatchGetToolsArgs() interface{} { - return manage.NewToolManageServiceBatchGetToolsArgs() + return tool_manage.NewToolManageServiceBatchGetToolsArgs() } func newToolManageServiceBatchGetToolsResult() interface{} { - return manage.NewToolManageServiceBatchGetToolsResult() + return tool_manage.NewToolManageServiceBatchGetToolsResult() } type kClient struct { @@ -241,70 +241,70 @@ func newServiceClient(c client.Client) *kClient { } } -func (p *kClient) CreateTool(ctx context.Context, request *manage.CreateToolRequest) (r *manage.CreateToolResponse, err error) { - var _args manage.ToolManageServiceCreateToolArgs +func (p *kClient) CreateTool(ctx context.Context, request *tool_manage.CreateToolRequest) (r *tool_manage.CreateToolResponse, err error) { + var _args tool_manage.ToolManageServiceCreateToolArgs _args.Request = request - var _result manage.ToolManageServiceCreateToolResult + var _result tool_manage.ToolManageServiceCreateToolResult if err = p.c.Call(ctx, "CreateTool", &_args, &_result); err != nil { return } return _result.GetSuccess(), nil } -func (p *kClient) GetToolDetail(ctx context.Context, request *manage.GetToolDetailRequest) (r *manage.GetToolDetailResponse, err error) { - var _args manage.ToolManageServiceGetToolDetailArgs +func (p *kClient) GetToolDetail(ctx context.Context, request *tool_manage.GetToolDetailRequest) (r *tool_manage.GetToolDetailResponse, err error) { + var _args tool_manage.ToolManageServiceGetToolDetailArgs _args.Request = request - var _result manage.ToolManageServiceGetToolDetailResult + var _result tool_manage.ToolManageServiceGetToolDetailResult if err = p.c.Call(ctx, "GetToolDetail", &_args, &_result); err != nil { return } return _result.GetSuccess(), nil } -func (p *kClient) ListTool(ctx context.Context, request *manage.ListToolRequest) (r *manage.ListToolResponse, err error) { - var _args manage.ToolManageServiceListToolArgs +func (p *kClient) ListTool(ctx context.Context, request *tool_manage.ListToolRequest) (r *tool_manage.ListToolResponse, err error) { + var _args tool_manage.ToolManageServiceListToolArgs _args.Request = request - var _result manage.ToolManageServiceListToolResult + var _result tool_manage.ToolManageServiceListToolResult if err = p.c.Call(ctx, "ListTool", &_args, &_result); err != nil { return } return _result.GetSuccess(), nil } -func (p *kClient) SaveToolDetail(ctx context.Context, request *manage.SaveToolDetailRequest) (r *manage.SaveToolDetailResponse, err error) { - var _args manage.ToolManageServiceSaveToolDetailArgs +func (p *kClient) SaveToolDetail(ctx context.Context, request *tool_manage.SaveToolDetailRequest) (r *tool_manage.SaveToolDetailResponse, err error) { + var _args tool_manage.ToolManageServiceSaveToolDetailArgs _args.Request = request - var _result manage.ToolManageServiceSaveToolDetailResult + var _result tool_manage.ToolManageServiceSaveToolDetailResult if err = p.c.Call(ctx, "SaveToolDetail", &_args, &_result); err != nil { return } return _result.GetSuccess(), nil } -func (p *kClient) CommitToolDraft(ctx context.Context, request *manage.CommitToolDraftRequest) (r *manage.CommitToolDraftResponse, err error) { - var _args manage.ToolManageServiceCommitToolDraftArgs +func (p *kClient) CommitToolDraft(ctx context.Context, request *tool_manage.CommitToolDraftRequest) (r *tool_manage.CommitToolDraftResponse, err error) { + var _args tool_manage.ToolManageServiceCommitToolDraftArgs _args.Request = request - var _result manage.ToolManageServiceCommitToolDraftResult + var _result tool_manage.ToolManageServiceCommitToolDraftResult if err = p.c.Call(ctx, "CommitToolDraft", &_args, &_result); err != nil { return } return _result.GetSuccess(), nil } -func (p *kClient) ListToolCommit(ctx context.Context, request *manage.ListToolCommitRequest) (r *manage.ListToolCommitResponse, err error) { - var _args manage.ToolManageServiceListToolCommitArgs +func (p *kClient) ListToolCommit(ctx context.Context, request *tool_manage.ListToolCommitRequest) (r *tool_manage.ListToolCommitResponse, err error) { + var _args tool_manage.ToolManageServiceListToolCommitArgs _args.Request = request - var _result manage.ToolManageServiceListToolCommitResult + var _result tool_manage.ToolManageServiceListToolCommitResult if err = p.c.Call(ctx, "ListToolCommit", &_args, &_result); err != nil { return } return _result.GetSuccess(), nil } -func (p *kClient) BatchGetTools(ctx context.Context, request *manage.BatchGetToolsRequest) (r *manage.BatchGetToolsResponse, err error) { - var _args manage.ToolManageServiceBatchGetToolsArgs +func (p *kClient) BatchGetTools(ctx context.Context, request *tool_manage.BatchGetToolsRequest) (r *tool_manage.BatchGetToolsResponse, err error) { + var _args tool_manage.ToolManageServiceBatchGetToolsArgs _args.Request = request - var _result manage.ToolManageServiceBatchGetToolsResult + var _result tool_manage.ToolManageServiceBatchGetToolsResult if err = p.c.Call(ctx, "BatchGetTools", &_args, &_result); err != nil { return } diff --git a/backend/kitex_gen/coze/loop/prompt/coze.loop.prompt.go b/backend/kitex_gen/coze/loop/prompt/coze.loop.prompt.go index bed5d4d7c..98b1b908a 100644 --- a/backend/kitex_gen/coze/loop/prompt/coze.loop.prompt.go +++ b/backend/kitex_gen/coze/loop/prompt/coze.loop.prompt.go @@ -8,7 +8,7 @@ import ( "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/execute" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/manage" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/openapi" - manage0 "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" + "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool_manage" ) type PromptManageService interface { @@ -38,28 +38,28 @@ func NewPromptManageServiceClient(c thrift.TClient) *PromptManageServiceClient { } type ToolManageService interface { - manage0.ToolManageService + tool_manage.ToolManageService } type ToolManageServiceClient struct { - *manage0.ToolManageServiceClient + *tool_manage.ToolManageServiceClient } func NewToolManageServiceClientFactory(t thrift.TTransport, f thrift.TProtocolFactory) *ToolManageServiceClient { return &ToolManageServiceClient{ - ToolManageServiceClient: manage0.NewToolManageServiceClientFactory(t, f), + ToolManageServiceClient: tool_manage.NewToolManageServiceClientFactory(t, f), } } func NewToolManageServiceClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *ToolManageServiceClient { return &ToolManageServiceClient{ - ToolManageServiceClient: manage0.NewToolManageServiceClientProtocol(t, iprot, oprot), + ToolManageServiceClient: tool_manage.NewToolManageServiceClientProtocol(t, iprot, oprot), } } func NewToolManageServiceClient(c thrift.TClient) *ToolManageServiceClient { return &ToolManageServiceClient{ - ToolManageServiceClient: manage0.NewToolManageServiceClient(c), + ToolManageServiceClient: tool_manage.NewToolManageServiceClient(c), } } @@ -151,11 +151,11 @@ func NewPromptManageServiceProcessor(handler PromptManageService) *PromptManageS } type ToolManageServiceProcessor struct { - *manage0.ToolManageServiceProcessor + *tool_manage.ToolManageServiceProcessor } func NewToolManageServiceProcessor(handler ToolManageService) *ToolManageServiceProcessor { - self := &ToolManageServiceProcessor{manage0.NewToolManageServiceProcessor(handler)} + self := &ToolManageServiceProcessor{tool_manage.NewToolManageServiceProcessor(handler)} return self } diff --git a/backend/kitex_gen/coze/loop/prompt/k-coze.loop.prompt.go b/backend/kitex_gen/coze/loop/prompt/k-coze.loop.prompt.go index 23bee6fdb..85d6a2bf3 100644 --- a/backend/kitex_gen/coze/loop/prompt/k-coze.loop.prompt.go +++ b/backend/kitex_gen/coze/loop/prompt/k-coze.loop.prompt.go @@ -14,7 +14,7 @@ import ( "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/execute" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/manage" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/openapi" - manage0 "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" + "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool_manage" ) var ( @@ -22,7 +22,7 @@ var ( _ = execute.KitexUnusedProtection _ = manage.KitexUnusedProtection _ = openapi.KitexUnusedProtection - _ = manage0.KitexUnusedProtection + _ = tool_manage.KitexUnusedProtection ) // unused protection diff --git a/backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool_manage.go b/backend/kitex_gen/coze/loop/prompt/tool_manage/coze.loop.prompt.tool_manage.go similarity index 99% rename from backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool_manage.go rename to backend/kitex_gen/coze/loop/prompt/tool_manage/coze.loop.prompt.tool_manage.go index 105da993b..fff65d9cf 100644 --- a/backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool_manage.go +++ b/backend/kitex_gen/coze/loop/prompt/tool_manage/coze.loop.prompt.tool_manage.go @@ -1,6 +1,6 @@ // Code generated by thriftgo (0.4.1). DO NOT EDIT. -package manage +package tool_manage import ( "context" diff --git a/backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool_manage_validator.go b/backend/kitex_gen/coze/loop/prompt/tool_manage/coze.loop.prompt.tool_manage_validator.go similarity index 99% rename from backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool_manage_validator.go rename to backend/kitex_gen/coze/loop/prompt/tool_manage/coze.loop.prompt.tool_manage_validator.go index 8fd97515b..3a11f6ef1 100644 --- a/backend/kitex_gen/coze/loop/prompt/tool/manage/coze.loop.prompt.tool_manage_validator.go +++ b/backend/kitex_gen/coze/loop/prompt/tool_manage/coze.loop.prompt.tool_manage_validator.go @@ -1,6 +1,6 @@ // Code generated by Validator v0.2.6. DO NOT EDIT. -package manage +package tool_manage import ( "bytes" diff --git a/backend/kitex_gen/coze/loop/prompt/tool/manage/k-consts.go b/backend/kitex_gen/coze/loop/prompt/tool_manage/k-consts.go similarity index 85% rename from backend/kitex_gen/coze/loop/prompt/tool/manage/k-consts.go rename to backend/kitex_gen/coze/loop/prompt/tool_manage/k-consts.go index 9fd241a66..3a9f0ff37 100644 --- a/backend/kitex_gen/coze/loop/prompt/tool/manage/k-consts.go +++ b/backend/kitex_gen/coze/loop/prompt/tool_manage/k-consts.go @@ -1,4 +1,4 @@ -package manage +package tool_manage // KitexUnusedProtection is used to prevent 'imported and not used' error. var KitexUnusedProtection = struct{}{} diff --git a/backend/kitex_gen/coze/loop/prompt/tool/manage/k-coze.loop.prompt.tool_manage.go b/backend/kitex_gen/coze/loop/prompt/tool_manage/k-coze.loop.prompt.tool_manage.go similarity index 99% rename from backend/kitex_gen/coze/loop/prompt/tool/manage/k-coze.loop.prompt.tool_manage.go rename to backend/kitex_gen/coze/loop/prompt/tool_manage/k-coze.loop.prompt.tool_manage.go index 4123658a2..8ee2be793 100644 --- a/backend/kitex_gen/coze/loop/prompt/tool/manage/k-coze.loop.prompt.tool_manage.go +++ b/backend/kitex_gen/coze/loop/prompt/tool_manage/k-coze.loop.prompt.tool_manage.go @@ -1,6 +1,6 @@ // Code generated by Kitex v0.13.1. DO NOT EDIT. -package manage +package tool_manage import ( "bytes" diff --git a/backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/client.go b/backend/kitex_gen/coze/loop/prompt/tool_manage/toolmanageservice/client.go similarity index 51% rename from backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/client.go rename to backend/kitex_gen/coze/loop/prompt/tool_manage/toolmanageservice/client.go index 19916ba88..34c5b6023 100644 --- a/backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/client.go +++ b/backend/kitex_gen/coze/loop/prompt/tool_manage/toolmanageservice/client.go @@ -6,18 +6,18 @@ import ( "context" client "github.com/cloudwego/kitex/client" callopt "github.com/cloudwego/kitex/client/callopt" - manage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" + tool_manage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool_manage" ) // Client is designed to provide IDL-compatible methods with call-option parameter for kitex framework. type Client interface { - CreateTool(ctx context.Context, request *manage.CreateToolRequest, callOptions ...callopt.Option) (r *manage.CreateToolResponse, err error) - GetToolDetail(ctx context.Context, request *manage.GetToolDetailRequest, callOptions ...callopt.Option) (r *manage.GetToolDetailResponse, err error) - ListTool(ctx context.Context, request *manage.ListToolRequest, callOptions ...callopt.Option) (r *manage.ListToolResponse, err error) - SaveToolDetail(ctx context.Context, request *manage.SaveToolDetailRequest, callOptions ...callopt.Option) (r *manage.SaveToolDetailResponse, err error) - CommitToolDraft(ctx context.Context, request *manage.CommitToolDraftRequest, callOptions ...callopt.Option) (r *manage.CommitToolDraftResponse, err error) - ListToolCommit(ctx context.Context, request *manage.ListToolCommitRequest, callOptions ...callopt.Option) (r *manage.ListToolCommitResponse, err error) - BatchGetTools(ctx context.Context, request *manage.BatchGetToolsRequest, callOptions ...callopt.Option) (r *manage.BatchGetToolsResponse, err error) + CreateTool(ctx context.Context, request *tool_manage.CreateToolRequest, callOptions ...callopt.Option) (r *tool_manage.CreateToolResponse, err error) + GetToolDetail(ctx context.Context, request *tool_manage.GetToolDetailRequest, callOptions ...callopt.Option) (r *tool_manage.GetToolDetailResponse, err error) + ListTool(ctx context.Context, request *tool_manage.ListToolRequest, callOptions ...callopt.Option) (r *tool_manage.ListToolResponse, err error) + SaveToolDetail(ctx context.Context, request *tool_manage.SaveToolDetailRequest, callOptions ...callopt.Option) (r *tool_manage.SaveToolDetailResponse, err error) + CommitToolDraft(ctx context.Context, request *tool_manage.CommitToolDraftRequest, callOptions ...callopt.Option) (r *tool_manage.CommitToolDraftResponse, err error) + ListToolCommit(ctx context.Context, request *tool_manage.ListToolCommitRequest, callOptions ...callopt.Option) (r *tool_manage.ListToolCommitResponse, err error) + BatchGetTools(ctx context.Context, request *tool_manage.BatchGetToolsRequest, callOptions ...callopt.Option) (r *tool_manage.BatchGetToolsResponse, err error) } // NewClient creates a client for the service defined in IDL. @@ -49,37 +49,37 @@ type kToolManageServiceClient struct { *kClient } -func (p *kToolManageServiceClient) CreateTool(ctx context.Context, request *manage.CreateToolRequest, callOptions ...callopt.Option) (r *manage.CreateToolResponse, err error) { +func (p *kToolManageServiceClient) CreateTool(ctx context.Context, request *tool_manage.CreateToolRequest, callOptions ...callopt.Option) (r *tool_manage.CreateToolResponse, err error) { ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.CreateTool(ctx, request) } -func (p *kToolManageServiceClient) GetToolDetail(ctx context.Context, request *manage.GetToolDetailRequest, callOptions ...callopt.Option) (r *manage.GetToolDetailResponse, err error) { +func (p *kToolManageServiceClient) GetToolDetail(ctx context.Context, request *tool_manage.GetToolDetailRequest, callOptions ...callopt.Option) (r *tool_manage.GetToolDetailResponse, err error) { ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.GetToolDetail(ctx, request) } -func (p *kToolManageServiceClient) ListTool(ctx context.Context, request *manage.ListToolRequest, callOptions ...callopt.Option) (r *manage.ListToolResponse, err error) { +func (p *kToolManageServiceClient) ListTool(ctx context.Context, request *tool_manage.ListToolRequest, callOptions ...callopt.Option) (r *tool_manage.ListToolResponse, err error) { ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.ListTool(ctx, request) } -func (p *kToolManageServiceClient) SaveToolDetail(ctx context.Context, request *manage.SaveToolDetailRequest, callOptions ...callopt.Option) (r *manage.SaveToolDetailResponse, err error) { +func (p *kToolManageServiceClient) SaveToolDetail(ctx context.Context, request *tool_manage.SaveToolDetailRequest, callOptions ...callopt.Option) (r *tool_manage.SaveToolDetailResponse, err error) { ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.SaveToolDetail(ctx, request) } -func (p *kToolManageServiceClient) CommitToolDraft(ctx context.Context, request *manage.CommitToolDraftRequest, callOptions ...callopt.Option) (r *manage.CommitToolDraftResponse, err error) { +func (p *kToolManageServiceClient) CommitToolDraft(ctx context.Context, request *tool_manage.CommitToolDraftRequest, callOptions ...callopt.Option) (r *tool_manage.CommitToolDraftResponse, err error) { ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.CommitToolDraft(ctx, request) } -func (p *kToolManageServiceClient) ListToolCommit(ctx context.Context, request *manage.ListToolCommitRequest, callOptions ...callopt.Option) (r *manage.ListToolCommitResponse, err error) { +func (p *kToolManageServiceClient) ListToolCommit(ctx context.Context, request *tool_manage.ListToolCommitRequest, callOptions ...callopt.Option) (r *tool_manage.ListToolCommitResponse, err error) { ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.ListToolCommit(ctx, request) } -func (p *kToolManageServiceClient) BatchGetTools(ctx context.Context, request *manage.BatchGetToolsRequest, callOptions ...callopt.Option) (r *manage.BatchGetToolsResponse, err error) { +func (p *kToolManageServiceClient) BatchGetTools(ctx context.Context, request *tool_manage.BatchGetToolsRequest, callOptions ...callopt.Option) (r *tool_manage.BatchGetToolsResponse, err error) { ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.BatchGetTools(ctx, request) } diff --git a/backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/server.go b/backend/kitex_gen/coze/loop/prompt/tool_manage/toolmanageservice/server.go similarity index 64% rename from backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/server.go rename to backend/kitex_gen/coze/loop/prompt/tool_manage/toolmanageservice/server.go index 7fed1bd14..ae70347da 100644 --- a/backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/server.go +++ b/backend/kitex_gen/coze/loop/prompt/tool_manage/toolmanageservice/server.go @@ -3,11 +3,11 @@ package toolmanageservice import ( server "github.com/cloudwego/kitex/server" - manage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" + tool_manage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool_manage" ) // NewServer creates a server.Server with the given handler and options. -func NewServer(handler manage.ToolManageService, opts ...server.Option) server.Server { +func NewServer(handler tool_manage.ToolManageService, opts ...server.Option) server.Server { var options []server.Option options = append(options, opts...) @@ -20,6 +20,6 @@ func NewServer(handler manage.ToolManageService, opts ...server.Option) server.S return svr } -func RegisterService(svr server.Server, handler manage.ToolManageService, opts ...server.RegisterOption) error { +func RegisterService(svr server.Server, handler tool_manage.ToolManageService, opts ...server.RegisterOption) error { return svr.RegisterService(serviceInfo(), handler, opts...) } diff --git a/backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/toolmanageservice.go b/backend/kitex_gen/coze/loop/prompt/tool_manage/toolmanageservice/toolmanageservice.go similarity index 57% rename from backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/toolmanageservice.go rename to backend/kitex_gen/coze/loop/prompt/tool_manage/toolmanageservice/toolmanageservice.go index 31f178824..d52fe0e06 100644 --- a/backend/kitex_gen/coze/loop/prompt/tool/manage/toolmanageservice/toolmanageservice.go +++ b/backend/kitex_gen/coze/loop/prompt/tool_manage/toolmanageservice/toolmanageservice.go @@ -7,7 +7,7 @@ import ( "errors" client "github.com/cloudwego/kitex/client" kitex "github.com/cloudwego/kitex/pkg/serviceinfo" - manage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" + tool_manage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool_manage" ) var errInvalidMessageType = errors.New("invalid message type for service method handler") @@ -80,9 +80,9 @@ func NewServiceInfo() *kitex.ServiceInfo { func newServiceInfo() *kitex.ServiceInfo { serviceName := "ToolManageService" - handlerType := (*manage.ToolManageService)(nil) + handlerType := (*tool_manage.ToolManageService)(nil) extra := map[string]interface{}{ - "PackageName": "manage", + "PackageName": "tool_manage", } svcInfo := &kitex.ServiceInfo{ ServiceName: serviceName, @@ -96,9 +96,9 @@ func newServiceInfo() *kitex.ServiceInfo { } func createToolHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - realArg := arg.(*manage.ToolManageServiceCreateToolArgs) - realResult := result.(*manage.ToolManageServiceCreateToolResult) - success, err := handler.(manage.ToolManageService).CreateTool(ctx, realArg.Request) + realArg := arg.(*tool_manage.ToolManageServiceCreateToolArgs) + realResult := result.(*tool_manage.ToolManageServiceCreateToolResult) + success, err := handler.(tool_manage.ToolManageService).CreateTool(ctx, realArg.Request) if err != nil { return err } @@ -107,17 +107,17 @@ func createToolHandler(ctx context.Context, handler interface{}, arg, result int } func newToolManageServiceCreateToolArgs() interface{} { - return manage.NewToolManageServiceCreateToolArgs() + return tool_manage.NewToolManageServiceCreateToolArgs() } func newToolManageServiceCreateToolResult() interface{} { - return manage.NewToolManageServiceCreateToolResult() + return tool_manage.NewToolManageServiceCreateToolResult() } func getToolDetailHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - realArg := arg.(*manage.ToolManageServiceGetToolDetailArgs) - realResult := result.(*manage.ToolManageServiceGetToolDetailResult) - success, err := handler.(manage.ToolManageService).GetToolDetail(ctx, realArg.Request) + realArg := arg.(*tool_manage.ToolManageServiceGetToolDetailArgs) + realResult := result.(*tool_manage.ToolManageServiceGetToolDetailResult) + success, err := handler.(tool_manage.ToolManageService).GetToolDetail(ctx, realArg.Request) if err != nil { return err } @@ -126,17 +126,17 @@ func getToolDetailHandler(ctx context.Context, handler interface{}, arg, result } func newToolManageServiceGetToolDetailArgs() interface{} { - return manage.NewToolManageServiceGetToolDetailArgs() + return tool_manage.NewToolManageServiceGetToolDetailArgs() } func newToolManageServiceGetToolDetailResult() interface{} { - return manage.NewToolManageServiceGetToolDetailResult() + return tool_manage.NewToolManageServiceGetToolDetailResult() } func listToolHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - realArg := arg.(*manage.ToolManageServiceListToolArgs) - realResult := result.(*manage.ToolManageServiceListToolResult) - success, err := handler.(manage.ToolManageService).ListTool(ctx, realArg.Request) + realArg := arg.(*tool_manage.ToolManageServiceListToolArgs) + realResult := result.(*tool_manage.ToolManageServiceListToolResult) + success, err := handler.(tool_manage.ToolManageService).ListTool(ctx, realArg.Request) if err != nil { return err } @@ -145,17 +145,17 @@ func listToolHandler(ctx context.Context, handler interface{}, arg, result inter } func newToolManageServiceListToolArgs() interface{} { - return manage.NewToolManageServiceListToolArgs() + return tool_manage.NewToolManageServiceListToolArgs() } func newToolManageServiceListToolResult() interface{} { - return manage.NewToolManageServiceListToolResult() + return tool_manage.NewToolManageServiceListToolResult() } func saveToolDetailHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - realArg := arg.(*manage.ToolManageServiceSaveToolDetailArgs) - realResult := result.(*manage.ToolManageServiceSaveToolDetailResult) - success, err := handler.(manage.ToolManageService).SaveToolDetail(ctx, realArg.Request) + realArg := arg.(*tool_manage.ToolManageServiceSaveToolDetailArgs) + realResult := result.(*tool_manage.ToolManageServiceSaveToolDetailResult) + success, err := handler.(tool_manage.ToolManageService).SaveToolDetail(ctx, realArg.Request) if err != nil { return err } @@ -164,17 +164,17 @@ func saveToolDetailHandler(ctx context.Context, handler interface{}, arg, result } func newToolManageServiceSaveToolDetailArgs() interface{} { - return manage.NewToolManageServiceSaveToolDetailArgs() + return tool_manage.NewToolManageServiceSaveToolDetailArgs() } func newToolManageServiceSaveToolDetailResult() interface{} { - return manage.NewToolManageServiceSaveToolDetailResult() + return tool_manage.NewToolManageServiceSaveToolDetailResult() } func commitToolDraftHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - realArg := arg.(*manage.ToolManageServiceCommitToolDraftArgs) - realResult := result.(*manage.ToolManageServiceCommitToolDraftResult) - success, err := handler.(manage.ToolManageService).CommitToolDraft(ctx, realArg.Request) + realArg := arg.(*tool_manage.ToolManageServiceCommitToolDraftArgs) + realResult := result.(*tool_manage.ToolManageServiceCommitToolDraftResult) + success, err := handler.(tool_manage.ToolManageService).CommitToolDraft(ctx, realArg.Request) if err != nil { return err } @@ -183,17 +183,17 @@ func commitToolDraftHandler(ctx context.Context, handler interface{}, arg, resul } func newToolManageServiceCommitToolDraftArgs() interface{} { - return manage.NewToolManageServiceCommitToolDraftArgs() + return tool_manage.NewToolManageServiceCommitToolDraftArgs() } func newToolManageServiceCommitToolDraftResult() interface{} { - return manage.NewToolManageServiceCommitToolDraftResult() + return tool_manage.NewToolManageServiceCommitToolDraftResult() } func listToolCommitHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - realArg := arg.(*manage.ToolManageServiceListToolCommitArgs) - realResult := result.(*manage.ToolManageServiceListToolCommitResult) - success, err := handler.(manage.ToolManageService).ListToolCommit(ctx, realArg.Request) + realArg := arg.(*tool_manage.ToolManageServiceListToolCommitArgs) + realResult := result.(*tool_manage.ToolManageServiceListToolCommitResult) + success, err := handler.(tool_manage.ToolManageService).ListToolCommit(ctx, realArg.Request) if err != nil { return err } @@ -202,17 +202,17 @@ func listToolCommitHandler(ctx context.Context, handler interface{}, arg, result } func newToolManageServiceListToolCommitArgs() interface{} { - return manage.NewToolManageServiceListToolCommitArgs() + return tool_manage.NewToolManageServiceListToolCommitArgs() } func newToolManageServiceListToolCommitResult() interface{} { - return manage.NewToolManageServiceListToolCommitResult() + return tool_manage.NewToolManageServiceListToolCommitResult() } func batchGetToolsHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - realArg := arg.(*manage.ToolManageServiceBatchGetToolsArgs) - realResult := result.(*manage.ToolManageServiceBatchGetToolsResult) - success, err := handler.(manage.ToolManageService).BatchGetTools(ctx, realArg.Request) + realArg := arg.(*tool_manage.ToolManageServiceBatchGetToolsArgs) + realResult := result.(*tool_manage.ToolManageServiceBatchGetToolsResult) + success, err := handler.(tool_manage.ToolManageService).BatchGetTools(ctx, realArg.Request) if err != nil { return err } @@ -221,11 +221,11 @@ func batchGetToolsHandler(ctx context.Context, handler interface{}, arg, result } func newToolManageServiceBatchGetToolsArgs() interface{} { - return manage.NewToolManageServiceBatchGetToolsArgs() + return tool_manage.NewToolManageServiceBatchGetToolsArgs() } func newToolManageServiceBatchGetToolsResult() interface{} { - return manage.NewToolManageServiceBatchGetToolsResult() + return tool_manage.NewToolManageServiceBatchGetToolsResult() } type kClient struct { @@ -240,70 +240,70 @@ func newServiceClient(c client.Client) *kClient { } } -func (p *kClient) CreateTool(ctx context.Context, request *manage.CreateToolRequest) (r *manage.CreateToolResponse, err error) { - var _args manage.ToolManageServiceCreateToolArgs +func (p *kClient) CreateTool(ctx context.Context, request *tool_manage.CreateToolRequest) (r *tool_manage.CreateToolResponse, err error) { + var _args tool_manage.ToolManageServiceCreateToolArgs _args.Request = request - var _result manage.ToolManageServiceCreateToolResult + var _result tool_manage.ToolManageServiceCreateToolResult if err = p.c.Call(ctx, "CreateTool", &_args, &_result); err != nil { return } return _result.GetSuccess(), nil } -func (p *kClient) GetToolDetail(ctx context.Context, request *manage.GetToolDetailRequest) (r *manage.GetToolDetailResponse, err error) { - var _args manage.ToolManageServiceGetToolDetailArgs +func (p *kClient) GetToolDetail(ctx context.Context, request *tool_manage.GetToolDetailRequest) (r *tool_manage.GetToolDetailResponse, err error) { + var _args tool_manage.ToolManageServiceGetToolDetailArgs _args.Request = request - var _result manage.ToolManageServiceGetToolDetailResult + var _result tool_manage.ToolManageServiceGetToolDetailResult if err = p.c.Call(ctx, "GetToolDetail", &_args, &_result); err != nil { return } return _result.GetSuccess(), nil } -func (p *kClient) ListTool(ctx context.Context, request *manage.ListToolRequest) (r *manage.ListToolResponse, err error) { - var _args manage.ToolManageServiceListToolArgs +func (p *kClient) ListTool(ctx context.Context, request *tool_manage.ListToolRequest) (r *tool_manage.ListToolResponse, err error) { + var _args tool_manage.ToolManageServiceListToolArgs _args.Request = request - var _result manage.ToolManageServiceListToolResult + var _result tool_manage.ToolManageServiceListToolResult if err = p.c.Call(ctx, "ListTool", &_args, &_result); err != nil { return } return _result.GetSuccess(), nil } -func (p *kClient) SaveToolDetail(ctx context.Context, request *manage.SaveToolDetailRequest) (r *manage.SaveToolDetailResponse, err error) { - var _args manage.ToolManageServiceSaveToolDetailArgs +func (p *kClient) SaveToolDetail(ctx context.Context, request *tool_manage.SaveToolDetailRequest) (r *tool_manage.SaveToolDetailResponse, err error) { + var _args tool_manage.ToolManageServiceSaveToolDetailArgs _args.Request = request - var _result manage.ToolManageServiceSaveToolDetailResult + var _result tool_manage.ToolManageServiceSaveToolDetailResult if err = p.c.Call(ctx, "SaveToolDetail", &_args, &_result); err != nil { return } return _result.GetSuccess(), nil } -func (p *kClient) CommitToolDraft(ctx context.Context, request *manage.CommitToolDraftRequest) (r *manage.CommitToolDraftResponse, err error) { - var _args manage.ToolManageServiceCommitToolDraftArgs +func (p *kClient) CommitToolDraft(ctx context.Context, request *tool_manage.CommitToolDraftRequest) (r *tool_manage.CommitToolDraftResponse, err error) { + var _args tool_manage.ToolManageServiceCommitToolDraftArgs _args.Request = request - var _result manage.ToolManageServiceCommitToolDraftResult + var _result tool_manage.ToolManageServiceCommitToolDraftResult if err = p.c.Call(ctx, "CommitToolDraft", &_args, &_result); err != nil { return } return _result.GetSuccess(), nil } -func (p *kClient) ListToolCommit(ctx context.Context, request *manage.ListToolCommitRequest) (r *manage.ListToolCommitResponse, err error) { - var _args manage.ToolManageServiceListToolCommitArgs +func (p *kClient) ListToolCommit(ctx context.Context, request *tool_manage.ListToolCommitRequest) (r *tool_manage.ListToolCommitResponse, err error) { + var _args tool_manage.ToolManageServiceListToolCommitArgs _args.Request = request - var _result manage.ToolManageServiceListToolCommitResult + var _result tool_manage.ToolManageServiceListToolCommitResult if err = p.c.Call(ctx, "ListToolCommit", &_args, &_result); err != nil { return } return _result.GetSuccess(), nil } -func (p *kClient) BatchGetTools(ctx context.Context, request *manage.BatchGetToolsRequest) (r *manage.BatchGetToolsResponse, err error) { - var _args manage.ToolManageServiceBatchGetToolsArgs +func (p *kClient) BatchGetTools(ctx context.Context, request *tool_manage.BatchGetToolsRequest) (r *tool_manage.BatchGetToolsResponse, err error) { + var _args tool_manage.ToolManageServiceBatchGetToolsArgs _args.Request = request - var _result manage.ToolManageServiceBatchGetToolsResult + var _result tool_manage.ToolManageServiceBatchGetToolsResult if err = p.c.Call(ctx, "BatchGetTools", &_args, &_result); err != nil { return } diff --git a/backend/kitex_gen/coze/loop/prompt/toolmanageservice/client.go b/backend/kitex_gen/coze/loop/prompt/toolmanageservice/client.go index 19916ba88..34c5b6023 100644 --- a/backend/kitex_gen/coze/loop/prompt/toolmanageservice/client.go +++ b/backend/kitex_gen/coze/loop/prompt/toolmanageservice/client.go @@ -6,18 +6,18 @@ import ( "context" client "github.com/cloudwego/kitex/client" callopt "github.com/cloudwego/kitex/client/callopt" - manage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" + tool_manage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool_manage" ) // Client is designed to provide IDL-compatible methods with call-option parameter for kitex framework. type Client interface { - CreateTool(ctx context.Context, request *manage.CreateToolRequest, callOptions ...callopt.Option) (r *manage.CreateToolResponse, err error) - GetToolDetail(ctx context.Context, request *manage.GetToolDetailRequest, callOptions ...callopt.Option) (r *manage.GetToolDetailResponse, err error) - ListTool(ctx context.Context, request *manage.ListToolRequest, callOptions ...callopt.Option) (r *manage.ListToolResponse, err error) - SaveToolDetail(ctx context.Context, request *manage.SaveToolDetailRequest, callOptions ...callopt.Option) (r *manage.SaveToolDetailResponse, err error) - CommitToolDraft(ctx context.Context, request *manage.CommitToolDraftRequest, callOptions ...callopt.Option) (r *manage.CommitToolDraftResponse, err error) - ListToolCommit(ctx context.Context, request *manage.ListToolCommitRequest, callOptions ...callopt.Option) (r *manage.ListToolCommitResponse, err error) - BatchGetTools(ctx context.Context, request *manage.BatchGetToolsRequest, callOptions ...callopt.Option) (r *manage.BatchGetToolsResponse, err error) + CreateTool(ctx context.Context, request *tool_manage.CreateToolRequest, callOptions ...callopt.Option) (r *tool_manage.CreateToolResponse, err error) + GetToolDetail(ctx context.Context, request *tool_manage.GetToolDetailRequest, callOptions ...callopt.Option) (r *tool_manage.GetToolDetailResponse, err error) + ListTool(ctx context.Context, request *tool_manage.ListToolRequest, callOptions ...callopt.Option) (r *tool_manage.ListToolResponse, err error) + SaveToolDetail(ctx context.Context, request *tool_manage.SaveToolDetailRequest, callOptions ...callopt.Option) (r *tool_manage.SaveToolDetailResponse, err error) + CommitToolDraft(ctx context.Context, request *tool_manage.CommitToolDraftRequest, callOptions ...callopt.Option) (r *tool_manage.CommitToolDraftResponse, err error) + ListToolCommit(ctx context.Context, request *tool_manage.ListToolCommitRequest, callOptions ...callopt.Option) (r *tool_manage.ListToolCommitResponse, err error) + BatchGetTools(ctx context.Context, request *tool_manage.BatchGetToolsRequest, callOptions ...callopt.Option) (r *tool_manage.BatchGetToolsResponse, err error) } // NewClient creates a client for the service defined in IDL. @@ -49,37 +49,37 @@ type kToolManageServiceClient struct { *kClient } -func (p *kToolManageServiceClient) CreateTool(ctx context.Context, request *manage.CreateToolRequest, callOptions ...callopt.Option) (r *manage.CreateToolResponse, err error) { +func (p *kToolManageServiceClient) CreateTool(ctx context.Context, request *tool_manage.CreateToolRequest, callOptions ...callopt.Option) (r *tool_manage.CreateToolResponse, err error) { ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.CreateTool(ctx, request) } -func (p *kToolManageServiceClient) GetToolDetail(ctx context.Context, request *manage.GetToolDetailRequest, callOptions ...callopt.Option) (r *manage.GetToolDetailResponse, err error) { +func (p *kToolManageServiceClient) GetToolDetail(ctx context.Context, request *tool_manage.GetToolDetailRequest, callOptions ...callopt.Option) (r *tool_manage.GetToolDetailResponse, err error) { ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.GetToolDetail(ctx, request) } -func (p *kToolManageServiceClient) ListTool(ctx context.Context, request *manage.ListToolRequest, callOptions ...callopt.Option) (r *manage.ListToolResponse, err error) { +func (p *kToolManageServiceClient) ListTool(ctx context.Context, request *tool_manage.ListToolRequest, callOptions ...callopt.Option) (r *tool_manage.ListToolResponse, err error) { ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.ListTool(ctx, request) } -func (p *kToolManageServiceClient) SaveToolDetail(ctx context.Context, request *manage.SaveToolDetailRequest, callOptions ...callopt.Option) (r *manage.SaveToolDetailResponse, err error) { +func (p *kToolManageServiceClient) SaveToolDetail(ctx context.Context, request *tool_manage.SaveToolDetailRequest, callOptions ...callopt.Option) (r *tool_manage.SaveToolDetailResponse, err error) { ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.SaveToolDetail(ctx, request) } -func (p *kToolManageServiceClient) CommitToolDraft(ctx context.Context, request *manage.CommitToolDraftRequest, callOptions ...callopt.Option) (r *manage.CommitToolDraftResponse, err error) { +func (p *kToolManageServiceClient) CommitToolDraft(ctx context.Context, request *tool_manage.CommitToolDraftRequest, callOptions ...callopt.Option) (r *tool_manage.CommitToolDraftResponse, err error) { ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.CommitToolDraft(ctx, request) } -func (p *kToolManageServiceClient) ListToolCommit(ctx context.Context, request *manage.ListToolCommitRequest, callOptions ...callopt.Option) (r *manage.ListToolCommitResponse, err error) { +func (p *kToolManageServiceClient) ListToolCommit(ctx context.Context, request *tool_manage.ListToolCommitRequest, callOptions ...callopt.Option) (r *tool_manage.ListToolCommitResponse, err error) { ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.ListToolCommit(ctx, request) } -func (p *kToolManageServiceClient) BatchGetTools(ctx context.Context, request *manage.BatchGetToolsRequest, callOptions ...callopt.Option) (r *manage.BatchGetToolsResponse, err error) { +func (p *kToolManageServiceClient) BatchGetTools(ctx context.Context, request *tool_manage.BatchGetToolsRequest, callOptions ...callopt.Option) (r *tool_manage.BatchGetToolsResponse, err error) { ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.BatchGetTools(ctx, request) } diff --git a/backend/kitex_gen/coze/loop/prompt/toolmanageservice/toolmanageservice.go b/backend/kitex_gen/coze/loop/prompt/toolmanageservice/toolmanageservice.go index a2e36208d..82470a51a 100644 --- a/backend/kitex_gen/coze/loop/prompt/toolmanageservice/toolmanageservice.go +++ b/backend/kitex_gen/coze/loop/prompt/toolmanageservice/toolmanageservice.go @@ -8,7 +8,7 @@ import ( client "github.com/cloudwego/kitex/client" kitex "github.com/cloudwego/kitex/pkg/serviceinfo" prompt "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt" - manage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" + tool_manage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool_manage" ) var errInvalidMessageType = errors.New("invalid message type for service method handler") @@ -97,9 +97,9 @@ func newServiceInfo() *kitex.ServiceInfo { } func createToolHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - realArg := arg.(*manage.ToolManageServiceCreateToolArgs) - realResult := result.(*manage.ToolManageServiceCreateToolResult) - success, err := handler.(manage.ToolManageService).CreateTool(ctx, realArg.Request) + realArg := arg.(*tool_manage.ToolManageServiceCreateToolArgs) + realResult := result.(*tool_manage.ToolManageServiceCreateToolResult) + success, err := handler.(tool_manage.ToolManageService).CreateTool(ctx, realArg.Request) if err != nil { return err } @@ -108,17 +108,17 @@ func createToolHandler(ctx context.Context, handler interface{}, arg, result int } func newToolManageServiceCreateToolArgs() interface{} { - return manage.NewToolManageServiceCreateToolArgs() + return tool_manage.NewToolManageServiceCreateToolArgs() } func newToolManageServiceCreateToolResult() interface{} { - return manage.NewToolManageServiceCreateToolResult() + return tool_manage.NewToolManageServiceCreateToolResult() } func getToolDetailHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - realArg := arg.(*manage.ToolManageServiceGetToolDetailArgs) - realResult := result.(*manage.ToolManageServiceGetToolDetailResult) - success, err := handler.(manage.ToolManageService).GetToolDetail(ctx, realArg.Request) + realArg := arg.(*tool_manage.ToolManageServiceGetToolDetailArgs) + realResult := result.(*tool_manage.ToolManageServiceGetToolDetailResult) + success, err := handler.(tool_manage.ToolManageService).GetToolDetail(ctx, realArg.Request) if err != nil { return err } @@ -127,17 +127,17 @@ func getToolDetailHandler(ctx context.Context, handler interface{}, arg, result } func newToolManageServiceGetToolDetailArgs() interface{} { - return manage.NewToolManageServiceGetToolDetailArgs() + return tool_manage.NewToolManageServiceGetToolDetailArgs() } func newToolManageServiceGetToolDetailResult() interface{} { - return manage.NewToolManageServiceGetToolDetailResult() + return tool_manage.NewToolManageServiceGetToolDetailResult() } func listToolHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - realArg := arg.(*manage.ToolManageServiceListToolArgs) - realResult := result.(*manage.ToolManageServiceListToolResult) - success, err := handler.(manage.ToolManageService).ListTool(ctx, realArg.Request) + realArg := arg.(*tool_manage.ToolManageServiceListToolArgs) + realResult := result.(*tool_manage.ToolManageServiceListToolResult) + success, err := handler.(tool_manage.ToolManageService).ListTool(ctx, realArg.Request) if err != nil { return err } @@ -146,17 +146,17 @@ func listToolHandler(ctx context.Context, handler interface{}, arg, result inter } func newToolManageServiceListToolArgs() interface{} { - return manage.NewToolManageServiceListToolArgs() + return tool_manage.NewToolManageServiceListToolArgs() } func newToolManageServiceListToolResult() interface{} { - return manage.NewToolManageServiceListToolResult() + return tool_manage.NewToolManageServiceListToolResult() } func saveToolDetailHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - realArg := arg.(*manage.ToolManageServiceSaveToolDetailArgs) - realResult := result.(*manage.ToolManageServiceSaveToolDetailResult) - success, err := handler.(manage.ToolManageService).SaveToolDetail(ctx, realArg.Request) + realArg := arg.(*tool_manage.ToolManageServiceSaveToolDetailArgs) + realResult := result.(*tool_manage.ToolManageServiceSaveToolDetailResult) + success, err := handler.(tool_manage.ToolManageService).SaveToolDetail(ctx, realArg.Request) if err != nil { return err } @@ -165,17 +165,17 @@ func saveToolDetailHandler(ctx context.Context, handler interface{}, arg, result } func newToolManageServiceSaveToolDetailArgs() interface{} { - return manage.NewToolManageServiceSaveToolDetailArgs() + return tool_manage.NewToolManageServiceSaveToolDetailArgs() } func newToolManageServiceSaveToolDetailResult() interface{} { - return manage.NewToolManageServiceSaveToolDetailResult() + return tool_manage.NewToolManageServiceSaveToolDetailResult() } func commitToolDraftHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - realArg := arg.(*manage.ToolManageServiceCommitToolDraftArgs) - realResult := result.(*manage.ToolManageServiceCommitToolDraftResult) - success, err := handler.(manage.ToolManageService).CommitToolDraft(ctx, realArg.Request) + realArg := arg.(*tool_manage.ToolManageServiceCommitToolDraftArgs) + realResult := result.(*tool_manage.ToolManageServiceCommitToolDraftResult) + success, err := handler.(tool_manage.ToolManageService).CommitToolDraft(ctx, realArg.Request) if err != nil { return err } @@ -184,17 +184,17 @@ func commitToolDraftHandler(ctx context.Context, handler interface{}, arg, resul } func newToolManageServiceCommitToolDraftArgs() interface{} { - return manage.NewToolManageServiceCommitToolDraftArgs() + return tool_manage.NewToolManageServiceCommitToolDraftArgs() } func newToolManageServiceCommitToolDraftResult() interface{} { - return manage.NewToolManageServiceCommitToolDraftResult() + return tool_manage.NewToolManageServiceCommitToolDraftResult() } func listToolCommitHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - realArg := arg.(*manage.ToolManageServiceListToolCommitArgs) - realResult := result.(*manage.ToolManageServiceListToolCommitResult) - success, err := handler.(manage.ToolManageService).ListToolCommit(ctx, realArg.Request) + realArg := arg.(*tool_manage.ToolManageServiceListToolCommitArgs) + realResult := result.(*tool_manage.ToolManageServiceListToolCommitResult) + success, err := handler.(tool_manage.ToolManageService).ListToolCommit(ctx, realArg.Request) if err != nil { return err } @@ -203,17 +203,17 @@ func listToolCommitHandler(ctx context.Context, handler interface{}, arg, result } func newToolManageServiceListToolCommitArgs() interface{} { - return manage.NewToolManageServiceListToolCommitArgs() + return tool_manage.NewToolManageServiceListToolCommitArgs() } func newToolManageServiceListToolCommitResult() interface{} { - return manage.NewToolManageServiceListToolCommitResult() + return tool_manage.NewToolManageServiceListToolCommitResult() } func batchGetToolsHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { - realArg := arg.(*manage.ToolManageServiceBatchGetToolsArgs) - realResult := result.(*manage.ToolManageServiceBatchGetToolsResult) - success, err := handler.(manage.ToolManageService).BatchGetTools(ctx, realArg.Request) + realArg := arg.(*tool_manage.ToolManageServiceBatchGetToolsArgs) + realResult := result.(*tool_manage.ToolManageServiceBatchGetToolsResult) + success, err := handler.(tool_manage.ToolManageService).BatchGetTools(ctx, realArg.Request) if err != nil { return err } @@ -222,11 +222,11 @@ func batchGetToolsHandler(ctx context.Context, handler interface{}, arg, result } func newToolManageServiceBatchGetToolsArgs() interface{} { - return manage.NewToolManageServiceBatchGetToolsArgs() + return tool_manage.NewToolManageServiceBatchGetToolsArgs() } func newToolManageServiceBatchGetToolsResult() interface{} { - return manage.NewToolManageServiceBatchGetToolsResult() + return tool_manage.NewToolManageServiceBatchGetToolsResult() } type kClient struct { @@ -241,70 +241,70 @@ func newServiceClient(c client.Client) *kClient { } } -func (p *kClient) CreateTool(ctx context.Context, request *manage.CreateToolRequest) (r *manage.CreateToolResponse, err error) { - var _args manage.ToolManageServiceCreateToolArgs +func (p *kClient) CreateTool(ctx context.Context, request *tool_manage.CreateToolRequest) (r *tool_manage.CreateToolResponse, err error) { + var _args tool_manage.ToolManageServiceCreateToolArgs _args.Request = request - var _result manage.ToolManageServiceCreateToolResult + var _result tool_manage.ToolManageServiceCreateToolResult if err = p.c.Call(ctx, "CreateTool", &_args, &_result); err != nil { return } return _result.GetSuccess(), nil } -func (p *kClient) GetToolDetail(ctx context.Context, request *manage.GetToolDetailRequest) (r *manage.GetToolDetailResponse, err error) { - var _args manage.ToolManageServiceGetToolDetailArgs +func (p *kClient) GetToolDetail(ctx context.Context, request *tool_manage.GetToolDetailRequest) (r *tool_manage.GetToolDetailResponse, err error) { + var _args tool_manage.ToolManageServiceGetToolDetailArgs _args.Request = request - var _result manage.ToolManageServiceGetToolDetailResult + var _result tool_manage.ToolManageServiceGetToolDetailResult if err = p.c.Call(ctx, "GetToolDetail", &_args, &_result); err != nil { return } return _result.GetSuccess(), nil } -func (p *kClient) ListTool(ctx context.Context, request *manage.ListToolRequest) (r *manage.ListToolResponse, err error) { - var _args manage.ToolManageServiceListToolArgs +func (p *kClient) ListTool(ctx context.Context, request *tool_manage.ListToolRequest) (r *tool_manage.ListToolResponse, err error) { + var _args tool_manage.ToolManageServiceListToolArgs _args.Request = request - var _result manage.ToolManageServiceListToolResult + var _result tool_manage.ToolManageServiceListToolResult if err = p.c.Call(ctx, "ListTool", &_args, &_result); err != nil { return } return _result.GetSuccess(), nil } -func (p *kClient) SaveToolDetail(ctx context.Context, request *manage.SaveToolDetailRequest) (r *manage.SaveToolDetailResponse, err error) { - var _args manage.ToolManageServiceSaveToolDetailArgs +func (p *kClient) SaveToolDetail(ctx context.Context, request *tool_manage.SaveToolDetailRequest) (r *tool_manage.SaveToolDetailResponse, err error) { + var _args tool_manage.ToolManageServiceSaveToolDetailArgs _args.Request = request - var _result manage.ToolManageServiceSaveToolDetailResult + var _result tool_manage.ToolManageServiceSaveToolDetailResult if err = p.c.Call(ctx, "SaveToolDetail", &_args, &_result); err != nil { return } return _result.GetSuccess(), nil } -func (p *kClient) CommitToolDraft(ctx context.Context, request *manage.CommitToolDraftRequest) (r *manage.CommitToolDraftResponse, err error) { - var _args manage.ToolManageServiceCommitToolDraftArgs +func (p *kClient) CommitToolDraft(ctx context.Context, request *tool_manage.CommitToolDraftRequest) (r *tool_manage.CommitToolDraftResponse, err error) { + var _args tool_manage.ToolManageServiceCommitToolDraftArgs _args.Request = request - var _result manage.ToolManageServiceCommitToolDraftResult + var _result tool_manage.ToolManageServiceCommitToolDraftResult if err = p.c.Call(ctx, "CommitToolDraft", &_args, &_result); err != nil { return } return _result.GetSuccess(), nil } -func (p *kClient) ListToolCommit(ctx context.Context, request *manage.ListToolCommitRequest) (r *manage.ListToolCommitResponse, err error) { - var _args manage.ToolManageServiceListToolCommitArgs +func (p *kClient) ListToolCommit(ctx context.Context, request *tool_manage.ListToolCommitRequest) (r *tool_manage.ListToolCommitResponse, err error) { + var _args tool_manage.ToolManageServiceListToolCommitArgs _args.Request = request - var _result manage.ToolManageServiceListToolCommitResult + var _result tool_manage.ToolManageServiceListToolCommitResult if err = p.c.Call(ctx, "ListToolCommit", &_args, &_result); err != nil { return } return _result.GetSuccess(), nil } -func (p *kClient) BatchGetTools(ctx context.Context, request *manage.BatchGetToolsRequest) (r *manage.BatchGetToolsResponse, err error) { - var _args manage.ToolManageServiceBatchGetToolsArgs +func (p *kClient) BatchGetTools(ctx context.Context, request *tool_manage.BatchGetToolsRequest) (r *tool_manage.BatchGetToolsResponse, err error) { + var _args tool_manage.ToolManageServiceBatchGetToolsArgs _args.Request = request - var _result manage.ToolManageServiceBatchGetToolsResult + var _result tool_manage.ToolManageServiceBatchGetToolsResult if err = p.c.Call(ctx, "BatchGetTools", &_args, &_result); err != nil { return } diff --git a/backend/loop_gen/coze/loop/prompt/tool/lomanage/local_toolmanageservice.go b/backend/loop_gen/coze/loop/prompt/lotool_manage/local_toolmanageservice.go similarity index 56% rename from backend/loop_gen/coze/loop/prompt/tool/lomanage/local_toolmanageservice.go rename to backend/loop_gen/coze/loop/prompt/lotool_manage/local_toolmanageservice.go index b1784274a..439482af0 100644 --- a/backend/loop_gen/coze/loop/prompt/tool/lomanage/local_toolmanageservice.go +++ b/backend/loop_gen/coze/loop/prompt/lotool_manage/local_toolmanageservice.go @@ -1,5 +1,5 @@ // Code generated by cozeloop. DO NOT EDIT. -package lomanage // import github.com/coze-dev/coze-loop/backend/lomanage +package lotool_manage // import github.com/coze-dev/coze-loop/backend/lotool_manage import ( "context" @@ -7,25 +7,25 @@ import ( "github.com/cloudwego/kitex/client/callopt" "github.com/cloudwego/kitex/pkg/endpoint" "github.com/cloudwego/kitex/pkg/rpcinfo" - "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" + "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool_manage" ) type LocalToolManageService struct { - impl manage.ToolManageService // the service implementation + impl tool_manage.ToolManageService // the service implementation mds endpoint.Middleware } -func NewLocalToolManageService(impl manage.ToolManageService, mds ...endpoint.Middleware) *LocalToolManageService { +func NewLocalToolManageService(impl tool_manage.ToolManageService, mds ...endpoint.Middleware) *LocalToolManageService { return &LocalToolManageService{ impl: impl, mds: endpoint.Chain(mds...), } } -func (l *LocalToolManageService) CreateTool(ctx context.Context, request *manage.CreateToolRequest, callOptions ...callopt.Option) (*manage.CreateToolResponse, error) { +func (l *LocalToolManageService) CreateTool(ctx context.Context, request *tool_manage.CreateToolRequest, callOptions ...callopt.Option) (*tool_manage.CreateToolResponse, error) { chain := l.mds(func(ctx context.Context, in, out interface{}) error { - arg := in.(*manage.ToolManageServiceCreateToolArgs) - result := out.(*manage.ToolManageServiceCreateToolResult) + arg := in.(*tool_manage.ToolManageServiceCreateToolArgs) + result := out.(*tool_manage.ToolManageServiceCreateToolResult) resp, err := l.impl.CreateTool(ctx, arg.Request) if err != nil { return err @@ -34,8 +34,8 @@ func (l *LocalToolManageService) CreateTool(ctx context.Context, request *manage return nil }) - arg := &manage.ToolManageServiceCreateToolArgs{Request: request} - result := &manage.ToolManageServiceCreateToolResult{} + arg := &tool_manage.ToolManageServiceCreateToolArgs{Request: request} + result := &tool_manage.ToolManageServiceCreateToolResult{} ctx = l.injectRPCInfo(ctx, "CreateTool") if err := chain(ctx, arg, result); err != nil { return nil, err @@ -43,10 +43,10 @@ func (l *LocalToolManageService) CreateTool(ctx context.Context, request *manage return result.GetSuccess(), nil } -func (l *LocalToolManageService) GetToolDetail(ctx context.Context, request *manage.GetToolDetailRequest, callOptions ...callopt.Option) (*manage.GetToolDetailResponse, error) { +func (l *LocalToolManageService) GetToolDetail(ctx context.Context, request *tool_manage.GetToolDetailRequest, callOptions ...callopt.Option) (*tool_manage.GetToolDetailResponse, error) { chain := l.mds(func(ctx context.Context, in, out interface{}) error { - arg := in.(*manage.ToolManageServiceGetToolDetailArgs) - result := out.(*manage.ToolManageServiceGetToolDetailResult) + arg := in.(*tool_manage.ToolManageServiceGetToolDetailArgs) + result := out.(*tool_manage.ToolManageServiceGetToolDetailResult) resp, err := l.impl.GetToolDetail(ctx, arg.Request) if err != nil { return err @@ -55,8 +55,8 @@ func (l *LocalToolManageService) GetToolDetail(ctx context.Context, request *man return nil }) - arg := &manage.ToolManageServiceGetToolDetailArgs{Request: request} - result := &manage.ToolManageServiceGetToolDetailResult{} + arg := &tool_manage.ToolManageServiceGetToolDetailArgs{Request: request} + result := &tool_manage.ToolManageServiceGetToolDetailResult{} ctx = l.injectRPCInfo(ctx, "GetToolDetail") if err := chain(ctx, arg, result); err != nil { return nil, err @@ -64,10 +64,10 @@ func (l *LocalToolManageService) GetToolDetail(ctx context.Context, request *man return result.GetSuccess(), nil } -func (l *LocalToolManageService) ListTool(ctx context.Context, request *manage.ListToolRequest, callOptions ...callopt.Option) (*manage.ListToolResponse, error) { +func (l *LocalToolManageService) ListTool(ctx context.Context, request *tool_manage.ListToolRequest, callOptions ...callopt.Option) (*tool_manage.ListToolResponse, error) { chain := l.mds(func(ctx context.Context, in, out interface{}) error { - arg := in.(*manage.ToolManageServiceListToolArgs) - result := out.(*manage.ToolManageServiceListToolResult) + arg := in.(*tool_manage.ToolManageServiceListToolArgs) + result := out.(*tool_manage.ToolManageServiceListToolResult) resp, err := l.impl.ListTool(ctx, arg.Request) if err != nil { return err @@ -76,8 +76,8 @@ func (l *LocalToolManageService) ListTool(ctx context.Context, request *manage.L return nil }) - arg := &manage.ToolManageServiceListToolArgs{Request: request} - result := &manage.ToolManageServiceListToolResult{} + arg := &tool_manage.ToolManageServiceListToolArgs{Request: request} + result := &tool_manage.ToolManageServiceListToolResult{} ctx = l.injectRPCInfo(ctx, "ListTool") if err := chain(ctx, arg, result); err != nil { return nil, err @@ -85,10 +85,10 @@ func (l *LocalToolManageService) ListTool(ctx context.Context, request *manage.L return result.GetSuccess(), nil } -func (l *LocalToolManageService) SaveToolDetail(ctx context.Context, request *manage.SaveToolDetailRequest, callOptions ...callopt.Option) (*manage.SaveToolDetailResponse, error) { +func (l *LocalToolManageService) SaveToolDetail(ctx context.Context, request *tool_manage.SaveToolDetailRequest, callOptions ...callopt.Option) (*tool_manage.SaveToolDetailResponse, error) { chain := l.mds(func(ctx context.Context, in, out interface{}) error { - arg := in.(*manage.ToolManageServiceSaveToolDetailArgs) - result := out.(*manage.ToolManageServiceSaveToolDetailResult) + arg := in.(*tool_manage.ToolManageServiceSaveToolDetailArgs) + result := out.(*tool_manage.ToolManageServiceSaveToolDetailResult) resp, err := l.impl.SaveToolDetail(ctx, arg.Request) if err != nil { return err @@ -97,8 +97,8 @@ func (l *LocalToolManageService) SaveToolDetail(ctx context.Context, request *ma return nil }) - arg := &manage.ToolManageServiceSaveToolDetailArgs{Request: request} - result := &manage.ToolManageServiceSaveToolDetailResult{} + arg := &tool_manage.ToolManageServiceSaveToolDetailArgs{Request: request} + result := &tool_manage.ToolManageServiceSaveToolDetailResult{} ctx = l.injectRPCInfo(ctx, "SaveToolDetail") if err := chain(ctx, arg, result); err != nil { return nil, err @@ -106,10 +106,10 @@ func (l *LocalToolManageService) SaveToolDetail(ctx context.Context, request *ma return result.GetSuccess(), nil } -func (l *LocalToolManageService) CommitToolDraft(ctx context.Context, request *manage.CommitToolDraftRequest, callOptions ...callopt.Option) (*manage.CommitToolDraftResponse, error) { +func (l *LocalToolManageService) CommitToolDraft(ctx context.Context, request *tool_manage.CommitToolDraftRequest, callOptions ...callopt.Option) (*tool_manage.CommitToolDraftResponse, error) { chain := l.mds(func(ctx context.Context, in, out interface{}) error { - arg := in.(*manage.ToolManageServiceCommitToolDraftArgs) - result := out.(*manage.ToolManageServiceCommitToolDraftResult) + arg := in.(*tool_manage.ToolManageServiceCommitToolDraftArgs) + result := out.(*tool_manage.ToolManageServiceCommitToolDraftResult) resp, err := l.impl.CommitToolDraft(ctx, arg.Request) if err != nil { return err @@ -118,8 +118,8 @@ func (l *LocalToolManageService) CommitToolDraft(ctx context.Context, request *m return nil }) - arg := &manage.ToolManageServiceCommitToolDraftArgs{Request: request} - result := &manage.ToolManageServiceCommitToolDraftResult{} + arg := &tool_manage.ToolManageServiceCommitToolDraftArgs{Request: request} + result := &tool_manage.ToolManageServiceCommitToolDraftResult{} ctx = l.injectRPCInfo(ctx, "CommitToolDraft") if err := chain(ctx, arg, result); err != nil { return nil, err @@ -127,10 +127,10 @@ func (l *LocalToolManageService) CommitToolDraft(ctx context.Context, request *m return result.GetSuccess(), nil } -func (l *LocalToolManageService) ListToolCommit(ctx context.Context, request *manage.ListToolCommitRequest, callOptions ...callopt.Option) (*manage.ListToolCommitResponse, error) { +func (l *LocalToolManageService) ListToolCommit(ctx context.Context, request *tool_manage.ListToolCommitRequest, callOptions ...callopt.Option) (*tool_manage.ListToolCommitResponse, error) { chain := l.mds(func(ctx context.Context, in, out interface{}) error { - arg := in.(*manage.ToolManageServiceListToolCommitArgs) - result := out.(*manage.ToolManageServiceListToolCommitResult) + arg := in.(*tool_manage.ToolManageServiceListToolCommitArgs) + result := out.(*tool_manage.ToolManageServiceListToolCommitResult) resp, err := l.impl.ListToolCommit(ctx, arg.Request) if err != nil { return err @@ -139,8 +139,8 @@ func (l *LocalToolManageService) ListToolCommit(ctx context.Context, request *ma return nil }) - arg := &manage.ToolManageServiceListToolCommitArgs{Request: request} - result := &manage.ToolManageServiceListToolCommitResult{} + arg := &tool_manage.ToolManageServiceListToolCommitArgs{Request: request} + result := &tool_manage.ToolManageServiceListToolCommitResult{} ctx = l.injectRPCInfo(ctx, "ListToolCommit") if err := chain(ctx, arg, result); err != nil { return nil, err @@ -148,10 +148,10 @@ func (l *LocalToolManageService) ListToolCommit(ctx context.Context, request *ma return result.GetSuccess(), nil } -func (l *LocalToolManageService) BatchGetTools(ctx context.Context, request *manage.BatchGetToolsRequest, callOptions ...callopt.Option) (*manage.BatchGetToolsResponse, error) { +func (l *LocalToolManageService) BatchGetTools(ctx context.Context, request *tool_manage.BatchGetToolsRequest, callOptions ...callopt.Option) (*tool_manage.BatchGetToolsResponse, error) { chain := l.mds(func(ctx context.Context, in, out interface{}) error { - arg := in.(*manage.ToolManageServiceBatchGetToolsArgs) - result := out.(*manage.ToolManageServiceBatchGetToolsResult) + arg := in.(*tool_manage.ToolManageServiceBatchGetToolsArgs) + result := out.(*tool_manage.ToolManageServiceBatchGetToolsResult) resp, err := l.impl.BatchGetTools(ctx, arg.Request) if err != nil { return err @@ -160,8 +160,8 @@ func (l *LocalToolManageService) BatchGetTools(ctx context.Context, request *man return nil }) - arg := &manage.ToolManageServiceBatchGetToolsArgs{Request: request} - result := &manage.ToolManageServiceBatchGetToolsResult{} + arg := &tool_manage.ToolManageServiceBatchGetToolsArgs{Request: request} + result := &tool_manage.ToolManageServiceBatchGetToolsResult{} ctx = l.injectRPCInfo(ctx, "BatchGetTools") if err := chain(ctx, arg, result); err != nil { return nil, err diff --git a/backend/modules/prompt/application/tool_manage.go b/backend/modules/prompt/application/tool_manage.go index 769638eaa..20330003b 100644 --- a/backend/modules/prompt/application/tool_manage.go +++ b/backend/modules/prompt/application/tool_manage.go @@ -11,7 +11,7 @@ import ( "github.com/coze-dev/coze-loop/backend/infra/middleware/session" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/domain/tool" - toolmanage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" + toolmanage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool_manage" "github.com/coze-dev/coze-loop/backend/modules/prompt/application/convertor" "github.com/coze-dev/coze-loop/backend/modules/prompt/domain/component/rpc" "github.com/coze-dev/coze-loop/backend/modules/prompt/domain/entity/toolmgmt" diff --git a/backend/modules/prompt/application/wire.go b/backend/modules/prompt/application/wire.go index 7528e8089..87d572cb6 100644 --- a/backend/modules/prompt/application/wire.go +++ b/backend/modules/prompt/application/wire.go @@ -24,7 +24,7 @@ import ( "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/execute" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/manage" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/openapi" - toolmanage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" + toolmanage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool_manage" "github.com/coze-dev/coze-loop/backend/modules/prompt/domain/service" "github.com/coze-dev/coze-loop/backend/modules/prompt/infra/collector" promptconf "github.com/coze-dev/coze-loop/backend/modules/prompt/infra/conf" diff --git a/backend/modules/prompt/application/wire_gen.go b/backend/modules/prompt/application/wire_gen.go index 30efbdf3d..73e0b6fbf 100644 --- a/backend/modules/prompt/application/wire_gen.go +++ b/backend/modules/prompt/application/wire_gen.go @@ -22,7 +22,7 @@ import ( "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/execute" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/manage" "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/openapi" - manage2 "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool/manage" + manage2 "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool_manage" "github.com/coze-dev/coze-loop/backend/modules/prompt/domain/service" "github.com/coze-dev/coze-loop/backend/modules/prompt/infra/collector" conf2 "github.com/coze-dev/coze-loop/backend/modules/prompt/infra/conf" diff --git a/idl/thrift/coze/loop/prompt/coze.loop.prompt.tool_manage.thrift b/idl/thrift/coze/loop/prompt/coze.loop.prompt.tool_manage.thrift index 2871a0654..268b378da 100644 --- a/idl/thrift/coze/loop/prompt/coze.loop.prompt.tool_manage.thrift +++ b/idl/thrift/coze/loop/prompt/coze.loop.prompt.tool_manage.thrift @@ -1,4 +1,4 @@ -namespace go coze.loop.prompt.tool.manage +namespace go coze.loop.prompt.tool_manage include "../../../base.thrift" include "./domain/tool.thrift" From fbf85b5033194bea79b2d9134b05f53c45843213 Mon Sep 17 00:00:00 2001 From: "wangluming.wlm" Date: Tue, 24 Mar 2026 20:16:25 +0800 Subject: [PATCH 5/8] feat:tool --- frontend/packages/loop-base/api-schema/api.config.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/frontend/packages/loop-base/api-schema/api.config.js b/frontend/packages/loop-base/api-schema/api.config.js index 05394893e..90dd43179 100644 --- a/frontend/packages/loop-base/api-schema/api.config.js +++ b/frontend/packages/loop-base/api-schema/api.config.js @@ -13,7 +13,7 @@ const config = [ entries: { promptDebug: './prompt/coze.loop.prompt.debug.thrift', promptManage: './prompt/coze.loop.prompt.manage.thrift', - toolManage: './prompt/coze.loop.prompt.tool.manage.thrift', + toolManage: './prompt/coze.loop.prompt.tool_manage.thrift', observabilityTrace: './observability/coze.loop.observability.trace.thrift', observabilityTask: './observability/coze.loop.observability.task.thrift', From ac98401c3a4cb932fff72e1f93887944cd376bcf Mon Sep 17 00:00:00 2001 From: wutingjia Date: Fri, 27 Mar 2026 14:40:14 +0800 Subject: [PATCH 6/8] feat: auto-generated unit tests for tool manage --- .../convertor/toolmgmt_unit_test.go | 152 ++++ .../application/convertor/user_unit_test.go | 76 ++ .../application/tool_manage_unit_test.go | 828 ++++++++++++++++++ .../domain/entity/toolmgmt/tool_unit_test.go | 35 + .../prompt/domain/repo/mocks/tool_repo.go | 160 ++++ .../repo/mysql/convertor/tool_unit_test.go | 146 +++ 6 files changed, 1397 insertions(+) create mode 100644 backend/modules/prompt/application/convertor/toolmgmt_unit_test.go create mode 100644 backend/modules/prompt/application/convertor/user_unit_test.go create mode 100644 backend/modules/prompt/application/tool_manage_unit_test.go create mode 100644 backend/modules/prompt/domain/entity/toolmgmt/tool_unit_test.go create mode 100644 backend/modules/prompt/domain/repo/mocks/tool_repo.go create mode 100644 backend/modules/prompt/infra/repo/mysql/convertor/tool_unit_test.go diff --git a/backend/modules/prompt/application/convertor/toolmgmt_unit_test.go b/backend/modules/prompt/application/convertor/toolmgmt_unit_test.go new file mode 100644 index 000000000..d7a4a9229 --- /dev/null +++ b/backend/modules/prompt/application/convertor/toolmgmt_unit_test.go @@ -0,0 +1,152 @@ +package convertor + +import ( + "testing" + "time" + + "github.com/stretchr/testify/assert" + + "github.com/coze-dev/coze-loop/backend/modules/prompt/domain/entity/toolmgmt" +) + +func TestToolMgmtDO2DTO_Nil(t *testing.T) { + t.Parallel() + result := ToolMgmtDO2DTO(nil) + assert.Nil(t, result) +} + +func TestToolMgmtDO2DTO_NilSubfields(t *testing.T) { + t.Parallel() + do := &toolmgmt.Tool{ + ID: 10, + SpaceID: 20, + ToolBasic: nil, + ToolCommit: nil, + } + result := ToolMgmtDO2DTO(do) + assert.NotNil(t, result) + assert.Equal(t, int64(10), result.GetID()) + assert.Equal(t, int64(20), result.GetWorkspaceID()) + assert.Nil(t, result.ToolBasic) + assert.Nil(t, result.ToolCommit) +} + +func TestToolMgmtDO2DTO_FullFields(t *testing.T) { + t.Parallel() + now := time.Now() + do := &toolmgmt.Tool{ + ID: 1, + SpaceID: 100, + ToolBasic: &toolmgmt.ToolBasic{ + Name: "example-tool", + Description: "desc", + LatestCommittedVersion: "1.0.0", + CreatedBy: "user-1", + UpdatedBy: "user-2", + CreatedAt: now, + UpdatedAt: now, + }, + ToolCommit: &toolmgmt.ToolCommit{ + CommitInfo: &toolmgmt.CommitInfo{ + Version: "1.0.0", + BaseVersion: "0.0.1", + Description: "initial", + CommittedBy: "user-1", + CommittedAt: now, + }, + ToolDetail: &toolmgmt.ToolDetail{ + Content: "tool content", + }, + }, + } + result := ToolMgmtDO2DTO(do) + assert.NotNil(t, result) + assert.Equal(t, "example-tool", result.ToolBasic.GetName()) + assert.Equal(t, "desc", result.ToolBasic.GetDescription()) + assert.Equal(t, "1.0.0", result.ToolBasic.GetLatestCommittedVersion()) + assert.Equal(t, "user-1", result.ToolBasic.GetCreatedBy()) + assert.Equal(t, "user-2", result.ToolBasic.GetUpdatedBy()) + assert.Equal(t, now.UnixMilli(), result.ToolBasic.GetCreatedAt()) + assert.Equal(t, now.UnixMilli(), result.ToolBasic.GetUpdatedAt()) + + assert.NotNil(t, result.ToolCommit) + assert.Equal(t, "1.0.0", result.ToolCommit.CommitInfo.GetVersion()) + assert.Equal(t, "0.0.1", result.ToolCommit.CommitInfo.GetBaseVersion()) + assert.Equal(t, "initial", result.ToolCommit.CommitInfo.GetDescription()) + assert.Equal(t, "tool content", result.ToolCommit.Detail.GetContent()) +} + +func TestToolMgmtBasicDO2DTO_Nil(t *testing.T) { + t.Parallel() + result := ToolMgmtBasicDO2DTO(nil) + assert.Nil(t, result) +} + +func TestToolMgmtCommitDO2DTO_Nil(t *testing.T) { + t.Parallel() + result := ToolMgmtCommitDO2DTO(nil) + assert.Nil(t, result) +} + +func TestToolMgmtCommitDO2DTO_NilSubfields(t *testing.T) { + t.Parallel() + do := &toolmgmt.ToolCommit{ + CommitInfo: nil, + ToolDetail: nil, + } + result := ToolMgmtCommitDO2DTO(do) + assert.NotNil(t, result) + assert.Nil(t, result.CommitInfo) + assert.Nil(t, result.Detail) +} + +func TestToolMgmtCommitInfoDO2DTO_Nil(t *testing.T) { + t.Parallel() + result := ToolMgmtCommitInfoDO2DTO(nil) + assert.Nil(t, result) +} + +func TestToolMgmtDetailDO2DTO_Nil(t *testing.T) { + t.Parallel() + result := ToolMgmtDetailDO2DTO(nil) + assert.Nil(t, result) +} + +func TestToolMgmtDetailDO2DTO_EmptyContent(t *testing.T) { + t.Parallel() + do := &toolmgmt.ToolDetail{Content: ""} + result := ToolMgmtDetailDO2DTO(do) + assert.NotNil(t, result) + assert.Equal(t, "", result.GetContent()) +} + +// --- BatchToolMgmtDO2DTO tests --- + +func TestBatchToolMgmtDO2DTO_EmptySlice(t *testing.T) { + t.Parallel() + result := BatchToolMgmtDO2DTO(nil) + assert.Nil(t, result) + + result = BatchToolMgmtDO2DTO([]*toolmgmt.Tool{}) + assert.Nil(t, result) +} + +func TestBatchToolMgmtDO2DTO_AllNil(t *testing.T) { + t.Parallel() + result := BatchToolMgmtDO2DTO([]*toolmgmt.Tool{nil, nil, nil}) + assert.Nil(t, result) +} + +func TestBatchToolMgmtDO2DTO_MixedNilAndValid(t *testing.T) { + t.Parallel() + dos := []*toolmgmt.Tool{ + nil, + {ID: 1, SpaceID: 100}, + nil, + {ID: 2, SpaceID: 200}, + } + result := BatchToolMgmtDO2DTO(dos) + assert.Len(t, result, 2) + assert.Equal(t, int64(1), result[0].GetID()) + assert.Equal(t, int64(2), result[1].GetID()) +} diff --git a/backend/modules/prompt/application/convertor/user_unit_test.go b/backend/modules/prompt/application/convertor/user_unit_test.go new file mode 100644 index 000000000..7c1d2a623 --- /dev/null +++ b/backend/modules/prompt/application/convertor/user_unit_test.go @@ -0,0 +1,76 @@ +package convertor + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/coze-dev/coze-loop/backend/modules/prompt/domain/component/rpc" +) + +func TestUserInfoDO2DTO_Nil(t *testing.T) { + t.Parallel() + result := UserInfoDO2DTO(nil) + assert.Nil(t, result) +} + +func TestUserInfoDO2DTO_FullFields(t *testing.T) { + t.Parallel() + do := &rpc.UserInfo{ + UserID: "user-1", + UserName: "Demo User", + NickName: "Demo", + AvatarURL: "https://example.com/avatar.png", + Email: "demo@example.com", + Mobile: "1234567890", + } + result := UserInfoDO2DTO(do) + assert.NotNil(t, result) + assert.Equal(t, "user-1", result.GetUserID()) + assert.Equal(t, "Demo User", result.GetName()) + assert.Equal(t, "Demo", result.GetNickName()) + assert.Equal(t, "https://example.com/avatar.png", result.GetAvatarURL()) + assert.Equal(t, "demo@example.com", result.GetEmail()) + assert.Equal(t, "1234567890", result.GetMobile()) +} + +func TestUserInfoDO2DTO_EmptyFields(t *testing.T) { + t.Parallel() + do := &rpc.UserInfo{} + result := UserInfoDO2DTO(do) + assert.NotNil(t, result) + assert.Equal(t, "", result.GetUserID()) + assert.Equal(t, "", result.GetName()) +} + +func TestBatchUserInfoDO2DTO_Nil(t *testing.T) { + t.Parallel() + result := BatchUserInfoDO2DTO(nil) + assert.Nil(t, result) +} + +func TestBatchUserInfoDO2DTO_EmptySlice(t *testing.T) { + t.Parallel() + result := BatchUserInfoDO2DTO([]*rpc.UserInfo{}) + assert.Nil(t, result) +} + +func TestBatchUserInfoDO2DTO_AllNil(t *testing.T) { + t.Parallel() + result := BatchUserInfoDO2DTO([]*rpc.UserInfo{nil, nil}) + assert.Nil(t, result) +} + +func TestBatchUserInfoDO2DTO_MixedNilAndValid(t *testing.T) { + t.Parallel() + dos := []*rpc.UserInfo{ + nil, + {UserID: "user-1", UserName: "Demo User 1"}, + nil, + {UserID: "user-2", UserName: "Demo User 2"}, + } + result := BatchUserInfoDO2DTO(dos) + assert.Len(t, result, 2) + assert.Equal(t, "user-1", result[0].GetUserID()) + assert.Equal(t, "user-2", result[1].GetUserID()) +} diff --git a/backend/modules/prompt/application/tool_manage_unit_test.go b/backend/modules/prompt/application/tool_manage_unit_test.go new file mode 100644 index 000000000..d628d2f19 --- /dev/null +++ b/backend/modules/prompt/application/tool_manage_unit_test.go @@ -0,0 +1,828 @@ +package application + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" + "go.uber.org/mock/gomock" + + "github.com/coze-dev/coze-loop/backend/infra/middleware/session" + toolDTO "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/domain/tool" + toolmanage "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/prompt/tool_manage" + "github.com/coze-dev/coze-loop/backend/modules/prompt/domain/component/rpc" + "github.com/coze-dev/coze-loop/backend/modules/prompt/domain/component/rpc/mocks" + "github.com/coze-dev/coze-loop/backend/modules/prompt/domain/entity/toolmgmt" + "github.com/coze-dev/coze-loop/backend/modules/prompt/domain/repo" + repomocks "github.com/coze-dev/coze-loop/backend/modules/prompt/domain/repo/mocks" + prompterr "github.com/coze-dev/coze-loop/backend/modules/prompt/pkg/errno" + "github.com/coze-dev/coze-loop/backend/pkg/errorx" + "github.com/coze-dev/coze-loop/backend/pkg/lang/ptr" + "github.com/coze-dev/coze-loop/backend/pkg/unittest" +) + +func ctxWithUser(userID string) context.Context { + return session.WithCtxUser(context.Background(), &session.User{ID: userID}) +} + +// --- CreateTool unit tests --- + +func TestCreateTool_UserNotFound(t *testing.T) { + t.Parallel() + + app := &ToolManageApplicationImpl{} + tests := []struct { + name string + ctx context.Context + }{ + {name: "no user in context", ctx: context.Background()}, + {name: "empty user id", ctx: ctxWithUser("")}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + req := &toolmanage.CreateToolRequest{ + WorkspaceID: ptr.Of(int64(100)), + ToolName: ptr.Of("example-tool"), + } + _, err := app.CreateTool(tt.ctx, req) + unittest.AssertErrorEqual(t, errorx.NewByCode(prompterr.CommonInvalidParamCode), err) + }) + } +} + +func TestCreateTool_InvalidWorkspaceID(t *testing.T) { + t.Parallel() + + tests := []struct { + name string + workspaceID int64 + }{ + {name: "workspace_id is zero", workspaceID: 0}, + {name: "workspace_id is negative", workspaceID: -1}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + app := &ToolManageApplicationImpl{} + req := &toolmanage.CreateToolRequest{ + WorkspaceID: ptr.Of(tt.workspaceID), + ToolName: ptr.Of("example-tool"), + } + _, err := app.CreateTool(ctxWithUser("user-1"), req) + unittest.AssertErrorEqual(t, errorx.NewByCode(prompterr.CommonInvalidParamCode), err) + }) + } +} + +func TestCreateTool_PermissionCheckError(t *testing.T) { + t.Parallel() + ctrl := gomock.NewController(t) + + mockAuth := mocks.NewMockIAuthProvider(ctrl) + mockAuth.EXPECT().CheckSpacePermission(gomock.Any(), int64(100), gomock.Any()).Return(errorx.New("permission denied")) + + app := &ToolManageApplicationImpl{authRPCProvider: mockAuth} + req := &toolmanage.CreateToolRequest{ + WorkspaceID: ptr.Of(int64(100)), + ToolName: ptr.Of("example-tool"), + } + _, err := app.CreateTool(ctxWithUser("user-1"), req) + assert.Error(t, err) + assert.Contains(t, err.Error(), "permission denied") +} + +func TestCreateTool_DraftDetailNil(t *testing.T) { + t.Parallel() + ctrl := gomock.NewController(t) + + mockAuth := mocks.NewMockIAuthProvider(ctrl) + mockAuth.EXPECT().CheckSpacePermission(gomock.Any(), int64(100), gomock.Any()).Return(nil) + + mockToolRepo := repomocks.NewMockIToolRepo(ctrl) + mockToolRepo.EXPECT().CreateTool(gomock.Any(), gomock.Any()).DoAndReturn( + func(ctx context.Context, tool *toolmgmt.Tool) (int64, error) { + assert.Empty(t, tool.ToolCommit.ToolDetail.Content, "content should be empty when DraftDetail is nil") + return 12345, nil + }, + ) + + app := &ToolManageApplicationImpl{ + toolRepo: mockToolRepo, + authRPCProvider: mockAuth, + } + req := &toolmanage.CreateToolRequest{ + WorkspaceID: ptr.Of(int64(100)), + ToolName: ptr.Of("example-tool"), + ToolDescription: ptr.Of("desc"), + DraftDetail: nil, + } + resp, err := app.CreateTool(ctxWithUser("user-1"), req) + assert.NoError(t, err) + assert.Equal(t, int64(12345), resp.GetToolID()) +} + +func TestCreateTool_DraftDetailWithContent(t *testing.T) { + t.Parallel() + ctrl := gomock.NewController(t) + + mockAuth := mocks.NewMockIAuthProvider(ctrl) + mockAuth.EXPECT().CheckSpacePermission(gomock.Any(), int64(100), gomock.Any()).Return(nil) + + mockToolRepo := repomocks.NewMockIToolRepo(ctrl) + mockToolRepo.EXPECT().CreateTool(gomock.Any(), gomock.Any()).DoAndReturn( + func(ctx context.Context, tool *toolmgmt.Tool) (int64, error) { + assert.Equal(t, "some content", tool.ToolCommit.ToolDetail.Content) + assert.Equal(t, "user-1", tool.ToolBasic.CreatedBy) + assert.Equal(t, "user-1", tool.ToolBasic.UpdatedBy) + assert.Equal(t, toolmgmt.PublicDraftVersion, tool.ToolCommit.CommitInfo.Version) + return 99, nil + }, + ) + + app := &ToolManageApplicationImpl{ + toolRepo: mockToolRepo, + authRPCProvider: mockAuth, + } + req := &toolmanage.CreateToolRequest{ + WorkspaceID: ptr.Of(int64(100)), + ToolName: ptr.Of("example-tool"), + ToolDescription: ptr.Of("desc"), + DraftDetail: &toolDTO.ToolDetail{Content: ptr.Of("some content")}, + } + resp, err := app.CreateTool(ctxWithUser("user-1"), req) + assert.NoError(t, err) + assert.Equal(t, int64(99), resp.GetToolID()) +} + +func TestCreateTool_RepoError(t *testing.T) { + t.Parallel() + ctrl := gomock.NewController(t) + + mockAuth := mocks.NewMockIAuthProvider(ctrl) + mockAuth.EXPECT().CheckSpacePermission(gomock.Any(), int64(100), gomock.Any()).Return(nil) + + mockToolRepo := repomocks.NewMockIToolRepo(ctrl) + mockToolRepo.EXPECT().CreateTool(gomock.Any(), gomock.Any()).Return(int64(0), errorx.New("db error")) + + app := &ToolManageApplicationImpl{ + toolRepo: mockToolRepo, + authRPCProvider: mockAuth, + } + req := &toolmanage.CreateToolRequest{ + WorkspaceID: ptr.Of(int64(100)), + ToolName: ptr.Of("example-tool"), + } + _, err := app.CreateTool(ctxWithUser("user-1"), req) + assert.Error(t, err) + assert.Contains(t, err.Error(), "db error") +} + +// --- GetToolDetail unit tests --- + +func TestGetToolDetail_UserNotFound(t *testing.T) { + t.Parallel() + app := &ToolManageApplicationImpl{} + req := &toolmanage.GetToolDetailRequest{ + ToolID: ptr.Of(int64(1)), + WorkspaceID: ptr.Of(int64(100)), + } + _, err := app.GetToolDetail(context.Background(), req) + unittest.AssertErrorEqual(t, errorx.NewByCode(prompterr.CommonInvalidParamCode), err) +} + +func TestGetToolDetail_InvalidToolID(t *testing.T) { + t.Parallel() + + tests := []struct { + name string + toolID int64 + }{ + {name: "tool_id is zero", toolID: 0}, + {name: "tool_id is negative", toolID: -5}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + app := &ToolManageApplicationImpl{} + req := &toolmanage.GetToolDetailRequest{ + ToolID: ptr.Of(tt.toolID), + WorkspaceID: ptr.Of(int64(100)), + } + _, err := app.GetToolDetail(ctxWithUser("user-1"), req) + unittest.AssertErrorEqual(t, errorx.NewByCode(prompterr.CommonInvalidParamCode), err) + }) + } +} + +func TestGetToolDetail_InvalidWorkspaceID(t *testing.T) { + t.Parallel() + app := &ToolManageApplicationImpl{} + req := &toolmanage.GetToolDetailRequest{ + ToolID: ptr.Of(int64(1)), + WorkspaceID: ptr.Of(int64(0)), + } + _, err := app.GetToolDetail(ctxWithUser("user-1"), req) + unittest.AssertErrorEqual(t, errorx.NewByCode(prompterr.CommonInvalidParamCode), err) +} + +func TestGetToolDetail_ToolNotFound(t *testing.T) { + t.Parallel() + ctrl := gomock.NewController(t) + + mockAuth := mocks.NewMockIAuthProvider(ctrl) + mockAuth.EXPECT().CheckSpacePermission(gomock.Any(), int64(100), gomock.Any()).Return(nil) + + mockToolRepo := repomocks.NewMockIToolRepo(ctrl) + mockToolRepo.EXPECT().GetTool(gomock.Any(), gomock.Any()).Return(nil, nil) + + app := &ToolManageApplicationImpl{ + toolRepo: mockToolRepo, + authRPCProvider: mockAuth, + } + req := &toolmanage.GetToolDetailRequest{ + ToolID: ptr.Of(int64(999)), + WorkspaceID: ptr.Of(int64(100)), + } + _, err := app.GetToolDetail(ctxWithUser("user-1"), req) + unittest.AssertErrorEqual(t, errorx.NewByCode(prompterr.ResourceNotFoundCode), err) +} + +func TestGetToolDetail_SpaceIDMismatch(t *testing.T) { + t.Parallel() + ctrl := gomock.NewController(t) + + mockAuth := mocks.NewMockIAuthProvider(ctrl) + mockAuth.EXPECT().CheckSpacePermission(gomock.Any(), int64(100), gomock.Any()).Return(nil) + + mockToolRepo := repomocks.NewMockIToolRepo(ctrl) + mockToolRepo.EXPECT().GetTool(gomock.Any(), gomock.Any()).Return(&toolmgmt.Tool{ + ID: 1, + SpaceID: 200, // different from requested workspace_id=100 + }, nil) + + app := &ToolManageApplicationImpl{ + toolRepo: mockToolRepo, + authRPCProvider: mockAuth, + } + req := &toolmanage.GetToolDetailRequest{ + ToolID: ptr.Of(int64(1)), + WorkspaceID: ptr.Of(int64(100)), + } + _, err := app.GetToolDetail(ctxWithUser("user-1"), req) + unittest.AssertErrorEqual(t, errorx.NewByCode(prompterr.ResourceNotFoundCode), err) +} + +// --- ListTool unit tests --- + +func TestListTool_InvalidPagination(t *testing.T) { + t.Parallel() + + tests := []struct { + name string + pageNum int32 + pageSize int32 + }{ + {name: "page_num is zero", pageNum: 0, pageSize: 10}, + {name: "page_size is zero", pageNum: 1, pageSize: 0}, + {name: "page_num is negative", pageNum: -1, pageSize: 10}, + {name: "page_size is negative", pageNum: 1, pageSize: -1}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + app := &ToolManageApplicationImpl{} + req := &toolmanage.ListToolRequest{ + WorkspaceID: ptr.Of(int64(100)), + PageNum: ptr.Of(tt.pageNum), + PageSize: ptr.Of(tt.pageSize), + } + _, err := app.ListTool(ctxWithUser("user-1"), req) + unittest.AssertErrorEqual(t, errorx.NewByCode(prompterr.CommonInvalidParamCode), err) + }) + } +} + +func TestListTool_NilListResult(t *testing.T) { + t.Parallel() + ctrl := gomock.NewController(t) + + mockAuth := mocks.NewMockIAuthProvider(ctrl) + mockAuth.EXPECT().CheckSpacePermission(gomock.Any(), int64(100), gomock.Any()).Return(nil) + + mockToolRepo := repomocks.NewMockIToolRepo(ctrl) + mockToolRepo.EXPECT().ListTool(gomock.Any(), gomock.Any()).Return(nil, nil) + + app := &ToolManageApplicationImpl{ + toolRepo: mockToolRepo, + authRPCProvider: mockAuth, + } + req := &toolmanage.ListToolRequest{ + WorkspaceID: ptr.Of(int64(100)), + PageNum: ptr.Of(int32(1)), + PageSize: ptr.Of(int32(10)), + } + resp, err := app.ListTool(ctxWithUser("user-1"), req) + assert.NoError(t, err) + assert.Nil(t, resp.Tools) +} + +func TestListTool_UserInfoFetchError(t *testing.T) { + t.Parallel() + ctrl := gomock.NewController(t) + + mockAuth := mocks.NewMockIAuthProvider(ctrl) + mockAuth.EXPECT().CheckSpacePermission(gomock.Any(), int64(100), gomock.Any()).Return(nil) + + mockToolRepo := repomocks.NewMockIToolRepo(ctrl) + mockToolRepo.EXPECT().ListTool(gomock.Any(), gomock.Any()).Return(&repo.ListToolResult{ + Total: 1, + Tools: []*toolmgmt.Tool{ + { + ID: 1, + SpaceID: 100, + ToolBasic: &toolmgmt.ToolBasic{ + Name: "example-tool", + CreatedBy: "user-1", + UpdatedBy: "user-2", + }, + }, + }, + }, nil) + + mockUser := mocks.NewMockIUserProvider(ctrl) + mockUser.EXPECT().MGetUserInfo(gomock.Any(), gomock.Any()).Return(nil, errorx.New("user rpc error")) + + app := &ToolManageApplicationImpl{ + toolRepo: mockToolRepo, + authRPCProvider: mockAuth, + userRPCProvider: mockUser, + } + req := &toolmanage.ListToolRequest{ + WorkspaceID: ptr.Of(int64(100)), + PageNum: ptr.Of(int32(1)), + PageSize: ptr.Of(int32(10)), + } + _, err := app.ListTool(ctxWithUser("user-1"), req) + assert.Error(t, err) + assert.Contains(t, err.Error(), "user rpc error") +} + +// --- listToolOrderBy unit tests --- + +func TestListToolOrderBy(t *testing.T) { + t.Parallel() + + app := &ToolManageApplicationImpl{} + + tests := []struct { + name string + orderBy *toolmanage.ListToolOrderBy + expected int + }{ + {name: "nil orderBy defaults to ID", orderBy: nil, expected: 1}, + {name: "committed_at", orderBy: ptr.Of(toolmanage.ListToolOrderByCommittedAt), expected: 4}, + {name: "created_at", orderBy: ptr.Of(toolmanage.ListToolOrderByCreatedAt), expected: 2}, + {name: "unknown value defaults to ID", orderBy: ptr.Of(toolmanage.ListToolOrderBy("unknown_order")), expected: 1}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + result := app.listToolOrderBy(tt.orderBy) + assert.Equal(t, tt.expected, result) + }) + } +} + +// --- SaveToolDetail unit tests --- + +func TestSaveToolDetail_InvalidParams(t *testing.T) { + t.Parallel() + + tests := []struct { + name string + req *toolmanage.SaveToolDetailRequest + }{ + { + name: "tool_id is zero", + req: &toolmanage.SaveToolDetailRequest{ + ToolID: ptr.Of(int64(0)), + WorkspaceID: ptr.Of(int64(100)), + ToolDetail: &toolDTO.ToolDetail{Content: ptr.Of("content")}, + }, + }, + { + name: "tool_detail is nil", + req: &toolmanage.SaveToolDetailRequest{ + ToolID: ptr.Of(int64(1)), + WorkspaceID: ptr.Of(int64(100)), + ToolDetail: nil, + }, + }, + { + name: "workspace_id is zero", + req: &toolmanage.SaveToolDetailRequest{ + ToolID: ptr.Of(int64(1)), + WorkspaceID: ptr.Of(int64(0)), + ToolDetail: &toolDTO.ToolDetail{Content: ptr.Of("content")}, + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + app := &ToolManageApplicationImpl{} + _, err := app.SaveToolDetail(ctxWithUser("user-1"), tt.req) + unittest.AssertErrorEqual(t, errorx.NewByCode(prompterr.CommonInvalidParamCode), err) + }) + } +} + +func TestSaveToolDetail_ToolNotFound(t *testing.T) { + t.Parallel() + ctrl := gomock.NewController(t) + + mockAuth := mocks.NewMockIAuthProvider(ctrl) + mockAuth.EXPECT().CheckSpacePermission(gomock.Any(), int64(100), gomock.Any()).Return(nil) + + mockToolRepo := repomocks.NewMockIToolRepo(ctrl) + mockToolRepo.EXPECT().GetTool(gomock.Any(), gomock.Any()).Return(nil, nil) + + app := &ToolManageApplicationImpl{ + toolRepo: mockToolRepo, + authRPCProvider: mockAuth, + } + req := &toolmanage.SaveToolDetailRequest{ + ToolID: ptr.Of(int64(999)), + WorkspaceID: ptr.Of(int64(100)), + ToolDetail: &toolDTO.ToolDetail{Content: ptr.Of("content")}, + } + _, err := app.SaveToolDetail(ctxWithUser("user-1"), req) + unittest.AssertErrorEqual(t, errorx.NewByCode(prompterr.ResourceNotFoundCode), err) +} + +func TestSaveToolDetail_SpaceIDMismatch(t *testing.T) { + t.Parallel() + ctrl := gomock.NewController(t) + + mockAuth := mocks.NewMockIAuthProvider(ctrl) + mockAuth.EXPECT().CheckSpacePermission(gomock.Any(), int64(100), gomock.Any()).Return(nil) + + mockToolRepo := repomocks.NewMockIToolRepo(ctrl) + mockToolRepo.EXPECT().GetTool(gomock.Any(), gomock.Any()).Return(&toolmgmt.Tool{ + ID: 999, + SpaceID: 200, + }, nil) + + app := &ToolManageApplicationImpl{ + toolRepo: mockToolRepo, + authRPCProvider: mockAuth, + } + req := &toolmanage.SaveToolDetailRequest{ + ToolID: ptr.Of(int64(999)), + WorkspaceID: ptr.Of(int64(100)), + ToolDetail: &toolDTO.ToolDetail{Content: ptr.Of("content")}, + } + _, err := app.SaveToolDetail(ctxWithUser("user-1"), req) + unittest.AssertErrorEqual(t, errorx.NewByCode(prompterr.ResourceNotFoundCode), err) +} + +// --- CommitToolDraft unit tests --- + +func TestCommitToolDraft_InvalidSemver(t *testing.T) { + t.Parallel() + + tests := []struct { + name string + version string + }{ + {name: "empty version", version: ""}, + {name: "invalid format", version: "not-a-version"}, + {name: "missing patch", version: "1.0"}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + app := &ToolManageApplicationImpl{} + req := &toolmanage.CommitToolDraftRequest{ + ToolID: ptr.Of(int64(1)), + WorkspaceID: ptr.Of(int64(100)), + CommitVersion: ptr.Of(tt.version), + } + _, err := app.CommitToolDraft(ctxWithUser("user-1"), req) + assert.Error(t, err) + }) + } +} + +func TestCommitToolDraft_InvalidToolID(t *testing.T) { + t.Parallel() + app := &ToolManageApplicationImpl{} + req := &toolmanage.CommitToolDraftRequest{ + ToolID: ptr.Of(int64(0)), + WorkspaceID: ptr.Of(int64(100)), + CommitVersion: ptr.Of("1.0.0"), + } + _, err := app.CommitToolDraft(ctxWithUser("user-1"), req) + unittest.AssertErrorEqual(t, errorx.NewByCode(prompterr.CommonInvalidParamCode), err) +} + +func TestCommitToolDraft_InvalidWorkspaceID(t *testing.T) { + t.Parallel() + + ctrl := gomock.NewController(t) + mockAuth := mocks.NewMockIAuthProvider(ctrl) + // No expectation needed since validation should fail before permission check + + app := &ToolManageApplicationImpl{authRPCProvider: mockAuth} + req := &toolmanage.CommitToolDraftRequest{ + ToolID: ptr.Of(int64(1)), + WorkspaceID: ptr.Of(int64(0)), + CommitVersion: ptr.Of("1.0.0"), + } + _, err := app.CommitToolDraft(ctxWithUser("user-1"), req) + unittest.AssertErrorEqual(t, errorx.NewByCode(prompterr.CommonInvalidParamCode), err) +} + +func TestCommitToolDraft_SpaceIDMismatch(t *testing.T) { + t.Parallel() + ctrl := gomock.NewController(t) + + mockAuth := mocks.NewMockIAuthProvider(ctrl) + mockAuth.EXPECT().CheckSpacePermission(gomock.Any(), int64(100), gomock.Any()).Return(nil) + + mockToolRepo := repomocks.NewMockIToolRepo(ctrl) + mockToolRepo.EXPECT().GetTool(gomock.Any(), gomock.Any()).Return(&toolmgmt.Tool{ + ID: 1, + SpaceID: 200, + }, nil) + + app := &ToolManageApplicationImpl{ + toolRepo: mockToolRepo, + authRPCProvider: mockAuth, + } + req := &toolmanage.CommitToolDraftRequest{ + ToolID: ptr.Of(int64(1)), + WorkspaceID: ptr.Of(int64(100)), + CommitVersion: ptr.Of("1.0.0"), + } + _, err := app.CommitToolDraft(ctxWithUser("user-1"), req) + unittest.AssertErrorEqual(t, errorx.NewByCode(prompterr.ResourceNotFoundCode), err) +} + +// --- ListToolCommit unit tests --- + +func TestListToolCommit_InvalidPageToken(t *testing.T) { + t.Parallel() + ctrl := gomock.NewController(t) + + mockAuth := mocks.NewMockIAuthProvider(ctrl) + mockAuth.EXPECT().CheckSpacePermission(gomock.Any(), int64(100), gomock.Any()).Return(nil) + + mockToolRepo := repomocks.NewMockIToolRepo(ctrl) + mockToolRepo.EXPECT().GetTool(gomock.Any(), gomock.Any()).Return(&toolmgmt.Tool{ + ID: 1, + SpaceID: 100, + }, nil) + + app := &ToolManageApplicationImpl{ + toolRepo: mockToolRepo, + authRPCProvider: mockAuth, + } + req := &toolmanage.ListToolCommitRequest{ + ToolID: ptr.Of(int64(1)), + WorkspaceID: ptr.Of(int64(100)), + PageSize: ptr.Of(int32(10)), + PageToken: ptr.Of("not-a-number"), + } + _, err := app.ListToolCommit(ctxWithUser("user-1"), req) + unittest.AssertErrorEqual(t, errorx.NewByCode(prompterr.CommonInvalidParamCode), err) +} + +func TestListToolCommit_NilListResult(t *testing.T) { + t.Parallel() + ctrl := gomock.NewController(t) + + mockAuth := mocks.NewMockIAuthProvider(ctrl) + mockAuth.EXPECT().CheckSpacePermission(gomock.Any(), int64(100), gomock.Any()).Return(nil) + + mockToolRepo := repomocks.NewMockIToolRepo(ctrl) + mockToolRepo.EXPECT().GetTool(gomock.Any(), gomock.Any()).Return(&toolmgmt.Tool{ID: 1, SpaceID: 100}, nil) + mockToolRepo.EXPECT().ListToolCommit(gomock.Any(), gomock.Any()).Return(nil, nil) + + app := &ToolManageApplicationImpl{ + toolRepo: mockToolRepo, + authRPCProvider: mockAuth, + } + req := &toolmanage.ListToolCommitRequest{ + ToolID: ptr.Of(int64(1)), + WorkspaceID: ptr.Of(int64(100)), + PageSize: ptr.Of(int32(10)), + } + resp, err := app.ListToolCommit(ctxWithUser("user-1"), req) + assert.NoError(t, err) + assert.Nil(t, resp.ToolCommitInfos) +} + +func TestListToolCommit_WithCommitDetailAndNextPage(t *testing.T) { + t.Parallel() + ctrl := gomock.NewController(t) + + mockAuth := mocks.NewMockIAuthProvider(ctrl) + mockAuth.EXPECT().CheckSpacePermission(gomock.Any(), int64(100), gomock.Any()).Return(nil) + + mockToolRepo := repomocks.NewMockIToolRepo(ctrl) + mockToolRepo.EXPECT().GetTool(gomock.Any(), gomock.Any()).Return(&toolmgmt.Tool{ID: 1, SpaceID: 100}, nil) + mockToolRepo.EXPECT().ListToolCommit(gomock.Any(), gomock.Any()).Return(&repo.ListToolCommitResult{ + CommitInfos: []*toolmgmt.CommitInfo{ + {Version: "1.0.0", CommittedBy: "user-1"}, + }, + CommitDetails: map[string]*toolmgmt.ToolDetail{ + "1.0.0": {Content: "detail-content"}, + }, + NextPageToken: 12345, + }, nil) + + mockUser := mocks.NewMockIUserProvider(ctrl) + mockUser.EXPECT().MGetUserInfo(gomock.Any(), gomock.Any()).Return([]*rpc.UserInfo{ + {UserID: "user-1", UserName: "Demo User"}, + }, nil) + + app := &ToolManageApplicationImpl{ + toolRepo: mockToolRepo, + authRPCProvider: mockAuth, + userRPCProvider: mockUser, + } + req := &toolmanage.ListToolCommitRequest{ + ToolID: ptr.Of(int64(1)), + WorkspaceID: ptr.Of(int64(100)), + PageSize: ptr.Of(int32(10)), + WithCommitDetail: ptr.Of(true), + } + resp, err := app.ListToolCommit(ctxWithUser("user-1"), req) + assert.NoError(t, err) + assert.NotNil(t, resp.NextPageToken) + assert.Equal(t, "12345", resp.GetNextPageToken()) + assert.True(t, resp.GetHasMore()) + assert.Len(t, resp.ToolCommitInfos, 1) + assert.NotNil(t, resp.ToolCommitDetailMapping) + assert.NotNil(t, resp.Users) +} + +func TestListToolCommit_NilCommitInfoSkipped(t *testing.T) { + t.Parallel() + ctrl := gomock.NewController(t) + + mockAuth := mocks.NewMockIAuthProvider(ctrl) + mockAuth.EXPECT().CheckSpacePermission(gomock.Any(), int64(100), gomock.Any()).Return(nil) + + mockToolRepo := repomocks.NewMockIToolRepo(ctrl) + mockToolRepo.EXPECT().GetTool(gomock.Any(), gomock.Any()).Return(&toolmgmt.Tool{ID: 1, SpaceID: 100}, nil) + mockToolRepo.EXPECT().ListToolCommit(gomock.Any(), gomock.Any()).Return(&repo.ListToolCommitResult{ + CommitInfos: []*toolmgmt.CommitInfo{ + nil, + {Version: "1.0.0", CommittedBy: "user-1"}, + nil, + }, + NextPageToken: 0, + }, nil) + + mockUser := mocks.NewMockIUserProvider(ctrl) + mockUser.EXPECT().MGetUserInfo(gomock.Any(), gomock.Any()).Return(nil, nil) + + app := &ToolManageApplicationImpl{ + toolRepo: mockToolRepo, + authRPCProvider: mockAuth, + userRPCProvider: mockUser, + } + req := &toolmanage.ListToolCommitRequest{ + ToolID: ptr.Of(int64(1)), + WorkspaceID: ptr.Of(int64(100)), + PageSize: ptr.Of(int32(10)), + } + resp, err := app.ListToolCommit(ctxWithUser("user-1"), req) + assert.NoError(t, err) + assert.Len(t, resp.ToolCommitInfos, 1) + assert.Nil(t, resp.HasMore) +} + +func TestListToolCommit_UserInfoFetchError(t *testing.T) { + t.Parallel() + ctrl := gomock.NewController(t) + + mockAuth := mocks.NewMockIAuthProvider(ctrl) + mockAuth.EXPECT().CheckSpacePermission(gomock.Any(), int64(100), gomock.Any()).Return(nil) + + mockToolRepo := repomocks.NewMockIToolRepo(ctrl) + mockToolRepo.EXPECT().GetTool(gomock.Any(), gomock.Any()).Return(&toolmgmt.Tool{ID: 1, SpaceID: 100}, nil) + mockToolRepo.EXPECT().ListToolCommit(gomock.Any(), gomock.Any()).Return(&repo.ListToolCommitResult{ + CommitInfos: []*toolmgmt.CommitInfo{ + {Version: "1.0.0", CommittedBy: "user-1"}, + }, + }, nil) + + mockUser := mocks.NewMockIUserProvider(ctrl) + mockUser.EXPECT().MGetUserInfo(gomock.Any(), gomock.Any()).Return(nil, errorx.New("user rpc error")) + + app := &ToolManageApplicationImpl{ + toolRepo: mockToolRepo, + authRPCProvider: mockAuth, + userRPCProvider: mockUser, + } + req := &toolmanage.ListToolCommitRequest{ + ToolID: ptr.Of(int64(1)), + WorkspaceID: ptr.Of(int64(100)), + PageSize: ptr.Of(int32(10)), + } + resp, err := app.ListToolCommit(ctxWithUser("user-1"), req) + assert.Error(t, err) + // When user fetch fails, the method returns a fresh response + assert.NotNil(t, resp) +} + +// --- BatchGetTools unit tests --- + +func TestBatchGetTools_EmptyQueries(t *testing.T) { + t.Parallel() + app := &ToolManageApplicationImpl{} + req := &toolmanage.BatchGetToolsRequest{ + WorkspaceID: ptr.Of(int64(100)), + Queries: []*toolmanage.ToolQuery{}, + } + _, err := app.BatchGetTools(ctxWithUser("user-1"), req) + unittest.AssertErrorEqual(t, errorx.NewByCode(prompterr.CommonInvalidParamCode), err) +} + +func TestBatchGetTools_NilQueriesSkipped(t *testing.T) { + t.Parallel() + ctrl := gomock.NewController(t) + + mockAuth := mocks.NewMockIAuthProvider(ctrl) + mockAuth.EXPECT().CheckSpacePermission(gomock.Any(), int64(100), gomock.Any()).Return(nil) + + mockToolRepo := repomocks.NewMockIToolRepo(ctrl) + // After filtering nil queries, should still call BatchGetTools with non-nil entries + mockToolRepo.EXPECT().BatchGetTools(gomock.Any(), gomock.Any()).DoAndReturn( + func(ctx context.Context, param repo.BatchGetToolsParam) ([]*repo.BatchGetToolsResult, error) { + assert.Len(t, param.Queries, 1) + assert.Equal(t, int64(1), param.Queries[0].ToolID) + return []*repo.BatchGetToolsResult{ + { + Query: repo.BatchGetToolsQuery{ToolID: 1, Version: "1.0.0"}, + Tool: &toolmgmt.Tool{ + ID: 1, + SpaceID: 100, + }, + }, + }, nil + }, + ) + + app := &ToolManageApplicationImpl{ + toolRepo: mockToolRepo, + authRPCProvider: mockAuth, + } + req := &toolmanage.BatchGetToolsRequest{ + WorkspaceID: ptr.Of(int64(100)), + Queries: []*toolmanage.ToolQuery{ + nil, + {ToolID: ptr.Of(int64(1)), Version: ptr.Of("1.0.0")}, + nil, + }, + } + resp, err := app.BatchGetTools(ctxWithUser("user-1"), req) + assert.NoError(t, err) + assert.Len(t, resp.Items, 1) +} + +func TestBatchGetTools_NilResultsSkipped(t *testing.T) { + t.Parallel() + ctrl := gomock.NewController(t) + + mockAuth := mocks.NewMockIAuthProvider(ctrl) + mockAuth.EXPECT().CheckSpacePermission(gomock.Any(), int64(100), gomock.Any()).Return(nil) + + mockToolRepo := repomocks.NewMockIToolRepo(ctrl) + mockToolRepo.EXPECT().BatchGetTools(gomock.Any(), gomock.Any()).Return([]*repo.BatchGetToolsResult{ + nil, + {Query: repo.BatchGetToolsQuery{ToolID: 1, Version: "1.0.0"}, Tool: nil}, + {Query: repo.BatchGetToolsQuery{ToolID: 2, Version: "1.0.0"}, Tool: &toolmgmt.Tool{ID: 2, SpaceID: 100}}, + }, nil) + + app := &ToolManageApplicationImpl{ + toolRepo: mockToolRepo, + authRPCProvider: mockAuth, + } + req := &toolmanage.BatchGetToolsRequest{ + WorkspaceID: ptr.Of(int64(100)), + Queries: []*toolmanage.ToolQuery{ + {ToolID: ptr.Of(int64(1)), Version: ptr.Of("1.0.0")}, + {ToolID: ptr.Of(int64(2)), Version: ptr.Of("1.0.0")}, + }, + } + resp, err := app.BatchGetTools(ctxWithUser("user-1"), req) + assert.NoError(t, err) + assert.Len(t, resp.Items, 1) + assert.Equal(t, int64(2), resp.Items[0].Tool.GetID()) +} + diff --git a/backend/modules/prompt/domain/entity/toolmgmt/tool_unit_test.go b/backend/modules/prompt/domain/entity/toolmgmt/tool_unit_test.go new file mode 100644 index 000000000..18c143dc9 --- /dev/null +++ b/backend/modules/prompt/domain/entity/toolmgmt/tool_unit_test.go @@ -0,0 +1,35 @@ +package toolmgmt + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestCommitInfo_IsPublicDraft(t *testing.T) { + t.Parallel() + + tests := []struct { + name string + version string + expected bool + }{ + {name: "public draft version", version: PublicDraftVersion, expected: true}, + {name: "normal version", version: "1.0.0", expected: false}, + {name: "empty version", version: "", expected: false}, + {name: "similar but not exact", version: "$PublicDraf", expected: false}, + {name: "with extra suffix", version: PublicDraftVersion + "x", expected: false}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + ci := CommitInfo{Version: tt.version} + assert.Equal(t, tt.expected, ci.IsPublicDraft()) + }) + } +} + +func TestPublicDraftVersionConst(t *testing.T) { + t.Parallel() + assert.Equal(t, "$PublicDraft", PublicDraftVersion) +} diff --git a/backend/modules/prompt/domain/repo/mocks/tool_repo.go b/backend/modules/prompt/domain/repo/mocks/tool_repo.go new file mode 100644 index 000000000..b678729b4 --- /dev/null +++ b/backend/modules/prompt/domain/repo/mocks/tool_repo.go @@ -0,0 +1,160 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/coze-dev/coze-loop/backend/modules/prompt/domain/repo (interfaces: IToolRepo) +// +// Generated by this command: +// +// mockgen -destination=mocks/tool_repo.go -package=mocks . IToolRepo +// + +// Package mocks is a generated GoMock package. +package mocks + +import ( + context "context" + reflect "reflect" + + toolmgmt "github.com/coze-dev/coze-loop/backend/modules/prompt/domain/entity/toolmgmt" + repo "github.com/coze-dev/coze-loop/backend/modules/prompt/domain/repo" + gomock "go.uber.org/mock/gomock" +) + +// MockIToolRepo is a mock of IToolRepo interface. +type MockIToolRepo struct { + ctrl *gomock.Controller + recorder *MockIToolRepoMockRecorder + isgomock struct{} +} + +// MockIToolRepoMockRecorder is the mock recorder for MockIToolRepo. +type MockIToolRepoMockRecorder struct { + mock *MockIToolRepo +} + +// NewMockIToolRepo creates a new mock instance. +func NewMockIToolRepo(ctrl *gomock.Controller) *MockIToolRepo { + mock := &MockIToolRepo{ctrl: ctrl} + mock.recorder = &MockIToolRepoMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockIToolRepo) EXPECT() *MockIToolRepoMockRecorder { + return m.recorder +} + +// CreateTool mocks base method. +func (m *MockIToolRepo) CreateTool(ctx context.Context, tool *toolmgmt.Tool) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTool", ctx, tool) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTool indicates an expected call of CreateTool. +func (mr *MockIToolRepoMockRecorder) CreateTool(ctx, tool any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTool", reflect.TypeOf((*MockIToolRepo)(nil).CreateTool), ctx, tool) +} + +// DeleteTool mocks base method. +func (m *MockIToolRepo) DeleteTool(ctx context.Context, toolID int64) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTool", ctx, toolID) + ret0, _ := ret[0].(error) + return ret0 +} + +// DeleteTool indicates an expected call of DeleteTool. +func (mr *MockIToolRepoMockRecorder) DeleteTool(ctx, toolID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTool", reflect.TypeOf((*MockIToolRepo)(nil).DeleteTool), ctx, toolID) +} + +// GetTool mocks base method. +func (m *MockIToolRepo) GetTool(ctx context.Context, param repo.GetToolParam) (*toolmgmt.Tool, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTool", ctx, param) + ret0, _ := ret[0].(*toolmgmt.Tool) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTool indicates an expected call of GetTool. +func (mr *MockIToolRepoMockRecorder) GetTool(ctx, param any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTool", reflect.TypeOf((*MockIToolRepo)(nil).GetTool), ctx, param) +} + +// BatchGetTools mocks base method. +func (m *MockIToolRepo) BatchGetTools(ctx context.Context, param repo.BatchGetToolsParam) ([]*repo.BatchGetToolsResult, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BatchGetTools", ctx, param) + ret0, _ := ret[0].([]*repo.BatchGetToolsResult) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BatchGetTools indicates an expected call of BatchGetTools. +func (mr *MockIToolRepoMockRecorder) BatchGetTools(ctx, param any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetTools", reflect.TypeOf((*MockIToolRepo)(nil).BatchGetTools), ctx, param) +} + +// ListTool mocks base method. +func (m *MockIToolRepo) ListTool(ctx context.Context, param repo.ListToolParam) (*repo.ListToolResult, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListTool", ctx, param) + ret0, _ := ret[0].(*repo.ListToolResult) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListTool indicates an expected call of ListTool. +func (mr *MockIToolRepoMockRecorder) ListTool(ctx, param any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTool", reflect.TypeOf((*MockIToolRepo)(nil).ListTool), ctx, param) +} + +// SaveToolDetail mocks base method. +func (m *MockIToolRepo) SaveToolDetail(ctx context.Context, param repo.SaveToolDetailParam) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SaveToolDetail", ctx, param) + ret0, _ := ret[0].(error) + return ret0 +} + +// SaveToolDetail indicates an expected call of SaveToolDetail. +func (mr *MockIToolRepoMockRecorder) SaveToolDetail(ctx, param any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveToolDetail", reflect.TypeOf((*MockIToolRepo)(nil).SaveToolDetail), ctx, param) +} + +// CommitToolDraft mocks base method. +func (m *MockIToolRepo) CommitToolDraft(ctx context.Context, param repo.CommitToolDraftParam) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CommitToolDraft", ctx, param) + ret0, _ := ret[0].(error) + return ret0 +} + +// CommitToolDraft indicates an expected call of CommitToolDraft. +func (mr *MockIToolRepoMockRecorder) CommitToolDraft(ctx, param any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommitToolDraft", reflect.TypeOf((*MockIToolRepo)(nil).CommitToolDraft), ctx, param) +} + +// ListToolCommit mocks base method. +func (m *MockIToolRepo) ListToolCommit(ctx context.Context, param repo.ListToolCommitParam) (*repo.ListToolCommitResult, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListToolCommit", ctx, param) + ret0, _ := ret[0].(*repo.ListToolCommitResult) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListToolCommit indicates an expected call of ListToolCommit. +func (mr *MockIToolRepoMockRecorder) ListToolCommit(ctx, param any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListToolCommit", reflect.TypeOf((*MockIToolRepo)(nil).ListToolCommit), ctx, param) +} diff --git a/backend/modules/prompt/infra/repo/mysql/convertor/tool_unit_test.go b/backend/modules/prompt/infra/repo/mysql/convertor/tool_unit_test.go new file mode 100644 index 000000000..5415b994f --- /dev/null +++ b/backend/modules/prompt/infra/repo/mysql/convertor/tool_unit_test.go @@ -0,0 +1,146 @@ +package convertor + +import ( + "testing" + "time" + + "github.com/samber/lo" + "github.com/stretchr/testify/assert" + + "github.com/coze-dev/coze-loop/backend/modules/prompt/domain/entity/toolmgmt" + "github.com/coze-dev/coze-loop/backend/modules/prompt/infra/repo/mysql/gorm_gen/model" +) + +func TestToolPO2DO_NilBasicPO(t *testing.T) { + t.Parallel() + result := ToolPO2DO(nil, nil) + assert.Nil(t, result) +} + +func TestToolPO2DO_BasicOnly(t *testing.T) { + t.Parallel() + now := time.Now() + basicPO := &model.ToolBasic{ + ID: 1, + SpaceID: 100, + Name: "example-tool", + Description: "desc", + LatestCommittedVersion: "1.0.0", + CreatedBy: "user-1", + UpdatedBy: "user-2", + CreatedAt: now, + UpdatedAt: now, + } + result := ToolPO2DO(basicPO, nil) + assert.NotNil(t, result) + assert.Equal(t, int64(1), result.ID) + assert.Equal(t, int64(100), result.SpaceID) + assert.NotNil(t, result.ToolBasic) + assert.Equal(t, "example-tool", result.ToolBasic.Name) + assert.Equal(t, "desc", result.ToolBasic.Description) + assert.Equal(t, "1.0.0", result.ToolBasic.LatestCommittedVersion) + assert.Equal(t, "user-1", result.ToolBasic.CreatedBy) + assert.Equal(t, "user-2", result.ToolBasic.UpdatedBy) + assert.Equal(t, now, result.ToolBasic.CreatedAt) + assert.Equal(t, now, result.ToolBasic.UpdatedAt) + assert.Nil(t, result.ToolCommit) +} + +func TestToolPO2DO_WithCommit(t *testing.T) { + t.Parallel() + now := time.Now() + basicPO := &model.ToolBasic{ + ID: 1, + SpaceID: 100, + Name: "example-tool", + } + commitPO := &model.ToolCommit{ + ToolID: 1, + Version: "1.0.0", + BaseVersion: "0.0.1", + CommittedBy: "user-1", + Content: lo.ToPtr("tool content"), + Description: lo.ToPtr("commit desc"), + CreatedAt: now, + } + result := ToolPO2DO(basicPO, commitPO) + assert.NotNil(t, result) + assert.NotNil(t, result.ToolCommit) + assert.Equal(t, "1.0.0", result.ToolCommit.CommitInfo.Version) + assert.Equal(t, "0.0.1", result.ToolCommit.CommitInfo.BaseVersion) + assert.Equal(t, "commit desc", result.ToolCommit.CommitInfo.Description) + assert.Equal(t, "user-1", result.ToolCommit.CommitInfo.CommittedBy) + assert.Equal(t, now, result.ToolCommit.CommitInfo.CommittedAt) + assert.Equal(t, "tool content", result.ToolCommit.ToolDetail.Content) +} + +func TestToolCommitPO2DO_Nil(t *testing.T) { + t.Parallel() + result := ToolCommitPO2DO(nil) + assert.Nil(t, result) +} + +func TestToolCommitPO2DO_NilContentAndDescription(t *testing.T) { + t.Parallel() + commitPO := &model.ToolCommit{ + ToolID: 1, + Version: "1.0.0", + BaseVersion: "", + CommittedBy: "user-1", + Content: nil, + Description: nil, + CreatedAt: time.Now(), + } + result := ToolCommitPO2DO(commitPO) + assert.NotNil(t, result) + assert.Equal(t, "", result.CommitInfo.Description) + assert.Equal(t, "", result.ToolDetail.Content) +} + +func TestToolDO2BasicPO_Nil(t *testing.T) { + t.Parallel() + + tests := []struct { + name string + do *toolmgmt.Tool + }{ + {name: "nil tool", do: nil}, + {name: "nil tool basic", do: &toolmgmt.Tool{ID: 1, ToolBasic: nil}}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + result := ToolDO2BasicPO(tt.do) + assert.Nil(t, result) + }) + } +} + +func TestToolDO2BasicPO_FullMapping(t *testing.T) { + t.Parallel() + now := time.Now() + do := &toolmgmt.Tool{ + ID: 1, + SpaceID: 100, + ToolBasic: &toolmgmt.ToolBasic{ + Name: "example-tool", + Description: "desc", + LatestCommittedVersion: "2.0.0", + CreatedBy: "user-1", + UpdatedBy: "user-2", + CreatedAt: now, + UpdatedAt: now, + }, + } + result := ToolDO2BasicPO(do) + assert.NotNil(t, result) + assert.Equal(t, int64(1), result.ID) + assert.Equal(t, int64(100), result.SpaceID) + assert.Equal(t, "example-tool", result.Name) + assert.Equal(t, "desc", result.Description) + assert.Equal(t, "2.0.0", result.LatestCommittedVersion) + assert.Equal(t, "user-1", result.CreatedBy) + assert.Equal(t, "user-2", result.UpdatedBy) + assert.Equal(t, now, result.CreatedAt) + assert.Equal(t, now, result.UpdatedAt) +} From 12e3323c68ddfaa006a03ec73774a8428c729e0b Mon Sep 17 00:00:00 2001 From: wutingjia Date: Fri, 27 Mar 2026 16:19:15 +0800 Subject: [PATCH 7/8] fix: remove strict semver validation in CommitToolDraft --- backend/modules/prompt/application/tool_manage.go | 6 ------ 1 file changed, 6 deletions(-) diff --git a/backend/modules/prompt/application/tool_manage.go b/backend/modules/prompt/application/tool_manage.go index 20330003b..78ca35242 100644 --- a/backend/modules/prompt/application/tool_manage.go +++ b/backend/modules/prompt/application/tool_manage.go @@ -5,7 +5,6 @@ import ( "fmt" "strconv" - "github.com/Masterminds/semver/v3" "github.com/samber/lo" "golang.org/x/exp/maps" @@ -241,11 +240,6 @@ func (app *ToolManageApplicationImpl) CommitToolDraft(ctx context.Context, reque return r, errorx.NewByCode(prompterr.CommonInvalidParamCode, errorx.WithExtraMsg("User not found")) } - _, err = semver.StrictNewVersion(request.GetCommitVersion()) - if err != nil { - return r, err - } - if request.GetToolID() <= 0 { return r, errorx.NewByCode(prompterr.CommonInvalidParamCode, errorx.WithExtraMsg("Tool ID is required")) } From 12525cfcdf37e46c10a0557c696eacf198c3d95c Mon Sep 17 00:00:00 2001 From: wutingjia Date: Fri, 27 Mar 2026 17:15:56 +0800 Subject: [PATCH 8/8] fix: use ID as cursor for ListToolCommit pagination to avoid duplicate records Switch from CreatedAt timestamp (second precision) to auto-increment ID as the cursor field in ListToolCommit. This prevents duplicate records when multiple commits are created within the same second. - tool_commit.go: Replace CreatedAt-based Lte/Gte conditions with ID-based Lt/Gt strict conditions and order by ID instead of CreatedAt - tool.go: Use po.ID instead of po.CreatedAt.Unix() as nextToken value --- backend/modules/prompt/infra/repo/mysql/tool_commit.go | 8 ++++---- backend/modules/prompt/infra/repo/tool.go | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/backend/modules/prompt/infra/repo/mysql/tool_commit.go b/backend/modules/prompt/infra/repo/mysql/tool_commit.go index be016d978..899c082ce 100644 --- a/backend/modules/prompt/infra/repo/mysql/tool_commit.go +++ b/backend/modules/prompt/infra/repo/mysql/tool_commit.go @@ -157,15 +157,15 @@ func (d *ToolCommitDAOImpl) List(ctx context.Context, param ListToolCommitParam, if param.Cursor == nil { if param.Asc { - tx = tx.Order(q.ToolCommit.CreatedAt.Asc()) + tx = tx.Order(q.ToolCommit.ID.Asc()) } else { - tx = tx.Order(q.ToolCommit.CreatedAt.Desc()) + tx = tx.Order(q.ToolCommit.ID.Desc()) } } else { if param.Asc { - tx = tx.Where(q.ToolCommit.CreatedAt.Gte(time.Unix(*param.Cursor, 0))).Order(q.ToolCommit.CreatedAt.Asc()) + tx = tx.Where(q.ToolCommit.ID.Gt(*param.Cursor)).Order(q.ToolCommit.ID.Asc()) } else { - tx = tx.Where(q.ToolCommit.CreatedAt.Lte(time.Unix(*param.Cursor, 0))).Order(q.ToolCommit.CreatedAt.Desc()) + tx = tx.Where(q.ToolCommit.ID.Lt(*param.Cursor)).Order(q.ToolCommit.ID.Desc()) } } tx = tx.Limit(param.Limit) diff --git a/backend/modules/prompt/infra/repo/tool.go b/backend/modules/prompt/infra/repo/tool.go index c9b19154c..8e583226d 100644 --- a/backend/modules/prompt/infra/repo/tool.go +++ b/backend/modules/prompt/infra/repo/tool.go @@ -350,7 +350,7 @@ func (d *ToolRepoImpl) ListToolCommit(ctx context.Context, param repo.ListToolCo if po == nil { continue } - nextToken = po.CreatedAt.Unix() + nextToken = po.ID commitInfos = append(commitInfos, &toolmgmt.CommitInfo{ Version: po.Version, BaseVersion: po.BaseVersion,