relayer connection code; formatting (#5020)

src/sql/workbench/parts/connection/common/connection.ts

@@ -0,0 +1,27 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+// ------------------------------- < Cancel Connect Request > ---------------------------------------
+
+/**
+ * Cancel connect request message format
+ */
+export class CancelConnectParams {
+	/**
+	 * URI identifying the owner of the connection
+	 */
+	public ownerUri: string;
+}
+
+// ------------------------------- </ Cancel Connect Request > --------------------------------------
+
+// ------------------------------- < Disconnect Request > -------------------------------------------
+
+// Disconnect request message format
+export class DisconnectParams {
+	// URI identifying the owner of the connection
+	public ownerUri: string;
+}
+
+// ------------------------------- </ Disconnect Request > ------------------------------------------

src/sql/workbench/parts/connection/common/connectionActions.ts

@@ -0,0 +1,180 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import nls = require('vs/nls');
+import { Action } from 'vs/base/common/actions';
+import { Event, Emitter } from 'vs/base/common/event';
+import { IConnectionProfile } from 'sql/platform/connection/common/interfaces';
+import { IConnectionManagementService } from 'sql/platform/connection/common/connectionManagement';
+import { INotificationService, INotificationActions } from 'vs/platform/notification/common/notification';
+import Severity from 'vs/base/common/severity';
+import { IDialogService, IConfirmation, IConfirmationResult } from 'vs/platform/dialogs/common/dialogs';
+import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
+import { QueryInput } from 'sql/parts/query/common/queryInput';
+import { EditDataInput } from 'sql/parts/editData/common/editDataInput';
+import { DashboardInput } from 'sql/workbench/parts/dashboard/dashboardInput';
+import { IClipboardService } from 'vs/platform/clipboard/common/clipboardService';
+import { IQuickInputService } from 'vs/platform/quickinput/common/quickInput';
+import { IObjectExplorerService } from 'sql/workbench/services/objectExplorer/common/objectExplorerService';
+
+/**
+ * Workbench action to clear the recent connnections list
+ */
+export class ClearRecentConnectionsAction extends Action {
+
+	public static ID = 'clearRecentConnectionsAction';
+	public static LABEL = nls.localize('ClearRecentlyUsedLabel', 'Clear List');
+	public static ICON = 'search-action clear-search-results';
+
+	private _onRecentConnectionsRemoved = new Emitter<void>();
+	public onRecentConnectionsRemoved: Event<void> = this._onRecentConnectionsRemoved.event;
+
+	private _useConfirmationMessage = false;
+
+	constructor(
+		id: string,
+		label: string,
+		@IConnectionManagementService private _connectionManagementService: IConnectionManagementService,
+		@INotificationService private _notificationService: INotificationService,
+		@IQuickInputService private _quickInputService: IQuickInputService,
+		@IDialogService private _dialogService: IDialogService,
+	) {
+		super(id, label, ClearRecentConnectionsAction.ICON);
+		this.enabled = true;
+	}
+
+	public set useConfirmationMessage(value: boolean) {
+		this._useConfirmationMessage = value;
+	}
+
+	public run(): Promise<void> {
+		if (this._useConfirmationMessage) {
+			return this.promptConfirmationMessage().then(result => {
+				if (result.confirmed) {
+					this._connectionManagementService.clearRecentConnectionsList();
+					this._onRecentConnectionsRemoved.fire();
+				}
+			});
+		} else {
+			return this.promptQuickOpenService().then(result => {
+				if (result) {
+					this._connectionManagementService.clearRecentConnectionsList();
+
+					const actions: INotificationActions = { primary: [] };
+					this._notificationService.notify({
+						severity: Severity.Info,
+						message: nls.localize('ClearedRecentConnections', 'Recent connections list cleared'),
+						actions
+					});
+					this._onRecentConnectionsRemoved.fire();
+				}
+			});
+		}
+	}
+
+	private promptQuickOpenService(): Promise<boolean> {
+		const self = this;
+		return new Promise<boolean>((resolve, reject) => {
+			let choices: { key, value }[] = [
+				{ key: nls.localize('connectionAction.yes', 'Yes'), value: true },
+				{ key: nls.localize('connectionAction.no', 'No'), value: false }
+			];
+
+			self._quickInputService.pick(choices.map(x => x.key), { placeHolder: nls.localize('ClearRecentlyUsedLabel', 'Clear List'), ignoreFocusLost: true }).then((choice) => {
+				let confirm = choices.find(x => x.key === choice);
+				resolve(confirm && confirm.value);
+			});
+		});
+	}
+
+	private promptConfirmationMessage(): Promise<IConfirmationResult> {
+		let confirm: IConfirmation = {
+			message: nls.localize('clearRecentConnectionMessage', 'Are you sure you want to delete all the connections from the list?'),
+			primaryButton: nls.localize('connectionDialog.yes', 'Yes'),
+			secondaryButton: nls.localize('connectionDialog.no', 'No'),
+			type: 'question'
+		};
+
+		return new Promise<IConfirmationResult>((resolve, reject) => {
+			this._dialogService.confirm(confirm).then((confirmed) => {
+				resolve(confirmed);
+			});
+		});
+	}
+}
+
+/**
+ * Action to delete one recently used connection from the MRU
+ */
+export class ClearSingleRecentConnectionAction extends Action {
+
+	public static ID = 'clearSingleRecentConnectionAction';
+	public static LABEL = nls.localize('delete', 'Delete');
+	private _onRecentConnectionRemoved = new Emitter<void>();
+	public onRecentConnectionRemoved: Event<void> = this._onRecentConnectionRemoved.event;
+
+	constructor(
+		id: string,
+		label: string,
+		private _connectionProfile: IConnectionProfile,
+		@IConnectionManagementService private _connectionManagementService: IConnectionManagementService,
+	) {
+		super(id, label);
+		this.enabled = true;
+	}
+
+	public run(): Promise<void> {
+		return new Promise<void>((resolve, reject) => {
+			resolve(this._connectionManagementService.clearRecentConnection(this._connectionProfile));
+			this._onRecentConnectionRemoved.fire();
+		});
+	}
+}
+
+/**
+ * Action to retrieve the current connection string
+ */
+export class GetCurrentConnectionStringAction extends Action {
+
+	public static ID = 'getCurrentConnectionStringAction';
+	public static LABEL = nls.localize('connectionAction.GetCurrentConnectionString', "Get Current Connection String");
+
+	constructor(
+		id: string,
+		label: string,
+		@IConnectionManagementService private _connectionManagementService: IConnectionManagementService,
+		@IEditorService private _editorService: IEditorService,
+		@IObjectExplorerService private _objectExplorerService: IObjectExplorerService,
+		@INotificationService private readonly _notificationService: INotificationService,
+		@IClipboardService private _clipboardService: IClipboardService,
+	) {
+		super(GetCurrentConnectionStringAction.ID, GetCurrentConnectionStringAction.LABEL);
+		this.enabled = true;
+	}
+
+	public run(): Promise<void> {
+		return new Promise<void>((resolve, reject) => {
+			let activeInput = this._editorService.activeEditor;
+			if (activeInput && (activeInput instanceof QueryInput || activeInput instanceof EditDataInput || activeInput instanceof DashboardInput)
+				&& this._connectionManagementService.isConnected(activeInput.uri)) {
+				let includePassword = false;
+				let connectionProfile = this._connectionManagementService.getConnectionProfile(activeInput.uri);
+				this._connectionManagementService.getConnectionString(connectionProfile.id, includePassword).then(result => {
+
+					//Copy to clipboard
+					this._clipboardService.writeText(result);
+
+					let message = result
+						? result
+						: nls.localize('connectionAction.connectionString', "Connection string not available");
+					this._notificationService.info(message);
+				});
+			} else {
+				let message = nls.localize('connectionAction.noConnection', "No active connection available");
+				this._notificationService.info(message);
+			}
+		});
+	}
+}

src/sql/workbench/parts/connection/common/connectionContextKey.ts

@@ -0,0 +1,47 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { RawContextKey, IContextKeyService, IContextKey } from 'vs/platform/contextkey/common/contextkey';
+import { IConnectionProfile } from 'azdata';
+
+export class ConnectionContextKey implements IContextKey<IConnectionProfile> {
+
+	static Provider = new RawContextKey<string>('connectionProvider', undefined);
+	static Server = new RawContextKey<string>('serverName', undefined);
+	static Database = new RawContextKey<string>('databaseName', undefined);
+	static Connection = new RawContextKey<IConnectionProfile>('connection', undefined);
+
+	private _providerKey: IContextKey<string>;
+	private _serverKey: IContextKey<string>;
+	private _databaseKey: IContextKey<string>;
+	private _connectionKey: IContextKey<IConnectionProfile>;
+
+	constructor(
+		@IContextKeyService contextKeyService: IContextKeyService
+	) {
+		this._providerKey = ConnectionContextKey.Provider.bindTo(contextKeyService);
+		this._serverKey = ConnectionContextKey.Server.bindTo(contextKeyService);
+		this._databaseKey = ConnectionContextKey.Database.bindTo(contextKeyService);
+		this._connectionKey = ConnectionContextKey.Connection.bindTo(contextKeyService);
+	}
+
+	set(value: IConnectionProfile) {
+		this._connectionKey.set(value);
+		this._providerKey.set(value && value.providerName);
+		this._serverKey.set(value && value.serverName);
+		this._databaseKey.set(value && value.databaseName);
+	}
+
+	reset(): void {
+		this._providerKey.reset();
+		this._serverKey.reset();
+		this._databaseKey.reset();
+		this._connectionKey.reset();
+	}
+
+	public get(): IConnectionProfile {
+		return this._connectionKey.get();
+	}
+}

src/sql/workbench/parts/connection/common/connectionGlobalStatus.ts

@@ -0,0 +1,40 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { ConnectionSummary } from 'azdata';
+import { IStatusbarService } from 'vs/platform/statusbar/common/statusbar';
+import * as LocalizedConstants from 'sql/workbench/parts/connection/common/localizedConstants';
+
+// Status when making connections from the viewlet
+export class ConnectionGlobalStatus {
+
+	private _displayTime: number = 5000; // (in ms)
+
+	constructor(
+		@IStatusbarService private _statusBarService: IStatusbarService
+	) {
+	}
+
+	public setStatusToConnected(connectionSummary: ConnectionSummary): void {
+		if (this._statusBarService) {
+			let text: string;
+			let connInfo: string = connectionSummary.serverName;
+			if (connInfo) {
+				if (connectionSummary.databaseName && connectionSummary.databaseName !== '') {
+					connInfo = connInfo + ' : ' + connectionSummary.databaseName;
+				} else {
+					connInfo = connInfo + ' : ' + '<default>';
+				}
+				text = LocalizedConstants.onDidConnectMessage + ' ' + connInfo;
+			}
+			this._statusBarService.setStatusMessage(text, this._displayTime);
+		}
+	}
+
+	public setStatusToDisconnected(fileUri: string): void {
+		if (this._statusBarService) {
+			this._statusBarService.setStatusMessage(LocalizedConstants.onDidDisconnectMessage, this._displayTime);
+		}
+	}
+}

src/sql/workbench/parts/connection/common/localizedConstants.ts

@@ -2,8 +2,9 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-import { IViewlet } from 'vs/workbench/common/viewlet';
 
-export interface IConnectionsViewlet extends IViewlet {
-	search(text: string): void;
-}
+import { localize } from 'vs/nls';
+
+export const onDidConnectMessage = localize('onDidConnectMessage', 'Connected to');
+export const onDidDisconnectMessage = localize('onDidDisconnectMessage', 'Disconnected');
+export const unsavedGroupLabel = localize('unsavedGroupLabel', 'Unsaved Connections');

src/sql/workbench/parts/connection/common/serverInfoContextKey.ts

@@ -0,0 +1,37 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { RawContextKey, IContextKeyService, IContextKey } from 'vs/platform/contextkey/common/contextkey';
+import { ServerInfo } from 'azdata';
+
+export class ServerInfoContextKey implements IContextKey<ServerInfo> {
+
+	static ServerInfo = new RawContextKey<ServerInfo>('serverInfo', undefined);
+	static ServerMajorVersion = new RawContextKey<string>('serverMajorVersion', undefined);
+
+	private _serverInfo: IContextKey<ServerInfo>;
+	private _serverMajorVersion: IContextKey<string>;
+
+	constructor(
+		@IContextKeyService contextKeyService: IContextKeyService
+	) {
+		this._serverInfo = ServerInfoContextKey.ServerInfo.bindTo(contextKeyService);
+		this._serverMajorVersion = ServerInfoContextKey.ServerMajorVersion.bindTo(contextKeyService);
+	}
+
+	set(value: ServerInfo) {
+		this._serverInfo.set(value);
+		let majorVersion = value && value.serverMajorVersion;
+		this._serverMajorVersion.set(majorVersion && `${majorVersion}`);
+	}
+
+	reset(): void {
+		this._serverMajorVersion.reset();
+	}
+
+	public get(): ServerInfo {
+		return this._serverInfo.get();
+	}
+}