Refresh master with initial release/0.24 snapshot (#332)

* Initial port of release/0.24 source code

* Fix additional headers

* Fix a typo in launch.json

src/sql/parts/accountManagement/common/accountActions.ts

@@ -36,8 +36,6 @@ export class AddAccountAction extends Action {
 
 	constructor(
 		private _providerId: string,
-		@IMessageService private _messageService: IMessageService,
-		@IErrorMessageService private _errorMessageService: IErrorMessageService,
 		@IAccountManagementService private _accountManagementService: IAccountManagementService
 	) {
 		super(AddAccountAction.ID, AddAccountAction.LABEL);
@@ -99,21 +97,25 @@ export class RemoveAccountAction extends Action {
 			type: 'question'
 		};
 
-		if (!this._messageService.confirm(confirm)) {
-			return TPromise.as(false);
-		}
+		let confirmPromise = this._messageService.confirm(confirm);
 
-		return new TPromise((resolve, reject) => {
-			self._accountManagementService.removeAccount(self._account.key)
-				.then(
-					(result) => { resolve(result); },
-					(err) => {
-						// Must handle here as this is an independent action
-						self._errorMessageService.showDialog(Severity.Error,
-							localize('removeAccountFailed', 'Failed to remove account'), err);
-						resolve(false);
-					}
-				);
+		return confirmPromise.then(confirmation => {
+			if (!confirmation.confirmed) {
+				return TPromise.as(false);
+			} else {
+				return new TPromise((resolve, reject) => {
+					self._accountManagementService.removeAccount(self._account.key)
+						.then(
+							(result) => { resolve(result); },
+							(err) => {
+								// Must handle here as this is an independent action
+								self._errorMessageService.showDialog(Severity.Error,
+									localize('removeAccountFailed', 'Failed to remove account'), err);
+								resolve(false);
+							}
+						);
+				});
+			}
 		});
 	}
 }
@@ -144,15 +146,31 @@ export class ApplyFilterAction extends Action {
 export class RefreshAccountAction extends Action {
 	public static ID = 'account.refresh';
 	public static LABEL = localize('refreshAccount', 'Reenter your credentials');
+	public account: data.Account;
 
 	constructor(
-		id: string,
-		label: string
+		@IAccountManagementService private _accountManagementService: IAccountManagementService
 	) {
-		super(id, label, 'refresh-account-action icon refresh');
+		super(RefreshAccountAction.ID, RefreshAccountAction.LABEL, 'refresh-account-action icon refresh');
 	}
 	public run(): TPromise<boolean> {
-		// Todo: refresh the account
-		return TPromise.as(true);
+		let self = this;
+		return new TPromise((resolve, reject) => {
+			if (self.account) {
+				self._accountManagementService.refreshAccount(self.account)
+					.then(
+						() => {
+							resolve(true);
+						},
+						err => {
+							error(`Error while refreshing account: ${err}`);
+							reject(err);
+						}
+				);
+			} else {
+				let errorMessage = localize('NoAccountToRefresh', 'There is no account to refresh');
+				reject(errorMessage);
+			}
+		});
 	}
 }

src/sql/parts/accountManagement/common/accountListRenderer.ts

@@ -13,7 +13,7 @@ import { ActionBar, IActionOptions } from 'vs/base/browser/ui/actionbar/actionba
 import { localize } from 'vs/nls';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 
-import { RemoveAccountAction, ApplyFilterAction, RefreshAccountAction } from 'sql/parts/accountManagement/common/accountActions';
+import { RemoveAccountAction, RefreshAccountAction } from 'sql/parts/accountManagement/common/accountActions';
 
 import * as data from 'data';
 
@@ -66,9 +66,7 @@ export class AccountPickerListRenderer implements IRenderer<data.Account, Accoun
 
 	public renderElement(account: data.Account, index: number, templateData: AccountListTemplate): void {
 		// Set the account icon
-		templateData.icon.classList.add('account-logo');
-		templateData.icon.style.background = `url('data:${account.displayInfo.contextualLogo.light}')`;
-		// TODO: Pick between the light and dark logo
+		templateData.icon.classList.add('account-logo', account.displayInfo.accountType);
 
 		templateData.contextualDisplayName.innerText = account.displayInfo.contextualDisplayName;
 		templateData.displayName.innerText = account.displayInfo.displayName;
@@ -114,9 +112,12 @@ export class AccountListRenderer extends AccountPickerListRenderer {
 
 		let actionOptions: IActionOptions = { icon: true, label: false };
 		if (account.isStale) {
-			templateData.actions.push(new RefreshAccountAction(RefreshAccountAction.ID, RefreshAccountAction.LABEL), actionOptions);
+			let refreshAction = this._instantiationService.createInstance(RefreshAccountAction);
+			refreshAction.account = account;
+			templateData.actions.push(refreshAction, actionOptions);
 		} else {
-			templateData.actions.push(new ApplyFilterAction(ApplyFilterAction.ID, ApplyFilterAction.LABEL), actionOptions);
+			// Todo: Will show filter action when API/GUI for filtering is implemented (#3022, #3024)
+			// templateData.actions.push(new ApplyFilterAction(ApplyFilterAction.ID, ApplyFilterAction.LABEL), actionOptions);
 		}
 
 		let removeAction = this._instantiationService.createInstance(RemoveAccountAction, account);

src/sql/parts/accountManagement/common/accountManagement.contribution.ts

@@ -0,0 +1,109 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { Registry } from 'vs/platform/registry/common/platform';
+import { IWorkbenchActionRegistry, Extensions } from 'vs/workbench/common/actions';
+import { SyncActionDescriptor } from 'vs/platform/actions/common/actions';
+import { IExtensionPointUser, ExtensionsRegistry } from 'vs/platform/extensions/common/extensionsRegistry';
+import { IJSONSchema } from 'vs/base/common/jsonSchema';
+import { localize } from 'vs/nls';
+import { join } from 'path';
+import { createCSSRule } from 'vs/base/browser/dom';
+import URI from 'vs/base/common/uri';
+
+import { ManageLinkedAccountAction } from 'sql/parts/accountManagement/accountListStatusbar/accountListStatusbarItem';
+
+let actionRegistry = <IWorkbenchActionRegistry>Registry.as(Extensions.WorkbenchActions);
+
+actionRegistry.registerWorkbenchAction(
+	new SyncActionDescriptor(
+		ManageLinkedAccountAction,
+		ManageLinkedAccountAction.ID,
+		ManageLinkedAccountAction.LABEL
+	),
+	ManageLinkedAccountAction.LABEL
+);
+
+export interface IAccountContrib {
+	id: string;
+	icon?: IUserFriendlyIcon;
+}
+
+export type IUserFriendlyIcon = string | { light: string; dark: string; };
+
+const account: IJSONSchema = {
+	type: 'object',
+	properties: {
+		id: {
+			description: localize('carbon.extension.contributes.account.id', 'Identifier of the account type'),
+			type: 'string'
+		},
+		icon: {
+			description: localize('carbon.extension.contributes.account.icon', '(Optional) Icon which is used to represent the accpunt in the UI. Either a file path or a themable configuration'),
+			anyOf: [{
+				type: 'string'
+			},
+			{
+				type: 'object',
+				properties: {
+					light: {
+						description: localize('carbon.extension.contributes.account.icon.light', 'Icon path when a light theme is used'),
+						type: 'string'
+					},
+					dark: {
+						description: localize('carbon.extension.contributes.account.icon.dark', 'Icon path when a dark theme is used'),
+						type: 'string'
+					}
+				}
+			}]
+		}
+	}
+};
+
+export const accountsContribution: IJSONSchema = {
+	description: localize('carbon.extension.contributes.account', "Contributes icons to account provider."),
+	oneOf: [
+		account,
+		{
+			type: 'array',
+			items: account
+		}
+	]
+};
+
+ExtensionsRegistry.registerExtensionPoint<IAccountContrib | IAccountContrib[]>('account-type', [], accountsContribution).setHandler(extensions => {
+
+	function handleCommand(account: IAccountContrib, extension: IExtensionPointUser<any>) {
+		let { icon, id } = account;
+		let iconClass: string;
+		if (icon) {
+			iconClass = id;
+			if (typeof icon === 'string') {
+				const path = join(extension.description.extensionFolderPath, icon);
+				createCSSRule(`.icon.${iconClass}`, `background-image: url("${URI.file(path).toString()}")`);
+			} else {
+				const light = join(extension.description.extensionFolderPath, icon.light);
+				const dark = join(extension.description.extensionFolderPath, icon.dark);
+				createCSSRule(`.icon.${iconClass}`, `background-image: url("${URI.file(light).toString()}")`);
+				createCSSRule(`.vs-dark .icon.${iconClass}, .hc-black .icon.${iconClass}`, `background-image: url("${URI.file(dark).toString()}")`);
+			}
+		}
+	}
+
+	for (let extension of extensions) {
+		const { value } = extension;
+		if (Array.isArray<IAccountContrib>(value)) {
+			for (let command of value) {
+				handleCommand(command, extension);
+			}
+		} else {
+			handleCommand(value, extension);
+		}
+	}
+
+});
+

src/sql/parts/accountManagement/common/resourceProviderService.ts

@@ -6,7 +6,6 @@
 'use strict';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
-import { IEnvironmentService } from 'vs/platform/environment/common/environment';
 
 import { IConnectionProfile } from 'sql/parts/connection/common/interfaces';
 import { IResourceProviderService, IHandleFirewallRuleResult } from 'sql/parts/accountManagement/common/interfaces';
@@ -26,7 +25,6 @@ export class ResourceProviderService implements IResourceProviderService {
 	constructor(
 		@ITelemetryService private _telemetryService: ITelemetryService,
 		@IInstantiationService private _instantiationService: IInstantiationService,
-		@IEnvironmentService private _environmentService: IEnvironmentService
 	) {
 	}
 
@@ -66,39 +64,33 @@ export class ResourceProviderService implements IResourceProviderService {
 	 * Handle a firewall rule
 	 */
 	public handleFirewallRule(errorCode: number, errorMessage: string, connectionTypeId: string): Promise<IHandleFirewallRuleResult> {
-		if (!this._environmentService.isBuilt) {
-			let self = this;
-			return new Promise<IHandleFirewallRuleResult>((resolve, reject) => {
-				let handleFirewallRuleResult: IHandleFirewallRuleResult;
-				let promises = [];
-				if (self._providers) {
-					for (let key in self._providers) {
-						let provider = self._providers[key];
-						promises.push(provider.handleFirewallRule(errorCode, errorMessage, connectionTypeId)
-							.then(response => {
-								if (response.result) {
-									handleFirewallRuleResult = { canHandleFirewallRule: response.result, ipAddress: response.ipAddress, resourceProviderId: key };
-								}
-							},
-							() => { /* Swallow failures at getting accounts, we'll just hide that provider */
-							}));
-					}
+		let self = this;
+		return new Promise<IHandleFirewallRuleResult>((resolve, reject) => {
+			let handleFirewallRuleResult: IHandleFirewallRuleResult;
+			let promises = [];
+			if (self._providers) {
+				for (let key in self._providers) {
+					let provider = self._providers[key];
+					promises.push(provider.handleFirewallRule(errorCode, errorMessage, connectionTypeId)
+						.then(response => {
+							if (response.result) {
+								handleFirewallRuleResult = { canHandleFirewallRule: response.result, ipAddress: response.ipAddress, resourceProviderId: key };
+							}
+						},
+						() => { /* Swallow failures at getting accounts, we'll just hide that provider */
+						}));
 				}
+			}
 
-				Promise.all(promises).then(() => {
-					if (handleFirewallRuleResult) {
-						resolve(handleFirewallRuleResult);
-					} else {
-						handleFirewallRuleResult = { canHandleFirewallRule: false, ipAddress: undefined, resourceProviderId: undefined };
-						resolve(handleFirewallRuleResult);
-					}
-				});
+			Promise.all(promises).then(() => {
+				if (handleFirewallRuleResult) {
+					resolve(handleFirewallRuleResult);
+				} else {
+					handleFirewallRuleResult = { canHandleFirewallRule: false, ipAddress: undefined, resourceProviderId: undefined };
+					resolve(handleFirewallRuleResult);
+				}
 			});
-		} else {
-			return new Promise<IHandleFirewallRuleResult>((resolve, reject) => {
-				resolve({ canHandleFirewallRule: false, ipAddress: undefined, resourceProviderId: undefined });
-			});
-		}
+		});
 	}
 
 	/**