public async Task <IExplorerItem> Load(bool reloadCatalogue, IPopupController popupController) { if (!Connection.IsConnected) { ShowServerDisconnectedPopup(); return(new ServerExplorerItem()); } var comsController = CommunicationControllerFactory.CreateController("FetchExplorerItemsService"); comsController.AddPayloadArgument("ReloadResourceCatalogue", reloadCatalogue.ToString()); if (Connection.IsLocalHost) { var result = await comsController.ExecuteCompressedCommandAsync <IExplorerItem>(Connection, GlobalConstants.ServerWorkspaceID).ConfigureAwait(true); return(result); } else { var fetchExplorerTask = comsController.ExecuteCompressedCommandAsync <IExplorerItem>(Connection, GlobalConstants.ServerWorkspaceID); var delayTask = Task.Delay(60000).ContinueWith((t) => { if (fetchExplorerTask.Status != TaskStatus.RanToCompletion) { popupController?.Show(string.Format(ErrorResource.ServerBusyError, Connection.DisplayName), ErrorResource.ServerBusyHeader, MessageBoxButton.OK, MessageBoxImage.Warning, "", false, false, true, false, false, false); } }, System.Threading.Tasks.TaskScheduler.FromCurrentSynchronizationContext()); var result = await fetchExplorerTask.ConfigureAwait(true); return(result); } }
private void ConnectionRetry() { HubConnection.Stop(new TimeSpan(0, 0, 0, 1)); IPopupController popup = CustomContainer.Get <IPopupController>(); var application = Application.Current; MessageBoxResult res = MessageBoxResult.No; if (application != null && application.Dispatcher != null) { application.Dispatcher.Invoke(() => { res = popup.ShowConnectionTimeoutConfirmation(DisplayName); }); } if (res == MessageBoxResult.Yes) { if (!HubConnection.Start().Wait(5000)) { ConnectionRetry(); } } else { throw new NotConnectedException(); } }
/* * DELETE THIS METHOD AND LOOSE A VERY IMPORTANT PART OF YOU ;) * * IT IS REQUIRED FOR UPDATES IN RELEASE MODE ;) * REMOVING IT MEANS IT IS NOT POSSIBLE TO BUILD AN INSTALLER ;) */ // ReSharper disable once UnusedMember.Local private bool CheckWindowsService() { IWindowsServiceManager windowsServiceManager = CustomContainer.Get <IWindowsServiceManager>(); IPopupController popup = CustomContainer.Get <IPopupController>(); ServerServiceConfiguration ssc = new ServerServiceConfiguration(windowsServiceManager, popup); if (ssc.DoesServiceExist()) { if (ssc.IsServiceRunning()) { return(true); } if (ssc.PromptUserToStartService()) { if (ssc.StartService()) { _serverServiceStartedFromStudio = true; return(true); } } } return(false); }
public WorkSurfaceContextViewModel(IEventAggregator eventPublisher, WorkSurfaceKey workSurfaceKey, IWorkSurfaceViewModel workSurfaceViewModel, IPopupController popupController, Action <IContextualResourceModel, bool, System.Action> saveDialogAction) : base(eventPublisher) { if (workSurfaceKey == null) { throw new ArgumentNullException(nameof(workSurfaceKey)); } if (workSurfaceViewModel == null) { throw new ArgumentNullException(nameof(workSurfaceViewModel)); } VerifyArgument.IsNotNull("popupController", popupController); WorkSurfaceKey = workSurfaceKey; WorkSurfaceViewModel = workSurfaceViewModel; _windowManager = CustomContainer.Get <IWindowManager>(); var model = WorkSurfaceViewModel as IWorkflowDesignerViewModel; if (model != null) { model.WorkflowChanged += UpdateForWorkflowChange; _server = model.Server; if (_server != null) { _server.IsConnectedChanged += EnvironmentModelOnIsConnectedChanged(); _server.Connection.ReceivedResourceAffectedMessage += OnReceivedResourceAffectedMessage; } } _popupController = popupController; _saveDialogAction = saveDialogAction; }
public WorkflowInputDataViewModel(IServiceDebugInfoModel input, Guid sessionId) { VerifyArgument.IsNotNull(@"input", input); CanDebug = true; CanViewInBrowser = true; DebugTo = new DebugTO { DataList = !string.IsNullOrEmpty(input.ResourceModel.DataList) ? input.ResourceModel.DataList : @"<DataList></DataList>", ServiceName = input.ResourceModel.ResourceName, WorkflowID = input.ResourceModel.ResourceName, WorkflowXaml = string.Empty, XmlData = input.ServiceInputData, ResourceID = input.ResourceModel.ID, ServerID = input.ResourceModel.ServerID, RememberInputs = input.RememberInputs, SessionID = sessionId }; if (input.DebugModeSetting == DebugMode.DebugInteractive) { DebugTo.IsDebugMode = true; } _resourceModel = input.ResourceModel; DisplayName = @"Debug input data"; _popupController = CustomContainer.Get <IPopupController>(); }
public PersistenceSettingsViewModel(IServer currentEnvironment, IExternalProcessExecutor processExecutor) { CurrentEnvironment = currentEnvironment ?? throw new ArgumentNullException(nameof(currentEnvironment)); _resourceRepository = CurrentEnvironment.ResourceRepository; _processExecutor = processExecutor ?? throw new ArgumentNullException(nameof(processExecutor)); var settingsData = CurrentEnvironment.ResourceRepository.GetPersistenceSettings <PersistenceSettingsData>(CurrentEnvironment); var persistenceScheduler = PersistenceSchedulers.FirstOrDefault(o => o == settingsData.PersistenceScheduler); SelectedPersistenceScheduler = persistenceScheduler; var selectedDataSource = PersistenceDataSources.FirstOrDefault(o => o.ResourceID == settingsData.PersistenceDataSource.Value); SelectedPersistenceDataSource = selectedDataSource; _encryptDataSource = settingsData.EncryptDataSource ?? true; _enable = settingsData.Enable ?? false; _prepareSchemaIfNecessary = settingsData.PrepareSchemaIfNecessary ?? true; _dashboardName = settingsData.DashboardName; _dashboardHostname = settingsData.DashboardHostname; _dashboardPort = settingsData.DashboardPort; _serverName = settingsData.ServerName; UpdateHangfireDashboardUrl(); HangfireDashboardBrowserCommand = new DelegateCommand(HangfireDashboardBrowser); _popupController = CustomContainer.Get <IPopupController>(); IsDirty = false; }
public MergeViewModel(IEventAggregator eventPublisher, IMergeWorkflowViewModel vm, IPopupController popupController, IView view) : base(eventPublisher) { ViewModel = vm; View = view; _popupController = popupController; ViewModel.PropertyChanged += (sender, args) => { var mainViewModel = CustomContainer.Get <IShellViewModel>(); if (mainViewModel != null) { ViewModelUtils.RaiseCanExecuteChanged(mainViewModel.SaveCommand); } if (args.PropertyName == "DisplayName") { NotifyOfPropertyChange(() => DisplayName); } if (args.PropertyName == "DataListViewModel") { NotifyOfPropertyChange(() => DataListViewModel); } }; }
#pragma warning disable CC0091 // Use static method #pragma warning disable CC0038 // You should use expression bodied members whenever possible. bool CheckWindowsService() #pragma warning restore CC0091 // Use static method { #if DEBUG return(true); #else IWindowsServiceManager windowsServiceManager = CustomContainer.Get <IWindowsServiceManager>(); IPopupController popup = CustomContainer.Get <IPopupController>(); ServerServiceConfiguration ssc = new ServerServiceConfiguration(windowsServiceManager, popup); if (ssc.DoesServiceExist()) { if (ssc.IsServiceRunning()) { return(true); } if (ssc.PromptUserToStartService()) { if (ssc.StartService()) { _serverServiceStartedFromStudio = true; return(true); } } } return(false); #endif }
public SchedulerViewModel(IEventAggregator eventPublisher, DirectoryObjectPickerDialog directoryObjectPicker, IPopupController popupController, IAsyncWorker asyncWorker, IServer server, Func <IServer, IServer> toEnvironmentModel, Task <IResourcePickerDialog> getResourcePicker = null) : base(eventPublisher) { SchedulerTaskManager = new SchedulerTaskManager(this, getResourcePicker); VerifyArgument.IsNotNull("directoryObjectPicker", directoryObjectPicker); DirectoryObjectPickerDialog directoryObjectPicker1 = directoryObjectPicker; VerifyArgument.IsNotNull("popupController", popupController); _popupController = popupController; VerifyArgument.IsNotNull("asyncWorker", asyncWorker); _asyncWorker = asyncWorker; _toEnvironmentModel = toEnvironmentModel ?? (a => a.ToEnvironmentModel()); Errors = new ErrorResultTO(); 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(); DebugOutputViewModel = new DebugOutputViewModel(new EventPublisher(), ServerRepository.Instance, new DebugOutputFilterStrategy()); Server = server; SetupServer(server); SetDisplayName(false); }
public SearchViewModel(IShellViewModel shellViewModel, IEventAggregator aggregator) : base(shellViewModel, aggregator, false) { _shellViewModel = shellViewModel; PopupController = shellViewModel.PopupProvider; ConnectControlViewModel = new ConnectControlViewModel(shellViewModel.LocalhostServer, aggregator, shellViewModel.ExplorerViewModel.ConnectControlViewModel.Servers); ConnectControlViewModel.ServerConnected += async(sender, server) => { await ServerConnectedAsync(sender, server).ConfigureAwait(false); }; ConnectControlViewModel.ServerDisconnected += ServerDisconnected; ConnectControlViewModel.SelectedEnvironmentChanged += UpdateServerCompareChanged; SelectedEnvironment = _environments.FirstOrDefault(); RefreshCommand = new DelegateCommand(async(o) => await RefreshEnvironment(SelectedEnvironment.ResourceId)); SearchInputCommand = new DelegateCommand((o) => SearchWarewolf()); OpenResourceCommand = new DelegateCommand((searchObject) => { var searchResult = searchObject as ISearchResult; OpenResource(searchResult); }); CanShowResults = true; SearchResults = new ObservableCollection <ISearchResult>(); Search = new Common.Search.Search(); SelectedEnvironment?.Server?.ResourceRepository?.Load(false); IsSearching = false; DisplayName = $"Search"; UpdateHelpDescriptor(Warewolf.Studio.Resources.Languages.HelpText.MenuSearchHelp); }
public DebugOutputViewModel(IEventPublisher serverEventPublisher, IServerRepository serverRepository, IDebugOutputFilterStrategy debugOutputFilterStrategy, IContextualResourceModel contextualResourceModel) { VerifyArgument.IsNotNull("serverEventPublisher", serverEventPublisher); VerifyArgument.IsNotNull("environmentRepository", serverRepository); VerifyArgument.IsNotNull("debugOutputFilterStrategy", debugOutputFilterStrategy); _serverRepository = serverRepository; _debugOutputFilterStrategy = debugOutputFilterStrategy; if (contextualResourceModel != null) { _contextualResourceModel = contextualResourceModel; ResourceID = _contextualResourceModel.ID; } IsTestView = false; _contentItems = new List <IDebugState>(); _contentItemMap = new Dictionary <Guid, IDebugTreeViewItemViewModel>(); _debugWriterSubscriptionService = new SubscriptionService <DebugWriterWriteMessage>(serverEventPublisher); _debugWriterSubscriptionService.Subscribe(msg => { Append(msg.DebugState); }); SessionID = Guid.NewGuid(); _popup = CustomContainer.Get <IPopupController>(); ClearSearchTextCommand = new Microsoft.Practices.Prism.Commands.DelegateCommand(() => SearchText = ""); AddNewTestCommand = new DelegateCommand(o => AddNewTest(EventPublishers.Aggregator), o => CanAddNewTest()); _outputViewModelUtil = new DebugOutputViewModelUtil(SessionID); }
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 WorkflowDesignerViewModelMock(IContextualResourceModel resource, IWorkflowHelper workflowHelper, IPopupController popupController, bool createDesigner = false) : base(new Mock<IEventAggregator>().Object, resource, workflowHelper, popupController, new TestAsyncWorker(), createDesigner, false, false) { _moq.SetupAllProperties(); _wd = _moq.Object; }
public AuthenticationModel( IFactory <ProxyPopupModel> proxyPopupModelFactory, IAuthenticator authenticator, IPopupController popupController ) { _modelDisposable = new CompositeDisposable(); SetProxyCommand = ReactiveCommand.Create(() => { var popupModel = proxyPopupModelFactory.Create(); popupController.Show(popupModel); }); var canSendCode = this .WhenAnyValue(x => x.PhoneNumber) .Select(phone => !string.IsNullOrWhiteSpace(phone)); SendCodeCommand = ReactiveCommand.CreateFromObservable( () => authenticator.SetPhoneNumber(PhoneNumber), canSendCode, RxApp.MainThreadScheduler); var canCheckCode = this .WhenAnyValue(x => x.ConfirmCode) .Select(code => !string.IsNullOrWhiteSpace(code)); CheckCodeCommand = ReactiveCommand.CreateFromObservable( () => authenticator.CheckCode(ConfirmCode, FirstName, LastName), canCheckCode, RxApp.MainThreadScheduler); var canCheckPassword = this .WhenAnyValue(x => x.Password) .Select(password => !string.IsNullOrWhiteSpace(password)); CheckPasswordCommand = ReactiveCommand.CreateFromObservable( () => authenticator.CheckPassword(Password), canCheckPassword, RxApp.MainThreadScheduler); var stateObservable = authenticator .ObserveState() .ObserveOn(RxApp.MainThreadScheduler); stateObservable .OfType <TdApi.AuthorizationState.AuthorizationStateWaitPhoneNumber>() .Subscribe(state => OnWaitingPhoneNumber()) .DisposeWith(_modelDisposable); stateObservable .OfType <TdApi.AuthorizationState.AuthorizationStateWaitCode>() .Subscribe(state => OnWaitingConfirmCode(!state.IsRegistered)) .DisposeWith(_modelDisposable); stateObservable .OfType <TdApi.AuthorizationState.AuthorizationStateWaitPassword>() .Subscribe(state => OnWaitingPassword()) .DisposeWith(_modelDisposable); }
public DependencyVisualiserViewModel(DependencyVisualiserView view, IServer server, bool getDependsOnMe) : base(EventPublishers.Aggregator) { _view = view; _server = server; GetDependsOnMe = getDependsOnMe; GetDependsOnOther = !GetDependsOnMe; NestingLevel = "0"; _popupController = new PopupController(); }
public static IDisposable BindProxySettings( this AuthenticationModel model, IPopupController popupController) { model.SetProxyCommand = ReactiveCommand.Create( () => popupController.Show(new ProxyPopupContext()), null, RxApp.MainThreadScheduler); return(Disposable.Empty); }
public PopupModel( PopupKind popupKind, IPopupController popupController ) { PopupTitle = ""; IsPopupVisible = true; PopupIndex = (int)popupKind; PopupCloseCommand = ReactiveCommand.Create(popupController.Hide); }
internal static void IntellisenseTextBoxTabInsertedEvent(object sender, RoutedEventArgs e) { Application.Current.Dispatcher.BeginInvoke(new Action(() => { IPopupController popup = CustomContainer.Get <IPopupController>(); popup.Show("You have pasted text which contins tabs into a textbox on the design surface. Tabs are not allowed in textboxes on the design surface and will be replaced with spaces. " + Environment.NewLine + Environment.NewLine + "Please note that tabs are fully supported but the runtime, in variables and when reading from files.", "Tabs Pasted", MessageBoxButton.OK, MessageBoxImage.Information, GlobalConstants.Dev2MessageBoxDesignSurfaceTabPasteDialog); }), null); }
public static IDisposable BindPopup( this PopupModel model, IPopupController popupController) { return(model.Context.CloseCommand .SubscribeOn(RxApp.TaskpoolScheduler) .ObserveOn(RxApp.MainThreadScheduler) .Accept(_ => { popupController.Hide(); })); }
void ServerDisconnectDetected(object _, IServer server) { Application.Current.Dispatcher.Invoke(() => { IPopupController controller = CustomContainer.Get <IPopupController>(); ServerDisconnected(_, server); if (!ShowServerDownError) { controller.ShowServerNotConnected(server.DisplayName); ShowServerDownError = true; } }); }
public void RemovePopupActive(IPopupController _popup) { if (popupsActive.Count == 0) { return; } popupsActive.Remove(_popup); _popup.SelfDestruction(); if (popupsActive.Count == 0) { //gpRaycaster.enabled = false; } }
public static void ShowTrustRelationshipError(IPopupController popupController, SystemException exception) { if (exception.Message.Contains("The trust relationship between this workstation and the primary domain failed")) { var popup = popupController; popup.Header = "Error connecting to server"; popup.Description = "This computer cannot contact the Domain Controller." + Environment.NewLine + "If it does not belong to a domain, please ensure it is removed from the domain in computer management."; popup.Buttons = MessageBoxButton.OK; popup.ImageType = MessageBoxImage.Error; popup.Show(); } }
/** * RemovePopupActive : remove các popup đang active ra khỏi list * */ public void RemovePopupActive(IPopupController _popup) { if (popupsActive.Count == 0) { return; } popupsActive.Remove(_popup); _popup.SelfDestruction(); if (popupsActive.Count == 0) { myCanvasGroup.alpha = 0f; myCanvasGroup.blocksRaycasts = false; } }
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); }
public QueueEventsViewModel(IServer server, IExternalProcessExecutor externalProcessExecutor, IResourcePickerDialog resourcePickerDialog) { _server = server; _resourceRepository = server.ResourceRepository; _externalProcessExecutor = externalProcessExecutor; AddWorkflowCommand = new DelegateCommand(OpenResourcePicker); _source = new EnvironmentViewModel(server, CustomContainer.Get <IShellViewModel>(), true); _currentResourcePicker = resourcePickerDialog ?? CreateResourcePickerDialog(); InitializeHelp(); PopupController = CustomContainer.Get <IPopupController>(); PopulateQueues(); AddDummyTriggerQueueView(); }
public SingleExplorerDeployViewModel(IDeployDestinationExplorerViewModel destination, IDeploySourceExplorerViewModel source, IEnumerable <IExplorerTreeItem> selectedItems, IDeployStatsViewerViewModel stats, IShellViewModel shell, IPopupController popupController, IAsyncWorker asyncWorker) { VerifyArgument.AreNotNull(new Dictionary <string, object> { { "destination", destination }, { "source", source }, { "selectedItems", selectedItems }, { "stats", stats }, { "popupController", popupController } }); _destination = destination; PopupController = popupController; _source = source; _errorMessage = ""; _source.Preselected = selectedItems; _stats = stats; _shell = shell; _stats.CalculateAction = () => { IsDeployLoading = true; ServicesCount = _stats.Services.ToString(); SourcesCount = _stats.Sources.ToString(); TestsCount = _stats.Tests.ToString(); TriggersCount = _stats.Triggers.ToString(); NewResourcesCount = _stats.NewResources.ToString(); NewTestsCount = _stats.NewTests.ToString(); NewTriggersCount = _stats.NewTriggers.ToString(); OverridesCount = _stats.Overrides.ToString(); OverridesTestsCount = _stats.OverridesTests.ToString(); OverridesTriggersCount = _stats.OverridesTriggers.ToString(); ConflictItems = _stats.Conflicts; NewItems = _stats.New; ShowConflicts = false; ViewModelUtils.RaiseCanExecuteChanged(DeployCommand); IsDeployLoading = false; }; SourceConnectControlViewModel = _source.ConnectControlViewModel; DestinationConnectControlViewModel = _destination.ConnectControlViewModel; SourceConnectControlViewModel.SelectedEnvironmentChanged += UpdateServerCompareChanged; DestinationConnectControlViewModel.SelectedEnvironmentChanged += UpdateServerCompareChanged; DeployCommand = new DelegateCommand(Deploy, () => CanDeploy); SelectDependenciesCommand = new DelegateCommand(SelectDependencies, () => CanSelectDependencies); NewResourcesViewCommand = new DelegateCommand(ViewNewResources); OverridesViewCommand = new DelegateCommand(ViewOverrides); Destination.ServerStateChanged += DestinationServerStateChanged; Destination.PropertyChanged += DestinationOnPropertyChanged; ShowConflicts = false; }
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 DeployWorksurfaceViewModel(IEventAggregator eventPublisher, SingleExplorerDeployViewModel vm, IPopupController popupController, IView view) : base(eventPublisher) { ViewModel = vm; View = view; _popupController = popupController; ViewModel.PropertyChanged += (sender, args) => { if (args.PropertyName == "Header") { OnPropertyChanged("DisplayName"); } var mainViewModel = CustomContainer.Get <IShellViewModel>(); if (mainViewModel != null) { ViewModelUtils.RaiseCanExecuteChanged(mainViewModel.SaveCommand); } }; }
static void IsConnectionValid(IEnvironmentConnection connection, IPopupController popupController) { if (connection != null) { try { if (!connection.IsConnecting) { popupController?.Show(string.Format(ErrorResource.ServerDisconnected, connection.DisplayName) + Environment.NewLine + ErrorResource.ServerReconnectForActions, ErrorResource.ServerDisconnectedHeader, MessageBoxButton.OK, MessageBoxImage.Information, "", false, false, true, false, false, false); } } catch (Exception e) { Dev2Logger.Error("Error popup", e, "Warewolf Error"); } } }
public WorkSurfaceContextViewModel(IEventAggregator eventPublisher, WorkSurfaceKey workSurfaceKey, IWorkSurfaceViewModel workSurfaceViewModel, IPopupController popupController, Action <IContextualResourceModel, bool> saveDialogAction) : base(eventPublisher) { if (workSurfaceKey == null) { throw new ArgumentNullException("workSurfaceKey"); } if (workSurfaceViewModel == null) { throw new ArgumentNullException("workSurfaceViewModel"); } VerifyArgument.IsNotNull("popupController", popupController); WorkSurfaceKey = workSurfaceKey; WorkSurfaceViewModel = workSurfaceViewModel; _windowManager = CustomContainer.Get <IWindowManager>(); _workspaceItemRepository = WorkspaceItemRepository.Instance; var model = WorkSurfaceViewModel as IWorkflowDesignerViewModel; if (model != null) { _environmentModel = model.EnvironmentModel; if (_environmentModel != null) { // MUST use connection server event publisher - debug events are published from the server! DebugOutputViewModel = new DebugOutputViewModel(_environmentModel.Connection.ServerEvents, EnvironmentRepository.Instance, new DebugOutputFilterStrategy()); _environmentModel.IsConnectedChanged += EnvironmentModelOnIsConnectedChanged(); _environmentModel.Connection.ReceivedResourceAffectedMessage += OnReceivedResourceAffectedMessage; } } if (WorkSurfaceKey.WorkSurfaceContext == WorkSurfaceContext.Scheduler) { if (DebugOutputViewModel == null) { DebugOutputViewModel = new DebugOutputViewModel(new EventPublisher(), EnvironmentRepository.Instance, new DebugOutputFilterStrategy()); } } _popupController = popupController; _saveDialogAction = saveDialogAction; }
public SingleExplorerDeployViewModel(IDeployDestinationExplorerViewModel destination, IDeploySourceExplorerViewModel source, IEnumerable <IExplorerTreeItem> selectedItems, IDeployStatsViewerViewModel stats, IShellViewModel shell, IPopupController popupController) { VerifyArgument.AreNotNull(new Dictionary <string, object> { { "destination", destination }, { "source", source }, { "selectedItems", selectedItems }, { "stats", stats }, { "popupController", popupController } }); _destination = destination; // ReSharper disable once VirtualMemberCallInContructor PopupController = popupController; _source = source; _errorMessage = ""; _source.Preselected = selectedItems; _stats = stats; _shell = shell; _stats.CalculateAction = () => { ServicesCount = _stats.Services.ToString(); SourcesCount = _stats.Sources.ToString(); NewResourcesCount = _stats.NewResources.ToString(); OverridesCount = _stats.Overrides.ToString(); ConflictItems = _stats.Conflicts; NewItems = _stats.New; ShowConflicts = false; if (!string.IsNullOrEmpty(_stats.RenameErrors)) { PopupController.ShowDeployNameConflict(_stats.RenameErrors); } ViewModelUtils.RaiseCanExecuteChanged(DeployCommand); }; SourceConnectControlViewModel = _source.ConnectControlViewModel; DestinationConnectControlViewModel = _destination.ConnectControlViewModel; SourceConnectControlViewModel.SelectedEnvironmentChanged += UpdateServerCompareChanged; DestinationConnectControlViewModel.SelectedEnvironmentChanged += UpdateServerCompareChanged; DeployCommand = new DelegateCommand(Deploy, () => CanDeploy); SelectDependenciesCommand = new DelegateCommand(SelectDependencies, () => CanSelectDependencies); NewResourcesViewCommand = new DelegateCommand(ViewNewResources); OverridesViewCommand = new DelegateCommand(ViewOverrides); Destination.ServerStateChanged += DestinationServerStateChanged; Destination.PropertyChanged += DestinationOnPropertyChanged; ShowConflicts = false; }
static TestSettingsViewModel CreateSettingsViewModel(IPopupController popupController, string executeCommandReadResult = "", string executeCommandWriteResult = "", SecurityViewModel securityViewModel = null) { var viewModel = new TestSettingsViewModel(new Mock<IEventAggregator>().Object, popupController, AsyncWorkerTests.CreateSynchronousAsyncWorker().Object, new Mock<IWin32Window>().Object) { TheSecurityViewModel = securityViewModel }; var mockResourceRepo = new Mock<IResourceRepository>(); ExecuteMessage writeMsg = null; if(!string.IsNullOrEmpty(executeCommandWriteResult)) { writeMsg = new ExecuteMessage { HasError = executeCommandWriteResult != "Success" }; writeMsg.SetMessage(executeCommandWriteResult); } mockResourceRepo.Setup(c => c.ReadSettings(It.IsAny<IEnvironmentModel>())).Returns(executeCommandReadResult == null ? null : new Dev2JsonSerializer().Deserialize<Data.Settings.Settings>(executeCommandReadResult)); mockResourceRepo.Setup(c => c.WriteSettings(It.IsAny<IEnvironmentModel>(), It.IsAny<Data.Settings.Settings>())).Returns(writeMsg); var environment = new Mock<IEnvironmentModel>(); environment.Setup(e => e.IsConnected).Returns(true); environment.Setup(c => c.ResourceRepository).Returns(mockResourceRepo.Object); Mock<IAuthorizationService> authService = new Mock<IAuthorizationService>(); authService.Setup(c => c.IsAuthorized(It.IsAny<AuthorizationContext>(), It.IsAny<string>())).Returns(true); environment.Setup(c => c.AuthorizationService).Returns(authService.Object); // simulate auto-loading of ConnectControl ComboBox viewModel.ServerChangedCommand.Execute(environment.Object); return viewModel; }
public ServerServiceConfiguration(IWindowsServiceManager serviceManager, IPopupController popupController) : this(serviceManager) { PopupController = popupController; }
// 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) { }
// 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 SchedulerViewModelForTest(IEventAggregator eventPublisher, DirectoryObjectPickerDialog directoryObjectPicker, IPopupController popupController, IAsyncWorker asyncWorker) : base(eventPublisher, directoryObjectPicker, popupController, asyncWorker, new Mock<IConnectControlViewModel>().Object) { }
public TestSettingsViewModel(IEventAggregator eventPublisher, IPopupController popupController, IAsyncWorker asyncWorker, IWin32Window parentWindow) : base(eventPublisher, popupController, asyncWorker, parentWindow, new Mock<IConnectControlViewModel>().Object) { }
public static void ShowExampleWorkflow(string activityName, IEnvironmentModel environment, IPopupController popupController) { var resourceID = GetExampleID(activityName); var resource = environment.ResourceRepository .FindSingle(r => r.ID.Equals(resourceID)); if(resource == null) { if(popupController == null) { var message = string.Format( StringResources.ExampleWorkflowNotFound, GetExampleName(activityName)); MessageBox.Show(message, "Information", MessageBoxButton.OK, MessageBoxImage.Information); } else { popupController.Buttons = MessageBoxButton.OK; popupController.Description = string.Format(StringResources.ExampleWorkflowNotFound, resourceID); popupController.Header = "Example Workflow Not Found"; popupController.ImageType = MessageBoxImage.Information; popupController.Show(); } } else { resource.ResourceType = ResourceType.WorkflowService; EditResource(resource, EventPublishers.Aggregator); } }