Fix Connection prompts

Author: cheenamalhotra

src/constants/constants.ts

@@ -45,6 +45,7 @@ export const cmdRefreshObjectExplorerNode = 'mssql.refreshObjectExplorerNode';
 export const cmdDisconnectObjectExplorerNode = 'mssql.disconnectObjectExplorerNode';
 export const cmdObjectExplorerNodeSignIn = 'mssql.objectExplorerNodeSignIn';
 export const cmdConnectObjectExplorerNode = 'mssql.connectObjectExplorerNode';
+export const cmdConnectObjectExplorerProfile = 'mssql.connectObjectExplorerProfile';
 export const cmdOpenObjectExplorerCommand = 'workbench.view.extension.objectExplorer';
 export const cmdScriptSelect = 'mssql.scriptSelect';
 export const cmdScriptCreate = 'mssql.scriptCreate';
@@ -94,6 +95,7 @@ export const renamedOpenTimeThreshold = 10.0;
 export const timeToWaitForLanguageModeChange = 10000.0;
 export const macOpenSslHelpLink = 'https://github.com/Microsoft/vscode-mssql/wiki/OpenSSL-Configuration';
 export const gettingStartedGuideLink = 'https://aka.ms/mssql-getting-started';
+export const encryptionReadMoreLink = 'https://learn.microsoft.com/sql/database-engine/configure-windows/enable-encrypted-connections-to-the-database-engine';
 export const changelogLink = 'https://aka.ms/vscode-mssql-changes';
 export const integratedAuthHelpLink = 'https://aka.ms/vscode-mssql-integratedauth';
 export const sqlToolsServiceCrashLink = 'https://github.com/Microsoft/vscode-mssql/wiki/SqlToolsService-Known-Issues';

src/controllers/connectionManager.ts

@@ -74,6 +74,10 @@ export class ConnectionInfo {
 	}
 }
 
