Fixed #3294 removed dead code for "attach to" and remove disable to make it respond theme change (#3349)

* Fixed #3294

* Fixed #3294

extensions/agent/package.json

@@ -2,7 +2,7 @@
   "name": "agent",
   "displayName": "SQL Server Agent",
   "description": "Manage and troubleshoot SQL Server Agent jobs",
-  "version": "0.35.0",
+  "version": "0.35.1",
   "publisher": "Microsoft",
   "preview": true,
   "license": "https://raw.githubusercontent.com/Microsoft/azuredatastudio/master/LICENSE.txt",

extensions/agent/src/data/jobStepData.ts

@@ -123,6 +123,7 @@ export class JobStepData implements IAgentDialogData {
 		stepData.retryInterval = jobStepInfo.retryInterval,
 		stepData.proxyName = jobStepInfo.proxyName;
 		stepData.dialogMode = AgentDialogMode.EDIT;
+		stepData.viaJobDialog = true;
 		return stepData;
 	}
 

extensions/agent/src/dialogs/jobDialog.ts

@@ -46,7 +46,7 @@ export class JobDialog extends AgentDialog<JobData>  {
 	private readonly EditStepButtonString: string = localize('jobDialog.edit', 'Edit');
 	private readonly DeleteStepButtonString: string = localize('jobDialog.delete', 'Delete');
 	private readonly MoveStepUpButtonString: string = localize('jobDialog.moveUp', 'Move Step Up');
-	private readonly MoveStepDownButtonString: string = localize('jobDialog.moveDown', 'Move Step Up');
+	private readonly MoveStepDownButtonString: string = localize('jobDialog.moveDown', 'Move Step Down');
 
 	// Notifications tab strings
 	private readonly NotificationsTabTopLabelString: string = localize('jobDialog.notificationsTabTop', 'Actions to perform when the job completes');
@@ -230,7 +230,7 @@ export class JobDialog extends AgentDialog<JobData>  {
 			this.moveStepDownButton = view.modelBuilder.button()
 				.withProperties({
 					label: this.MoveStepDownButtonString,
-					width: 80
+					width: 120
 				}).component();
 
 			this.moveStepUpButton.enabled = false;
@@ -270,31 +270,87 @@ export class JobDialog extends AgentDialog<JobData>  {
 			this.editStepButton.enabled = false;
 			this.deleteStepButton.enabled = false;
 
+			this.moveStepUpButton.onDidClick(() => {
+                if (this.stepsTable.selectedRows.length === 1) {
+                    let rowNumber = this.stepsTable.selectedRows[0];
+                    // if it's not the first step
+                    if (rowNumber !== 0) {
+                        let previousRow = rowNumber - 1;
+                        let previousStep = this.steps[previousRow];
+                        let previousStepId = this.steps[previousRow].id;
+                        let currentStep = this.steps[rowNumber];
+                        let currentStepId = this.steps[rowNumber].id;
+                        this.steps[previousRow] = currentStep;
+                        this.steps[rowNumber] = previousStep;
+                        this.stepsTable.data = this.convertStepsToData(this.steps);
+                        this.steps[previousRow].id = previousStepId;
+                        this.steps[rowNumber].id = currentStepId;
+                    }
+                }
+			});
+
+			this.moveStepDownButton.onDidClick(() => {
+				if (this.stepsTable.selectedRows.length === 1) {
+					let rowNumber = this.stepsTable.selectedRows[0];
+					// if it's not the last step
+					if (this.steps.length !== rowNumber + 1) {
+						let nextRow = rowNumber + 1;
+						let nextStep = this.steps[nextRow];
+						let nextStepId = this.steps[nextRow].id;
+						let currentStep = this.steps[rowNumber];
+						let currentStepId = this.steps[rowNumber].id;
+						this.steps[nextRow] = currentStep;
+						this.steps[rowNumber] = nextStep;
+						this.stepsTable.data = this.convertStepsToData(this.steps);
+						this.steps[nextRow].id = nextStepId;
+						this.steps[rowNumber].id = currentStepId;
+					}
+				}
+			});
+
+			this.editStepButton.onDidClick(() => {
+				if (this.stepsTable.selectedRows.length === 1) {
+					let rowNumber = this.stepsTable.selectedRows[0];
+					let stepData = this.model.jobSteps[rowNumber];
+					let editStepDialog = new JobStepDialog(this.model.ownerUri, '' , this.model, stepData, true);
+					editStepDialog.onSuccess((step) => {
+						let stepInfo = JobStepData.convertToAgentJobStepInfo(step);
+						for (let i = 0; i < this.steps.length; i++) {
+							if (this.steps[i].id === stepInfo.id) {
+								this.steps[i] = stepInfo;
+							}
+						}
+						this.stepsTable.data = this.convertStepsToData(this.steps);
+					});
+					editStepDialog.openDialog();
+				}
+			});
+
+			this.deleteStepButton.onDidClick(() => {
+				if (this.stepsTable.selectedRows.length === 1) {
+					let rowNumber = this.stepsTable.selectedRows[0];
+					AgentUtils.getAgentService().then((agentService) => {
+						let steps = this.model.jobSteps ? this.model.jobSteps : [];
+						let stepData = this.model.jobSteps[rowNumber];
+						agentService.deleteJobStep(this.ownerUri, stepData).then((result) => {
+							if (result && result.success) {
+								delete steps[rowNumber];
+								let data = this.convertStepsToData(steps);
+								this.stepsTable.data = data;
+							}
+						});
+					});
+				}
+			});
+
 			this.stepsTable.onRowSelected(() => {
 				// only let edit or delete steps if there's
 				// one step selection
 				if (this.stepsTable.selectedRows.length === 1) {
-					let rowNumber = this.stepsTable.selectedRows[0];
-					let stepData = this.model.jobSteps[rowNumber];
+					this.moveStepUpButton.enabled = true;
+					this.moveStepDownButton.enabled = true;
 					this.deleteStepButton.enabled = true;
 					this.editStepButton.enabled = true;
-					this.editStepButton.onDidClick(() => {
-						let stepDialog = new JobStepDialog(this.model.ownerUri, '' , this.model, stepData, true);
-						stepDialog.openDialog();
-					});
-
-					this.deleteStepButton.onDidClick(() => {
-						AgentUtils.getAgentService().then((agentService) => {
-							let steps = this.model.jobSteps ? this.model.jobSteps : [];
-							agentService.deleteJobStep(this.ownerUri, stepData).then((result) => {
-								if (result && result.success) {
-									delete steps[rowNumber];
-									let data = this.convertStepsToData(steps);
-									this.stepsTable.data = data;
-								}
-							});
-						});
-					});
 				}
 			});
 

extensions/agent/src/dialogs/jobStepDialog.ts

@@ -519,6 +519,7 @@ export class JobStepDialog extends AgentDialog<JobStepData> {
 		this.model.failureAction = this.failureActionDropdown.value as string;
 		this.model.outputFileName = this.outputFileNameBox.value;
 		this.model.appendToLogFile = this.appendToExistingFileCheckbox.checked;
+		this.model.command = this.commandTextBox.value ? this.commandTextBox.value : '';
 	}
 
 	public async initializeDialog() {

extensions/azurecore/src/account-provider/azureAccountProvider.ts

@@ -69,8 +69,8 @@ export class AzureAccountProvider implements sqlops.AccountProvider {
 		return this._tokenCache.clear();
 	}
 
-	public getSecurityToken(account: AzureAccount): Thenable<AzureAccountSecurityTokenCollection> {
-		return this.doIfInitialized(() => this.getAccessTokens(account));
+	public getSecurityToken(account: AzureAccount, resource: sqlops.AzureResource): Thenable<AzureAccountSecurityTokenCollection> {
+		return this.doIfInitialized(() => this.getAccessTokens(account, resource));
 	}
 
 	public initialize(restoredAccounts: sqlops.Account[]): Thenable<sqlops.Account[]> {
@@ -90,7 +90,7 @@ export class AzureAccountProvider implements sqlops.AccountProvider {
 
 			// Attempt to get fresh tokens. If this fails then the account is stale.
 			// NOTE: Based on ADAL implementation, getting tokens should use the refresh token if necessary
-			let task = this.getAccessTokens(account)
+			let task = this.getAccessTokens(account, sqlops.AzureResource.ResourceManagement)
 				.then(
 				() => {
 					return account;
@@ -161,9 +161,14 @@ export class AzureAccountProvider implements sqlops.AccountProvider {
 			: Promise.reject(localize('accountProviderNotInitialized', 'Account provider not initialized, cannot perform action'));
 	}
 
-	private getAccessTokens(account: AzureAccount): Thenable<AzureAccountSecurityTokenCollection> {
+	private getAccessTokens(account: AzureAccount, resource: sqlops.AzureResource): Thenable<AzureAccountSecurityTokenCollection> {
 		let self = this;
 
+		const resourceIdMap = new Map<sqlops.AzureResource, string>([
+			[sqlops.AzureResource.ResourceManagement, self._metadata.settings.armResource.id],
+			[sqlops.AzureResource.Sql, self._metadata.settings.sqlResource.id]
+		]);
+
 		let accessTokenPromises: Thenable<void>[] = [];
 		let tokenCollection: AzureAccountSecurityTokenCollection = {};
 		for (let tenant of account.properties.tenants) {
@@ -172,7 +177,7 @@ export class AzureAccountProvider implements sqlops.AccountProvider {
 				let context = new adal.AuthenticationContext(authorityUrl, null, self._tokenCache);
 
 				context.acquireToken(
-					self._metadata.settings.armResource.id,
+					resourceIdMap.get(resource),
 					tenant.userId,
 					self._metadata.settings.clientId,
 					(error: Error, response: adal.TokenResponse | adal.ErrorResponse) => {

extensions/azurecore/src/account-provider/interfaces.ts

@@ -81,6 +81,11 @@ export interface Settings {
 	 */
 	armResource?: Resource;
 
+	/**
+	 * Information that describes the SQL Azure resource
+	 */
+	sqlResource?: Resource;
+
 	/**
 	 * A list of tenant IDs to authenticate against. If defined, then these IDs will be used
 	 * instead of querying the tenants endpoint of the armResource

extensions/azurecore/src/account-provider/providerSettings.ts

@@ -27,6 +27,10 @@ const publicAzureSettings: ProviderSettings = {
 				id: 'https://management.core.windows.net/',
 				endpoint: 'https://management.azure.com'
 			},
+			sqlResource: {
+				id: 'https://database.windows.net/',
+				endpoint: 'https://database.windows.net'
+			},
 			redirectUri: 'http://localhost/redirect'
 		}
 	}

extensions/azurecore/src/apiWrapper.ts

@@ -212,8 +212,8 @@ export class ApiWrapper {
 		return sqlops.accounts.getAllAccounts();
 	}
 
-	public getSecurityToken(account: sqlops.Account): Thenable<{}> {
-		return sqlops.accounts.getSecurityToken(account);
+	public getSecurityToken(account: sqlops.Account, resource: sqlops.AzureResource): Thenable<{}> {
+		return sqlops.accounts.getSecurityToken(account, resource);
 	}
 
 	public readonly onDidChangeAccounts = sqlops.accounts.onDidChangeAccounts;

extensions/azurecore/src/azureResource/commands.ts

@@ -6,7 +6,7 @@
 'use strict';
 
 import { window, QuickPickItem } from 'vscode';
-import { IConnectionProfile } from 'sqlops';
+import * as sqlops from 'sqlops';
 import { generateGuid } from './utils';
 import { ApiWrapper } from '../apiWrapper';
 import { TreeNode } from '../treeNodes';
@@ -30,7 +30,7 @@ export function registerAzureResourceCommands(apiWrapper: ApiWrapper, tree: Azur
 
 		let subscriptions = await accountNode.getCachedSubscriptions();
 		if (!subscriptions || subscriptions.length === 0) {
-			const credentials = await servicePool.credentialService.getCredentials(accountNode.account);
+			const credentials = await servicePool.credentialService.getCredentials(accountNode.account, sqlops.AzureResource.ResourceManagement);
 			subscriptions = await servicePool.subscriptionService.getSubscriptions(accountNode.account, credentials);
 		}
 
@@ -71,7 +71,7 @@ export function registerAzureResourceCommands(apiWrapper: ApiWrapper, tree: Azur
 	});
 
 	apiWrapper.registerCommand('azureresource.connectsqldb', async (node?: TreeNode) => {
-		let connectionProfile: IConnectionProfile = {
+		let connectionProfile: sqlops.IConnectionProfile = {
 			id: generateGuid(),
 			connectionName: undefined,
 			serverName: undefined,

extensions/azurecore/src/azureResource/interfaces.ts

@@ -6,29 +6,29 @@
 'use strict';
 
 import { ServiceClientCredentials } from 'ms-rest';
-import { Account, DidChangeAccountsParams } from 'sqlops';
+import * as sqlops from 'sqlops';
 import { Event } from 'vscode';
 
 import { AzureResourceSubscription, AzureResourceDatabaseServer, AzureResourceDatabase } from './models';
 
 export interface IAzureResourceAccountService {
-	getAccounts(): Promise<Account[]>;
+	getAccounts(): Promise<sqlops.Account[]>;
 
-	readonly onDidChangeAccounts: Event<DidChangeAccountsParams>;
+	readonly onDidChangeAccounts: Event<sqlops.DidChangeAccountsParams>;
 }
 
 export interface IAzureResourceCredentialService {
-	getCredentials(account: Account): Promise<ServiceClientCredentials[]>;
+	getCredentials(account: sqlops.Account, resource: sqlops.AzureResource): Promise<ServiceClientCredentials[]>;
 }
 
 export interface IAzureResourceSubscriptionService {
-	getSubscriptions(account: Account, credentials: ServiceClientCredentials[]): Promise<AzureResourceSubscription[]>;
+	getSubscriptions(account: sqlops.Account, credentials: ServiceClientCredentials[]): Promise<AzureResourceSubscription[]>;
 }
 
 export interface IAzureResourceSubscriptionFilterService {
-	getSelectedSubscriptions(account: Account): Promise<AzureResourceSubscription[]>;
+	getSelectedSubscriptions(account: sqlops.Account): Promise<AzureResourceSubscription[]>;
 
-	saveSelectedSubscriptions(account: Account, selectedSubscriptions: AzureResourceSubscription[]): Promise<void>;
+	saveSelectedSubscriptions(account: sqlops.Account, selectedSubscriptions: AzureResourceSubscription[]): Promise<void>;
 }
 
 export interface IAzureResourceDatabaseServerService {

extensions/azurecore/src/azureResource/services/credentialService.ts

@@ -5,7 +5,7 @@
 
 'use strict';
 
-import { Account } from 'sqlops';
+import * as sqlops from 'sqlops';
 import { TokenCredentials, ServiceClientCredentials } from 'ms-rest';
 import { ApiWrapper } from '../../apiWrapper';
 import * as nls from 'vscode-nls';
@@ -21,10 +21,10 @@ export class AzureResourceCredentialService implements IAzureResourceCredentialS
 		this._apiWrapper = apiWrapper;
 	}
 
-	public async getCredentials(account: Account): Promise<ServiceClientCredentials[]> {
+	public async getCredentials(account: sqlops.Account, resource: sqlops.AzureResource): Promise<ServiceClientCredentials[]> {
 		try {
 			let credentials: TokenCredentials[] = [];
-			let tokens = await this._apiWrapper.getSecurityToken(account);
+			let tokens = await this._apiWrapper.getSecurityToken(account, resource);
 
 			for (let tenant of account.properties.tenants) {
 				let token = tokens[tenant.id].token;

extensions/azurecore/src/azureResource/tree/baseTreeNodes.ts

@@ -5,7 +5,7 @@
 
 'use strict';
 
-import { Account } from 'sqlops';
+import * as sqlops from 'sqlops';
 import { ServiceClientCredentials } from 'ms-rest';
 import { TreeNode } from '../../treeNodes';
 
@@ -28,7 +28,7 @@ export abstract class AzureResourceTreeNodeBase extends TreeNode {
 
 export abstract class AzureResourceContainerTreeNodeBase extends AzureResourceTreeNodeBase {
 	public constructor(
-		public readonly account: Account,
+		public readonly account: sqlops.Account,
 		treeChangeHandler: IAzureResourceTreeChangeHandler,
 		parent: TreeNode
 	) {
@@ -45,7 +45,7 @@ export abstract class AzureResourceContainerTreeNodeBase extends AzureResourceTr
 
 	protected async getCredentials(): Promise<ServiceClientCredentials[]> {
 		try {
-			return await this.servicePool.credentialService.getCredentials(this.account);
+			return await this.servicePool.credentialService.getCredentials(this.account, sqlops.AzureResource.ResourceManagement);
 		} catch (error) {
 			if (error instanceof AzureResourceCredentialError) {
 				this.servicePool.contextService.showErrorMessage(error.message);

extensions/azurecore/src/test/azureResource/tree/accountTreeNode.test.ts

@@ -87,7 +87,7 @@ describe('AzureResourceAccountTreeNode.info', function(): void {
 		mockServicePool.subscriptionService = mockSubscriptionService.object;
 		mockServicePool.subscriptionFilterService = mockSubscriptionFilterService.object;
 
-		mockCredentialService.setup((o) => o.getCredentials(mockAccount)).returns(() => Promise.resolve(mockCredentials));
+		mockCredentialService.setup((o) => o.getCredentials(mockAccount, sqlops.AzureResource.ResourceManagement)).returns(() => Promise.resolve(mockCredentials));
 		mockCacheService.setup((o) => o.get(TypeMoq.It.isAnyString())).returns(() => mockSubscriptionCache);
 		mockCacheService.setup((o) => o.update(TypeMoq.It.isAnyString(), TypeMoq.It.isAny())).returns(() => mockSubscriptionCache.subscriptions[mockAccount.key.accountId] = mockSubscriptions);
 	});
@@ -164,7 +164,7 @@ describe('AzureResourceAccountTreeNode.getChildren', function(): void {
 		mockServicePool.subscriptionService = mockSubscriptionService.object;
 		mockServicePool.subscriptionFilterService = mockSubscriptionFilterService.object;
 
-		mockCredentialService.setup((o) => o.getCredentials(mockAccount)).returns(() => Promise.resolve(mockCredentials));
+		mockCredentialService.setup((o) => o.getCredentials(mockAccount, sqlops.AzureResource.ResourceManagement)).returns(() => Promise.resolve(mockCredentials));
 		mockCacheService.setup((o) => o.get(TypeMoq.It.isAnyString())).returns(() => mockSubscriptionCache);
 		mockCacheService.setup((o) => o.update(TypeMoq.It.isAnyString(), TypeMoq.It.isAny())).returns(() => mockSubscriptionCache.subscriptions[mockAccount.key.accountId] = mockSubscriptions);
 	});
@@ -177,7 +177,7 @@ describe('AzureResourceAccountTreeNode.getChildren', function(): void {
 
 		const children = await accountTreeNode.getChildren();
 
-		mockCredentialService.verify((o) => o.getCredentials(mockAccount), TypeMoq.Times.once());
+		mockCredentialService.verify((o) => o.getCredentials(mockAccount, sqlops.AzureResource.ResourceManagement), TypeMoq.Times.once());
 		mockSubscriptionService.verify((o) => o.getSubscriptions(mockAccount, mockCredentials), TypeMoq.Times.once());
 		mockCacheService.verify((o) => o.get(TypeMoq.It.isAnyString()), TypeMoq.Times.once());
 		mockCacheService.verify((o) => o.update(TypeMoq.It.isAnyString(), TypeMoq.It.isAny()), TypeMoq.Times.once());
@@ -213,7 +213,7 @@ describe('AzureResourceAccountTreeNode.getChildren', function(): void {
 		await accountTreeNode.getChildren();
 		const children = await accountTreeNode.getChildren();
 
-		mockCredentialService.verify((o) => o.getCredentials(mockAccount), TypeMoq.Times.exactly(1));
+		mockCredentialService.verify((o) => o.getCredentials(mockAccount, sqlops.AzureResource.ResourceManagement), TypeMoq.Times.exactly(1));
 		mockSubscriptionService.verify((o) => o.getSubscriptions(mockAccount, mockCredentials), TypeMoq.Times.exactly(1));
 		mockCacheService.verify((o) => o.get(TypeMoq.It.isAnyString()), TypeMoq.Times.exactly(2));
 		mockCacheService.verify((o) => o.update(TypeMoq.It.isAnyString(), TypeMoq.It.isAny()), TypeMoq.Times.exactly(1));
@@ -267,7 +267,7 @@ describe('AzureResourceAccountTreeNode.getChildren', function(): void {
 
 		const children = await accountTreeNode.getChildren();
 
-		mockCredentialService.verify((o) => o.getCredentials(mockAccount), TypeMoq.Times.once());
+		mockCredentialService.verify((o) => o.getCredentials(mockAccount, sqlops.AzureResource.ResourceManagement), TypeMoq.Times.once());
 		mockSubscriptionService.verify((o) => o.getSubscriptions(mockAccount, mockCredentials), TypeMoq.Times.once());
 		mockCacheService.verify((o) => o.get(TypeMoq.It.isAnyString()), TypeMoq.Times.never());
 		mockCacheService.verify((o) => o.update(TypeMoq.It.isAnyString(), TypeMoq.It.isAny()), TypeMoq.Times.never());

extensions/azurecore/src/test/azureResource/tree/databaseContainerTreeNode.test.ts

@@ -118,7 +118,7 @@ describe('AzureResourceDatabaseContainerTreeNode.getChildren', function(): void
 		mockServicePool.credentialService = mockCredentialService.object;
 		mockServicePool.databaseService = mockDatabaseService.object;
 
-		mockCredentialService.setup((o) => o.getCredentials(mockAccount)).returns(() => Promise.resolve(mockCredentials));
+		mockCredentialService.setup((o) => o.getCredentials(mockAccount, sqlops.AzureResource.ResourceManagement)).returns(() => Promise.resolve(mockCredentials));
 		mockCacheService.setup((o) => o.get(TypeMoq.It.isAnyString())).returns(() => mockDatabaseContainerCache);
 		mockCacheService.setup((o) => o.update(TypeMoq.It.isAnyString(), TypeMoq.It.isAny())).returns(() => mockDatabaseContainerCache.databases[mockSubscription.id] = mockDatabases);
 	});
@@ -130,7 +130,7 @@ describe('AzureResourceDatabaseContainerTreeNode.getChildren', function(): void
 
 		const children = await databaseContainerTreeNode.getChildren();
 
-		mockCredentialService.verify((o) => o.getCredentials(mockAccount), TypeMoq.Times.once());
+		mockCredentialService.verify((o) => o.getCredentials(mockAccount, sqlops.AzureResource.ResourceManagement), TypeMoq.Times.once());
 		mockDatabaseService.verify((o) => o.getDatabases(mockSubscription, mockCredentials), TypeMoq.Times.once());
 		mockCacheService.verify((o) => o.get(TypeMoq.It.isAnyString()), TypeMoq.Times.once());
 		mockCacheService.verify((o) => o.update(TypeMoq.It.isAnyString(), TypeMoq.It.isAny()), TypeMoq.Times.once());
@@ -160,7 +160,7 @@ describe('AzureResourceDatabaseContainerTreeNode.getChildren', function(): void
 		await databaseContainerTreeNode.getChildren();
 		const children = await databaseContainerTreeNode.getChildren();
 
-		mockCredentialService.verify((o) => o.getCredentials(mockAccount), TypeMoq.Times.exactly(1));
+		mockCredentialService.verify((o) => o.getCredentials(mockAccount, sqlops.AzureResource.ResourceManagement), TypeMoq.Times.exactly(1));
 		mockDatabaseService.verify((o) => o.getDatabases(mockSubscription, mockCredentials), TypeMoq.Times.exactly(1));
 		mockCacheService.verify((o) => o.get(TypeMoq.It.isAnyString()), TypeMoq.Times.exactly(2));
 		mockCacheService.verify((o) => o.update(TypeMoq.It.isAnyString(), TypeMoq.It.isAny()), TypeMoq.Times.exactly(1));
@@ -193,7 +193,7 @@ describe('AzureResourceDatabaseContainerTreeNode.getChildren', function(): void
 		const databaseContainerTreeNode = new AzureResourceDatabaseContainerTreeNode(mockSubscription, mockAccount, mockTreeChangeHandler.object, undefined);
 		const children = await databaseContainerTreeNode.getChildren();
 
-		mockCredentialService.verify((o) => o.getCredentials(mockAccount), TypeMoq.Times.once());
+		mockCredentialService.verify((o) => o.getCredentials(mockAccount, sqlops.AzureResource.ResourceManagement), TypeMoq.Times.once());
 		mockDatabaseService.verify((o) => o.getDatabases(mockSubscription, mockCredentials), TypeMoq.Times.once());
 		mockCacheService.verify((o) => o.get(TypeMoq.It.isAnyString()), TypeMoq.Times.never());
 		mockCacheService.verify((o) => o.update(TypeMoq.It.isAnyString(), TypeMoq.It.isAny()), TypeMoq.Times.never());

extensions/azurecore/src/test/azureResource/tree/databaseServerContainerTreeNode.test.ts

@@ -118,7 +118,7 @@ describe('AzureResourceDatabaseServerContainerTreeNode.getChildren', function():
 		mockServicePool.credentialService = mockCredentialService.object;
 		mockServicePool.databaseServerService = mockDatabaseServerService.object;
 
-		mockCredentialService.setup((o) => o.getCredentials(mockAccount)).returns(() => Promise.resolve(mockCredentials));
+		mockCredentialService.setup((o) => o.getCredentials(mockAccount, sqlops.AzureResource.ResourceManagement)).returns(() => Promise.resolve(mockCredentials));
 		mockCacheService.setup((o) => o.get(TypeMoq.It.isAnyString())).returns(() => mockDatabaseServerContainerCache);
 		mockCacheService.setup((o) => o.update(TypeMoq.It.isAnyString(), TypeMoq.It.isAny())).returns(() => mockDatabaseServerContainerCache.databaseServers[mockSubscription.id] = mockDatabaseServers);
 	});
@@ -130,7 +130,7 @@ describe('AzureResourceDatabaseServerContainerTreeNode.getChildren', function():
 
 		const children = await databaseServerContainerTreeNode.getChildren();
 
-		mockCredentialService.verify((o) => o.getCredentials(mockAccount), TypeMoq.Times.once());
+		mockCredentialService.verify((o) => o.getCredentials(mockAccount, sqlops.AzureResource.ResourceManagement), TypeMoq.Times.once());
 		mockDatabaseServerService.verify((o) => o.getDatabaseServers(mockSubscription, mockCredentials), TypeMoq.Times.once());
 		mockCacheService.verify((o) => o.get(TypeMoq.It.isAnyString()), TypeMoq.Times.once());
 		mockCacheService.verify((o) => o.update(TypeMoq.It.isAnyString(), TypeMoq.It.isAny()), TypeMoq.Times.once());
@@ -160,7 +160,7 @@ describe('AzureResourceDatabaseServerContainerTreeNode.getChildren', function():
 		await databaseServerContainerTreeNode.getChildren();
 		const children = await databaseServerContainerTreeNode.getChildren();
 
-		mockCredentialService.verify((o) => o.getCredentials(mockAccount), TypeMoq.Times.exactly(1));
+		mockCredentialService.verify((o) => o.getCredentials(mockAccount, sqlops.AzureResource.ResourceManagement), TypeMoq.Times.exactly(1));
 		mockDatabaseServerService.verify((o) => o.getDatabaseServers(mockSubscription, mockCredentials), TypeMoq.Times.exactly(1));
 		mockCacheService.verify((o) => o.get(TypeMoq.It.isAnyString()), TypeMoq.Times.exactly(2));
 		mockCacheService.verify((o) => o.update(TypeMoq.It.isAnyString(), TypeMoq.It.isAny()), TypeMoq.Times.exactly(1));
@@ -193,7 +193,7 @@ describe('AzureResourceDatabaseServerContainerTreeNode.getChildren', function():
 		const databaseServerContainerTreeNode = new AzureResourceDatabaseServerContainerTreeNode(mockSubscription, mockAccount, mockTreeChangeHandler.object, undefined);
 		const children = await databaseServerContainerTreeNode.getChildren();
 
-		mockCredentialService.verify((o) => o.getCredentials(mockAccount), TypeMoq.Times.once());
+		mockCredentialService.verify((o) => o.getCredentials(mockAccount, sqlops.AzureResource.ResourceManagement), TypeMoq.Times.once());
 		mockDatabaseServerService.verify((o) => o.getDatabaseServers(mockSubscription, mockCredentials), TypeMoq.Times.once());
 		mockCacheService.verify((o) => o.get(TypeMoq.It.isAnyString()), TypeMoq.Times.never());
 		mockCacheService.verify((o) => o.update(TypeMoq.It.isAnyString(), TypeMoq.It.isAny()), TypeMoq.Times.never());

extensions/import/package.json

@@ -2,7 +2,7 @@
   "name": "import",
   "displayName": "SQL Server Import",
   "description": "SQL Server Import for Azure Data Studio supports importing CSV or JSON files into SQL Server.",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "publisher": "Microsoft",
   "preview": true,
   "engines": {
@@ -33,6 +33,15 @@
           "light": "./images/light_icon.svg",
           "dark": "./images/dark_icon.svg"
         }
+      },
+      {
+        "command": "dacFx.start",
+        "title": "Data-tier Application Wizard",
+        "category": "Data-tier Application",
+        "icon": {
+          "light": "./images/light_icon.svg",
+          "dark": "./images/dark_icon.svg"
+        }
       }
     ],
     "keybindings": [
@@ -48,6 +57,11 @@
           "command": "flatFileImport.start",
           "when": "connectionProvider == MSSQL && nodeType && nodeType == Database",
           "group": "import"
+        },
+        {
+          "command": "dacFx.start",
+          "when": "connectionProvider == MSSQL && nodeType && nodeType == Database",
+          "group": "export"
         }
       ]
     }

extensions/import/src/controllers/mainController.ts

@@ -13,6 +13,7 @@ import { FlatFileWizard } from '../wizard/flatFileWizard';
 import { ServiceClient } from '../services/serviceClient';
 import { ApiType, managerInstance } from '../services/serviceApiManager';
 import { FlatFileProvider } from '../services/contracts';
+import { DataTierApplicationWizard } from '../wizard/dataTierApplicationWizard';
 
 /**
  * The main controller class that initializes the extension
@@ -35,10 +36,15 @@ export default class MainController extends ControllerBase {
 			this.initializeFlatFileProvider(provider);
 		});
 
+		this.initializeDacFxWizard();
 		return Promise.resolve(true);
 	}
 
 	private initializeFlatFileProvider(provider: FlatFileProvider) {
 		sqlops.tasks.registerTask('flatFileImport.start', (profile: sqlops.IConnectionProfile, ...args: any[]) => new FlatFileWizard(provider).start(profile, args));
 	}
+
+	private initializeDacFxWizard() {
+		sqlops.tasks.registerTask('dacFx.start', (profile: sqlops.IConnectionProfile, ...args: any[]) => new DataTierApplicationWizard().start(profile, args));
+	}
 }

extensions/import/src/wizard/api/basePage.ts

@@ -0,0 +1,139 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 * as sqlops from 'sqlops';
+import { BaseDataModel } from './models';
+
+export abstract class BasePage {
+
+	protected readonly wizardPage: sqlops.window.modelviewdialog.WizardPage;
+	protected readonly model: BaseDataModel;
+	protected readonly view: sqlops.ModelView;
+
+	/**
+	 * This method constructs all the elements of the page.
+	 * @returns {Promise<boolean>}
+	 */
+	public async abstract start(): Promise<boolean>;
+
+	/**
+	 * This method is called when the user is entering the page.
+	 * @returns {Promise<boolean>}
+	 */
+	public async abstract onPageEnter(): Promise<boolean>;
+
+	/**
+	 * This method is called when the user is leaving the page.
+	 * @returns {Promise<boolean>}
+	 */
+	async onPageLeave(): Promise<boolean> {
+		return true;
+	}
+
+	/**
+	 * Override this method to cleanup what you don't need cached in the page.
+	 * @returns {Promise<boolean>}
+	 */
+	public async cleanup(): Promise<boolean> {
+		return true;
+	}
+
+	/**
+	 * Sets up a navigation validator.
+	 * This will be called right before onPageEnter().
+	 */
+	public abstract setupNavigationValidator();
+
+	protected async getServerValues(): Promise<{ connection, displayName, name }[]> {
+		let cons = await sqlops.connection.getActiveConnections();
+		// This user has no active connections ABORT MISSION
+		if (!cons || cons.length === 0) {
+			return undefined;
+		}
+
+		let count = -1;
+		let idx = -1;
+
+
+		let values = cons.map(c => {
+			// Handle the code to remember what the user's choice was from before
+			count++;
+			if (idx === -1) {
+				if (this.model.server && c.connectionId === this.model.server.connectionId) {
+					idx = count;
+				} else if (this.model.serverId && c.connectionId === this.model.serverId) {
+					idx = count;
+				}
+			}
+
+			let db = c.options.databaseDisplayName;
+			let usr = c.options.user;
+			let srv = c.options.server;
+
+			if (!db) {
+				db = '<default>';
+			}
+
+			if (!usr) {
+				usr = 'default';
+			}
+
+			let finalName = `${srv}, ${db} (${usr})`;
+			return {
+				connection: c,
+				displayName: finalName,
+				name: c.connectionId
+			};
+		});
+
+		if (idx >= 0) {
+			let tmp = values[0];
+			values[0] = values[idx];
+			values[idx] = tmp;
+		} else {
+			this.deleteServerValues();
+		}
+
+		return values;
+	}
+
+	protected async getDatabaseValues(): Promise<{ displayName, name }[]> {
+		let idx = -1;
+		let count = -1;
+		let values = (await sqlops.connection.listDatabases(this.model.server.connectionId)).map(db => {
+			count++;
+			if (this.model.database && db === this.model.database) {
+				idx = count;
+			}
+
+			return {
+				displayName: db,
+				name: db
+			};
+		});
+
+		if (idx >= 0) {
+			let tmp = values[0];
+			values[0] = values[idx];
+			values[idx] = tmp;
+		} else {
+			this.deleteDatabaseValues();
+		}
+
+		return values;
+	}
+
+	protected deleteServerValues() {
+		delete this.model.server;
+		delete this.model.serverId;
+		delete this.model.database;
+	}
+
+	protected deleteDatabaseValues() {
+		return;
+	}
+}
+

extensions/import/src/wizard/api/dacFxConfigPage.ts

@@ -0,0 +1,158 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 * as sqlops from 'sqlops';
+import * as nls from 'vscode-nls';
+import * as os from 'os';
+import * as path from 'path';
+import { DataTierApplicationWizard } from '../dataTierApplicationWizard';
+import { DacFxDataModel } from './models';
+import { BasePage } from './basePage';
+
+const localize = nls.loadMessageBundle();
+
+export abstract class DacFxConfigPage extends BasePage {
+
+	protected readonly wizardPage: sqlops.window.modelviewdialog.WizardPage;
+	protected readonly instance: DataTierApplicationWizard;
+	protected readonly model: DacFxDataModel;
+	protected readonly view: sqlops.ModelView;
+	protected serverDropdown: sqlops.DropDownComponent;
+	protected databaseTextBox: sqlops.InputBoxComponent;
+	protected databaseDropdown: sqlops.DropDownComponent;
+	protected databaseLoader: sqlops.LoadingComponent;
+	protected fileTextBox: sqlops.InputBoxComponent;
+	protected fileButton: sqlops.ButtonComponent;
+	protected fileExtension: string;
+
+	protected constructor(instance: DataTierApplicationWizard, wizardPage: sqlops.window.modelviewdialog.WizardPage, model: DacFxDataModel, view: sqlops.ModelView) {
+		super();
+		this.instance = instance;
+		this.wizardPage = wizardPage;
+		this.model = model;
+		this.view = view;
+	}
+
+	public setupNavigationValidator() {
+		this.instance.registerNavigationValidator(() => {
+			return true;
+		});
+	}
+
+	protected async createServerDropdown(isTargetServer: boolean): Promise<sqlops.FormComponent> {
+		this.serverDropdown = this.view.modelBuilder.dropDown().withProperties({
+			required: true
+		}).component();
+
+		// Handle server changes
+		this.serverDropdown.onValueChanged(async () => {
+			this.model.server = (this.serverDropdown.value as ConnectionDropdownValue).connection;
+			this.model.serverName = (this.serverDropdown.value as ConnectionDropdownValue).displayName;
+			await this.populateDatabaseDropdown();
+		});
+
+		let targetServerTitle = localize('dacFx.targetServerDropdownTitle', 'Target Server');
+		let sourceServerTitle = localize('dacFx.sourceServerDropdownTitle', 'Source Server');
+
+		return {
+			component: this.serverDropdown,
+			title: isTargetServer ? targetServerTitle : sourceServerTitle
+		};
+	}
+
+	protected async populateServerDropdown(): Promise<boolean> {
+		let values = await this.getServerValues();
+		if (values === undefined) {
+			return false;
+		}
+
+		this.model.server = values[0].connection;
+		this.model.serverName = values[0].displayName;
+
+		this.serverDropdown.updateProperties({
+			values: values
+		});
+		return true;
+	}
+
+	protected async createDatabaseTextBox(): Promise<sqlops.FormComponent> {
+		this.databaseTextBox = this.view.modelBuilder.inputBox().withProperties({
+			required: true
+		}).component();
+
+		this.databaseTextBox.onTextChanged(async () => {
+			this.model.database = this.databaseTextBox.value;
+		});
+
+		return {
+			component: this.databaseTextBox,
+			title: localize('dacFx.databaseNameTextBox', 'Target Database')
+		};
+	}
+
+	protected async createDatabaseDropdown(): Promise<sqlops.FormComponent> {
+		this.databaseDropdown = this.view.modelBuilder.dropDown().withProperties({
+			required: true
+		}).component();
+
+		// Handle database changes
+		this.databaseDropdown.onValueChanged(async () => {
+			this.model.database = (<sqlops.CategoryValue>this.databaseDropdown.value).name;
+			this.fileTextBox.value = this.generateFilePath();
+			this.model.filePath = this.fileTextBox.value;
+		});
+
+		this.databaseLoader = this.view.modelBuilder.loadingComponent().withItem(this.databaseDropdown).component();
+
+		return {
+			component: this.databaseLoader,
+			title: localize('dacFx.sourceDatabaseDropdownTitle', 'Source Database')
+		};
+	}
+
+	protected async populateDatabaseDropdown(): Promise<boolean> {
+		this.databaseLoader.loading = true;
+		this.databaseDropdown.updateProperties({ values: [] });
+
+		if (!this.model.server) {
+			this.databaseLoader.loading = false;
+			return false;
+		}
+
+		let values = await this.getDatabaseValues();
+		this.model.database = values[0].name;
+		this.model.filePath = this.generateFilePath();
+		this.fileTextBox.value = this.model.filePath;
+
+		this.databaseDropdown.updateProperties({
+			values: values
+		});
+		this.databaseLoader.loading = false;
+
+		return true;
+	}
+
+	protected async createFileBrowserParts() {
+		this.fileTextBox = this.view.modelBuilder.inputBox().withProperties({
+			required: true
+		}).component();
+
+		this.fileButton = this.view.modelBuilder.button().withProperties({
+			label: '•••',
+		}).component();
+	}
+
+	protected generateFilePath(): string {
+		let now = new Date();
+		let datetime = now.getFullYear() + '-' + (now.getMonth() + 1) + '-' + now.getDate() + '-' + now.getHours() + '-' + now.getMinutes();
+		return path.join(os.homedir(), this.model.database + '-' + datetime + this.fileExtension);
+	}
+}
+
+interface ConnectionDropdownValue extends sqlops.CategoryValue {
+	connection: sqlops.connection.Connection;
+}
+

extensions/import/src/wizard/api/importPage.ts

@@ -8,8 +8,9 @@ import { ImportDataModel } from './models';
 import * as sqlops from 'sqlops';
 import { FlatFileProvider } from '../../services/contracts';
 import { FlatFileWizard } from '../flatFileWizard';
+import { BasePage } from './basePage';
 
-export abstract class ImportPage {
+export abstract class ImportPage extends BasePage {
 
 	protected readonly wizardPage: sqlops.window.modelviewdialog.WizardPage;
 	protected readonly instance: FlatFileWizard;
@@ -18,42 +19,11 @@ export abstract class ImportPage {
 	protected readonly provider: FlatFileProvider;
 
 	protected constructor(instance: FlatFileWizard, wizardPage: sqlops.window.modelviewdialog.WizardPage, model: ImportDataModel, view: sqlops.ModelView, provider: FlatFileProvider) {
+		super();
 		this.instance = instance;
 		this.wizardPage = wizardPage;
 		this.model = model;
 		this.view = view;
 		this.provider = provider;
 	}
-
-	/**
-	 * This method constructs all the elements of the page.
-	 * @returns {Promise<boolean>}
-	 */
-	public async abstract start(): Promise<boolean>;
-
-	/**
-	 * This method is called when the user is entering the page.
-	 * @returns {Promise<boolean>}
-	 */
-	public async abstract onPageEnter(): Promise<boolean>;
-
-	/**
-	 * This method is called when the user is leaving the page.
-	 * @returns {Promise<boolean>}
-	 */
-	public async abstract onPageLeave(): Promise<boolean>;
-
-	/**
-	 * Sets up a navigation validator.
-	 * This will be called right before onPageEnter().
-	 */
-	public abstract setupNavigationValidator();
-
-	/**
-	 * Override this method to cleanup what you don't need cached in the page.
-	 * @returns {Promise<boolean>}
-	 */
-	public async cleanup(): Promise<boolean> {
-		return true;
-	}
 }

extensions/import/src/wizard/api/models.ts

@@ -6,15 +6,19 @@
 
 import * as sqlops from 'sqlops';
 
+export interface BaseDataModel {
+	server: sqlops.connection.Connection;
+	serverId: string;
+	database: string;
+}
+
 /**
  * The main data model that communicates between the pages.
  */
-export interface ImportDataModel {
+export interface ImportDataModel extends BaseDataModel {
 	ownerUri: string;
 	proseColumns: ColumnMetadata[];
 	proseDataPreview: string[][];
-	server: sqlops.connection.Connection;
-	serverId: string;
 	database: string;
 	table: string;
 	schema: string;
@@ -31,3 +35,14 @@ export interface ColumnMetadata {
 	primaryKey: boolean;
 	nullable: boolean;
 }
+
+/**
+ * Data model to communicate between DacFx pages
+ */
+export interface DacFxDataModel extends BaseDataModel {
+	serverName: string;
+	serverId: string;
+	filePath: string;
+	version: string;
+	upgradeExisting: boolean;
+}

extensions/import/src/wizard/dataTierApplicationWizard.ts

@@ -0,0 +1,253 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 * as vscode from 'vscode';
+import * as nls from 'vscode-nls';
+import * as sqlops from 'sqlops';
+import { SelectOperationPage } from './pages/selectOperationpage';
+import { DeployConfigPage } from './pages/deployConfigPage';
+import { DacFxSummaryPage } from './pages/dacFxSummaryPage';
+import { ExportConfigPage } from './pages/exportConfigPage';
+import { ExtractConfigPage } from './pages/extractConfigPage';
+import { ImportConfigPage } from './pages/importConfigPage';
+import { DacFxDataModel } from './api/models';
+import { BasePage } from './api/basePage';
+
+const localize = nls.loadMessageBundle();
+
+class Page {
+	wizardPage: sqlops.window.modelviewdialog.WizardPage;
+	dacFxPage: BasePage;
+
+	constructor(wizardPage: sqlops.window.modelviewdialog.WizardPage) {
+		this.wizardPage = wizardPage;
+	}
+}
+
+export enum Operation {
+	deploy,
+	extract,
+	import,
+	export
+}
+
+export class DataTierApplicationWizard {
+	public wizard: sqlops.window.modelviewdialog.Wizard;
+	private connection: sqlops.connection.Connection;
+	private model: DacFxDataModel;
+	public pages: Map<string, Page> = new Map<string, Page>();
+	public selectedOperation: Operation;
+
+	constructor() {
+	}
+
+	public async start(p: any, ...args: any[]) {
+		this.model = <DacFxDataModel>{};
+
+		let profile = p ? <sqlops.IConnectionProfile>p.connectionProfile : undefined;
+		if (profile) {
+			this.model.serverId = profile.id;
+			this.model.database = profile.databaseName;
+		}
+
+		this.connection = await sqlops.connection.getCurrentConnection();
+		if (!this.connection) {
+			this.connection = await sqlops.connection.openConnectionDialog();
+		}
+
+		this.wizard = sqlops.window.modelviewdialog.createWizard('Data-tier Application Wizard');
+		let selectOperationWizardPage = sqlops.window.modelviewdialog.createWizardPage(localize('dacFx.selectOperationPageName', 'Select an Operation'));
+		let deployConfigWizardPage = sqlops.window.modelviewdialog.createWizardPage(localize('dacFx.deployConfigPageName', 'Select Deploy Dacpac Settings'));
+		let summaryWizardPage = sqlops.window.modelviewdialog.createWizardPage(localize('dacFx.summaryPageName', 'Summary'));
+		let extractConfigWizardPage = sqlops.window.modelviewdialog.createWizardPage(localize('dacFx.extractConfigPageName', 'Select Extract Dacpac Settings'));
+		let importConfigWizardPage = sqlops.window.modelviewdialog.createWizardPage(localize('dacFx.importConfigPageName', 'Select Import Bacpac Settings'));
+		let exportConfigWizardPage = sqlops.window.modelviewdialog.createWizardPage(localize('dacFx.exportConfigPageName', 'Select Export Bacpac Settings'));
+
+		this.pages.set('selectOperation', new Page(selectOperationWizardPage));
+		this.pages.set('deployConfig', new Page(deployConfigWizardPage));
+		this.pages.set('extractConfig', new Page(extractConfigWizardPage));
+		this.pages.set('importConfig', new Page(importConfigWizardPage));
+		this.pages.set('exportConfig', new Page(exportConfigWizardPage));
+		this.pages.set('summary', new Page(summaryWizardPage));
+
+		selectOperationWizardPage.registerContent(async (view) => {
+			let selectOperationDacFxPage = new SelectOperationPage(this, selectOperationWizardPage, this.model, view);
+			this.pages.get('selectOperation').dacFxPage = selectOperationDacFxPage;
+			await selectOperationDacFxPage.start().then(() => {
+				selectOperationDacFxPage.setupNavigationValidator();
+				selectOperationDacFxPage.onPageEnter();
+			});
+		});
+
+		deployConfigWizardPage.registerContent(async (view) => {
+			let deployConfigDacFxPage = new DeployConfigPage(this, deployConfigWizardPage, this.model, view);
+			this.pages.get('deployConfig').dacFxPage = deployConfigDacFxPage;
+			await deployConfigDacFxPage.start();
+		});
+
+		extractConfigWizardPage.registerContent(async (view) => {
+			let extractConfigDacFxPage = new ExtractConfigPage(this, extractConfigWizardPage, this.model, view);
+			this.pages.get('extractConfig').dacFxPage = extractConfigDacFxPage;
+			await extractConfigDacFxPage.start();
+		});
+
+		importConfigWizardPage.registerContent(async (view) => {
+			let importConfigDacFxPage = new ImportConfigPage(this, importConfigWizardPage, this.model, view);
+			this.pages.get('importConfig').dacFxPage = importConfigDacFxPage;
+			await importConfigDacFxPage.start();
+		});
+
+		exportConfigWizardPage.registerContent(async (view) => {
+			let exportConfigDacFxPage = new ExportConfigPage(this, exportConfigWizardPage, this.model, view);
+			this.pages.get('exportConfig').dacFxPage = exportConfigDacFxPage;
+			await exportConfigDacFxPage.start();
+		});
+
+		summaryWizardPage.registerContent(async (view) => {
+			let summaryDacFxPage = new DacFxSummaryPage(this, summaryWizardPage, this.model, view);
+			this.pages.get('summary').dacFxPage = summaryDacFxPage;
+			await summaryDacFxPage.start();
+		});
+
+		this.wizard.onPageChanged(async (event) => {
+			let idx = event.newPage;
+			let page: Page;
+
+			if (idx === 1) {
+				switch (this.selectedOperation) {
+					case Operation.deploy: {
+						page = this.pages.get('deployConfig');
+						break;
+					}
+					case Operation.extract: {
+						page = this.pages.get('extractConfig');
+						break;
+					}
+					case Operation.import: {
+						page = this.pages.get('importConfig');
+						break;
+					}
+					case Operation.export: {
+						page = this.pages.get('exportConfig');
+						break;
+					}
+				}
+			} else if (idx === 2) {
+				page = this.pages.get('summary');
+			}
+
+			if (page !== undefined) {
+				page.dacFxPage.setupNavigationValidator();
+				page.dacFxPage.onPageEnter();
+			}
+		});
+
+		this.wizard.pages = [selectOperationWizardPage, deployConfigWizardPage, summaryWizardPage];
+		this.wizard.generateScriptButton.hidden = true;
+		this.wizard.doneButton.onClick(async () => await this.executeOperation());
+
+		this.wizard.open();
+	}
+
+	public registerNavigationValidator(validator: (pageChangeInfo: sqlops.window.modelviewdialog.WizardPageChangeInfo) => boolean) {
+		this.wizard.registerNavigationValidator(validator);
+	}
+
+	public setDoneButton(operation: Operation): void {
+		switch (operation) {
+			case Operation.deploy: {
+				this.wizard.doneButton.label = localize('dacFx.deployButton', 'Deploy');
+				this.selectedOperation = Operation.deploy;
+				break;
+			}
+			case Operation.extract: {
+				this.wizard.doneButton.label = localize('dacFx.extractButton', 'Extract');
+				this.selectedOperation = Operation.extract;
+				break;
+			}
+			case Operation.import: {
+				this.wizard.doneButton.label = localize('dacFx.importButton', 'Import');
+				this.selectedOperation = Operation.import;
+				break;
+			}
+			case Operation.export: {
+				this.wizard.doneButton.label = localize('dacFx.exportButton', 'Export');
+				this.selectedOperation = Operation.export;
+				break;
+			}
+		}
+	}
+
+	private async executeOperation() {
+		switch (this.selectedOperation) {
+			case Operation.deploy: {
+				await this.deploy();
+				break;
+			}
+			case Operation.extract: {
+				await this.extract();
+				break;
+			}
+			case Operation.import: {
+				await this.import();
+				break;
+			}
+			case Operation.export: {
+				await this.export();
+				break;
+			}
+		}
+	}
+
+	private async deploy() {
+		let service = await DataTierApplicationWizard.getService();
+		let ownerUri = await sqlops.connection.getUriForConnection(this.model.server.connectionId);
+
+		let result = await service.deployDacpac(this.model.filePath, this.model.database, this.model.upgradeExisting, ownerUri, sqlops.TaskExecutionMode.execute);
+		if (!result || !result.success) {
+			vscode.window.showErrorMessage(
+				localize('alertData.deployErrorMessage', "Deploy failed '{0}'", result.errorMessage ? result.errorMessage : 'Unknown'));
+		}
+	}
+
+	private async extract() {
+		let service = await DataTierApplicationWizard.getService();
+		let ownerUri = await sqlops.connection.getUriForConnection(this.model.server.connectionId);
+
+		let result = await service.extractDacpac(this.model.database, this.model.filePath, this.model.database, this.model.version, ownerUri, sqlops.TaskExecutionMode.execute);
+		if (!result || !result.success) {
+			vscode.window.showErrorMessage(
+				localize('alertData.extractErrorMessage', "Extract failed '{0}'", result.errorMessage ? result.errorMessage : 'Unknown'));
+		}
+	}
+
+	private async export() {
+		let service = await DataTierApplicationWizard.getService();
+		let ownerUri = await sqlops.connection.getUriForConnection(this.model.server.connectionId);
+
+		let result = await service.exportBacpac(this.model.database, this.model.filePath, ownerUri, sqlops.TaskExecutionMode.execute);
+		if (!result || !result.success) {
+			vscode.window.showErrorMessage(
+				localize('alertData.exportErrorMessage', "Export failed '{0}'", result.errorMessage ? result.errorMessage : 'Unknown'));
+		}
+	}
+
+	private async import() {
+		let service = await DataTierApplicationWizard.getService();
+		let ownerUri = await sqlops.connection.getUriForConnection(this.model.server.connectionId);
+
+		let result = await service.importBacpac(this.model.filePath, this.model.database, ownerUri, sqlops.TaskExecutionMode.execute);
+		if (!result || !result.success) {
+			vscode.window.showErrorMessage(
+				localize('alertData.importErrorMessage', "Import failed '{0}'", result.errorMessage ? result.errorMessage : 'Unknown'));
+		}
+	}
+
+	public static async getService(): Promise<sqlops.DacFxServicesProvider> {
+		let currentConnection = await sqlops.connection.getCurrentConnection();
+		let service = sqlops.dataprotocol.getProvider<sqlops.DacFxServicesProvider>(currentConnection.providerName, sqlops.DataProviderType.DacFxServicesProvider);
+		return service;
+	}
+}

extensions/import/src/wizard/pages/dacFxSummaryPage.ts

@@ -0,0 +1,112 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 * as sqlops from 'sqlops';
+import * as nls from 'vscode-nls';
+import { DacFxDataModel } from '../api/models';
+import { DataTierApplicationWizard, Operation } from '../dataTierApplicationWizard';
+import { BasePage } from '../api/basePage';
+
+const localize = nls.loadMessageBundle();
+
+export class DacFxSummaryPage extends BasePage {
+
+	protected readonly wizardPage: sqlops.window.modelviewdialog.WizardPage;
+	protected readonly instance: DataTierApplicationWizard;
+	protected readonly model: DacFxDataModel;
+	protected readonly view: sqlops.ModelView;
+
+	private form: sqlops.FormContainer;
+	private table: sqlops.TableComponent;
+	private loader: sqlops.LoadingComponent;
+
+	public constructor(instance: DataTierApplicationWizard, wizardPage: sqlops.window.modelviewdialog.WizardPage, model: DacFxDataModel, view: sqlops.ModelView) {
+		super();
+		this.instance = instance;
+		this.wizardPage = wizardPage;
+		this.model = model;
+		this.view = view;
+	}
+
+	async start(): Promise<boolean> {
+		this.table = this.view.modelBuilder.table().component();
+		this.loader = this.view.modelBuilder.loadingComponent().withItem(this.table).component();
+		this.form = this.view.modelBuilder.formContainer().withFormItems(
+			[
+				{
+					component: this.table,
+					title: ''
+				}
+			]
+		).component();
+		await this.view.initializeModel(this.form);
+		return true;
+	}
+
+	async onPageEnter(): Promise<boolean> {
+		this.populateTable();
+		this.loader.loading = false;
+		return true;
+	}
+
+	public setupNavigationValidator() {
+		this.instance.registerNavigationValidator(() => {
+			if (this.loader.loading) {
+				return false;
+			}
+			return true;
+		});
+	}
+
+	private populateTable() {
+		let data = [];
+		let targetServer = localize('dacfx.targetServerName', 'Target Server');
+		let targetDatabase = localize('dacfx.targetDatabaseName', 'Target Database');
+		let sourceServer = localize('dacfx.sourceServerName', 'Source Server');
+		let sourceDatabase = localize('dacfx.sourceDatabaseName', 'Source Database');
+		let fileLocation = localize('dacfx.fileLocation', 'File Location');
+
+		switch (this.instance.selectedOperation) {
+			case Operation.deploy: {
+				data = [
+					[targetServer, this.model.serverName],
+					[fileLocation, this.model.filePath],
+					[targetDatabase, this.model.database]];
+				break;
+			}
+			case Operation.extract: {
+				data = [
+					[sourceServer, this.model.serverName],
+					[sourceDatabase, this.model.database],
+					[localize('dacfxExtract.version', 'Version'), this.model.version],
+					[fileLocation, this.model.filePath]];
+				break;
+			}
+			case Operation.import: {
+				data = [
+					[targetServer, this.model.serverName],
+					[fileLocation, this.model.filePath],
+					[targetDatabase, this.model.database]];
+				break;
+			}
+			case Operation.export: {
+				data = [
+					[sourceServer, this.model.serverName],
+					[sourceDatabase, this.model.database],
+					[fileLocation, this.model.filePath]];
+				break;
+			}
+		}
+
+		this.table.updateProperties({
+			data: data,
+			columns: ['Setting', 'Value'],
+			width: 600,
+			height: 200
+		});
+	}
+}
+

extensions/import/src/wizard/pages/deployConfigPage.ts

@@ -0,0 +1,190 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 * as sqlops from 'sqlops';
+import * as nls from 'vscode-nls';
+import * as vscode from 'vscode';
+import * as path from 'path';
+import * as os from 'os';
+import { DacFxDataModel } from '../api/models';
+import { DataTierApplicationWizard } from '../dataTierApplicationWizard';
+import { DacFxConfigPage } from '../api/dacFxConfigPage';
+
+const localize = nls.loadMessageBundle();
+
+export class DeployConfigPage extends DacFxConfigPage {
+
+	protected readonly wizardPage: sqlops.window.modelviewdialog.WizardPage;
+	protected readonly instance: DataTierApplicationWizard;
+	protected readonly model: DacFxDataModel;
+	protected readonly view: sqlops.ModelView;
+	private databaseDropdownComponent: sqlops.FormComponent;
+	private databaseComponent: sqlops.FormComponent;
+	private formBuilder: sqlops.FormBuilder;
+	private form: sqlops.FormContainer;
+
+	public constructor(instance: DataTierApplicationWizard, wizardPage: sqlops.window.modelviewdialog.WizardPage, model: DacFxDataModel, view: sqlops.ModelView) {
+		super(instance, wizardPage, model, view);
+		this.fileExtension = '.bacpac';
+	}
+
+	async start(): Promise<boolean> {
+				let serverComponent = await this.createServerDropdown(true);
+		let fileBrowserComponent = await this.createFileBrowser();
+		this.databaseComponent = await this.createDatabaseTextBox();
+		this.databaseComponent.title = localize('dacFx.databaseNameTextBox', 'Database Name');
+		this.databaseDropdownComponent = await this.createDeployDatabaseDropdown();
+		this.databaseDropdownComponent.title = localize('dacFx.databaseNameDropdown', 'Database Name');
+		let radioButtons = await this.createRadiobuttons();
+
+		this.formBuilder = this.view.modelBuilder.formContainer()
+			.withFormItems(
+				[
+					fileBrowserComponent,
+					serverComponent,
+					radioButtons,
+					this.databaseDropdownComponent
+				], {
+					horizontal: true,
+					componentWidth: 400
+				});
+
+		this.form = this.formBuilder.component();
+		await this.view.initializeModel(this.form);
+		return true;
+	}
+
+	async onPageEnter(): Promise<boolean> {
+		let r1 = await this.populateServerDropdown();
+		let r2 = await this.populateDeployDatabaseDropdown();
+		return r1 && r2;
+	}
+
+	private async createFileBrowser(): Promise<sqlops.FormComponent> {
+		this.createFileBrowserParts();
+
+		this.fileButton.onDidClick(async (click) => {
+			let fileUris = await vscode.window.showOpenDialog(
+				{
+					canSelectFiles: true,
+					canSelectFolders: false,
+					canSelectMany: false,
+					defaultUri: vscode.Uri.file(os.homedir()),
+					openLabel: localize('dacFxDeploy.openFile', 'Open'),
+					filters: {
+						'dacpac Files': ['dacpac'],
+					}
+				}
+			);
+
+			if (!fileUris || fileUris.length === 0) {
+				return;
+			}
+
+			let fileUri = fileUris[0];
+			this.fileTextBox.value = fileUri.fsPath;
+			this.model.filePath = fileUri.fsPath;
+		});
+
+		this.fileTextBox.onTextChanged(async () => {
+			this.model.filePath = this.fileTextBox.value;
+			this.databaseTextBox.value = this.generateDatabaseName(this.model.filePath);
+			if (!this.model.upgradeExisting) {
+				this.model.database = this.databaseTextBox.value;
+			}
+		});
+
+		return {
+			component: this.fileTextBox,
+			title: localize('dacFxDeploy.fileTextboxTitle', 'File Location'),
+			actions: [this.fileButton]
+		};
+	}
+
+	private async createRadiobuttons(): Promise<sqlops.FormComponent> {
+		let upgradeRadioButton = this.view.modelBuilder.radioButton()
+			.withProperties({
+				name: 'updateExisting',
+				label: localize('dacFx.upgradeRadioButtonLabel', 'Upgrade Existing Database'),
+			}).component();
+
+		let newRadioButton = this.view.modelBuilder.radioButton()
+			.withProperties({
+				name: 'updateExisting',
+				label: localize('dacFx.newRadioButtonLabel', 'New Database'),
+			}).component();
+
+		upgradeRadioButton.onDidClick(() => {
+			this.model.upgradeExisting = true;
+			this.formBuilder.removeFormItem(this.databaseComponent);
+			this.formBuilder.addFormItem(this.databaseDropdownComponent, { horizontal: true, componentWidth: 400 });
+			this.model.database = (<sqlops.CategoryValue>this.databaseDropdown.value).name;
+		});
+
+		newRadioButton.onDidClick(() => {
+			this.model.upgradeExisting = false;
+			this.formBuilder.removeFormItem(this.databaseDropdownComponent);
+			this.formBuilder.addFormItem(this.databaseComponent, { horizontal: true, componentWidth: 400 });
+			this.model.database = this.databaseTextBox.value;
+		});
+
+		// Initialize with upgrade existing true
+		upgradeRadioButton.checked = true;
+		this.model.upgradeExisting = true;
+
+		let flexRadioButtonsModel = this.view.modelBuilder.flexContainer()
+			.withLayout({
+				flexFlow: 'row',
+			}).withItems([
+				upgradeRadioButton, newRadioButton]
+			).component();
+
+		return {
+			component: flexRadioButtonsModel,
+			title: localize('dacFx.targetDatabaseRadioButtonsTitle', 'Target Database')
+		};
+	}
+
+	protected async createDeployDatabaseDropdown(): Promise<sqlops.FormComponent> {
+			this.databaseDropdown = this.view.modelBuilder.dropDown().withProperties({
+			required: true
+		}).component();
+		// Handle database changes
+		this.databaseDropdown.onValueChanged(async () => {
+			this.model.database = (<sqlops.CategoryValue>this.databaseDropdown.value).name;
+		});
+		this.databaseLoader = this.view.modelBuilder.loadingComponent().withItem(this.databaseDropdown).component();
+		return {
+			component: this.databaseLoader,
+			title: localize('dacFx.targetDatabaseDropdownTitle', 'Database Name')
+		};
+	}
+
+	protected async populateDeployDatabaseDropdown(): Promise<boolean> {
+		this.databaseLoader.loading = true;
+		this.databaseDropdown.updateProperties({ values: [] });
+		if (!this.model.server) {
+			this.databaseLoader.loading = false;
+			return false;
+		}
+		let values = await this.getDatabaseValues();
+
+		if (this.model.database === undefined) {
+			this.model.database = values[0].name;
+		}
+
+		this.databaseDropdown.updateProperties({
+			values: values
+		});
+		this.databaseLoader.loading = false;
+		return true;
+	}
+
+	private generateDatabaseName(filePath: string): string {
+		let result = path.parse(filePath);
+		return result.name;
+	}
+}

extensions/import/src/wizard/pages/exportConfigPage.ts

@@ -0,0 +1,100 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 * as sqlops from 'sqlops';
+import * as nls from 'vscode-nls';
+import * as vscode from 'vscode';
+import { DacFxDataModel } from '../api/models';
+import { DataTierApplicationWizard } from '../dataTierApplicationWizard';
+import { DacFxConfigPage } from '../api/dacFxConfigPage';
+
+const localize = nls.loadMessageBundle();
+
+export class ExportConfigPage extends DacFxConfigPage {
+
+	protected readonly wizardPage: sqlops.window.modelviewdialog.WizardPage;
+	protected readonly instance: DataTierApplicationWizard;
+	protected readonly model: DacFxDataModel;
+	protected readonly view: sqlops.ModelView;
+
+	private form: sqlops.FormContainer;
+
+	public constructor(instance: DataTierApplicationWizard, wizardPage: sqlops.window.modelviewdialog.WizardPage, model: DacFxDataModel, view: sqlops.ModelView) {
+		super(instance, wizardPage, model, view);
+		this.fileExtension = '.bacpac';
+	}
+
+	async start(): Promise<boolean> {
+		let databaseComponent = await this.createDatabaseDropdown();
+		let serverComponent = await this.createServerDropdown(false);
+		let fileBrowserComponent = await this.createFileBrowser();
+
+		this.form = this.view.modelBuilder.formContainer()
+			.withFormItems(
+				[
+					serverComponent,
+					databaseComponent,
+					fileBrowserComponent,
+				], {
+					horizontal: true,
+					componentWidth: 400
+				}).component();
+		await this.view.initializeModel(this.form);
+		return true;
+	}
+
+	async onPageEnter(): Promise<boolean> {
+		let r1 = await this.populateServerDropdown();
+		let r2 = await this.populateDatabaseDropdown();
+		return r1 && r2;
+	}
+
+	public setupNavigationValidator() {
+		this.instance.registerNavigationValidator(() => {
+			if (this.databaseLoader.loading) {
+				return false;
+			}
+			return true;
+		});
+	}
+
+	private async createFileBrowser(): Promise<sqlops.FormComponent> {
+		this.createFileBrowserParts();
+
+		// default filepath
+		this.fileTextBox.value = this.generateFilePath();
+		this.model.filePath = this.fileTextBox.value;
+
+		this.fileButton.onDidClick(async (click) => {
+			let fileUri = await vscode.window.showSaveDialog(
+				{
+					defaultUri: vscode.Uri.file(this.fileTextBox.value),
+					saveLabel: localize('dacfxExport.saveFile', 'Save'),
+					filters: {
+						'bacpac Files': ['bacpac'],
+					}
+				}
+			);
+
+			if (!fileUri) {
+				return;
+			}
+
+			this.fileTextBox.value = fileUri.fsPath;
+			this.model.filePath = fileUri.fsPath;
+		});
+
+		this.fileTextBox.onTextChanged(async () => {
+			this.model.filePath = this.fileTextBox.value;
+		});
+
+		return {
+			component: this.fileTextBox,
+			title: localize('dacFxExport.fileTextboxTitle', 'File Location'),
+			actions: [this.fileButton]
+		};
+	}
+}

extensions/import/src/wizard/pages/extractConfigPage.ts

@@ -0,0 +1,122 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 * as sqlops from 'sqlops';
+import * as nls from 'vscode-nls';
+import * as vscode from 'vscode';
+import { DacFxDataModel } from '../api/models';
+import { DataTierApplicationWizard } from '../dataTierApplicationWizard';
+import { DacFxConfigPage } from '../api/dacFxConfigPage';
+
+const localize = nls.loadMessageBundle();
+
+export class ExtractConfigPage extends DacFxConfigPage {
+
+	protected readonly wizardPage: sqlops.window.modelviewdialog.WizardPage;
+	protected readonly instance: DataTierApplicationWizard;
+	protected readonly model: DacFxDataModel;
+	protected readonly view: sqlops.ModelView;
+
+	private form: sqlops.FormContainer;
+	private versionTextBox: sqlops.InputBoxComponent;
+
+	public constructor(instance: DataTierApplicationWizard, wizardPage: sqlops.window.modelviewdialog.WizardPage, model: DacFxDataModel, view: sqlops.ModelView) {
+		super(instance, wizardPage, model, view);
+		this.fileExtension = '.dacpac';
+	}
+
+	async start(): Promise<boolean> {
+		let databaseComponent = await this.createDatabaseDropdown();
+		let serverComponent = await this.createServerDropdown(false);
+		let fileBrowserComponent = await this.createFileBrowser();
+		let versionComponent = await this.createVersionTextBox();
+
+		this.form = this.view.modelBuilder.formContainer()
+			.withFormItems(
+				[
+					serverComponent,
+					databaseComponent,
+					versionComponent,
+					fileBrowserComponent,
+				], {
+					horizontal: true,
+					componentWidth: 400
+				}).component();
+		await this.view.initializeModel(this.form);
+		return true;
+	}
+
+	async onPageEnter(): Promise<boolean> {
+		let r1 = await this.populateServerDropdown();
+		let r2 = await this.populateDatabaseDropdown();
+		return r1 && r2;
+	}
+
+	public setupNavigationValidator() {
+		this.instance.registerNavigationValidator(() => {
+			if (this.databaseLoader.loading) {
+				return false;
+			}
+			return true;
+		});
+	}
+
+	private async createFileBrowser(): Promise<sqlops.FormComponent> {
+		this.createFileBrowserParts();
+
+		// default filepath
+		this.fileTextBox.value = this.generateFilePath();
+		this.model.filePath = this.fileTextBox.value;
+
+		this.fileButton.onDidClick(async (click) => {
+			let fileUri = await vscode.window.showSaveDialog(
+				{
+					defaultUri: vscode.Uri.file(this.fileTextBox.value),
+					saveLabel: localize('dacfxExtract.saveFile', 'Save'),
+					filters: {
+						'dacpac Files': ['dacpac'],
+					}
+				}
+			);
+
+			if (!fileUri) {
+				return;
+			}
+
+			this.fileTextBox.value = fileUri.fsPath;
+			this.model.filePath = fileUri.fsPath;
+		});
+
+		this.fileTextBox.onTextChanged(async () => {
+			this.model.filePath = this.fileTextBox.value;
+		});
+
+		return {
+			component: this.fileTextBox,
+			title: localize('dacFxExtract.fileTextboxTitle', 'File Location'),
+			actions: [this.fileButton]
+		};
+	}
+
+	private async createVersionTextBox(): Promise<sqlops.FormComponent> {
+		this.versionTextBox = this.view.modelBuilder.inputBox().withProperties({
+			required: true
+		}).component();
+
+		// default filepath
+		this.versionTextBox.value = '1.0.0.0';
+		this.model.version = this.versionTextBox.value;
+
+		this.versionTextBox.onTextChanged(async () => {
+			this.model.version = this.versionTextBox.value;
+		});
+
+		return {
+			component: this.versionTextBox,
+			title: localize('dacFxExtract.versionTextboxTitle', 'Version (use x.x.x.x where x is a number)'),
+		};
+	}
+}

extensions/import/src/wizard/pages/fileConfigPage.ts

@@ -102,57 +102,9 @@ export class FileConfigPage extends ImportPage {
 	}
 
 	private async populateServerDropdown(): Promise<boolean> {
-		let cons = await sqlops.connection.getActiveConnections();
-		// This user has no active connections ABORT MISSION
-		if (!cons || cons.length === 0) {
-			return true;
-		}
-
-
-		let count = -1;
-		let idx = -1;
-
-
-		let values = cons.map(c => {
-			// Handle the code to remember what the user's choice was from before
-			count++;
-			if (idx === -1) {
-				if (this.model.server && c.connectionId === this.model.server.connectionId) {
-					idx = count;
-				} else if (this.model.serverId && c.connectionId === this.model.serverId) {
-					idx = count;
-				}
-			}
-
-			let db = c.options.databaseDisplayName;
-			let usr = c.options.user;
-			let srv = c.options.server;
-
-			if (!db) {
-				db = '<default>';
-			}
-
-			if (!usr) {
-				usr = 'default';
-			}
-
-			let finalName = `${srv}, ${db} (${usr})`;
-			return {
-				connection: c,
-				displayName: finalName,
-				name: c.connectionId
-			};
-		});
-
-		if (idx >= 0) {
-			let tmp = values[0];
-			values[0] = values[idx];
-			values[idx] = tmp;
-		} else {
-			delete this.model.server;
-			delete this.model.serverId;
-			delete this.model.database;
-			delete this.model.schema;
+		let values = await this.getServerValues();
+		if (values === undefined) {
+			return false;
 		}
 
 		this.model.server = values[0].connection;
@@ -195,29 +147,7 @@ export class FileConfigPage extends ImportPage {
 			return false;
 		}
 
-
-		let idx = -1;
-		let count = -1;
-		let values = (await sqlops.connection.listDatabases(this.model.server.connectionId)).map(db => {
-			count++;
-			if (this.model.database && db === this.model.database) {
-				idx = count;
-			}
-
-			return {
-				displayName: db,
-				name: db
-			};
-		});
-
-		if (idx >= 0) {
-			let tmp = values[0];
-			values[0] = values[idx];
-			values[idx] = tmp;
-		} else {
-			delete this.model.database;
-			delete this.model.schema;
-		}
+		let values = await this.getDatabaseValues();
 
 		this.model.database = values[0].name;
 
@@ -377,6 +307,18 @@ export class FileConfigPage extends ImportPage {
 		return true;
 	}
 
+	protected deleteServerValues() {
+		delete this.model.server;
+		delete this.model.serverId;
+		delete this.model.database;
+		delete this.model.schema;
+	}
+
+	protected deleteDatabaseValues() {
+		delete this.model.database;
+		delete this.model.schema;
+	}
+
 	// private async populateTableNames(): Promise<boolean> {
 	// 	this.tableNames = [];
 	// 	let databaseName = (<sqlops.CategoryValue>this.databaseDropdown.value).name;

extensions/import/src/wizard/pages/importConfigPage.ts

@@ -0,0 +1,101 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 * as sqlops from 'sqlops';
+import * as nls from 'vscode-nls';
+import * as vscode from 'vscode';
+import * as path from 'path';
+import * as os from 'os';
+import { DacFxDataModel } from '../api/models';
+import { DataTierApplicationWizard } from '../dataTierApplicationWizard';
+import { DacFxConfigPage } from '../api/dacFxConfigPage';
+
+const localize = nls.loadMessageBundle();
+
+export class ImportConfigPage extends DacFxConfigPage {
+
+	protected readonly wizardPage: sqlops.window.modelviewdialog.WizardPage;
+	protected readonly instance: DataTierApplicationWizard;
+	protected readonly model: DacFxDataModel;
+	protected readonly view: sqlops.ModelView;
+
+	private form: sqlops.FormContainer;
+
+	public constructor(instance: DataTierApplicationWizard, wizardPage: sqlops.window.modelviewdialog.WizardPage, model: DacFxDataModel, view: sqlops.ModelView) {
+		super(instance, wizardPage, model, view);
+		this.fileExtension = '.bacpac';
+	}
+
+	async start(): Promise<boolean> {
+		let databaseComponent = await this.createDatabaseTextBox();
+		let serverComponent = await this.createServerDropdown(true);
+		let fileBrowserComponent = await this.createFileBrowser();
+
+		this.form = this.view.modelBuilder.formContainer()
+			.withFormItems(
+				[
+					fileBrowserComponent,
+					serverComponent,
+					databaseComponent,
+				], {
+					horizontal: true,
+					componentWidth: 400
+				}).component();
+		await this.view.initializeModel(this.form);
+		return true;
+	}
+
+	async onPageEnter(): Promise<boolean> {
+		let r1 = await this.populateServerDropdown();
+		return r1;
+	}
+
+	private async createFileBrowser(): Promise<sqlops.FormComponent> {
+		this.createFileBrowserParts();
+
+		this.fileButton.onDidClick(async (click) => {
+			let fileUris = await vscode.window.showOpenDialog(
+				{
+					canSelectFiles: true,
+					canSelectFolders: false,
+					canSelectMany: false,
+					defaultUri: vscode.Uri.file(os.homedir()),
+					openLabel: localize('dacFxImport.openFile', 'Open'),
+					filters: {
+						'bacpac Files': ['bacpac'],
+					}
+				}
+			);
+
+			if (!fileUris || fileUris.length === 0) {
+				return;
+			}
+
+			let fileUri = fileUris[0];
+			this.fileTextBox.value = fileUri.fsPath;
+			this.model.filePath = fileUri.fsPath;
+			this.model.database = this.generateDatabaseName(this.model.filePath);
+			this.databaseTextBox.value = this.model.database;
+		});
+
+		this.fileTextBox.onTextChanged(async () => {
+			this.model.filePath = this.fileTextBox.value;
+			this.model.database = this.generateDatabaseName(this.model.filePath);
+			this.databaseTextBox.value = this.model.database;
+		});
+
+		return {
+			component: this.fileTextBox,
+			title: localize('dacFxImport.fileTextboxTitle', 'File Location'),
+			actions: [this.fileButton]
+		};
+	}
+
+	private generateDatabaseName(filePath: string): string {
+		let result = path.parse(filePath);
+		return result.name;
+	}
+}

extensions/import/src/wizard/pages/selectOperationpage.ts

@@ -0,0 +1,174 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 * as sqlops from 'sqlops';
+import * as nls from 'vscode-nls';
+import { DacFxDataModel } from '../api/models';
+import { DataTierApplicationWizard, Operation } from '../dataTierApplicationWizard';
+import { BasePage } from '../api/basePage';
+
+const localize = nls.loadMessageBundle();
+
+export class SelectOperationPage extends BasePage {
+
+	protected readonly wizardPage: sqlops.window.modelviewdialog.WizardPage;
+	protected readonly instance: DataTierApplicationWizard;
+	protected readonly model: DacFxDataModel;
+	protected readonly view: sqlops.ModelView;
+
+	private deployRadioButton: sqlops.RadioButtonComponent;
+	private extractRadioButton: sqlops.RadioButtonComponent;
+	private importRadioButton: sqlops.RadioButtonComponent;
+	private exportRadioButton: sqlops.RadioButtonComponent;
+	private form: sqlops.FormContainer;
+
+	public constructor(instance: DataTierApplicationWizard, wizardPage: sqlops.window.modelviewdialog.WizardPage, model: DacFxDataModel, view: sqlops.ModelView) {
+		super();
+		this.instance = instance;
+		this.wizardPage = wizardPage;
+		this.model = model;
+		this.view = view;
+	}
+
+	async start(): Promise<boolean> {
+		let deployComponent = await this.createDeployRadioButton();
+		let extractComponent = await this.createExtractRadioButton();
+		let importComponent = await this.createImportRadioButton();
+		let exportComponent = await this.createExportRadioButton();
+
+		this.form = this.view.modelBuilder.formContainer()
+			.withFormItems(
+				[
+					deployComponent,
+					extractComponent,
+					importComponent,
+					exportComponent
+				], {
+					horizontal: true
+				}).component();
+		await this.view.initializeModel(this.form);
+
+		// default have the first radio button checked
+		this.deployRadioButton.checked = true;
+		this.instance.setDoneButton(Operation.deploy);
+		return true;
+	}
+
+	async onPageEnter(): Promise<boolean> {
+		let numPages = this.instance.wizard.pages.length;
+		for (let i = numPages - 1; i > 2; --i) {
+			await this.instance.wizard.removePage(i);
+		}
+
+		return true;
+	}
+
+	private async createDeployRadioButton(): Promise<sqlops.FormComponent> {
+		this.deployRadioButton = this.view.modelBuilder.radioButton()
+			.withProperties({
+				name: 'selectedOperation',
+				label: localize('dacFx.deployRadioButtonLabel', 'Deploy a data-tier application .dacpac file to an instance of SQL Server [Deploy Dacpac]'),
+			}).component();
+
+		this.deployRadioButton.onDidClick(() => {
+			// remove the previous page
+			this.instance.wizard.removePage(1);
+
+			// add deploy page
+			let page = this.instance.pages.get('deployConfig');
+			this.instance.wizard.addPage(page.wizardPage, 1);
+
+			// change button text and operation
+			this.instance.setDoneButton(Operation.deploy);
+		});
+
+		return {
+			component: this.deployRadioButton,
+			title: ''
+		};
+	}
+
+	private async createExtractRadioButton(): Promise<sqlops.FormComponent> {
+		this.extractRadioButton = this.view.modelBuilder.radioButton()
+			.withProperties({
+				name: 'selectedOperation',
+				label: localize('dacFx.extractRadioButtonLabel', 'Extract a data-tier application from an instance of SQL Server to a .dacpac file [Extract Dacpac]'),
+			}).component();
+
+		this.extractRadioButton.onDidClick(() => {
+			// remove the previous pages
+			this.instance.wizard.removePage(1);
+
+			// add the extract page
+			let page = this.instance.pages.get('extractConfig');
+			this.instance.wizard.addPage(page.wizardPage, 1);
+
+			// change button text and operation
+			this.instance.setDoneButton(Operation.extract);
+		});
+
+		return {
+			component: this.extractRadioButton,
+			title: ''
+		};
+	}
+
+	private async createImportRadioButton(): Promise<sqlops.FormComponent> {
+		this.importRadioButton = this.view.modelBuilder.radioButton()
+			.withProperties({
+				name: 'selectedOperation',
+				label: localize('dacFx.importRadioButtonLabel', 'Create a database from a .bacpac file [Import Bacpac]'),
+			}).component();
+
+		this.importRadioButton.onDidClick(() => {
+			// remove the  previous page
+			this.instance.wizard.removePage(1);
+
+			// add the import page
+			let page = this.instance.pages.get('importConfig');
+			this.instance.wizard.addPage(page.wizardPage, 1);
+
+			// change button text and operation
+			this.instance.setDoneButton(Operation.import);
+		});
+
+		return {
+			component: this.importRadioButton,
+			title: ''
+		};
+	}
+
+	private async createExportRadioButton(): Promise<sqlops.FormComponent> {
+		this.exportRadioButton = this.view.modelBuilder.radioButton()
+			.withProperties({
+				name: 'selectedOperation',
+				label: localize('dacFx.exportRadioButtonLabel', 'Export the schema and data from a database to the logical .bacpac file format [Export Bacpac]'),
+			}).component();
+
+		this.exportRadioButton.onDidClick(() => {
+			// remove the 2 previous pages
+			this.instance.wizard.removePage(1);
+
+			// add the export pages
+			let page = this.instance.pages.get('exportConfig');
+			this.instance.wizard.addPage(page.wizardPage, 1);
+
+			// change button text and operation
+			this.instance.setDoneButton(Operation.export);
+		});
+
+		return {
+			component: this.exportRadioButton,
+			title: ''
+		};
+	}
+
+	public setupNavigationValidator() {
+		this.instance.registerNavigationValidator(() => {
+			return true;
+		});
+	}
+}

extensions/mssql/package.json

@@ -285,6 +285,10 @@
             {
               "displayName": "Windows Authentication",
               "name": "Integrated"
+            },
+            {
+              "displayName": "Azure Active Directory - Universal with MFA support",
+              "name": "AzureMFA"
             }
           ],
           "isRequired": true,

extensions/mssql/src/config.json

@@ -1,6 +1,6 @@
 {
 	"downloadUrl": "https://github.com/Microsoft/sqltoolsservice/releases/download/v{#version#}/microsoft.sqltools.servicelayer-{#fileName#}",
-	"version": "1.5.0-alpha.58",
+	"version": "1.5.0-alpha.60",
 	"downloadFileNames": {
 		"Windows_86": "win-x86-netcoreapp2.2.zip",
 		"Windows_64": "win-x64-netcoreapp2.2.zip",

extensions/mssql/src/contracts.ts

@@ -291,3 +291,60 @@ export namespace DeleteAgentJobScheduleRequest {
 }
 
 // ------------------------------- < Agent Management > ------------------------------------
+
+// ------------------------------- < DacFx > ------------------------------------
+
+export enum TaskExecutionMode {
+	execute = 0,
+	script = 1,
+	executeAndScript = 2,
+}
+export interface ExportParams {
+	databaseName: string;
+	packageFilePath: string;
+	ownerUri: string;
+	taskExecutionMode: TaskExecutionMode;
+}
+
+export interface ImportParams {
+	packageFilePath: string;
+	databaseName: string;
+	ownerUri: string;
+	taskExecutionMode: TaskExecutionMode;
+}
+
+
+export interface ExtractParams {
+	databaseName: string;
+	packageFilePath: string;
+	applicationName: string;
+	applicationVersion: string;
+	ownerUri: string;
+	taskExecutionMode: TaskExecutionMode;
+}
+
+export interface DeployParams {
+	packageFilePath: string;
+	databaseName: string;
+	upgradeExisting: boolean;
+	ownerUri: string;
+	taskExecutionMode: TaskExecutionMode;
+}
+
+export namespace ExportRequest {
+	export const type = new RequestType<ExportParams, sqlops.DacFxResult, void, void>('dacfx/export');
+}
+
+export namespace ImportRequest {
+	export const type = new RequestType<ImportParams, sqlops.DacFxResult, void, void>('dacfx/import');
+}
+
+export namespace ExtractRequest {
+	export const type = new RequestType<ExtractParams, sqlops.DacFxResult, void, void>('dacfx/extract');
+}
+
+export namespace DeployRequest {
+	export const type = new RequestType<DeployParams, sqlops.DacFxResult, void, void>('dacfx/deploy');
+}
+
+// ------------------------------- < DacFx > ------------------------------------

extensions/mssql/src/features.ts

@@ -8,7 +8,7 @@ import { SqlOpsDataClient, SqlOpsFeature } from 'dataprotocol-client';
 import { ClientCapabilities, StaticFeature, RPCMessageType, ServerCapabilities } from 'vscode-languageclient';
 import { Disposable } from 'vscode';
 import { Telemetry } from './telemetry';
-import * as contracts  from './contracts';
+import * as contracts from './contracts';
 import * as sqlops from 'sqlops';
 import * as Utils from './utils';
 import * as UUID from 'vscode-languageclient/lib/utils/uuid';
@@ -28,6 +28,94 @@ export class TelemetryFeature implements StaticFeature {
 	}
 }
 
+export class DacFxServicesFeature extends SqlOpsFeature<undefined> {
+	private static readonly messageTypes: RPCMessageType[] = [
+		contracts.ExportRequest.type,
+		contracts.ImportRequest.type,
+		contracts.ExtractRequest.type,
+		contracts.DeployRequest.type
+	];
+
+	constructor(client: SqlOpsDataClient) {
+		super(client, DacFxServicesFeature.messageTypes);
+	}
+
+	public fillClientCapabilities(capabilities: ClientCapabilities): void {
+	}
+
+	public initialize(capabilities: ServerCapabilities): void {
+		this.register(this.messages, {
+			id: UUID.generateUuid(),
+			registerOptions: undefined
+		});
+	}
+
+	protected registerProvider(options: undefined): Disposable {
+		const client = this._client;
+		let self = this;
+
+		let exportBacpac = (databaseName: string, packageFilePath: string, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.DacFxResult> => {
+			let params: contracts.ExportParams = { databaseName: databaseName, packageFilePath: packageFilePath, ownerUri: ownerUri, taskExecutionMode: taskExecutionMode };
+			return client.sendRequest(contracts.ExportRequest.type, params).then(
+				r => {
+					return r;
+				},
+				e => {
+					client.logFailedRequest(contracts.ExportRequest.type, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
+		let importBacpac = (packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.DacFxResult> => {
+			let params: contracts.ImportParams = { packageFilePath: packageFilePath, databaseName: databaseName, ownerUri: ownerUri, taskExecutionMode: taskExecutionMode };
+			return client.sendRequest(contracts.ImportRequest.type, params).then(
+				r => {
+					return r;
+				},
+				e => {
+					client.logFailedRequest(contracts.ImportRequest.type, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
+		let extractDacpac = (databaseName: string, packageFilePath: string, applicationName: string, applicationVersion: string, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.DacFxResult> => {
+			let params: contracts.ExtractParams = { databaseName: databaseName, packageFilePath: packageFilePath, applicationName: applicationName, applicationVersion: applicationVersion, ownerUri: ownerUri, taskExecutionMode: taskExecutionMode };
+			return client.sendRequest(contracts.ExtractRequest.type, params).then(
+				r => {
+					return r;
+				},
+				e => {
+					client.logFailedRequest(contracts.ExtractRequest.type, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
+		let deployDacpac = (packageFilePath: string, targetDatabaseName: string, upgradeExisting: boolean, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.DacFxResult> => {
+			let params: contracts.DeployParams = { packageFilePath: packageFilePath, databaseName: targetDatabaseName, upgradeExisting: upgradeExisting, ownerUri: ownerUri, taskExecutionMode: taskExecutionMode };
+			return client.sendRequest(contracts.DeployRequest.type, params).then(
+				r => {
+					return r;
+				},
+				e => {
+					client.logFailedRequest(contracts.DeployRequest.type, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
+		return sqlops.dataprotocol.registerDacFxServicesProvider({
+			providerId: client.providerId,
+			exportBacpac,
+			importBacpac,
+			extractDacpac,
+			deployDacpac
+		});
+	}
+}
+
 export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 	private static readonly messagesTypes: RPCMessageType[] = [
 		contracts.AgentJobsRequest.type,
@@ -229,7 +317,7 @@ export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 		};
 
 		// Alert management methods
-		let  getAlerts = (ownerUri: string): Thenable<sqlops.AgentAlertsResult>  => {
+		let getAlerts = (ownerUri: string): Thenable<sqlops.AgentAlertsResult> => {
 			let params: contracts.AgentAlertsParams = {
 				ownerUri: ownerUri
 			};
@@ -299,7 +387,7 @@ export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 		};
 
 		// Operator management methods
-		let  getOperators = (ownerUri: string): Thenable<sqlops.AgentOperatorsResult>  => {
+		let getOperators = (ownerUri: string): Thenable<sqlops.AgentOperatorsResult> => {
 			let params: contracts.AgentOperatorsParams = {
 				ownerUri: ownerUri
 			};
@@ -369,7 +457,7 @@ export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 		};
 
 		// Proxy management methods
-		let  getProxies = (ownerUri: string): Thenable<sqlops.AgentProxiesResult>  => {
+		let getProxies = (ownerUri: string): Thenable<sqlops.AgentProxiesResult> => {
 			let params: contracts.AgentProxiesParams = {
 				ownerUri: ownerUri
 			};
@@ -439,7 +527,7 @@ export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 		};
 
 		// Agent Credential Method
-		let  getCredentials = (ownerUri: string): Thenable<sqlops.GetCredentialsResult>  => {
+		let getCredentials = (ownerUri: string): Thenable<sqlops.GetCredentialsResult> => {
 			let params: contracts.GetCredentialsParams = {
 				ownerUri: ownerUri
 			};
@@ -455,7 +543,7 @@ export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 
 
 		// Job Schedule management methods
-		let  getJobSchedules = (ownerUri: string): Thenable<sqlops.AgentJobSchedulesResult>  => {
+		let getJobSchedules = (ownerUri: string): Thenable<sqlops.AgentJobSchedulesResult> => {
 			let params: contracts.AgentJobScheduleParams = {
 				ownerUri: ownerUri
 			};

extensions/mssql/src/main.ts

@@ -16,7 +16,7 @@ import { CredentialStore } from './credentialstore/credentialstore';
 import { AzureResourceProvider } from './resourceProvider/resourceProvider';
 import * as Utils from './utils';
 import { Telemetry, LanguageClientErrorHandler } from './telemetry';
-import { TelemetryFeature, AgentServicesFeature } from './features';
+import { TelemetryFeature, AgentServicesFeature, DacFxServicesFeature } from './features';
 
 const baseConfig = require('./config.json');
 const outputChannel = vscode.window.createOutputChannel(Constants.serviceName);
@@ -55,7 +55,8 @@ export async function activate(context: vscode.ExtensionContext) {
 			// we only want to add new features
 			...SqlOpsDataClient.defaultFeatures,
 			TelemetryFeature,
-			AgentServicesFeature
+			AgentServicesFeature,
+			DacFxServicesFeature,
 		],
 		outputChannel: new CustomOutputChannel()
 	};

extensions/profiler/package.json

@@ -2,7 +2,7 @@
   "name": "profiler",
   "displayName": "SQL Server Profiler",
   "description": "SQL Server Profiler for Azure Data Studio",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "publisher": "Microsoft",
   "preview": true,
   "license": "https://raw.githubusercontent.com/Microsoft/azuredatastudio/master/LICENSE.txt",
@@ -26,8 +26,7 @@
     "Microsoft.mssql"
   ],
   "contributes": {
-    "commands": [
-      {
+    "commands": [{
         "command": "profiler.newProfiler",
         "title": "Launch Profiler",
         "category": "Profiler"
@@ -49,13 +48,23 @@
       }
     ],
     "menus": {
-      "objectExplorer/item/context": [
+      "commandPalette": [{
+          "command": "profiler.start",
+          "when": "False"
+        },
         {
-          "command": "profiler.newProfiler",
-          "when": "connectionProvider == MSSQL && nodeType && nodeType == Server",
-          "group": "profiler"
+          "command": "profiler.stop",
+          "when": "False"
+        }, {
+          "command": "profiler.openCreateSessionDialog",
+          "when": "False"
         }
-      ]
+      ],
+      "objectExplorer/item/context": [{
+        "command": "profiler.newProfiler",
+        "when": "connectionProvider == MSSQL && nodeType && nodeType == Server",
+        "group": "profiler"
+      }]
     },
     "outputChannels": [
       "sqlprofiler"

package.json

@@ -1,6 +1,6 @@
 {
   "name": "azuredatastudio",
-  "version": "1.3.3",
+  "version": "1.3.5",
   "distro": "8c3e97e3425cc9814496472ab73e076de2ba99ee",
   "author": {
     "name": "Microsoft Corporation"
@@ -102,12 +102,12 @@
     "documentdb": "^1.5.1",
     "electron-mksnapshot": "~1.7.0",
     "eslint": "^3.4.0",
-    "event-stream": "^3.3.4",
+    "event-stream": "3.3.4",
     "express": "^4.13.1",
     "glob": "^5.0.13",
     "gulp": "^3.9.1",
-    "gulp-atom-electron": "^1.16.1",
-    "gulp-azure-storage": "^0.7.0",
+    "gulp-atom-electron": "^1.19.2",
+    "gulp-azure-storage": "^0.8.2",
     "gulp-bom": "^1.0.0",
     "gulp-buffer": "0.0.2",
     "gulp-cli": "^2.0.1",
@@ -120,7 +120,7 @@
     "gulp-json-editor": "^2.2.1",
     "gulp-mocha": "^2.1.3",
     "gulp-plumber": "^1.2.0",
-    "gulp-remote-src": "^0.4.0",
+    "gulp-remote-src": "^0.4.4",
     "gulp-rename": "^1.2.0",
     "gulp-replace": "^0.5.4",
     "gulp-shell": "^0.5.2",
@@ -129,7 +129,7 @@
     "gulp-tslint": "^8.1.2",
     "gulp-uglify": "^3.0.0",
     "gulp-util": "^3.0.6",
-    "gulp-vinyl-zip": "^1.2.2",
+    "gulp-vinyl-zip": "^2.1.2",
     "husky": "^0.13.1",
     "innosetup-compiler": "^5.5.60",
     "is": "^3.1.0",
@@ -174,6 +174,7 @@
     "windows-process-tree": "0.2.2"
   },
   "resolutions": {
-    "rc": "1.2.8"
+    "rc": "1.2.8",
+    "event-stream": "3.3.4"
   }
 }

src/sql/base/browser/ui/modal/dialogHelper.ts

@@ -12,9 +12,10 @@ import * as types from 'vs/base/common/types';
 
 import * as sqlops from 'sqlops';
 
-export function appendRow(container: Builder, label: string, labelClass: string, cellContainerClass: string): Builder {
+export function appendRow(container: Builder, label: string, labelClass: string, cellContainerClass: string, rowContainerClass?: string): Builder {
 	let cellContainer: Builder;
-	container.element('tr', {}, (rowContainer) => {
+	let rowAttributes = rowContainerClass ? { class: rowContainerClass } : {};
+	container.element('tr', rowAttributes, (rowContainer) => {
 		rowContainer.element('td', { class: labelClass }, (labelCellContainer) => {
 			labelCellContainer.div({}, (labelContainer) => {
 				labelContainer.text(label);

src/sql/base/browser/ui/selectBox/selectBox.ts

@@ -75,7 +75,12 @@ export class SelectBox extends vsSelectBox {
 
 		// explicitly set the accessible role so that the screen readers can read the control type properly
 		this.selectElement.setAttribute('role', 'combobox');
+
 		this._selectBoxOptions = selectBoxOptions;
+		var focusTracker = dom.trackFocus(this.selectElement);
+		this._register(focusTracker);
+		this._register(focusTracker.onDidBlur(() => this._hideMessage()));
+		this._register(focusTracker.onDidFocus(() => this._showMessage()));
 	}
 
 	public style(styles: ISelectBoxStyles): void {
@@ -142,6 +147,10 @@ export class SelectBox extends vsSelectBox {
 		this.applyStyles();
 	}
 
+	public hasFocus(): boolean {
+		return document.activeElement === this.selectElement;
+	}
+
 	public showMessage(message: IMessage): void {
 		this.message = message;
 
@@ -163,7 +172,9 @@ export class SelectBox extends vsSelectBox {
 
 		aria.alert(alertText);
 
-		this._showMessage();
+		if (this.hasFocus()) {
+			this._showMessage();
+		}
 	}
 
 	public _showMessage(): void {

src/sql/parts/accountManagement/firewallRuleDialog/firewallRuleDialogController.ts

@@ -12,7 +12,7 @@ import * as sqlops from 'sqlops';
 import { IConnectionProfile } from 'sql/parts/connection/common/interfaces';
 import { IErrorMessageService } from 'sql/parts/connection/common/connectionManagement';
 import { FirewallRuleDialog } from 'sql/parts/accountManagement/firewallRuleDialog/firewallRuleDialog';
-import { IAccountManagementService } from 'sql/services/accountManagement/interfaces';
+import { IAccountManagementService, AzureResource } from 'sql/services/accountManagement/interfaces';
 import { IResourceProviderService } from 'sql/parts/accountManagement/common/interfaces';
 import { Deferred } from 'sql/base/common/promise';
 
@@ -61,7 +61,7 @@ export class FirewallRuleDialogController {
 	private handleOnCreateFirewallRule(): void {
 		let resourceProviderId = this._resourceProviderId;
 
-		this._accountManagementService.getSecurityToken(this._firewallRuleDialog.viewModel.selectedAccount).then(tokenMappings => {
+		this._accountManagementService.getSecurityToken(this._firewallRuleDialog.viewModel.selectedAccount, AzureResource.ResourceManagement).then(tokenMappings => {
 			let firewallRuleInfo: sqlops.FirewallRuleInfo = {
 				startIpAddress: this._firewallRuleDialog.viewModel.isIPAddressSelected ? this._firewallRuleDialog.viewModel.defaultIPAddress : this._firewallRuleDialog.viewModel.fromSubnetIPRange,
 				endIpAddress: this._firewallRuleDialog.viewModel.isIPAddressSelected ? this._firewallRuleDialog.viewModel.defaultIPAddress : this._firewallRuleDialog.viewModel.toSubnetIPRange,

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

@@ -34,12 +34,13 @@ import { Deferred } from 'sql/base/common/promise';
 import { ConnectionOptionSpecialType } from 'sql/workbench/api/common/sqlExtHostTypes';
 import { values } from 'sql/base/common/objects';
 import { ConnectionProviderProperties, IConnectionProviderRegistry, Extensions as ConnectionProviderExtensions } from 'sql/workbench/parts/connection/common/connectionProviderExtension';
+import { IAccountManagementService, AzureResource } from 'sql/services/accountManagement/interfaces';
 
 import * as sqlops from 'sqlops';
 
 import * as nls from 'vs/nls';
 import * as errors from 'vs/base/common/errors';
-import { IDisposable, dispose, Disposable } from 'vs/base/common/lifecycle';
+import { Disposable } from 'vs/base/common/lifecycle';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { IEditorService, ACTIVE_GROUP } from 'vs/workbench/services/editor/common/editorService';
 import * as platform from 'vs/platform/registry/common/platform';
@@ -58,7 +59,6 @@ import * as statusbar from 'vs/workbench/browser/parts/statusbar/statusbar';
 import { IViewletService } from 'vs/workbench/services/viewlet/browser/viewlet';
 import { IStatusbarService } from 'vs/platform/statusbar/common/statusbar';
 import { ICommandService } from 'vs/platform/commands/common/commands';
-import { EditorGroup } from 'vs/workbench/common/editor/editorGroup';
 
 export class ConnectionManagementService extends Disposable implements IConnectionManagementService {
 
@@ -100,7 +100,8 @@ export class ConnectionManagementService extends Disposable implements IConnecti
 		@IStatusbarService private _statusBarService: IStatusbarService,
 		@IResourceProviderService private _resourceProviderService: IResourceProviderService,
 		@IViewletService private _viewletService: IViewletService,
-		@IAngularEventingService private _angularEventing: IAngularEventingService
+		@IAngularEventingService private _angularEventing: IAngularEventingService,
+		@IAccountManagementService private _accountManagementService: IAccountManagementService
 	) {
 		super();
 		if (this._instantiationService) {
@@ -248,7 +249,8 @@ export class ConnectionManagementService extends Disposable implements IConnecti
 	 * Load the password for the profile
 	 * @param connectionProfile Connection Profile
 	 */
-	public addSavedPassword(connectionProfile: IConnectionProfile): Promise<IConnectionProfile> {
+	public async addSavedPassword(connectionProfile: IConnectionProfile): Promise<IConnectionProfile> {
+		await this.fillInAzureTokenIfNeeded(connectionProfile);
 		return this._connectionStore.addSavedPassword(connectionProfile).then(result => result.profile);
 	}
 
@@ -274,7 +276,7 @@ export class ConnectionManagementService extends Disposable implements IConnecti
 		let self = this;
 		return new Promise<IConnectionResult>((resolve, reject) => {
 			// Load the password if it's not already loaded
-			self._connectionStore.addSavedPassword(connection).then(result => {
+			self._connectionStore.addSavedPassword(connection).then(async result => {
 				let newConnection = result.profile;
 				let foundPassword = result.savedCred;
 
@@ -286,8 +288,12 @@ export class ConnectionManagementService extends Disposable implements IConnecti
 						foundPassword = true;
 					}
 				}
+
+				// Fill in the Azure account token if needed and open the connection dialog if it fails
+				let tokenFillSuccess = await self.fillInAzureTokenIfNeeded(newConnection);
+
 				// If the password is required and still not loaded show the dialog
-				if (!foundPassword && self._connectionStore.isPasswordRequired(newConnection) && !newConnection.password) {
+				if ((!foundPassword && self._connectionStore.isPasswordRequired(newConnection) && !newConnection.password) || !tokenFillSuccess) {
 					resolve(self.showConnectionDialogOnError(connection, owner, { connected: false, errorMessage: undefined, callStack: undefined, errorCode: undefined }, options));
 				} else {
 					// Try to connect
@@ -449,10 +455,14 @@ export class ConnectionManagementService extends Disposable implements IConnecti
 				showFirewallRuleOnError: true
 			};
 		}
-		return new Promise<IConnectionResult>((resolve, reject) => {
+		return new Promise<IConnectionResult>(async (resolve, reject) => {
 			if (callbacks.onConnectStart) {
 				callbacks.onConnectStart();
 			}
+			let tokenFillSuccess = await this.fillInAzureTokenIfNeeded(connection);
+			if (!tokenFillSuccess) {
+				throw new Error(nls.localize('connection.noAzureAccount', 'Failed to get Azure account token for connection'));
+			}
 			this.createNewConnection(uri, connection).then(connectionResult => {
 				if (connectionResult && connectionResult.connected) {
 					if (callbacks.onConnectSuccess) {
@@ -743,8 +753,33 @@ export class ConnectionManagementService extends Disposable implements IConnecti
 		}
 	}
 
+	private async fillInAzureTokenIfNeeded(connection: IConnectionProfile): Promise<boolean> {
+		if (connection.authenticationType !== Constants.azureMFA || connection.options['azureAccountToken']) {
+			return true;
+		}
+		let accounts = await this._accountManagementService.getAccountsForProvider('azurePublicCloud');
+		if (accounts && accounts.length > 0) {
+			let account = accounts.find(account => account.key.accountId === connection.userName);
+			if (account) {
+				if (account.isStale) {
+					try {
+						account = await this._accountManagementService.refreshAccount(account);
+					} catch {
+						// refreshAccount throws an error if the user cancels the dialog
+						return false;
+					}
+				}
+				let tokens = await this._accountManagementService.getSecurityToken(account, AzureResource.Sql);
+				connection.options['azureAccountToken'] = Object.values(tokens)[0].token;
+				connection.options['password'] = '';
+				return true;
+			}
+		}
+		return false;
+	}
+
 	// Request Senders
-	private sendConnectRequest(connection: IConnectionProfile, uri: string): Thenable<boolean> {
+	private async sendConnectRequest(connection: IConnectionProfile, uri: string): Promise<boolean> {
 		let connectionInfo = Object.assign({}, {
 			options: connection.options
 		});

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

@@ -33,4 +33,5 @@ export const passwordChars = '***************';
 /* authentication types */
 export const sqlLogin = 'SqlLogin';
 export const integrated = 'Integrated';
+export const azureMFA = 'AzureMFA';
 

src/sql/parts/connection/connectionDialog/connectionWidget.ts

@@ -22,6 +22,8 @@ import { Dropdown } from 'sql/base/browser/ui/editableDropdown/dropdown';
 import { IConnectionManagementService } from 'sql/parts/connection/common/connectionManagement';
 import { ICapabilitiesService } from 'sql/services/capabilities/capabilitiesService';
 import { ConnectionProfile } from '../common/connectionProfile';
+import * as styler from 'sql/common/theme/styler';
+import { IAccountManagementService } from 'sql/services/accountManagement/interfaces';
 
 import * as sqlops from 'sqlops';
 
@@ -30,7 +32,6 @@ import { IContextViewService } from 'vs/platform/contextview/browser/contextView
 import { localize } from 'vs/nls';
 import * as DOM from 'vs/base/browser/dom';
 import { IThemeService } from 'vs/platform/theme/common/themeService';
-import * as styler from 'vs/platform/theme/common/styler';
 import { OS, OperatingSystem } from 'vs/base/common/platform';
 import { Builder, $ } from 'vs/base/browser/builder';
 import { MessageType } from 'vs/base/browser/ui/inputbox/inputBox';
@@ -50,6 +51,11 @@ export class ConnectionWidget {
 	private _passwordInputBox: InputBox;
 	private _password: string;
 	private _rememberPasswordCheckBox: Checkbox;
+	private _azureAccountDropdown: SelectBox;
+	private _refreshCredentialsLinkBuilder: Builder;
+	private _addAzureAccountMessage: string = localize('connectionWidget.AddAzureAccount', 'Add an account...');
+	private readonly _azureProviderId = 'azurePublicCloud';
+	private _azureAccountList: sqlops.Account[];
 	private _advancedButton: Button;
 	private _callbacks: IConnectionComponentCallbacks;
 	private _authTypeSelectBox: SelectBox;
@@ -59,7 +65,7 @@ export class ConnectionWidget {
 	private _focusedBeforeHandleOnConnection: HTMLElement;
 	private _providerName: string;
 	private _authTypeMap: { [providerName: string]: AuthenticationType[] } = {
-		[Constants.mssqlProviderName]: [new AuthenticationType(Constants.integrated, false), new AuthenticationType(Constants.sqlLogin, true)]
+		[Constants.mssqlProviderName]: [AuthenticationType.SqlLogin, AuthenticationType.Integrated, AuthenticationType.AzureMFA]
 	};
 	private _saveProfile: boolean;
 	private _databaseDropdownExpanded: boolean = false;
@@ -96,7 +102,8 @@ export class ConnectionWidget {
 		@IConnectionManagementService private _connectionManagementService: IConnectionManagementService,
 		@ICapabilitiesService private _capabilitiesService: ICapabilitiesService,
 		@IClipboardService private _clipboardService: IClipboardService,
-		@IConfigurationService private _configurationService: IConfigurationService
+		@IConfigurationService private _configurationService: IConfigurationService,
+		@IAccountManagementService private _accountManagementService: IAccountManagementService
 	) {
 		this._callbacks = callbacks;
 		this._toDispose = [];
@@ -109,9 +116,9 @@ export class ConnectionWidget {
 		var authTypeOption = this._optionsMaps[ConnectionOptionSpecialType.authType];
 		if (authTypeOption) {
 			if (OS === OperatingSystem.Windows) {
-				authTypeOption.defaultValue = this.getAuthTypeDisplayName(Constants.integrated);
+				authTypeOption.defaultValue = this.getAuthTypeDisplayName(AuthenticationType.Integrated);
 			} else {
-				authTypeOption.defaultValue = this.getAuthTypeDisplayName(Constants.sqlLogin);
+				authTypeOption.defaultValue = this.getAuthTypeDisplayName(AuthenticationType.SqlLogin);
 			}
 			this._authTypeSelectBox = new SelectBox(authTypeOption.categoryValues.map(c => c.displayName), authTypeOption.defaultValue, this._contextViewService, undefined, { ariaLabel: authTypeOption.displayName });
 		}
@@ -182,7 +189,7 @@ export class ConnectionWidget {
 		// Username
 		let self = this;
 		let userNameOption = this._optionsMaps[ConnectionOptionSpecialType.userName];
-		let userNameBuilder = DialogHelper.appendRow(this._tableContainer, userNameOption.displayName, 'connection-label', 'connection-input');
+		let userNameBuilder = DialogHelper.appendRow(this._tableContainer, userNameOption.displayName, 'connection-label', 'connection-input', 'username-password-row');
 		this._userNameInputBox = new InputBox(userNameBuilder.getHTMLElement(), this._contextViewService, {
 			validationOptions: {
 				validation: (value: string) => self.validateUsername(value, userNameOption.isRequired) ? ({ type: MessageType.ERROR, content: localize('connectionWidget.missingRequireField', '{0} is required.', userNameOption.displayName) }) : null
@@ -191,14 +198,22 @@ export class ConnectionWidget {
 		});
 		// Password
 		let passwordOption = this._optionsMaps[ConnectionOptionSpecialType.password];
-		let passwordBuilder = DialogHelper.appendRow(this._tableContainer, passwordOption.displayName, 'connection-label', 'connection-input');
+		let passwordBuilder = DialogHelper.appendRow(this._tableContainer, passwordOption.displayName, 'connection-label', 'connection-input', 'username-password-row');
 		this._passwordInputBox = new InputBox(passwordBuilder.getHTMLElement(), this._contextViewService, { ariaLabel: passwordOption.displayName });
 		this._passwordInputBox.inputElement.type = 'password';
 		this._password = '';
 
 		// Remember password
 		let rememberPasswordLabel = localize('rememberPassword', 'Remember password');
-		this._rememberPasswordCheckBox = this.appendCheckbox(this._tableContainer, rememberPasswordLabel, 'connection-checkbox', 'connection-input', false);
+		this._rememberPasswordCheckBox = this.appendCheckbox(this._tableContainer, rememberPasswordLabel, 'connection-checkbox', 'connection-input', 'username-password-row', false);
+
+		// Azure account picker
+		let accountLabel = localize('connection.azureAccountDropdownLabel', 'Account');
+		let accountDropdownBuilder = DialogHelper.appendRow(this._tableContainer, accountLabel, 'connection-label', 'connection-input', 'azure-account-row');
+		this._azureAccountDropdown = new SelectBox([], undefined, this._contextViewService, accountDropdownBuilder.getContainer(), { ariaLabel: accountLabel });
+		DialogHelper.appendInputSelectBox(accountDropdownBuilder, this._azureAccountDropdown);
+		let refreshCredentialsBuilder = DialogHelper.appendRow(this._tableContainer, '', 'connection-label', 'connection-input', 'azure-account-row refresh-credentials-link');
+		this._refreshCredentialsLinkBuilder = refreshCredentialsBuilder.a({ href: '#' }).text(localize('connectionWidget.refreshAzureCredentials', 'Refresh account credentials'));
 
 		// Database
 		let databaseOption = this._optionsMaps[ConnectionOptionSpecialType.databaseName];
@@ -228,7 +243,7 @@ export class ConnectionWidget {
 
 	private validateUsername(value: string, isOptionRequired: boolean): boolean {
 		let currentAuthType = this._authTypeSelectBox ? this.getMatchingAuthType(this._authTypeSelectBox.value) : undefined;
-		if (!currentAuthType || currentAuthType.showUsernameAndPassword) {
+		if (!currentAuthType || currentAuthType === AuthenticationType.SqlLogin) {
 			if (!value && isOptionRequired) {
 				return true;
 			}
@@ -254,9 +269,9 @@ export class ConnectionWidget {
 		return button;
 	}
 
-	private appendCheckbox(container: Builder, label: string, checkboxClass: string, cellContainerClass: string, isChecked: boolean): Checkbox {
+	private appendCheckbox(container: Builder, label: string, checkboxClass: string, cellContainerClass: string, rowContainerClass: string, isChecked: boolean): Checkbox {
 		let checkbox: Checkbox;
-		container.element('tr', {}, (rowContainer) => {
+		container.element('tr', { class: rowContainerClass }, (rowContainer) => {
 			rowContainer.element('td');
 			rowContainer.element('td', { class: cellContainerClass }, (inputCellContainer) => {
 				checkbox = new Checkbox(inputCellContainer.getHTMLElement(), { label, checked: isChecked, ariaLabel: label });
@@ -275,6 +290,7 @@ export class ConnectionWidget {
 		this._toDispose.push(styler.attachSelectBoxStyler(this._serverGroupSelectBox, this._themeService));
 		this._toDispose.push(attachButtonStyler(this._advancedButton, this._themeService));
 		this._toDispose.push(attachCheckboxStyler(this._rememberPasswordCheckBox, this._themeService));
+		this._toDispose.push(styler.attachSelectBoxStyler(this._azureAccountDropdown, this._themeService));
 
 		if (this._authTypeSelectBox) {
 			// Theme styler
@@ -285,6 +301,23 @@ export class ConnectionWidget {
 			}));
 		}
 
+		if (this._azureAccountDropdown) {
+			this._toDispose.push(styler.attachSelectBoxStyler(this._azureAccountDropdown, this._themeService));
+			this._toDispose.push(this._azureAccountDropdown.onDidSelect(() => {
+				this.onAzureAccountSelected();
+			}));
+		}
+
+		if (this._refreshCredentialsLinkBuilder) {
+			this._toDispose.push(this._refreshCredentialsLinkBuilder.on(DOM.EventType.CLICK, async () => {
+				let account = this._azureAccountList.find(account => account.key.accountId === this._azureAccountDropdown.value);
+				if (account) {
+					await this._accountManagementService.refreshAccount(account);
+					this.fillInAzureAccountOptions();
+				}
+			}));
+		}
+
 		this._toDispose.push(this._serverGroupSelectBox.onDidSelect(selectedGroup => {
 			this.onGroupSelected(selectedGroup.selected);
 		}));
@@ -342,7 +375,7 @@ export class ConnectionWidget {
 	private setConnectButton(): void {
 		let showUsernameAndPassword: boolean = true;
 		if (this.authType) {
-			showUsernameAndPassword = this.authType.showUsernameAndPassword;
+			showUsernameAndPassword = this.authType === AuthenticationType.SqlLogin;
 		}
 		showUsernameAndPassword ? this._callbacks.onSetConnectButton(!!this.serverName && !!this.userName) :
 			this._callbacks.onSetConnectButton(!!this.serverName);
@@ -350,7 +383,7 @@ export class ConnectionWidget {
 
 	private onAuthTypeSelected(selectedAuthType: string) {
 		let currentAuthType = this.getMatchingAuthType(selectedAuthType);
-		if (!currentAuthType.showUsernameAndPassword) {
+		if (currentAuthType !== AuthenticationType.SqlLogin) {
 			this._userNameInputBox.disable();
 			this._passwordInputBox.disable();
 			this._userNameInputBox.hideMessage();
@@ -366,6 +399,68 @@ export class ConnectionWidget {
 			this._passwordInputBox.enable();
 			this._rememberPasswordCheckBox.enabled = true;
 		}
+
+		if (currentAuthType === AuthenticationType.AzureMFA) {
+			this.fillInAzureAccountOptions();
+			this._azureAccountDropdown.enable();
+			let tableContainer = this._tableContainer.getContainer();
+			tableContainer.classList.add('hide-username-password');
+			tableContainer.classList.remove('hide-azure-accounts');
+		} else {
+			this._azureAccountDropdown.disable();
+			let tableContainer = this._tableContainer.getContainer();
+			tableContainer.classList.remove('hide-username-password');
+			tableContainer.classList.add('hide-azure-accounts');
+			this._azureAccountDropdown.hideMessage();
+		}
+	}
+
+	private async fillInAzureAccountOptions(): Promise<void> {
+		let oldSelection = this._azureAccountDropdown.value;
+		this._azureAccountList = await this._accountManagementService.getAccountsForProvider(this._azureProviderId);
+		let accountDropdownOptions = this._azureAccountList.map(account => account.key.accountId);
+		if (accountDropdownOptions.length === 0) {
+			// If there are no accounts add a blank option so that add account isn't automatically selected
+			accountDropdownOptions.unshift('');
+		}
+		accountDropdownOptions.push(this._addAzureAccountMessage);
+		this._azureAccountDropdown.setOptions(accountDropdownOptions);
+		this._azureAccountDropdown.selectWithOptionName(oldSelection);
+		this.updateRefreshCredentialsLink();
+	}
+
+	private async updateRefreshCredentialsLink(): Promise<void> {
+		let chosenAccount = this._azureAccountList.find(account => account.key.accountId === this._azureAccountDropdown.value);
+		if (chosenAccount && chosenAccount.isStale) {
+			this._tableContainer.getContainer().classList.remove('hide-refresh-link');
+		} else {
+			this._tableContainer.getContainer().classList.add('hide-refresh-link');
+		}
+	}
+
+	private async onAzureAccountSelected(): Promise<void> {
+		// Reset the dropdown's validation message if the old selection was not valid but the new one is
+		this.validateAzureAccountSelection(false);
+		this._refreshCredentialsLinkBuilder.display('none');
+
+		// Open the add account dialog if needed, then select the added account
+		if (this._azureAccountDropdown.value === this._addAzureAccountMessage) {
+			let oldAccountIds = this._azureAccountList.map(account => account.key.accountId);
+			await this._accountManagementService.addAccount(this._azureProviderId);
+
+			// Refresh the dropdown's list to include the added account
+			await this.fillInAzureAccountOptions();
+
+			// If a new account was added find it and select it, otherwise select the first account
+			let newAccount = this._azureAccountList.find(option => !oldAccountIds.some(oldId => oldId === option.key.accountId));
+			if (newAccount) {
+				this._azureAccountDropdown.selectWithOptionName(newAccount.key.accountId);
+			} else {
+				this._azureAccountDropdown.select(0);
+			}
+		}
+
+		this.updateRefreshCredentialsLink();
 	}
 
 	private serverNameChanged(serverName: string) {
@@ -407,6 +502,7 @@ export class ConnectionWidget {
 	private clearValidationMessages(): void {
 		this._serverNameInputBox.hideMessage();
 		this._userNameInputBox.hideMessage();
+		this._azureAccountDropdown.hideMessage();
 	}
 
 	private getModelValue(value: string): string {
@@ -449,8 +545,12 @@ export class ConnectionWidget {
 
 			if (this._authTypeSelectBox) {
 				this.onAuthTypeSelected(this._authTypeSelectBox.value);
-
+			} else {
+				let tableContainerElement = this._tableContainer.getContainer();
+				tableContainerElement.classList.remove('hide-username-password');
+				tableContainerElement.classList.add('hide-azure-accounts');
 			}
+
 			// Disable connect button if -
 			// 1. Authentication type is SQL Login and no username is provided
 			// 2. No server name is provided
@@ -513,7 +613,7 @@ export class ConnectionWidget {
 			currentAuthType = this.getMatchingAuthType(this._authTypeSelectBox.value);
 		}
 
-		if (!currentAuthType || currentAuthType.showUsernameAndPassword) {
+		if (!currentAuthType || currentAuthType === AuthenticationType.SqlLogin) {
 			this._userNameInputBox.enable();
 			this._passwordInputBox.enable();
 			this._rememberPasswordCheckBox.enabled = true;
@@ -537,7 +637,7 @@ export class ConnectionWidget {
 	}
 
 	public get userName(): string {
-		return this._userNameInputBox.value;
+		return this.authenticationType === AuthenticationType.AzureMFA ? this._azureAccountDropdown.value : this._userNameInputBox.value;
 	}
 
 	public get password(): string {
@@ -548,6 +648,27 @@ export class ConnectionWidget {
 		return this._authTypeSelectBox ? this.getAuthTypeName(this._authTypeSelectBox.value) : undefined;
 	}
 
+	private validateAzureAccountSelection(showMessage: boolean = true): boolean {
+		if (this.authType !== AuthenticationType.AzureMFA) {
+			return true;
+		}
+
+		let selected = this._azureAccountDropdown.value;
+		if (selected === '' || selected === this._addAzureAccountMessage) {
+			if (showMessage) {
+				this._azureAccountDropdown.showMessage({
+					content: localize('connectionWidget.invalidAzureAccount', 'You must select an account'),
+					type: MessageType.ERROR
+				});
+			}
+			return false;
+		} else {
+			this._azureAccountDropdown.hideMessage();
+		}
+
+		return true;
+	}
+
 	private validateInputs(): boolean {
 		let isFocused = false;
 		let validateServerName = this._serverNameInputBox.validate();
@@ -565,7 +686,12 @@ export class ConnectionWidget {
 			this._passwordInputBox.focus();
 			isFocused = true;
 		}
-		return validateServerName && validateUserName && validatePassword;
+		let validateAzureAccount = this.validateAzureAccountSelection();
+		if (!validateAzureAccount && !isFocused) {
+			this._azureAccountDropdown.focus();
+			isFocused = true;
+		}
+		return validateServerName && validateUserName && validatePassword && validateAzureAccount;
 	}
 
 	public connect(model: IConnectionProfile): boolean {
@@ -613,7 +739,7 @@ export class ConnectionWidget {
 
 	private getMatchingAuthType(displayName: string): AuthenticationType {
 		const authType = this._authTypeMap[this._providerName];
-		return authType ? authType.find(authType => this.getAuthTypeDisplayName(authType.name) === displayName) : undefined;
+		return authType ? authType.find(authType => this.getAuthTypeDisplayName(authType) === displayName) : undefined;
 	}
 
 	public closeDatabaseDropdown(): void {
@@ -634,18 +760,14 @@ export class ConnectionWidget {
 	}
 
 	private focusPasswordIfNeeded(): void {
-		if (this.authType && this.authType.showUsernameAndPassword && this.userName && !this.password) {
+		if (this.authType && this.authType === AuthenticationType.SqlLogin && this.userName && !this.password) {
 			this._passwordInputBox.focus();
 		}
 	}
 }
 
-class AuthenticationType {
-	public name: string;
-	public showUsernameAndPassword: boolean;
-
-	constructor(name: string, showUsernameAndPassword: boolean) {
-		this.name = name;
-		this.showUsernameAndPassword = showUsernameAndPassword;
-	}
+enum AuthenticationType {
+	SqlLogin = 'SqlLogin',
+	Integrated = 'Integrated',
+	AzureMFA = 'AzureMFA'
 }

src/sql/parts/connection/connectionDialog/media/connectionDialog.css

@@ -28,11 +28,12 @@
 	overflow: hidden;
 	margin: 0px 11px;
 }
+
 .connection-dialog .tabBody {
 	overflow: hidden;
-    flex: 1 1;
-    display: flex;
-    flex-direction: column;
+	flex: 1 1;
+	display: flex;
+	flex-direction: column;
 }
 
 .connection-recent, .connection-saved {
@@ -114,4 +115,16 @@
 	margin: 5px 0px;
 	padding: 5px 15px;
 	font-weight: 600;
-}
+}
+
+.hide-azure-accounts .azure-account-row {
+	display: none;
+}
+
+.hide-username-password .username-password-row {
+	display: none;
+}
+
+.hide-refresh-link .azure-account-row.refresh-credentials-link {
+	display: none;
+}

src/sql/parts/notebook/cellViews/code.component.html

@@ -9,6 +9,6 @@
 	</div>
 	<div #editor class="editor" style="flex: 1 1 auto; overflow: hidden;">
 	</div>
-	<div #moreactions class="toolbar" style="flex: 0 0 auto; display: flex; flex-flow:column; width: 20px; min-height: 20px; max-height: 20px; padding-top: 10px; orientation: portrait">
+	<div #moreactions class="toolbar" style="flex: 0 0 auto; display: flex; flex-flow:column; width: 20px; min-height: 20px; max-height: 20px; padding-top: 0px; orientation: portrait">
 	</div>
 </div>

src/sql/parts/notebook/cellViews/code.component.ts

@@ -4,7 +4,7 @@
 *--------------------------------------------------------------------------------------------*/
 import 'vs/css!./code';
 
-import { OnInit, Component, Input, Inject, forwardRef, ElementRef, ChangeDetectorRef, OnDestroy, ViewChild, Output, EventEmitter } from '@angular/core';
+import { OnInit, Component, Input, Inject, forwardRef, ElementRef, ChangeDetectorRef, OnDestroy, ViewChild, Output, EventEmitter, OnChanges, SimpleChange } from '@angular/core';
 
 import { CommonServiceInterface } from 'sql/services/common/commonServiceInterface.service';
 import { AngularDisposable } from 'sql/base/common/lifecycle';
@@ -41,11 +41,12 @@ export const CODE_SELECTOR: string = 'code-component';
 	selector: CODE_SELECTOR,
 	templateUrl: decodeURI(require.toUrl('./code.component.html'))
 })
-export class CodeComponent extends AngularDisposable implements OnInit {
+export class CodeComponent extends AngularDisposable implements OnInit, OnChanges {
 	@ViewChild('toolbar', { read: ElementRef }) private toolbarElement: ElementRef;
-	@ViewChild('moreactions', { read: ElementRef }) private moreactionsElement: ElementRef;
+	@ViewChild('moreactions', { read: ElementRef }) private moreActionsElementRef: ElementRef;
 	@ViewChild('editor', { read: ElementRef }) private codeElement: ElementRef;
 	@Input() cellModel: ICellModel;
+	@Input() hideVerticalToolbar: boolean = false;
 
 	@Output() public onContentChanged = new EventEmitter<void>();
 
@@ -53,6 +54,10 @@ export class CodeComponent extends AngularDisposable implements OnInit {
 		this._model = value;
 	}
 
+	@Input() set activeCellId(value: string) {
+		this._activeCellId = value;
+	}
+
 	protected _actionBar: Taskbar;
 	protected _moreActions: ActionBar;
 	private readonly _minimumHeight = 30;
@@ -61,6 +66,8 @@ export class CodeComponent extends AngularDisposable implements OnInit {
 	private _editorModel: ITextModel;
 	private _uri: string;
 	private _model: NotebookModel;
+	private _actions: Action[] = [];
+	private _activeCellId: string;
 
 	constructor(
 		@Inject(forwardRef(() => CommonServiceInterface)) private _bootstrapService: CommonServiceInterface,
@@ -74,17 +81,38 @@ export class CodeComponent extends AngularDisposable implements OnInit {
 		@Inject(INotificationService) private notificationService: INotificationService,
 	) {
 		super();
+		this._actions.push(
+			this._instantiationService.createInstance(AddCellAction, 'codeBefore', localize('codeBefore', 'Insert Code before'), CellTypes.Code, false),
+			this._instantiationService.createInstance(AddCellAction, 'codeAfter', localize('codeAfter', 'Insert Code after'), CellTypes.Code, true),
+			this._instantiationService.createInstance(AddCellAction, 'markdownBefore', localize('markdownBefore', 'Insert Markdown before'), CellTypes.Markdown, false),
+			this._instantiationService.createInstance(AddCellAction, 'markdownAfter', localize('markdownAfter', 'Insert Markdown after'), CellTypes.Markdown, true),
+			this._instantiationService.createInstance(DeleteCellAction, 'delete', localize('delete', 'Delete'))
+		);
 	}
 
 	ngOnInit() {
 		this._register(this.themeService.onDidColorThemeChange(this.updateTheme, this));
 		this.updateTheme(this.themeService.getColorTheme());
-		this.initActionBar();
+		if (!this.hideVerticalToolbar) {
+			this.initActionBar();
+		}
 	}
 
-	ngOnChanges() {
+	ngOnChanges(changes: { [propKey: string]: SimpleChange }) {
 		this.updateLanguageMode();
 		this.updateModel();
+		for (let propName in changes) {
+			if (propName === 'activeCellId') {
+				let changedProp = changes[propName];
+				if (this.cellModel.id === changedProp.currentValue) {
+					this.toggleMoreActions(true);
+				}
+				else {
+					this.toggleMoreActions(false);
+				}
+				break;
+			}
+		}
 	}
 
 	ngAfterContentInit(): void {
@@ -98,6 +126,10 @@ export class CodeComponent extends AngularDisposable implements OnInit {
 		return this._model;
 	}
 
+	get activeCellId(): string {
+		return this._activeCellId;
+	}
+
 	private createEditor(): void {
 		let instantiationService = this._instantiationService.createChild(new ServiceCollection([IProgressService, new SimpleProgressService()]));
 		this._editor = instantiationService.createInstance(QueryTextEditor);
@@ -139,19 +171,22 @@ export class CodeComponent extends AngularDisposable implements OnInit {
 		this._actionBar.setContent([
 			{ action: runCellAction }
 		]);
+	}
 
-		let moreActionsElement = <HTMLElement>this.moreactionsElement.nativeElement;
-		this._moreActions = new ActionBar(moreActionsElement, { orientation: ActionsOrientation.VERTICAL });
-		this._moreActions.context = { target: moreActionsElement };
-
-		let actions: Action[] = [];
-		actions.push(this._instantiationService.createInstance(AddCellAction, 'codeBefore', localize('codeBefore', 'Insert Code before'), CellTypes.Code, false));
-		actions.push(this._instantiationService.createInstance(AddCellAction, 'codeAfter', localize('codeAfter', 'Insert Code after'), CellTypes.Code, true));
-		actions.push(this._instantiationService.createInstance(AddCellAction, 'markdownBefore', localize('markdownBefore', 'Insert Markdown before'), CellTypes.Markdown, false));
-		actions.push(this._instantiationService.createInstance(AddCellAction, 'markdownAfter', localize('markdownAfter', 'Insert Markdown after'), CellTypes.Markdown, true));
-		actions.push(this._instantiationService.createInstance(DeleteCellAction, 'delete', localize('delete', 'Delete')));
-
-		this._moreActions.push(this._instantiationService.createInstance(ToggleMoreWidgetAction, actions, context), { icon: true, label: false });
+	private toggleMoreActions(showIcon: boolean) {
+		let context = new CellContext(this.model, this.cellModel);
+		let moreActionsElement = <HTMLElement>this.moreActionsElementRef.nativeElement;
+		if (showIcon) {
+			if (moreActionsElement.childNodes.length > 0) {
+				moreActionsElement.removeChild(moreActionsElement.childNodes[0]);
+			}
+			this._moreActions = new ActionBar(moreActionsElement, { orientation: ActionsOrientation.VERTICAL });
+			this._moreActions.context = { target: moreActionsElement };
+			this._moreActions.push(this._instantiationService.createInstance(ToggleMoreWidgetAction, this._actions, context), { icon: showIcon, label: false });
+		}
+		else if (moreActionsElement.childNodes.length > 0) {
+			moreActionsElement.removeChild(moreActionsElement.childNodes[0]);
+		}
 	}
 
 	private createUri(): URI {
@@ -180,8 +215,8 @@ export class CodeComponent extends AngularDisposable implements OnInit {
 		let toolbarEl = <HTMLElement>this.toolbarElement.nativeElement;
 		toolbarEl.style.borderRightColor = theme.getColor(themeColors.SIDE_BAR_BACKGROUND, true).toString();
 
-		let moreactionsEl = <HTMLElement>this.moreactionsElement.nativeElement;
-		moreactionsEl.style.borderRightColor = theme.getColor(themeColors.SIDE_BAR_BACKGROUND, true).toString();
+		let moreActionsEl = <HTMLElement>this.moreActionsElementRef.nativeElement;
+		moreActionsEl.style.borderRightColor = theme.getColor(themeColors.SIDE_BAR_BACKGROUND, true).toString();
 	}
 
 }

src/sql/parts/notebook/cellViews/code.css

@@ -11,7 +11,6 @@ code-component {
 
 code-component .toolbar {
 	border-right-width: 1px;
-	border-right-style: solid;
 }
 
 code-component .toolbarIconRun {

src/sql/parts/notebook/cellViews/codeActions.ts

@@ -173,7 +173,7 @@ export class DeleteCellAction extends CellActionBase {
 
 	runCellAction(context: CellContext): Promise<void> {
 		try {
-				context.model.deleteCell(context.cell);
+			context.model.deleteCell(context.cell);
 		} catch (error) {
 			let message = getErrorMessage(error);
 

src/sql/parts/notebook/cellViews/codeCell.component.html

@@ -6,9 +6,9 @@
 -->
 <div style="overflow: hidden; width: 100%; height: 100%; display: flex; flex-flow: column">
 	<div class="notebook-code" style="flex: 0 0 auto;">
-		<code-component [cellModel]="cellModel" [model]="model"></code-component>
+		<code-component [cellModel]="cellModel" [model]="model" [activeCellId]="activeCellId"></code-component>
 	</div>
-	<div #codeCellOutput class="notebook-output" style="flex: 0 0 auto;">
+	<div style="flex: 0 0 auto; width: 100%; height: 100%; display: block">
 		<output-area-component *ngIf="cellModel.outputs && cellModel.outputs.length > 0" [cellModel]="cellModel">
 		</output-area-component>
 	</div>

src/sql/parts/notebook/cellViews/codeCell.component.ts

@@ -2,15 +2,10 @@
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the Source EULA. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
-import 'vs/css!./codeCell';
-
-import { OnInit, Component, Input, Inject, forwardRef, ElementRef, ChangeDetectorRef, OnDestroy, ViewChild } from '@angular/core';
 
+import { OnInit, Component, Input, Inject, forwardRef, ElementRef, ChangeDetectorRef, OnDestroy, ViewChild, SimpleChange, OnChanges } from '@angular/core';
 import { CommonServiceInterface } from 'sql/services/common/commonServiceInterface.service';
 import { CellView } from 'sql/parts/notebook/cellViews/interfaces';
-
-import { IColorTheme, IWorkbenchThemeService } from 'vs/workbench/services/themes/common/workbenchThemeService';
-import * as themeColors from 'vs/workbench/common/theme';
 import { ICellModel } from 'sql/parts/notebook/models/modelInterfaces';
 import { NotebookModel } from 'sql/parts/notebook/models/notebookModel';
 
@@ -21,24 +16,27 @@ export const CODE_SELECTOR: string = 'code-cell-component';
 	selector: CODE_SELECTOR,
 	templateUrl: decodeURI(require.toUrl('./codeCell.component.html'))
 })
-export class CodeCellComponent extends CellView implements OnInit {
+
+export class CodeCellComponent extends CellView implements OnInit, OnChanges {
 	@ViewChild('codeCellOutput', { read: ElementRef }) private outputPreview: ElementRef;
-	private _model: NotebookModel;
 	@Input() cellModel: ICellModel;
 	@Input() set model(value: NotebookModel) {
 		this._model = value;
 	}
+	@Input() set activeCellId(value: string) {
+		this._activeCellId = value;
+	}
+
+	private _model: NotebookModel;
+	private _activeCellId: string;
 
 	constructor(
 		@Inject(forwardRef(() => ChangeDetectorRef)) private _changeRef: ChangeDetectorRef,
-		@Inject(IWorkbenchThemeService) private themeService: IWorkbenchThemeService
 	) {
 		super();
 	}
 
 	ngOnInit() {
-		this._register(this.themeService.onDidColorThemeChange(this.updateTheme, this));
-		this.updateTheme(this.themeService.getColorTheme());
 		if (this.cellModel) {
 			this.cellModel.onOutputsChanged(() => {
 				this._changeRef.detectChanges();
@@ -46,18 +44,26 @@ export class CodeCellComponent extends CellView implements OnInit {
 		}
 	}
 
-	// Todo: implement layout
-	public layout() {
-
-	}
-
-	private updateTheme(theme: IColorTheme): void {
-		let outputElement = <HTMLElement>this.outputPreview.nativeElement;
-		outputElement.style.borderTopColor = theme.getColor(themeColors.SIDE_BAR_BACKGROUND, true).toString();
+	ngOnChanges(changes: { [propKey: string]: SimpleChange }) {
+		for (let propName in changes) {
+			if (propName === 'activeCellId') {
+				let changedProp = changes[propName];
+				this._activeCellId = changedProp.currentValue;
+				break;
+			}
+		}
 	}
 
 	get model(): NotebookModel {
 		return this._model;
 	}
 
+	get activeCellId(): string {
+		return this._activeCellId;
+	}
+
+	// Todo: implement layout
+	public layout() {
+
+	}
 }

src/sql/parts/notebook/cellViews/outputArea.component.html

@@ -5,7 +5,7 @@
  *--------------------------------------------------------------------------------------------*/
 -->
 <div style="overflow: hidden; width: 100%; height: 100%; display: flex; flex-flow: column">
-	<div style="flex: 0 0 auto;">
+	<div #outputarea class="notebook-output" style="flex: 0 0 auto;">
 		<output-component *ngFor="let output of cellModel.outputs" [cellOutput]="output" [trustedMode] = "cellModel.trustedMode" >
 		</output-component>
 	</div>

src/sql/parts/notebook/cellViews/outputArea.component.ts

@@ -3,9 +3,12 @@
 *  Licensed under the Source EULA. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
 import 'vs/css!./code';
-import { OnInit, Component, Input, Inject, forwardRef, ChangeDetectorRef } from '@angular/core';
+import 'vs/css!./outputArea';
+import { OnInit, Component, Input, Inject, ElementRef, ViewChild, forwardRef, ChangeDetectorRef } from '@angular/core';
 import { AngularDisposable } from 'sql/base/common/lifecycle';
 import { ICellModel } from 'sql/parts/notebook/models/modelInterfaces';
+import * as themeColors from 'vs/workbench/common/theme';
+import { IWorkbenchThemeService, IColorTheme } from 'vs/workbench/services/themes/common/workbenchThemeService';
 
 export const OUTPUT_AREA_SELECTOR: string = 'output-area-component';
 
@@ -14,20 +17,30 @@ export const OUTPUT_AREA_SELECTOR: string = 'output-area-component';
 	templateUrl: decodeURI(require.toUrl('./outputArea.component.html'))
 })
 export class OutputAreaComponent extends AngularDisposable implements OnInit {
+	@ViewChild('outputarea', { read: ElementRef }) private outputArea: ElementRef;
 	@Input() cellModel: ICellModel;
 
 	private readonly _minimumHeight = 30;
 
 	constructor(
-		@Inject(forwardRef(() => ChangeDetectorRef)) private _changeRef: ChangeDetectorRef,
+		@Inject(IWorkbenchThemeService) private themeService: IWorkbenchThemeService,
+		@Inject(forwardRef(() => ChangeDetectorRef)) private _changeRef: ChangeDetectorRef
 	) {
 		super();
 	}
-	ngOnInit(): void {
+
+	ngOnInit() {
+		this._register(this.themeService.onDidColorThemeChange(this.updateTheme, this));
+		this.updateTheme(this.themeService.getColorTheme());
 		if (this.cellModel) {
 			this.cellModel.onOutputsChanged(() => {
 				this._changeRef.detectChanges();
 			});
 		}
 	}
+
+	private updateTheme(theme: IColorTheme): void {
+		let outputElement = <HTMLElement>this.outputArea.nativeElement;
+		outputElement.style.borderTopColor = theme.getColor(themeColors.SIDE_BAR_BACKGROUND, true).toString();
+	}
 }

src/sql/parts/notebook/cellViews/outputArea.css

@@ -2,13 +2,14 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-
-code-cell-component {
+output-area-component {
 	display: block;
 }
 
-code-cell-component .notebook-output {
+output-area-component .notebook-output {
 	border-top-width: 1px;
 	border-top-style: solid;
 	user-select: initial;
+	padding: 5px 20px 0px;
+	box-shadow: rgba(120, 120, 120, 0.75) 0px -2px 1px -2px;
 }

src/sql/parts/notebook/cellViews/textCell.component.html

@@ -6,8 +6,9 @@
 -->
 <div style="overflow: hidden; width: 100%; height: 100%; display: flex; flex-flow: column">
 	<div class="notebook-text" style="flex: 0 0 auto;">
-		<code-component *ngIf="isEditMode" [cellModel]="cellModel" (onContentChanged)="handleContentChanged()"></code-component>
+		<code-component *ngIf="isEditMode" [cellModel]="cellModel" (onContentChanged)="handleContentChanged()" [model]="model" [activeCellId]="activeCellId" [hideVerticalToolbar]=true>
+		</code-component>
 	</div>
-	<div #preview class="notebook-preview" style="flex: 0 0 auto;" (dblclick)="toggleEditMode()">
+	<div #preview style="flex: 0 0 auto;" (dblclick)="toggleEditMode()">
 	</div>
 </div>

src/sql/parts/notebook/cellViews/textCell.component.ts

@@ -4,7 +4,7 @@
 *--------------------------------------------------------------------------------------------*/
 import 'vs/css!./textCell';
 
-import { OnInit, Component, Input, Inject, forwardRef, ElementRef, ChangeDetectorRef, OnDestroy, ViewChild } from '@angular/core';
+import { OnInit, Component, Input, Inject, forwardRef, ElementRef, ChangeDetectorRef, OnDestroy, ViewChild, OnChanges, SimpleChange } from '@angular/core';
 
 import { CommonServiceInterface } from 'sql/services/common/commonServiceInterface.service';
 import { CellView } from 'sql/parts/notebook/cellViews/interfaces';
@@ -15,6 +15,7 @@ import { ICommandService } from 'vs/platform/commands/common/commands';
 import { ICellModel } from 'sql/parts/notebook/models/modelInterfaces';
 import { ISanitizer, defaultSanitizer } from 'sql/parts/notebook/outputs/sanitizer';
 import { localize } from 'vs/nls';
+import { NotebookModel } from 'sql/parts/notebook/models/notebookModel';
 
 export const TEXT_SELECTOR: string = 'text-cell-component';
 
@@ -22,12 +23,24 @@ export const TEXT_SELECTOR: string = 'text-cell-component';
 	selector: TEXT_SELECTOR,
 	templateUrl: decodeURI(require.toUrl('./textCell.component.html'))
 })
-export class TextCellComponent extends CellView implements OnInit {
+export class TextCellComponent extends CellView implements OnInit, OnChanges {
 	@ViewChild('preview', { read: ElementRef }) private output: ElementRef;
 	@Input() cellModel: ICellModel;
+
+	@Input() set model(value: NotebookModel) {
+		this._model = value;
+	}
+
+	@Input() set activeCellId(value: string) {
+		this._activeCellId = value;
+	}
+
 	private _content: string;
 	private isEditMode: boolean;
 	private _sanitizer: ISanitizer;
+	private _previewCssApplied: boolean = false;
+	private _model: NotebookModel;
+	private _activeCellId: string;
 
 	constructor(
 		@Inject(forwardRef(() => CommonServiceInterface)) private _bootstrapService: CommonServiceInterface,
@@ -39,10 +52,6 @@ export class TextCellComponent extends CellView implements OnInit {
 		this.isEditMode = false;
 	}
 
-	ngOnChanges() {
-		this.updatePreview();
-	}
-
 	//Gets sanitizer from ISanitizer interface
 	private get sanitizer(): ISanitizer {
 		if (this._sanitizer) {
@@ -51,13 +60,43 @@ export class TextCellComponent extends CellView implements OnInit {
 		return this._sanitizer = defaultSanitizer;
 	}
 
+	get model(): NotebookModel {
+		return this._model;
+	}
+
+	get activeCellId(): string {
+		return this._activeCellId;
+	}
+
+	ngOnInit() {
+		this.updatePreview();
+		this._register(this.themeService.onDidColorThemeChange(this.updateTheme, this));
+		this.updateTheme(this.themeService.getColorTheme());
+		this.cellModel.onOutputsChanged(e => {
+			this.updatePreview();
+		});
+	}
+
+	ngOnChanges(changes: { [propKey: string]: SimpleChange }) {
+		for (let propName in changes) {
+			if (propName === 'activeCellId') {
+				let changedProp = changes[propName];
+				this._activeCellId = changedProp.currentValue;
+				if (this._activeCellId) {
+					this.toggleEditMode(false);
+				}
+				break;
+			}
+		}
+	}
+
 	/**
 	 * Updates the preview of markdown component with latest changes
 	 * If content is empty and in non-edit mode, default it to 'Double-click to edit'
 	 * Sanitizes the data to be shown in markdown cell
 	 */
 	private updatePreview() {
-		if (this._content !== this.cellModel.source) {
+		if (this._content !== this.cellModel.source || this.cellModel.source.length === 0) {
 			if (!this.cellModel.source && !this.isEditMode) {
 				(<HTMLElement>this.output.nativeElement).innerHTML = localize('doubleClickEdit', 'Double-click to edit');
 			} else {
@@ -78,15 +117,7 @@ export class TextCellComponent extends CellView implements OnInit {
 		}
 		return content;
 	}
-
-	ngOnInit() {
-		this.updatePreview();
-		this._register(this.themeService.onDidColorThemeChange(this.updateTheme, this));
-		this.updateTheme(this.themeService.getColorTheme());
-		this.cellModel.onOutputsChanged(e => {
-			this.updatePreview();
-		});
-	}
+	
 
 	// Todo: implement layout
 	public layout() {
@@ -98,12 +129,29 @@ export class TextCellComponent extends CellView implements OnInit {
 	}
 
 	public handleContentChanged(): void {
+		if (!this._previewCssApplied) {
+			this.updatePreviewCssClass();
+		}
 		this.updatePreview();
 	}
 
-	public toggleEditMode(): void {
-		this.isEditMode = !this.isEditMode;
+	public toggleEditMode(editMode?: boolean): void {
+		this.isEditMode = editMode !== undefined? editMode : !this.isEditMode;
+		this.updatePreviewCssClass();
 		this.updatePreview();
 		this._changeRef.detectChanges();
 	}
+
+	// Updates the css class to preview 'div' based on edit mode
+	private updatePreviewCssClass() {
+		let outputElement = <HTMLElement>this.output.nativeElement;
+		if (this.isEditMode && this.cellModel.source) {
+			outputElement.className = 'notebook-preview';
+			this._previewCssApplied = true;
+		}
+		else {
+			outputElement.className = '';
+			this._previewCssApplied = false;
+		}
+	}
 }

src/sql/parts/notebook/media/dark/save_inverse.svg

@@ -0,0 +1 @@
+<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><defs><style>.cls-1{fill:#fff;}</style></defs><title>save_inverse</title><path class="cls-1" d="M14,1a1,1,0,0,1,.39.08,1,1,0,0,1,.53.53A1,1,0,0,1,15,2V15H2.79L1,13.2V2a1,1,0,0,1,.08-.39,1,1,0,0,1,.53-.53A1,1,0,0,1,2,1Zm0,1H13V8H3V2H2V12.79L3.2,14H4V10h7v4h3ZM4,7h8V2H4Zm6,4H5v3H6V12H7v2h3Z"/></svg>

src/sql/parts/notebook/media/light/save.svg

@@ -0,0 +1 @@
+<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><title>save</title><path d="M14,1a1,1,0,0,1,.39.08,1,1,0,0,1,.53.53A1,1,0,0,1,15,2V15H2.79L1,13.2V2a1,1,0,0,1,.08-.39,1,1,0,0,1,.53-.53A1,1,0,0,1,2,1Zm0,1H13V8H3V2H2V12.79L3.2,14H4V10h7v4h3ZM4,7h8V2H4Zm6,4H5v3H6V12H7v2h3Z"/></svg>

src/sql/parts/notebook/models/cell.ts

@@ -14,6 +14,7 @@ import { ICellModelOptions, IModelFactory, FutureInternal } from './modelInterfa
 import * as notebookUtils from '../notebookUtils';
 import { CellTypes, CellType, NotebookChangeType } from 'sql/parts/notebook/models/contracts';
 import { ICellModel } from 'sql/parts/notebook/models/modelInterfaces';
+import { NotebookModel } from 'sql/parts/notebook/models/notebookModel';
 
 let modelId = 0;
 
@@ -222,11 +223,41 @@ export class CellModel implements ICellModel {
 		if (output) {
 			// deletes transient node in the serialized JSON
 			delete output['transient'];
-			this._outputs.push(output);
+			this._outputs.push(this.rewriteOutputUrls(output));
 			this.fireOutputsChanged();
 		}
 	}
 
+	private rewriteOutputUrls(output: nb.ICellOutput): nb.ICellOutput {
+		// Only rewrite if this is coming back during execution, not when loading from disk.
+		// A good approximation is that the model has a future (needed for execution)
+		if (this.future) {
+			try {
+				let result = output as nb.IDisplayResult;
+				if (result && result.data && result.data['text/html']) {
+					let nbm = (this as CellModel).options.notebook as NotebookModel;
+					if (nbm.hadoopConnection) {
+						let host = nbm.hadoopConnection.host;
+						let html = result.data['text/html'];
+						html = html.replace(/(https?:\/\/mssql-master.*\/proxy)(.*)/g, function (a, b, c) {
+							let ret = '';
+							if (b !== '') {
+								ret = 'https://' + host + ':30443/gateway/default/yarn/proxy';
+							}
+							if (c !== '') {
+								ret = ret + c;
+							}
+							return ret;
+						});
+						(<nb.IDisplayResult>output).data['text/html'] = html;
+					}
+				}
+			}
+			catch (e) {}
+		}
+		return output;
+	}
+
 	private getDisplayId(msg: nb.IIOPubMessage): string | undefined {
 		let transient = (msg.content.transient || {});
 		return transient['display_id'] as string;

src/sql/parts/notebook/notebook.component.html

@@ -10,9 +10,9 @@
 	<div class="scrollable" style="flex: 1 1 auto; position: relative">
 		<loading-spinner [loading]="isLoading"></loading-spinner>
 		<div class="notebook-cell" *ngFor="let cell of cells" (click)="selectCell(cell)" [class.active]="cell.active" (keydown)="onKeyDown($event)">
-			<code-cell-component *ngIf="cell.cellType === 'code'" [cellModel]="cell" [model]="model">
+			<code-cell-component *ngIf="cell.cellType === 'code'" [cellModel]="cell" [model]="model" [activeCellId]="activeCellId">
 			</code-cell-component>
-			<text-cell-component *ngIf="cell.cellType === 'markdown'" [cellModel]="cell">
+			<text-cell-component *ngIf="cell.cellType === 'markdown'" [cellModel]="cell" [model]="model" [activeCellId]="activeCellId">
 			</text-cell-component>
 		</div>
 	</div>

src/sql/parts/notebook/notebook.component.ts

@@ -31,7 +31,7 @@ import { IConnectionProfile } from 'sql/parts/connection/common/interfaces';
 import { Taskbar } from 'sql/base/browser/ui/taskbar/taskbar';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { IContextMenuService, IContextViewService } from 'vs/platform/contextview/browser/contextView';
-import { KernelsDropdown, AttachToDropdown, AddCellAction, TrustedAction } from 'sql/parts/notebook/notebookActions';
+import { KernelsDropdown, AttachToDropdown, AddCellAction, TrustedAction, SaveNotebookAction } from 'sql/parts/notebook/notebookActions';
 import { attachSelectBoxStyler } from 'vs/platform/theme/common/styler';
 
 export const NOTEBOOK_SELECTOR: string = 'notebook-component';
@@ -54,6 +54,7 @@ export class NotebookComponent extends AngularDisposable implements OnInit {
 	private _modelRegisteredDeferred = new Deferred<NotebookModel>();
 	private profile: IConnectionProfile;
 	private _trustedAction: TrustedAction;
+	private _activeCellId: string;
 
 
 	constructor(
@@ -85,6 +86,10 @@ export class NotebookComponent extends AngularDisposable implements OnInit {
 		return this._model;
 	}
 
+	public get activeCellId(): string {
+		return this._activeCellId;
+	}
+
 	public get modelRegistered(): Promise<NotebookModel> {
 		return this._modelRegisteredDeferred.promise;
 	}
@@ -106,6 +111,7 @@ export class NotebookComponent extends AngularDisposable implements OnInit {
 			this._activeCell = cell;
 			this._activeCell.active = true;
 			this._model.activeCell = this._activeCell;
+			this._activeCellId = cell.id;
 			this._changeRef.detectChanges();
 		}
 	}
@@ -233,9 +239,6 @@ export class NotebookComponent extends AngularDisposable implements OnInit {
 		attachTodropdwon.render(attachToContainer);
 		attachSelectBoxStyler(attachTodropdwon, this.themeService);
 
-		let attachToInfoText = document.createElement('div');
-		attachToInfoText.className = 'notebook-info-label';
-		attachToInfoText.innerText = 'Attach To: ';
 
 		let addCodeCellButton = new AddCellAction('notebook.AddCodeCell', localize('code', 'Code'), 'notebook-button icon-add');
 		addCodeCellButton.cellType = CellTypes.Code;
@@ -246,15 +249,18 @@ export class NotebookComponent extends AngularDisposable implements OnInit {
 		this._trustedAction = this.instantiationService.createInstance(TrustedAction, 'notebook.Trusted');
 		this._trustedAction.enabled = false;
 
+		let saveNotebookButton = this.instantiationService.createInstance(SaveNotebookAction, 'notebook.SaveNotebook', localize('save', 'Save'), 'notebook-button icon-save');
+
 		let taskbar = <HTMLElement>this.toolbar.nativeElement;
 		this._actionBar = new Taskbar(taskbar, this.contextMenuService);
 		this._actionBar.context = this;
 		this._actionBar.setContent([
 			{ element: kernelContainer },
 			{ element: attachToContainer },
-			{ action: addCodeCellButton},
-			{ action: addTextCellButton},
-			{ action: this._trustedAction}
+			{ action: addCodeCellButton },
+			{ action: addTextCellButton },
+			{ action: saveNotebookButton },
+			{ action: this._trustedAction }
 		]);
 	}
 

src/sql/parts/notebook/notebook.css

@@ -31,9 +31,9 @@
 	text-align: center;
 	cursor: pointer;
 	padding-left: 15px;
-	background-size: 11px;
+	background-size: 13px;
 	margin-right: 0.3em;
-	font-size: 11px;
+	font-size: 13px;
 }
 
 .notebookEditor .notebook-button.icon-add{
@@ -61,4 +61,13 @@
 .vs-dark .notebookEditor .notebook-button.icon-notTrusted,
 .hc-black .notebookEditor .notebook-button.icon-notTrusted{
 	background-image: url("./media/dark/nottrusted_inverse.svg");
+}
+
+.notebookEditor .notebook-button.icon-save{
+	background-image: url("./media/light/save.svg");
+}
+
+.vs-dark .notebookEditor .notebook-button.icon-save,
+.hc-black .notebookEditor .notebook-button.icon-save{
+	background-image: url("./media/dark/save_inverse.svg");
 }

src/sql/parts/notebook/notebookActions.ts

@@ -26,6 +26,7 @@ const msgLoadingContexts = localize('loadingContexts', 'Loading contexts...');
 const msgAddNewConnection = localize('addNewConnection', 'Add new connection');
 const msgSelectConnection = localize('selectConnection', 'Select connection');
 const msgConnectionNotApplicable = localize('connectionNotSupported', 'n/a');
+const msgLocalHost = localize('localhost', 'Localhost');
 
 // Action to add a cell to notebook based on cell type(code/markdown).
 export class AddCellAction extends Action {
@@ -48,6 +49,28 @@ export class AddCellAction extends Action {
 	}
 }
 
+export class SaveNotebookAction extends Action {
+	private static readonly notebookSavedMsg = localize('notebookSavedMsg', 'Notebook saved successfully.');
+	private static readonly notebookFailedSaveMsg = localize('notebookFailedSaveMsg', 'Failed to save Notebook.');
+	constructor(
+		id: string, label: string, cssClass: string,
+		@INotificationService private _notificationService: INotificationService
+	) {
+		super(id, label, cssClass);
+	}
+
+	public async run(context: NotebookComponent): TPromise<boolean> {
+		const actions: INotificationActions = { primary: [] };
+		let saved = await context.save();
+		if (saved) {
+			this._notificationService.notify({ severity: Severity.Info, message: SaveNotebookAction.notebookSavedMsg, actions });
+		} else {
+			this._notificationService.error(SaveNotebookAction.notebookFailedSaveMsg);
+		}
+		return saved;
+	}
+}
+
 export interface IToggleableState {
 	baseClass?: string;
 	shouldToggleTooltip?: boolean;
@@ -216,8 +239,7 @@ export class AttachToDropdown extends SelectBox {
 	// Load "Attach To" dropdown with the values corresponding to Kernel dropdown
 	public async loadAttachToDropdown(model: INotebookModel, currentKernel: string): Promise<void> {
 		if (currentKernel === notebookConstants.python3) {
-			this.setOptions([msgConnectionNotApplicable]);
-			this.disable();
+			this.setOptions([msgLocalHost]);
 		}
 		else {
 			let hadoopConnections = this.getHadoopConnections(model);

src/sql/parts/objectExplorer/common/objectExplorerService.ts

@@ -261,7 +261,7 @@ export class ObjectExplorerService implements IObjectExplorerService {
 		return this._activeObjectExplorerNodes[connection.id];
 	}
 
-	public createNewSession(providerId: string, connection: ConnectionProfile): Thenable<sqlops.ObjectExplorerSessionResponse> {
+	public async createNewSession(providerId: string, connection: ConnectionProfile): Promise<sqlops.ObjectExplorerSessionResponse> {
 		let self = this;
 		return new Promise<sqlops.ObjectExplorerSessionResponse>((resolve, reject) => {
 			let provider = this._providers[providerId];

src/sql/parts/query/execution/queryRunner.ts

@@ -377,7 +377,9 @@ export default class QueryRunner extends Disposable {
 					this.getQueryRows(0, 1, result.resultSetSummary.batchId, result.resultSetSummary.id).then(e => this._planXml.resolve(e.resultSubset.rows[0][0].displayValue));
 				}
 			}
-			if (batchSet) {
+			// we will just ignore the set if we already have it
+			// ideally this should never happen
+			if (batchSet && !batchSet.resultSetSummaries[resultSet.id]) {
 				// Store the result set in the batch and emit that a result set has completed
 				batchSet.resultSetSummaries[resultSet.id] = resultSet;
 				this._eventEmitter.emit(EventType.RESULT_SET, resultSet);

src/sql/services/accountManagement/accountManagementService.ts

@@ -20,7 +20,7 @@ import { AccountDialogController } from 'sql/parts/accountManagement/accountDial
 import { AutoOAuthDialogController } from 'sql/parts/accountManagement/autoOAuthDialog/autoOAuthDialogController';
 import { AccountListStatusbarItem } from 'sql/parts/accountManagement/accountListStatusbar/accountListStatusbarItem';
 import { AccountProviderAddedEventParams, UpdateAccountListEventParams } from 'sql/services/accountManagement/eventTypes';
-import { IAccountManagementService } from 'sql/services/accountManagement/interfaces';
+import { IAccountManagementService, AzureResource } from 'sql/services/accountManagement/interfaces';
 import { IClipboardService } from 'vs/platform/clipboard/common/clipboardService';
 
 export class AccountManagementService implements IAccountManagementService {
@@ -217,11 +217,12 @@ export class AccountManagementService implements IAccountManagementService {
 	/**
 	 * Generates a security token by asking the account's provider
 	 * @param {Account} account Account to generate security token for
+	 * @param {AzureResource} resource The resource to get the security token for
 	 * @return {Thenable<{}>} Promise to return the security token
 	 */
-	public getSecurityToken(account: sqlops.Account): Thenable<{}> {
+	public getSecurityToken(account: sqlops.Account, resource: sqlops.AzureResource): Thenable<{}> {
 		return this.doWithProvider(account.key.providerId, provider => {
-			return provider.provider.getSecurityToken(account);
+			return provider.provider.getSecurityToken(account, resource);
 		});
 	}
 

src/sql/services/accountManagement/interfaces.ts

@@ -22,7 +22,7 @@ export interface IAccountManagementService {
 	addAccount(providerId: string): Thenable<void>;
 	getAccountProviderMetadata(): Thenable<sqlops.AccountProviderMetadata[]>;
 	getAccountsForProvider(providerId: string): Thenable<sqlops.Account[]>;
-	getSecurityToken(account: sqlops.Account): Thenable<{}>;
+	getSecurityToken(account: sqlops.Account, resource: sqlops.AzureResource): Thenable<{}>;
 	removeAccount(accountKey: sqlops.AccountKey): Thenable<boolean>;
 	refreshAccount(account: sqlops.Account): Thenable<sqlops.Account>;
 
@@ -44,6 +44,12 @@ export interface IAccountManagementService {
 	readonly updateAccountListEvent: Event<UpdateAccountListEventParams>;
 }
 
+// Enum matching the AzureResource enum from sqlops.d.ts
+export enum AzureResource {
+	ResourceManagement = 0,
+	Sql = 1
+}
+
 export interface IAccountStore {
 	/**
 	 * Adds the provided account if the account doesn't exist. Updates the account if it already exists

src/sql/services/dacfx/dacFxService.ts

@@ -0,0 +1,78 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 * as sqlops from 'sqlops';
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { IConnectionManagementService } from 'sql/parts/connection/common/connectionManagement';
+import { TPromise } from 'vs/base/common/winjs.base';
+import { localize } from 'vs/nls';
+import { data } from 'vs/base/test/common/filters.perf.data';
+
+export const SERVICE_ID = 'dacFxService';
+export const IDacFxService = createDecorator<IDacFxService>(SERVICE_ID);
+
+export interface IDacFxService {
+	_serviceBrand: any;
+
+	registerProvider(providerId: string, provider: sqlops.DacFxServicesProvider): void;
+	exportBacpac(sourceDatabaseName: string, packageFilePath: string, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): void;
+	importBacpac(packageFilePath: string, targetDatabaseName: string, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): void;
+	extractDacpac(sourceDatabaseName: string, packageFilePath: string, applicationName: string, applicationVersion: string, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): void;
+	deployDacpac(packageFilePath: string, targetDatabaseName: string, upgradeExisting: boolean, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): void;
+}
+
+export class DacFxService implements IDacFxService {
+	_serviceBrand: any;
+	private _providers: { [handle: string]: sqlops.DacFxServicesProvider; } = Object.create(null);
+
+	constructor(
+		@IConnectionManagementService private _connectionService: IConnectionManagementService
+	) {
+	}
+
+	registerProvider(providerId: string, provider: sqlops.DacFxServicesProvider): void {
+		this._providers[providerId] = provider;
+	}
+
+	exportBacpac(databasesName: string, packageFilePath: string, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.DacFxResult> {
+		return this._runAction(ownerUri, (runner) => {
+			return runner.exportBacpac(databasesName, packageFilePath, ownerUri, taskExecutionMode);
+		});
+	}
+
+	importBacpac(packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.DacFxResult> {
+		return this._runAction(ownerUri, (runner) => {
+			return runner.importBacpac(packageFilePath, databaseName, ownerUri, taskExecutionMode);
+		});
+	}
+
+	extractDacpac(databaseName: string, packageFilePath: string, applicationName: string, applicationVersion: string, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.DacFxResult> {
+		return this._runAction(ownerUri, (runner) => {
+			return runner.extractDacpac(databaseName, packageFilePath, applicationName, applicationVersion, ownerUri, taskExecutionMode);
+		});
+	}
+
+	deployDacpac(packageFilePath: string, databaseName: string, upgradeExisting: boolean, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.DacFxResult> {
+		return this._runAction(ownerUri, (runner) => {
+			return runner.deployDacpac(packageFilePath, databaseName, upgradeExisting, ownerUri, taskExecutionMode);
+		});
+	}
+
+	private _runAction<T>(uri: string, action: (handler: sqlops.DacFxServicesProvider) => Thenable<T>): Thenable<T> {
+		let providerId: string = this._connectionService.getProviderIdFromUri(uri);
+
+		if (!providerId) {
+			return TPromise.wrapError(new Error(localize('providerIdNotValidError', "Connection is required in order to interact with DacFxService")));
+		}
+		let handler = this._providers[providerId];
+		if (handler) {
+			return action(handler);
+		} else {
+			return TPromise.wrapError(new Error(localize('noHandlerRegistered', "No Handler Registered")));
+		}
+	}
+}

src/sql/sqlops.d.ts

@@ -37,6 +37,8 @@ declare module 'sqlops' {
 
 		export function registerCapabilitiesServiceProvider(provider: CapabilitiesProvider): vscode.Disposable;
 
+		export function registerDacFxServicesProvider(provider: DacFxServicesProvider): vscode.Disposable;
+
 		/**
 		 * An [event](#Event) which fires when the specific flavor of a language used in DMP
 		 * connections has changed. And example is for a SQL connection, the flavor changes
@@ -1585,6 +1587,49 @@ declare module 'sqlops' {
 		registerOnUpdated(handler: () => any): void;
 	}
 
+	// DacFx interfaces  -----------------------------------------------------------------------
+	export interface DacFxResult extends ResultStatus {
+		operationId: string;
+	}
+
+	export interface ExportParams {
+		databaseName: string;
+		packageFilePath: string;
+		ownerUri: string;
+		taskExecutionMode: TaskExecutionMode;
+	}
+
+	export interface ImportParams {
+		packageFilePath: string;
+		databaseName: string;
+		ownerUri: string;
+		taskExecutionMode: TaskExecutionMode;
+	}
+
+	export interface ExtractParams {
+		databaseName: string;
+		packageFilePath: string;
+		applicationName: string;
+		applicationVersion: string;
+		ownerUri: string;
+		taskExecutionMode: TaskExecutionMode;
+	}
+
+	export interface DeployParams {
+		packageFilePath: string;
+		databaseName: string;
+		upgradeExisting: boolean;
+		ownerUri: string;
+		taskExecutionMode: TaskExecutionMode;
+	}
+
+	export interface DacFxServicesProvider extends DataProvider {
+		exportBacpac(databaseName: string, packageFilePath: string, ownerUri: string, taskExecutionMode: TaskExecutionMode): Thenable<DacFxResult>;
+		importBacpac(packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: TaskExecutionMode): Thenable<DacFxResult>;
+		extractDacpac(databaseName: string, packageFilePath: string, applicationName: string, applicationVersion: string, ownerUri: string, taskExecutionMode: TaskExecutionMode): Thenable<DacFxResult>;
+		deployDacpac(packageFilePath: string, databaseName: string, upgradeExisting: boolean, ownerUri: string, taskExecutionMode: TaskExecutionMode): Thenable<DacFxResult>;
+	}
+
 	// Security service interfaces ------------------------------------------------------------------------
 	export interface CredentialInfo {
 		id: number;
@@ -1914,10 +1959,11 @@ declare module 'sqlops' {
 
 		/**
 		 * Generates a security token by asking the account's provider
-		 * @param {Account} account Account to generate security token for
+		 * @param {Account} account Account to generate security token for (defaults to
+		 * AzureResource.ResourceManagement if not given)
 		 * @return {Thenable<{}>} Promise to return the security token
 		 */
-		export function getSecurityToken(account: Account): Thenable<{}>;
+		export function getSecurityToken(account: Account, resource?: AzureResource): Thenable<{}>;
 
 		/**
 		 * An [event](#Event) which fires when the accounts have changed.
@@ -1990,6 +2036,11 @@ declare module 'sqlops' {
 		isStale: boolean;
 	}
 
+	export enum AzureResource {
+		ResourceManagement = 0,
+		Sql = 1
+	}
+
 	export interface DidChangeAccountsParams {
 		// Updated accounts
 		accounts: Account[];
@@ -2047,9 +2098,10 @@ declare module 'sqlops' {
 		/**
 		 * Generates a security token for the provided account
 		 * @param {Account} account The account to generate a security token for
+		 * @param {AzureResource} resource The resource to get the token for
 		 * @return {Thenable<{}>} Promise to return a security token object
 		 */
-		getSecurityToken(account: Account): Thenable<{}>;
+		getSecurityToken(account: Account, resource: AzureResource): Thenable<{}>;
 
 		/**
 		 * Prompts the user to enter account information.

src/sql/sqlops.proposed.d.ts

@@ -1232,7 +1232,8 @@ declare module 'sqlops' {
 		QueryProvider = 'QueryProvider',
 		AdminServicesProvider = 'AdminServicesProvider',
 		AgentServicesProvider = 'AgentServicesProvider',
-		CapabilitiesProvider = 'CapabilitiesProvider'
+		CapabilitiesProvider = 'CapabilitiesProvider',
+		DacFxServicesProvider = 'DacFxServicesProvider',
 	}
 
 	export namespace dataprotocol {

src/sql/workbench/api/common/sqlExtHostTypes.ts

@@ -285,7 +285,8 @@ export enum DataProviderType {
 	QueryProvider = 'QueryProvider',
 	AdminServicesProvider = 'AdminServicesProvider',
 	AgentServicesProvider = 'AgentServicesProvider',
-	CapabilitiesProvider = 'CapabilitiesProvider'
+	CapabilitiesProvider = 'CapabilitiesProvider',
+	DacFxServicesProvider = 'DacFxServicesProvider',
 }
 
 export enum DeclarativeDataType {
@@ -313,6 +314,11 @@ export class TreeComponentItem extends TreeItem {
 	checked?: boolean;
 }
 
+export enum AzureResource {
+	ResourceManagement = 0,
+	Sql = 1
+}
+
 export class SqlThemeIcon {
 
 	static readonly Folder = new SqlThemeIcon('Folder');

src/sql/workbench/api/node/extHostAccountManagement.ts

@@ -13,6 +13,7 @@ import {
 	MainThreadAccountManagementShape,
 	SqlMainContext,
 } from 'sql/workbench/api/node/sqlExtHost.protocol';
+import { AzureResource } from 'sql/workbench/api/common/sqlExtHostTypes';
 import { IMainContext } from 'vs/workbench/api/node/extHost.protocol';
 import { Event, Emitter } from 'vs/base/common/event';
 
@@ -89,12 +90,15 @@ export class ExtHostAccountManagement extends ExtHostAccountManagementShape {
 		return Promise.all(promises).then(() => resultAccounts);
 	}
 
-	public $getSecurityToken(account: sqlops.Account): Thenable<{}> {
+	public $getSecurityToken(account: sqlops.Account, resource?: sqlops.AzureResource): Thenable<{}> {
+		if (resource === undefined) {
+			resource = AzureResource.ResourceManagement;
+		}
 		return this.$getAllAccounts().then(() => {
 			for (const handle in this._accounts) {
 				const providerHandle = parseInt(handle);
 				if (this._accounts[handle].findIndex((acct) => acct.key.accountId === account.key.accountId) !== -1) {
-					return this._withProvider(providerHandle, (provider: sqlops.AccountProvider) => provider.getSecurityToken(account));
+					return this._withProvider(providerHandle, (provider: sqlops.AccountProvider) => provider.getSecurityToken(account, resource));
 				}
 			}
 

src/sql/workbench/api/node/extHostDataProtocol.ts

@@ -156,6 +156,12 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 		return rt;
 	}
 
+	$registerDacFxServiceProvider(provider: sqlops.DacFxServicesProvider): vscode.Disposable {
+		let rt = this.registerProvider(provider, DataProviderType.DacFxServicesProvider);
+		this._proxy.$registerDacFxServicesProvider(provider.providerId, provider.handle);
+		return rt;
+	}
+
 	// Capabilities Discovery handlers
 	$getServerCapabilities(handle: number, client: sqlops.DataProtocolClientCapabilities): Thenable<sqlops.DataProtocolServerCapabilities> {
 		return this._resolveProvider<sqlops.CapabilitiesProvider>(handle).getServerCapabilities(client);

src/sql/workbench/api/node/mainThreadAccountManagement.ts

@@ -76,8 +76,8 @@ export class MainThreadAccountManagement implements MainThreadAccountManagementS
 			clear(accountKey: sqlops.AccountKey): Thenable<void> {
 				return self._proxy.$clear(handle, accountKey);
 			},
-			getSecurityToken(account: sqlops.Account): Thenable<{}> {
-				return self._proxy.$getSecurityToken(account);
+			getSecurityToken(account: sqlops.Account, resource: sqlops.AzureResource): Thenable<{}> {
+				return self._proxy.$getSecurityToken(account, resource);
 			},
 			initialize(restoredAccounts: sqlops.Account[]): Thenable<sqlops.Account[]> {
 				return self._proxy.$initialize(handle, restoredAccounts);

src/sql/workbench/api/node/mainThreadDataProtocol.ts

@@ -26,6 +26,7 @@ import { IProfilerService } from 'sql/parts/profiler/service/interfaces';
 import { ISerializationService } from 'sql/services/serialization/serializationService';
 import { IFileBrowserService } from 'sql/parts/fileBrowser/common/interfaces';
 import { IExtHostContext } from 'vs/workbench/api/node/extHost.protocol';
+import { IDacFxService } from 'sql/services/dacfx/dacFxService';
 import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
 
 /**
@@ -55,7 +56,8 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
 		@ITaskService private _taskService: ITaskService,
 		@IProfilerService private _profilerService: IProfilerService,
 		@ISerializationService private _serializationService: ISerializationService,
-		@IFileBrowserService private _fileBrowserService: IFileBrowserService
+		@IFileBrowserService private _fileBrowserService: IFileBrowserService,
+		@IDacFxService private _dacFxService: IDacFxService,
 	) {
 		if (extHostContext) {
 			this._proxy = extHostContext.getProxy(SqlExtHostContext.ExtHostDataProtocol);
@@ -399,6 +401,26 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
 		return undefined;
 	}
 
+	public $registerDacFxServicesProvider(providerId: string, handle: number): TPromise<any> {
+		const self = this;
+		this._dacFxService.registerProvider(providerId, <sqlops.DacFxServicesProvider>{
+			exportBacpac(databaseName: string, packageFilePath: string, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.DacFxResult> {
+				return self._proxy.$exportBacpac(handle, databaseName, packageFilePath, ownerUri, taskExecutionMode);
+			},
+			importBacpac(packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.DacFxResult> {
+				return self._proxy.$importBacpac(handle, packageFilePath, databaseName, ownerUri, taskExecutionMode);
+			},
+			extractDacpac(databaseName: string, packageFilePath: string, applicationName: string, applicationVersion: string, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.DacFxResult> {
+				return self._proxy.$extractDacpac(handle, databaseName, packageFilePath, applicationName, applicationVersion, ownerUri, taskExecutionMode);
+			},
+			deployDacpac(packageFilePath: string, databaseName: string, upgradeExisting: boolean, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.DacFxResult> {
+				return self._proxy.$deployDacpac(handle, packageFilePath, databaseName, upgradeExisting, ownerUri, taskExecutionMode);
+			}
+		});
+
+		return undefined;
+	}
+
 	// Connection Management handlers
 	public $onConnectionComplete(handle: number, connectionInfoSummary: sqlops.ConnectionInfoSummary): void {
 		this._connectionManagementService.onConnectionComplete(handle, connectionInfoSummary);

src/sql/workbench/api/node/sqlExtHost.api.impl.ts

@@ -97,8 +97,8 @@ export function createApiFactory(
 				getAllAccounts(): Thenable<sqlops.Account[]> {
 					return extHostAccountManagement.$getAllAccounts();
 				},
-				getSecurityToken(account: sqlops.Account): Thenable<{}> {
-					return extHostAccountManagement.$getSecurityToken(account);
+				getSecurityToken(account: sqlops.Account, resource?: sqlops.AzureResource): Thenable<{}> {
+					return extHostAccountManagement.$getSecurityToken(account, resource);
 				},
 				onDidChangeAccounts(listener: (e: sqlops.DidChangeAccountsParams) => void, thisArgs?: any, disposables?: extHostTypes.Disposable[]) {
 					return extHostAccountManagement.onDidChangeAccounts(listener, thisArgs, disposables);
@@ -314,6 +314,10 @@ export function createApiFactory(
 				return extHostDataProvider.$registerAgentServiceProvider(provider);
 			};
 
+			let registerDacFxServicesProvider = (provider: sqlops.DacFxServicesProvider): vscode.Disposable => {
+				return extHostDataProvider.$registerDacFxServiceProvider(provider);
+			};
+
 			// namespace: dataprotocol
 			const dataprotocol: typeof sqlops.dataprotocol = {
 				registerBackupProvider,
@@ -329,6 +333,7 @@ export function createApiFactory(
 				registerAdminServicesProvider,
 				registerAgentServicesProvider,
 				registerCapabilitiesServiceProvider,
+				registerDacFxServicesProvider,
 				onDidChangeLanguageFlavor(listener: (e: sqlops.DidChangeLanguageFlavorParams) => any, thisArgs?: any, disposables?: extHostTypes.Disposable[]) {
 					return extHostDataProvider.onDidChangeLanguageFlavor(listener, thisArgs, disposables);
 				},
@@ -456,7 +461,8 @@ export function createApiFactory(
 				Orientation: sqlExtHostTypes.Orientation,
 				SqlThemeIcon: sqlExtHostTypes.SqlThemeIcon,
 				TreeComponentItem: sqlExtHostTypes.TreeComponentItem,
-				nb: nb
+				nb: nb,
+				AzureResource: sqlExtHostTypes.AzureResource
 			};
 		}
 	};

src/sql/workbench/api/node/sqlExtHost.protocol.ts

@@ -27,7 +27,7 @@ import {
 export abstract class ExtHostAccountManagementShape {
 	$autoOAuthCancelled(handle: number): Thenable<void> { throw ni(); }
 	$clear(handle: number, accountKey: sqlops.AccountKey): Thenable<void> { throw ni(); }
-	$getSecurityToken(account: sqlops.Account): Thenable<{}> { throw ni(); }
+	$getSecurityToken(account: sqlops.Account, resource?: sqlops.AzureResource): Thenable<{}> { throw ni(); }
 	$initialize(handle: number, restoredAccounts: sqlops.Account[]): Thenable<sqlops.Account[]> { throw ni(); }
 	$prompt(handle: number): Thenable<sqlops.Account> { throw ni(); }
 	$refresh(handle: number, account: sqlops.Account): Thenable<sqlops.Account> { throw ni(); }
@@ -413,6 +413,26 @@ export abstract class ExtHostDataProtocolShape {
 	 * Get Agent Credentials list
 	 */
 	$getCredentials(handle: number, connectionUri: string): Thenable<sqlops.GetCredentialsResult> { throw ni(); }
+
+	/**
+	 * DacFx export bacpac
+	 */
+	$exportBacpac(handle: number, databaseName: string, packageFilePath: string, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.DacFxResult> { throw ni(); }
+
+	/**
+	 * DacFx import bacpac
+	 */
+	$importBacpac(handle: number, packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.DacFxResult> { throw ni(); }
+
+	/**
+	 * DacFx extract dacpac
+	 */
+	$extractDacpac(handle: number, databaseName: string, packageFilePath: string, applicationName: string, applicationVersion: string, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.DacFxResult> { throw ni(); }
+
+	/**
+	 * DacFx deploy dacpac
+	 */
+	$deployDacpac(handle: number, packageFilePath: string, databaseName: string, upgradeExisting: boolean, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.DacFxResult> { throw ni(); }
 }
 
 /**
@@ -480,6 +500,7 @@ export interface MainThreadDataProtocolShape extends IDisposable {
 	$registerCapabilitiesServiceProvider(providerId: string, handle: number): TPromise<any>;
 	$registerAdminServicesProvider(providerId: string, handle: number): TPromise<any>;
 	$registerAgentServicesProvider(providerId: string, handle: number): TPromise<any>;
+	$registerDacFxServicesProvider(providerId: string, handle: number): TPromise<any>;
 	$unregisterProvider(handle: number): TPromise<any>;
 	$onConnectionComplete(handle: number, connectionInfoSummary: sqlops.ConnectionInfoSummary): void;
 	$onIntelliSenseCacheComplete(handle: number, connectionUri: string): void;

src/sqltest/parts/accountManagement/firewallRuleDialogController.test.ts

@@ -136,7 +136,7 @@ suite('Firewall rule dialog controller tests', () => {
 
 		// Then: it should get security token from account management service and call create firewall rule in resource provider
 		deferredPromise.promise.then(() => {
-			mockAccountManagementService.verify(x => x.getSecurityToken(TypeMoq.It.isAny()), TypeMoq.Times.once());
+			mockAccountManagementService.verify(x => x.getSecurityToken(TypeMoq.It.isAny(), TypeMoq.It.isAny()), TypeMoq.Times.once());
 			mockResourceProvider.verify(x => x.createFirewallRule(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny()), TypeMoq.Times.once());
 			mockFirewallRuleDialog.verify(x => x.close(), TypeMoq.Times.once());
 			mockFirewallRuleDialog.verify(x => x.onServiceComplete(), TypeMoq.Times.once());
@@ -165,7 +165,7 @@ suite('Firewall rule dialog controller tests', () => {
 
 		// Then: it should get security token from account management service and an error dialog should have been opened
 		deferredPromise.promise.then(() => {
-			mockAccountManagementService.verify(x => x.getSecurityToken(TypeMoq.It.isAny()), TypeMoq.Times.once());
+			mockAccountManagementService.verify(x => x.getSecurityToken(TypeMoq.It.isAny(), TypeMoq.It.isAny()), TypeMoq.Times.once());
 			mockErrorMessageService.verify(x => x.showDialog(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny()), TypeMoq.Times.once());
 			mockResourceProvider.verify(x => x.createFirewallRule(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny()), TypeMoq.Times.never());
 			done();
@@ -193,7 +193,7 @@ suite('Firewall rule dialog controller tests', () => {
 
 		// Then: it should get security token from account management service and an error dialog should have been opened
 		deferredPromise.promise.then(() => {
-			mockAccountManagementService.verify(x => x.getSecurityToken(TypeMoq.It.isAny()), TypeMoq.Times.once());
+			mockAccountManagementService.verify(x => x.getSecurityToken(TypeMoq.It.isAny(), TypeMoq.It.isAny()), TypeMoq.Times.once());
 			mockResourceProvider.verify(x => x.createFirewallRule(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny()), TypeMoq.Times.once());
 			mockErrorMessageService.verify(x => x.showDialog(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny()), TypeMoq.Times.once());
 			done();
@@ -221,7 +221,7 @@ suite('Firewall rule dialog controller tests', () => {
 
 		// Then: it should get security token from account management service and an error dialog should have been opened
 		deferredPromise.promise.then(() => {
-			mockAccountManagementService.verify(x => x.getSecurityToken(TypeMoq.It.isAny()), TypeMoq.Times.once());
+			mockAccountManagementService.verify(x => x.getSecurityToken(TypeMoq.It.isAny(), TypeMoq.It.isAny()), TypeMoq.Times.once());
 			mockResourceProvider.verify(x => x.createFirewallRule(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny()), TypeMoq.Times.once());
 			mockErrorMessageService.verify(x => x.showDialog(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny()), TypeMoq.Times.once());
 			done();
@@ -232,7 +232,7 @@ suite('Firewall rule dialog controller tests', () => {
 function getMockAccountManagementService(resolveSecurityToken: boolean): TypeMoq.Mock<AccountManagementTestService> {
 	let accountManagementTestService = new AccountManagementTestService();
 	let mockAccountManagementService = TypeMoq.Mock.ofInstance(accountManagementTestService);
-	mockAccountManagementService.setup(x => x.getSecurityToken(TypeMoq.It.isAny()))
+	mockAccountManagementService.setup(x => x.getSecurityToken(TypeMoq.It.isAny(), TypeMoq.It.isAny()))
 		.returns(() => resolveSecurityToken ? Promise.resolve({}) : Promise.reject(null).then());
 	return mockAccountManagementService;
 }

src/sqltest/parts/connection/connectionManagementService.test.ts

@@ -34,6 +34,7 @@ import * as assert from 'assert';
 import * as TypeMoq from 'typemoq';
 import { IConnectionProfileGroup, ConnectionProfileGroup } from 'sql/parts/connection/common/connectionProfileGroup';
 import { ConnectionProfile } from 'sql/parts/connection/common/connectionProfile';
+import { AccountManagementTestService } from 'sqltest/stubs/accountManagementStubs';
 
 suite('SQL ConnectionManagementService tests', () => {
 
@@ -46,6 +47,7 @@ suite('SQL ConnectionManagementService tests', () => {
 	let mssqlConnectionProvider: TypeMoq.Mock<ConnectionProviderStub>;
 	let workspaceConfigurationServiceMock: TypeMoq.Mock<WorkspaceConfigurationTestService>;
 	let resourceProviderStubMock: TypeMoq.Mock<ResourceProviderStub>;
+	let accountManagementService: TypeMoq.Mock<AccountManagementTestService>;
 
 	let none: void;
 
@@ -88,6 +90,7 @@ suite('SQL ConnectionManagementService tests', () => {
 		mssqlConnectionProvider = TypeMoq.Mock.ofType(ConnectionProviderStub);
 		let resourceProviderStub = new ResourceProviderStub();
 		resourceProviderStubMock = TypeMoq.Mock.ofInstance(resourceProviderStub);
+		accountManagementService = TypeMoq.Mock.ofType(AccountManagementTestService);
 		let root = new ConnectionProfileGroup(ConnectionProfileGroup.RootGroupName, undefined, ConnectionProfileGroup.RootGroupName, undefined, undefined);
 		root.connections = [ConnectionProfile.fromIConnectionProfile(capabilitiesService, connectionProfile)];
 
@@ -162,7 +165,8 @@ suite('SQL ConnectionManagementService tests', () => {
 			undefined,
 			resourceProviderStubMock.object,
 			undefined,
-			undefined
+			undefined,
+			accountManagementService.object
 		);
 		return connectionManagementService;
 	}
@@ -837,4 +841,44 @@ suite('SQL ConnectionManagementService tests', () => {
 		// Then undefined is returned
 		assert.equal(foundUri, undefined);
 	});
+
+	test('addSavedPassword fills in Azure access tokens for Azure accounts', async () => {
+		// Set up a connection profile that uses Azure
+		let azureConnectionProfile = ConnectionProfile.fromIConnectionProfile(capabilitiesService, connectionProfile);
+		azureConnectionProfile.authenticationType = 'AzureMFA';
+		let username = 'testuser@microsoft.com';
+		azureConnectionProfile.userName = username;
+		let servername = 'test-database.database.windows.net';
+		azureConnectionProfile.serverName = servername;
+
+		// Set up the account management service to return a token for the given user
+		accountManagementService.setup(x => x.getAccountsForProvider(TypeMoq.It.isAny())).returns(providerId => Promise.resolve<sqlops.Account[]>([
+			{
+				key: {
+					accountId: username,
+					providerId: providerId
+				},
+				displayInfo: undefined,
+				isStale: false,
+				properties: undefined
+			}
+		]));
+		let testToken = 'testToken';
+		accountManagementService.setup(x => x.getSecurityToken(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve({
+			azurePublicCloud: {
+				token: testToken
+			}
+		}));
+		connectionStore.setup(x => x.addSavedPassword(TypeMoq.It.is(profile => profile.authenticationType === 'AzureMFA'))).returns(profile => Promise.resolve({
+			profile: profile,
+			savedCred: false
+		}));
+
+		// If I call addSavedPassword
+		let profileWithCredentials = await connectionManagementService.addSavedPassword(azureConnectionProfile);
+
+		// Then the returned profile has the account token set
+		assert.equal(profileWithCredentials.userName, username);
+		assert.equal(profileWithCredentials.options['azureAccountToken'], testToken);
+	});
 });

src/sqltest/stubs/accountManagementStubs.ts

@@ -50,7 +50,7 @@ export class AccountManagementTestService implements IAccountManagementService {
 		return undefined;
 	}
 
-	getSecurityToken(account: sqlops.Account): Thenable<{}> {
+	getSecurityToken(account: sqlops.Account, resource: sqlops.AzureResource): Thenable<{}> {
 		return undefined;
 	}
 
@@ -88,7 +88,7 @@ export class AccountProviderStub implements sqlops.AccountProvider {
 		return Promise.resolve();
 	}
 
-	getSecurityToken(account: sqlops.Account): Thenable<{}> {
+	getSecurityToken(account: sqlops.Account, resource: sqlops.AzureResource): Thenable<{}> {
 		return Promise.resolve({});
 	}
 

src/sqltest/workbench/api/extHostAccountManagement.test.ts

@@ -15,7 +15,7 @@ import { TestInstantiationService } from 'vs/platform/instantiation/test/common/
 import { IRPCProtocol } from 'vs/workbench/services/extensions/node/proxyIdentifier';
 import { SqlMainContext } from 'sql/workbench/api/node/sqlExtHost.protocol';
 import { MainThreadAccountManagement } from 'sql/workbench/api/node/mainThreadAccountManagement';
-import { IAccountManagementService } from 'sql/services/accountManagement/interfaces';
+import { IAccountManagementService, AzureResource } from 'sql/services/accountManagement/interfaces';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
 
 const IRPCProtocol = createDecorator<IRPCProtocol>('rpcProtocol');
@@ -366,7 +366,7 @@ suite('ExtHostAccountManagement', () => {
 		extHost.$getAllAccounts()
 			.then((accounts) => {
 		    		// If: I get security token it will not throw
-					return extHost.$getSecurityToken(mockAccount1);
+					return extHost.$getSecurityToken(mockAccount1, AzureResource.ResourceManagement);
 				}
 			).then(() => done(), (err) => done(new Error(err)));
 	});
@@ -417,7 +417,7 @@ suite('ExtHostAccountManagement', () => {
 
 		extHost.$getAllAccounts()
 		.then(accounts => {
-			return extHost.$getSecurityToken(mockAccount2);
+			return extHost.$getSecurityToken(mockAccount2, AzureResource.ResourceManagement);
 		})
 		.then((noError) => {
 			done(new Error('Expected getSecurityToken to throw'));
@@ -447,7 +447,7 @@ function getMockAccountManagementService(accounts: sqlops.Account[]): TypeMoq.Mo
 
 	mockAccountManagementService.setup(x => x.getAccountsForProvider(TypeMoq.It.isAny()))
 		.returns(() => Promise.resolve(accounts));
-	mockAccountManagementService.setup(x => x.getSecurityToken(TypeMoq.It.isValue(accounts[0])))
+	mockAccountManagementService.setup(x => x.getSecurityToken(TypeMoq.It.isValue(accounts[0]), TypeMoq.It.isAny()))
 	    .returns(() => Promise.resolve({}));
 	mockAccountManagementService.setup(x => x.updateAccountListEvent)
 	    .returns(() => () => { return undefined; } );

src/vs/workbench/electron-browser/workbench.ts

@@ -137,6 +137,7 @@ import { IScriptingService, ScriptingService } from 'sql/services/scripting/scri
 import { IAdminService, AdminService } from 'sql/parts/admin/common/adminService';
 import { IJobManagementService } from 'sql/parts/jobManagement/common/interfaces';
 import { JobManagementService } from 'sql/parts/jobManagement/common/jobManagementService';
+import { IDacFxService, DacFxService } from 'sql/services/dacfx/dacFxService';
 import { IBackupService, IBackupUiService } from 'sql/parts/disasterRecovery/backup/common/backupService';
 import { BackupService, BackupUiService } from 'sql/parts/disasterRecovery/backup/common/backupServiceImp';
 import { IRestoreDialogController, IRestoreService } from 'sql/parts/disasterRecovery/restore/common/restoreService';
@@ -557,6 +558,8 @@ export class Workbench extends Disposable implements IPartService {
 		serviceCollection.set(IServerGroupController, this.instantiationService.createInstance(ServerGroupController));
 		serviceCollection.set(ICredentialsService, this.instantiationService.createInstance(CredentialsService));
 		serviceCollection.set(IResourceProviderService, this.instantiationService.createInstance(ResourceProviderService));
+		let accountManagementService = this.instantiationService.createInstance(AccountManagementService, undefined);
+		serviceCollection.set(IAccountManagementService, accountManagementService);
 		let connectionManagementService = this.instantiationService.createInstance(ConnectionManagementService, undefined, undefined);
 		serviceCollection.set(IConnectionManagementService, connectionManagementService);
 		serviceCollection.set(ISerializationService, this.instantiationService.createInstance(SerializationService));
@@ -577,8 +580,6 @@ export class Workbench extends Disposable implements IPartService {
 		serviceCollection.set(IFileBrowserService, this.instantiationService.createInstance(FileBrowserService));
 		serviceCollection.set(IFileBrowserDialogController, this.instantiationService.createInstance(FileBrowserDialogController));
 		serviceCollection.set(IInsightsDialogService, this.instantiationService.createInstance(InsightsDialogService));
-		let accountManagementService = this.instantiationService.createInstance(AccountManagementService, undefined);
-		serviceCollection.set(IAccountManagementService, accountManagementService);
 		let notebookService = this.instantiationService.createInstance(NotebookService);
 		serviceCollection.set(INotebookService, notebookService);
 		serviceCollection.set(IAccountPickerService, this.instantiationService.createInstance(AccountPickerService));
@@ -586,6 +587,8 @@ export class Workbench extends Disposable implements IPartService {
 		// {{SQL CARBON EDIT}}
 		serviceCollection.set(ICommandLineProcessing, this.instantiationService.createInstance(CommandLineService));
 		// {{SQL CARBON EDIT}}
+		serviceCollection.set(IDacFxService, this.instantiationService.createInstance(DacFxService));
+
 		this._register(toDisposable(() => connectionManagementService.shutdown()));
 		this._register(toDisposable(() => accountManagementService.shutdown()));
 		this._register(toDisposable(() => notebookService.shutdown()));