diff --git a/backend/infra/platestwrite/latest_write_tracker.go b/backend/infra/platestwrite/latest_write_tracker.go index 69b6cd859..935019cfe 100644 --- a/backend/infra/platestwrite/latest_write_tracker.go +++ b/backend/infra/platestwrite/latest_write_tracker.go @@ -131,6 +131,10 @@ const ( ResourceTypePromptCommitLabelMapping ResourceType = "prompt_commit_label_mapping" ResourceTypeCozeloopOptimizeTask ResourceType = "cozeloop_optimize_task" // 外场智能优化 ResourceTypePromptRelation ResourceType = "prompt_relation" + ResourceTypePromptRelease ResourceType = "prompt_release" + ResourceTypeReleaseTask ResourceType = "release_task" + ResourceTypeReleaseSubtask ResourceType = "release_subtask" + ResourceTypeReleaseTaskResource ResourceType = "release_task_resource" ResourceTypeExperiment ResourceType = "experiment" ResourceTypeEvalSet ResourceType = "eval_set" diff --git a/backend/kitex_gen/coze/loop/apis/promptmanageservice/client.go b/backend/kitex_gen/coze/loop/apis/promptmanageservice/client.go index 3e7b1c158..aaec1bad2 100644 --- a/backend/kitex_gen/coze/loop/apis/promptmanageservice/client.go +++ b/backend/kitex_gen/coze/loop/apis/promptmanageservice/client.go @@ -18,6 +18,7 @@ type Client interface { BatchGetPrompt(ctx context.Context, request *manage.BatchGetPromptRequest, callOptions ...callopt.Option) (r *manage.BatchGetPromptResponse, err error) ListPrompt(ctx context.Context, request *manage.ListPromptRequest, callOptions ...callopt.Option) (r *manage.ListPromptResponse, err error) ListParentPrompt(ctx context.Context, request *manage.ListParentPromptRequest, callOptions ...callopt.Option) (r *manage.ListParentPromptResponse, err error) + BatchGetPromptBasic(ctx context.Context, request *manage.BatchGetPromptBasicRequest, callOptions ...callopt.Option) (r *manage.BatchGetPromptBasicResponse, err error) UpdatePrompt(ctx context.Context, request *manage.UpdatePromptRequest, callOptions ...callopt.Option) (r *manage.UpdatePromptResponse, err error) SaveDraft(ctx context.Context, request *manage.SaveDraftRequest, callOptions ...callopt.Option) (r *manage.SaveDraftResponse, err error) CreateLabel(ctx context.Context, request *manage.CreateLabelRequest, callOptions ...callopt.Option) (r *manage.CreateLabelResponse, err error) @@ -93,6 +94,11 @@ func (p *kPromptManageServiceClient) ListParentPrompt(ctx context.Context, reque return p.kClient.ListParentPrompt(ctx, request) } +func (p *kPromptManageServiceClient) BatchGetPromptBasic(ctx context.Context, request *manage.BatchGetPromptBasicRequest, callOptions ...callopt.Option) (r *manage.BatchGetPromptBasicResponse, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.BatchGetPromptBasic(ctx, request) +} + func (p *kPromptManageServiceClient) UpdatePrompt(ctx context.Context, request *manage.UpdatePromptRequest, callOptions ...callopt.Option) (r *manage.UpdatePromptResponse, err error) { ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.UpdatePrompt(ctx, request) diff --git a/backend/kitex_gen/coze/loop/apis/promptmanageservice/promptmanageservice.go b/backend/kitex_gen/coze/loop/apis/promptmanageservice/promptmanageservice.go index 331bb3c02..f3917260f 100644 --- a/backend/kitex_gen/coze/loop/apis/promptmanageservice/promptmanageservice.go +++ b/backend/kitex_gen/coze/loop/apis/promptmanageservice/promptmanageservice.go @@ -63,6 +63,13 @@ var serviceMethods = map[string]kitex.MethodInfo{ false, kitex.WithStreamingMode(kitex.StreamingNone), ), + "BatchGetPromptBasic": kitex.NewMethodInfo( + batchGetPromptBasicHandler, + newPromptManageServiceBatchGetPromptBasicArgs, + newPromptManageServiceBatchGetPromptBasicResult, + false, + kitex.WithStreamingMode(kitex.StreamingNone), + ), "UpdatePrompt": kitex.NewMethodInfo( updatePromptHandler, newPromptManageServiceUpdatePromptArgs, @@ -292,6 +299,25 @@ func newPromptManageServiceListParentPromptResult() interface{} { return manage.NewPromptManageServiceListParentPromptResult() } +func batchGetPromptBasicHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*manage.PromptManageServiceBatchGetPromptBasicArgs) + realResult := result.(*manage.PromptManageServiceBatchGetPromptBasicResult) + success, err := handler.(manage.PromptManageService).BatchGetPromptBasic(ctx, realArg.Request) + if err != nil { + return err + } + realResult.Success = success + return nil +} + +func newPromptManageServiceBatchGetPromptBasicArgs() interface{} { + return manage.NewPromptManageServiceBatchGetPromptBasicArgs() +} + +func newPromptManageServiceBatchGetPromptBasicResult() interface{} { + return manage.NewPromptManageServiceBatchGetPromptBasicResult() +} + func updatePromptHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { realArg := arg.(*manage.PromptManageServiceUpdatePromptArgs) realResult := result.(*manage.PromptManageServiceUpdatePromptResult) @@ -545,6 +571,16 @@ func (p *kClient) ListParentPrompt(ctx context.Context, request *manage.ListPare return _result.GetSuccess(), nil } +func (p *kClient) BatchGetPromptBasic(ctx context.Context, request *manage.BatchGetPromptBasicRequest) (r *manage.BatchGetPromptBasicResponse, err error) { + var _args manage.PromptManageServiceBatchGetPromptBasicArgs + _args.Request = request + var _result manage.PromptManageServiceBatchGetPromptBasicResult + if err = p.c.Call(ctx, "BatchGetPromptBasic", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} + func (p *kClient) UpdatePrompt(ctx context.Context, request *manage.UpdatePromptRequest) (r *manage.UpdatePromptResponse, err error) { var _args manage.PromptManageServiceUpdatePromptArgs _args.Request = request diff --git a/backend/kitex_gen/coze/loop/evaluation/expt/coze.loop.evaluation.expt.go b/backend/kitex_gen/coze/loop/evaluation/expt/coze.loop.evaluation.expt.go index 6e11ef3b8..6e69b37d2 100644 --- a/backend/kitex_gen/coze/loop/evaluation/expt/coze.loop.evaluation.expt.go +++ b/backend/kitex_gen/coze/loop/evaluation/expt/coze.loop.evaluation.expt.go @@ -12322,7 +12322,7 @@ func (p *BatchGetExperimentAggrResultResponse) Field255DeepEqual(src *base.BaseR type CalculateExperimentAggrResultRequest struct { WorkspaceID int64 `thrift:"workspace_id,1,required" frugal:"1,required,i64" form:"workspace_id,required" json:"workspace_id,string,required"` - ExptID int64 `thrift:"expt_id,2,required" frugal:"2,required,i64" json:"expt_id,required" path:"expt_id,required"` + ExptID int64 `thrift:"expt_id,2,required" frugal:"2,required,i64" json:"expt_id,string,required" path:"expt_id,required"` Base *base.Base `thrift:"Base,255,optional" frugal:"255,optional,base.Base" form:"Base" json:"Base,omitempty" query:"Base"` } diff --git a/backend/kitex_gen/coze/loop/prompt/manage/coze.loop.prompt.manage.go b/backend/kitex_gen/coze/loop/prompt/manage/coze.loop.prompt.manage.go index 64dca1a7f..5ac6b1591 100644 --- a/backend/kitex_gen/coze/loop/prompt/manage/coze.loop.prompt.manage.go +++ b/backend/kitex_gen/coze/loop/prompt/manage/coze.loop.prompt.manage.go @@ -13138,6 +13138,625 @@ func (p *ListParentPromptResponse) Field255DeepEqual(src *base.BaseResp) bool { return true } +type BatchGetPromptBasicRequest struct { + WorkspaceID *int64 `thrift:"workspace_id,1,optional" frugal:"1,optional,i64" json:"workspace_id" form:"workspace_id" query:"workspace_id"` + PromptIds []int64 `thrift:"prompt_ids,2,optional" frugal:"2,optional,list" form:"prompt_ids" json:"prompt_ids,omitempty" query:"prompt_ids"` + Base *base.Base `thrift:"Base,255,optional" frugal:"255,optional,base.Base" form:"Base" json:"Base,omitempty" query:"Base"` +} + +func NewBatchGetPromptBasicRequest() *BatchGetPromptBasicRequest { + return &BatchGetPromptBasicRequest{} +} + +func (p *BatchGetPromptBasicRequest) InitDefault() { +} + +var BatchGetPromptBasicRequest_WorkspaceID_DEFAULT int64 + +func (p *BatchGetPromptBasicRequest) GetWorkspaceID() (v int64) { + if p == nil { + return + } + if !p.IsSetWorkspaceID() { + return BatchGetPromptBasicRequest_WorkspaceID_DEFAULT + } + return *p.WorkspaceID +} + +var BatchGetPromptBasicRequest_PromptIds_DEFAULT []int64 + +func (p *BatchGetPromptBasicRequest) GetPromptIds() (v []int64) { + if p == nil { + return + } + if !p.IsSetPromptIds() { + return BatchGetPromptBasicRequest_PromptIds_DEFAULT + } + return p.PromptIds +} + +var BatchGetPromptBasicRequest_Base_DEFAULT *base.Base + +func (p *BatchGetPromptBasicRequest) GetBase() (v *base.Base) { + if p == nil { + return + } + if !p.IsSetBase() { + return BatchGetPromptBasicRequest_Base_DEFAULT + } + return p.Base +} +func (p *BatchGetPromptBasicRequest) SetWorkspaceID(val *int64) { + p.WorkspaceID = val +} +func (p *BatchGetPromptBasicRequest) SetPromptIds(val []int64) { + p.PromptIds = val +} +func (p *BatchGetPromptBasicRequest) SetBase(val *base.Base) { + p.Base = val +} + +var fieldIDToName_BatchGetPromptBasicRequest = map[int16]string{ + 1: "workspace_id", + 2: "prompt_ids", + 255: "Base", +} + +func (p *BatchGetPromptBasicRequest) IsSetWorkspaceID() bool { + return p.WorkspaceID != nil +} + +func (p *BatchGetPromptBasicRequest) IsSetPromptIds() bool { + return p.PromptIds != nil +} + +func (p *BatchGetPromptBasicRequest) IsSetBase() bool { + return p.Base != nil +} + +func (p *BatchGetPromptBasicRequest) 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_BatchGetPromptBasicRequest[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 *BatchGetPromptBasicRequest) 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 *BatchGetPromptBasicRequest) ReadField2(iprot thrift.TProtocol) error { + _, size, err := iprot.ReadListBegin() + if err != nil { + return err + } + _field := make([]int64, 0, size) + for i := 0; i < size; i++ { + + var _elem int64 + if v, err := iprot.ReadI64(); err != nil { + return err + } else { + _elem = v + } + + _field = append(_field, _elem) + } + if err := iprot.ReadListEnd(); err != nil { + return err + } + p.PromptIds = _field + return nil +} +func (p *BatchGetPromptBasicRequest) ReadField255(iprot thrift.TProtocol) error { + _field := base.NewBase() + if err := _field.Read(iprot); err != nil { + return err + } + p.Base = _field + return nil +} + +func (p *BatchGetPromptBasicRequest) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("BatchGetPromptBasicRequest"); 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 *BatchGetPromptBasicRequest) 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 *BatchGetPromptBasicRequest) writeField2(oprot thrift.TProtocol) (err error) { + if p.IsSetPromptIds() { + if err = oprot.WriteFieldBegin("prompt_ids", thrift.LIST, 2); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteListBegin(thrift.I64, len(p.PromptIds)); err != nil { + return err + } + for _, v := range p.PromptIds { + if err := oprot.WriteI64(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 2 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err) +} +func (p *BatchGetPromptBasicRequest) 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 *BatchGetPromptBasicRequest) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("BatchGetPromptBasicRequest(%+v)", *p) + +} + +func (p *BatchGetPromptBasicRequest) DeepEqual(ano *BatchGetPromptBasicRequest) 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.PromptIds) { + return false + } + if !p.Field255DeepEqual(ano.Base) { + return false + } + return true +} + +func (p *BatchGetPromptBasicRequest) 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 *BatchGetPromptBasicRequest) Field2DeepEqual(src []int64) bool { + + if len(p.PromptIds) != len(src) { + return false + } + for i, v := range p.PromptIds { + _src := src[i] + if v != _src { + return false + } + } + return true +} +func (p *BatchGetPromptBasicRequest) Field255DeepEqual(src *base.Base) bool { + + if !p.Base.DeepEqual(src) { + return false + } + return true +} + +type BatchGetPromptBasicResponse struct { + Prompts []*prompt.Prompt `thrift:"prompts,1,optional" frugal:"1,optional,list" form:"prompts" json:"prompts,omitempty" query:"prompts"` + BaseResp *base.BaseResp `thrift:"BaseResp,255,optional" frugal:"255,optional,base.BaseResp" form:"BaseResp" json:"BaseResp,omitempty" query:"BaseResp"` +} + +func NewBatchGetPromptBasicResponse() *BatchGetPromptBasicResponse { + return &BatchGetPromptBasicResponse{} +} + +func (p *BatchGetPromptBasicResponse) InitDefault() { +} + +var BatchGetPromptBasicResponse_Prompts_DEFAULT []*prompt.Prompt + +func (p *BatchGetPromptBasicResponse) GetPrompts() (v []*prompt.Prompt) { + if p == nil { + return + } + if !p.IsSetPrompts() { + return BatchGetPromptBasicResponse_Prompts_DEFAULT + } + return p.Prompts +} + +var BatchGetPromptBasicResponse_BaseResp_DEFAULT *base.BaseResp + +func (p *BatchGetPromptBasicResponse) GetBaseResp() (v *base.BaseResp) { + if p == nil { + return + } + if !p.IsSetBaseResp() { + return BatchGetPromptBasicResponse_BaseResp_DEFAULT + } + return p.BaseResp +} +func (p *BatchGetPromptBasicResponse) SetPrompts(val []*prompt.Prompt) { + p.Prompts = val +} +func (p *BatchGetPromptBasicResponse) SetBaseResp(val *base.BaseResp) { + p.BaseResp = val +} + +var fieldIDToName_BatchGetPromptBasicResponse = map[int16]string{ + 1: "prompts", + 255: "BaseResp", +} + +func (p *BatchGetPromptBasicResponse) IsSetPrompts() bool { + return p.Prompts != nil +} + +func (p *BatchGetPromptBasicResponse) IsSetBaseResp() bool { + return p.BaseResp != nil +} + +func (p *BatchGetPromptBasicResponse) 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_BatchGetPromptBasicResponse[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 *BatchGetPromptBasicResponse) ReadField1(iprot thrift.TProtocol) error { + _, size, err := iprot.ReadListBegin() + if err != nil { + return err + } + _field := make([]*prompt.Prompt, 0, size) + values := make([]prompt.Prompt, 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.Prompts = _field + return nil +} +func (p *BatchGetPromptBasicResponse) ReadField255(iprot thrift.TProtocol) error { + _field := base.NewBaseResp() + if err := _field.Read(iprot); err != nil { + return err + } + p.BaseResp = _field + return nil +} + +func (p *BatchGetPromptBasicResponse) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("BatchGetPromptBasicResponse"); 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 *BatchGetPromptBasicResponse) writeField1(oprot thrift.TProtocol) (err error) { + if p.IsSetPrompts() { + if err = oprot.WriteFieldBegin("prompts", thrift.LIST, 1); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteListBegin(thrift.STRUCT, len(p.Prompts)); err != nil { + return err + } + for _, v := range p.Prompts { + 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 *BatchGetPromptBasicResponse) 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 *BatchGetPromptBasicResponse) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("BatchGetPromptBasicResponse(%+v)", *p) + +} + +func (p *BatchGetPromptBasicResponse) DeepEqual(ano *BatchGetPromptBasicResponse) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.Prompts) { + return false + } + if !p.Field255DeepEqual(ano.BaseResp) { + return false + } + return true +} + +func (p *BatchGetPromptBasicResponse) Field1DeepEqual(src []*prompt.Prompt) bool { + + if len(p.Prompts) != len(src) { + return false + } + for i, v := range p.Prompts { + _src := src[i] + if !v.DeepEqual(_src) { + return false + } + } + return true +} +func (p *BatchGetPromptBasicResponse) Field255DeepEqual(src *base.BaseResp) bool { + + if !p.BaseResp.DeepEqual(src) { + return false + } + return true +} + type PromptManageService interface { // --------------- Prompt管理 --------------- // // 增 @@ -13154,6 +13773,8 @@ type PromptManageService interface { ListPrompt(ctx context.Context, request *ListPromptRequest) (r *ListPromptResponse, err error) // 查询片段的引用记录 ListParentPrompt(ctx context.Context, request *ListParentPromptRequest) (r *ListParentPromptResponse, err error) + + BatchGetPromptBasic(ctx context.Context, request *BatchGetPromptBasicRequest) (r *BatchGetPromptBasicResponse, err error) // 改 UpdatePrompt(ctx context.Context, request *UpdatePromptRequest) (r *UpdatePromptResponse, err error) @@ -13264,6 +13885,15 @@ func (p *PromptManageServiceClient) ListParentPrompt(ctx context.Context, reques } return _result.GetSuccess(), nil } +func (p *PromptManageServiceClient) BatchGetPromptBasic(ctx context.Context, request *BatchGetPromptBasicRequest) (r *BatchGetPromptBasicResponse, err error) { + var _args PromptManageServiceBatchGetPromptBasicArgs + _args.Request = request + var _result PromptManageServiceBatchGetPromptBasicResult + if err = p.Client_().Call(ctx, "BatchGetPromptBasic", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} func (p *PromptManageServiceClient) UpdatePrompt(ctx context.Context, request *UpdatePromptRequest) (r *UpdatePromptResponse, err error) { var _args PromptManageServiceUpdatePromptArgs _args.Request = request @@ -13373,6 +14003,7 @@ func NewPromptManageServiceProcessor(handler PromptManageService) *PromptManageS self.AddToProcessorMap("BatchGetPrompt", &promptManageServiceProcessorBatchGetPrompt{handler: handler}) self.AddToProcessorMap("ListPrompt", &promptManageServiceProcessorListPrompt{handler: handler}) self.AddToProcessorMap("ListParentPrompt", &promptManageServiceProcessorListParentPrompt{handler: handler}) + self.AddToProcessorMap("BatchGetPromptBasic", &promptManageServiceProcessorBatchGetPromptBasic{handler: handler}) self.AddToProcessorMap("UpdatePrompt", &promptManageServiceProcessorUpdatePrompt{handler: handler}) self.AddToProcessorMap("SaveDraft", &promptManageServiceProcessorSaveDraft{handler: handler}) self.AddToProcessorMap("CreateLabel", &promptManageServiceProcessorCreateLabel{handler: handler}) @@ -13738,6 +14369,54 @@ func (p *promptManageServiceProcessorListParentPrompt) Process(ctx context.Conte return true, err } +type promptManageServiceProcessorBatchGetPromptBasic struct { + handler PromptManageService +} + +func (p *promptManageServiceProcessorBatchGetPromptBasic) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := PromptManageServiceBatchGetPromptBasicArgs{} + if err = args.Read(iprot); err != nil { + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) + oprot.WriteMessageBegin("BatchGetPromptBasic", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return false, err + } + + iprot.ReadMessageEnd() + var err2 error + result := PromptManageServiceBatchGetPromptBasicResult{} + var retval *BatchGetPromptBasicResponse + if retval, err2 = p.handler.BatchGetPromptBasic(ctx, args.Request); err2 != nil { + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing BatchGetPromptBasic: "+err2.Error()) + oprot.WriteMessageBegin("BatchGetPromptBasic", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return true, err2 + } else { + result.Success = retval + } + if err2 = oprot.WriteMessageBegin("BatchGetPromptBasic", 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 promptManageServiceProcessorUpdatePrompt struct { handler PromptManageService } @@ -14008,7 +14687,103 @@ func (p *promptManageServiceProcessorListCommit) Process(ctx context.Context, se } else { result.Success = retval } - if err2 = oprot.WriteMessageBegin("ListCommit", thrift.REPLY, seqId); err2 != nil { + if err2 = oprot.WriteMessageBegin("ListCommit", 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 promptManageServiceProcessorCommitDraft struct { + handler PromptManageService +} + +func (p *promptManageServiceProcessorCommitDraft) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := PromptManageServiceCommitDraftArgs{} + if err = args.Read(iprot); err != nil { + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) + oprot.WriteMessageBegin("CommitDraft", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return false, err + } + + iprot.ReadMessageEnd() + var err2 error + result := PromptManageServiceCommitDraftResult{} + var retval *CommitDraftResponse + if retval, err2 = p.handler.CommitDraft(ctx, args.Request); err2 != nil { + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing CommitDraft: "+err2.Error()) + oprot.WriteMessageBegin("CommitDraft", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return true, err2 + } else { + result.Success = retval + } + if err2 = oprot.WriteMessageBegin("CommitDraft", 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 promptManageServiceProcessorRevertDraftFromCommit struct { + handler PromptManageService +} + +func (p *promptManageServiceProcessorRevertDraftFromCommit) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := PromptManageServiceRevertDraftFromCommitArgs{} + if err = args.Read(iprot); err != nil { + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) + oprot.WriteMessageBegin("RevertDraftFromCommit", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return false, err + } + + iprot.ReadMessageEnd() + var err2 error + result := PromptManageServiceRevertDraftFromCommitResult{} + var retval *RevertDraftFromCommitResponse + if retval, err2 = p.handler.RevertDraftFromCommit(ctx, args.Request); err2 != nil { + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing RevertDraftFromCommit: "+err2.Error()) + oprot.WriteMessageBegin("RevertDraftFromCommit", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return true, err2 + } else { + result.Success = retval + } + if err2 = oprot.WriteMessageBegin("RevertDraftFromCommit", thrift.REPLY, seqId); err2 != nil { err = err2 } if err2 = result.Write(oprot); err == nil && err2 != nil { @@ -14026,16 +14801,16 @@ func (p *promptManageServiceProcessorListCommit) Process(ctx context.Context, se return true, err } -type promptManageServiceProcessorCommitDraft struct { +type promptManageServiceProcessorUpdateCommitLabels struct { handler PromptManageService } -func (p *promptManageServiceProcessorCommitDraft) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := PromptManageServiceCommitDraftArgs{} +func (p *promptManageServiceProcessorUpdateCommitLabels) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := PromptManageServiceUpdateCommitLabelsArgs{} if err = args.Read(iprot); err != nil { iprot.ReadMessageEnd() x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("CommitDraft", thrift.EXCEPTION, seqId) + oprot.WriteMessageBegin("UpdateCommitLabels", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush(ctx) @@ -14044,11 +14819,11 @@ func (p *promptManageServiceProcessorCommitDraft) Process(ctx context.Context, s iprot.ReadMessageEnd() var err2 error - result := PromptManageServiceCommitDraftResult{} - var retval *CommitDraftResponse - if retval, err2 = p.handler.CommitDraft(ctx, args.Request); err2 != nil { - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing CommitDraft: "+err2.Error()) - oprot.WriteMessageBegin("CommitDraft", thrift.EXCEPTION, seqId) + result := PromptManageServiceUpdateCommitLabelsResult{} + var retval *UpdateCommitLabelsResponse + if retval, err2 = p.handler.UpdateCommitLabels(ctx, args.Request); err2 != nil { + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing UpdateCommitLabels: "+err2.Error()) + oprot.WriteMessageBegin("UpdateCommitLabels", thrift.EXCEPTION, seqId) x.Write(oprot) oprot.WriteMessageEnd() oprot.Flush(ctx) @@ -14056,7 +14831,7 @@ func (p *promptManageServiceProcessorCommitDraft) Process(ctx context.Context, s } else { result.Success = retval } - if err2 = oprot.WriteMessageBegin("CommitDraft", thrift.REPLY, seqId); err2 != nil { + if err2 = oprot.WriteMessageBegin("UpdateCommitLabels", thrift.REPLY, seqId); err2 != nil { err = err2 } if err2 = result.Write(oprot); err == nil && err2 != nil { @@ -14068,143 +14843,391 @@ func (p *promptManageServiceProcessorCommitDraft) Process(ctx context.Context, s if err2 = oprot.Flush(ctx); err == nil && err2 != nil { err = err2 } - if err != nil { - return + if err != nil { + return + } + return true, err +} + +type PromptManageServiceCreatePromptArgs struct { + Request *CreatePromptRequest `thrift:"request,1" frugal:"1,default,CreatePromptRequest"` +} + +func NewPromptManageServiceCreatePromptArgs() *PromptManageServiceCreatePromptArgs { + return &PromptManageServiceCreatePromptArgs{} +} + +func (p *PromptManageServiceCreatePromptArgs) InitDefault() { +} + +var PromptManageServiceCreatePromptArgs_Request_DEFAULT *CreatePromptRequest + +func (p *PromptManageServiceCreatePromptArgs) GetRequest() (v *CreatePromptRequest) { + if p == nil { + return + } + if !p.IsSetRequest() { + return PromptManageServiceCreatePromptArgs_Request_DEFAULT + } + return p.Request +} +func (p *PromptManageServiceCreatePromptArgs) SetRequest(val *CreatePromptRequest) { + p.Request = val +} + +var fieldIDToName_PromptManageServiceCreatePromptArgs = map[int16]string{ + 1: "request", +} + +func (p *PromptManageServiceCreatePromptArgs) IsSetRequest() bool { + return p.Request != nil +} + +func (p *PromptManageServiceCreatePromptArgs) 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_PromptManageServiceCreatePromptArgs[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 *PromptManageServiceCreatePromptArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewCreatePromptRequest() + if err := _field.Read(iprot); err != nil { + return err + } + p.Request = _field + return nil +} + +func (p *PromptManageServiceCreatePromptArgs) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("CreatePrompt_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 *PromptManageServiceCreatePromptArgs) 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 *PromptManageServiceCreatePromptArgs) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("PromptManageServiceCreatePromptArgs(%+v)", *p) + +} + +func (p *PromptManageServiceCreatePromptArgs) DeepEqual(ano *PromptManageServiceCreatePromptArgs) 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 *PromptManageServiceCreatePromptArgs) Field1DeepEqual(src *CreatePromptRequest) bool { + + if !p.Request.DeepEqual(src) { + return false + } + return true +} + +type PromptManageServiceCreatePromptResult struct { + Success *CreatePromptResponse `thrift:"success,0,optional" frugal:"0,optional,CreatePromptResponse"` +} + +func NewPromptManageServiceCreatePromptResult() *PromptManageServiceCreatePromptResult { + return &PromptManageServiceCreatePromptResult{} +} + +func (p *PromptManageServiceCreatePromptResult) InitDefault() { +} + +var PromptManageServiceCreatePromptResult_Success_DEFAULT *CreatePromptResponse + +func (p *PromptManageServiceCreatePromptResult) GetSuccess() (v *CreatePromptResponse) { + if p == nil { + return + } + if !p.IsSetSuccess() { + return PromptManageServiceCreatePromptResult_Success_DEFAULT + } + return p.Success +} +func (p *PromptManageServiceCreatePromptResult) SetSuccess(x interface{}) { + p.Success = x.(*CreatePromptResponse) +} + +var fieldIDToName_PromptManageServiceCreatePromptResult = map[int16]string{ + 0: "success", +} + +func (p *PromptManageServiceCreatePromptResult) IsSetSuccess() bool { + return p.Success != nil +} + +func (p *PromptManageServiceCreatePromptResult) 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 true, err -} -type promptManageServiceProcessorRevertDraftFromCommit struct { - handler PromptManageService + 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_PromptManageServiceCreatePromptResult[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 *promptManageServiceProcessorRevertDraftFromCommit) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := PromptManageServiceRevertDraftFromCommitArgs{} - if err = args.Read(iprot); err != nil { - iprot.ReadMessageEnd() - x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("RevertDraftFromCommit", thrift.EXCEPTION, seqId) - x.Write(oprot) - oprot.WriteMessageEnd() - oprot.Flush(ctx) - return false, err +func (p *PromptManageServiceCreatePromptResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewCreatePromptResponse() + if err := _field.Read(iprot); err != nil { + return err } + p.Success = _field + return nil +} - iprot.ReadMessageEnd() - var err2 error - result := PromptManageServiceRevertDraftFromCommitResult{} - var retval *RevertDraftFromCommitResponse - if retval, err2 = p.handler.RevertDraftFromCommit(ctx, args.Request); err2 != nil { - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing RevertDraftFromCommit: "+err2.Error()) - oprot.WriteMessageBegin("RevertDraftFromCommit", thrift.EXCEPTION, seqId) - x.Write(oprot) - oprot.WriteMessageEnd() - oprot.Flush(ctx) - return true, err2 - } else { - result.Success = retval - } - if err2 = oprot.WriteMessageBegin("RevertDraftFromCommit", thrift.REPLY, seqId); err2 != nil { - err = err2 - } - if err2 = result.Write(oprot); err == nil && err2 != nil { - err = err2 +func (p *PromptManageServiceCreatePromptResult) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("CreatePrompt_result"); err != nil { + goto WriteStructBeginError } - if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil { - err = err2 + if p != nil { + if err = p.writeField0(oprot); err != nil { + fieldId = 0 + goto WriteFieldError + } } - if err2 = oprot.Flush(ctx); err == nil && err2 != nil { - err = err2 + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError } - if err != nil { - return + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError } - return true, err + 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) } -type promptManageServiceProcessorUpdateCommitLabels struct { - handler PromptManageService +func (p *PromptManageServiceCreatePromptResult) 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 *promptManageServiceProcessorUpdateCommitLabels) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { - args := PromptManageServiceUpdateCommitLabelsArgs{} - if err = args.Read(iprot); err != nil { - iprot.ReadMessageEnd() - x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) - oprot.WriteMessageBegin("UpdateCommitLabels", thrift.EXCEPTION, seqId) - x.Write(oprot) - oprot.WriteMessageEnd() - oprot.Flush(ctx) - return false, err +func (p *PromptManageServiceCreatePromptResult) String() string { + if p == nil { + return "" } + return fmt.Sprintf("PromptManageServiceCreatePromptResult(%+v)", *p) - iprot.ReadMessageEnd() - var err2 error - result := PromptManageServiceUpdateCommitLabelsResult{} - var retval *UpdateCommitLabelsResponse - if retval, err2 = p.handler.UpdateCommitLabels(ctx, args.Request); err2 != nil { - x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing UpdateCommitLabels: "+err2.Error()) - oprot.WriteMessageBegin("UpdateCommitLabels", thrift.EXCEPTION, seqId) - x.Write(oprot) - oprot.WriteMessageEnd() - oprot.Flush(ctx) - return true, err2 - } else { - result.Success = retval - } - if err2 = oprot.WriteMessageBegin("UpdateCommitLabels", 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 +} + +func (p *PromptManageServiceCreatePromptResult) DeepEqual(ano *PromptManageServiceCreatePromptResult) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false } - if err2 = oprot.Flush(ctx); err == nil && err2 != nil { - err = err2 + if !p.Field0DeepEqual(ano.Success) { + return false } - if err != nil { - return + return true +} + +func (p *PromptManageServiceCreatePromptResult) Field0DeepEqual(src *CreatePromptResponse) bool { + + if !p.Success.DeepEqual(src) { + return false } - return true, err + return true } -type PromptManageServiceCreatePromptArgs struct { - Request *CreatePromptRequest `thrift:"request,1" frugal:"1,default,CreatePromptRequest"` +type PromptManageServiceClonePromptArgs struct { + Request *ClonePromptRequest `thrift:"request,1" frugal:"1,default,ClonePromptRequest"` } -func NewPromptManageServiceCreatePromptArgs() *PromptManageServiceCreatePromptArgs { - return &PromptManageServiceCreatePromptArgs{} +func NewPromptManageServiceClonePromptArgs() *PromptManageServiceClonePromptArgs { + return &PromptManageServiceClonePromptArgs{} } -func (p *PromptManageServiceCreatePromptArgs) InitDefault() { +func (p *PromptManageServiceClonePromptArgs) InitDefault() { } -var PromptManageServiceCreatePromptArgs_Request_DEFAULT *CreatePromptRequest +var PromptManageServiceClonePromptArgs_Request_DEFAULT *ClonePromptRequest -func (p *PromptManageServiceCreatePromptArgs) GetRequest() (v *CreatePromptRequest) { +func (p *PromptManageServiceClonePromptArgs) GetRequest() (v *ClonePromptRequest) { if p == nil { return } if !p.IsSetRequest() { - return PromptManageServiceCreatePromptArgs_Request_DEFAULT + return PromptManageServiceClonePromptArgs_Request_DEFAULT } return p.Request } -func (p *PromptManageServiceCreatePromptArgs) SetRequest(val *CreatePromptRequest) { +func (p *PromptManageServiceClonePromptArgs) SetRequest(val *ClonePromptRequest) { p.Request = val } -var fieldIDToName_PromptManageServiceCreatePromptArgs = map[int16]string{ +var fieldIDToName_PromptManageServiceClonePromptArgs = map[int16]string{ 1: "request", } -func (p *PromptManageServiceCreatePromptArgs) IsSetRequest() bool { +func (p *PromptManageServiceClonePromptArgs) IsSetRequest() bool { return p.Request != nil } -func (p *PromptManageServiceCreatePromptArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceClonePromptArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -14249,7 +15272,7 @@ ReadStructBeginError: 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_PromptManageServiceCreatePromptArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_PromptManageServiceClonePromptArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -14259,8 +15282,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *PromptManageServiceCreatePromptArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewCreatePromptRequest() +func (p *PromptManageServiceClonePromptArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewClonePromptRequest() if err := _field.Read(iprot); err != nil { return err } @@ -14268,9 +15291,9 @@ func (p *PromptManageServiceCreatePromptArgs) ReadField1(iprot thrift.TProtocol) return nil } -func (p *PromptManageServiceCreatePromptArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceClonePromptArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("CreatePrompt_args"); err != nil { + if err = oprot.WriteStructBegin("ClonePrompt_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -14296,7 +15319,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *PromptManageServiceCreatePromptArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceClonePromptArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -14313,15 +15336,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *PromptManageServiceCreatePromptArgs) String() string { +func (p *PromptManageServiceClonePromptArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("PromptManageServiceCreatePromptArgs(%+v)", *p) + return fmt.Sprintf("PromptManageServiceClonePromptArgs(%+v)", *p) } -func (p *PromptManageServiceCreatePromptArgs) DeepEqual(ano *PromptManageServiceCreatePromptArgs) bool { +func (p *PromptManageServiceClonePromptArgs) DeepEqual(ano *PromptManageServiceClonePromptArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -14333,7 +15356,7 @@ func (p *PromptManageServiceCreatePromptArgs) DeepEqual(ano *PromptManageService return true } -func (p *PromptManageServiceCreatePromptArgs) Field1DeepEqual(src *CreatePromptRequest) bool { +func (p *PromptManageServiceClonePromptArgs) Field1DeepEqual(src *ClonePromptRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -14341,41 +15364,41 @@ func (p *PromptManageServiceCreatePromptArgs) Field1DeepEqual(src *CreatePromptR return true } -type PromptManageServiceCreatePromptResult struct { - Success *CreatePromptResponse `thrift:"success,0,optional" frugal:"0,optional,CreatePromptResponse"` +type PromptManageServiceClonePromptResult struct { + Success *ClonePromptResponse `thrift:"success,0,optional" frugal:"0,optional,ClonePromptResponse"` } -func NewPromptManageServiceCreatePromptResult() *PromptManageServiceCreatePromptResult { - return &PromptManageServiceCreatePromptResult{} +func NewPromptManageServiceClonePromptResult() *PromptManageServiceClonePromptResult { + return &PromptManageServiceClonePromptResult{} } -func (p *PromptManageServiceCreatePromptResult) InitDefault() { +func (p *PromptManageServiceClonePromptResult) InitDefault() { } -var PromptManageServiceCreatePromptResult_Success_DEFAULT *CreatePromptResponse +var PromptManageServiceClonePromptResult_Success_DEFAULT *ClonePromptResponse -func (p *PromptManageServiceCreatePromptResult) GetSuccess() (v *CreatePromptResponse) { +func (p *PromptManageServiceClonePromptResult) GetSuccess() (v *ClonePromptResponse) { if p == nil { return } if !p.IsSetSuccess() { - return PromptManageServiceCreatePromptResult_Success_DEFAULT + return PromptManageServiceClonePromptResult_Success_DEFAULT } return p.Success } -func (p *PromptManageServiceCreatePromptResult) SetSuccess(x interface{}) { - p.Success = x.(*CreatePromptResponse) +func (p *PromptManageServiceClonePromptResult) SetSuccess(x interface{}) { + p.Success = x.(*ClonePromptResponse) } -var fieldIDToName_PromptManageServiceCreatePromptResult = map[int16]string{ +var fieldIDToName_PromptManageServiceClonePromptResult = map[int16]string{ 0: "success", } -func (p *PromptManageServiceCreatePromptResult) IsSetSuccess() bool { +func (p *PromptManageServiceClonePromptResult) IsSetSuccess() bool { return p.Success != nil } -func (p *PromptManageServiceCreatePromptResult) Read(iprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceClonePromptResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -14420,7 +15443,7 @@ ReadStructBeginError: 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_PromptManageServiceCreatePromptResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_PromptManageServiceClonePromptResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -14429,9 +15452,9 @@ ReadFieldEndError: ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } - -func (p *PromptManageServiceCreatePromptResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewCreatePromptResponse() + +func (p *PromptManageServiceClonePromptResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewClonePromptResponse() if err := _field.Read(iprot); err != nil { return err } @@ -14439,9 +15462,9 @@ func (p *PromptManageServiceCreatePromptResult) ReadField0(iprot thrift.TProtoco return nil } -func (p *PromptManageServiceCreatePromptResult) Write(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceClonePromptResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("CreatePrompt_result"); err != nil { + if err = oprot.WriteStructBegin("ClonePrompt_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -14467,7 +15490,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *PromptManageServiceCreatePromptResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceClonePromptResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -14486,15 +15509,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *PromptManageServiceCreatePromptResult) String() string { +func (p *PromptManageServiceClonePromptResult) String() string { if p == nil { return "" } - return fmt.Sprintf("PromptManageServiceCreatePromptResult(%+v)", *p) + return fmt.Sprintf("PromptManageServiceClonePromptResult(%+v)", *p) } -func (p *PromptManageServiceCreatePromptResult) DeepEqual(ano *PromptManageServiceCreatePromptResult) bool { +func (p *PromptManageServiceClonePromptResult) DeepEqual(ano *PromptManageServiceClonePromptResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -14506,7 +15529,7 @@ func (p *PromptManageServiceCreatePromptResult) DeepEqual(ano *PromptManageServi return true } -func (p *PromptManageServiceCreatePromptResult) Field0DeepEqual(src *CreatePromptResponse) bool { +func (p *PromptManageServiceClonePromptResult) Field0DeepEqual(src *ClonePromptResponse) bool { if !p.Success.DeepEqual(src) { return false @@ -14514,41 +15537,41 @@ func (p *PromptManageServiceCreatePromptResult) Field0DeepEqual(src *CreatePromp return true } -type PromptManageServiceClonePromptArgs struct { - Request *ClonePromptRequest `thrift:"request,1" frugal:"1,default,ClonePromptRequest"` +type PromptManageServiceDeletePromptArgs struct { + Request *DeletePromptRequest `thrift:"request,1" frugal:"1,default,DeletePromptRequest"` } -func NewPromptManageServiceClonePromptArgs() *PromptManageServiceClonePromptArgs { - return &PromptManageServiceClonePromptArgs{} +func NewPromptManageServiceDeletePromptArgs() *PromptManageServiceDeletePromptArgs { + return &PromptManageServiceDeletePromptArgs{} } -func (p *PromptManageServiceClonePromptArgs) InitDefault() { +func (p *PromptManageServiceDeletePromptArgs) InitDefault() { } -var PromptManageServiceClonePromptArgs_Request_DEFAULT *ClonePromptRequest +var PromptManageServiceDeletePromptArgs_Request_DEFAULT *DeletePromptRequest -func (p *PromptManageServiceClonePromptArgs) GetRequest() (v *ClonePromptRequest) { +func (p *PromptManageServiceDeletePromptArgs) GetRequest() (v *DeletePromptRequest) { if p == nil { return } if !p.IsSetRequest() { - return PromptManageServiceClonePromptArgs_Request_DEFAULT + return PromptManageServiceDeletePromptArgs_Request_DEFAULT } return p.Request } -func (p *PromptManageServiceClonePromptArgs) SetRequest(val *ClonePromptRequest) { +func (p *PromptManageServiceDeletePromptArgs) SetRequest(val *DeletePromptRequest) { p.Request = val } -var fieldIDToName_PromptManageServiceClonePromptArgs = map[int16]string{ +var fieldIDToName_PromptManageServiceDeletePromptArgs = map[int16]string{ 1: "request", } -func (p *PromptManageServiceClonePromptArgs) IsSetRequest() bool { +func (p *PromptManageServiceDeletePromptArgs) IsSetRequest() bool { return p.Request != nil } -func (p *PromptManageServiceClonePromptArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceDeletePromptArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -14593,7 +15616,7 @@ ReadStructBeginError: 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_PromptManageServiceClonePromptArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_PromptManageServiceDeletePromptArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -14603,8 +15626,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *PromptManageServiceClonePromptArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewClonePromptRequest() +func (p *PromptManageServiceDeletePromptArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewDeletePromptRequest() if err := _field.Read(iprot); err != nil { return err } @@ -14612,9 +15635,9 @@ func (p *PromptManageServiceClonePromptArgs) ReadField1(iprot thrift.TProtocol) return nil } -func (p *PromptManageServiceClonePromptArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceDeletePromptArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("ClonePrompt_args"); err != nil { + if err = oprot.WriteStructBegin("DeletePrompt_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -14640,7 +15663,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *PromptManageServiceClonePromptArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceDeletePromptArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -14657,15 +15680,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *PromptManageServiceClonePromptArgs) String() string { +func (p *PromptManageServiceDeletePromptArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("PromptManageServiceClonePromptArgs(%+v)", *p) + return fmt.Sprintf("PromptManageServiceDeletePromptArgs(%+v)", *p) } -func (p *PromptManageServiceClonePromptArgs) DeepEqual(ano *PromptManageServiceClonePromptArgs) bool { +func (p *PromptManageServiceDeletePromptArgs) DeepEqual(ano *PromptManageServiceDeletePromptArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -14677,7 +15700,7 @@ func (p *PromptManageServiceClonePromptArgs) DeepEqual(ano *PromptManageServiceC return true } -func (p *PromptManageServiceClonePromptArgs) Field1DeepEqual(src *ClonePromptRequest) bool { +func (p *PromptManageServiceDeletePromptArgs) Field1DeepEqual(src *DeletePromptRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -14685,41 +15708,41 @@ func (p *PromptManageServiceClonePromptArgs) Field1DeepEqual(src *ClonePromptReq return true } -type PromptManageServiceClonePromptResult struct { - Success *ClonePromptResponse `thrift:"success,0,optional" frugal:"0,optional,ClonePromptResponse"` +type PromptManageServiceDeletePromptResult struct { + Success *DeletePromptResponse `thrift:"success,0,optional" frugal:"0,optional,DeletePromptResponse"` } -func NewPromptManageServiceClonePromptResult() *PromptManageServiceClonePromptResult { - return &PromptManageServiceClonePromptResult{} +func NewPromptManageServiceDeletePromptResult() *PromptManageServiceDeletePromptResult { + return &PromptManageServiceDeletePromptResult{} } -func (p *PromptManageServiceClonePromptResult) InitDefault() { +func (p *PromptManageServiceDeletePromptResult) InitDefault() { } -var PromptManageServiceClonePromptResult_Success_DEFAULT *ClonePromptResponse +var PromptManageServiceDeletePromptResult_Success_DEFAULT *DeletePromptResponse -func (p *PromptManageServiceClonePromptResult) GetSuccess() (v *ClonePromptResponse) { +func (p *PromptManageServiceDeletePromptResult) GetSuccess() (v *DeletePromptResponse) { if p == nil { return } if !p.IsSetSuccess() { - return PromptManageServiceClonePromptResult_Success_DEFAULT + return PromptManageServiceDeletePromptResult_Success_DEFAULT } return p.Success } -func (p *PromptManageServiceClonePromptResult) SetSuccess(x interface{}) { - p.Success = x.(*ClonePromptResponse) +func (p *PromptManageServiceDeletePromptResult) SetSuccess(x interface{}) { + p.Success = x.(*DeletePromptResponse) } -var fieldIDToName_PromptManageServiceClonePromptResult = map[int16]string{ +var fieldIDToName_PromptManageServiceDeletePromptResult = map[int16]string{ 0: "success", } -func (p *PromptManageServiceClonePromptResult) IsSetSuccess() bool { +func (p *PromptManageServiceDeletePromptResult) IsSetSuccess() bool { return p.Success != nil } -func (p *PromptManageServiceClonePromptResult) Read(iprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceDeletePromptResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -14764,7 +15787,7 @@ ReadStructBeginError: 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_PromptManageServiceClonePromptResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_PromptManageServiceDeletePromptResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -14774,8 +15797,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *PromptManageServiceClonePromptResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewClonePromptResponse() +func (p *PromptManageServiceDeletePromptResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewDeletePromptResponse() if err := _field.Read(iprot); err != nil { return err } @@ -14783,9 +15806,9 @@ func (p *PromptManageServiceClonePromptResult) ReadField0(iprot thrift.TProtocol return nil } -func (p *PromptManageServiceClonePromptResult) Write(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceDeletePromptResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("ClonePrompt_result"); err != nil { + if err = oprot.WriteStructBegin("DeletePrompt_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -14811,7 +15834,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *PromptManageServiceClonePromptResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceDeletePromptResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -14830,15 +15853,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *PromptManageServiceClonePromptResult) String() string { +func (p *PromptManageServiceDeletePromptResult) String() string { if p == nil { return "" } - return fmt.Sprintf("PromptManageServiceClonePromptResult(%+v)", *p) + return fmt.Sprintf("PromptManageServiceDeletePromptResult(%+v)", *p) } -func (p *PromptManageServiceClonePromptResult) DeepEqual(ano *PromptManageServiceClonePromptResult) bool { +func (p *PromptManageServiceDeletePromptResult) DeepEqual(ano *PromptManageServiceDeletePromptResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -14850,7 +15873,7 @@ func (p *PromptManageServiceClonePromptResult) DeepEqual(ano *PromptManageServic return true } -func (p *PromptManageServiceClonePromptResult) Field0DeepEqual(src *ClonePromptResponse) bool { +func (p *PromptManageServiceDeletePromptResult) Field0DeepEqual(src *DeletePromptResponse) bool { if !p.Success.DeepEqual(src) { return false @@ -14858,41 +15881,41 @@ func (p *PromptManageServiceClonePromptResult) Field0DeepEqual(src *ClonePromptR return true } -type PromptManageServiceDeletePromptArgs struct { - Request *DeletePromptRequest `thrift:"request,1" frugal:"1,default,DeletePromptRequest"` +type PromptManageServiceGetPromptArgs struct { + Request *GetPromptRequest `thrift:"request,1" frugal:"1,default,GetPromptRequest"` } -func NewPromptManageServiceDeletePromptArgs() *PromptManageServiceDeletePromptArgs { - return &PromptManageServiceDeletePromptArgs{} +func NewPromptManageServiceGetPromptArgs() *PromptManageServiceGetPromptArgs { + return &PromptManageServiceGetPromptArgs{} } -func (p *PromptManageServiceDeletePromptArgs) InitDefault() { +func (p *PromptManageServiceGetPromptArgs) InitDefault() { } -var PromptManageServiceDeletePromptArgs_Request_DEFAULT *DeletePromptRequest +var PromptManageServiceGetPromptArgs_Request_DEFAULT *GetPromptRequest -func (p *PromptManageServiceDeletePromptArgs) GetRequest() (v *DeletePromptRequest) { +func (p *PromptManageServiceGetPromptArgs) GetRequest() (v *GetPromptRequest) { if p == nil { return } if !p.IsSetRequest() { - return PromptManageServiceDeletePromptArgs_Request_DEFAULT + return PromptManageServiceGetPromptArgs_Request_DEFAULT } return p.Request } -func (p *PromptManageServiceDeletePromptArgs) SetRequest(val *DeletePromptRequest) { +func (p *PromptManageServiceGetPromptArgs) SetRequest(val *GetPromptRequest) { p.Request = val } -var fieldIDToName_PromptManageServiceDeletePromptArgs = map[int16]string{ +var fieldIDToName_PromptManageServiceGetPromptArgs = map[int16]string{ 1: "request", } -func (p *PromptManageServiceDeletePromptArgs) IsSetRequest() bool { +func (p *PromptManageServiceGetPromptArgs) IsSetRequest() bool { return p.Request != nil } -func (p *PromptManageServiceDeletePromptArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceGetPromptArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -14937,7 +15960,7 @@ ReadStructBeginError: 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_PromptManageServiceDeletePromptArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_PromptManageServiceGetPromptArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -14947,8 +15970,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *PromptManageServiceDeletePromptArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewDeletePromptRequest() +func (p *PromptManageServiceGetPromptArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewGetPromptRequest() if err := _field.Read(iprot); err != nil { return err } @@ -14956,9 +15979,9 @@ func (p *PromptManageServiceDeletePromptArgs) ReadField1(iprot thrift.TProtocol) return nil } -func (p *PromptManageServiceDeletePromptArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceGetPromptArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("DeletePrompt_args"); err != nil { + if err = oprot.WriteStructBegin("GetPrompt_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -14984,7 +16007,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *PromptManageServiceDeletePromptArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceGetPromptArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -15001,15 +16024,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *PromptManageServiceDeletePromptArgs) String() string { +func (p *PromptManageServiceGetPromptArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("PromptManageServiceDeletePromptArgs(%+v)", *p) + return fmt.Sprintf("PromptManageServiceGetPromptArgs(%+v)", *p) } -func (p *PromptManageServiceDeletePromptArgs) DeepEqual(ano *PromptManageServiceDeletePromptArgs) bool { +func (p *PromptManageServiceGetPromptArgs) DeepEqual(ano *PromptManageServiceGetPromptArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -15021,7 +16044,7 @@ func (p *PromptManageServiceDeletePromptArgs) DeepEqual(ano *PromptManageService return true } -func (p *PromptManageServiceDeletePromptArgs) Field1DeepEqual(src *DeletePromptRequest) bool { +func (p *PromptManageServiceGetPromptArgs) Field1DeepEqual(src *GetPromptRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -15029,41 +16052,41 @@ func (p *PromptManageServiceDeletePromptArgs) Field1DeepEqual(src *DeletePromptR return true } -type PromptManageServiceDeletePromptResult struct { - Success *DeletePromptResponse `thrift:"success,0,optional" frugal:"0,optional,DeletePromptResponse"` +type PromptManageServiceGetPromptResult struct { + Success *GetPromptResponse `thrift:"success,0,optional" frugal:"0,optional,GetPromptResponse"` } -func NewPromptManageServiceDeletePromptResult() *PromptManageServiceDeletePromptResult { - return &PromptManageServiceDeletePromptResult{} +func NewPromptManageServiceGetPromptResult() *PromptManageServiceGetPromptResult { + return &PromptManageServiceGetPromptResult{} } -func (p *PromptManageServiceDeletePromptResult) InitDefault() { +func (p *PromptManageServiceGetPromptResult) InitDefault() { } -var PromptManageServiceDeletePromptResult_Success_DEFAULT *DeletePromptResponse +var PromptManageServiceGetPromptResult_Success_DEFAULT *GetPromptResponse -func (p *PromptManageServiceDeletePromptResult) GetSuccess() (v *DeletePromptResponse) { +func (p *PromptManageServiceGetPromptResult) GetSuccess() (v *GetPromptResponse) { if p == nil { return } if !p.IsSetSuccess() { - return PromptManageServiceDeletePromptResult_Success_DEFAULT + return PromptManageServiceGetPromptResult_Success_DEFAULT } return p.Success } -func (p *PromptManageServiceDeletePromptResult) SetSuccess(x interface{}) { - p.Success = x.(*DeletePromptResponse) +func (p *PromptManageServiceGetPromptResult) SetSuccess(x interface{}) { + p.Success = x.(*GetPromptResponse) } -var fieldIDToName_PromptManageServiceDeletePromptResult = map[int16]string{ +var fieldIDToName_PromptManageServiceGetPromptResult = map[int16]string{ 0: "success", } -func (p *PromptManageServiceDeletePromptResult) IsSetSuccess() bool { +func (p *PromptManageServiceGetPromptResult) IsSetSuccess() bool { return p.Success != nil } -func (p *PromptManageServiceDeletePromptResult) Read(iprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceGetPromptResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -15108,7 +16131,7 @@ ReadStructBeginError: 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_PromptManageServiceDeletePromptResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_PromptManageServiceGetPromptResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -15118,8 +16141,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *PromptManageServiceDeletePromptResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewDeletePromptResponse() +func (p *PromptManageServiceGetPromptResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewGetPromptResponse() if err := _field.Read(iprot); err != nil { return err } @@ -15127,9 +16150,9 @@ func (p *PromptManageServiceDeletePromptResult) ReadField0(iprot thrift.TProtoco return nil } -func (p *PromptManageServiceDeletePromptResult) Write(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceGetPromptResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("DeletePrompt_result"); err != nil { + if err = oprot.WriteStructBegin("GetPrompt_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -15155,7 +16178,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *PromptManageServiceDeletePromptResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceGetPromptResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -15174,15 +16197,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *PromptManageServiceDeletePromptResult) String() string { +func (p *PromptManageServiceGetPromptResult) String() string { if p == nil { return "" } - return fmt.Sprintf("PromptManageServiceDeletePromptResult(%+v)", *p) + return fmt.Sprintf("PromptManageServiceGetPromptResult(%+v)", *p) } -func (p *PromptManageServiceDeletePromptResult) DeepEqual(ano *PromptManageServiceDeletePromptResult) bool { +func (p *PromptManageServiceGetPromptResult) DeepEqual(ano *PromptManageServiceGetPromptResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -15194,7 +16217,7 @@ func (p *PromptManageServiceDeletePromptResult) DeepEqual(ano *PromptManageServi return true } -func (p *PromptManageServiceDeletePromptResult) Field0DeepEqual(src *DeletePromptResponse) bool { +func (p *PromptManageServiceGetPromptResult) Field0DeepEqual(src *GetPromptResponse) bool { if !p.Success.DeepEqual(src) { return false @@ -15202,41 +16225,41 @@ func (p *PromptManageServiceDeletePromptResult) Field0DeepEqual(src *DeletePromp return true } -type PromptManageServiceGetPromptArgs struct { - Request *GetPromptRequest `thrift:"request,1" frugal:"1,default,GetPromptRequest"` +type PromptManageServiceBatchGetPromptArgs struct { + Request *BatchGetPromptRequest `thrift:"request,1" frugal:"1,default,BatchGetPromptRequest"` } -func NewPromptManageServiceGetPromptArgs() *PromptManageServiceGetPromptArgs { - return &PromptManageServiceGetPromptArgs{} +func NewPromptManageServiceBatchGetPromptArgs() *PromptManageServiceBatchGetPromptArgs { + return &PromptManageServiceBatchGetPromptArgs{} } -func (p *PromptManageServiceGetPromptArgs) InitDefault() { +func (p *PromptManageServiceBatchGetPromptArgs) InitDefault() { } -var PromptManageServiceGetPromptArgs_Request_DEFAULT *GetPromptRequest +var PromptManageServiceBatchGetPromptArgs_Request_DEFAULT *BatchGetPromptRequest -func (p *PromptManageServiceGetPromptArgs) GetRequest() (v *GetPromptRequest) { +func (p *PromptManageServiceBatchGetPromptArgs) GetRequest() (v *BatchGetPromptRequest) { if p == nil { return } if !p.IsSetRequest() { - return PromptManageServiceGetPromptArgs_Request_DEFAULT + return PromptManageServiceBatchGetPromptArgs_Request_DEFAULT } return p.Request } -func (p *PromptManageServiceGetPromptArgs) SetRequest(val *GetPromptRequest) { +func (p *PromptManageServiceBatchGetPromptArgs) SetRequest(val *BatchGetPromptRequest) { p.Request = val } -var fieldIDToName_PromptManageServiceGetPromptArgs = map[int16]string{ +var fieldIDToName_PromptManageServiceBatchGetPromptArgs = map[int16]string{ 1: "request", } -func (p *PromptManageServiceGetPromptArgs) IsSetRequest() bool { +func (p *PromptManageServiceBatchGetPromptArgs) IsSetRequest() bool { return p.Request != nil } -func (p *PromptManageServiceGetPromptArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceBatchGetPromptArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -15281,7 +16304,7 @@ ReadStructBeginError: 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_PromptManageServiceGetPromptArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_PromptManageServiceBatchGetPromptArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -15291,8 +16314,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *PromptManageServiceGetPromptArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewGetPromptRequest() +func (p *PromptManageServiceBatchGetPromptArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewBatchGetPromptRequest() if err := _field.Read(iprot); err != nil { return err } @@ -15300,9 +16323,9 @@ func (p *PromptManageServiceGetPromptArgs) ReadField1(iprot thrift.TProtocol) er return nil } -func (p *PromptManageServiceGetPromptArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceBatchGetPromptArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("GetPrompt_args"); err != nil { + if err = oprot.WriteStructBegin("BatchGetPrompt_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -15328,7 +16351,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *PromptManageServiceGetPromptArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceBatchGetPromptArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -15345,15 +16368,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *PromptManageServiceGetPromptArgs) String() string { +func (p *PromptManageServiceBatchGetPromptArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("PromptManageServiceGetPromptArgs(%+v)", *p) + return fmt.Sprintf("PromptManageServiceBatchGetPromptArgs(%+v)", *p) } -func (p *PromptManageServiceGetPromptArgs) DeepEqual(ano *PromptManageServiceGetPromptArgs) bool { +func (p *PromptManageServiceBatchGetPromptArgs) DeepEqual(ano *PromptManageServiceBatchGetPromptArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -15365,7 +16388,7 @@ func (p *PromptManageServiceGetPromptArgs) DeepEqual(ano *PromptManageServiceGet return true } -func (p *PromptManageServiceGetPromptArgs) Field1DeepEqual(src *GetPromptRequest) bool { +func (p *PromptManageServiceBatchGetPromptArgs) Field1DeepEqual(src *BatchGetPromptRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -15373,41 +16396,41 @@ func (p *PromptManageServiceGetPromptArgs) Field1DeepEqual(src *GetPromptRequest return true } -type PromptManageServiceGetPromptResult struct { - Success *GetPromptResponse `thrift:"success,0,optional" frugal:"0,optional,GetPromptResponse"` +type PromptManageServiceBatchGetPromptResult struct { + Success *BatchGetPromptResponse `thrift:"success,0,optional" frugal:"0,optional,BatchGetPromptResponse"` } -func NewPromptManageServiceGetPromptResult() *PromptManageServiceGetPromptResult { - return &PromptManageServiceGetPromptResult{} +func NewPromptManageServiceBatchGetPromptResult() *PromptManageServiceBatchGetPromptResult { + return &PromptManageServiceBatchGetPromptResult{} } -func (p *PromptManageServiceGetPromptResult) InitDefault() { +func (p *PromptManageServiceBatchGetPromptResult) InitDefault() { } -var PromptManageServiceGetPromptResult_Success_DEFAULT *GetPromptResponse +var PromptManageServiceBatchGetPromptResult_Success_DEFAULT *BatchGetPromptResponse -func (p *PromptManageServiceGetPromptResult) GetSuccess() (v *GetPromptResponse) { +func (p *PromptManageServiceBatchGetPromptResult) GetSuccess() (v *BatchGetPromptResponse) { if p == nil { return } if !p.IsSetSuccess() { - return PromptManageServiceGetPromptResult_Success_DEFAULT + return PromptManageServiceBatchGetPromptResult_Success_DEFAULT } return p.Success } -func (p *PromptManageServiceGetPromptResult) SetSuccess(x interface{}) { - p.Success = x.(*GetPromptResponse) +func (p *PromptManageServiceBatchGetPromptResult) SetSuccess(x interface{}) { + p.Success = x.(*BatchGetPromptResponse) } -var fieldIDToName_PromptManageServiceGetPromptResult = map[int16]string{ +var fieldIDToName_PromptManageServiceBatchGetPromptResult = map[int16]string{ 0: "success", } -func (p *PromptManageServiceGetPromptResult) IsSetSuccess() bool { +func (p *PromptManageServiceBatchGetPromptResult) IsSetSuccess() bool { return p.Success != nil } -func (p *PromptManageServiceGetPromptResult) Read(iprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceBatchGetPromptResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -15452,7 +16475,7 @@ ReadStructBeginError: 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_PromptManageServiceGetPromptResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_PromptManageServiceBatchGetPromptResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -15462,8 +16485,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *PromptManageServiceGetPromptResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewGetPromptResponse() +func (p *PromptManageServiceBatchGetPromptResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewBatchGetPromptResponse() if err := _field.Read(iprot); err != nil { return err } @@ -15471,9 +16494,9 @@ func (p *PromptManageServiceGetPromptResult) ReadField0(iprot thrift.TProtocol) return nil } -func (p *PromptManageServiceGetPromptResult) Write(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceBatchGetPromptResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("GetPrompt_result"); err != nil { + if err = oprot.WriteStructBegin("BatchGetPrompt_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -15499,7 +16522,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *PromptManageServiceGetPromptResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceBatchGetPromptResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -15518,15 +16541,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *PromptManageServiceGetPromptResult) String() string { +func (p *PromptManageServiceBatchGetPromptResult) String() string { if p == nil { return "" } - return fmt.Sprintf("PromptManageServiceGetPromptResult(%+v)", *p) + return fmt.Sprintf("PromptManageServiceBatchGetPromptResult(%+v)", *p) } -func (p *PromptManageServiceGetPromptResult) DeepEqual(ano *PromptManageServiceGetPromptResult) bool { +func (p *PromptManageServiceBatchGetPromptResult) DeepEqual(ano *PromptManageServiceBatchGetPromptResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -15538,7 +16561,7 @@ func (p *PromptManageServiceGetPromptResult) DeepEqual(ano *PromptManageServiceG return true } -func (p *PromptManageServiceGetPromptResult) Field0DeepEqual(src *GetPromptResponse) bool { +func (p *PromptManageServiceBatchGetPromptResult) Field0DeepEqual(src *BatchGetPromptResponse) bool { if !p.Success.DeepEqual(src) { return false @@ -15546,41 +16569,41 @@ func (p *PromptManageServiceGetPromptResult) Field0DeepEqual(src *GetPromptRespo return true } -type PromptManageServiceBatchGetPromptArgs struct { - Request *BatchGetPromptRequest `thrift:"request,1" frugal:"1,default,BatchGetPromptRequest"` +type PromptManageServiceListPromptArgs struct { + Request *ListPromptRequest `thrift:"request,1" frugal:"1,default,ListPromptRequest"` } -func NewPromptManageServiceBatchGetPromptArgs() *PromptManageServiceBatchGetPromptArgs { - return &PromptManageServiceBatchGetPromptArgs{} +func NewPromptManageServiceListPromptArgs() *PromptManageServiceListPromptArgs { + return &PromptManageServiceListPromptArgs{} } -func (p *PromptManageServiceBatchGetPromptArgs) InitDefault() { +func (p *PromptManageServiceListPromptArgs) InitDefault() { } -var PromptManageServiceBatchGetPromptArgs_Request_DEFAULT *BatchGetPromptRequest +var PromptManageServiceListPromptArgs_Request_DEFAULT *ListPromptRequest -func (p *PromptManageServiceBatchGetPromptArgs) GetRequest() (v *BatchGetPromptRequest) { +func (p *PromptManageServiceListPromptArgs) GetRequest() (v *ListPromptRequest) { if p == nil { return } if !p.IsSetRequest() { - return PromptManageServiceBatchGetPromptArgs_Request_DEFAULT + return PromptManageServiceListPromptArgs_Request_DEFAULT } return p.Request } -func (p *PromptManageServiceBatchGetPromptArgs) SetRequest(val *BatchGetPromptRequest) { +func (p *PromptManageServiceListPromptArgs) SetRequest(val *ListPromptRequest) { p.Request = val } -var fieldIDToName_PromptManageServiceBatchGetPromptArgs = map[int16]string{ +var fieldIDToName_PromptManageServiceListPromptArgs = map[int16]string{ 1: "request", } -func (p *PromptManageServiceBatchGetPromptArgs) IsSetRequest() bool { +func (p *PromptManageServiceListPromptArgs) IsSetRequest() bool { return p.Request != nil } -func (p *PromptManageServiceBatchGetPromptArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceListPromptArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -15625,7 +16648,7 @@ ReadStructBeginError: 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_PromptManageServiceBatchGetPromptArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_PromptManageServiceListPromptArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -15635,8 +16658,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *PromptManageServiceBatchGetPromptArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewBatchGetPromptRequest() +func (p *PromptManageServiceListPromptArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewListPromptRequest() if err := _field.Read(iprot); err != nil { return err } @@ -15644,9 +16667,9 @@ func (p *PromptManageServiceBatchGetPromptArgs) ReadField1(iprot thrift.TProtoco return nil } -func (p *PromptManageServiceBatchGetPromptArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceListPromptArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("BatchGetPrompt_args"); err != nil { + if err = oprot.WriteStructBegin("ListPrompt_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -15672,7 +16695,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *PromptManageServiceBatchGetPromptArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceListPromptArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -15689,15 +16712,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *PromptManageServiceBatchGetPromptArgs) String() string { +func (p *PromptManageServiceListPromptArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("PromptManageServiceBatchGetPromptArgs(%+v)", *p) + return fmt.Sprintf("PromptManageServiceListPromptArgs(%+v)", *p) } -func (p *PromptManageServiceBatchGetPromptArgs) DeepEqual(ano *PromptManageServiceBatchGetPromptArgs) bool { +func (p *PromptManageServiceListPromptArgs) DeepEqual(ano *PromptManageServiceListPromptArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -15709,7 +16732,7 @@ func (p *PromptManageServiceBatchGetPromptArgs) DeepEqual(ano *PromptManageServi return true } -func (p *PromptManageServiceBatchGetPromptArgs) Field1DeepEqual(src *BatchGetPromptRequest) bool { +func (p *PromptManageServiceListPromptArgs) Field1DeepEqual(src *ListPromptRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -15717,41 +16740,41 @@ func (p *PromptManageServiceBatchGetPromptArgs) Field1DeepEqual(src *BatchGetPro return true } -type PromptManageServiceBatchGetPromptResult struct { - Success *BatchGetPromptResponse `thrift:"success,0,optional" frugal:"0,optional,BatchGetPromptResponse"` +type PromptManageServiceListPromptResult struct { + Success *ListPromptResponse `thrift:"success,0,optional" frugal:"0,optional,ListPromptResponse"` } -func NewPromptManageServiceBatchGetPromptResult() *PromptManageServiceBatchGetPromptResult { - return &PromptManageServiceBatchGetPromptResult{} +func NewPromptManageServiceListPromptResult() *PromptManageServiceListPromptResult { + return &PromptManageServiceListPromptResult{} } -func (p *PromptManageServiceBatchGetPromptResult) InitDefault() { +func (p *PromptManageServiceListPromptResult) InitDefault() { } -var PromptManageServiceBatchGetPromptResult_Success_DEFAULT *BatchGetPromptResponse +var PromptManageServiceListPromptResult_Success_DEFAULT *ListPromptResponse -func (p *PromptManageServiceBatchGetPromptResult) GetSuccess() (v *BatchGetPromptResponse) { +func (p *PromptManageServiceListPromptResult) GetSuccess() (v *ListPromptResponse) { if p == nil { return } if !p.IsSetSuccess() { - return PromptManageServiceBatchGetPromptResult_Success_DEFAULT + return PromptManageServiceListPromptResult_Success_DEFAULT } return p.Success } -func (p *PromptManageServiceBatchGetPromptResult) SetSuccess(x interface{}) { - p.Success = x.(*BatchGetPromptResponse) +func (p *PromptManageServiceListPromptResult) SetSuccess(x interface{}) { + p.Success = x.(*ListPromptResponse) } -var fieldIDToName_PromptManageServiceBatchGetPromptResult = map[int16]string{ +var fieldIDToName_PromptManageServiceListPromptResult = map[int16]string{ 0: "success", } -func (p *PromptManageServiceBatchGetPromptResult) IsSetSuccess() bool { +func (p *PromptManageServiceListPromptResult) IsSetSuccess() bool { return p.Success != nil } -func (p *PromptManageServiceBatchGetPromptResult) Read(iprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceListPromptResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -15796,7 +16819,7 @@ ReadStructBeginError: 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_PromptManageServiceBatchGetPromptResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_PromptManageServiceListPromptResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -15806,8 +16829,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *PromptManageServiceBatchGetPromptResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewBatchGetPromptResponse() +func (p *PromptManageServiceListPromptResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewListPromptResponse() if err := _field.Read(iprot); err != nil { return err } @@ -15815,9 +16838,9 @@ func (p *PromptManageServiceBatchGetPromptResult) ReadField0(iprot thrift.TProto return nil } -func (p *PromptManageServiceBatchGetPromptResult) Write(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceListPromptResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("BatchGetPrompt_result"); err != nil { + if err = oprot.WriteStructBegin("ListPrompt_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -15843,7 +16866,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *PromptManageServiceBatchGetPromptResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceListPromptResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -15862,15 +16885,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *PromptManageServiceBatchGetPromptResult) String() string { +func (p *PromptManageServiceListPromptResult) String() string { if p == nil { return "" } - return fmt.Sprintf("PromptManageServiceBatchGetPromptResult(%+v)", *p) + return fmt.Sprintf("PromptManageServiceListPromptResult(%+v)", *p) } -func (p *PromptManageServiceBatchGetPromptResult) DeepEqual(ano *PromptManageServiceBatchGetPromptResult) bool { +func (p *PromptManageServiceListPromptResult) DeepEqual(ano *PromptManageServiceListPromptResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -15882,7 +16905,7 @@ func (p *PromptManageServiceBatchGetPromptResult) DeepEqual(ano *PromptManageSer return true } -func (p *PromptManageServiceBatchGetPromptResult) Field0DeepEqual(src *BatchGetPromptResponse) bool { +func (p *PromptManageServiceListPromptResult) Field0DeepEqual(src *ListPromptResponse) bool { if !p.Success.DeepEqual(src) { return false @@ -15890,41 +16913,41 @@ func (p *PromptManageServiceBatchGetPromptResult) Field0DeepEqual(src *BatchGetP return true } -type PromptManageServiceListPromptArgs struct { - Request *ListPromptRequest `thrift:"request,1" frugal:"1,default,ListPromptRequest"` +type PromptManageServiceListParentPromptArgs struct { + Request *ListParentPromptRequest `thrift:"request,1" frugal:"1,default,ListParentPromptRequest"` } -func NewPromptManageServiceListPromptArgs() *PromptManageServiceListPromptArgs { - return &PromptManageServiceListPromptArgs{} +func NewPromptManageServiceListParentPromptArgs() *PromptManageServiceListParentPromptArgs { + return &PromptManageServiceListParentPromptArgs{} } -func (p *PromptManageServiceListPromptArgs) InitDefault() { +func (p *PromptManageServiceListParentPromptArgs) InitDefault() { } -var PromptManageServiceListPromptArgs_Request_DEFAULT *ListPromptRequest +var PromptManageServiceListParentPromptArgs_Request_DEFAULT *ListParentPromptRequest -func (p *PromptManageServiceListPromptArgs) GetRequest() (v *ListPromptRequest) { +func (p *PromptManageServiceListParentPromptArgs) GetRequest() (v *ListParentPromptRequest) { if p == nil { return } if !p.IsSetRequest() { - return PromptManageServiceListPromptArgs_Request_DEFAULT + return PromptManageServiceListParentPromptArgs_Request_DEFAULT } return p.Request } -func (p *PromptManageServiceListPromptArgs) SetRequest(val *ListPromptRequest) { +func (p *PromptManageServiceListParentPromptArgs) SetRequest(val *ListParentPromptRequest) { p.Request = val } -var fieldIDToName_PromptManageServiceListPromptArgs = map[int16]string{ +var fieldIDToName_PromptManageServiceListParentPromptArgs = map[int16]string{ 1: "request", } -func (p *PromptManageServiceListPromptArgs) IsSetRequest() bool { +func (p *PromptManageServiceListParentPromptArgs) IsSetRequest() bool { return p.Request != nil } -func (p *PromptManageServiceListPromptArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceListParentPromptArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -15969,7 +16992,7 @@ ReadStructBeginError: 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_PromptManageServiceListPromptArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_PromptManageServiceListParentPromptArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -15979,8 +17002,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *PromptManageServiceListPromptArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewListPromptRequest() +func (p *PromptManageServiceListParentPromptArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewListParentPromptRequest() if err := _field.Read(iprot); err != nil { return err } @@ -15988,9 +17011,9 @@ func (p *PromptManageServiceListPromptArgs) ReadField1(iprot thrift.TProtocol) e return nil } -func (p *PromptManageServiceListPromptArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceListParentPromptArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("ListPrompt_args"); err != nil { + if err = oprot.WriteStructBegin("ListParentPrompt_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -16016,7 +17039,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *PromptManageServiceListPromptArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceListParentPromptArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -16033,15 +17056,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *PromptManageServiceListPromptArgs) String() string { +func (p *PromptManageServiceListParentPromptArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("PromptManageServiceListPromptArgs(%+v)", *p) + return fmt.Sprintf("PromptManageServiceListParentPromptArgs(%+v)", *p) } -func (p *PromptManageServiceListPromptArgs) DeepEqual(ano *PromptManageServiceListPromptArgs) bool { +func (p *PromptManageServiceListParentPromptArgs) DeepEqual(ano *PromptManageServiceListParentPromptArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -16053,7 +17076,7 @@ func (p *PromptManageServiceListPromptArgs) DeepEqual(ano *PromptManageServiceLi return true } -func (p *PromptManageServiceListPromptArgs) Field1DeepEqual(src *ListPromptRequest) bool { +func (p *PromptManageServiceListParentPromptArgs) Field1DeepEqual(src *ListParentPromptRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -16061,41 +17084,41 @@ func (p *PromptManageServiceListPromptArgs) Field1DeepEqual(src *ListPromptReque return true } -type PromptManageServiceListPromptResult struct { - Success *ListPromptResponse `thrift:"success,0,optional" frugal:"0,optional,ListPromptResponse"` +type PromptManageServiceListParentPromptResult struct { + Success *ListParentPromptResponse `thrift:"success,0,optional" frugal:"0,optional,ListParentPromptResponse"` } -func NewPromptManageServiceListPromptResult() *PromptManageServiceListPromptResult { - return &PromptManageServiceListPromptResult{} +func NewPromptManageServiceListParentPromptResult() *PromptManageServiceListParentPromptResult { + return &PromptManageServiceListParentPromptResult{} } -func (p *PromptManageServiceListPromptResult) InitDefault() { +func (p *PromptManageServiceListParentPromptResult) InitDefault() { } -var PromptManageServiceListPromptResult_Success_DEFAULT *ListPromptResponse +var PromptManageServiceListParentPromptResult_Success_DEFAULT *ListParentPromptResponse -func (p *PromptManageServiceListPromptResult) GetSuccess() (v *ListPromptResponse) { +func (p *PromptManageServiceListParentPromptResult) GetSuccess() (v *ListParentPromptResponse) { if p == nil { return } if !p.IsSetSuccess() { - return PromptManageServiceListPromptResult_Success_DEFAULT + return PromptManageServiceListParentPromptResult_Success_DEFAULT } return p.Success } -func (p *PromptManageServiceListPromptResult) SetSuccess(x interface{}) { - p.Success = x.(*ListPromptResponse) +func (p *PromptManageServiceListParentPromptResult) SetSuccess(x interface{}) { + p.Success = x.(*ListParentPromptResponse) } -var fieldIDToName_PromptManageServiceListPromptResult = map[int16]string{ +var fieldIDToName_PromptManageServiceListParentPromptResult = map[int16]string{ 0: "success", } -func (p *PromptManageServiceListPromptResult) IsSetSuccess() bool { +func (p *PromptManageServiceListParentPromptResult) IsSetSuccess() bool { return p.Success != nil } -func (p *PromptManageServiceListPromptResult) Read(iprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceListParentPromptResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -16140,7 +17163,7 @@ ReadStructBeginError: 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_PromptManageServiceListPromptResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_PromptManageServiceListParentPromptResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -16150,8 +17173,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *PromptManageServiceListPromptResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewListPromptResponse() +func (p *PromptManageServiceListParentPromptResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewListParentPromptResponse() if err := _field.Read(iprot); err != nil { return err } @@ -16159,9 +17182,9 @@ func (p *PromptManageServiceListPromptResult) ReadField0(iprot thrift.TProtocol) return nil } -func (p *PromptManageServiceListPromptResult) Write(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceListParentPromptResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("ListPrompt_result"); err != nil { + if err = oprot.WriteStructBegin("ListParentPrompt_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -16187,7 +17210,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *PromptManageServiceListPromptResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceListParentPromptResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -16206,15 +17229,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *PromptManageServiceListPromptResult) String() string { +func (p *PromptManageServiceListParentPromptResult) String() string { if p == nil { return "" } - return fmt.Sprintf("PromptManageServiceListPromptResult(%+v)", *p) + return fmt.Sprintf("PromptManageServiceListParentPromptResult(%+v)", *p) } -func (p *PromptManageServiceListPromptResult) DeepEqual(ano *PromptManageServiceListPromptResult) bool { +func (p *PromptManageServiceListParentPromptResult) DeepEqual(ano *PromptManageServiceListParentPromptResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -16226,7 +17249,7 @@ func (p *PromptManageServiceListPromptResult) DeepEqual(ano *PromptManageService return true } -func (p *PromptManageServiceListPromptResult) Field0DeepEqual(src *ListPromptResponse) bool { +func (p *PromptManageServiceListParentPromptResult) Field0DeepEqual(src *ListParentPromptResponse) bool { if !p.Success.DeepEqual(src) { return false @@ -16234,41 +17257,41 @@ func (p *PromptManageServiceListPromptResult) Field0DeepEqual(src *ListPromptRes return true } -type PromptManageServiceListParentPromptArgs struct { - Request *ListParentPromptRequest `thrift:"request,1" frugal:"1,default,ListParentPromptRequest"` +type PromptManageServiceBatchGetPromptBasicArgs struct { + Request *BatchGetPromptBasicRequest `thrift:"request,1" frugal:"1,default,BatchGetPromptBasicRequest"` } -func NewPromptManageServiceListParentPromptArgs() *PromptManageServiceListParentPromptArgs { - return &PromptManageServiceListParentPromptArgs{} +func NewPromptManageServiceBatchGetPromptBasicArgs() *PromptManageServiceBatchGetPromptBasicArgs { + return &PromptManageServiceBatchGetPromptBasicArgs{} } -func (p *PromptManageServiceListParentPromptArgs) InitDefault() { +func (p *PromptManageServiceBatchGetPromptBasicArgs) InitDefault() { } -var PromptManageServiceListParentPromptArgs_Request_DEFAULT *ListParentPromptRequest +var PromptManageServiceBatchGetPromptBasicArgs_Request_DEFAULT *BatchGetPromptBasicRequest -func (p *PromptManageServiceListParentPromptArgs) GetRequest() (v *ListParentPromptRequest) { +func (p *PromptManageServiceBatchGetPromptBasicArgs) GetRequest() (v *BatchGetPromptBasicRequest) { if p == nil { return } if !p.IsSetRequest() { - return PromptManageServiceListParentPromptArgs_Request_DEFAULT + return PromptManageServiceBatchGetPromptBasicArgs_Request_DEFAULT } return p.Request } -func (p *PromptManageServiceListParentPromptArgs) SetRequest(val *ListParentPromptRequest) { +func (p *PromptManageServiceBatchGetPromptBasicArgs) SetRequest(val *BatchGetPromptBasicRequest) { p.Request = val } -var fieldIDToName_PromptManageServiceListParentPromptArgs = map[int16]string{ +var fieldIDToName_PromptManageServiceBatchGetPromptBasicArgs = map[int16]string{ 1: "request", } -func (p *PromptManageServiceListParentPromptArgs) IsSetRequest() bool { +func (p *PromptManageServiceBatchGetPromptBasicArgs) IsSetRequest() bool { return p.Request != nil } -func (p *PromptManageServiceListParentPromptArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceBatchGetPromptBasicArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -16313,7 +17336,7 @@ ReadStructBeginError: 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_PromptManageServiceListParentPromptArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_PromptManageServiceBatchGetPromptBasicArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -16323,8 +17346,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *PromptManageServiceListParentPromptArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewListParentPromptRequest() +func (p *PromptManageServiceBatchGetPromptBasicArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewBatchGetPromptBasicRequest() if err := _field.Read(iprot); err != nil { return err } @@ -16332,9 +17355,9 @@ func (p *PromptManageServiceListParentPromptArgs) ReadField1(iprot thrift.TProto return nil } -func (p *PromptManageServiceListParentPromptArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceBatchGetPromptBasicArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("ListParentPrompt_args"); err != nil { + if err = oprot.WriteStructBegin("BatchGetPromptBasic_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -16360,7 +17383,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *PromptManageServiceListParentPromptArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceBatchGetPromptBasicArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -16377,15 +17400,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *PromptManageServiceListParentPromptArgs) String() string { +func (p *PromptManageServiceBatchGetPromptBasicArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("PromptManageServiceListParentPromptArgs(%+v)", *p) + return fmt.Sprintf("PromptManageServiceBatchGetPromptBasicArgs(%+v)", *p) } -func (p *PromptManageServiceListParentPromptArgs) DeepEqual(ano *PromptManageServiceListParentPromptArgs) bool { +func (p *PromptManageServiceBatchGetPromptBasicArgs) DeepEqual(ano *PromptManageServiceBatchGetPromptBasicArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -16397,7 +17420,7 @@ func (p *PromptManageServiceListParentPromptArgs) DeepEqual(ano *PromptManageSer return true } -func (p *PromptManageServiceListParentPromptArgs) Field1DeepEqual(src *ListParentPromptRequest) bool { +func (p *PromptManageServiceBatchGetPromptBasicArgs) Field1DeepEqual(src *BatchGetPromptBasicRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -16405,41 +17428,41 @@ func (p *PromptManageServiceListParentPromptArgs) Field1DeepEqual(src *ListParen return true } -type PromptManageServiceListParentPromptResult struct { - Success *ListParentPromptResponse `thrift:"success,0,optional" frugal:"0,optional,ListParentPromptResponse"` +type PromptManageServiceBatchGetPromptBasicResult struct { + Success *BatchGetPromptBasicResponse `thrift:"success,0,optional" frugal:"0,optional,BatchGetPromptBasicResponse"` } -func NewPromptManageServiceListParentPromptResult() *PromptManageServiceListParentPromptResult { - return &PromptManageServiceListParentPromptResult{} +func NewPromptManageServiceBatchGetPromptBasicResult() *PromptManageServiceBatchGetPromptBasicResult { + return &PromptManageServiceBatchGetPromptBasicResult{} } -func (p *PromptManageServiceListParentPromptResult) InitDefault() { +func (p *PromptManageServiceBatchGetPromptBasicResult) InitDefault() { } -var PromptManageServiceListParentPromptResult_Success_DEFAULT *ListParentPromptResponse +var PromptManageServiceBatchGetPromptBasicResult_Success_DEFAULT *BatchGetPromptBasicResponse -func (p *PromptManageServiceListParentPromptResult) GetSuccess() (v *ListParentPromptResponse) { +func (p *PromptManageServiceBatchGetPromptBasicResult) GetSuccess() (v *BatchGetPromptBasicResponse) { if p == nil { return } if !p.IsSetSuccess() { - return PromptManageServiceListParentPromptResult_Success_DEFAULT + return PromptManageServiceBatchGetPromptBasicResult_Success_DEFAULT } return p.Success } -func (p *PromptManageServiceListParentPromptResult) SetSuccess(x interface{}) { - p.Success = x.(*ListParentPromptResponse) +func (p *PromptManageServiceBatchGetPromptBasicResult) SetSuccess(x interface{}) { + p.Success = x.(*BatchGetPromptBasicResponse) } -var fieldIDToName_PromptManageServiceListParentPromptResult = map[int16]string{ +var fieldIDToName_PromptManageServiceBatchGetPromptBasicResult = map[int16]string{ 0: "success", } -func (p *PromptManageServiceListParentPromptResult) IsSetSuccess() bool { +func (p *PromptManageServiceBatchGetPromptBasicResult) IsSetSuccess() bool { return p.Success != nil } -func (p *PromptManageServiceListParentPromptResult) Read(iprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceBatchGetPromptBasicResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -16484,7 +17507,7 @@ ReadStructBeginError: 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_PromptManageServiceListParentPromptResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_PromptManageServiceBatchGetPromptBasicResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -16494,8 +17517,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *PromptManageServiceListParentPromptResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewListParentPromptResponse() +func (p *PromptManageServiceBatchGetPromptBasicResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewBatchGetPromptBasicResponse() if err := _field.Read(iprot); err != nil { return err } @@ -16503,9 +17526,9 @@ func (p *PromptManageServiceListParentPromptResult) ReadField0(iprot thrift.TPro return nil } -func (p *PromptManageServiceListParentPromptResult) Write(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceBatchGetPromptBasicResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("ListParentPrompt_result"); err != nil { + if err = oprot.WriteStructBegin("BatchGetPromptBasic_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -16531,7 +17554,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *PromptManageServiceListParentPromptResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *PromptManageServiceBatchGetPromptBasicResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -16550,15 +17573,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *PromptManageServiceListParentPromptResult) String() string { +func (p *PromptManageServiceBatchGetPromptBasicResult) String() string { if p == nil { return "" } - return fmt.Sprintf("PromptManageServiceListParentPromptResult(%+v)", *p) + return fmt.Sprintf("PromptManageServiceBatchGetPromptBasicResult(%+v)", *p) } -func (p *PromptManageServiceListParentPromptResult) DeepEqual(ano *PromptManageServiceListParentPromptResult) bool { +func (p *PromptManageServiceBatchGetPromptBasicResult) DeepEqual(ano *PromptManageServiceBatchGetPromptBasicResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -16570,7 +17593,7 @@ func (p *PromptManageServiceListParentPromptResult) DeepEqual(ano *PromptManageS return true } -func (p *PromptManageServiceListParentPromptResult) Field0DeepEqual(src *ListParentPromptResponse) bool { +func (p *PromptManageServiceBatchGetPromptBasicResult) Field0DeepEqual(src *BatchGetPromptBasicResponse) bool { if !p.Success.DeepEqual(src) { return false diff --git a/backend/kitex_gen/coze/loop/prompt/manage/coze.loop.prompt.manage_validator.go b/backend/kitex_gen/coze/loop/prompt/manage/coze.loop.prompt.manage_validator.go index be8d6c11b..fb7b91a86 100644 --- a/backend/kitex_gen/coze/loop/prompt/manage/coze.loop.prompt.manage_validator.go +++ b/backend/kitex_gen/coze/loop/prompt/manage/coze.loop.prompt.manage_validator.go @@ -511,3 +511,25 @@ func (p *ListParentPromptResponse) IsValid() error { } return nil } +func (p *BatchGetPromptBasicRequest) 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.Base != nil { + if err := p.Base.IsValid(); err != nil { + return fmt.Errorf("field Base not valid, %w", err) + } + } + return nil +} +func (p *BatchGetPromptBasicResponse) 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/manage/k-coze.loop.prompt.manage.go b/backend/kitex_gen/coze/loop/prompt/manage/k-coze.loop.prompt.manage.go index b66c724f8..87d0af839 100644 --- a/backend/kitex_gen/coze/loop/prompt/manage/k-coze.loop.prompt.manage.go +++ b/backend/kitex_gen/coze/loop/prompt/manage/k-coze.loop.prompt.manage.go @@ -9520,6 +9520,458 @@ func (p *ListParentPromptResponse) DeepCopy(s interface{}) error { return nil } +func (p *BatchGetPromptBasicRequest) 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_BatchGetPromptBasicRequest[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *BatchGetPromptBasicRequest) 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 *BatchGetPromptBasicRequest) 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([]int64, 0, size) + for i := 0; i < size; i++ { + var _elem int64 + if v, l, err := thrift.Binary.ReadI64(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + _elem = v + } + + _field = append(_field, _elem) + } + p.PromptIds = _field + return offset, nil +} + +func (p *BatchGetPromptBasicRequest) 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 *BatchGetPromptBasicRequest) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *BatchGetPromptBasicRequest) 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 *BatchGetPromptBasicRequest) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + l += p.field2Length() + l += p.field255Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *BatchGetPromptBasicRequest) 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 *BatchGetPromptBasicRequest) fastWriteField2(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetPromptIds() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.LIST, 2) + listBeginOffset := offset + offset += thrift.Binary.ListBeginLength() + var length int + for _, v := range p.PromptIds { + length++ + offset += thrift.Binary.WriteI64(buf[offset:], v) + } + thrift.Binary.WriteListBegin(buf[listBeginOffset:], thrift.I64, length) + } + return offset +} + +func (p *BatchGetPromptBasicRequest) 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 *BatchGetPromptBasicRequest) field1Length() int { + l := 0 + if p.IsSetWorkspaceID() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.I64Length() + } + return l +} + +func (p *BatchGetPromptBasicRequest) field2Length() int { + l := 0 + if p.IsSetPromptIds() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.ListBeginLength() + l += + thrift.Binary.I64Length() * len(p.PromptIds) + } + return l +} + +func (p *BatchGetPromptBasicRequest) field255Length() int { + l := 0 + if p.IsSetBase() { + l += thrift.Binary.FieldBeginLength() + l += p.Base.BLength() + } + return l +} + +func (p *BatchGetPromptBasicRequest) DeepCopy(s interface{}) error { + src, ok := s.(*BatchGetPromptBasicRequest) + 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.PromptIds != nil { + p.PromptIds = make([]int64, 0, len(src.PromptIds)) + for _, elem := range src.PromptIds { + var _elem int64 + _elem = elem + p.PromptIds = append(p.PromptIds, _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 *BatchGetPromptBasicResponse) 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_BatchGetPromptBasicResponse[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *BatchGetPromptBasicResponse) 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([]*prompt.Prompt, 0, size) + values := make([]prompt.Prompt, 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.Prompts = _field + return offset, nil +} + +func (p *BatchGetPromptBasicResponse) 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 *BatchGetPromptBasicResponse) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *BatchGetPromptBasicResponse) 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 *BatchGetPromptBasicResponse) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + l += p.field255Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *BatchGetPromptBasicResponse) fastWriteField1(buf []byte, w thrift.NocopyWriter) int { + offset := 0 + if p.IsSetPrompts() { + offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.LIST, 1) + listBeginOffset := offset + offset += thrift.Binary.ListBeginLength() + var length int + for _, v := range p.Prompts { + length++ + offset += v.FastWriteNocopy(buf[offset:], w) + } + thrift.Binary.WriteListBegin(buf[listBeginOffset:], thrift.STRUCT, length) + } + return offset +} + +func (p *BatchGetPromptBasicResponse) 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 *BatchGetPromptBasicResponse) field1Length() int { + l := 0 + if p.IsSetPrompts() { + l += thrift.Binary.FieldBeginLength() + l += thrift.Binary.ListBeginLength() + for _, v := range p.Prompts { + _ = v + l += v.BLength() + } + } + return l +} + +func (p *BatchGetPromptBasicResponse) field255Length() int { + l := 0 + if p.IsSetBaseResp() { + l += thrift.Binary.FieldBeginLength() + l += p.BaseResp.BLength() + } + return l +} + +func (p *BatchGetPromptBasicResponse) DeepCopy(s interface{}) error { + src, ok := s.(*BatchGetPromptBasicResponse) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + if src.Prompts != nil { + p.Prompts = make([]*prompt.Prompt, 0, len(src.Prompts)) + for _, elem := range src.Prompts { + var _elem *prompt.Prompt + if elem != nil { + _elem = &prompt.Prompt{} + if err := _elem.DeepCopy(elem); err != nil { + return err + } + } + + p.Prompts = append(p.Prompts, _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 *PromptManageServiceCreatePromptArgs) FastRead(buf []byte) (int, error) { var err error @@ -11158,6 +11610,240 @@ func (p *PromptManageServiceListParentPromptResult) DeepCopy(s interface{}) erro return nil } +func (p *PromptManageServiceBatchGetPromptBasicArgs) 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_PromptManageServiceBatchGetPromptBasicArgs[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *PromptManageServiceBatchGetPromptBasicArgs) FastReadField1(buf []byte) (int, error) { + offset := 0 + _field := NewBatchGetPromptBasicRequest() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Request = _field + return offset, nil +} + +func (p *PromptManageServiceBatchGetPromptBasicArgs) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *PromptManageServiceBatchGetPromptBasicArgs) 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 *PromptManageServiceBatchGetPromptBasicArgs) BLength() int { + l := 0 + if p != nil { + l += p.field1Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *PromptManageServiceBatchGetPromptBasicArgs) 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 *PromptManageServiceBatchGetPromptBasicArgs) field1Length() int { + l := 0 + l += thrift.Binary.FieldBeginLength() + l += p.Request.BLength() + return l +} + +func (p *PromptManageServiceBatchGetPromptBasicArgs) DeepCopy(s interface{}) error { + src, ok := s.(*PromptManageServiceBatchGetPromptBasicArgs) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + var _request *BatchGetPromptBasicRequest + if src.Request != nil { + _request = &BatchGetPromptBasicRequest{} + if err := _request.DeepCopy(src.Request); err != nil { + return err + } + } + p.Request = _request + + return nil +} + +func (p *PromptManageServiceBatchGetPromptBasicResult) 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_PromptManageServiceBatchGetPromptBasicResult[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +} + +func (p *PromptManageServiceBatchGetPromptBasicResult) FastReadField0(buf []byte) (int, error) { + offset := 0 + _field := NewBatchGetPromptBasicResponse() + if l, err := _field.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Success = _field + return offset, nil +} + +func (p *PromptManageServiceBatchGetPromptBasicResult) FastWrite(buf []byte) int { + return p.FastWriteNocopy(buf, nil) +} + +func (p *PromptManageServiceBatchGetPromptBasicResult) 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 *PromptManageServiceBatchGetPromptBasicResult) BLength() int { + l := 0 + if p != nil { + l += p.field0Length() + } + l += thrift.Binary.FieldStopLength() + return l +} + +func (p *PromptManageServiceBatchGetPromptBasicResult) 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 *PromptManageServiceBatchGetPromptBasicResult) field0Length() int { + l := 0 + if p.IsSetSuccess() { + l += thrift.Binary.FieldBeginLength() + l += p.Success.BLength() + } + return l +} + +func (p *PromptManageServiceBatchGetPromptBasicResult) DeepCopy(s interface{}) error { + src, ok := s.(*PromptManageServiceBatchGetPromptBasicResult) + if !ok { + return fmt.Errorf("%T's type not matched %T", s, p) + } + + var _success *BatchGetPromptBasicResponse + if src.Success != nil { + _success = &BatchGetPromptBasicResponse{} + if err := _success.DeepCopy(src.Success); err != nil { + return err + } + } + p.Success = _success + + return nil +} + func (p *PromptManageServiceUpdatePromptArgs) FastRead(buf []byte) (int, error) { var err error @@ -13320,6 +14006,14 @@ func (p *PromptManageServiceListParentPromptResult) GetResult() interface{} { return p.Success } +func (p *PromptManageServiceBatchGetPromptBasicArgs) GetFirstArgument() interface{} { + return p.Request +} + +func (p *PromptManageServiceBatchGetPromptBasicResult) GetResult() interface{} { + return p.Success +} + func (p *PromptManageServiceUpdatePromptArgs) GetFirstArgument() interface{} { return p.Request } diff --git a/backend/kitex_gen/coze/loop/prompt/manage/promptmanageservice/client.go b/backend/kitex_gen/coze/loop/prompt/manage/promptmanageservice/client.go index 3e7b1c158..aaec1bad2 100644 --- a/backend/kitex_gen/coze/loop/prompt/manage/promptmanageservice/client.go +++ b/backend/kitex_gen/coze/loop/prompt/manage/promptmanageservice/client.go @@ -18,6 +18,7 @@ type Client interface { BatchGetPrompt(ctx context.Context, request *manage.BatchGetPromptRequest, callOptions ...callopt.Option) (r *manage.BatchGetPromptResponse, err error) ListPrompt(ctx context.Context, request *manage.ListPromptRequest, callOptions ...callopt.Option) (r *manage.ListPromptResponse, err error) ListParentPrompt(ctx context.Context, request *manage.ListParentPromptRequest, callOptions ...callopt.Option) (r *manage.ListParentPromptResponse, err error) + BatchGetPromptBasic(ctx context.Context, request *manage.BatchGetPromptBasicRequest, callOptions ...callopt.Option) (r *manage.BatchGetPromptBasicResponse, err error) UpdatePrompt(ctx context.Context, request *manage.UpdatePromptRequest, callOptions ...callopt.Option) (r *manage.UpdatePromptResponse, err error) SaveDraft(ctx context.Context, request *manage.SaveDraftRequest, callOptions ...callopt.Option) (r *manage.SaveDraftResponse, err error) CreateLabel(ctx context.Context, request *manage.CreateLabelRequest, callOptions ...callopt.Option) (r *manage.CreateLabelResponse, err error) @@ -93,6 +94,11 @@ func (p *kPromptManageServiceClient) ListParentPrompt(ctx context.Context, reque return p.kClient.ListParentPrompt(ctx, request) } +func (p *kPromptManageServiceClient) BatchGetPromptBasic(ctx context.Context, request *manage.BatchGetPromptBasicRequest, callOptions ...callopt.Option) (r *manage.BatchGetPromptBasicResponse, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.BatchGetPromptBasic(ctx, request) +} + func (p *kPromptManageServiceClient) UpdatePrompt(ctx context.Context, request *manage.UpdatePromptRequest, callOptions ...callopt.Option) (r *manage.UpdatePromptResponse, err error) { ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.UpdatePrompt(ctx, request) diff --git a/backend/kitex_gen/coze/loop/prompt/manage/promptmanageservice/promptmanageservice.go b/backend/kitex_gen/coze/loop/prompt/manage/promptmanageservice/promptmanageservice.go index d8900b7be..3ef8b1cd6 100644 --- a/backend/kitex_gen/coze/loop/prompt/manage/promptmanageservice/promptmanageservice.go +++ b/backend/kitex_gen/coze/loop/prompt/manage/promptmanageservice/promptmanageservice.go @@ -62,6 +62,13 @@ var serviceMethods = map[string]kitex.MethodInfo{ false, kitex.WithStreamingMode(kitex.StreamingNone), ), + "BatchGetPromptBasic": kitex.NewMethodInfo( + batchGetPromptBasicHandler, + newPromptManageServiceBatchGetPromptBasicArgs, + newPromptManageServiceBatchGetPromptBasicResult, + false, + kitex.WithStreamingMode(kitex.StreamingNone), + ), "UpdatePrompt": kitex.NewMethodInfo( updatePromptHandler, newPromptManageServiceUpdatePromptArgs, @@ -291,6 +298,25 @@ func newPromptManageServiceListParentPromptResult() interface{} { return manage.NewPromptManageServiceListParentPromptResult() } +func batchGetPromptBasicHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*manage.PromptManageServiceBatchGetPromptBasicArgs) + realResult := result.(*manage.PromptManageServiceBatchGetPromptBasicResult) + success, err := handler.(manage.PromptManageService).BatchGetPromptBasic(ctx, realArg.Request) + if err != nil { + return err + } + realResult.Success = success + return nil +} + +func newPromptManageServiceBatchGetPromptBasicArgs() interface{} { + return manage.NewPromptManageServiceBatchGetPromptBasicArgs() +} + +func newPromptManageServiceBatchGetPromptBasicResult() interface{} { + return manage.NewPromptManageServiceBatchGetPromptBasicResult() +} + func updatePromptHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { realArg := arg.(*manage.PromptManageServiceUpdatePromptArgs) realResult := result.(*manage.PromptManageServiceUpdatePromptResult) @@ -544,6 +570,16 @@ func (p *kClient) ListParentPrompt(ctx context.Context, request *manage.ListPare return _result.GetSuccess(), nil } +func (p *kClient) BatchGetPromptBasic(ctx context.Context, request *manage.BatchGetPromptBasicRequest) (r *manage.BatchGetPromptBasicResponse, err error) { + var _args manage.PromptManageServiceBatchGetPromptBasicArgs + _args.Request = request + var _result manage.PromptManageServiceBatchGetPromptBasicResult + if err = p.c.Call(ctx, "BatchGetPromptBasic", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} + func (p *kClient) UpdatePrompt(ctx context.Context, request *manage.UpdatePromptRequest) (r *manage.UpdatePromptResponse, err error) { var _args manage.PromptManageServiceUpdatePromptArgs _args.Request = request diff --git a/backend/kitex_gen/coze/loop/prompt/promptmanageservice/client.go b/backend/kitex_gen/coze/loop/prompt/promptmanageservice/client.go index 3e7b1c158..aaec1bad2 100644 --- a/backend/kitex_gen/coze/loop/prompt/promptmanageservice/client.go +++ b/backend/kitex_gen/coze/loop/prompt/promptmanageservice/client.go @@ -18,6 +18,7 @@ type Client interface { BatchGetPrompt(ctx context.Context, request *manage.BatchGetPromptRequest, callOptions ...callopt.Option) (r *manage.BatchGetPromptResponse, err error) ListPrompt(ctx context.Context, request *manage.ListPromptRequest, callOptions ...callopt.Option) (r *manage.ListPromptResponse, err error) ListParentPrompt(ctx context.Context, request *manage.ListParentPromptRequest, callOptions ...callopt.Option) (r *manage.ListParentPromptResponse, err error) + BatchGetPromptBasic(ctx context.Context, request *manage.BatchGetPromptBasicRequest, callOptions ...callopt.Option) (r *manage.BatchGetPromptBasicResponse, err error) UpdatePrompt(ctx context.Context, request *manage.UpdatePromptRequest, callOptions ...callopt.Option) (r *manage.UpdatePromptResponse, err error) SaveDraft(ctx context.Context, request *manage.SaveDraftRequest, callOptions ...callopt.Option) (r *manage.SaveDraftResponse, err error) CreateLabel(ctx context.Context, request *manage.CreateLabelRequest, callOptions ...callopt.Option) (r *manage.CreateLabelResponse, err error) @@ -93,6 +94,11 @@ func (p *kPromptManageServiceClient) ListParentPrompt(ctx context.Context, reque return p.kClient.ListParentPrompt(ctx, request) } +func (p *kPromptManageServiceClient) BatchGetPromptBasic(ctx context.Context, request *manage.BatchGetPromptBasicRequest, callOptions ...callopt.Option) (r *manage.BatchGetPromptBasicResponse, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.BatchGetPromptBasic(ctx, request) +} + func (p *kPromptManageServiceClient) UpdatePrompt(ctx context.Context, request *manage.UpdatePromptRequest, callOptions ...callopt.Option) (r *manage.UpdatePromptResponse, err error) { ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.UpdatePrompt(ctx, request) diff --git a/backend/kitex_gen/coze/loop/prompt/promptmanageservice/promptmanageservice.go b/backend/kitex_gen/coze/loop/prompt/promptmanageservice/promptmanageservice.go index f2c8b070e..d003d7ae1 100644 --- a/backend/kitex_gen/coze/loop/prompt/promptmanageservice/promptmanageservice.go +++ b/backend/kitex_gen/coze/loop/prompt/promptmanageservice/promptmanageservice.go @@ -63,6 +63,13 @@ var serviceMethods = map[string]kitex.MethodInfo{ false, kitex.WithStreamingMode(kitex.StreamingNone), ), + "BatchGetPromptBasic": kitex.NewMethodInfo( + batchGetPromptBasicHandler, + newPromptManageServiceBatchGetPromptBasicArgs, + newPromptManageServiceBatchGetPromptBasicResult, + false, + kitex.WithStreamingMode(kitex.StreamingNone), + ), "UpdatePrompt": kitex.NewMethodInfo( updatePromptHandler, newPromptManageServiceUpdatePromptArgs, @@ -292,6 +299,25 @@ func newPromptManageServiceListParentPromptResult() interface{} { return manage.NewPromptManageServiceListParentPromptResult() } +func batchGetPromptBasicHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*manage.PromptManageServiceBatchGetPromptBasicArgs) + realResult := result.(*manage.PromptManageServiceBatchGetPromptBasicResult) + success, err := handler.(manage.PromptManageService).BatchGetPromptBasic(ctx, realArg.Request) + if err != nil { + return err + } + realResult.Success = success + return nil +} + +func newPromptManageServiceBatchGetPromptBasicArgs() interface{} { + return manage.NewPromptManageServiceBatchGetPromptBasicArgs() +} + +func newPromptManageServiceBatchGetPromptBasicResult() interface{} { + return manage.NewPromptManageServiceBatchGetPromptBasicResult() +} + func updatePromptHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { realArg := arg.(*manage.PromptManageServiceUpdatePromptArgs) realResult := result.(*manage.PromptManageServiceUpdatePromptResult) @@ -545,6 +571,16 @@ func (p *kClient) ListParentPrompt(ctx context.Context, request *manage.ListPare return _result.GetSuccess(), nil } +func (p *kClient) BatchGetPromptBasic(ctx context.Context, request *manage.BatchGetPromptBasicRequest) (r *manage.BatchGetPromptBasicResponse, err error) { + var _args manage.PromptManageServiceBatchGetPromptBasicArgs + _args.Request = request + var _result manage.PromptManageServiceBatchGetPromptBasicResult + if err = p.c.Call(ctx, "BatchGetPromptBasic", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} + func (p *kClient) UpdatePrompt(ctx context.Context, request *manage.UpdatePromptRequest) (r *manage.UpdatePromptResponse, err error) { var _args manage.PromptManageServiceUpdatePromptArgs _args.Request = request diff --git a/backend/loop_gen/coze/loop/prompt/lomanage/local_promptmanageservice.go b/backend/loop_gen/coze/loop/prompt/lomanage/local_promptmanageservice.go index 74d233021..aabc63c89 100644 --- a/backend/loop_gen/coze/loop/prompt/lomanage/local_promptmanageservice.go +++ b/backend/loop_gen/coze/loop/prompt/lomanage/local_promptmanageservice.go @@ -178,6 +178,27 @@ func (l *LocalPromptManageService) ListParentPrompt(ctx context.Context, request return result.GetSuccess(), nil } +func (l *LocalPromptManageService) BatchGetPromptBasic(ctx context.Context, request *manage.BatchGetPromptBasicRequest, callOptions ...callopt.Option) (*manage.BatchGetPromptBasicResponse, error) { + chain := l.mds(func(ctx context.Context, in, out interface{}) error { + arg := in.(*manage.PromptManageServiceBatchGetPromptBasicArgs) + result := out.(*manage.PromptManageServiceBatchGetPromptBasicResult) + resp, err := l.impl.BatchGetPromptBasic(ctx, arg.Request) + if err != nil { + return err + } + result.SetSuccess(resp) + return nil + }) + + arg := &manage.PromptManageServiceBatchGetPromptBasicArgs{Request: request} + result := &manage.PromptManageServiceBatchGetPromptBasicResult{} + ctx = l.injectRPCInfo(ctx, "BatchGetPromptBasic") + if err := chain(ctx, arg, result); err != nil { + return nil, err + } + return result.GetSuccess(), nil +} + // UpdatePrompt // 改 func (l *LocalPromptManageService) UpdatePrompt(ctx context.Context, request *manage.UpdatePromptRequest, callOptions ...callopt.Option) (*manage.UpdatePromptResponse, error) { diff --git a/backend/modules/prompt/application/manage.go b/backend/modules/prompt/application/manage.go index 858c25216..981bb8f5f 100644 --- a/backend/modules/prompt/application/manage.go +++ b/backend/modules/prompt/application/manage.go @@ -958,3 +958,28 @@ func (app *PromptManageApplicationImpl) UpdateCommitLabels(ctx context.Context, return r, nil } + +func (app *PromptManageApplicationImpl) BatchGetPromptBasic(ctx context.Context, request *manage.BatchGetPromptBasicRequest) (r *manage.BatchGetPromptBasicResponse, err error) { + r = manage.NewBatchGetPromptBasicResponse() + // 用户 + userID, ok := session.UserIDInCtx(ctx) + if !ok || lo.IsEmpty(userID) { + return r, errorx.NewByCode(prompterr.CommonInvalidParamCode, errorx.WithExtraMsg("User not found")) + } + + // 权限检查 + err = app.authRPCProvider.MCheckPromptPermission(ctx, request.GetWorkspaceID(), request.GetPromptIds(), consts.ActionLoopPromptRead) + if err != nil { + return r, err + } + + // 调用domain层服务查询PromptBasic列表 + promptBasics, err := app.manageRepo.BatchGetPromptBasic(ctx, request.GetPromptIds()) + if err != nil { + return r, err + } + // 转换结果 + r.Prompts = convertor.BatchPromptDO2DTO(maps.Values(promptBasics)) + + return r, nil +} diff --git a/backend/modules/prompt/domain/repo/manage.go b/backend/modules/prompt/domain/repo/manage.go index 4ecf0e7a4..6454e96b8 100644 --- a/backend/modules/prompt/domain/repo/manage.go +++ b/backend/modules/prompt/domain/repo/manage.go @@ -23,6 +23,7 @@ type IManageRepo interface { CommitDraft(ctx context.Context, param CommitDraftParam) (err error) ListCommitInfo(ctx context.Context, param ListCommitInfoParam) (result *ListCommitResult, err error) MGetVersionsByPromptID(ctx context.Context, promptID int64) (versions []string, err error) + BatchGetPromptBasic(ctx context.Context, promptIDs []int64) (promptDOMap map[int64]*entity.Prompt, err error) } type GetPromptParam struct { diff --git a/backend/modules/prompt/domain/repo/mocks/manage_repo.go b/backend/modules/prompt/domain/repo/mocks/manage_repo.go index 09a65463d..02bcfe412 100644 --- a/backend/modules/prompt/domain/repo/mocks/manage_repo.go +++ b/backend/modules/prompt/domain/repo/mocks/manage_repo.go @@ -42,6 +42,21 @@ func (m *MockIManageRepo) EXPECT() *MockIManageRepoMockRecorder { return m.recorder } +// BatchGetPromptBasic mocks base method. +func (m *MockIManageRepo) BatchGetPromptBasic(ctx context.Context, promptIDs []int64) (map[int64]*entity.Prompt, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BatchGetPromptBasic", ctx, promptIDs) + ret0, _ := ret[0].(map[int64]*entity.Prompt) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BatchGetPromptBasic indicates an expected call of BatchGetPromptBasic. +func (mr *MockIManageRepoMockRecorder) BatchGetPromptBasic(ctx, promptIDs any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetPromptBasic", reflect.TypeOf((*MockIManageRepo)(nil).BatchGetPromptBasic), ctx, promptIDs) +} + // CommitDraft mocks base method. func (m *MockIManageRepo) CommitDraft(ctx context.Context, param repo.CommitDraftParam) error { m.ctrl.T.Helper() diff --git a/backend/modules/prompt/infra/repo/manage.go b/backend/modules/prompt/infra/repo/manage.go index 561ccbc3c..d741724ec 100644 --- a/backend/modules/prompt/infra/repo/manage.go +++ b/backend/modules/prompt/infra/repo/manage.go @@ -1082,3 +1082,30 @@ func (d *ManageRepoImpl) ListParentPrompt(ctx context.Context, param repo.ListPa return result, nil } + +func (d *ManageRepoImpl) BatchGetPromptBasic(ctx context.Context, promptIDs []int64) (promptDOMap map[int64]*entity.Prompt, err error) { + if len(promptIDs) == 0 { + return make(map[int64]*entity.Prompt), nil + } + promptParams := make([]repo.GetPromptParam, 0) + for _, promptID := range promptIDs { + getParam := repo.GetPromptParam{ + PromptID: promptID, + WithCommit: false, + WithDraft: false, + } + promptParams = append(promptParams, getParam) + } + promptRepoMap, err := d.MGetPrompt(ctx, promptParams) + if err != nil { + return nil, err + } + promptMap := make(map[int64]*entity.Prompt, len(promptIDs)) + for _, prompt := range promptRepoMap { + if prompt == nil { + continue + } + promptMap[prompt.ID] = prompt + } + return promptMap, nil +} diff --git a/idl/thrift/coze/loop/prompt/coze.loop.prompt.manage.thrift b/idl/thrift/coze/loop/prompt/coze.loop.prompt.manage.thrift index 9608fe966..b19e453db 100644 --- a/idl/thrift/coze/loop/prompt/coze.loop.prompt.manage.thrift +++ b/idl/thrift/coze/loop/prompt/coze.loop.prompt.manage.thrift @@ -22,6 +22,7 @@ service PromptManageService { ListPromptResponse ListPrompt(1: ListPromptRequest request) (api.post = '/api/prompt/v1/prompts/list') // 查询片段的引用记录 ListParentPromptResponse ListParentPrompt (1: ListParentPromptRequest request) (api.post = '/api/prompt/v1/prompts/list_parent') + BatchGetPromptBasicResponse BatchGetPromptBasic (1: BatchGetPromptBasicRequest request) (api.post = '/api/prompt/v1/prompts/batch_get_prompt_basic') // 改 UpdatePromptResponse UpdatePrompt(1: UpdatePromptRequest request) (api.put = '/api/prompt/v1/prompts/:prompt_id') @@ -309,5 +310,18 @@ struct ListParentPromptRequest { struct ListParentPromptResponse { 1: optional map> parent_prompts // 不同片段版本被引用的父prompt记录 + 255: optional base.BaseResp BaseResp +} + +struct BatchGetPromptBasicRequest { + 1: optional i64 workspace_id (api.js_conv='true', vt.not_nil='true', vt.gt='0', go.tag='json:"workspace_id"') + 2: optional list prompt_ids + + 255: optional base.Base Base +} + +struct BatchGetPromptBasicResponse { + 1: optional list prompts + 255: optional base.BaseResp BaseResp } \ No newline at end of file