+export interface ReconnectAction {
+	(profile: IConnectionInfo): Promise<void>;
+}
+
 // ConnectionManager class is the main controller for connection management
 export default class ConnectionManager {
 	private _statusView: StatusView;
@@ -422,17 +426,28 @@ export default class ConnectionManager {
 			// Check if the error is an expired password
 			if (result.errorNumber === Constants.errorPasswordExpired || result.errorNumber === Constants.errorPasswordNeedsReset) {
 				// TODO: we should allow the user to change their password here once corefx supports SqlConnection.ChangePassword()
-				Utils.showErrorMsg(Utils.formatString(LocalizedConstants.msgConnectionErrorPasswordExpired, result.errorNumber, result.errorMessage));
+				Utils.showErrorMsg(Utils.formatString(LocalizedConstants.msgConnectionErrorPasswordExpired,
+					result.errorNumber, result.errorMessage));
+				connection.errorNumber = result.errorNumber;
+				connection.errorMessage = result.errorMessage;
+			} else if (result.errorNumber === Constants.errorSSLCertificateValidationFailed) {
+				this.showInstructionTextAsWarning(connection.credentials, async updatedConnection => {
+					vscode.commands.executeCommand(Constants.cmdConnectObjectExplorerProfile, updatedConnection);
+				});
+				return;
 			} else if (result.errorNumber !== Constants.errorLoginFailed) {
 				Utils.showErrorMsg(Utils.formatString(LocalizedConstants.msgConnectionError, result.errorNumber, result.errorMessage));
 				// check whether it's a firewall rule error
 				let firewallResult = await this.firewallService.handleFirewallRule(result.errorNumber, result.errorMessage);
 				if (firewallResult.result && firewallResult.ipAddress) {
 					this._failedUriToFirewallIpMap.set(fileUri, firewallResult.ipAddress);
 				}
+				connection.errorNumber = result.errorNumber;
+				connection.errorMessage = result.errorMessage;
+			} else {
+				connection.errorNumber = result.errorNumber;
+				connection.errorMessage = result.errorMessage;
 			}
-			connection.errorNumber = result.errorNumber;
-			connection.errorMessage = result.errorMessage;
 		} else {
 			const platformInfo = await PlatformInformation.getCurrent();
 			if (!platformInfo.isWindows && result.errorMessage && result.errorMessage.includes('Kerberos')) {
@@ -462,6 +477,27 @@ export default class ConnectionManager {
 		);
 	}
 
+	public async showInstructionTextAsWarning(profile: IConnectionInfo, reconnectAction: ReconnectAction): Promise<void> {
+		const instructionText = `${LocalizedConstants.msgPromptSSLCertificateValidationFailed}`;
+		await this.vscodeWrapper.showWarningMessageAdvanced(instructionText,
+			{ modal: false },
+			[
+				LocalizedConstants.enableTrustServerCertificate,
+				LocalizedConstants.readMore,
+				LocalizedConstants.cancel
+			])
+			.then(async (selection) => {
+				if (selection && selection === LocalizedConstants.enableTrustServerCertificate) {
+					profile.encrypt = 'Mandatory';
+					profile.trustServerCertificate = true;
+					await reconnectAction(profile);
+				} else if (selection && selection === LocalizedConstants.readMore) {
+					this.vscodeWrapper.openExternal(Constants.encryptionReadMoreLink);
+					this.showInstructionTextAsWarning(profile, reconnectAction);
+				}
+			});
+	}
+
 	private async tryAddMruConnection(connection: ConnectionInfo, newConnection: IConnectionInfo): Promise<void> {
 		if (newConnection) {
 			let connectionToSave: IConnectionInfo = Object.assign({}, newConnection);

src/controllers/mainController.ts

@@ -151,6 +151,15 @@ export default class MainController implements vscode.Disposable {
 
 			this.initializeObjectExplorer();
 
+			this.registerCommandWithArgs(Constants.cmdConnectObjectExplorerProfile);
+			this._event.on(Constants.cmdConnectObjectExplorerProfile, async (profile: IConnectionProfile) => {
+				await this.createObjectExplorerSession(profile).then((result) => {
+					if(result === true){
+						this._connectionMgr.connectionUI.saveProfile(profile);
+					}
+				});
+			});
+
 			this.initializeQueryHistory();
 
 			this.sqlTasksService = new SqlTasksService(SqlToolsServerClient.instance, this._untitledSqlDocumentService);
@@ -282,15 +291,17 @@ export default class MainController implements vscode.Disposable {
 	/**
 	 * Creates a new Object Explorer session
 	 */
-	private async createObjectExplorerSession(connectionCredentials?: IConnectionInfo): Promise<void> {
+	private async createObjectExplorerSession(connectionCredentials?: IConnectionInfo): Promise<boolean> {
 		let createSessionPromise = new Deferred<TreeNodeInfo>();
 		const sessionId = await this._objectExplorerProvider.createSession(createSessionPromise, connectionCredentials, this._context);
 		if (sessionId) {
 			const newNode = await createSessionPromise;
 			if (newNode) {
 				this._objectExplorerProvider.refresh(undefined);
+				return true;
 			}
 		}
+		return false;
 	}
 
 	/**

src/controllers/vscodeWrapper.ts

@@ -302,6 +302,13 @@ export default class VscodeWrapper {
 		return vscode.window.showWarningMessage(Constants.extensionName + ': ' + msg, messageOptions, ...items);
 	}
 
+	/**
+	 * Formats and shows a vscode warning message
+	 */
+	public openExternal(link: string): Thenable<boolean> {
+		return vscode.env.openExternal(vscode.Uri.parse(link));
+	}
+
 	/**
 	 * Returns a array of the text editors currently visible in the window
 	 */

src/models/connectionCredentials.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as LocalizedConstants from '../constants/localizedConstants';
-import { IConnectionProfile, AuthenticationTypes, EncryptOptions } from './interfaces';
+import { IConnectionProfile, AuthenticationTypes } from './interfaces';
 import { ConnectionStore } from './connectionStore';
 import * as utils from './utils';
 import { QuestionTypes, IQuestion, IPrompter, INameValueChoice } from '../prompts/question';
@@ -172,7 +172,6 @@ export class ConnectionCredentials implements IConnectionInfo {
 		defaultProfileValues?: IConnectionInfo): Promise<IQuestion[]> {
 
 		let authenticationChoices: INameValueChoice[] = ConnectionCredentials.getAuthenticationTypesChoice();
-		let encryptChoices: INameValueChoice[] = ConnectionCredentials.getEncryptChoices();
 
 		let connectionStringSet: () => boolean = () => Boolean(credentials.connectionString);
 
@@ -252,21 +251,6 @@ export class ConnectionCredentials implements IConnectionInfo {
 					}
 				},
 				default: defaultProfileValues ? await connectionStore.lookupPassword(defaultProfileValues) : undefined
-			},
-			// Encrypt may be optionally set.
-			{
-				type: QuestionTypes.expand,
-				name: LocalizedConstants.encryptName,
-				message: LocalizedConstants.encryptPrompt + ': ' + LocalizedConstants.encryptMandatoryRecommended,
-				choices: encryptChoices,
-				shouldPrompt: (answers) =>
-					!connectionStringSet()
-					&& utils.isEmpty(credentials.encrypt)
-					&& authenticationChoices.length > 1,
-				onAnswered: (value) => {
-					credentials.encrypt = value;
-				},
-				default: EncryptOptions.Mandatory
 			}
 		];
 		return questions;
@@ -334,14 +318,5 @@ export class ConnectionCredentials implements IConnectionInfo {
 
 		return choices;
 	}
-
-	public static getEncryptChoices(): INameValueChoice[] {
-		let choices: INameValueChoice[] = [
-			{ name: LocalizedConstants.encryptMandatory, value: utils.encryptToString(EncryptOptions.Mandatory) },
-			{ name: LocalizedConstants.encryptOptional, value: utils.encryptToString(EncryptOptions.Optional) }
-		];
-
-		return choices;
-	}
 }
 

src/objectExplorer/objectExplorerService.ts

@@ -118,7 +118,7 @@ export class ObjectExplorerService {
 				return promise.resolve(node);
 			} else {
 				// create session failure
-				if (self._currentNode.connectionInfo?.password) {
+				if (self._currentNode?.connectionInfo?.password) {
 					self._currentNode.connectionInfo.password = '';
 				}
 				let error = LocalizedConstants.connectErrorLabel;
@@ -129,32 +129,24 @@ export class ObjectExplorerService {
 				if (result.errorMessage) {
 					error += ` : ${result.errorMessage}`;
 				}
+
+				self._connectionManager.vscodeWrapper.showErrorMessage(error);
+
 				if (errorNumber === Constants.errorSSLCertificateValidationFailed) {
-					let instructionText = `${LocalizedConstants.msgPromptSSLCertificateValidationFailed}`;
-					self._connectionManager.vscodeWrapper.showWarningMessageAdvanced(instructionText,
-						{ modal: false },
-						[
-							LocalizedConstants.enableTrustServerCertificate,
-							LocalizedConstants.cancel
-						])
-					.then(async (selection) => {
-						if (selection && selection === LocalizedConstants.enableTrustServerCertificate) {
-							let profile = <IConnectionProfile>self._currentNode.connectionInfo;
-							profile.encrypt = 'Mandatory';
-							profile.trustServerCertificate = true;
+					self._connectionManager.showInstructionTextAsWarning(self._currentNode.connectionInfo,
+						async updatedProfile => {
+							self.currentNode.connectionInfo = updatedProfile;
 							self.updateNode(self._currentNode);
 							let fileUri = ObjectExplorerUtils.getNodeUri(self._currentNode);
-							if (await self._connectionManager.connectionStore.saveProfile(profile)) {
-								const res = await self._connectionManager.connect(fileUri, profile);
-								if (await self._connectionManager.handleConnectionResult(res, fileUri, profile)) {
+							if (await self._connectionManager.connectionStore.saveProfile(updatedProfile as IConnectionProfile)) {
+								const res = await self._connectionManager.connect(fileUri, updatedProfile);
+								if (await self._connectionManager.handleConnectionResult(res, fileUri, updatedProfile)) {
 									self.refreshNode(self._currentNode);
 								}
 							} else {
 								self._connectionManager.vscodeWrapper.showErrorMessage(LocalizedConstants.msgPromptProfileUpdateFailed);
 							}
-						}
-					});
-					self._connectionManager.vscodeWrapper.showErrorMessage(error);
+						});
 				}
 				const promise = self._sessionIdToPromiseMap.get(result.sessionId);
 

src/views/connectionUI.ts

@@ -542,7 +542,7 @@ export class ConnectionUI {
 	/**
 	 * Save a connection profile using the connection store
 	 */
-	private async saveProfile(profile: IConnectionProfile): Promise<IConnectionProfile> {
+	public async saveProfile(profile: IConnectionProfile): Promise<IConnectionProfile> {
 		return await this._connectionStore.saveProfile(profile);
 	}