private void UploadFiles(IEnumerable <string> files) { try { CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); var uploadOperationsQueue = _fileOperationsEngine.StartUploadOperations( files, bucket: Bucket.Name, bucketPath: _currentState.CurrentPath, cancellationToken: cancellationTokenSource.Token); GcsFileProgressDialogWindow.PromptUser( caption: Resources.GcsFileBrowserUploadingProgressCaption, message: Resources.GcsFileBrowserUploadingProgressMessage, progressMessage: Resources.GcsFileBrowserUploadingOverallProgressMessage, operations: uploadOperationsQueue.Operations, cancellationTokenSource: cancellationTokenSource); EventsReporterWrapper.ReportEvent(GcsFileBrowserStartUploadEvent.Create(CommandStatus.Success)); } catch (IOException ex) { UserPromptUtils.ErrorPrompt( message: Resources.GcsFileProgressDialogFailedToEnumerateFiles, title: Resources.UiErrorCaption, errorDetails: ex.Message); EventsReporterWrapper.ReportEvent(GcsFileBrowserStartUploadEvent.Create(CommandStatus.Failure)); } UpdateCurrentState(); }
/// <summary> /// Prompts the user about deleting the subscription, then calls the datasource to delete it. /// </summary> internal async void OnDeleteSubscriptionCommand() { IsLoading = true; try { bool doDelete = UserPromptUtils.ActionPrompt( string.Format(Resources.PubSubDeleteSubscriptionWindowMessage, _subscriptionItem.Name), Resources.PubSubDeleteSubscriptionWindowHeader, actionCaption: Resources.UiDeleteButtonCaption); if (doDelete) { try { await DataSource.DeleteSubscriptionAsync(_subscriptionItem.FullName); EventsReporterWrapper.ReportEvent(PubSubSubscriptionDeletedEvent.Create(CommandStatus.Success)); } catch (DataSourceException e) { Debug.Write(e.Message, "Delete Subscription"); EventsReporterWrapper.ReportEvent(PubSubSubscriptionDeletedEvent.Create(CommandStatus.Failure)); UserPromptUtils.ErrorPrompt( Resources.PubSubDeleteSubscriptionErrorMessage, Resources.PubSubDeleteSubscriptionErrorHeader, e.Message); } await _owner.Refresh(); } } finally { IsLoading = false; } }
private bool Validate() { if (String.IsNullOrEmpty(UserName)) { UserPromptUtils.ErrorPrompt( Resources.AddWindowsCredentialValidationEmptyUser, Resources.AddWindowsCredentialValidationErrorTtitle); return(false); } var invalidChars = UserName.Intersect(UserNameInvalidChars).ToArray(); if (invalidChars.Length > 0) { UserPromptUtils.ErrorPrompt( String.Format(Resources.AddWindowsCredentialValidationInvalidChars, new string(invalidChars)), Resources.AddWindowsCredentialValidationErrorTtitle); return(false); } if (ManualPassword && String.IsNullOrEmpty(Password)) { UserPromptUtils.ErrorPrompt( Resources.AddWindowsCredentialValidationEmptyPassword, Resources.AddWindowsCredentialValidationErrorTtitle); return(false); } // Valid entry. return(true); }
/// <summary> /// Prompts the user for a new subscription, and creates it. /// </summary> internal async void OnNewSubscriptionCommand() { IsLoading = true; try { Subscription subscription = NewSubscriptionUserPrompt(Item.FullName); if (subscription != null) { try { await DataSource.NewSubscriptionAsync(subscription); EventsReporterWrapper.ReportEvent(PubSubSubscriptionCreatedEvent.Create(CommandStatus.Success)); await Refresh(); } catch (DataSourceException e) { Debug.Write(e.Message, "New Subscription"); EventsReporterWrapper.ReportEvent(PubSubSubscriptionCreatedEvent.Create(CommandStatus.Failure)); Owner.Refresh(); UserPromptUtils.ErrorPrompt( Resources.PubSubNewSubscriptionErrorMessage, Resources.PubSubNewSubscriptionErrorHeader, e.Message); } } } finally { IsLoading = false; } }
/// <summary> /// Prompts the user about deleting the subscription, then calls the datasource to delete it. /// </summary> private async void OnDeleteSubscriptionCommand() { IsLoading = true; try { try { bool doDelete = UserPromptUtils.ActionPrompt( string.Format(Resources.PubSubDeleteSubscriptionWindowMessage, _subscriptionItem.Name), Resources.PubSubDeleteSubscriptionWindowHeader, actionCaption: Resources.UiDeleteButtonCaption); if (doDelete) { await DataSource.DeleteSubscriptionAsync(_subscriptionItem.FullName); } } catch (DataSourceException e) { Debug.Write(e.Message, "Delete Subscription"); UserPromptUtils.ErrorPrompt( Resources.PubSubDeleteSubscriptionErrorMessage, Resources.PubSubDeleteSubscriptionErrorHeader); } await _owner.Refresh(); } finally { IsLoading = false; } }
/// <summary> /// This method will enable the list of services given. /// </summary> /// <param name="serviceNames">The list of services to enable.</param> /// <returns>A task that will be completed once the operation finishes.</returns> public async Task EnableServicesAsync(IEnumerable <string> serviceNames) { ServiceManagementDataSource dataSource = _dataSource.Value; if (dataSource == null) { return; } try { await ProgressDialogWindow.PromptUser( dataSource.EnableAllServicesAsync(serviceNames), new ProgressDialogWindow.Options { Title = Resources.ApiManagerEnableServicesTitle, Message = Resources.ApiManagerEnableServicesProgressMessage, IsCancellable = false }); } catch (DataSourceException ex) { UserPromptUtils.ErrorPrompt( message: Resources.ApiManagerEnableServicesErrorMessage, title: Resources.UiErrorCaption, errorDetails: ex.Message); } }
/// <summary> /// Prompts the user for a new subscription, and creates it. /// </summary> private async void OnNewSubscriptionCommand() { IsLoading = true; try { try { Subscription subscription = NewSubscriptionWindow.PromptUser(TopicItem.FullName); if (subscription != null) { await DataSource.NewSubscriptionAsync(subscription); } } catch (DataSourceException e) { Debug.Write(e.Message, "New Subscription"); UserPromptUtils.ErrorPrompt( Resources.PubSubNewSubscriptionErrorMessage, Resources.PubSubNewSubscriptionErrorHeader); } await Refresh(); } finally { IsLoading = false; } }
private bool GetAllProcessesList() { var dte = Shell.Package.GetGlobalService(typeof(DTE)) as DTE; var debugger = dte.Debugger as Debugger2; var transport = debugger.Transports.Item("Default"); // Show engine types EngineTypes = new List <string>(); EngineTypes.Add(Resources.AttachDebuggerAutomaticallyDetectEngineTypeItemName); foreach (var engineType in transport.Engines) { var engine = engineType as Engine; if (engine == null) { Debug.WriteLine("engine is null, might be a code bug."); continue; } EngineTypes.Add(engine.Name); } SelectedEngine = s_detectEngineTypeItemName; Processes processes = debugger.GetProcesses(transport, Context.PublicIp); _allProcesses = new List <ProcessItem>(); foreach (var process in processes) // Linq does not work on COM list { var pro2 = process as Process2; _allProcesses.Add(new ProcessItem(pro2)); } if (_allProcesses.Count == 0) { UserPromptUtils.ErrorPrompt( message: Resources.AttachDebuggerListProcessEmptyResultErrorMessage, title: Resources.UiDefaultPromptTitle); return(false); } if (!String.IsNullOrWhiteSpace(AttachDebuggerSettings.Current.DefaultDebuggeeProcessName)) { var matching = _allProcesses .Where(x => x.Name.ToLowerInvariant() == AttachDebuggerSettings.Current.DefaultDebuggeeProcessName.ToLowerInvariant()); if (!matching.Any()) { ResetDefaultSelection(); } else if (matching.Count() == 1) { Processes = matching; SelectedProcess = matching.First(); SelectedEngine = AttachDebuggerSettings.Current.DefaultDebuggerEngineType; return(true); } } Processes = _allProcesses; SelectedProcess = Processes.FirstOrDefault(); return(true); }
public void TestErrorPrompt_PromptsWithGivenTitle() { UserPromptWindow userPrompt = GetWindow(() => _objectUnderTest.ErrorPrompt(DefaultPrompt, ExpectedTitle)); Assert.AreEqual(ExpectedTitle, userPrompt.Title); }
/// <summary> /// This method will check that all given services are enabled and if not will prompt the user to enable the /// necessary services. /// </summary> /// <param name="serviceNames">The services to check.</param> /// <param name="prompt">The prompt to use in the prompt dialog to ask the user for permission to enable the services.</param> /// <returns>A task that will be true if all services where enabled, false if the user cancelled or if the operation failed.</returns> public async Task <bool> EnsureAllServicesEnabledAsync( IEnumerable <string> serviceNames, string prompt) { ServiceManagementDataSource dataSource = _dataSource.Value; if (dataSource == null) { return(false); } try { // Check all services in parallel. IList <string> servicesToEnable = (await dataSource.CheckServicesStatusAsync(serviceNames)) .Where(x => !x.Enabled) .Select(x => x.Name) .ToList(); if (servicesToEnable.Count == 0) { Debug.WriteLine("All the services are already enabled."); return(true); } // Need to enable the services, prompt the user. Debug.WriteLine($"Need to enable the services: {string.Join(",", servicesToEnable)}."); if (!UserPromptUtils.ActionPrompt( prompt: prompt, title: Resources.ApiManagerEnableServicesTitle, actionCaption: Resources.UiEnableButtonCaption)) { return(false); } // Enable all services in parallel. await ProgressDialogWindow.PromptUser( dataSource.EnableAllServicesAsync(servicesToEnable), new ProgressDialogWindow.Options { Title = Resources.ApiManagerEnableServicesTitle, Message = Resources.ApiManagerEnableServicesProgressMessage, IsCancellable = false }); return(true); } catch (DataSourceException ex) { UserPromptUtils.ErrorPrompt( message: Resources.ApiManagerEnableServicesErrorMessage, title: Resources.UiErrorCaption, errorDetails: ex.Message); return(false); } }
private void OnCopyCommand() { try { Clipboard.SetText(Password); } catch { Debug.WriteLine("Failed to copy the string to the clipboard."); UserPromptUtils.ErrorPrompt(Resources.ShowPasswordCopyFailedMessage, Resources.ShowPasswordCopyFailedTitle); } }
private bool ValidateInput() { int replicas = 0; if (!int.TryParse(Replicas, out replicas)) { UserPromptUtils.ErrorPrompt(Resources.GkePublishInvalidReplicasMessage, Resources.UiInvalidValueTitle); return(false); } return(true); }
private async void OnRenameFolderCommand() { var newLeafName = NamePromptWindow.PromptUser(new NamePromptWindow.Options { InitialName = SelectedItem.LeafName, Title = Resources.GcsFileBrowserRenameFolderTitle }); if (newLeafName == null) { return; } try { IsLoading = true; CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); var renameDirectoryOperations = await _fileOperationsEngine.StartDirectoryRenameOperationsAsync( bucket : Bucket.Name, parentName : CurrentState.CurrentPath, oldLeafName : SelectedItem.LeafName, newLeafName : newLeafName, cancellationToken : cancellationTokenSource.Token); GcsFileProgressDialogWindow.PromptUser( caption: Resources.GcsFileBrowserRenamingFilesCaption, message: Resources.GcsFileBrowserRenamingFilesMessage, progressMessage: Resources.GcsFileBrowserRenamingFilesProgressMessage, operations: renameDirectoryOperations.Operations, cancellationTokenSource: cancellationTokenSource); EventsReporterWrapper.ReportEvent(GcsFileBrowserStartRenameDirectoryEvent.Create(CommandStatus.Success)); } catch (DataSourceException ex) { UserPromptUtils.ErrorPrompt( message: string.Format(Resources.GcsFileBrowserRenameFailedMessage, SelectedItem.LeafName), title: Resources.UiErrorCaption, errorDetails: ex.Message); EventsReporterWrapper.ReportEvent(GcsFileBrowserStartRenameDirectoryEvent.Create(CommandStatus.Failure)); } finally { IsLoading = false; } UpdateCurrentState(); }
private async void OnRenameFileCommand() { var choosenName = NamePromptWindow.PromptUser(new NamePromptWindow.Options { InitialName = SelectedItem.LeafName, Title = Resources.GcsFileBrowserRenameFileTitle }); if (choosenName == null) { return; } try { IsLoading = true; var newName = GcsPathUtils.Combine(CurrentState.CurrentPath, choosenName); Debug.WriteLine($"Renaming {SelectedItem.BlobName} to {newName}"); await ProgressDialogWindow.PromptUser( _dataSource.MoveFileAsync( bucket: Bucket.Name, sourceName: SelectedItem.BlobName, destName: newName), new ProgressDialogWindow.Options { Message = Resources.GcsFileBrowserRenamingProgressMessage, Title = Resources.UiDefaultPromptTitle, IsCancellable = false }); EventsReporterWrapper.ReportEvent(GcsFileBrowserRenameFileEvent.Create(CommandStatus.Success)); } catch (DataSourceException ex) { UserPromptUtils.ErrorPrompt( message: string.Format(Resources.GcsFileBrowserRenameFailedMessage, SelectedItem.LeafName), title: Resources.UiErrorCaption, errorDetails: ex.Message); EventsReporterWrapper.ReportEvent(GcsFileBrowserRenameFileEvent.Create(CommandStatus.Failure)); } finally { IsLoading = false; } UpdateCurrentState(); }
private async void OnDownloadCommand() { FBD dialog = new FBD(); dialog.Description = Resources.GcsFileBrowserFolderSelectionMessage; dialog.ShowNewFolderButton = true; var result = dialog.ShowDialog(); if (result == System.Windows.Forms.DialogResult.Cancel) { return; } var downloadRoot = dialog.SelectedPath; try { IsLoading = true; CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); var downloadOperationsQueue = await _fileOperationsEngine.StartDownloadOperationsAsync( SelectedItems.Select(x => new GcsUtils.GcsItemRef(x.Bucket, x.BlobName)), downloadRoot, cancellationTokenSource.Token); GcsFileProgressDialogWindow.PromptUser( caption: Resources.GcsFileBrowserDownloadingProgressCaption, message: Resources.GcsFileBrowserDownloadingProgressMessage, progressMessage: Resources.GcsFileBrowserDownloadingOverallProgressMessage, operations: downloadOperationsQueue.Operations, cancellationTokenSource: cancellationTokenSource); EventsReporterWrapper.ReportEvent(GcsFileBrowserStartDownloadEvent.Create(CommandStatus.Success)); } catch (IOException ex) { UserPromptUtils.ErrorPrompt( message: Resources.GcsFileBrowserFailedToCreateDirMessage, title: Resources.UiErrorCaption, errorDetails: ex.Message); EventsReporterWrapper.ReportEvent(GcsFileBrowserStartDownloadEvent.Create(CommandStatus.Failure)); return; } finally { IsLoading = false; } }
/// <summary> /// Repeatedly make list log entries request till it gets desired number of logs or it reaches end. /// _nextPageToken is used to control if it is getting first page or continuous page. /// /// On complex filters, scanning through logs take time. The server returns empty results /// with a next page token. Continue to send request till some logs are found. /// </summary> /// <param name="cancellationToken">A cancellation token. The caller can monitor the cancellation event.</param> /// <param name="autoReload">Indicate if the request comes from autoReload event.</param> private async Task LoadLogsAsync(CancellationToken cancellationToken, bool autoReload = false) { if (_logs.Count >= MaxLogEntriesCount) { UserPromptUtils.ErrorPrompt( message: Resources.LogViewerResultSetTooLargeMessage, title: Resources.UiDefaultPromptTitle); _cancellationTokenSource?.Cancel(); return; } try { var startTimestamp = DateTime.Now; var order = DateTimePickerModel.IsDescendingOrder ? "timestamp desc" : "timestamp asc"; int count = 0; while (count < DefaultPageSize && !cancellationToken.IsCancellationRequested) { Debug.WriteLine($"LoadLogs, count={count}, firstPage={_nextPageToken == null}"); // Here, it does not do pageSize: _defaultPageSize - count, // Because this is requried to use same page size for getting next page. var results = await _dataSource.Value.ListLogEntriesAsync(_filter, order, pageSize : DefaultPageSize, nextPageToken : _nextPageToken, cancelToken : cancellationToken); _nextPageToken = results.NextPageToken; if (results?.LogEntries != null) { count += results.LogEntries.Count; AddLogs(results.LogEntries, autoReload); } if (String.IsNullOrWhiteSpace(_nextPageToken)) { _nextPageToken = null; break; } } EventsReporterWrapper.ReportEvent(LogsViewerLogsLoadedEvent.Create(CommandStatus.Success, DateTime.Now - startTimestamp)); } catch (Exception ex) when(!ErrorHandlerUtils.IsCriticalException(ex)) { EventsReporterWrapper.ReportEvent(LogsViewerLogsLoadedEvent.Create(CommandStatus.Failure)); throw; } }
/// <summary> /// Validates the input. Prompts the user on validation errors. /// </summary> /// <returns>Returns true if validation succeded, false if the user had to be prompted</returns> private bool ValidateInput() { var results = PubSubNameValidationRule.Validate(TopicName, Resources.NewTopicWindowNameFieldName); var details = String.Join("\n", results.Select(result => result.Message)); if (!String.IsNullOrEmpty(details)) { string message = String.Format(Resources.PubSubNewTopicNameInvalidMessage, TopicName); UserPromptUtils.ErrorPrompt(message, Resources.PubSubNewTopicNameInvalidTitle, details); return(false); } else { return(true); } }
private bool Validate() { if (String.IsNullOrEmpty(Name)) { UserPromptUtils.ErrorPrompt(Resources.NamePromptEmptyNameMessage, Resources.UiErrorCaption); return(false); } if (Name.Contains('/')) { UserPromptUtils.ErrorPrompt(Resources.NamePromptInvalidCharsMessage, Resources.UiErrorCaption); return(false); } return(true); }
/// <summary> /// This function is the callback used to execute the command when the menu item is clicked. /// See the constructor to see how the menu item is associated with this function using /// OleMenuCommandService service and MenuCommand class. /// </summary> /// <param name="sender">Event sender.</param> /// <param name="e">Event args.</param> private void OnGenerateConfiguration(object sender, EventArgs e) { ErrorHandlerUtils.HandleExceptions(() => { var selectedProject = SolutionHelper.CurrentSolution.SelectedProject; Debug.WriteLine($"Generating configuration for project: {selectedProject.FullPath}"); var configurationStatus = AppEngineFlexDeployment.CheckProjectConfiguration(selectedProject); // If the app.yaml already exists allow the user to skip its generation to preserve the existing file. if (!configurationStatus.HasAppYaml || UserPromptUtils.ActionPrompt( prompt: Resources.GenerateConfigurationAppYamlOverwriteMessage, title: Resources.GenerateConfigurationOverwritePromptTitle, actionCaption: Resources.UiOverwriteButtonCaption, cancelCaption: Resources.UiSkipFileButtonCaption)) { Debug.WriteLine($"Generating app.yaml for {selectedProject.FullPath}"); if (!AppEngineFlexDeployment.GenerateAppYaml(selectedProject)) { UserPromptUtils.ErrorPrompt( String.Format(Resources.GenerateConfigurationFileGenerationErrorMessage, AppEngineFlexDeployment.AppYamlName), Resources.GenerateConfigurationFileGeneratinErrorTitle); return; } GcpOutputWindow.OutputLine(Resources.GenerateConfigurationAppYamlGeneratedMessage); } // If the Dockerfile already exists allow the user to skip its generation to preserve the existing file. if (!configurationStatus.HasDockerfile || UserPromptUtils.ActionPrompt( prompt: Resources.GenerateConfigurationDockerfileOverwriteMessage, title: Resources.GenerateConfigurationOverwritePromptTitle, actionCaption: Resources.UiOverwriteButtonCaption, cancelCaption: Resources.UiSkipFileButtonCaption)) { Debug.WriteLine($"Generating Dockerfile for {selectedProject.FullPath}"); if (!AppEngineFlexDeployment.GenerateDockerfile(selectedProject)) { UserPromptUtils.ErrorPrompt( String.Format(Resources.GenerateConfigurationFileGenerationErrorMessage, AppEngineFlexDeployment.DockerfileName), Resources.GenerateConfigurationFileGeneratinErrorTitle); return; } GcpOutputWindow.OutputLine(Resources.GenerateConfigurationDockerfileGeneratedMessage); } }); }
private async Task <WindowsInstanceCredentials> CreateOrResetCredentials(string user) { try { Debug.WriteLine("The user requested the password to be generated."); if (!UserPromptUtils.ActionPrompt( prompt: String.Format(Resources.ResetPasswordConfirmationPromptMessage, user, _instance.Name), title: Resources.ResetPasswordConfirmationPromptTitle, message: Resources.UiOperationCannotBeUndone, actionCaption: Resources.UiResetButtonCaption, isWarning: true)) { Debug.WriteLine("The user cancelled resetting the password."); return(null); } Debug.WriteLine($"Resetting the password for the user {user}"); // Check that gcloud is in the right state to invoke the reset credentials method. if (!await VerifyGCloudDependencies()) { Debug.WriteLine("Missing gcloud dependencies for resetting password."); return(null); } var context = new GCloudContext { CredentialsPath = CredentialsStore.Default.CurrentAccountPath, ProjectId = CredentialsStore.Default.CurrentProjectId, AppName = GoogleCloudExtensionPackage.ApplicationName, AppVersion = GoogleCloudExtensionPackage.ApplicationVersion, }; return(await GCloudWrapper.ResetWindowsCredentialsAsync( instanceName : _instance.Name, zoneName : _instance.GetZoneName(), userName : user, context : context)); } catch (GCloudException ex) { UserPromptUtils.ErrorPrompt( message: String.Format(Resources.ResetPasswordFailedPromptMessage, _instance.Name), title: Resources.ResetPasswordConfirmationPromptTitle, errorDetails: ex.Message); return(null); } }
private bool ValidateInput() { if (String.IsNullOrEmpty(Version)) { UserPromptUtils.ErrorPrompt(Resources.FlexPublishEmptyVersionMessage, Resources.UiInvalidValueTitle); return(false); } if (!GcpPublishStepsUtils.IsValidName(Version)) { UserPromptUtils.ErrorPrompt( String.Format(Resources.FlexPublishInvalidVersionMessage, Version), Resources.UiInvalidValueTitle); return(false); } return(true); }
private async void OnDeleteCommand() { if (!UserPromptUtils.ActionPrompt( prompt: Resources.GcsFileBrowserDeletePromptMessage, title: Resources.UiDefaultPromptTitle, actionCaption: Resources.UiDeleteButtonCaption, cancelCaption: Resources.UiCancelButtonCaption)) { return; } try { IsLoading = true; var cancellationTokenSource = new CancellationTokenSource(); var deleteOperationsQueue = await _fileOperationsEngine.StartDeleteOperationsAsync( SelectedItems.Select(x => new GcsItemRef(x.Bucket, x.BlobName)), cancellationTokenSource.Token); GcsFileProgressDialogWindow.PromptUser( caption: Resources.GcsFileBrowserDeletingProgressCaption, message: Resources.GcsFileBrowserDeletingProgressMessage, progressMessage: Resources.GcsFileBrowserDeletingOverallProgressMessage, operations: deleteOperationsQueue.Operations, cancellationTokenSource: cancellationTokenSource); EventsReporterWrapper.ReportEvent(GcsFileBrowserStartDeleteEvent.Create(CommandStatus.Success)); } catch (DataSourceException ex) { UserPromptUtils.ErrorPrompt( message: Resources.GcsFileBrowserDeleteListErrorMessage, title: Resources.UiErrorCaption, errorDetails: ex.Message); EventsReporterWrapper.ReportEvent(GcsFileBrowserStartDeleteEvent.Create(CommandStatus.Failure)); } finally { IsLoading = false; } UpdateCurrentState(); }
/// <summary> /// projectRepos is used to cache the list of 'cloud repos' of the project-id. /// </summary> private async Task AddLocalReposAsync(IList <GitRepository> localRepos, IList <Project> projects) { List <string> dataSourceErrorProjects = new List <string>(); Dictionary <string, IList <Repo> > projectRepos = new Dictionary <string, IList <Repo> >(StringComparer.OrdinalIgnoreCase); foreach (var localGitRepo in localRepos) { IList <string> remoteUrls = await localGitRepo.GetRemotesUrls(); foreach (var url in remoteUrls) { string projectId = CsrUtils.ParseProjectId(url); var project = projects.FirstOrDefault(x => x.ProjectId == projectId); if (String.IsNullOrWhiteSpace(projectId) || project == null) { continue; } try { var cloudRepo = await TryGetCloudRepoAsync(url, projectId, projectRepos); if (cloudRepo == null) { Debug.WriteLine($"{projectId} repos does not contain {url}"); continue; } Repositories.Add(new RepoItemViewModel(cloudRepo, localGitRepo.Root)); break; } catch (DataSourceException) { dataSourceErrorProjects.Add(project.Name); } } } if (dataSourceErrorProjects.Any()) { UserPromptUtils.ErrorPrompt( message: String.Format( Resources.CsrFetchReposErrorMessage, String.Join(", ", dataSourceErrorProjects)), title: Resources.CsrConnectSectionTitle); } }
private async Task CloneAsync() { if (IsDefaultLocation(LocalPath) && !Directory.Exists(s_defaultLocalPath)) { Directory.CreateDirectory(s_defaultLocalPath); } // If OkCommand is enabled, SelectedRepository and LocalPath is valid string destPath = Path.Combine(LocalPath, SelectedRepository.GetRepoName()); if (!CsrGitUtils.StoreCredential( SelectedRepository.Url, CredentialsStore.Default.CurrentAccount.RefreshToken, CsrGitUtils.StoreCredentialPathOption.UrlPath)) { UserPromptUtils.ErrorPrompt( message: Resources.CsrCloneFailedToSetCredentialMessage, title: Resources.UiDefaultPromptTitle); return; } try { var watch = Stopwatch.StartNew(); GitRepository localRepo = await CsrGitUtils.CloneAsync(SelectedRepository.Url, destPath); Result = new CloneDialogResult { RepoItem = new RepoItemViewModel(SelectedRepository, localRepo.Root), JustCreatedRepo = _newReposList.Contains(SelectedRepository.Name) }; _closeOwnerFunc(); EventsReporterWrapper.ReportEvent( CsrClonedEvent.Create(CommandStatus.Success, watch.Elapsed)); } catch (GitCommandException) { UserPromptUtils.ErrorPrompt( message: Resources.CsrCloneFailedMessage, title: Resources.UiDefaultPromptTitle); EventsReporterWrapper.ReportEvent(CsrClonedEvent.Create(CommandStatus.Failure)); return; } }
/// <summary> /// Opens the new pub sub topic dialog. /// </summary> private async void OnNewTopicCommand() { try { string topicName = NewTopicWindow.PromptUser(CurrentProjectId); if (topicName != null) { await DataSource.NewTopicAsync(topicName); Refresh(); } } catch (DataSourceException e) { Debug.Write(e.Message, "New Topic"); UserPromptUtils.ErrorPrompt( Resources.PubSubNewTopicErrorMessage, Resources.PubSubNewTopicErrorHeader); } }
private void OnManageFirewallPortsCommand() { try { var changes = PortManagerWindow.PromptUser(Instance); if (changes?.HasChanges ?? false) { var operation = _owner.DataSource.UpdateInstancePorts( Instance, portsToEnable: changes.PortsToEnable, portsToDisable: changes.PortsToDisable); UpdateInstanceState(operation); } } catch (DataSourceException) { UserPromptUtils.ErrorPrompt(Resources.CloudExplorerGceFailedToUpdateFirewallMessage, Resources.CloudExplorerGceFailedToUpdateFirewallCaption); } }
/// <summary> /// Starts the flow to add a new account to the credentials store. /// </summary> /// <returns>Will return true if the accound was added, false if the user cancelled.</returns> public static async Task <bool> StartAddAccountFlowAsync() { try { ExtensionAnalytics.ReportEvent(OAuthEventCategory, "FlowStarted"); string refreshToken = OAuthLoginFlowWindow.PromptUser(s_extensionCredentials, s_extensionScopes); if (refreshToken == null) { ExtensionAnalytics.ReportEvent(OAuthEventCategory, "FlowCancelled"); Debug.WriteLine("The user cancelled the OAUTH login flow."); return(false); } var credentials = await GetUserAccountForRefreshToken(refreshToken); ExtensionAnalytics.ReportEvent(OAuthEventCategory, "FlowFinished"); var existingUserAccount = CredentialsStore.Default.GetAccount(credentials.AccountName); if (existingUserAccount != null) { Debug.WriteLine($"Duplicate account {credentials.AccountName}"); UserPromptUtils.ErrorPrompt( string.Format(Resources.ManageAccountsAccountAlreadyExistsPromptMessage, credentials.AccountName), Resources.ManageAccountsAccountAlreadyExistsPromptTitle); return(false); } // Store the new account and set it as the current account. The project is not changed so if the // new account also have access to it, it remains as the current project. CredentialsStore.Default.AddAccount(credentials); CredentialsStore.Default.CurrentAccount = credentials; return(true); } catch (OAuthException ex) { ExtensionAnalytics.ReportEvent(OAuthEventCategory, "FlowFailed"); UserPromptUtils.ErrorPrompt( String.Format(Resources.CloudExplorerGceFailedToGetOauthCredentialsMessage, ex.Message), Resources.CloudExplorerGceFailedToGetOauthCredentialsCaption); return(false); } }
private async void OnCopyCommand() { try { Clipboard.SetText(Password); if (!ShowCopyFeedback) { ShowCopyFeedback = true; await Task.Delay(2000); ShowCopyFeedback = false; } } catch { Debug.WriteLine("Failed to copy the string to the clipboard."); UserPromptUtils.ErrorPrompt(Resources.ShowPasswordCopyFailedMessage, Resources.ShowPasswordCopyFailedTitle); } }
private bool Validate() { int allocationValue = 0; if (!Int32.TryParse(Allocation, out allocationValue)) { UserPromptUtils.ErrorPrompt( message: String.Format(Resources.AddGaeTrafficSplitInvalidValueMessage, Allocation), title: Resources.AddGaeTrafficSplitInvalidValueTitle); return(false); } if (allocationValue > 100 || allocationValue < 0) { UserPromptUtils.ErrorPrompt( message: String.Format(Resources.AddGaeTrafficSplitValueOutOfRangeMessage, Allocation), title: Resources.AddGaeTrafficSplitInvalidValueTitle); return(false); } return(true); }
private IAttachDebuggerStep Attach() { IsListVisible = false; ProgressMessage = String.Format( Resources.AttachDebuggerAttachingProcessMessageFormat, SelectedProcess.Name); var startTimestamp = DateTime.Now; try { if (SelectedEngine == s_detectEngineTypeItemName) { SelectedProcess.Process.Attach(); } else { SelectedProcess.Process.Attach2(SelectedEngine); } } catch (COMException ex) { EventsReporterWrapper.ReportEvent( RemoteDebuggerAttachedEvent.Create(CommandStatus.Failure)); Debug.WriteLine($"Attach debugger got exception. {ex}"); UserPromptUtils.ErrorPrompt( message: String.Format(Resources.AttachDebuggerAttachErrorMessageFormat, SelectedProcess.Name), title: Resources.UiDefaultPromptTitle); ResetDefaultSelection(); return(HelpStepViewModel.CreateStep(Context)); } EventsReporterWrapper.ReportEvent(RemoteDebuggerAttachedEvent.Create( CommandStatus.Success, DateTime.Now - startTimestamp)); Context.DialogWindow.Close(); return(null); }