2115 lines
96 KiB
Go
2115 lines
96 KiB
Go
/*
|
|
* Copyright 2025 coze-dev Authors
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
// Code generated by MockGen. DO NOT EDIT.
|
|
// Source: interface.go
|
|
//
|
|
// Generated by this command:
|
|
//
|
|
// mockgen -destination ../../internal/mock/domain/workflow/interface.go --package mockWorkflow -source interface.go
|
|
//
|
|
|
|
// Package mockWorkflow is a generated GoMock package.
|
|
package mockWorkflow
|
|
|
|
import (
|
|
context "context"
|
|
reflect "reflect"
|
|
|
|
model "github.com/cloudwego/eino/components/model"
|
|
compose "github.com/cloudwego/eino/compose"
|
|
schema "github.com/cloudwego/eino/schema"
|
|
workflow "github.com/coze-dev/coze-studio/backend/api/model/crossdomain/workflow"
|
|
workflow0 "github.com/coze-dev/coze-studio/backend/api/model/workflow"
|
|
workflow1 "github.com/coze-dev/coze-studio/backend/domain/workflow"
|
|
config "github.com/coze-dev/coze-studio/backend/domain/workflow/config"
|
|
entity "github.com/coze-dev/coze-studio/backend/domain/workflow/entity"
|
|
vo "github.com/coze-dev/coze-studio/backend/domain/workflow/entity/vo"
|
|
storage "github.com/coze-dev/coze-studio/backend/infra/contract/storage"
|
|
gomock "go.uber.org/mock/gomock"
|
|
)
|
|
|
|
// MockService is a mock of Service interface.
|
|
type MockService struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockServiceMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockServiceMockRecorder is the mock recorder for MockService.
|
|
type MockServiceMockRecorder struct {
|
|
mock *MockService
|
|
}
|
|
|
|
// NewMockService creates a new mock instance.
|
|
func NewMockService(ctrl *gomock.Controller) *MockService {
|
|
mock := &MockService{ctrl: ctrl}
|
|
mock.recorder = &MockServiceMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockService) EXPECT() *MockServiceMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// AsyncExecute mocks base method.
|
|
func (m *MockService) AsyncExecute(ctx context.Context, arg1 workflow.ExecuteConfig, input map[string]any) (int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AsyncExecute", ctx, arg1, input)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AsyncExecute indicates an expected call of AsyncExecute.
|
|
func (mr *MockServiceMockRecorder) AsyncExecute(ctx, arg1, input any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AsyncExecute", reflect.TypeOf((*MockService)(nil).AsyncExecute), ctx, arg1, input)
|
|
}
|
|
|
|
// AsyncExecuteNode mocks base method.
|
|
func (m *MockService) AsyncExecuteNode(ctx context.Context, nodeID string, arg2 workflow.ExecuteConfig, input map[string]any) (int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AsyncExecuteNode", ctx, nodeID, arg2, input)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AsyncExecuteNode indicates an expected call of AsyncExecuteNode.
|
|
func (mr *MockServiceMockRecorder) AsyncExecuteNode(ctx, nodeID, arg2, input any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AsyncExecuteNode", reflect.TypeOf((*MockService)(nil).AsyncExecuteNode), ctx, nodeID, arg2, input)
|
|
}
|
|
|
|
// AsyncResume mocks base method.
|
|
func (m *MockService) AsyncResume(ctx context.Context, req *entity.ResumeRequest, arg2 workflow.ExecuteConfig) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AsyncResume", ctx, req, arg2)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// AsyncResume indicates an expected call of AsyncResume.
|
|
func (mr *MockServiceMockRecorder) AsyncResume(ctx, req, arg2 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AsyncResume", reflect.TypeOf((*MockService)(nil).AsyncResume), ctx, req, arg2)
|
|
}
|
|
|
|
// BindConvRelatedInfo mocks base method.
|
|
func (m *MockService) BindConvRelatedInfo(ctx context.Context, convID int64, info entity.ConvRelatedInfo) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "BindConvRelatedInfo", ctx, convID, info)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// BindConvRelatedInfo indicates an expected call of BindConvRelatedInfo.
|
|
func (mr *MockServiceMockRecorder) BindConvRelatedInfo(ctx, convID, info any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BindConvRelatedInfo", reflect.TypeOf((*MockService)(nil).BindConvRelatedInfo), ctx, convID, info)
|
|
}
|
|
|
|
// Cancel mocks base method.
|
|
func (m *MockService) Cancel(ctx context.Context, wfExeID, wfID, spaceID int64) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Cancel", ctx, wfExeID, wfID, spaceID)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Cancel indicates an expected call of Cancel.
|
|
func (mr *MockServiceMockRecorder) Cancel(ctx, wfExeID, wfID, spaceID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cancel", reflect.TypeOf((*MockService)(nil).Cancel), ctx, wfExeID, wfID, spaceID)
|
|
}
|
|
|
|
// CheckWorkflowsToReplace mocks base method.
|
|
func (m *MockService) CheckWorkflowsToReplace(ctx context.Context, appID, templateID int64) ([]*entity.Workflow, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CheckWorkflowsToReplace", ctx, appID, templateID)
|
|
ret0, _ := ret[0].([]*entity.Workflow)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CheckWorkflowsToReplace indicates an expected call of CheckWorkflowsToReplace.
|
|
func (mr *MockServiceMockRecorder) CheckWorkflowsToReplace(ctx, appID, templateID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckWorkflowsToReplace", reflect.TypeOf((*MockService)(nil).CheckWorkflowsToReplace), ctx, appID, templateID)
|
|
}
|
|
|
|
// CopyWorkflow mocks base method.
|
|
func (m *MockService) CopyWorkflow(ctx context.Context, workflowID int64, policy vo.CopyWorkflowPolicy) (*entity.Workflow, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CopyWorkflow", ctx, workflowID, policy)
|
|
ret0, _ := ret[0].(*entity.Workflow)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CopyWorkflow indicates an expected call of CopyWorkflow.
|
|
func (mr *MockServiceMockRecorder) CopyWorkflow(ctx, workflowID, policy any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyWorkflow", reflect.TypeOf((*MockService)(nil).CopyWorkflow), ctx, workflowID, policy)
|
|
}
|
|
|
|
// CopyWorkflowFromAppToLibrary mocks base method.
|
|
func (m *MockService) CopyWorkflowFromAppToLibrary(ctx context.Context, workflowID, appID int64, related vo.ExternalResourceRelated) (*entity.CopyWorkflowFromAppToLibraryResult, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CopyWorkflowFromAppToLibrary", ctx, workflowID, appID, related)
|
|
ret0, _ := ret[0].(*entity.CopyWorkflowFromAppToLibraryResult)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CopyWorkflowFromAppToLibrary indicates an expected call of CopyWorkflowFromAppToLibrary.
|
|
func (mr *MockServiceMockRecorder) CopyWorkflowFromAppToLibrary(ctx, workflowID, appID, related any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyWorkflowFromAppToLibrary", reflect.TypeOf((*MockService)(nil).CopyWorkflowFromAppToLibrary), ctx, workflowID, appID, related)
|
|
}
|
|
|
|
// Create mocks base method.
|
|
func (m *MockService) Create(ctx context.Context, meta *vo.MetaCreate) (int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Create", ctx, meta)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Create indicates an expected call of Create.
|
|
func (mr *MockServiceMockRecorder) Create(ctx, meta any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockService)(nil).Create), ctx, meta)
|
|
}
|
|
|
|
// CreateChatFlowRole mocks base method.
|
|
func (m *MockService) CreateChatFlowRole(ctx context.Context, role *vo.ChatFlowRoleCreate) (int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CreateChatFlowRole", ctx, role)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CreateChatFlowRole indicates an expected call of CreateChatFlowRole.
|
|
func (mr *MockServiceMockRecorder) CreateChatFlowRole(ctx, role any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateChatFlowRole", reflect.TypeOf((*MockService)(nil).CreateChatFlowRole), ctx, role)
|
|
}
|
|
|
|
// CreateDraftConversationTemplate mocks base method.
|
|
func (m *MockService) CreateDraftConversationTemplate(ctx context.Context, template *vo.CreateConversationTemplateMeta) (int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CreateDraftConversationTemplate", ctx, template)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CreateDraftConversationTemplate indicates an expected call of CreateDraftConversationTemplate.
|
|
func (mr *MockServiceMockRecorder) CreateDraftConversationTemplate(ctx, template any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDraftConversationTemplate", reflect.TypeOf((*MockService)(nil).CreateDraftConversationTemplate), ctx, template)
|
|
}
|
|
|
|
// Delete mocks base method.
|
|
func (m *MockService) Delete(ctx context.Context, policy *vo.DeletePolicy) ([]int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Delete", ctx, policy)
|
|
ret0, _ := ret[0].([]int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Delete indicates an expected call of Delete.
|
|
func (mr *MockServiceMockRecorder) Delete(ctx, policy any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockService)(nil).Delete), ctx, policy)
|
|
}
|
|
|
|
// DeleteChatFlowRole mocks base method.
|
|
func (m *MockService) DeleteChatFlowRole(ctx context.Context, id, workflowID int64) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DeleteChatFlowRole", ctx, id, workflowID)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// DeleteChatFlowRole indicates an expected call of DeleteChatFlowRole.
|
|
func (mr *MockServiceMockRecorder) DeleteChatFlowRole(ctx, id, workflowID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteChatFlowRole", reflect.TypeOf((*MockService)(nil).DeleteChatFlowRole), ctx, id, workflowID)
|
|
}
|
|
|
|
// DeleteDraftConversationTemplate mocks base method.
|
|
func (m *MockService) DeleteDraftConversationTemplate(ctx context.Context, templateID int64, wfID2ConversationName map[int64]string) (int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DeleteDraftConversationTemplate", ctx, templateID, wfID2ConversationName)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// DeleteDraftConversationTemplate indicates an expected call of DeleteDraftConversationTemplate.
|
|
func (mr *MockServiceMockRecorder) DeleteDraftConversationTemplate(ctx, templateID, wfID2ConversationName any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDraftConversationTemplate", reflect.TypeOf((*MockService)(nil).DeleteDraftConversationTemplate), ctx, templateID, wfID2ConversationName)
|
|
}
|
|
|
|
// DeleteDynamicConversation mocks base method.
|
|
func (m *MockService) DeleteDynamicConversation(ctx context.Context, env vo.Env, templateID int64) (int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DeleteDynamicConversation", ctx, env, templateID)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// DeleteDynamicConversation indicates an expected call of DeleteDynamicConversation.
|
|
func (mr *MockServiceMockRecorder) DeleteDynamicConversation(ctx, env, templateID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDynamicConversation", reflect.TypeOf((*MockService)(nil).DeleteDynamicConversation), ctx, env, templateID)
|
|
}
|
|
|
|
// DuplicateWorkflowsByAppID mocks base method.
|
|
func (m *MockService) DuplicateWorkflowsByAppID(ctx context.Context, sourceAPPID, targetAppID int64, related vo.ExternalResourceRelated) ([]*entity.Workflow, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DuplicateWorkflowsByAppID", ctx, sourceAPPID, targetAppID, related)
|
|
ret0, _ := ret[0].([]*entity.Workflow)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// DuplicateWorkflowsByAppID indicates an expected call of DuplicateWorkflowsByAppID.
|
|
func (mr *MockServiceMockRecorder) DuplicateWorkflowsByAppID(ctx, sourceAPPID, targetAppID, related any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DuplicateWorkflowsByAppID", reflect.TypeOf((*MockService)(nil).DuplicateWorkflowsByAppID), ctx, sourceAPPID, targetAppID, related)
|
|
}
|
|
|
|
// Get mocks base method.
|
|
func (m *MockService) Get(ctx context.Context, policy *vo.GetPolicy) (*entity.Workflow, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Get", ctx, policy)
|
|
ret0, _ := ret[0].(*entity.Workflow)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Get indicates an expected call of Get.
|
|
func (mr *MockServiceMockRecorder) Get(ctx, policy any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockService)(nil).Get), ctx, policy)
|
|
}
|
|
|
|
// GetChatFlowRole mocks base method.
|
|
func (m *MockService) GetChatFlowRole(ctx context.Context, workflowID int64, version string) (*entity.ChatFlowRole, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetChatFlowRole", ctx, workflowID, version)
|
|
ret0, _ := ret[0].(*entity.ChatFlowRole)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetChatFlowRole indicates an expected call of GetChatFlowRole.
|
|
func (mr *MockServiceMockRecorder) GetChatFlowRole(ctx, workflowID, version any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChatFlowRole", reflect.TypeOf((*MockService)(nil).GetChatFlowRole), ctx, workflowID, version)
|
|
}
|
|
|
|
// GetConvRelatedInfo mocks base method.
|
|
func (m *MockService) GetConvRelatedInfo(ctx context.Context, convID int64) (*entity.ConvRelatedInfo, bool, func() error, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetConvRelatedInfo", ctx, convID)
|
|
ret0, _ := ret[0].(*entity.ConvRelatedInfo)
|
|
ret1, _ := ret[1].(bool)
|
|
ret2, _ := ret[2].(func() error)
|
|
ret3, _ := ret[3].(error)
|
|
return ret0, ret1, ret2, ret3
|
|
}
|
|
|
|
// GetConvRelatedInfo indicates an expected call of GetConvRelatedInfo.
|
|
func (mr *MockServiceMockRecorder) GetConvRelatedInfo(ctx, convID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConvRelatedInfo", reflect.TypeOf((*MockService)(nil).GetConvRelatedInfo), ctx, convID)
|
|
}
|
|
|
|
// GetConversationNameByID mocks base method.
|
|
func (m *MockService) GetConversationNameByID(ctx context.Context, env vo.Env, appID, connectorID, conversationID int64) (string, bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetConversationNameByID", ctx, env, appID, connectorID, conversationID)
|
|
ret0, _ := ret[0].(string)
|
|
ret1, _ := ret[1].(bool)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// GetConversationNameByID indicates an expected call of GetConversationNameByID.
|
|
func (mr *MockServiceMockRecorder) GetConversationNameByID(ctx, env, appID, connectorID, conversationID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConversationNameByID", reflect.TypeOf((*MockService)(nil).GetConversationNameByID), ctx, env, appID, connectorID, conversationID)
|
|
}
|
|
|
|
// GetDynamicConversationByName mocks base method.
|
|
func (m *MockService) GetDynamicConversationByName(ctx context.Context, env vo.Env, appID, connectorID, userID int64, name string) (*entity.DynamicConversation, bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetDynamicConversationByName", ctx, env, appID, connectorID, userID, name)
|
|
ret0, _ := ret[0].(*entity.DynamicConversation)
|
|
ret1, _ := ret[1].(bool)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// GetDynamicConversationByName indicates an expected call of GetDynamicConversationByName.
|
|
func (mr *MockServiceMockRecorder) GetDynamicConversationByName(ctx, env, appID, connectorID, userID, name any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDynamicConversationByName", reflect.TypeOf((*MockService)(nil).GetDynamicConversationByName), ctx, env, appID, connectorID, userID, name)
|
|
}
|
|
|
|
// GetExecution mocks base method.
|
|
func (m *MockService) GetExecution(ctx context.Context, wfExe *entity.WorkflowExecution, includeNodes bool) (*entity.WorkflowExecution, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetExecution", ctx, wfExe, includeNodes)
|
|
ret0, _ := ret[0].(*entity.WorkflowExecution)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetExecution indicates an expected call of GetExecution.
|
|
func (mr *MockServiceMockRecorder) GetExecution(ctx, wfExe, includeNodes any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExecution", reflect.TypeOf((*MockService)(nil).GetExecution), ctx, wfExe, includeNodes)
|
|
}
|
|
|
|
// GetLatestNodeDebugInput mocks base method.
|
|
func (m *MockService) GetLatestNodeDebugInput(ctx context.Context, wfID int64, nodeID string, userID int64) (*entity.NodeExecution, *entity.NodeExecution, bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetLatestNodeDebugInput", ctx, wfID, nodeID, userID)
|
|
ret0, _ := ret[0].(*entity.NodeExecution)
|
|
ret1, _ := ret[1].(*entity.NodeExecution)
|
|
ret2, _ := ret[2].(bool)
|
|
ret3, _ := ret[3].(error)
|
|
return ret0, ret1, ret2, ret3
|
|
}
|
|
|
|
// GetLatestNodeDebugInput indicates an expected call of GetLatestNodeDebugInput.
|
|
func (mr *MockServiceMockRecorder) GetLatestNodeDebugInput(ctx, wfID, nodeID, userID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestNodeDebugInput", reflect.TypeOf((*MockService)(nil).GetLatestNodeDebugInput), ctx, wfID, nodeID, userID)
|
|
}
|
|
|
|
// GetLatestTestRunInput mocks base method.
|
|
func (m *MockService) GetLatestTestRunInput(ctx context.Context, wfID, userID int64) (*entity.NodeExecution, bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetLatestTestRunInput", ctx, wfID, userID)
|
|
ret0, _ := ret[0].(*entity.NodeExecution)
|
|
ret1, _ := ret[1].(bool)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// GetLatestTestRunInput indicates an expected call of GetLatestTestRunInput.
|
|
func (mr *MockServiceMockRecorder) GetLatestTestRunInput(ctx, wfID, userID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestTestRunInput", reflect.TypeOf((*MockService)(nil).GetLatestTestRunInput), ctx, wfID, userID)
|
|
}
|
|
|
|
// GetNodeExecution mocks base method.
|
|
func (m *MockService) GetNodeExecution(ctx context.Context, exeID int64, nodeID string) (*entity.NodeExecution, *entity.NodeExecution, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetNodeExecution", ctx, exeID, nodeID)
|
|
ret0, _ := ret[0].(*entity.NodeExecution)
|
|
ret1, _ := ret[1].(*entity.NodeExecution)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// GetNodeExecution indicates an expected call of GetNodeExecution.
|
|
func (mr *MockServiceMockRecorder) GetNodeExecution(ctx, exeID, nodeID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeExecution", reflect.TypeOf((*MockService)(nil).GetNodeExecution), ctx, exeID, nodeID)
|
|
}
|
|
|
|
// GetOrCreateConversation mocks base method.
|
|
func (m *MockService) GetOrCreateConversation(ctx context.Context, env vo.Env, appID, connectorID, userID int64, conversationName string) (int64, int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetOrCreateConversation", ctx, env, appID, connectorID, userID, conversationName)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(int64)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// GetOrCreateConversation indicates an expected call of GetOrCreateConversation.
|
|
func (mr *MockServiceMockRecorder) GetOrCreateConversation(ctx, env, appID, connectorID, userID, conversationName any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrCreateConversation", reflect.TypeOf((*MockService)(nil).GetOrCreateConversation), ctx, env, appID, connectorID, userID, conversationName)
|
|
}
|
|
|
|
// GetTemplateByName mocks base method.
|
|
func (m *MockService) GetTemplateByName(ctx context.Context, env vo.Env, appID int64, templateName string) (*entity.ConversationTemplate, bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetTemplateByName", ctx, env, appID, templateName)
|
|
ret0, _ := ret[0].(*entity.ConversationTemplate)
|
|
ret1, _ := ret[1].(bool)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// GetTemplateByName indicates an expected call of GetTemplateByName.
|
|
func (mr *MockServiceMockRecorder) GetTemplateByName(ctx, env, appID, templateName any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplateByName", reflect.TypeOf((*MockService)(nil).GetTemplateByName), ctx, env, appID, templateName)
|
|
}
|
|
|
|
// GetWorkflowDependenceResource mocks base method.
|
|
func (m *MockService) GetWorkflowDependenceResource(ctx context.Context, workflowID int64) (*vo.DependenceResource, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetWorkflowDependenceResource", ctx, workflowID)
|
|
ret0, _ := ret[0].(*vo.DependenceResource)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetWorkflowDependenceResource indicates an expected call of GetWorkflowDependenceResource.
|
|
func (mr *MockServiceMockRecorder) GetWorkflowDependenceResource(ctx, workflowID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowDependenceResource", reflect.TypeOf((*MockService)(nil).GetWorkflowDependenceResource), ctx, workflowID)
|
|
}
|
|
|
|
// GetWorkflowReference mocks base method.
|
|
func (m *MockService) GetWorkflowReference(ctx context.Context, id int64) (map[int64]*vo.Meta, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetWorkflowReference", ctx, id)
|
|
ret0, _ := ret[0].(map[int64]*vo.Meta)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetWorkflowReference indicates an expected call of GetWorkflowReference.
|
|
func (mr *MockServiceMockRecorder) GetWorkflowReference(ctx, id any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowReference", reflect.TypeOf((*MockService)(nil).GetWorkflowReference), ctx, id)
|
|
}
|
|
|
|
// GetWorkflowVersionsByConnector mocks base method.
|
|
func (m *MockService) GetWorkflowVersionsByConnector(ctx context.Context, connectorID, workflowID int64, limit int) ([]string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetWorkflowVersionsByConnector", ctx, connectorID, workflowID, limit)
|
|
ret0, _ := ret[0].([]string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetWorkflowVersionsByConnector indicates an expected call of GetWorkflowVersionsByConnector.
|
|
func (mr *MockServiceMockRecorder) GetWorkflowVersionsByConnector(ctx, connectorID, workflowID, limit any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowVersionsByConnector", reflect.TypeOf((*MockService)(nil).GetWorkflowVersionsByConnector), ctx, connectorID, workflowID, limit)
|
|
}
|
|
|
|
// InitApplicationDefaultConversationTemplate mocks base method.
|
|
func (m *MockService) InitApplicationDefaultConversationTemplate(ctx context.Context, spaceID, appID, userID int64) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "InitApplicationDefaultConversationTemplate", ctx, spaceID, appID, userID)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// InitApplicationDefaultConversationTemplate indicates an expected call of InitApplicationDefaultConversationTemplate.
|
|
func (mr *MockServiceMockRecorder) InitApplicationDefaultConversationTemplate(ctx, spaceID, appID, userID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitApplicationDefaultConversationTemplate", reflect.TypeOf((*MockService)(nil).InitApplicationDefaultConversationTemplate), ctx, spaceID, appID, userID)
|
|
}
|
|
|
|
// ListConversationTemplate mocks base method.
|
|
func (m *MockService) ListConversationTemplate(ctx context.Context, env vo.Env, policy *vo.ListConversationTemplatePolicy) ([]*entity.ConversationTemplate, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ListConversationTemplate", ctx, env, policy)
|
|
ret0, _ := ret[0].([]*entity.ConversationTemplate)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ListConversationTemplate indicates an expected call of ListConversationTemplate.
|
|
func (mr *MockServiceMockRecorder) ListConversationTemplate(ctx, env, policy any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListConversationTemplate", reflect.TypeOf((*MockService)(nil).ListConversationTemplate), ctx, env, policy)
|
|
}
|
|
|
|
// ListDynamicConversation mocks base method.
|
|
func (m *MockService) ListDynamicConversation(ctx context.Context, env vo.Env, policy *vo.ListConversationPolicy) ([]*entity.DynamicConversation, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ListDynamicConversation", ctx, env, policy)
|
|
ret0, _ := ret[0].([]*entity.DynamicConversation)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ListDynamicConversation indicates an expected call of ListDynamicConversation.
|
|
func (mr *MockServiceMockRecorder) ListDynamicConversation(ctx, env, policy any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDynamicConversation", reflect.TypeOf((*MockService)(nil).ListDynamicConversation), ctx, env, policy)
|
|
}
|
|
|
|
// ListNodeMeta mocks base method.
|
|
func (m *MockService) ListNodeMeta(ctx context.Context, nodeTypes map[entity.NodeType]bool) (map[string][]*entity.NodeTypeMeta, []entity.Category, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ListNodeMeta", ctx, nodeTypes)
|
|
ret0, _ := ret[0].(map[string][]*entity.NodeTypeMeta)
|
|
ret1, _ := ret[1].([]entity.Category)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// ListNodeMeta indicates an expected call of ListNodeMeta.
|
|
func (mr *MockServiceMockRecorder) ListNodeMeta(ctx, nodeTypes any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNodeMeta", reflect.TypeOf((*MockService)(nil).ListNodeMeta), ctx, nodeTypes)
|
|
}
|
|
|
|
// MGet mocks base method.
|
|
func (m *MockService) MGet(ctx context.Context, policy *vo.MGetPolicy) ([]*entity.Workflow, int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "MGet", ctx, policy)
|
|
ret0, _ := ret[0].([]*entity.Workflow)
|
|
ret1, _ := ret[1].(int64)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// MGet indicates an expected call of MGet.
|
|
func (mr *MockServiceMockRecorder) MGet(ctx, policy any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGet", reflect.TypeOf((*MockService)(nil).MGet), ctx, policy)
|
|
}
|
|
|
|
// MGetStaticConversation mocks base method.
|
|
func (m *MockService) MGetStaticConversation(ctx context.Context, env vo.Env, userID, connectorID int64, templateIDs []int64) ([]*entity.StaticConversation, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "MGetStaticConversation", ctx, env, userID, connectorID, templateIDs)
|
|
ret0, _ := ret[0].([]*entity.StaticConversation)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// MGetStaticConversation indicates an expected call of MGetStaticConversation.
|
|
func (mr *MockServiceMockRecorder) MGetStaticConversation(ctx, env, userID, connectorID, templateIDs any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetStaticConversation", reflect.TypeOf((*MockService)(nil).MGetStaticConversation), ctx, env, userID, connectorID, templateIDs)
|
|
}
|
|
|
|
// Publish mocks base method.
|
|
func (m *MockService) Publish(ctx context.Context, policy *vo.PublishPolicy) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Publish", ctx, policy)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Publish indicates an expected call of Publish.
|
|
func (mr *MockServiceMockRecorder) Publish(ctx, policy any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Publish", reflect.TypeOf((*MockService)(nil).Publish), ctx, policy)
|
|
}
|
|
|
|
// PublishChatFlowRole mocks base method.
|
|
func (m *MockService) PublishChatFlowRole(ctx context.Context, policy *vo.PublishRolePolicy) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "PublishChatFlowRole", ctx, policy)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// PublishChatFlowRole indicates an expected call of PublishChatFlowRole.
|
|
func (mr *MockServiceMockRecorder) PublishChatFlowRole(ctx, policy any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishChatFlowRole", reflect.TypeOf((*MockService)(nil).PublishChatFlowRole), ctx, policy)
|
|
}
|
|
|
|
// QueryNodeProperties mocks base method.
|
|
func (m *MockService) QueryNodeProperties(ctx context.Context, id int64) (map[string]*vo.NodeProperty, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "QueryNodeProperties", ctx, id)
|
|
ret0, _ := ret[0].(map[string]*vo.NodeProperty)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// QueryNodeProperties indicates an expected call of QueryNodeProperties.
|
|
func (mr *MockServiceMockRecorder) QueryNodeProperties(ctx, id any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryNodeProperties", reflect.TypeOf((*MockService)(nil).QueryNodeProperties), ctx, id)
|
|
}
|
|
|
|
// ReleaseApplicationWorkflows mocks base method.
|
|
func (m *MockService) ReleaseApplicationWorkflows(ctx context.Context, appID int64, arg2 *vo.ReleaseWorkflowConfig) ([]*vo.ValidateIssue, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ReleaseApplicationWorkflows", ctx, appID, arg2)
|
|
ret0, _ := ret[0].([]*vo.ValidateIssue)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ReleaseApplicationWorkflows indicates an expected call of ReleaseApplicationWorkflows.
|
|
func (mr *MockServiceMockRecorder) ReleaseApplicationWorkflows(ctx, appID, arg2 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseApplicationWorkflows", reflect.TypeOf((*MockService)(nil).ReleaseApplicationWorkflows), ctx, appID, arg2)
|
|
}
|
|
|
|
// ReleaseConversationTemplate mocks base method.
|
|
func (m *MockService) ReleaseConversationTemplate(ctx context.Context, appID int64, version string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ReleaseConversationTemplate", ctx, appID, version)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ReleaseConversationTemplate indicates an expected call of ReleaseConversationTemplate.
|
|
func (mr *MockServiceMockRecorder) ReleaseConversationTemplate(ctx, appID, version any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseConversationTemplate", reflect.TypeOf((*MockService)(nil).ReleaseConversationTemplate), ctx, appID, version)
|
|
}
|
|
|
|
// Save mocks base method.
|
|
func (m *MockService) Save(ctx context.Context, id int64, arg2 string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Save", ctx, id, arg2)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Save indicates an expected call of Save.
|
|
func (mr *MockServiceMockRecorder) Save(ctx, id, arg2 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockService)(nil).Save), ctx, id, arg2)
|
|
}
|
|
|
|
// StreamExecute mocks base method.
|
|
func (m *MockService) StreamExecute(ctx context.Context, arg1 workflow.ExecuteConfig, input map[string]any) (*schema.StreamReader[*entity.Message], error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "StreamExecute", ctx, arg1, input)
|
|
ret0, _ := ret[0].(*schema.StreamReader[*entity.Message])
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// StreamExecute indicates an expected call of StreamExecute.
|
|
func (mr *MockServiceMockRecorder) StreamExecute(ctx, arg1, input any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamExecute", reflect.TypeOf((*MockService)(nil).StreamExecute), ctx, arg1, input)
|
|
}
|
|
|
|
// StreamResume mocks base method.
|
|
func (m *MockService) StreamResume(ctx context.Context, req *entity.ResumeRequest, arg2 workflow.ExecuteConfig) (*schema.StreamReader[*entity.Message], error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "StreamResume", ctx, req, arg2)
|
|
ret0, _ := ret[0].(*schema.StreamReader[*entity.Message])
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// StreamResume indicates an expected call of StreamResume.
|
|
func (mr *MockServiceMockRecorder) StreamResume(ctx, req, arg2 any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamResume", reflect.TypeOf((*MockService)(nil).StreamResume), ctx, req, arg2)
|
|
}
|
|
|
|
// Suggest mocks base method.
|
|
func (m *MockService) Suggest(ctx context.Context, input *vo.SuggestInfo) ([]string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Suggest", ctx, input)
|
|
ret0, _ := ret[0].([]string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Suggest indicates an expected call of Suggest.
|
|
func (mr *MockServiceMockRecorder) Suggest(ctx, input any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Suggest", reflect.TypeOf((*MockService)(nil).Suggest), ctx, input)
|
|
}
|
|
|
|
// SyncExecute mocks base method.
|
|
func (m *MockService) SyncExecute(ctx context.Context, arg1 workflow.ExecuteConfig, input map[string]any) (*entity.WorkflowExecution, vo.TerminatePlan, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SyncExecute", ctx, arg1, input)
|
|
ret0, _ := ret[0].(*entity.WorkflowExecution)
|
|
ret1, _ := ret[1].(vo.TerminatePlan)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// SyncExecute indicates an expected call of SyncExecute.
|
|
func (mr *MockServiceMockRecorder) SyncExecute(ctx, arg1, input any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncExecute", reflect.TypeOf((*MockService)(nil).SyncExecute), ctx, arg1, input)
|
|
}
|
|
|
|
// SyncRelatedWorkflowResources mocks base method.
|
|
func (m *MockService) SyncRelatedWorkflowResources(ctx context.Context, appID int64, relatedWorkflows map[int64]entity.IDVersionPair, related vo.ExternalResourceRelated) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SyncRelatedWorkflowResources", ctx, appID, relatedWorkflows, related)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SyncRelatedWorkflowResources indicates an expected call of SyncRelatedWorkflowResources.
|
|
func (mr *MockServiceMockRecorder) SyncRelatedWorkflowResources(ctx, appID, relatedWorkflows, related any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncRelatedWorkflowResources", reflect.TypeOf((*MockService)(nil).SyncRelatedWorkflowResources), ctx, appID, relatedWorkflows, related)
|
|
}
|
|
|
|
// UpdateChatFlowRole mocks base method.
|
|
func (m *MockService) UpdateChatFlowRole(ctx context.Context, workflowID int64, role *vo.ChatFlowRoleUpdate) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateChatFlowRole", ctx, workflowID, role)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateChatFlowRole indicates an expected call of UpdateChatFlowRole.
|
|
func (mr *MockServiceMockRecorder) UpdateChatFlowRole(ctx, workflowID, role any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChatFlowRole", reflect.TypeOf((*MockService)(nil).UpdateChatFlowRole), ctx, workflowID, role)
|
|
}
|
|
|
|
// UpdateConversation mocks base method.
|
|
func (m *MockService) UpdateConversation(ctx context.Context, env vo.Env, appID, connectorID, userID int64, conversationName string) (int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateConversation", ctx, env, appID, connectorID, userID, conversationName)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// UpdateConversation indicates an expected call of UpdateConversation.
|
|
func (mr *MockServiceMockRecorder) UpdateConversation(ctx, env, appID, connectorID, userID, conversationName any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateConversation", reflect.TypeOf((*MockService)(nil).UpdateConversation), ctx, env, appID, connectorID, userID, conversationName)
|
|
}
|
|
|
|
// UpdateDraftConversationTemplateName mocks base method.
|
|
func (m *MockService) UpdateDraftConversationTemplateName(ctx context.Context, appID, userID, templateID int64, name string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateDraftConversationTemplateName", ctx, appID, userID, templateID, name)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateDraftConversationTemplateName indicates an expected call of UpdateDraftConversationTemplateName.
|
|
func (mr *MockServiceMockRecorder) UpdateDraftConversationTemplateName(ctx, appID, userID, templateID, name any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDraftConversationTemplateName", reflect.TypeOf((*MockService)(nil).UpdateDraftConversationTemplateName), ctx, appID, userID, templateID, name)
|
|
}
|
|
|
|
// UpdateMeta mocks base method.
|
|
func (m *MockService) UpdateMeta(ctx context.Context, id int64, metaUpdate *vo.MetaUpdate) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateMeta", ctx, id, metaUpdate)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateMeta indicates an expected call of UpdateMeta.
|
|
func (mr *MockServiceMockRecorder) UpdateMeta(ctx, id, metaUpdate any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMeta", reflect.TypeOf((*MockService)(nil).UpdateMeta), ctx, id, metaUpdate)
|
|
}
|
|
|
|
// ValidateTree mocks base method.
|
|
func (m *MockService) ValidateTree(ctx context.Context, id int64, validateConfig vo.ValidateTreeConfig) ([]*workflow0.ValidateTreeInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ValidateTree", ctx, id, validateConfig)
|
|
ret0, _ := ret[0].([]*workflow0.ValidateTreeInfo)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ValidateTree indicates an expected call of ValidateTree.
|
|
func (mr *MockServiceMockRecorder) ValidateTree(ctx, id, validateConfig any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateTree", reflect.TypeOf((*MockService)(nil).ValidateTree), ctx, id, validateConfig)
|
|
}
|
|
|
|
// WithExecuteConfig mocks base method.
|
|
func (m *MockService) WithExecuteConfig(cfg workflow.ExecuteConfig) compose.Option {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "WithExecuteConfig", cfg)
|
|
ret0, _ := ret[0].(compose.Option)
|
|
return ret0
|
|
}
|
|
|
|
// WithExecuteConfig indicates an expected call of WithExecuteConfig.
|
|
func (mr *MockServiceMockRecorder) WithExecuteConfig(cfg any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithExecuteConfig", reflect.TypeOf((*MockService)(nil).WithExecuteConfig), cfg)
|
|
}
|
|
|
|
// WithMessagePipe mocks base method.
|
|
func (m *MockService) WithMessagePipe() (compose.Option, *schema.StreamReader[*entity.Message], func()) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "WithMessagePipe")
|
|
ret0, _ := ret[0].(compose.Option)
|
|
ret1, _ := ret[1].(*schema.StreamReader[*entity.Message])
|
|
ret2, _ := ret[2].(func())
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// WithMessagePipe indicates an expected call of WithMessagePipe.
|
|
func (mr *MockServiceMockRecorder) WithMessagePipe() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithMessagePipe", reflect.TypeOf((*MockService)(nil).WithMessagePipe))
|
|
}
|
|
|
|
// WithResumeToolWorkflow mocks base method.
|
|
func (m *MockService) WithResumeToolWorkflow(resumingEvent *entity.ToolInterruptEvent, resumeData string, allInterruptEvents map[string]*entity.ToolInterruptEvent) compose.Option {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "WithResumeToolWorkflow", resumingEvent, resumeData, allInterruptEvents)
|
|
ret0, _ := ret[0].(compose.Option)
|
|
return ret0
|
|
}
|
|
|
|
// WithResumeToolWorkflow indicates an expected call of WithResumeToolWorkflow.
|
|
func (mr *MockServiceMockRecorder) WithResumeToolWorkflow(resumingEvent, resumeData, allInterruptEvents any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithResumeToolWorkflow", reflect.TypeOf((*MockService)(nil).WithResumeToolWorkflow), resumingEvent, resumeData, allInterruptEvents)
|
|
}
|
|
|
|
// WorkflowAsModelTool mocks base method.
|
|
func (m *MockService) WorkflowAsModelTool(ctx context.Context, policies []*vo.GetPolicy) ([]workflow1.ToolFromWorkflow, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "WorkflowAsModelTool", ctx, policies)
|
|
ret0, _ := ret[0].([]workflow1.ToolFromWorkflow)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// WorkflowAsModelTool indicates an expected call of WorkflowAsModelTool.
|
|
func (mr *MockServiceMockRecorder) WorkflowAsModelTool(ctx, policies any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WorkflowAsModelTool", reflect.TypeOf((*MockService)(nil).WorkflowAsModelTool), ctx, policies)
|
|
}
|
|
|
|
// WorkflowSchemaCheck mocks base method.
|
|
func (m *MockService) WorkflowSchemaCheck(ctx context.Context, wf *entity.Workflow, checks []workflow0.CheckType) ([]*workflow0.CheckResult, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "WorkflowSchemaCheck", ctx, wf, checks)
|
|
ret0, _ := ret[0].([]*workflow0.CheckResult)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// WorkflowSchemaCheck indicates an expected call of WorkflowSchemaCheck.
|
|
func (mr *MockServiceMockRecorder) WorkflowSchemaCheck(ctx, wf, checks any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WorkflowSchemaCheck", reflect.TypeOf((*MockService)(nil).WorkflowSchemaCheck), ctx, wf, checks)
|
|
}
|
|
|
|
// MockRepository is a mock of Repository interface.
|
|
type MockRepository struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockRepositoryMockRecorder
|
|
isgomock struct{}
|
|
}
|
|
|
|
// MockRepositoryMockRecorder is the mock recorder for MockRepository.
|
|
type MockRepositoryMockRecorder struct {
|
|
mock *MockRepository
|
|
}
|
|
|
|
// NewMockRepository creates a new mock instance.
|
|
func NewMockRepository(ctrl *gomock.Controller) *MockRepository {
|
|
mock := &MockRepository{ctrl: ctrl}
|
|
mock.recorder = &MockRepositoryMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockRepository) EXPECT() *MockRepositoryMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// BatchCreateConnectorWorkflowVersion mocks base method.
|
|
func (m *MockRepository) BatchCreateConnectorWorkflowVersion(ctx context.Context, appID, connectorID int64, workflowIDs []int64, version string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "BatchCreateConnectorWorkflowVersion", ctx, appID, connectorID, workflowIDs, version)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// BatchCreateConnectorWorkflowVersion indicates an expected call of BatchCreateConnectorWorkflowVersion.
|
|
func (mr *MockRepositoryMockRecorder) BatchCreateConnectorWorkflowVersion(ctx, appID, connectorID, workflowIDs, version any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCreateConnectorWorkflowVersion", reflect.TypeOf((*MockRepository)(nil).BatchCreateConnectorWorkflowVersion), ctx, appID, connectorID, workflowIDs, version)
|
|
}
|
|
|
|
// BatchCreateOnlineConversationTemplate mocks base method.
|
|
func (m *MockRepository) BatchCreateOnlineConversationTemplate(ctx context.Context, templates []*entity.ConversationTemplate, version string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "BatchCreateOnlineConversationTemplate", ctx, templates, version)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// BatchCreateOnlineConversationTemplate indicates an expected call of BatchCreateOnlineConversationTemplate.
|
|
func (mr *MockRepositoryMockRecorder) BatchCreateOnlineConversationTemplate(ctx, templates, version any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCreateOnlineConversationTemplate", reflect.TypeOf((*MockRepository)(nil).BatchCreateOnlineConversationTemplate), ctx, templates, version)
|
|
}
|
|
|
|
// BindConvRelatedInfo mocks base method.
|
|
func (m *MockRepository) BindConvRelatedInfo(ctx context.Context, convID int64, info entity.ConvRelatedInfo) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "BindConvRelatedInfo", ctx, convID, info)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// BindConvRelatedInfo indicates an expected call of BindConvRelatedInfo.
|
|
func (mr *MockRepositoryMockRecorder) BindConvRelatedInfo(ctx, convID, info any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BindConvRelatedInfo", reflect.TypeOf((*MockRepository)(nil).BindConvRelatedInfo), ctx, convID, info)
|
|
}
|
|
|
|
// CancelAllRunningNodes mocks base method.
|
|
func (m *MockRepository) CancelAllRunningNodes(ctx context.Context, wfExeID int64) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CancelAllRunningNodes", ctx, wfExeID)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// CancelAllRunningNodes indicates an expected call of CancelAllRunningNodes.
|
|
func (mr *MockRepositoryMockRecorder) CancelAllRunningNodes(ctx, wfExeID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelAllRunningNodes", reflect.TypeOf((*MockRepository)(nil).CancelAllRunningNodes), ctx, wfExeID)
|
|
}
|
|
|
|
// CopyTemplateConversationByAppID mocks base method.
|
|
func (m *MockRepository) CopyTemplateConversationByAppID(ctx context.Context, appID, toAppID int64) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CopyTemplateConversationByAppID", ctx, appID, toAppID)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// CopyTemplateConversationByAppID indicates an expected call of CopyTemplateConversationByAppID.
|
|
func (mr *MockRepositoryMockRecorder) CopyTemplateConversationByAppID(ctx, appID, toAppID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyTemplateConversationByAppID", reflect.TypeOf((*MockRepository)(nil).CopyTemplateConversationByAppID), ctx, appID, toAppID)
|
|
}
|
|
|
|
// CopyWorkflow mocks base method.
|
|
func (m *MockRepository) CopyWorkflow(ctx context.Context, workflowID int64, policy vo.CopyWorkflowPolicy) (*entity.Workflow, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CopyWorkflow", ctx, workflowID, policy)
|
|
ret0, _ := ret[0].(*entity.Workflow)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CopyWorkflow indicates an expected call of CopyWorkflow.
|
|
func (mr *MockRepositoryMockRecorder) CopyWorkflow(ctx, workflowID, policy any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyWorkflow", reflect.TypeOf((*MockRepository)(nil).CopyWorkflow), ctx, workflowID, policy)
|
|
}
|
|
|
|
// CreateChatFlowRoleConfig mocks base method.
|
|
func (m *MockRepository) CreateChatFlowRoleConfig(ctx context.Context, chatFlowRole *entity.ChatFlowRole) (int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CreateChatFlowRoleConfig", ctx, chatFlowRole)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CreateChatFlowRoleConfig indicates an expected call of CreateChatFlowRoleConfig.
|
|
func (mr *MockRepositoryMockRecorder) CreateChatFlowRoleConfig(ctx, chatFlowRole any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateChatFlowRoleConfig", reflect.TypeOf((*MockRepository)(nil).CreateChatFlowRoleConfig), ctx, chatFlowRole)
|
|
}
|
|
|
|
// CreateDraftConversationTemplate mocks base method.
|
|
func (m *MockRepository) CreateDraftConversationTemplate(ctx context.Context, template *vo.CreateConversationTemplateMeta) (int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CreateDraftConversationTemplate", ctx, template)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CreateDraftConversationTemplate indicates an expected call of CreateDraftConversationTemplate.
|
|
func (mr *MockRepositoryMockRecorder) CreateDraftConversationTemplate(ctx, template any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDraftConversationTemplate", reflect.TypeOf((*MockRepository)(nil).CreateDraftConversationTemplate), ctx, template)
|
|
}
|
|
|
|
// CreateMeta mocks base method.
|
|
func (m *MockRepository) CreateMeta(ctx context.Context, meta *vo.Meta) (int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CreateMeta", ctx, meta)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CreateMeta indicates an expected call of CreateMeta.
|
|
func (mr *MockRepositoryMockRecorder) CreateMeta(ctx, meta any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMeta", reflect.TypeOf((*MockRepository)(nil).CreateMeta), ctx, meta)
|
|
}
|
|
|
|
// CreateNodeExecution mocks base method.
|
|
func (m *MockRepository) CreateNodeExecution(ctx context.Context, execution *entity.NodeExecution) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CreateNodeExecution", ctx, execution)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// CreateNodeExecution indicates an expected call of CreateNodeExecution.
|
|
func (mr *MockRepositoryMockRecorder) CreateNodeExecution(ctx, execution any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNodeExecution", reflect.TypeOf((*MockRepository)(nil).CreateNodeExecution), ctx, execution)
|
|
}
|
|
|
|
// CreateOrUpdateDraft mocks base method.
|
|
func (m *MockRepository) CreateOrUpdateDraft(ctx context.Context, id int64, draft *vo.DraftInfo) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CreateOrUpdateDraft", ctx, id, draft)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// CreateOrUpdateDraft indicates an expected call of CreateOrUpdateDraft.
|
|
func (mr *MockRepositoryMockRecorder) CreateOrUpdateDraft(ctx, id, draft any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateDraft", reflect.TypeOf((*MockRepository)(nil).CreateOrUpdateDraft), ctx, id, draft)
|
|
}
|
|
|
|
// CreateSnapshotIfNeeded mocks base method.
|
|
func (m *MockRepository) CreateSnapshotIfNeeded(ctx context.Context, id int64, commitID string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CreateSnapshotIfNeeded", ctx, id, commitID)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// CreateSnapshotIfNeeded indicates an expected call of CreateSnapshotIfNeeded.
|
|
func (mr *MockRepositoryMockRecorder) CreateSnapshotIfNeeded(ctx, id, commitID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshotIfNeeded", reflect.TypeOf((*MockRepository)(nil).CreateSnapshotIfNeeded), ctx, id, commitID)
|
|
}
|
|
|
|
// CreateVersion mocks base method.
|
|
func (m *MockRepository) CreateVersion(ctx context.Context, id int64, info *vo.VersionInfo, newRefs map[entity.WorkflowReferenceKey]struct{}) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CreateVersion", ctx, id, info, newRefs)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// CreateVersion indicates an expected call of CreateVersion.
|
|
func (mr *MockRepositoryMockRecorder) CreateVersion(ctx, id, info, newRefs any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVersion", reflect.TypeOf((*MockRepository)(nil).CreateVersion), ctx, id, info, newRefs)
|
|
}
|
|
|
|
// CreateWorkflowExecution mocks base method.
|
|
func (m *MockRepository) CreateWorkflowExecution(ctx context.Context, execution *entity.WorkflowExecution) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CreateWorkflowExecution", ctx, execution)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// CreateWorkflowExecution indicates an expected call of CreateWorkflowExecution.
|
|
func (mr *MockRepositoryMockRecorder) CreateWorkflowExecution(ctx, execution any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateWorkflowExecution", reflect.TypeOf((*MockRepository)(nil).CreateWorkflowExecution), ctx, execution)
|
|
}
|
|
|
|
// Delete mocks base method.
|
|
func (m *MockRepository) Delete(ctx context.Context, id int64) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Delete", ctx, id)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Delete indicates an expected call of Delete.
|
|
func (mr *MockRepositoryMockRecorder) Delete(ctx, id any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockRepository)(nil).Delete), ctx, id)
|
|
}
|
|
|
|
// DeleteChatFlowRoleConfig mocks base method.
|
|
func (m *MockRepository) DeleteChatFlowRoleConfig(ctx context.Context, id, workflowID int64) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DeleteChatFlowRoleConfig", ctx, id, workflowID)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// DeleteChatFlowRoleConfig indicates an expected call of DeleteChatFlowRoleConfig.
|
|
func (mr *MockRepositoryMockRecorder) DeleteChatFlowRoleConfig(ctx, id, workflowID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteChatFlowRoleConfig", reflect.TypeOf((*MockRepository)(nil).DeleteChatFlowRoleConfig), ctx, id, workflowID)
|
|
}
|
|
|
|
// DeleteDraftConversationTemplate mocks base method.
|
|
func (m *MockRepository) DeleteDraftConversationTemplate(ctx context.Context, templateID int64) (int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DeleteDraftConversationTemplate", ctx, templateID)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// DeleteDraftConversationTemplate indicates an expected call of DeleteDraftConversationTemplate.
|
|
func (mr *MockRepositoryMockRecorder) DeleteDraftConversationTemplate(ctx, templateID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDraftConversationTemplate", reflect.TypeOf((*MockRepository)(nil).DeleteDraftConversationTemplate), ctx, templateID)
|
|
}
|
|
|
|
// DeleteDynamicConversation mocks base method.
|
|
func (m *MockRepository) DeleteDynamicConversation(ctx context.Context, env vo.Env, id int64) (int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DeleteDynamicConversation", ctx, env, id)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// DeleteDynamicConversation indicates an expected call of DeleteDynamicConversation.
|
|
func (mr *MockRepositoryMockRecorder) DeleteDynamicConversation(ctx, env, id any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDynamicConversation", reflect.TypeOf((*MockRepository)(nil).DeleteDynamicConversation), ctx, env, id)
|
|
}
|
|
|
|
// DraftV2 mocks base method.
|
|
func (m *MockRepository) DraftV2(ctx context.Context, id int64, commitID string) (*vo.DraftInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DraftV2", ctx, id, commitID)
|
|
ret0, _ := ret[0].(*vo.DraftInfo)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// DraftV2 indicates an expected call of DraftV2.
|
|
func (mr *MockRepositoryMockRecorder) DraftV2(ctx, id, commitID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DraftV2", reflect.TypeOf((*MockRepository)(nil).DraftV2), ctx, id, commitID)
|
|
}
|
|
|
|
// GenID mocks base method.
|
|
func (m *MockRepository) GenID(ctx context.Context) (int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GenID", ctx)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GenID indicates an expected call of GenID.
|
|
func (mr *MockRepositoryMockRecorder) GenID(ctx any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenID", reflect.TypeOf((*MockRepository)(nil).GenID), ctx)
|
|
}
|
|
|
|
// GenMultiIDs mocks base method.
|
|
func (m *MockRepository) GenMultiIDs(ctx context.Context, counts int) ([]int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GenMultiIDs", ctx, counts)
|
|
ret0, _ := ret[0].([]int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GenMultiIDs indicates an expected call of GenMultiIDs.
|
|
func (mr *MockRepositoryMockRecorder) GenMultiIDs(ctx, counts any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenMultiIDs", reflect.TypeOf((*MockRepository)(nil).GenMultiIDs), ctx, counts)
|
|
}
|
|
|
|
// Get mocks base method.
|
|
func (m *MockRepository) Get(ctx context.Context, checkPointID string) ([]byte, bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Get", ctx, checkPointID)
|
|
ret0, _ := ret[0].([]byte)
|
|
ret1, _ := ret[1].(bool)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// Get indicates an expected call of Get.
|
|
func (mr *MockRepositoryMockRecorder) Get(ctx, checkPointID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockRepository)(nil).Get), ctx, checkPointID)
|
|
}
|
|
|
|
// GetChatFlowRoleConfig mocks base method.
|
|
func (m *MockRepository) GetChatFlowRoleConfig(ctx context.Context, workflowID int64, version string) (*entity.ChatFlowRole, error, bool) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetChatFlowRoleConfig", ctx, workflowID, version)
|
|
ret0, _ := ret[0].(*entity.ChatFlowRole)
|
|
ret1, _ := ret[1].(error)
|
|
ret2, _ := ret[2].(bool)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// GetChatFlowRoleConfig indicates an expected call of GetChatFlowRoleConfig.
|
|
func (mr *MockRepositoryMockRecorder) GetChatFlowRoleConfig(ctx, workflowID, version any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChatFlowRoleConfig", reflect.TypeOf((*MockRepository)(nil).GetChatFlowRoleConfig), ctx, workflowID, version)
|
|
}
|
|
|
|
// GetConvRelatedInfo mocks base method.
|
|
func (m *MockRepository) GetConvRelatedInfo(ctx context.Context, convID int64) (*entity.ConvRelatedInfo, bool, func() error, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetConvRelatedInfo", ctx, convID)
|
|
ret0, _ := ret[0].(*entity.ConvRelatedInfo)
|
|
ret1, _ := ret[1].(bool)
|
|
ret2, _ := ret[2].(func() error)
|
|
ret3, _ := ret[3].(error)
|
|
return ret0, ret1, ret2, ret3
|
|
}
|
|
|
|
// GetConvRelatedInfo indicates an expected call of GetConvRelatedInfo.
|
|
func (mr *MockRepositoryMockRecorder) GetConvRelatedInfo(ctx, convID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConvRelatedInfo", reflect.TypeOf((*MockRepository)(nil).GetConvRelatedInfo), ctx, convID)
|
|
}
|
|
|
|
// GetConversationTemplate mocks base method.
|
|
func (m *MockRepository) GetConversationTemplate(ctx context.Context, env vo.Env, policy vo.GetConversationTemplatePolicy) (*entity.ConversationTemplate, bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetConversationTemplate", ctx, env, policy)
|
|
ret0, _ := ret[0].(*entity.ConversationTemplate)
|
|
ret1, _ := ret[1].(bool)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// GetConversationTemplate indicates an expected call of GetConversationTemplate.
|
|
func (mr *MockRepositoryMockRecorder) GetConversationTemplate(ctx, env, policy any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConversationTemplate", reflect.TypeOf((*MockRepository)(nil).GetConversationTemplate), ctx, env, policy)
|
|
}
|
|
|
|
// GetDraftWorkflowsByAppID mocks base method.
|
|
func (m *MockRepository) GetDraftWorkflowsByAppID(ctx context.Context, AppID int64) (map[int64]*vo.DraftInfo, map[int64]string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetDraftWorkflowsByAppID", ctx, AppID)
|
|
ret0, _ := ret[0].(map[int64]*vo.DraftInfo)
|
|
ret1, _ := ret[1].(map[int64]string)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// GetDraftWorkflowsByAppID indicates an expected call of GetDraftWorkflowsByAppID.
|
|
func (mr *MockRepositoryMockRecorder) GetDraftWorkflowsByAppID(ctx, AppID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDraftWorkflowsByAppID", reflect.TypeOf((*MockRepository)(nil).GetDraftWorkflowsByAppID), ctx, AppID)
|
|
}
|
|
|
|
// GetDynamicConversationByID mocks base method.
|
|
func (m *MockRepository) GetDynamicConversationByID(ctx context.Context, env vo.Env, appID, connectorID, conversationID int64) (*entity.DynamicConversation, bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetDynamicConversationByID", ctx, env, appID, connectorID, conversationID)
|
|
ret0, _ := ret[0].(*entity.DynamicConversation)
|
|
ret1, _ := ret[1].(bool)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// GetDynamicConversationByID indicates an expected call of GetDynamicConversationByID.
|
|
func (mr *MockRepositoryMockRecorder) GetDynamicConversationByID(ctx, env, appID, connectorID, conversationID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDynamicConversationByID", reflect.TypeOf((*MockRepository)(nil).GetDynamicConversationByID), ctx, env, appID, connectorID, conversationID)
|
|
}
|
|
|
|
// GetDynamicConversationByName mocks base method.
|
|
func (m *MockRepository) GetDynamicConversationByName(ctx context.Context, env vo.Env, appID, connectorID, userID int64, name string) (*entity.DynamicConversation, bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetDynamicConversationByName", ctx, env, appID, connectorID, userID, name)
|
|
ret0, _ := ret[0].(*entity.DynamicConversation)
|
|
ret1, _ := ret[1].(bool)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// GetDynamicConversationByName indicates an expected call of GetDynamicConversationByName.
|
|
func (mr *MockRepositoryMockRecorder) GetDynamicConversationByName(ctx, env, appID, connectorID, userID, name any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDynamicConversationByName", reflect.TypeOf((*MockRepository)(nil).GetDynamicConversationByName), ctx, env, appID, connectorID, userID, name)
|
|
}
|
|
|
|
// GetEntity mocks base method.
|
|
func (m *MockRepository) GetEntity(ctx context.Context, policy *vo.GetPolicy) (*entity.Workflow, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetEntity", ctx, policy)
|
|
ret0, _ := ret[0].(*entity.Workflow)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetEntity indicates an expected call of GetEntity.
|
|
func (mr *MockRepositoryMockRecorder) GetEntity(ctx, policy any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEntity", reflect.TypeOf((*MockRepository)(nil).GetEntity), ctx, policy)
|
|
}
|
|
|
|
// GetFirstInterruptEvent mocks base method.
|
|
func (m *MockRepository) GetFirstInterruptEvent(ctx context.Context, wfExeID int64) (*entity.InterruptEvent, bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetFirstInterruptEvent", ctx, wfExeID)
|
|
ret0, _ := ret[0].(*entity.InterruptEvent)
|
|
ret1, _ := ret[1].(bool)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// GetFirstInterruptEvent indicates an expected call of GetFirstInterruptEvent.
|
|
func (mr *MockRepositoryMockRecorder) GetFirstInterruptEvent(ctx, wfExeID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFirstInterruptEvent", reflect.TypeOf((*MockRepository)(nil).GetFirstInterruptEvent), ctx, wfExeID)
|
|
}
|
|
|
|
// GetKnowledgeRecallChatModel mocks base method.
|
|
func (m *MockRepository) GetKnowledgeRecallChatModel() model.BaseChatModel {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetKnowledgeRecallChatModel")
|
|
ret0, _ := ret[0].(model.BaseChatModel)
|
|
return ret0
|
|
}
|
|
|
|
// GetKnowledgeRecallChatModel indicates an expected call of GetKnowledgeRecallChatModel.
|
|
func (mr *MockRepositoryMockRecorder) GetKnowledgeRecallChatModel() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetKnowledgeRecallChatModel", reflect.TypeOf((*MockRepository)(nil).GetKnowledgeRecallChatModel))
|
|
}
|
|
|
|
// GetLatestVersion mocks base method.
|
|
func (m *MockRepository) GetLatestVersion(ctx context.Context, id int64) (*vo.VersionInfo, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetLatestVersion", ctx, id)
|
|
ret0, _ := ret[0].(*vo.VersionInfo)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetLatestVersion indicates an expected call of GetLatestVersion.
|
|
func (mr *MockRepositoryMockRecorder) GetLatestVersion(ctx, id any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestVersion", reflect.TypeOf((*MockRepository)(nil).GetLatestVersion), ctx, id)
|
|
}
|
|
|
|
// GetMeta mocks base method.
|
|
func (m *MockRepository) GetMeta(ctx context.Context, id int64) (*vo.Meta, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetMeta", ctx, id)
|
|
ret0, _ := ret[0].(*vo.Meta)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetMeta indicates an expected call of GetMeta.
|
|
func (mr *MockRepositoryMockRecorder) GetMeta(ctx, id any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMeta", reflect.TypeOf((*MockRepository)(nil).GetMeta), ctx, id)
|
|
}
|
|
|
|
// GetNodeDebugLatestExeID mocks base method.
|
|
func (m *MockRepository) GetNodeDebugLatestExeID(ctx context.Context, wfID int64, nodeID string, uID int64) (int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetNodeDebugLatestExeID", ctx, wfID, nodeID, uID)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetNodeDebugLatestExeID indicates an expected call of GetNodeDebugLatestExeID.
|
|
func (mr *MockRepositoryMockRecorder) GetNodeDebugLatestExeID(ctx, wfID, nodeID, uID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeDebugLatestExeID", reflect.TypeOf((*MockRepository)(nil).GetNodeDebugLatestExeID), ctx, wfID, nodeID, uID)
|
|
}
|
|
|
|
// GetNodeExecution mocks base method.
|
|
func (m *MockRepository) GetNodeExecution(ctx context.Context, wfExeID int64, nodeID string) (*entity.NodeExecution, bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetNodeExecution", ctx, wfExeID, nodeID)
|
|
ret0, _ := ret[0].(*entity.NodeExecution)
|
|
ret1, _ := ret[1].(bool)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// GetNodeExecution indicates an expected call of GetNodeExecution.
|
|
func (mr *MockRepositoryMockRecorder) GetNodeExecution(ctx, wfExeID, nodeID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeExecution", reflect.TypeOf((*MockRepository)(nil).GetNodeExecution), ctx, wfExeID, nodeID)
|
|
}
|
|
|
|
// GetNodeExecutionByParent mocks base method.
|
|
func (m *MockRepository) GetNodeExecutionByParent(ctx context.Context, wfExeID int64, parentNodeID string) ([]*entity.NodeExecution, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetNodeExecutionByParent", ctx, wfExeID, parentNodeID)
|
|
ret0, _ := ret[0].([]*entity.NodeExecution)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetNodeExecutionByParent indicates an expected call of GetNodeExecutionByParent.
|
|
func (mr *MockRepositoryMockRecorder) GetNodeExecutionByParent(ctx, wfExeID, parentNodeID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeExecutionByParent", reflect.TypeOf((*MockRepository)(nil).GetNodeExecutionByParent), ctx, wfExeID, parentNodeID)
|
|
}
|
|
|
|
// GetNodeExecutionsByWfExeID mocks base method.
|
|
func (m *MockRepository) GetNodeExecutionsByWfExeID(ctx context.Context, wfExeID int64) ([]*entity.NodeExecution, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetNodeExecutionsByWfExeID", ctx, wfExeID)
|
|
ret0, _ := ret[0].([]*entity.NodeExecution)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetNodeExecutionsByWfExeID indicates an expected call of GetNodeExecutionsByWfExeID.
|
|
func (mr *MockRepositoryMockRecorder) GetNodeExecutionsByWfExeID(ctx, wfExeID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeExecutionsByWfExeID", reflect.TypeOf((*MockRepository)(nil).GetNodeExecutionsByWfExeID), ctx, wfExeID)
|
|
}
|
|
|
|
// GetNodeOfCodeConfig mocks base method.
|
|
func (m *MockRepository) GetNodeOfCodeConfig() *config.NodeOfCodeConfig {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetNodeOfCodeConfig")
|
|
ret0, _ := ret[0].(*config.NodeOfCodeConfig)
|
|
return ret0
|
|
}
|
|
|
|
// GetNodeOfCodeConfig indicates an expected call of GetNodeOfCodeConfig.
|
|
func (mr *MockRepositoryMockRecorder) GetNodeOfCodeConfig() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeOfCodeConfig", reflect.TypeOf((*MockRepository)(nil).GetNodeOfCodeConfig))
|
|
}
|
|
|
|
// GetObjectUrl mocks base method.
|
|
func (m *MockRepository) GetObjectUrl(ctx context.Context, objectKey string, opts ...storage.GetOptFn) (string, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []any{ctx, objectKey}
|
|
for _, a := range opts {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "GetObjectUrl", varargs...)
|
|
ret0, _ := ret[0].(string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetObjectUrl indicates an expected call of GetObjectUrl.
|
|
func (mr *MockRepositoryMockRecorder) GetObjectUrl(ctx, objectKey any, opts ...any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]any{ctx, objectKey}, opts...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectUrl", reflect.TypeOf((*MockRepository)(nil).GetObjectUrl), varargs...)
|
|
}
|
|
|
|
// GetOrCreateDynamicConversation mocks base method.
|
|
func (m *MockRepository) GetOrCreateDynamicConversation(ctx context.Context, env vo.Env, idGen workflow1.ConversationIDGenerator, meta *vo.CreateDynamicConversation) (int64, int64, bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetOrCreateDynamicConversation", ctx, env, idGen, meta)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(int64)
|
|
ret2, _ := ret[2].(bool)
|
|
ret3, _ := ret[3].(error)
|
|
return ret0, ret1, ret2, ret3
|
|
}
|
|
|
|
// GetOrCreateDynamicConversation indicates an expected call of GetOrCreateDynamicConversation.
|
|
func (mr *MockRepositoryMockRecorder) GetOrCreateDynamicConversation(ctx, env, idGen, meta any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrCreateDynamicConversation", reflect.TypeOf((*MockRepository)(nil).GetOrCreateDynamicConversation), ctx, env, idGen, meta)
|
|
}
|
|
|
|
// GetOrCreateStaticConversation mocks base method.
|
|
func (m *MockRepository) GetOrCreateStaticConversation(ctx context.Context, env vo.Env, idGen workflow1.ConversationIDGenerator, meta *vo.CreateStaticConversation) (int64, int64, bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetOrCreateStaticConversation", ctx, env, idGen, meta)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(int64)
|
|
ret2, _ := ret[2].(bool)
|
|
ret3, _ := ret[3].(error)
|
|
return ret0, ret1, ret2, ret3
|
|
}
|
|
|
|
// GetOrCreateStaticConversation indicates an expected call of GetOrCreateStaticConversation.
|
|
func (mr *MockRepositoryMockRecorder) GetOrCreateStaticConversation(ctx, env, idGen, meta any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrCreateStaticConversation", reflect.TypeOf((*MockRepository)(nil).GetOrCreateStaticConversation), ctx, env, idGen, meta)
|
|
}
|
|
|
|
// GetStaticConversationByID mocks base method.
|
|
func (m *MockRepository) GetStaticConversationByID(ctx context.Context, env vo.Env, appID, connectorID, conversationID int64) (string, bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetStaticConversationByID", ctx, env, appID, connectorID, conversationID)
|
|
ret0, _ := ret[0].(string)
|
|
ret1, _ := ret[1].(bool)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// GetStaticConversationByID indicates an expected call of GetStaticConversationByID.
|
|
func (mr *MockRepositoryMockRecorder) GetStaticConversationByID(ctx, env, appID, connectorID, conversationID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStaticConversationByID", reflect.TypeOf((*MockRepository)(nil).GetStaticConversationByID), ctx, env, appID, connectorID, conversationID)
|
|
}
|
|
|
|
// GetStaticConversationByTemplateID mocks base method.
|
|
func (m *MockRepository) GetStaticConversationByTemplateID(ctx context.Context, env vo.Env, userID, connectorID, templateID int64) (*entity.StaticConversation, bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetStaticConversationByTemplateID", ctx, env, userID, connectorID, templateID)
|
|
ret0, _ := ret[0].(*entity.StaticConversation)
|
|
ret1, _ := ret[1].(bool)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// GetStaticConversationByTemplateID indicates an expected call of GetStaticConversationByTemplateID.
|
|
func (mr *MockRepositoryMockRecorder) GetStaticConversationByTemplateID(ctx, env, userID, connectorID, templateID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStaticConversationByTemplateID", reflect.TypeOf((*MockRepository)(nil).GetStaticConversationByTemplateID), ctx, env, userID, connectorID, templateID)
|
|
}
|
|
|
|
// GetTestRunLatestExeID mocks base method.
|
|
func (m *MockRepository) GetTestRunLatestExeID(ctx context.Context, wfID, uID int64) (int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetTestRunLatestExeID", ctx, wfID, uID)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetTestRunLatestExeID indicates an expected call of GetTestRunLatestExeID.
|
|
func (mr *MockRepositoryMockRecorder) GetTestRunLatestExeID(ctx, wfID, uID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTestRunLatestExeID", reflect.TypeOf((*MockRepository)(nil).GetTestRunLatestExeID), ctx, wfID, uID)
|
|
}
|
|
|
|
// GetVersion mocks base method.
|
|
func (m *MockRepository) GetVersion(ctx context.Context, id int64, version string) (*vo.VersionInfo, bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetVersion", ctx, id, version)
|
|
ret0, _ := ret[0].(*vo.VersionInfo)
|
|
ret1, _ := ret[1].(bool)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// GetVersion indicates an expected call of GetVersion.
|
|
func (mr *MockRepositoryMockRecorder) GetVersion(ctx, id, version any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVersion", reflect.TypeOf((*MockRepository)(nil).GetVersion), ctx, id, version)
|
|
}
|
|
|
|
// GetVersionListByConnectorAndWorkflowID mocks base method.
|
|
func (m *MockRepository) GetVersionListByConnectorAndWorkflowID(ctx context.Context, connectorID, workflowID int64, limit int) ([]string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetVersionListByConnectorAndWorkflowID", ctx, connectorID, workflowID, limit)
|
|
ret0, _ := ret[0].([]string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetVersionListByConnectorAndWorkflowID indicates an expected call of GetVersionListByConnectorAndWorkflowID.
|
|
func (mr *MockRepositoryMockRecorder) GetVersionListByConnectorAndWorkflowID(ctx, connectorID, workflowID, limit any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVersionListByConnectorAndWorkflowID", reflect.TypeOf((*MockRepository)(nil).GetVersionListByConnectorAndWorkflowID), ctx, connectorID, workflowID, limit)
|
|
}
|
|
|
|
// GetWorkflowCancelFlag mocks base method.
|
|
func (m *MockRepository) GetWorkflowCancelFlag(ctx context.Context, wfExeID int64) (bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetWorkflowCancelFlag", ctx, wfExeID)
|
|
ret0, _ := ret[0].(bool)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetWorkflowCancelFlag indicates an expected call of GetWorkflowCancelFlag.
|
|
func (mr *MockRepositoryMockRecorder) GetWorkflowCancelFlag(ctx, wfExeID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowCancelFlag", reflect.TypeOf((*MockRepository)(nil).GetWorkflowCancelFlag), ctx, wfExeID)
|
|
}
|
|
|
|
// GetWorkflowExecution mocks base method.
|
|
func (m *MockRepository) GetWorkflowExecution(ctx context.Context, id int64) (*entity.WorkflowExecution, bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetWorkflowExecution", ctx, id)
|
|
ret0, _ := ret[0].(*entity.WorkflowExecution)
|
|
ret1, _ := ret[1].(bool)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// GetWorkflowExecution indicates an expected call of GetWorkflowExecution.
|
|
func (mr *MockRepositoryMockRecorder) GetWorkflowExecution(ctx, id any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowExecution", reflect.TypeOf((*MockRepository)(nil).GetWorkflowExecution), ctx, id)
|
|
}
|
|
|
|
// IsApplicationConnectorWorkflowVersion mocks base method.
|
|
func (m *MockRepository) IsApplicationConnectorWorkflowVersion(ctx context.Context, connectorID, workflowID int64, version string) (bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "IsApplicationConnectorWorkflowVersion", ctx, connectorID, workflowID, version)
|
|
ret0, _ := ret[0].(bool)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// IsApplicationConnectorWorkflowVersion indicates an expected call of IsApplicationConnectorWorkflowVersion.
|
|
func (mr *MockRepositoryMockRecorder) IsApplicationConnectorWorkflowVersion(ctx, connectorID, workflowID, version any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsApplicationConnectorWorkflowVersion", reflect.TypeOf((*MockRepository)(nil).IsApplicationConnectorWorkflowVersion), ctx, connectorID, workflowID, version)
|
|
}
|
|
|
|
// ListConversationTemplate mocks base method.
|
|
func (m *MockRepository) ListConversationTemplate(ctx context.Context, env vo.Env, policy *vo.ListConversationTemplatePolicy) ([]*entity.ConversationTemplate, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ListConversationTemplate", ctx, env, policy)
|
|
ret0, _ := ret[0].([]*entity.ConversationTemplate)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ListConversationTemplate indicates an expected call of ListConversationTemplate.
|
|
func (mr *MockRepositoryMockRecorder) ListConversationTemplate(ctx, env, policy any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListConversationTemplate", reflect.TypeOf((*MockRepository)(nil).ListConversationTemplate), ctx, env, policy)
|
|
}
|
|
|
|
// ListDynamicConversation mocks base method.
|
|
func (m *MockRepository) ListDynamicConversation(ctx context.Context, env vo.Env, policy *vo.ListConversationPolicy) ([]*entity.DynamicConversation, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ListDynamicConversation", ctx, env, policy)
|
|
ret0, _ := ret[0].([]*entity.DynamicConversation)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ListDynamicConversation indicates an expected call of ListDynamicConversation.
|
|
func (mr *MockRepositoryMockRecorder) ListDynamicConversation(ctx, env, policy any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDynamicConversation", reflect.TypeOf((*MockRepository)(nil).ListDynamicConversation), ctx, env, policy)
|
|
}
|
|
|
|
// ListInterruptEvents mocks base method.
|
|
func (m *MockRepository) ListInterruptEvents(ctx context.Context, wfExeID int64) ([]*entity.InterruptEvent, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ListInterruptEvents", ctx, wfExeID)
|
|
ret0, _ := ret[0].([]*entity.InterruptEvent)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ListInterruptEvents indicates an expected call of ListInterruptEvents.
|
|
func (mr *MockRepositoryMockRecorder) ListInterruptEvents(ctx, wfExeID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListInterruptEvents", reflect.TypeOf((*MockRepository)(nil).ListInterruptEvents), ctx, wfExeID)
|
|
}
|
|
|
|
// MDelete mocks base method.
|
|
func (m *MockRepository) MDelete(ctx context.Context, ids []int64) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "MDelete", ctx, ids)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// MDelete indicates an expected call of MDelete.
|
|
func (mr *MockRepositoryMockRecorder) MDelete(ctx, ids any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MDelete", reflect.TypeOf((*MockRepository)(nil).MDelete), ctx, ids)
|
|
}
|
|
|
|
// MGetDrafts mocks base method.
|
|
func (m *MockRepository) MGetDrafts(ctx context.Context, policy *vo.MGetPolicy) ([]*entity.Workflow, int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "MGetDrafts", ctx, policy)
|
|
ret0, _ := ret[0].([]*entity.Workflow)
|
|
ret1, _ := ret[1].(int64)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// MGetDrafts indicates an expected call of MGetDrafts.
|
|
func (mr *MockRepositoryMockRecorder) MGetDrafts(ctx, policy any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetDrafts", reflect.TypeOf((*MockRepository)(nil).MGetDrafts), ctx, policy)
|
|
}
|
|
|
|
// MGetLatestVersion mocks base method.
|
|
func (m *MockRepository) MGetLatestVersion(ctx context.Context, policy *vo.MGetPolicy) ([]*entity.Workflow, int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "MGetLatestVersion", ctx, policy)
|
|
ret0, _ := ret[0].([]*entity.Workflow)
|
|
ret1, _ := ret[1].(int64)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// MGetLatestVersion indicates an expected call of MGetLatestVersion.
|
|
func (mr *MockRepositoryMockRecorder) MGetLatestVersion(ctx, policy any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetLatestVersion", reflect.TypeOf((*MockRepository)(nil).MGetLatestVersion), ctx, policy)
|
|
}
|
|
|
|
// MGetMetas mocks base method.
|
|
func (m *MockRepository) MGetMetas(ctx context.Context, query *vo.MetaQuery) (map[int64]*vo.Meta, int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "MGetMetas", ctx, query)
|
|
ret0, _ := ret[0].(map[int64]*vo.Meta)
|
|
ret1, _ := ret[1].(int64)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// MGetMetas indicates an expected call of MGetMetas.
|
|
func (mr *MockRepositoryMockRecorder) MGetMetas(ctx, query any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetMetas", reflect.TypeOf((*MockRepository)(nil).MGetMetas), ctx, query)
|
|
}
|
|
|
|
// MGetReferences mocks base method.
|
|
func (m *MockRepository) MGetReferences(ctx context.Context, policy *vo.MGetReferencePolicy) ([]*entity.WorkflowReference, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "MGetReferences", ctx, policy)
|
|
ret0, _ := ret[0].([]*entity.WorkflowReference)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// MGetReferences indicates an expected call of MGetReferences.
|
|
func (mr *MockRepositoryMockRecorder) MGetReferences(ctx, policy any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetReferences", reflect.TypeOf((*MockRepository)(nil).MGetReferences), ctx, policy)
|
|
}
|
|
|
|
// MGetStaticConversation mocks base method.
|
|
func (m *MockRepository) MGetStaticConversation(ctx context.Context, env vo.Env, userID, connectorID int64, templateIDs []int64) ([]*entity.StaticConversation, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "MGetStaticConversation", ctx, env, userID, connectorID, templateIDs)
|
|
ret0, _ := ret[0].([]*entity.StaticConversation)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// MGetStaticConversation indicates an expected call of MGetStaticConversation.
|
|
func (mr *MockRepositoryMockRecorder) MGetStaticConversation(ctx, env, userID, connectorID, templateIDs any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetStaticConversation", reflect.TypeOf((*MockRepository)(nil).MGetStaticConversation), ctx, env, userID, connectorID, templateIDs)
|
|
}
|
|
|
|
// PopFirstInterruptEvent mocks base method.
|
|
func (m *MockRepository) PopFirstInterruptEvent(ctx context.Context, wfExeID int64) (*entity.InterruptEvent, bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "PopFirstInterruptEvent", ctx, wfExeID)
|
|
ret0, _ := ret[0].(*entity.InterruptEvent)
|
|
ret1, _ := ret[1].(bool)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// PopFirstInterruptEvent indicates an expected call of PopFirstInterruptEvent.
|
|
func (mr *MockRepositoryMockRecorder) PopFirstInterruptEvent(ctx, wfExeID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PopFirstInterruptEvent", reflect.TypeOf((*MockRepository)(nil).PopFirstInterruptEvent), ctx, wfExeID)
|
|
}
|
|
|
|
// SaveInterruptEvents mocks base method.
|
|
func (m *MockRepository) SaveInterruptEvents(ctx context.Context, wfExeID int64, events []*entity.InterruptEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SaveInterruptEvents", ctx, wfExeID, events)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SaveInterruptEvents indicates an expected call of SaveInterruptEvents.
|
|
func (mr *MockRepositoryMockRecorder) SaveInterruptEvents(ctx, wfExeID, events any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveInterruptEvents", reflect.TypeOf((*MockRepository)(nil).SaveInterruptEvents), ctx, wfExeID, events)
|
|
}
|
|
|
|
// Set mocks base method.
|
|
func (m *MockRepository) Set(ctx context.Context, checkPointID string, checkPoint []byte) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Set", ctx, checkPointID, checkPoint)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Set indicates an expected call of Set.
|
|
func (mr *MockRepositoryMockRecorder) Set(ctx, checkPointID, checkPoint any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockRepository)(nil).Set), ctx, checkPointID, checkPoint)
|
|
}
|
|
|
|
// SetNodeDebugLatestExeID mocks base method.
|
|
func (m *MockRepository) SetNodeDebugLatestExeID(ctx context.Context, wfID int64, nodeID string, uID, exeID int64) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SetNodeDebugLatestExeID", ctx, wfID, nodeID, uID, exeID)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SetNodeDebugLatestExeID indicates an expected call of SetNodeDebugLatestExeID.
|
|
func (mr *MockRepositoryMockRecorder) SetNodeDebugLatestExeID(ctx, wfID, nodeID, uID, exeID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNodeDebugLatestExeID", reflect.TypeOf((*MockRepository)(nil).SetNodeDebugLatestExeID), ctx, wfID, nodeID, uID, exeID)
|
|
}
|
|
|
|
// SetTestRunLatestExeID mocks base method.
|
|
func (m *MockRepository) SetTestRunLatestExeID(ctx context.Context, wfID, uID, exeID int64) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SetTestRunLatestExeID", ctx, wfID, uID, exeID)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SetTestRunLatestExeID indicates an expected call of SetTestRunLatestExeID.
|
|
func (mr *MockRepositoryMockRecorder) SetTestRunLatestExeID(ctx, wfID, uID, exeID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTestRunLatestExeID", reflect.TypeOf((*MockRepository)(nil).SetTestRunLatestExeID), ctx, wfID, uID, exeID)
|
|
}
|
|
|
|
// SetWorkflowCancelFlag mocks base method.
|
|
func (m *MockRepository) SetWorkflowCancelFlag(ctx context.Context, wfExeID int64) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SetWorkflowCancelFlag", ctx, wfExeID)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SetWorkflowCancelFlag indicates an expected call of SetWorkflowCancelFlag.
|
|
func (mr *MockRepositoryMockRecorder) SetWorkflowCancelFlag(ctx, wfExeID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWorkflowCancelFlag", reflect.TypeOf((*MockRepository)(nil).SetWorkflowCancelFlag), ctx, wfExeID)
|
|
}
|
|
|
|
// Suggest mocks base method.
|
|
func (m *MockRepository) Suggest(ctx context.Context, input *vo.SuggestInfo) ([]string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Suggest", ctx, input)
|
|
ret0, _ := ret[0].([]string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Suggest indicates an expected call of Suggest.
|
|
func (mr *MockRepositoryMockRecorder) Suggest(ctx, input any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Suggest", reflect.TypeOf((*MockRepository)(nil).Suggest), ctx, input)
|
|
}
|
|
|
|
// TryLockWorkflowExecution mocks base method.
|
|
func (m *MockRepository) TryLockWorkflowExecution(ctx context.Context, wfExeID, resumingEventID int64) (bool, entity.WorkflowExecuteStatus, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "TryLockWorkflowExecution", ctx, wfExeID, resumingEventID)
|
|
ret0, _ := ret[0].(bool)
|
|
ret1, _ := ret[1].(entity.WorkflowExecuteStatus)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// TryLockWorkflowExecution indicates an expected call of TryLockWorkflowExecution.
|
|
func (mr *MockRepositoryMockRecorder) TryLockWorkflowExecution(ctx, wfExeID, resumingEventID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryLockWorkflowExecution", reflect.TypeOf((*MockRepository)(nil).TryLockWorkflowExecution), ctx, wfExeID, resumingEventID)
|
|
}
|
|
|
|
// UpdateChatFlowRoleConfig mocks base method.
|
|
func (m *MockRepository) UpdateChatFlowRoleConfig(ctx context.Context, workflowID int64, chatFlowRole *vo.ChatFlowRoleUpdate) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateChatFlowRoleConfig", ctx, workflowID, chatFlowRole)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateChatFlowRoleConfig indicates an expected call of UpdateChatFlowRoleConfig.
|
|
func (mr *MockRepositoryMockRecorder) UpdateChatFlowRoleConfig(ctx, workflowID, chatFlowRole any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChatFlowRoleConfig", reflect.TypeOf((*MockRepository)(nil).UpdateChatFlowRoleConfig), ctx, workflowID, chatFlowRole)
|
|
}
|
|
|
|
// UpdateDraftConversationTemplateName mocks base method.
|
|
func (m *MockRepository) UpdateDraftConversationTemplateName(ctx context.Context, templateID int64, name string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateDraftConversationTemplateName", ctx, templateID, name)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateDraftConversationTemplateName indicates an expected call of UpdateDraftConversationTemplateName.
|
|
func (mr *MockRepositoryMockRecorder) UpdateDraftConversationTemplateName(ctx, templateID, name any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDraftConversationTemplateName", reflect.TypeOf((*MockRepository)(nil).UpdateDraftConversationTemplateName), ctx, templateID, name)
|
|
}
|
|
|
|
// UpdateDynamicConversation mocks base method.
|
|
func (m *MockRepository) UpdateDynamicConversation(ctx context.Context, env vo.Env, conversationID, newConversationID int64) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateDynamicConversation", ctx, env, conversationID, newConversationID)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateDynamicConversation indicates an expected call of UpdateDynamicConversation.
|
|
func (mr *MockRepositoryMockRecorder) UpdateDynamicConversation(ctx, env, conversationID, newConversationID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDynamicConversation", reflect.TypeOf((*MockRepository)(nil).UpdateDynamicConversation), ctx, env, conversationID, newConversationID)
|
|
}
|
|
|
|
// UpdateDynamicConversationNameByID mocks base method.
|
|
func (m *MockRepository) UpdateDynamicConversationNameByID(ctx context.Context, env vo.Env, templateID int64, name string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateDynamicConversationNameByID", ctx, env, templateID, name)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateDynamicConversationNameByID indicates an expected call of UpdateDynamicConversationNameByID.
|
|
func (mr *MockRepositoryMockRecorder) UpdateDynamicConversationNameByID(ctx, env, templateID, name any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDynamicConversationNameByID", reflect.TypeOf((*MockRepository)(nil).UpdateDynamicConversationNameByID), ctx, env, templateID, name)
|
|
}
|
|
|
|
// UpdateFirstInterruptEvent mocks base method.
|
|
func (m *MockRepository) UpdateFirstInterruptEvent(ctx context.Context, wfExeID int64, event *entity.InterruptEvent) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateFirstInterruptEvent", ctx, wfExeID, event)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateFirstInterruptEvent indicates an expected call of UpdateFirstInterruptEvent.
|
|
func (mr *MockRepositoryMockRecorder) UpdateFirstInterruptEvent(ctx, wfExeID, event any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFirstInterruptEvent", reflect.TypeOf((*MockRepository)(nil).UpdateFirstInterruptEvent), ctx, wfExeID, event)
|
|
}
|
|
|
|
// UpdateMeta mocks base method.
|
|
func (m *MockRepository) UpdateMeta(ctx context.Context, id int64, metaUpdate *vo.MetaUpdate) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateMeta", ctx, id, metaUpdate)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateMeta indicates an expected call of UpdateMeta.
|
|
func (mr *MockRepositoryMockRecorder) UpdateMeta(ctx, id, metaUpdate any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMeta", reflect.TypeOf((*MockRepository)(nil).UpdateMeta), ctx, id, metaUpdate)
|
|
}
|
|
|
|
// UpdateNodeExecution mocks base method.
|
|
func (m *MockRepository) UpdateNodeExecution(ctx context.Context, execution *entity.NodeExecution) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateNodeExecution", ctx, execution)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateNodeExecution indicates an expected call of UpdateNodeExecution.
|
|
func (mr *MockRepositoryMockRecorder) UpdateNodeExecution(ctx, execution any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateNodeExecution", reflect.TypeOf((*MockRepository)(nil).UpdateNodeExecution), ctx, execution)
|
|
}
|
|
|
|
// UpdateNodeExecutionStreaming mocks base method.
|
|
func (m *MockRepository) UpdateNodeExecutionStreaming(ctx context.Context, execution *entity.NodeExecution) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateNodeExecutionStreaming", ctx, execution)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateNodeExecutionStreaming indicates an expected call of UpdateNodeExecutionStreaming.
|
|
func (mr *MockRepositoryMockRecorder) UpdateNodeExecutionStreaming(ctx, execution any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateNodeExecutionStreaming", reflect.TypeOf((*MockRepository)(nil).UpdateNodeExecutionStreaming), ctx, execution)
|
|
}
|
|
|
|
// UpdateStaticConversation mocks base method.
|
|
func (m *MockRepository) UpdateStaticConversation(ctx context.Context, env vo.Env, templateID, connectorID, userID, newConversationID int64) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateStaticConversation", ctx, env, templateID, connectorID, userID, newConversationID)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateStaticConversation indicates an expected call of UpdateStaticConversation.
|
|
func (mr *MockRepositoryMockRecorder) UpdateStaticConversation(ctx, env, templateID, connectorID, userID, newConversationID any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStaticConversation", reflect.TypeOf((*MockRepository)(nil).UpdateStaticConversation), ctx, env, templateID, connectorID, userID, newConversationID)
|
|
}
|
|
|
|
// UpdateWorkflowDraftTestRunSuccess mocks base method.
|
|
func (m *MockRepository) UpdateWorkflowDraftTestRunSuccess(ctx context.Context, id int64) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateWorkflowDraftTestRunSuccess", ctx, id)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// UpdateWorkflowDraftTestRunSuccess indicates an expected call of UpdateWorkflowDraftTestRunSuccess.
|
|
func (mr *MockRepositoryMockRecorder) UpdateWorkflowDraftTestRunSuccess(ctx, id any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkflowDraftTestRunSuccess", reflect.TypeOf((*MockRepository)(nil).UpdateWorkflowDraftTestRunSuccess), ctx, id)
|
|
}
|
|
|
|
// UpdateWorkflowExecution mocks base method.
|
|
func (m *MockRepository) UpdateWorkflowExecution(ctx context.Context, execution *entity.WorkflowExecution, allowedStatus []entity.WorkflowExecuteStatus) (int64, entity.WorkflowExecuteStatus, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "UpdateWorkflowExecution", ctx, execution, allowedStatus)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(entity.WorkflowExecuteStatus)
|
|
ret2, _ := ret[2].(error)
|
|
return ret0, ret1, ret2
|
|
}
|
|
|
|
// UpdateWorkflowExecution indicates an expected call of UpdateWorkflowExecution.
|
|
func (mr *MockRepositoryMockRecorder) UpdateWorkflowExecution(ctx, execution, allowedStatus any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkflowExecution", reflect.TypeOf((*MockRepository)(nil).UpdateWorkflowExecution), ctx, execution, allowedStatus)
|
|
}
|
|
|
|
// WorkflowAsTool mocks base method.
|
|
func (m *MockRepository) WorkflowAsTool(ctx context.Context, policy vo.GetPolicy, wfToolConfig vo.WorkflowToolConfig) (workflow1.ToolFromWorkflow, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "WorkflowAsTool", ctx, policy, wfToolConfig)
|
|
ret0, _ := ret[0].(workflow1.ToolFromWorkflow)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// WorkflowAsTool indicates an expected call of WorkflowAsTool.
|
|
func (mr *MockRepositoryMockRecorder) WorkflowAsTool(ctx, policy, wfToolConfig any) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WorkflowAsTool", reflect.TypeOf((*MockRepository)(nil).WorkflowAsTool), ctx, policy, wfToolConfig)
|
|
}
|