// ReSharper disable MemberCanBeProtected.Global public ServerProxy(string serverUri, ICredentials credentials, IAsyncWorker worker) // ReSharper restore MemberCanBeProtected.Global { _wrappedConnection = new ServerProxyWithoutChunking(serverUri,credentials,worker); SetupPassthroughEvents(); }
public SettingsViewModel(IEventAggregator eventPublisher, IPopupController popupController, IAsyncWorker asyncWorker, IWin32Window parentWindow, IConnectControlViewModel connectControlViewModel) : base(eventPublisher) { Settings = new Data.Settings.Settings(); VerifyArgument.IsNotNull("popupController", popupController); _popupController = popupController; VerifyArgument.IsNotNull("asyncWorker", asyncWorker); _asyncWorker = asyncWorker; VerifyArgument.IsNotNull("parentWindow", parentWindow); _parentWindow = parentWindow; SaveCommand = new RelayCommand(o => SaveSettings(), o => IsDirty); ServerChangedCommand = new DelegateCommand(OnServerChanged); ConnectControlViewModel = connectControlViewModel ?? new ConnectControlViewModel(OnServerChanged, "Server:", false); }
internal ConnectControlSingleton(IStudioResourceRepository studioResourceRepository, IAsyncWorker asyncWorker, IEnvironmentModelProvider serverProvider, IEnvironmentRepository environmentRepository) { VerifyArgument.IsNotNull("studioResourceRepository", studioResourceRepository); VerifyArgument.IsNotNull("asyncWorker", asyncWorker); VerifyArgument.IsNotNull("serverProvider", serverProvider); VerifyArgument.IsNotNull("environmentRepository", environmentRepository); _studioResourceRepository = studioResourceRepository; _asyncWorker = asyncWorker; _serverProvider = serverProvider; _environmentRepository = environmentRepository; Servers = new ObservableCollection<IConnectControlEnvironment>(); LoadServers(); }
public ManageWcfSourceViewModel(IWcfSourceModel updateManager, IEventAggregator aggregator, IAsyncWorker asyncWorker, IServer environment) : base("WcfSource") { VerifyArgument.IsNotNull("asyncWorker", asyncWorker); VerifyArgument.IsNotNull("updateManager", updateManager); VerifyArgument.IsNotNull("aggregator", aggregator); AsyncWorker = asyncWorker; _environment = environment; _updateManager = updateManager; _endPointUrl = string.Empty; HeaderText = Resources.Languages.Core.WcfServiceNewHeaderLabel; Header = Resources.Languages.Core.WcfServiceNewHeaderLabel; TestCommand = new Microsoft.Practices.Prism.Commands.DelegateCommand(TestConnection, CanTest); SaveCommand = new Microsoft.Practices.Prism.Commands.DelegateCommand(SaveConnection, CanSave); CancelTestCommand = new Microsoft.Practices.Prism.Commands.DelegateCommand(CancelTest, CanCancelTest); }
/// <summary> /// Shared Ctor initialisation /// </summary> /// <param name="asyncWorker"></param> /// <param name="serverProvider"></param> /// <param name="environmentRepository"></param> /// <param name="eventAggregator"></param> /// <param name="connectControl"></param> /// <param name="deployStatsCalculator"></param> private void Initialize(IAsyncWorker asyncWorker, IEnvironmentModelProvider serverProvider, IEnvironmentRepository environmentRepository, IEventAggregator eventAggregator, IConnectControlSingleton connectControl, IDeployStatsCalculator deployStatsCalculator = null) { EnvironmentRepository = environmentRepository; _deployStatsCalculator = deployStatsCalculator ?? new DeployStatsCalculator(); _serverProvider = serverProvider; _servers = new ObservableCollection <IEnvironmentModel>(); _targetStats = new ObservableCollection <DeployStatsTO>(); _sourceStats = new ObservableCollection <DeployStatsTO>(); Target = new DeployNavigationViewModel(eventAggregator, asyncWorker, environmentRepository, StudioResourceRepository, true, connectControl); Source = new DeployNavigationViewModel(eventAggregator, asyncWorker, environmentRepository, StudioResourceRepository, false, connectControl); SetupPredicates(); SetupCommands(); LoadServers(); ExplorerItemModel.OnCheckedStateChangedAction += OnCheckedStateChangedAction; }
public TriggerQueueView(IServer server, IAsyncWorker asyncWorker) { VerifyArgument.IsNotNull(nameof(asyncWorker), asyncWorker); var activeServer = CustomContainer.Get <IShellViewModel>().ActiveServer; _server = server is null ? activeServer : server; _resourceRepository = _server.ResourceRepository; _asyncWorker = asyncWorker; _popupController = CustomContainer.Get <IPopupController>(); IsNewQueue = false; NewQueue = true; Options = new ObservableCollection <OptionView>(); DeadLetterOptions = new ObservableCollection <OptionView>(); Inputs = new List <IServiceInputBase>(); VerifyCommand = new DelegateCommand(ExecuteVerify); MapEntireMessage = true; }
public DeployViewModel(IAsyncWorker asyncWorker, IEnvironmentModelProvider serverProvider, IEnvironmentRepository environmentRepository, IEventAggregator eventAggregator, IStudioResourceRepository studioResourceRepository, IConnectControlViewModel sourceConnectControlVm, IConnectControlViewModel destinationConnectControlVm, IDeployStatsCalculator deployStatsCalculator = null, Guid?resourceID = null, Guid?environmentID = null, IConnectControlSingleton connectControlSingleton = null) : base(eventAggregator) { VerifyArgument.IsNotNull("asyncWorker", asyncWorker); if (connectControlSingleton == null) { connectControlSingleton = ConnectControlSingleton.Instance; } if (environmentID.HasValue) { _initialItemEnvironmentID = environmentID.Value; } _initialItemResourceID = resourceID.GetValueOrDefault(Guid.Empty); DestinationServerHasDropped = false; StudioResourceRepository = studioResourceRepository; Initialize(asyncWorker, serverProvider, environmentRepository, eventAggregator, connectControlSingleton, deployStatsCalculator); SourceConnectControlViewModel = sourceConnectControlVm ?? new ConnectControlViewModel(ChangeSourceServer, "Source Server:", false); TargetConnectControlViewModel = destinationConnectControlVm ?? new ConnectControlViewModel(ChangeDestinationServer, "Destination Server:", false); TargetConnectControlViewModel.SetTargetEnvironment(); }
public SharepointServerSourceViewModel(ISharePointSourceModel updateManager, IEventAggregator aggregator, IAsyncWorker asyncWorker, IServer environment) : base("SharepointServerSource") { VerifyArgument.IsNotNull("asyncWorker", asyncWorker); VerifyArgument.IsNotNull("updateManager", updateManager); VerifyArgument.IsNotNull("aggregator", aggregator); AsyncWorker = asyncWorker; _environment = environment; _updateManager = updateManager; _authenticationType = AuthenticationType.Windows; _serverName = string.Empty; _userName = string.Empty; _password = string.Empty; IsWindows = true; HeaderText = Resources.Languages.Core.SharePointServiceNewHeaderLabel; Header = Resources.Languages.Core.SharePointServiceNewHeaderLabel; TestCommand = new Microsoft.Practices.Prism.Commands.DelegateCommand(TestConnection, CanTest); SaveCommand = new Microsoft.Practices.Prism.Commands.DelegateCommand(SaveConnection, CanSave); CancelTestCommand = new Microsoft.Practices.Prism.Commands.DelegateCommand(CancelTest, CanCancelTest); }
public static void Send(WebServerMethod method, IContextualResourceModel resourceModel, string payload, IAsyncWorker asyncWorker) { if(resourceModel == null || resourceModel.Environment == null || !resourceModel.Environment.IsConnected) { return; } var clientContext = resourceModel.Environment.Connection; if(clientContext == null) { return; } asyncWorker.Start(() => { var controller = new CommunicationController { ServiceName = resourceModel.Category }; controller.AddPayloadArgument("DebugPayload", payload); controller.ExecuteCommand<string>(clientContext, clientContext.WorkspaceID); }, () => { }); }
public TriggersViewModel(IEventAggregator eventPublisher, IPopupController popupController, IAsyncWorker asyncWorker, IServer server, Func <IServer, IServer> toEnvironmentModel) : base(eventPublisher) { Server = server; Server.NetworkStateChanged += ServerNetworkStateChanged; VerifyArgument.IsNotNull(nameof(popupController), popupController); _popupController = popupController; VerifyArgument.IsNotNull(nameof(asyncWorker), asyncWorker); _asyncWorker = asyncWorker; SaveCommand = new RelayCommand(o => SaveTriggers(), o => { return(IsSaveEnabled()); }); ToEnvironmentModel = toEnvironmentModel ?? (a => a.ToEnvironmentModel()); CurrentEnvironment = ToEnvironmentModel?.Invoke(server); DisplayName = StringResources.TriggersHeader + " - " + Server.DisplayName; LoadTasks(); }
public SettingsViewModel(IEventAggregator eventPublisher, IPopupController popupController, IAsyncWorker asyncWorker, IWin32Window parentWindow, IServer server, Func <IServer, IServer> toEnvironmentModel) : base(eventPublisher) { Server = server; Server.NetworkStateChanged += ServerNetworkStateChanged; Settings = new Data.Settings.Settings(); VerifyArgument.IsNotNull("popupController", popupController); _popupController = popupController; VerifyArgument.IsNotNull("asyncWorker", asyncWorker); _asyncWorker = asyncWorker; VerifyArgument.IsNotNull("parentWindow", parentWindow); _parentWindow = parentWindow; SaveCommand = new RelayCommand(o => SaveSettings(), o => IsDirty); ToEnvironmentModel = toEnvironmentModel ?? (a => a.ToEnvironmentModel()); CurrentEnvironment = ToEnvironmentModel?.Invoke(server); LoadSettings(); // ReSharper disable once VirtualMemberCallInContructor DisplayName = StringResources.SettingsTitle + " - " + Server.DisplayName; }
public RedisSourceViewModel(IRedisSourceModel redisSourceModel, IEventAggregator aggregator, IAsyncWorker asyncWorker, IExternalProcessExecutor executor) : base("RedisSource") { VerifyArgument.IsNotNull(nameof(executor), executor); VerifyArgument.IsNotNull(nameof(asyncWorker), asyncWorker); VerifyArgument.IsNotNull(nameof(redisSourceModel), redisSourceModel); VerifyArgument.IsNotNull(nameof(aggregator), aggregator); AsyncWorker = asyncWorker; Executor = executor; _redisSourceModel = redisSourceModel; _warewolfserverName = redisSourceModel.ServerName; _authenticationType = AuthenticationType.Anonymous; _hostName = string.Empty; _port = "6379"; _password = string.Empty; HeaderText = Resources.Languages.Core.RedisNewHeaderLabel; Header = Resources.Languages.Core.RedisNewHeaderLabel; TestCommand = new DelegateCommand(TestConnection, CanTest); OkCommand = new DelegateCommand(SaveConnection, CanSave); CancelTestCommand = new DelegateCommand(CancelTest, CanCancelTest); }
/// <exception cref="Exception">A delegate callback throws an exception.</exception> public ManageComPluginSourceViewModel(IManageComPluginSourceModel updateManager, Microsoft.Practices.Prism.PubSubEvents.IEventAggregator aggregator, IAsyncWorker asyncWorker) : base("ComPluginSource") { VerifyArgument.IsNotNull("asyncWorker", asyncWorker); VerifyArgument.IsNotNull("updateManager", updateManager); VerifyArgument.IsNotNull("aggregator", aggregator); _updateManager = updateManager; AsyncWorker = asyncWorker; HeaderText = Resources.Languages.Core.ComPluginSourceNewHeaderLabel; Header = Resources.Languages.Core.ComPluginSourceNewHeaderLabel; OkCommand = new DelegateCommand(Save, CanSave); CancelCommand = new DelegateCommand(() => CloseAction.Invoke()); ClearSearchTextCommand = new DelegateCommand(() => SearchTerm = ""); RefreshCommand = new DelegateCommand(() => PerformLoadAll()); _warewolfserverName = updateManager.ServerName; if (Application.Current != null && Application.Current.Dispatcher != null) { DispatcherAction = Application.Current.Dispatcher.Invoke; } }
public NavigationViewModel(IEventAggregator eventPublisher, IAsyncWorker asyncWorker, Guid?context, IEnvironmentRepository environmentRepository, IStudioResourceRepository studioResourceRepository, IConnectControlSingleton connectControlSingleton, System.Action updateWorkSpaceItems, bool isFromActivityDrop = false, enDsfActivityType activityType = enDsfActivityType.All, NavigationViewModelType navigationViewModelType = NavigationViewModelType.Explorer) : base(eventPublisher, asyncWorker, environmentRepository, studioResourceRepository, updateWorkSpaceItems) { VerifyArgument.IsNotNull("eventPublisher", eventPublisher); VerifyArgument.IsNotNull("asyncWorker", asyncWorker); VerifyArgument.IsNotNull("environmentRepository", environmentRepository); VerifyArgument.IsNotNull("connectControlSingleton", connectControlSingleton); _eventPublisher = eventPublisher; _connectControlSingleton = connectControlSingleton; _eventPublisher.Subscribe(this); EnvironmentRepository = environmentRepository; Context = context; DsfActivityType = activityType; _fromActivityDrop = isFromActivityDrop; _navigationViewModelType = navigationViewModelType; Environments = new List <IEnvironmentModel>(); ExplorerItemModels = new ObservableCollection <IExplorerItemModel>(); CircularProgressBarVisibility = Visibility.Hidden; RefreshButtonVisibility = Visibility.Visible; }
public ExchangeNewEmailDesignerViewModel(ModelItem modelItem, IAsyncWorker asyncWorker, IServer server, IEventAggregator eventPublisher) : base(modelItem) { VerifyArgument.IsNotNull("asyncWorker", asyncWorker); VerifyArgument.IsNotNull("eventPublisher", eventPublisher); _asyncWorker = asyncWorker; _server = server; _eventPublisher = eventPublisher; _eventPublisher.Subscribe(this); AddTitleBarLargeToggle(); TestEmailAccountCommand = new RelayCommand(o => TestEmailAccount(), o => CanTestEmailAccount); ChooseAttachmentsCommand = new DelegateCommand(o => ChooseAttachments()); var shellViewModel = CustomContainer.Get <IShellViewModel>(); var model = CustomContainer.CreateInstance <IExchangeServiceModel>(server.UpdateRepository, server.QueryProxy, shellViewModel, server); Model = model; SetupCommonProperties(); HelpText = Warewolf.Studio.Resources.Languages.HelpText.Tool_Email_Exchange_Send; }
public ManageWebserviceSourceViewModel(IManageWebServiceSourceModel updateManager, IEventAggregator aggregator, IAsyncWorker asyncWorker, IExternalProcessExecutor executor) : base("WebSource") { VerifyArgument.IsNotNull("executor", executor); VerifyArgument.IsNotNull("asyncWorker", asyncWorker); VerifyArgument.IsNotNull("updateManager", updateManager); VerifyArgument.IsNotNull("aggregator", aggregator); AsyncWorker = asyncWorker; Executor = executor; _updateManager = updateManager; _warewolfserverName = updateManager.ServerName; _authenticationType = AuthenticationType.Anonymous; _hostName = string.Empty; _defaultQuery = string.Empty; _userName = string.Empty; _password = string.Empty; HeaderText = Resources.Languages.Core.WebserviceNewHeaderLabel; Header = Resources.Languages.Core.WebserviceNewHeaderLabel; TestCommand = new DelegateCommand(TestConnection, CanTest); OkCommand = new DelegateCommand(SaveConnection, CanSave); CancelTestCommand = new DelegateCommand(CancelTest, CanCancelTest); ViewInBrowserCommand = new DelegateCommand(ViewInBrowser, CanViewInBrowser); }
public ElasticsearchSourceViewModel(IElasticsearchSourceModel elasticsearchSourceModel, IEventAggregator aggregator, IAsyncWorker asyncWorker, IExternalProcessExecutor executor, IServer currentEnvironment) : base("ElasticsearchSource") { VerifyArgument.IsNotNull(nameof(executor), executor); VerifyArgument.IsNotNull(nameof(asyncWorker), asyncWorker); VerifyArgument.IsNotNull(nameof(elasticsearchSourceModel), elasticsearchSourceModel); VerifyArgument.IsNotNull(nameof(aggregator), aggregator); CurrentEnvironment = currentEnvironment ?? throw new ArgumentNullException(nameof(currentEnvironment)); AsyncWorker = asyncWorker; Executor = executor; _elasticsearchSourceModel = elasticsearchSourceModel; _authenticationType = AuthenticationType.Anonymous; _hostName = string.Empty; _port = "9200"; _password = string.Empty; _searchIndex = string.Empty; _username = string.Empty; HeaderText = Resources.Languages.Core.ElasticsearchNewHeaderLabel; Header = Resources.Languages.Core.ElasticsearchNewHeaderLabel; TestCommand = new DelegateCommand(TestConnection, CanTest); OkCommand = new DelegateCommand(SaveConnection, CanSave); CancelTestCommand = new DelegateCommand(CancelTest, CanCancelTest); }
public ExchangeNewEmailDesignerViewModel(ModelItem modelItem, IAsyncWorker asyncWorker, IServer server, IEventAggregator eventPublisher, IShellViewModel shellViewModel, IActiveDataList activeDataList) : base(modelItem) { VerifyArgument.IsNotNull("asyncWorker", asyncWorker); VerifyArgument.IsNotNull("eventPublisher", eventPublisher); _asyncWorker = asyncWorker; _server = server; _eventPublisher = eventPublisher; _eventPublisher.Subscribe(this); AddTitleBarLargeToggle(); TestEmailAccountCommand = new RelayCommand(o => TestEmailAccount(), o => CanTestEmailAccount); ChooseAttachmentsCommand = new DelegateCommand(o => ChooseAttachments()); _shellViewModel = shellViewModel; _activeDataList = activeDataList; var model = new ExchangeServiceModel(_server, _shellViewModel); Model = model; SetupCommonProperties(); HelpText = Warewolf.Studio.Resources.Languages.HelpText.Tool_Email_Exchange_Send; }
public SettingsViewModel(IEventAggregator eventPublisher, IPopupController popupController, IAsyncWorker asyncWorker, IWin32Window parentWindow, IServer server, Func <IServer, IServer> toEnvironmentModel) : base(eventPublisher) { Server = server; Server.NetworkStateChanged += ServerNetworkStateChanged; Settings = new Data.Settings.Settings(); VerifyArgument.IsNotNull("popupController", popupController); _popupController = popupController; VerifyArgument.IsNotNull("asyncWorker", asyncWorker); _asyncWorker = asyncWorker; VerifyArgument.IsNotNull("parentWindow", parentWindow); _parentWindow = parentWindow; SaveCommand = new RelayCommand(o => SaveSettings(), o => IsDirty); IShellViewModel vm = CustomContainer.Get <IShellViewModel>(); CreateEnvironmentFromServer(vm.LocalhostServer); ToEnvironmentModel = toEnvironmentModel ?? (a => a.ToEnvironmentModel()); CurrentEnvironment = ToEnvironmentModel(server); LoadSettings(); DisplayName = "Settings - " + Server.DisplayName; }
public ManageOracleSourceViewModel(IManageDatabaseSourceModel updateManager, Task <IRequestServiceNameViewModel> requestServiceNameViewModel, IEventAggregator aggregator, IAsyncWorker asyncWorker) : base(updateManager, requestServiceNameViewModel, aggregator, asyncWorker, "Oracle") { HeaderText = Resources.Languages.Core.OracleSourceNewHeaderLabel; Header = Resources.Languages.Core.OracleSourceNewHeaderLabel; InitializeViewModel(); }
public ManageMySqlSourceViewModel(IAsyncWorker asyncWorker) : base(asyncWorker, "MySqlDatabase") { }
public SchedulerViewModel(IEventAggregator eventPublisher, DirectoryObjectPickerDialog directoryObjectPicker, IPopupController popupController, IAsyncWorker asyncWorker, IConnectControlViewModel connectControlViewModel) : base(eventPublisher) { VerifyArgument.IsNotNull("directoryObjectPicker", directoryObjectPicker); DirectoryObjectPickerDialog directoryObjectPicker1 = directoryObjectPicker; VerifyArgument.IsNotNull("popupController", popupController); _popupController = popupController; VerifyArgument.IsNotNull("asyncWorker", asyncWorker); _asyncWorker = asyncWorker; IsLoading = false; directoryObjectPicker1.AllowedObjectTypes = ObjectTypes.Users; directoryObjectPicker1.DefaultObjectTypes = ObjectTypes.Users; directoryObjectPicker1.AllowedLocations = Locations.All; directoryObjectPicker1.DefaultLocations = Locations.JoinedDomain; directoryObjectPicker1.MultiSelect = false; directoryObjectPicker1.TargetComputer = string.Empty; directoryObjectPicker1.ShowAdvancedView = false; InitializeHelp(); var taskServiceConvertorFactory = new TaskServiceConvertorFactory(); SchedulerFactory = new ClientSchedulerFactory(new Dev2TaskService(taskServiceConvertorFactory), taskServiceConvertorFactory); ConnectControlViewModel = connectControlViewModel ?? new ConnectControlViewModel(OnServerChanged, "Server: ", false); }
public ManageSqlServerSourceViewModel(IAsyncWorker asyncWorker) : base(asyncWorker, "SqlDatabase") { }
public DeployNavigationViewModel(IEventAggregator eventPublisher, IAsyncWorker asyncWorker, IEnvironmentRepository environmentRepository, IStudioResourceRepository studioResourceRepository, bool target, IConnectControlSingleton connectControlSingleton) : base(eventPublisher, asyncWorker, environmentRepository, studioResourceRepository) { _target = target; ConnectControlSingleton = connectControlSingleton; }
public MySqlDatabaseDesignerViewModel(ModelItem modelItem, IDbServiceModel model, IAsyncWorker worker, IViewPropertyBuilder propertyBuilder) : base(modelItem) { Model = model; _worker = worker; _propertyBuilder = propertyBuilder; SetupCommonProperties(); }
public MergePreviewWorkflowDesignerViewModel(IWorkflowDesignerWrapper workflowDesignerHelper, IEventAggregator eventPublisher, IContextualResourceModel resource, IWorkflowHelper workflowHelper, IPopupController popupController, IAsyncWorker asyncWorker, bool createDesigner, bool liteInit) : base(eventPublisher, resource, workflowHelper, popupController, asyncWorker, createDesigner, liteInit) { }
public void Load(Guid environmentId, IAsyncWorker asyncWorker, Action<Guid> onCompletion) { if(asyncWorker == null) { throw new ArgumentNullException("asyncWorker"); } var environmentRepository = GetEnvironmentRepository(); if(!_isRegistered) { _isRegistered = true; } // ReSharper disable ImplicitlyCapturedClosure IEnvironmentModel environmentModel = environmentRepository.FindSingle(c => c.ID == environmentId); // ReSharper restore ImplicitlyCapturedClosure if(environmentModel != null) { if(!environmentModel.IsConnected) { // ReSharper disable ImplicitlyCapturedClosure asyncWorker.Start(environmentModel.Connect, () => LoadEnvironmentTree(environmentId, onCompletion, environmentModel), e => onCompletion(environmentId)); // ReSharper restore ImplicitlyCapturedClosure } else { asyncWorker.Start(()=>{}, () => LoadEnvironmentTree(environmentId, onCompletion, environmentModel), e => onCompletion(environmentId)); } } }
public void ClientClosed(IAsyncWorker worker) { if (this.fWorkers == null) return; lock (this.fWorkers) { this.fWorkers.Remove(worker); } }
public MainViewModelMock(IEventAggregator eventPublisher, IAsyncWorker asyncWorker, IEnvironmentRepository environmentRepository, IVersionChecker versionChecker, IStudioResourceRepository studioResourceRepository, IConnectControlSingleton connectControlSingleton, IConnectControlViewModel connectControlViewModel, bool createDesigners = true, IBrowserPopupController browserPopupController = null) : base(eventPublisher, asyncWorker, environmentRepository, versionChecker, createDesigners, browserPopupController, studioResourceRepository:studioResourceRepository, connectControlSingleton:connectControlSingleton, connectControlViewModel: connectControlViewModel) { }
// ReSharper disable MemberCanBeProtected.Global public ServerProxy(string serverUri, ICredentials credentials, IAsyncWorker worker) { _wrappedConnection = new ServerProxyWithoutChunking(serverUri,credentials,worker); SetupPassthroughEvents(); }
public TestSettingsViewModel(IEventAggregator eventPublisher, IPopupController popupController, IAsyncWorker asyncWorker, IWin32Window parentWindow) : base(eventPublisher, popupController, asyncWorker, parentWindow, new Mock<IConnectControlViewModel>().Object) { }
static DeployNavigationViewModel CreateDeployNavigationViewModel(IEnvironmentModel environmentModel, IEventAggregator eventAggregator, IAsyncWorker asyncWorker, IEnvironmentRepository environmentRepository, StudioResourceRepository studioResourceRepository) { DeployNavigationViewModel navigationViewModel = new DeployNavigationViewModel(eventAggregator, asyncWorker, environmentRepository, studioResourceRepository, true, new Mock<IConnectControlSingleton>().Object) { Environment = environmentModel }; return navigationViewModel; }
public ExplorerItemModel(IConnectControlSingleton connectControlSingleton, IStudioResourceRepository studioResourceRepository) { Children = new ObservableCollection<IExplorerItemModel>(); _isAuthorized = true; _isConnected = true; _studioResourceRepository = studioResourceRepository; Children.CollectionChanged -= ChildrenCollectionChanged; Children.CollectionChanged += ChildrenCollectionChanged; _asyncWorker = new AsyncWorker(); _activityNames = new Dictionary<ResourceType, Type> { { ResourceType.DbService, typeof(DsfDatabaseActivity) }, { ResourceType.PluginService, typeof(DsfPluginActivity) }, { ResourceType.WebService, typeof(DsfWebserviceActivity) } }; _connectControlSingleton = connectControlSingleton; _connectControlSingleton.ConnectedStatusChanged += ConnectedStatusChanged; ToggleVersionHistoryHeader = "Show Version History"; }
public ExplorerItemModel(IStudioResourceRepository studioResourceRepository, IAsyncWorker asyncWorker, IConnectControlSingleton connectControlSingleton) : this(connectControlSingleton, studioResourceRepository) { _studioResourceRepository = studioResourceRepository; _asyncWorker = asyncWorker; _connectControlSingleton = connectControlSingleton; }
public SchedulerViewModelForTest(IEventAggregator eventPublisher, DirectoryObjectPickerDialog directoryObjectPicker, IPopupController popupController, IAsyncWorker asyncWorker) : base(eventPublisher, directoryObjectPicker, popupController, asyncWorker, new Mock<IConnectControlViewModel>().Object) { }
public MainViewModelPersistenceMock(IEnvironmentRepository environmentRepository,IAsyncWorker asyncWorker, bool createDesigners = true) : base(new Mock<IEventAggregator>().Object, asyncWorker, environmentRepository, new VersionChecker(), createDesigners, studioResourceRepository: new Mock<IStudioResourceRepository>().Object, connectControlSingleton: new Mock<IConnectControlSingleton>().Object, connectControlViewModel: new Mock<IConnectControlViewModel>().Object) { }
public SharePointFileDownLoadDesignerViewModel(ModelItem modelItem, IAsyncWorker asyncWorker, IServer envModel) : base(modelItem, asyncWorker, envModel, EventPublishers.Aggregator, false) { HelpText = Warewolf.Studio.Resources.Languages.HelpText.Tool_SharePoint_Download_File; }
public void Load(Guid environmentId, IAsyncWorker asyncWorker) { Load(environmentId, asyncWorker, id => { }); }
static DeployNavigationViewModel CreateDeployNavigationViewModel(IEnvironmentModel environmentModel, IEventAggregator eventAggregator, IAsyncWorker asyncWorker, IEnvironmentRepository environmentRepository, StudioResourceRepository studioResourceRepository) { DeployNavigationViewModel navigationViewModel = new DeployNavigationViewModel(eventAggregator, asyncWorker, environmentRepository, studioResourceRepository, true, new Mock <IConnectControlSingleton>().Object) { Environment = environmentModel }; return(navigationViewModel); }
// ReSharper disable TooManyDependencies public SchedulerViewModelForTesting(IEventAggregator eventPublisher, DirectoryObjectPickerDialog directoryObjectPicker, IPopupController popupController, IAsyncWorker asyncWorker) // ReSharper restore TooManyDependencies : base(eventPublisher, directoryObjectPicker, popupController, asyncWorker, new Mock<IConnectControlViewModel>().Object) { }
public ManageSqlServerSourceViewModel(IManageDatabaseSourceModel updateManager, Task <IRequestServiceNameViewModel> requestServiceNameViewModel, IEventAggregator aggregator, IAsyncWorker asyncWorker) : base(updateManager, requestServiceNameViewModel, aggregator, asyncWorker, "SqlDatabase") { HeaderText = Resources.Languages.Core.SqlServerSourceServerNewHeaderLabel; Header = Resources.Languages.Core.SqlServerSourceServerNewHeaderLabel; }
// ReSharper disable TooManyDependencies public SettingsViewModelForTest(IEventAggregator eventPublisher, IPopupController popupController, // ReSharper restore TooManyDependencies IAsyncWorker asyncWorker, IWin32Window parentWindow) : base(eventPublisher, popupController, asyncWorker, parentWindow, new Mock<IConnectControlViewModel>().Object) { }
public TestResourcePickerDialog(enDsfActivityType activityType, IEnvironmentRepository environmentRepository, IEventAggregator eventPublisher, IAsyncWorker asyncWorker, bool isFromDrop, IStudioResourceRepository studioResourceRepository) : base(activityType, environmentRepository, eventPublisher, asyncWorker, isFromDrop, studioResourceRepository, new Mock<IConnectControlSingleton>().Object) { }
public ManageMySqlSourceViewModel(IManageDatabaseSourceModel updateManager, IEventAggregator aggregator, IDbSource dbSource, IAsyncWorker asyncWorker) : base(updateManager, aggregator, dbSource, asyncWorker, "MySqlDatabase") { VerifyArgument.IsNotNull("mySqlSource", dbSource); }
public RuntimeServiceBuilder RegisterAsyncWorker(IAsyncWorker worker) { context.Register(worker); return this; }
public ManageOracleSourceViewModel(IAsyncWorker asyncWorker) : base(asyncWorker, "Oracle") { }
public ServiceDesignerViewModel(ModelItem modelItem, IContextualResourceModel rootModel, IEnvironmentRepository environmentRepository, IEventAggregator eventPublisher, IAsyncWorker asyncWorker) : base(modelItem) { AddTitleBarEditToggle(); AddTitleBarMappingToggle(); // PBI 6690 - 2013.07.04 - TWR : added // BUG 9634 - 2013.07.17 - TWR : resourceModel may be null if it is a remote resource whose environment is not connected! VerifyArgument.IsNotNull("rootModel", rootModel); VerifyArgument.IsNotNull("environmentRepository", environmentRepository); VerifyArgument.IsNotNull("eventPublisher", eventPublisher); VerifyArgument.IsNotNull("asyncWorker", asyncWorker); _worker = asyncWorker; _eventPublisher = eventPublisher; eventPublisher.Subscribe(this); ButtonDisplayValue = DoneText; ShowExampleWorkflowLink = Visibility.Collapsed; RootModel = rootModel; DesignValidationErrors = new ObservableCollection <IErrorInfo>(); FixErrorsCommand = new DelegateCommand(o => { FixErrors(); IsFixed = IsWorstErrorReadOnly; }); DoneCommand = new DelegateCommand(o => Done()); DoneCompletedCommand = new DelegateCommand(o => DoneCompleted()); InitializeDisplayName(); InitializeProperties(); InitializeImageSource(); IsAsyncVisible = ActivityTypeToActionTypeConverter.ConvertToActionType(Type) == Common.Interfaces.Core.DynamicServices.enActionType.Workflow; OutputMappingEnabled = !RunWorkflowAsync; // When the active environment is not local, we need to get smart around this piece of logic. // It is very possible we are treating a remote active as local since we cannot logically assign // an environment id when this is the case as it will fail with source not found since the remote // does not contain localhost's connections ;) var activeEnvironment = environmentRepository.ActiveEnvironment; if (EnvironmentID == Guid.Empty && !activeEnvironment.IsLocalHostCheck()) { _environment = activeEnvironment; } else { var environment = environmentRepository.FindSingle(c => c.ID == EnvironmentID); if (environment == null) { IList <IEnvironmentModel> environments = EnvironmentRepository.Instance.LookupEnvironments(activeEnvironment); environment = environments.FirstOrDefault(model => model.ID == EnvironmentID); } _environment = environment; } InitializeValidationService(_environment); if (!InitializeResourceModel(_environment)) { return; } if (!IsDeleted) { // MUST InitializeMappings() first! InitializeMappings(); InitializeLastValidationMemo(_environment); if (IsItemDragged.Instance.IsDragged) { Expand(); IsItemDragged.Instance.IsDragged = false; } } if (_environment != null) { _environment.AuthorizationServiceSet += OnEnvironmentOnAuthorizationServiceSet; AuthorizationServiceOnPermissionsChanged(null, null); } }
public ManageOracleSourceViewModel(IManageDatabaseSourceModel updateManager, IEventAggregator aggregator, IDbSource dbSource, IAsyncWorker asyncWorker) : base(updateManager, aggregator, dbSource, asyncWorker, "Oracle") { VerifyArgument.IsNotNull("oracleSource", dbSource); InitializeViewModel(); }
static IExplorerItemModel SetupExplorerItemModelWithFolderAndOneChild(string displayName, Guid envID, Guid resourceId, out IExplorerItemModel resourceItem, IStudioResourceRepository rep, IAsyncWorker worker, IConnectControlSingleton connectControlSingleton) { var serverItem = new ExplorerItemModel(rep, worker, connectControlSingleton) { ResourceType = ResourceType.Server, DisplayName = displayName, ResourceId = Guid.Empty, Permissions = Permissions.Administrator, EnvironmentId = envID }; var folderItem = new ExplorerItemModel(rep, worker, connectControlSingleton) { ResourceType = ResourceType.Folder, DisplayName = Guid.NewGuid().ToString(), ResourceId = Guid.Empty, Permissions = Permissions.Administrator, EnvironmentId = envID }; resourceItem = new ExplorerItemModel(rep, worker, connectControlSingleton) { ResourceType = ResourceType.WorkflowService, DisplayName = Guid.NewGuid().ToString(), ResourceId = resourceId, Permissions = Permissions.Administrator, EnvironmentId = envID, ResourcePath = "Path", IsExplorerSelected = true, Parent = folderItem }; folderItem.Children.Add(resourceItem); serverItem.Children.Add(folderItem); return serverItem; }