added default config for timeSeries since it is not the same (#1852)

* Edit alert WIP

* A couple alert edit bugs

* Hook up dashboard refresh notification

* Hook onchange event to other agent service calls

* Switch update handler to scalar value

* Add null check on handler callback

.vscode/settings.json

@@ -38,5 +38,6 @@
 			}
 		}
 	],
-	"typescript.tsdk": "node_modules/typescript/lib"
+	"typescript.tsdk": "node_modules/typescript/lib",
+	"git.ignoreLimitWarning": true
 }

CHANGELOG.md

@@ -22,7 +22,7 @@ The May release is focused on stabilization and bug fixes leading up to the Buil
 
 * Announcing **Redgate SQL Search** extension available in Extension Manager
 * Community Localization available for 10 languages: **German, Spanish, French, Italian, Japanese, Korean, Portuguese, Russian, Simplified Chinese and Traditional Chinese!**
-* **GDPR-compliant** build has reduced telemetry collection, improved [opt-out](https://github.com/Microsoft/sqlopsstudio/wiki/How-to-Disable-Telemetry-Reporting) experience and in-product links to [Privacy Statement](https://privacy.microsoft.com/en-us/privacystatement)
+* Reduced telemetry collection, improved [opt-out](https://github.com/Microsoft/sqlopsstudio/wiki/How-to-Disable-Telemetry-Reporting) experience and in-product links to [Privacy Statement](https://privacy.microsoft.com/en-us/privacystatement)
 * Extension Manager has improved Marketplace experience to easily discover community extensions
 * SQL Agent extension Jobs and Job History view improvement
 * Updates for **whoisactive** and **Server Reports** extensions

extensions/agent/client/src/mainController.ts

@@ -1,38 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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 data from 'sqlops';
-import { ApiWrapper } from './apiWrapper';
-
-/**
- * The main controller class that initializes the extension
- */
-export class MainController  {
-    protected _apiWrapper: ApiWrapper;
-    protected _context: vscode.ExtensionContext;
-
-    // PUBLIC METHODS //////////////////////////////////////////////////////
-    public constructor(context: vscode.ExtensionContext, apiWrapper?: ApiWrapper) {
-        this._apiWrapper = apiWrapper || new ApiWrapper();
-        this._context = context;
-
-        console.log('Got: ' + apiWrapper);
-    }
-
-    /**
-     * Deactivates the extension
-     */
-    public deactivate(): void {
-    }
-
-    public activate(): void {
-
-        this._apiWrapper.registerWebviewProvider('data-management-agent', webview => {
-            webview.html = '<div><h1>SQL Agent</h1></div>';
-        });
-    }
-}

extensions/agent/package.json

@@ -1,23 +1,20 @@
 {
   "name": "agent",
   "displayName": "SQL Server Agent",
-  "description": "Manage and troubleshoot SQL Server Agent jobs (early preview)",
-  "version": "0.29.0",
+  "description": "Manage and troubleshoot SQL Server Agent jobs",
+  "version": "0.31.1",
   "publisher": "Microsoft",
   "preview": true,
   "license": "https://raw.githubusercontent.com/Microsoft/sqlopsstudio/master/LICENSE.txt",
   "icon": "images/sqlserver.png",
   "aiKey": "AIF-5574968e-856d-40d2-af67-c89a14e76412",
   "engines": {
-    "vscode": "0.10.x"
+      "vscode": "0.10.x"
   },
   "activationEvents": [
     "*"
   ],
-  "main": "./client/out/main",
-  "scripts": {
-    "compile": "gulp compile-extension:agent-client"
-  },
+  "main": "./out/main",
   "repository": {
     "type": "git",
     "url": "https://github.com/Microsoft/sqlopsstudio.git"
@@ -29,22 +26,32 @@
     "outputChannels": [
       "sqlagent"
     ],
+    "commands": [
+      {
+        "command": "agent.openNewStepDialog",
+        "title": "agent.openNewStepDialog"
+      }
+    ],
     "dashboard.tabs": [
-        {
-            "id": "data-management-agent",
-            "description": "Manage and troubleshoot SQL Agent jobs",
-            "provider": "MSSQL",
-            "title": "SQL Agent",
-            "when": "connectionProvider == 'MSSQL' && !mssql:iscloud",
-            "container": {
-                "controlhost-container": {
-                  "type": "agent"
-                }
-            }
+      {
+        "id": "data-management-agent",
+        "description": "Manage and troubleshoot SQL Agent jobs",
+        "provider": "MSSQL",
+        "title": "SQL Agent",
+        "when": "connectionProvider == 'MSSQL' && !mssql:iscloud",
+        "container": {
+          "controlhost-container": {
+            "type": "agent"
+          }
         }
+      }
     ]
   },
+  "dependencies": {
+    "vscode-nls": "^3.2.1"
+  },
   "devDependencies": {
-    "vscode": "1.0.1"
-  }
+		"mocha-junit-reporter": "^1.17.0",
+		"mocha-multi-reporters": "^1.1.7"
+	}
 }

extensions/agent/src/agentUtils.ts

@@ -0,0 +1,38 @@
+'use strict';
+
+import * as sqlops from 'sqlops';
+
+export class AgentUtils {
+
+	private static _agentService: sqlops.AgentServicesProvider;
+	private static _connectionService: sqlops.ConnectionProvider;
+	private static _queryProvider: sqlops.QueryProvider;
+
+	public static async getAgentService(): Promise<sqlops.AgentServicesProvider> {
+		if (!AgentUtils._agentService) {
+			let currentConnection = await sqlops.connection.getCurrentConnection();
+			this._agentService = sqlops.dataprotocol.getProvider<sqlops.AgentServicesProvider>(currentConnection.providerName, sqlops.DataProviderType.AgentServicesProvider);
+		}
+		return AgentUtils._agentService;
+	}
+
+	public static async getDatabases(ownerUri: string): Promise<string[]> {
+		if (!AgentUtils._connectionService) {
+			let currentConnection = await sqlops.connection.getCurrentConnection();
+			this._connectionService = sqlops.dataprotocol.getProvider<sqlops.ConnectionProvider>(currentConnection.providerName, sqlops.DataProviderType.ConnectionProvider);
+		}
+		return AgentUtils._connectionService.listDatabases(ownerUri).then(result => {
+			if (result && result.databaseNames && result.databaseNames.length > 0) {
+				return result.databaseNames;
+			}
+		});
+	}
+
+	public static async getQueryProvider(): Promise<sqlops.QueryProvider> {
+		if (!AgentUtils._queryProvider) {
+			let currentConnection = await sqlops.connection.getCurrentConnection();
+			this._queryProvider = sqlops.dataprotocol.getProvider<sqlops.QueryProvider>(currentConnection.providerName, sqlops.DataProviderType.QueryProvider);
+		}
+		return this._queryProvider;
+	}
+}

extensions/agent/src/data/alertData.ts

@@ -0,0 +1,117 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 nls from 'vscode-nls';
+import * as vscode from 'vscode';
+import * as sqlops from 'sqlops';
+import { AgentUtils } from '../agentUtils';
+import { IAgentDialogData, AgentDialogMode } from '../interfaces';
+
+const localize = nls.loadMessageBundle();
+
+export class AlertData implements IAgentDialogData {
+	ownerUri: string;
+	dialogMode: AgentDialogMode = AgentDialogMode.CREATE;
+	id: number;
+	name: string;
+	originalName: string;
+	delayBetweenResponses: number;
+	eventDescriptionKeyword: string;
+	eventSource: string;
+	hasNotification: number;
+	includeEventDescription: string;
+	isEnabled: boolean;
+	jobId: string;
+	jobName: string;
+	lastOccurrenceDate: string;
+	lastResponseDate: string;
+	messageId: number;
+	notificationMessage: string;
+	occurrenceCount: number;
+	performanceCondition: string;
+	severity: number;
+	databaseName: string;
+	countResetDate: string;
+	categoryName: string;
+	alertType: string;
+	wmiEventNamespace: string;
+	wmiEventQuery: string;
+
+	constructor(ownerUri:string, alertInfo: sqlops.AgentAlertInfo) {
+		this.ownerUri = ownerUri;
+
+		if (alertInfo) {
+			this.dialogMode = AgentDialogMode.EDIT;
+			this.id = alertInfo.id;
+			this.name = alertInfo.name;
+			this.originalName = alertInfo.name;
+			this.delayBetweenResponses = alertInfo.delayBetweenResponses;
+			this.eventDescriptionKeyword = alertInfo.eventDescriptionKeyword;
+			this.eventSource = alertInfo.eventSource;
+			this.hasNotification = alertInfo.hasNotification;
+			this.includeEventDescription = alertInfo.includeEventDescription.toString();
+			this.isEnabled = alertInfo.isEnabled;
+			this.jobId = alertInfo.jobId;
+			this.jobName = alertInfo.jobName;
+			this.lastOccurrenceDate = alertInfo.lastOccurrenceDate;
+			this.lastResponseDate = alertInfo.lastResponseDate;
+			this.messageId = alertInfo.messageId;
+			this.notificationMessage = alertInfo.notificationMessage;
+			this.occurrenceCount = alertInfo.occurrenceCount;
+			this.performanceCondition = alertInfo.performanceCondition;
+			this.severity = alertInfo.severity;
+			this.databaseName = alertInfo.databaseName;
+			this.countResetDate = alertInfo.countResetDate;
+			this.categoryName = alertInfo.categoryName;
+			this.alertType = alertInfo.alertType.toString();
+			this.wmiEventNamespace = alertInfo.wmiEventNamespace;
+			this.wmiEventQuery = alertInfo.wmiEventQuery;
+		}
+	}
+
+	public async initialize() {
+	}
+
+	public async save() {
+		let agentService = await AgentUtils.getAgentService();
+		let result = this.dialogMode === AgentDialogMode.CREATE
+			? await agentService.createAlert(this.ownerUri,  this.toAgentAlertInfo())
+			: await agentService.updateAlert(this.ownerUri, this.originalName, this.toAgentAlertInfo());
+
+		if (!result || !result.success) {
+			vscode.window.showErrorMessage(
+				localize('alertData.saveErrorMessage', "Alert update failed '{0}'", result.errorMessage ? result.errorMessage : 'Unknown'));
+		}
+	}
+
+	public toAgentAlertInfo(): sqlops.AgentAlertInfo {
+		return {
+			id: this.id,
+			name: this.name,
+			delayBetweenResponses: this.delayBetweenResponses,
+			eventDescriptionKeyword: this.eventDescriptionKeyword,
+			eventSource: this.eventSource,
+			hasNotification: this.hasNotification,
+			includeEventDescription: sqlops.NotifyMethods.none, // this.includeEventDescription,
+			isEnabled: this.isEnabled,
+			jobId: this.jobId,
+			jobName: this.jobName,
+			lastOccurrenceDate: this.lastOccurrenceDate,
+			lastResponseDate: this.lastResponseDate,
+			messageId: this.messageId,
+			notificationMessage: this.notificationMessage,
+			occurrenceCount: this.occurrenceCount,
+			performanceCondition: this.performanceCondition,
+			severity: this.severity,
+			databaseName: this.databaseName,
+			countResetDate: this.countResetDate,
+			categoryName: this.categoryName,
+			alertType: sqlops.AlertType.sqlServerEvent, //this.alertType,
+			wmiEventNamespace: this.wmiEventNamespace,
+			wmiEventQuery: this.wmiEventQuery
+		};
+	}
+}

extensions/agent/src/data/jobData.ts

@@ -0,0 +1,151 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { AgentUtils } from '../agentUtils';
+import { IAgentDialogData, AgentDialogMode } from '../interfaces';
+
+export class JobData implements IAgentDialogData {
+
+	private readonly JobCompletionActionCondition_Always: string = 'When the job completes';
+	private readonly JobCompletionActionCondition_OnFailure: string = 'When the job fails';
+	private readonly JobCompletionActionCondition_OnSuccess: string = 'When the job succeeds';
+
+	// Error Messages
+	private readonly CreateJobErrorMessage_NameIsEmpty = 'Job name must be provided';
+
+	private _ownerUri: string;
+	private _jobCategories: string[];
+	private _operators: string[];
+	private _defaultOwner: string;
+	private _jobCompletionActionConditions: sqlops.CategoryValue[];
+
+	public dialogMode: AgentDialogMode = AgentDialogMode.CREATE;
+	public name: string;
+	public enabled: boolean = true;
+	public description: string;
+	public category: string;
+	public categoryId: number;
+	public owner: string;
+	public emailLevel: sqlops.JobCompletionActionCondition = sqlops.JobCompletionActionCondition.OnFailure;
+	public pageLevel: sqlops.JobCompletionActionCondition = sqlops.JobCompletionActionCondition.OnFailure;
+	public eventLogLevel: sqlops.JobCompletionActionCondition = sqlops.JobCompletionActionCondition.OnFailure;
+	public deleteLevel: sqlops.JobCompletionActionCondition = sqlops.JobCompletionActionCondition.OnSuccess;
+	public operatorToEmail: string;
+	public operatorToPage: string;
+	public jobSteps: sqlops.AgentJobStepInfo[];
+	public jobSchedules: sqlops.AgentJobScheduleInfo[];
+	public alerts: sqlops.AgentAlertInfo[];
+
+	constructor(ownerUri: string, private _agentService: sqlops.AgentServicesProvider = null) {
+		this._ownerUri = ownerUri;
+	}
+
+	public get jobCategories(): string[] {
+		return this._jobCategories;
+	}
+
+	public get operators(): string[] {
+		return this._operators;
+	}
+
+	public get ownerUri(): string {
+		return this._ownerUri;
+	}
+
+	public get defaultOwner(): string {
+		return this._defaultOwner;
+	}
+
+	public get JobCompletionActionConditions(): sqlops.CategoryValue[] {
+		return this._jobCompletionActionConditions;
+	}
+
+	public async initialize() {
+		this._agentService = await AgentUtils.getAgentService();
+		let jobDefaults = await this._agentService.getJobDefaults(this.ownerUri);
+		if (jobDefaults && jobDefaults.success) {
+			this._jobCategories = jobDefaults.categories.map((cat) => {
+				return cat.name;
+			});
+
+			this._defaultOwner = jobDefaults.owner;
+
+			this._operators = ['', this._defaultOwner];
+		}
+
+		this._jobCompletionActionConditions = [{
+			displayName: this.JobCompletionActionCondition_OnSuccess,
+			name: sqlops.JobCompletionActionCondition.OnSuccess.toString()
+		}, {
+			displayName: this.JobCompletionActionCondition_OnFailure,
+			name: sqlops.JobCompletionActionCondition.OnFailure.toString()
+		}, {
+			displayName: this.JobCompletionActionCondition_Always,
+			name: sqlops.JobCompletionActionCondition.Always.toString()
+		}];
+
+		this.jobSchedules = [];
+	}
+
+	public async save() {
+		await this._agentService.createJob(this.ownerUri, {
+			name: this.name,
+			owner: this.owner,
+			description: this.description,
+			EmailLevel: this.emailLevel,
+			PageLevel: this.pageLevel,
+			EventLogLevel: this.eventLogLevel,
+			DeleteLevel: this.deleteLevel,
+			OperatorToEmail: this.operatorToEmail,
+			OperatorToPage: this.operatorToPage,
+			enabled: this.enabled,
+			category: this.category,
+			Alerts: this.alerts,
+			JobSchedules: this.jobSchedules,
+			JobSteps: this.jobSteps,
+			// The properties below are not collected from UI
+			// We could consider using a seperate class for create job request
+			//
+			currentExecutionStatus: 0,
+			lastRunOutcome: 0,
+			currentExecutionStep: '',
+			hasTarget: true,
+			hasSchedule: false,
+			hasStep: false,
+			runnable: true,
+			categoryId: 0,
+			categoryType: 1, // LocalJob, hard-coding the value, corresponds to the target tab in SSMS
+			lastRun: '',
+			nextRun: '',
+			jobId: ''
+		}).then(result => {
+			if (!result.success) {
+				console.info(result.errorMessage);
+			}
+		});
+	}
+
+	public validate(): { valid: boolean, errorMessages: string[] } {
+		let validationErrors: string[] = [];
+
+		if (!(this.name && this.name.trim())) {
+			validationErrors.push(this.CreateJobErrorMessage_NameIsEmpty);
+		}
+
+		return {
+			valid: validationErrors.length === 0,
+			errorMessages: validationErrors
+		};
+	}
+
+	public addJobSchedule(schedule: sqlops.AgentJobScheduleInfo) {
+		let existingSchedule = this.jobSchedules.find(item => item.name === schedule.name);
+		if (!existingSchedule) {
+			this.jobSchedules.push(schedule);
+		}
+	}
+}

extensions/agent/src/data/jobStepData.ts

@@ -0,0 +1,76 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { AgentUtils } from '../agentUtils';
+import { IAgentDialogData, AgentDialogMode } from '../interfaces';
+
+export class JobStepData implements IAgentDialogData {
+	public dialogMode: AgentDialogMode = AgentDialogMode.CREATE;
+	public ownerUri: string;
+	public jobId: string; //
+	public jobName: string;
+	public script: string; //
+	public scriptName: string;
+	public stepName: string; //
+	public subSystem: string; //
+	public id: number;
+	public failureAction: string; //
+	public successAction: string; //
+	public failStepId: number;
+	public successStepId: number;
+	public command: string;
+	public commandExecutionSuccessCode: number;
+	public databaseName: string; //
+	public databaseUserName: string;
+	public server: string;
+	public outputFileName: string; //
+	public appendToLogFile: boolean;
+	public appendToStepHist: boolean;
+	public writeLogToTable: boolean;
+	public appendLogToTable: boolean;
+	public retryAttempts: number; //
+	public retryInterval: number; //
+	public proxyName: string;
+
+	constructor(ownerUri:string) {
+		this.ownerUri = ownerUri;
+	}
+
+	public async initialize() {
+	}
+
+	public async save() {
+		let agentService = await AgentUtils.getAgentService();
+		agentService.createJobStep(this.ownerUri, {
+			jobId: this.jobId,
+			jobName: this.jobName,
+			script: this.script,
+			scriptName: this.scriptName,
+			stepName: this.stepName,
+			subSystem: this.subSystem,
+			id: 1,
+			failureAction: this.failureAction,
+			successAction: this.successAction,
+			failStepId: this.failStepId,
+			successStepId: this.successStepId,
+			command: this.command,
+			commandExecutionSuccessCode: this.commandExecutionSuccessCode,
+			databaseName: this.databaseName,
+			databaseUserName: this.databaseUserName,
+			server: this.server,
+			outputFileName: this.outputFileName,
+			appendToLogFile: this.appendToLogFile,
+			appendToStepHist: this.appendToStepHist,
+			writeLogToTable: this.writeLogToTable,
+			appendLogToTable: this.appendLogToTable,
+			retryAttempts: this.retryAttempts,
+			retryInterval: this.retryInterval,
+			proxyName: this.proxyName
+		}).then(result => {
+			console.info(result);
+		});
+	}
+}

extensions/agent/src/data/operatorData.ts

@@ -0,0 +1,68 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { AgentUtils } from '../agentUtils';
+import { IAgentDialogData, AgentDialogMode } from '../interfaces';
+
+export class OperatorData implements IAgentDialogData {
+	public dialogMode: AgentDialogMode = AgentDialogMode.CREATE;
+	ownerUri: string;
+	name: string;
+	id: number;
+	emailAddress: string;
+	enabled: boolean;
+	lastEmailDate: string;
+	lastNetSendDate: string;
+	lastPagerDate: string;
+	pagerAddress: string;
+	categoryName: string;
+	pagerDays: string;
+	saturdayPagerEndTime: string;
+	saturdayPagerStartTime: string;
+	sundayPagerEndTime: string;
+	sundayPagerStartTime: string;
+	netSendAddress: string;
+	weekdayPagerStartTime: string;
+	weekdayPagerEndTime: string;
+
+	constructor(ownerUri:string) {
+		this.ownerUri = ownerUri;
+	}
+
+	public async initialize() {
+	}
+
+	public async save() {
+		let agentService = await AgentUtils.getAgentService();
+		let result = await agentService.createOperator(this.ownerUri,  this.toAgentOperatorInfo());
+		if (!result || !result.success) {
+			// TODO handle error here
+		}
+	}
+
+	public toAgentOperatorInfo(): sqlops.AgentOperatorInfo {
+		return {
+			name: this.name,
+			id: this.id,
+			emailAddress: this.emailAddress,
+			enabled: this.enabled,
+			lastEmailDate: this.lastEmailDate,
+			lastNetSendDate: this.lastNetSendDate,
+			lastPagerDate: this.lastPagerDate,
+			pagerAddress: this.pagerAddress,
+			categoryName: this.categoryName,
+			pagerDays: sqlops.WeekDays.weekDays, //this.pagerDays,
+			saturdayPagerEndTime: this.saturdayPagerEndTime,
+			saturdayPagerStartTime: this.saturdayPagerStartTime,
+			sundayPagerEndTime: this.sundayPagerEndTime,
+			sundayPagerStartTime: this.sundayPagerStartTime,
+			netSendAddress: this.netSendAddress,
+			weekdayPagerStartTime: this.weekdayPagerStartTime,
+			weekdayPagerEndTime: this.weekdayPagerEndTime
+		};
+	}
+}

extensions/agent/src/data/pickScheduleData.ts

@@ -0,0 +1,31 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { AgentUtils } from '../agentUtils';
+import { IAgentDialogData, AgentDialogMode } from '../interfaces';
+
+export class PickScheduleData implements IAgentDialogData {
+	public dialogMode: AgentDialogMode = AgentDialogMode.VIEW;
+	public ownerUri: string;
+	public schedules: sqlops.AgentJobScheduleInfo[];
+	public selectedSchedule: sqlops.AgentJobScheduleInfo;
+
+	constructor(ownerUri:string) {
+		this.ownerUri = ownerUri;
+	}
+
+	public async initialize() {
+		let agentService = await AgentUtils.getAgentService();
+		let result = await agentService.getJobSchedules(this.ownerUri);
+		if (result && result.success) {
+			this.schedules = result.schedules;
+		}
+	}
+
+	public async save() {
+	}
+}

extensions/agent/src/data/proxyData.ts

@@ -0,0 +1,48 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { AgentUtils } from '../agentUtils';
+import { IAgentDialogData, AgentDialogMode } from '../interfaces';
+
+export class ProxyData implements IAgentDialogData {
+	public dialogMode: AgentDialogMode = AgentDialogMode.CREATE;
+	ownerUri: string;
+	id: number;
+	accountName: string;
+	description: string;
+	credentialName: string;
+	credentialIdentity: string;
+	credentialId: number;
+	isEnabled: boolean;
+
+	constructor(ownerUri:string) {
+		this.ownerUri = ownerUri;
+	}
+
+	public async initialize() {
+	}
+
+	public async save() {
+		let agentService = await AgentUtils.getAgentService();
+		let result = await agentService.createProxy(this.ownerUri,  this.toAgentProxyInfo());
+		if (!result || !result.success) {
+			// TODO handle error here
+		}
+	}
+
+	public toAgentProxyInfo(): sqlops.AgentProxyInfo {
+		return {
+			id: this.id,
+			accountName: this.accountName,
+			description: this.description,
+			credentialName: this.credentialName,
+			credentialIdentity: this.credentialIdentity,
+			credentialId: this.credentialId,
+			isEnabled: this.isEnabled
+		};
+	}
+}

extensions/agent/src/data/scheduleData.ts

@@ -0,0 +1,31 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { AgentUtils } from '../agentUtils';
+import { IAgentDialogData, AgentDialogMode } from '../interfaces';
+
+export class ScheduleData implements IAgentDialogData {
+	public dialogMode: AgentDialogMode = AgentDialogMode.CREATE;
+	public ownerUri: string;
+	public schedules: sqlops.AgentJobScheduleInfo[];
+	public selectedSchedule: sqlops.AgentJobScheduleInfo;
+
+	constructor(ownerUri:string) {
+		this.ownerUri = ownerUri;
+	}
+
+	public async initialize() {
+		let agentService = await AgentUtils.getAgentService();
+		let result = await agentService.getJobSchedules(this.ownerUri);
+		if (result && result.success) {
+			this.schedules = result.schedules;
+		}
+	}
+
+	public async save() {
+	}
+}

extensions/agent/src/dialogs/agentDialog.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 nls from 'vscode-nls';
+import * as sqlops from 'sqlops';
+import * as vscode from 'vscode';
+import { IAgentDialogData, AgentDialogMode } from '../interfaces';
+
+const localize = nls.loadMessageBundle();
+
+export abstract class AgentDialog<T extends IAgentDialogData> {
+
+	private static readonly OkButtonText: string = localize('agentDialog.OK', 'OK');
+	private static readonly CancelButtonText: string = localize('agentDialog.Cancel', 'Cancel');
+
+	protected _onSuccess: vscode.EventEmitter<T> = new vscode.EventEmitter<T>();
+	public readonly onSuccess: vscode.Event<T> = this._onSuccess.event;
+	public dialog: sqlops.window.modelviewdialog.Dialog;
+
+	constructor(public ownerUri: string, public model: T, public title: string) {
+	}
+
+	public get dialogMode(): AgentDialogMode {
+		return this.model.dialogMode;
+	}
+
+	protected abstract async updateModel();
+
+	protected abstract async initializeDialog(dialog: sqlops.window.modelviewdialog.Dialog);
+
+	public async openDialog() {
+		this.dialog = sqlops.window.modelviewdialog.createDialog(this.title);
+
+		await this.model.initialize();
+
+		await this.initializeDialog(this.dialog);
+
+		this.dialog.okButton.label = AgentDialog.OkButtonText;
+		this.dialog.okButton.onClick(async () => await this.execute());
+
+		this.dialog.cancelButton.label = AgentDialog.CancelButtonText;
+		this.dialog.cancelButton.onClick(async () => await this.cancel());
+
+		sqlops.window.modelviewdialog.openDialog(this.dialog);
+	}
+
+	protected async execute() {
+		this.updateModel();
+		let success = await this.model.save();
+		if (success) {
+			this._onSuccess.fire(this.model);
+		}
+	}
+
+	protected async cancel() {
+	}
+
+	protected getActualConditionValue(checkbox: sqlops.CheckBoxComponent, dropdown: sqlops.DropDownComponent): sqlops.JobCompletionActionCondition {
+		return checkbox.checked ? Number(this.getDropdownValue(dropdown)) : sqlops.JobCompletionActionCondition.Never;
+	}
+
+	protected getDropdownValue(dropdown: sqlops.DropDownComponent): string {
+		return (typeof dropdown.value === 'string') ? dropdown.value : dropdown.value.name;
+	}
+
+	protected setConditionDropdownSelectedValue(dropdown: sqlops.DropDownComponent, selectedValue: number) {
+		let idx: number = 0;
+		for (idx = 0; idx < dropdown.values.length; idx++) {
+			if (Number((<sqlops.CategoryValue>dropdown.values[idx]).name) === selectedValue) {
+				dropdown.value = dropdown.values[idx];
+				break;
+			}
+		}
+	}
+}

extensions/agent/src/dialogs/alertDialog.ts

@@ -0,0 +1,355 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 nls from 'vscode-nls';
+import * as sqlops from 'sqlops';
+import { AgentDialog } from './agentDialog';
+import { AgentUtils } from '../agentUtils';
+import { AlertData } from '../data/alertData';
+
+const localize = nls.loadMessageBundle();
+
+export class AlertDialog extends AgentDialog<AlertData> {
+
+	// Top level
+	private static readonly CreateDialogTitle: string = localize('alertDialog.createAlert', 'Create Alert');
+	private static readonly EditDialogTitle: string = localize('alertDialog.editAlert', 'Edit Alert');
+	private static readonly GeneralTabText: string = localize('alertDialog.General', 'General');
+	private static readonly ResponseTabText: string = localize('alertDialog.Response', 'Response');
+	private static readonly OptionsTabText: string = localize('alertDialog.Options', 'Options');
+
+	// General tab strings
+	private static readonly NameLabel: string = localize('alertDialog.Name', 'Name');
+	private static readonly TypeLabel: string = localize('alertDialog.Type', 'Type');
+	private static readonly EnabledCheckboxLabel: string = localize('alertDialog.Enabled', 'Enabled');
+	private static readonly DatabaseLabel: string = localize('alertDialog.DatabaseName', 'Database name');
+	private static readonly ErrorNumberLabel: string = localize('alertDialog.ErrorNumber', 'Error number');
+	private static readonly SeverityLabel: string = localize('alertDialog.Severity', 'Severity');
+	private static readonly RaiseIfMessageContainsLabel: string = localize('alertDialog.RaiseAlertContains', 'Raise alert when message contains');
+	private static readonly MessageTextLabel: string = localize('alertDialog.MessageText', 'Message text');
+	private static readonly AlertTypeSqlServerEventString: string = localize('alertDialog.SqlServerEventAlert', 'SQL Server event alert');
+	private static readonly AlertTypePerformanceConditionString: string = localize('alertDialog.PerformanceCondition', 'SQL Server performance condition alert');
+	private static readonly AlertTypeWmiEventString: string = localize('alertDialog.WmiEvent', 'WMI event alert');
+	private static readonly AlertSeverity001Label: string = localize('alertDialog.Severity001', '001 - Miscellaneous System Information');
+	private static readonly AlertSeverity002Label: string = localize('alertDialog.Severity002', '002 - Reserved');
+	private static readonly AlertSeverity003Label: string = localize('alertDialog.Severity003', '003 - Reserved');
+	private static readonly AlertSeverity004Label: string = localize('alertDialog.Severity004', '004 - Reserved');
+	private static readonly AlertSeverity005Label: string = localize('alertDialog.Severity005', '005 - Reserved');
+	private static readonly AlertSeverity006Label: string = localize('alertDialog.Severity006', '006 - Reserved');
+	private static readonly AlertSeverity007Label: string = localize('alertDialog.Severity007', '007 - Notification: Status Information');
+	private static readonly AlertSeverity008Label: string = localize('alertDialog.Severity008', '008 - Notification: User Intervention Required');
+	private static readonly AlertSeverity009Label: string = localize('alertDialog.Severity009', '009 - User Defined');
+	private static readonly AlertSeverity010Label: string = localize('alertDialog.Severity010', '010 - Information');
+	private static readonly AlertSeverity011Label: string = localize('alertDialog.Severity011', '011 - Specified Database Object Not Found');
+	private static readonly AlertSeverity012Label: string = localize('alertDialog.Severity012', '012 - Unused');
+	private static readonly AlertSeverity013Label: string = localize('alertDialog.Severity013', '013 - User Transaction Syntax Error');
+	private static readonly AlertSeverity014Label: string = localize('alertDialog.Severity014', '014 - Insufficient Permission');
+	private static readonly AlertSeverity015Label: string = localize('alertDialog.Severity015', '015 - Syntax Error in SQL Statements');
+	private static readonly AlertSeverity016Label: string = localize('alertDialog.Severity016', '016 - Miscellaneous User Error');
+	private static readonly AlertSeverity017Label: string = localize('alertDialog.Severity017', '017 - Insufficient Resources');
+	private static readonly AlertSeverity018Label: string = localize('alertDialog.Severity018', '018 - Nonfatal Internal Error');
+	private static readonly AlertSeverity019Label: string = localize('alertDialog.Severity019', '019 - Fatal Error in Resource');
+	private static readonly AlertSeverity020Label: string = localize('alertDialog.Severity020', '020 - Fatal Error in Current Process');
+	private static readonly AlertSeverity021Label: string = localize('alertDialog.Severity021', '021 - Fatal Error in Database Processes');
+	private static readonly AlertSeverity022Label: string = localize('alertDialog.Severity022', '022 - Fatal Error: Table Integrity Suspect');
+	private static readonly AlertSeverity023Label: string = localize('alertDialog.Severity023', '023 - Fatal Error: Database Integrity Suspect');
+	private static readonly AlertSeverity024Label: string = localize('alertDialog.Severity024', '024 - Fatal Error: Hardware Error');
+	private static readonly AlertSeverity025Label: string = localize('alertDialog.Severity025', '025 - Fatal Error');
+
+	private static readonly AlertTypes: string[]  = [
+		AlertDialog.AlertTypeSqlServerEventString,
+		AlertDialog.AlertTypePerformanceConditionString,
+		AlertDialog.AlertTypeWmiEventString
+	];
+
+	private static readonly AlertSeverities: string[]  = [
+		AlertDialog.AlertSeverity001Label,
+		AlertDialog.AlertSeverity002Label,
+		AlertDialog.AlertSeverity003Label,
+		AlertDialog.AlertSeverity004Label,
+		AlertDialog.AlertSeverity005Label,
+		AlertDialog.AlertSeverity006Label,
+		AlertDialog.AlertSeverity007Label,
+		AlertDialog.AlertSeverity008Label,
+		AlertDialog.AlertSeverity009Label,
+		AlertDialog.AlertSeverity010Label,
+		AlertDialog.AlertSeverity011Label,
+		AlertDialog.AlertSeverity012Label,
+		AlertDialog.AlertSeverity013Label,
+		AlertDialog.AlertSeverity014Label,
+		AlertDialog.AlertSeverity015Label,
+		AlertDialog.AlertSeverity016Label,
+		AlertDialog.AlertSeverity017Label,
+		AlertDialog.AlertSeverity018Label,
+		AlertDialog.AlertSeverity019Label,
+		AlertDialog.AlertSeverity020Label,
+		AlertDialog.AlertSeverity021Label,
+		AlertDialog.AlertSeverity022Label,
+		AlertDialog.AlertSeverity023Label,
+		AlertDialog.AlertSeverity024Label,
+		AlertDialog.AlertSeverity025Label
+	];
+
+	// Response tab strings
+	private static readonly ExecuteJobCheckBoxLabel: string = localize('alertDialog.ExecuteJob', 'Execute Job');
+	private static readonly ExecuteJobTextBoxLabel: string = localize('alertDialog.ExecuteJobName', 'Job Name');
+	private static readonly NotifyOperatorsTextBoxLabel: string =  localize('alertDialog.NotifyOperators', 'Notify Operators');
+	private static readonly NewJobButtonLabel: string =  localize('alertDialog.NewJob', 'New Job');
+	private static readonly OperatorListLabel: string =  localize('alertDialog.OperatorList', 'Operator List');
+	private static readonly OperatorNameColumnLabel: string =  localize('alertDialog.OperatorName', 'Operator');
+	private static readonly OperatorEmailColumnLabel: string =  localize('alertDialog.OperatorEmail', 'E-mail');
+	private static readonly OperatorPagerColumnLabel: string =  localize('alertDialog.OperatorPager', 'Pager');
+	private static readonly NewOperatorButtonLabel: string =  localize('alertDialog.NewOperator', 'New Operator');
+
+	// Options tab strings
+	private static readonly IncludeErrorInEmailCheckBoxLabel: string =  localize('alertDialog.IncludeErrorInEmail', 'Include alert error text in e-mail');
+	private static readonly IncludeErrorInPagerCheckBoxLabel: string =  localize('alertDialog.IncludeErrorInPager', 'Include alert error text in pager');
+	private static readonly AdditionalMessageTextBoxLabel: string =  localize('alertDialog.AdditionalNotification', 'Additional notification message to send');
+	private static readonly DelayBetweenResponsesTextBoxLabel: string =  localize('alertDialog.DelayBetweenResponse', 'Delay between responses');
+	private static readonly DelayMinutesTextBoxLabel: string =  localize('alertDialog.DelayMinutes', 'Delay Minutes');
+	private static readonly DelaySecondsTextBoxLabel: string =  localize('alertDialog.DelaySeconds', 'Delay Seconds');
+
+	// UI Components
+	private generalTab: sqlops.window.modelviewdialog.DialogTab;
+	private responseTab: sqlops.window.modelviewdialog.DialogTab;
+	private optionsTab: sqlops.window.modelviewdialog.DialogTab;
+
+	// General tab controls
+	private nameTextBox: sqlops.InputBoxComponent;
+	private typeDropDown: sqlops.DropDownComponent;
+	private severityDropDown: sqlops.DropDownComponent;
+	private databaseDropDown: sqlops.DropDownComponent;
+	private enabledCheckBox: sqlops.CheckBoxComponent;
+	private raiseAlertMessageCheckBox: sqlops.CheckBoxComponent;
+	private raiseAlertMessageTextBox: sqlops.InputBoxComponent;
+
+	// Response tab controls
+	private executeJobTextBox: sqlops.InputBoxComponent;
+	private executeJobCheckBox: sqlops.CheckBoxComponent;
+	private newJobButton: sqlops.ButtonComponent;
+	private notifyOperatorsCheckBox: sqlops.CheckBoxComponent;
+	private operatorsTable: sqlops.TableComponent;
+	private newOperatorButton: sqlops.ButtonComponent;
+
+	// Options tab controls
+	private additionalMessageTextBox: sqlops.InputBoxComponent;
+	private includeErrorInEmailTextBox: sqlops.CheckBoxComponent;
+	private includeErrorInPagerTextBox: sqlops.CheckBoxComponent;
+	private delayMinutesTextBox: sqlops.InputBoxComponent;
+	private delaySecondsTextBox: sqlops.InputBoxComponent;
+
+	constructor(ownerUri: string, alertInfo: sqlops.AgentAlertInfo = null) {
+		super(ownerUri,
+			new AlertData(ownerUri, alertInfo),
+			alertInfo ? AlertDialog.EditDialogTitle : AlertDialog.CreateDialogTitle);
+	}
+
+	protected async initializeDialog(dialog: sqlops.window.modelviewdialog.Dialog) {
+		let databases = await AgentUtils.getDatabases(this.ownerUri);
+		this.generalTab = sqlops.window.modelviewdialog.createTab(AlertDialog.GeneralTabText);
+		this.responseTab = sqlops.window.modelviewdialog.createTab(AlertDialog.ResponseTabText);
+		this.optionsTab = sqlops.window.modelviewdialog.createTab(AlertDialog.OptionsTabText);
+
+		this.initializeGeneralTab(databases);
+		this.initializeResponseTab();
+		this.initializeOptionsTab();
+
+		dialog.content = [this.generalTab, this.responseTab, this.optionsTab];
+	}
+
+	private initializeGeneralTab(databases: string[]) {
+		this.generalTab.registerContent(async view => {
+			this.nameTextBox = view.modelBuilder.inputBox().component();
+
+			this.enabledCheckBox = view.modelBuilder.checkBox()
+				.withProperties({
+					label: AlertDialog.EnabledCheckboxLabel
+				}).component();
+
+			this.databaseDropDown = view.modelBuilder.dropDown()
+				.withProperties({
+					value: databases[0],
+					values: databases
+				}).component();
+
+			this.typeDropDown = view.modelBuilder.dropDown()
+				.withProperties({
+					value: AlertDialog.AlertTypes[0],
+					values: AlertDialog.AlertTypes
+				}).component();
+
+			this.severityDropDown = view.modelBuilder.dropDown()
+				.withProperties({
+					value: AlertDialog.AlertSeverities[0],
+					values: AlertDialog.AlertSeverities
+				}).component();
+
+			this.raiseAlertMessageCheckBox = view.modelBuilder.checkBox()
+				.withProperties({
+					label: AlertDialog.RaiseIfMessageContainsLabel
+				}).component();
+
+			this.raiseAlertMessageTextBox = view.modelBuilder.inputBox().component();
+
+			let formModel = view.modelBuilder.formContainer()
+				.withFormItems([{
+					component: this.nameTextBox,
+					title: AlertDialog.NameLabel
+				}, {
+					component: this.enabledCheckBox,
+					title: ''
+				}, {
+					component: this.typeDropDown,
+					title: AlertDialog.TypeLabel
+				}, {
+					component: this.databaseDropDown,
+					title: AlertDialog.DatabaseLabel
+				}, {
+					component: this.severityDropDown,
+					title: AlertDialog.SeverityLabel
+				}, {
+					component: this.raiseAlertMessageCheckBox,
+					title: ''
+				}, {
+					component: this.raiseAlertMessageTextBox,
+					title: AlertDialog.MessageTextLabel
+				}
+			]).withLayout({ width: '100%' }).component();
+
+			await view.initializeModel(formModel);
+
+			this.nameTextBox.value = this.model.name;
+			this.enabledCheckBox.checked = this.model.isEnabled;
+		});
+	}
+
+	private initializeResponseTab() {
+		this.responseTab.registerContent(async view => {
+			this.executeJobCheckBox = view.modelBuilder.checkBox()
+				.withProperties({
+					label: AlertDialog.ExecuteJobCheckBoxLabel
+				}).component();
+
+			this.executeJobTextBox = view.modelBuilder.inputBox().component();
+
+			this.newJobButton = view.modelBuilder.button().withProperties({
+					label: AlertDialog.NewJobButtonLabel,
+					width: 80
+				}).component();
+
+			this.notifyOperatorsCheckBox = view.modelBuilder.checkBox()
+				.withProperties({
+					label: AlertDialog.NotifyOperatorsTextBoxLabel
+				}).component();
+
+			this.operatorsTable = view.modelBuilder.table()
+				.withProperties({
+					columns: [
+						AlertDialog.OperatorNameColumnLabel,
+						AlertDialog.OperatorEmailColumnLabel,
+						AlertDialog.OperatorPagerColumnLabel
+					],
+					data: [],
+					height: 500
+				}).component();
+
+			this.newOperatorButton = view.modelBuilder.button().withProperties({
+					label: this.newOperatorButton,
+					width: 80
+				}).component();
+
+			let formModel = view.modelBuilder.formContainer()
+				.withFormItems([{
+					component: this.executeJobCheckBox,
+					title: ''
+				}, {
+					component: this.executeJobTextBox,
+					title: AlertDialog.ExecuteJobTextBoxLabel
+				}, {
+					component: this.newJobButton,
+					title: AlertDialog.NewJobButtonLabel
+				}, {
+					component: this.notifyOperatorsCheckBox,
+					title: ''
+				}, {
+					component: this.operatorsTable,
+					title: AlertDialog.OperatorListLabel,
+					actions: [this.newOperatorButton]
+				}]).withLayout({ width: '100%' }).component();
+
+			await view.initializeModel(formModel);
+		});
+	}
+
+	private initializeOptionsTab() {
+		this.optionsTab.registerContent(async view => {
+
+			this.includeErrorInEmailTextBox = view.modelBuilder.checkBox()
+				.withProperties({
+					label: AlertDialog.IncludeErrorInEmailCheckBoxLabel
+				}).component();
+
+			this.includeErrorInPagerTextBox = view.modelBuilder.checkBox()
+				.withProperties({
+					label: AlertDialog.IncludeErrorInPagerCheckBoxLabel
+				}).component();
+
+			this.additionalMessageTextBox = view.modelBuilder.inputBox().component();
+
+			this.delayMinutesTextBox = view.modelBuilder.inputBox().component();
+
+			this.delaySecondsTextBox = view.modelBuilder.inputBox().component();
+
+			let formModel = view.modelBuilder.formContainer()
+				.withFormItems([{
+					component: this.includeErrorInEmailTextBox,
+					title: ''
+				}, {
+					component: this.includeErrorInPagerTextBox,
+					title: ''
+				}, {
+					component: this.additionalMessageTextBox,
+					title: AlertDialog.AdditionalMessageTextBoxLabel
+				}, {
+					component: this.delayMinutesTextBox,
+					title: AlertDialog.DelayMinutesTextBoxLabel
+				}, {
+					component: this.delaySecondsTextBox,
+					title: AlertDialog.DelaySecondsTextBoxLabel
+				}]).withLayout({ width: '100%' }).component();
+
+			await view.initializeModel(formModel);
+		});
+	}
+
+	private getSeverityNumber(): number {
+		let selected = this.getDropdownValue(this.severityDropDown);
+		let severityNumber: number = 0;
+		if (selected) {
+			let index = AlertDialog.AlertSeverities.indexOf(selected);
+			if (index >= 0) {
+				severityNumber = index + 1;
+			}
+		}
+		return severityNumber;
+	}
+
+	protected updateModel() {
+		this.model.name = this.nameTextBox.value;
+		this.model.isEnabled = this.enabledCheckBox.checked;
+
+		this.model.alertType = this.getDropdownValue(this.typeDropDown);
+		this.model.databaseName = this.getDropdownValue(this.databaseDropDown);
+		this.model.severity = this.getSeverityNumber();
+		this.model.messageId = undefined;
+
+		let raiseIfError = this.raiseAlertMessageCheckBox.checked;
+		if (raiseIfError) {
+			let messageText = this.raiseAlertMessageTextBox.value;
+		}
+	}
+}

extensions/agent/src/dialogs/jobDialog.ts

@@ -0,0 +1,425 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { JobData } from '../data/jobData';
+import { JobStepDialog } from './jobStepDialog';
+import { PickScheduleDialog } from './pickScheduleDialog';
+import { AlertDialog } from './alertDialog';
+import { AgentDialog } from './agentDialog';
+
+export class JobDialog extends AgentDialog<JobData>  {
+
+	// TODO: localize
+	// Top level
+	private static readonly DialogTitle: string = 'New Job';
+	private readonly GeneralTabText: string = 'General';
+	private readonly StepsTabText: string = 'Steps';
+	private readonly SchedulesTabText: string = 'Schedules';
+	private readonly AlertsTabText: string = 'Alerts';
+	private readonly NotificationsTabText: string = 'Notifications';
+
+	// General tab strings
+	private readonly NameTextBoxLabel: string = 'Name';
+	private readonly OwnerTextBoxLabel: string = 'Owner';
+	private readonly CategoryDropdownLabel: string = 'Category';
+	private readonly DescriptionTextBoxLabel: string = 'Description';
+	private readonly EnabledCheckboxLabel: string = 'Enabled';
+
+	// Steps tab strings
+	private readonly JobStepsTopLabelString: string = 'Job step list';
+	private readonly StepsTable_StepColumnString: string = 'Step';
+	private readonly StepsTable_NameColumnString: string = 'Name';
+	private readonly StepsTable_TypeColumnString: string = 'Type';
+	private readonly StepsTable_SuccessColumnString: string = 'On Success';
+	private readonly StepsTable_FailureColumnString: string = 'On Failure';
+	private readonly NewStepButtonString: string = 'New...';
+	private readonly InsertStepButtonString: string = 'Insert...';
+	private readonly EditStepButtonString: string = 'Edit';
+	private readonly DeleteStepButtonString: string = 'Delete';
+
+	// Notifications tab strings
+	private readonly NotificationsTabTopLabelString: string = 'Actions to perform when the job completes';
+	private readonly EmailCheckBoxString: string = 'Email';
+	private readonly PagerCheckBoxString: string = 'Page';
+	private readonly EventLogCheckBoxString: string = 'Write to the Windows Application event log';
+	private readonly DeleteJobCheckBoxString: string = 'Automatically delete job';
+
+	// Schedules tab strings
+	private readonly SchedulesTopLabelString: string = 'Schedules list';
+	private readonly PickScheduleButtonString: string = 'Pick Schedule';
+
+	// Alerts tab strings
+	private readonly AlertsTopLabelString: string = 'Alerts list';
+	private readonly NewAlertButtonString: string = 'New Alert';
+
+	// UI Components
+	private generalTab: sqlops.window.modelviewdialog.DialogTab;
+	private stepsTab: sqlops.window.modelviewdialog.DialogTab;
+	private alertsTab: sqlops.window.modelviewdialog.DialogTab;
+	private schedulesTab: sqlops.window.modelviewdialog.DialogTab;
+	private notificationsTab: sqlops.window.modelviewdialog.DialogTab;
+
+	// General tab controls
+	private nameTextBox: sqlops.InputBoxComponent;
+	private ownerTextBox: sqlops.InputBoxComponent;
+	private categoryDropdown: sqlops.DropDownComponent;
+	private descriptionTextBox: sqlops.InputBoxComponent;
+	private enabledCheckBox: sqlops.CheckBoxComponent;
+
+	// Steps tab controls
+	private stepsTable: sqlops.TableComponent;
+	private newStepButton: sqlops.ButtonComponent;
+	private insertStepButton: sqlops.ButtonComponent;
+	private editStepButton: sqlops.ButtonComponent;
+	private deleteStepButton: sqlops.ButtonComponent;
+
+	// Notifications tab controls
+	private notificationsTabTopLabel: sqlops.TextComponent;
+	private emailCheckBox: sqlops.CheckBoxComponent;
+	private emailOperatorDropdown: sqlops.DropDownComponent;
+	private emailConditionDropdown: sqlops.DropDownComponent;
+	private pagerCheckBox: sqlops.CheckBoxComponent;
+	private pagerOperatorDropdown: sqlops.DropDownComponent;
+	private pagerConditionDropdown: sqlops.DropDownComponent;
+	private eventLogCheckBox: sqlops.CheckBoxComponent;
+	private eventLogConditionDropdown: sqlops.DropDownComponent;
+	private deleteJobCheckBox: sqlops.CheckBoxComponent;
+	private deleteJobConditionDropdown: sqlops.DropDownComponent;
+
+	// Schedule tab controls
+	private schedulesTable: sqlops.TableComponent;
+	private pickScheduleButton: sqlops.ButtonComponent;
+
+	// Alert tab controls
+	private alertsTable: sqlops.TableComponent;
+	private newAlertButton: sqlops.ButtonComponent;
+
+	constructor(ownerUri: string) {
+		super(ownerUri, new JobData(ownerUri), JobDialog.DialogTitle);
+	}
+
+	protected async initializeDialog() {
+		this.generalTab = sqlops.window.modelviewdialog.createTab(this.GeneralTabText);
+		this.stepsTab = sqlops.window.modelviewdialog.createTab(this.StepsTabText);
+		this.alertsTab = sqlops.window.modelviewdialog.createTab(this.AlertsTabText);
+		this.schedulesTab = sqlops.window.modelviewdialog.createTab(this.SchedulesTabText);
+		this.notificationsTab = sqlops.window.modelviewdialog.createTab(this.NotificationsTabText);
+		this.initializeGeneralTab();
+		this.initializeStepsTab();
+		this.initializeAlertsTab();
+		this.initializeSchedulesTab();
+		this.initializeNotificationsTab();
+		this.dialog.content = [this.generalTab, this.stepsTab, this.schedulesTab, this.alertsTab, this.notificationsTab];
+
+		this.dialog.registerCloseValidator(() => {
+			this.updateModel();
+			let validationResult = this.model.validate();
+			if (!validationResult.valid) {
+				// TODO: Show Error Messages
+				console.error(validationResult.errorMessages.join(','));
+			}
+
+			return validationResult.valid;
+		});
+	}
+
+	private initializeGeneralTab() {
+		this.generalTab.registerContent(async view => {
+			this.nameTextBox = view.modelBuilder.inputBox().component();
+			this.ownerTextBox = view.modelBuilder.inputBox().component();
+			this.categoryDropdown = view.modelBuilder.dropDown().component();
+			this.descriptionTextBox = view.modelBuilder.inputBox().withProperties({
+				multiline: true,
+				height: 200
+			}).component();
+			this.enabledCheckBox = view.modelBuilder.checkBox()
+				.withProperties({
+					label: this.EnabledCheckboxLabel
+				}).component();
+			let formModel = view.modelBuilder.formContainer()
+				.withFormItems([{
+					component: this.nameTextBox,
+					title: this.NameTextBoxLabel
+				}, {
+					component: this.ownerTextBox,
+					title: this.OwnerTextBoxLabel
+				}, {
+					component: this.categoryDropdown,
+					title: this.CategoryDropdownLabel
+				}, {
+					component: this.descriptionTextBox,
+					title: this.DescriptionTextBoxLabel
+				}, {
+					component: this.enabledCheckBox,
+					title: ''
+				}]).withLayout({ width: '100%' }).component();
+
+			await view.initializeModel(formModel);
+
+			this.ownerTextBox.value = this.model.defaultOwner;
+			this.categoryDropdown.values = this.model.jobCategories;
+			this.categoryDropdown.value = this.model.jobCategories[0];
+			this.enabledCheckBox.checked = this.model.enabled;
+			this.descriptionTextBox.value = '';
+		});
+	}
+
+	private initializeStepsTab() {
+		this.stepsTab.registerContent(async view => {
+			this.stepsTable = view.modelBuilder.table()
+				.withProperties({
+					columns: [
+						this.StepsTable_StepColumnString,
+						this.StepsTable_NameColumnString,
+						this.StepsTable_TypeColumnString,
+						this.StepsTable_SuccessColumnString,
+						this.StepsTable_FailureColumnString
+					],
+					data: [],
+					height: 800
+				}).component();
+
+			this.newStepButton = view.modelBuilder.button().withProperties({
+				label: this.NewStepButtonString,
+				width: 80
+			}).component();
+
+			this.newStepButton.onDidClick((e)=>{
+				let stepDialog = new JobStepDialog(this.model.ownerUri, '', '', 1, this.model);
+				stepDialog.openNewStepDialog();
+			});
+
+			this.insertStepButton = view.modelBuilder.button().withProperties({
+				label: this.InsertStepButtonString,
+				width: 80
+			}).component();
+
+			this.editStepButton = view.modelBuilder.button().withProperties({
+				label: this.EditStepButtonString,
+				width: 80
+			}).component();
+
+			this.deleteStepButton = view.modelBuilder.button().withProperties({
+				label: this.DeleteStepButtonString,
+				width: 80
+			}).component();
+
+			let formModel = view.modelBuilder.formContainer()
+				.withFormItems([{
+					component: this.stepsTable,
+					title: this.JobStepsTopLabelString,
+					actions: [this.newStepButton, this.insertStepButton, this.editStepButton, this.deleteStepButton]
+				}]).withLayout({ width: '100%' }).component();
+			await view.initializeModel(formModel);
+		});
+	}
+
+	private initializeAlertsTab() {
+		this.alertsTab.registerContent(async view => {
+			this.alertsTable = view.modelBuilder.table()
+				.withProperties({
+					columns: [
+						'Alert Name'
+					],
+					data: [],
+					height: 600,
+					width: 400
+				}).component();
+
+			this.newAlertButton = view.modelBuilder.button().withProperties({
+				label: this.NewAlertButtonString,
+				width: 80
+			}).component();
+
+			this.newAlertButton.onDidClick((e)=>{
+				let alertDialog = new AlertDialog(this.model.ownerUri);
+				alertDialog.onSuccess((dialogModel) => {
+				});
+				alertDialog.openDialog();
+			});
+
+			let formModel = view.modelBuilder.formContainer()
+				.withFormItems([{
+					component: this.alertsTable,
+					title: this.AlertsTopLabelString,
+					actions: [this.newAlertButton]
+				}]).withLayout({ width: '100%' }).component();
+
+			await view.initializeModel(formModel);
+		});
+	}
+
+	private initializeSchedulesTab() {
+		this.schedulesTab.registerContent(async view => {
+			this.schedulesTable = view.modelBuilder.table()
+				.withProperties({
+					columns: [
+						'Schedule Name'
+					],
+					data: [],
+					height: 600,
+					width: 400
+				}).component();
+
+			this.pickScheduleButton = view.modelBuilder.button().withProperties({
+				label: this.PickScheduleButtonString,
+				width: 80
+			}).component();
+
+			this.pickScheduleButton.onDidClick((e)=>{
+				let pickScheduleDialog = new PickScheduleDialog(this.model.ownerUri);
+				pickScheduleDialog.onSuccess((dialogModel) => {
+					let selectedSchedule = dialogModel.selectedSchedule;
+					if (selectedSchedule) {
+						this.model.addJobSchedule(selectedSchedule);
+						this.populateScheduleTable();
+					}
+				});
+				pickScheduleDialog.showDialog();
+			});
+
+			let formModel = view.modelBuilder.formContainer()
+				.withFormItems([{
+					component: this.schedulesTable,
+					title: this.SchedulesTopLabelString,
+					actions: [this.pickScheduleButton]
+				}]).withLayout({ width: '100%' }).component();
+
+			await view.initializeModel(formModel);
+
+			this.populateScheduleTable();
+		});
+	}
+
+	private populateScheduleTable() {
+		if (this.model.jobSchedules) {
+			let data: any[][] = [];
+			for (let i = 0; i < this.model.jobSchedules.length; ++i) {
+				let schedule = this.model.jobSchedules[i];
+				data[i] = [ schedule.name ];
+			}
+			this.schedulesTable.data = data;
+		}
+	}
+
+	private initializeNotificationsTab() {
+		this.notificationsTab.registerContent(async view => {
+
+			this.notificationsTabTopLabel = view.modelBuilder.text().withProperties({ value: this.NotificationsTabTopLabelString }).component();
+			this.emailCheckBox = view.modelBuilder.checkBox().withProperties({
+				label: this.EmailCheckBoxString,
+				width: 80
+			}).component();
+
+			this.pagerCheckBox = view.modelBuilder.checkBox().withProperties({
+				label: this.PagerCheckBoxString,
+				width: 80
+			}).component();
+			this.eventLogCheckBox = view.modelBuilder.checkBox().withProperties({
+				label: this.EventLogCheckBoxString,
+				width: 250
+			}).component();
+			this.deleteJobCheckBox = view.modelBuilder.checkBox().withProperties({
+				label: this.DeleteJobCheckBoxString,
+				width: 250
+			}).component();
+
+			this.emailCheckBox.onChanged(() => {
+				this.emailConditionDropdown.enabled = this.emailCheckBox.checked;
+				this.emailOperatorDropdown.enabled = this.emailCheckBox.checked;
+			});
+
+			this.pagerCheckBox.onChanged(() => {
+				this.pagerConditionDropdown.enabled = this.pagerCheckBox.checked;
+				this.pagerOperatorDropdown.enabled = this.pagerCheckBox.checked;
+			});
+			this.eventLogCheckBox.onChanged(() => {
+				this.eventLogConditionDropdown.enabled = this.eventLogCheckBox.checked;
+			});
+
+			this.deleteJobCheckBox.onChanged(() => {
+				this.deleteJobConditionDropdown.enabled = this.deleteJobCheckBox.checked;
+			});
+
+			this.emailOperatorDropdown = view.modelBuilder.dropDown().withProperties({ width: 150 }).component();
+			this.pagerOperatorDropdown = view.modelBuilder.dropDown().withProperties({ width: 150 }).component();
+			this.emailConditionDropdown = view.modelBuilder.dropDown().withProperties({ width: 150 }).component();
+			this.pagerConditionDropdown = view.modelBuilder.dropDown().withProperties({ width: 150 }).component();
+			this.eventLogConditionDropdown = view.modelBuilder.dropDown().withProperties({ width: 150 }).component();
+			this.deleteJobConditionDropdown = view.modelBuilder.dropDown().withProperties({ width: 150 }).component();
+
+			let emailContainer = this.createRowContainer(view).withItems([this.emailCheckBox, this.emailOperatorDropdown, this.emailConditionDropdown]).component();
+
+			let pagerContainer = this.createRowContainer(view).withItems([this.pagerCheckBox, this.pagerOperatorDropdown, this.pagerConditionDropdown]).component();
+
+			let eventLogContainer = this.createRowContainer(view).withItems([this.eventLogCheckBox, this.eventLogConditionDropdown]).component();
+
+			let deleteJobContainer = this.createRowContainer(view).withItems([this.deleteJobCheckBox, this.deleteJobConditionDropdown]).component();
+
+			let formModel = view.modelBuilder.formContainer().withFormItems([
+				{
+					component: this.notificationsTabTopLabel,
+					title: ''
+				}, {
+					component: emailContainer,
+					title: ''
+				}, {
+					component: pagerContainer,
+					title: ''
+				}, {
+					component: eventLogContainer,
+					title: ''
+				}, {
+					component: deleteJobContainer,
+					title: ''
+				}]).withLayout({ width: '100%' }).component();
+
+			await view.initializeModel(formModel);
+			this.emailConditionDropdown.values = this.model.JobCompletionActionConditions;
+			this.pagerConditionDropdown.values = this.model.JobCompletionActionConditions;
+			this.eventLogConditionDropdown.values = this.model.JobCompletionActionConditions;
+			this.deleteJobConditionDropdown.values = this.model.JobCompletionActionConditions;
+			this.setConditionDropdownSelectedValue(this.emailConditionDropdown, this.model.emailLevel);
+			this.setConditionDropdownSelectedValue(this.pagerConditionDropdown, this.model.pageLevel);
+			this.setConditionDropdownSelectedValue(this.eventLogConditionDropdown, this.model.eventLogLevel);
+			this.setConditionDropdownSelectedValue(this.deleteJobConditionDropdown, this.model.deleteLevel);
+			this.emailOperatorDropdown.values = this.model.operators;
+			this.pagerOperatorDropdown.values = this.model.operators;
+			this.emailCheckBox.checked = false;
+			this.pagerCheckBox.checked = false;
+			this.eventLogCheckBox.checked = false;
+			this.deleteJobCheckBox.checked = false;
+			this.emailOperatorDropdown.enabled = false;
+			this.pagerOperatorDropdown.enabled = false;
+			this.emailConditionDropdown.enabled = false;
+			this.pagerConditionDropdown.enabled = false;
+			this.eventLogConditionDropdown.enabled = false;
+			this.deleteJobConditionDropdown.enabled = false;
+		});
+	}
+
+	private createRowContainer(view: sqlops.ModelView): sqlops.FlexBuilder {
+		return view.modelBuilder.flexContainer().withLayout({
+			flexFlow: 'row',
+			alignItems: 'left',
+			justifyContent: 'space-between'
+		});
+	}
+
+	protected updateModel() {
+		this.model.name = this.nameTextBox.value;
+		this.model.owner = this.ownerTextBox.value;
+		this.model.enabled = this.enabledCheckBox.checked;
+		this.model.description = this.descriptionTextBox.value;
+		this.model.category = this.getDropdownValue(this.categoryDropdown);
+		this.model.emailLevel = this.getActualConditionValue(this.emailCheckBox, this.emailConditionDropdown);
+		this.model.operatorToEmail = this.getDropdownValue(this.emailOperatorDropdown);
+		this.model.operatorToPage = this.getDropdownValue(this.pagerOperatorDropdown);
+		this.model.pageLevel = this.getActualConditionValue(this.pagerCheckBox, this.pagerConditionDropdown);
+		this.model.eventLogLevel = this.getActualConditionValue(this.eventLogCheckBox, this.eventLogConditionDropdown);
+		this.model.deleteLevel = this.getActualConditionValue(this.deleteJobCheckBox, this.deleteJobConditionDropdown);
+	}
+}

extensions/agent/src/dialogs/jobStepDialog.ts

@@ -0,0 +1,490 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 vscode from 'vscode';
+import { JobStepData } from '../data/jobStepData';
+import { AgentUtils } from '../agentUtils';
+import { JobData } from '../data/jobData';
+const path = require('path');
+
+export class JobStepDialog {
+
+	// TODO: localize
+	// Top level
+	//
+	private static readonly DialogTitle: string = 'New Job Step';
+	private static readonly FileBrowserDialogTitle: string = 'Locate Database Files - ';
+	private static readonly OkButtonText: string = 'OK';
+	private static readonly CancelButtonText: string = 'Cancel';
+	private static readonly GeneralTabText: string = 'General';
+	private static readonly AdvancedTabText: string = 'Advanced';
+	private static readonly OpenCommandText: string = 'Open...';
+	private static readonly ParseCommandText: string = 'Parse';
+	private static readonly NextButtonText: string = 'Next';
+	private static readonly PreviousButtonText: string = 'Previous';
+	private static readonly SuccessAction: string = 'On success action';
+	private static readonly FailureAction: string = 'On failure action';
+
+
+	// Dropdown options
+	private static readonly TSQLScript: string = 'Transact-SQL script (T-SQL)';
+	private static readonly AgentServiceAccount: string = 'SQL Server Agent Service Account';
+	private static readonly NextStep: string = 'Go to the next step';
+	private static readonly QuitJobReportingSuccess: string = 'Quit the job reporting success';
+	private static readonly QuitJobReportingFailure: string = 'Quit the job reporting failure';
+
+	// UI Components
+
+	// Dialogs
+	private dialog: sqlops.window.modelviewdialog.Dialog;
+	private fileBrowserDialog: sqlops.window.modelviewdialog.Dialog;
+
+	// Dialog tabs
+	private generalTab: sqlops.window.modelviewdialog.DialogTab;
+	private advancedTab: sqlops.window.modelviewdialog.DialogTab;
+
+	//Input boxes
+	private nameTextBox: sqlops.InputBoxComponent;
+	private commandTextBox: sqlops.InputBoxComponent;
+	private selectedPathTextBox: sqlops.InputBoxComponent;
+	private retryAttemptsBox: sqlops.InputBoxComponent;
+	private retryIntervalBox: sqlops.InputBoxComponent;
+	private outputFileNameBox: sqlops.InputBoxComponent;
+	private fileBrowserNameBox: sqlops.InputBoxComponent;
+
+	// Dropdowns
+	private typeDropdown: sqlops.DropDownComponent;
+	private runAsDropdown: sqlops.DropDownComponent;
+	private databaseDropdown: sqlops.DropDownComponent;
+	private successActionDropdown: sqlops.DropDownComponent;
+	private failureActionDropdown: sqlops.DropDownComponent;
+	private fileTypeDropdown: sqlops.DropDownComponent;
+
+	// Buttons
+	private openButton: sqlops.ButtonComponent;
+	private parseButton: sqlops.ButtonComponent;
+	private nextButton: sqlops.ButtonComponent;
+	private previousButton: sqlops.ButtonComponent;
+	private outputFileBrowserButton: sqlops.ButtonComponent;
+
+	// Checkbox
+	private appendToExistingFileCheckbox: sqlops.CheckBoxComponent;
+	private logToTableCheckbox: sqlops.CheckBoxComponent;
+
+	private fileBrowserTree: sqlops.FileBrowserTreeComponent;
+	private jobModel: JobData;
+	private model: JobStepData;
+	private ownerUri: string;
+	private jobName: string;
+	private server: string;
+	private stepId: number;
+
+	constructor(
+		ownerUri: string,
+		jobName: string,
+		server: string,
+		stepId: number,
+		jobModel?: JobData
+	) {
+		this.model = new JobStepData(ownerUri);
+		this.stepId = stepId;
+		this.ownerUri = ownerUri;
+		this.jobName = jobName;
+		this.server = server;
+		this.jobModel = jobModel;
+	}
+
+	private initializeUIComponents() {
+		this.dialog = sqlops.window.modelviewdialog.createDialog(JobStepDialog.DialogTitle);
+		this.generalTab = sqlops.window.modelviewdialog.createTab(JobStepDialog.GeneralTabText);
+		this.advancedTab = sqlops.window.modelviewdialog.createTab(JobStepDialog.AdvancedTabText);
+		this.dialog.content = [this.generalTab, this.advancedTab];
+		this.dialog.okButton.onClick(async () => await this.execute());
+		this.dialog.okButton.label = JobStepDialog.OkButtonText;
+		this.dialog.cancelButton.label = JobStepDialog.CancelButtonText;
+	}
+
+	private createCommands(view, queryProvider: sqlops.QueryProvider) {
+		this.openButton = view.modelBuilder.button()
+			.withProperties({
+				label: JobStepDialog.OpenCommandText,
+				width: '80px'
+			}).component();
+		this.parseButton = view.modelBuilder.button()
+			.withProperties({
+				label: JobStepDialog.ParseCommandText,
+				width: '80px'
+			}).component();
+		this.parseButton.onDidClick(e => {
+			if (this.commandTextBox.value) {
+				queryProvider.parseSyntax(this.ownerUri, this.commandTextBox.value).then(result => {
+					if (result && result.parseable) {
+						this.dialog.message = { text: 'The command was successfully parsed.', level: 2};
+					} else if (result && !result.parseable) {
+						this.dialog.message = { text: 'The command failed' };
+					}
+				});
+			}
+		});
+		this.commandTextBox = view.modelBuilder.inputBox()
+			.withProperties({
+				height: 300,
+				width: 400,
+				multiline: true,
+				inputType: 'text'
+			})
+			.component();
+		this.nextButton = view.modelBuilder.button()
+			.withProperties({
+				label: JobStepDialog.NextButtonText,
+				enabled: false,
+				width: '80px'
+			}).component();
+		this.previousButton = view.modelBuilder.button()
+			.withProperties({
+				label: JobStepDialog.PreviousButtonText,
+				enabled: false,
+				width: '80px'
+			}).component();
+	}
+
+	private createGeneralTab(databases: string[], queryProvider: sqlops.QueryProvider) {
+		this.generalTab.registerContent(async (view) => {
+			this.nameTextBox = view.modelBuilder.inputBox()
+				.withProperties({
+				}).component();
+			this.nameTextBox.required = true;
+			this.typeDropdown = view.modelBuilder.dropDown()
+				.withProperties({
+					value: JobStepDialog.TSQLScript,
+					values: [JobStepDialog.TSQLScript]
+				})
+				.component();
+			this.runAsDropdown = view.modelBuilder.dropDown()
+				.withProperties({
+					value: '',
+					values: ['']
+				})
+				.component();
+			this.runAsDropdown.enabled = false;
+			this.typeDropdown.onValueChanged((type) => {
+				if (type.selected !== JobStepDialog.TSQLScript) {
+					this.runAsDropdown.value = JobStepDialog.AgentServiceAccount;
+					this.runAsDropdown.values = [this.runAsDropdown.value];
+				} else {
+					this.runAsDropdown.value = '';
+					this.runAsDropdown.values = [''];
+				}
+			});
+			this.databaseDropdown = view.modelBuilder.dropDown()
+				.withProperties({
+					value: databases[0],
+					values: databases
+				}).component();
+
+			// create the commands section
+			this.createCommands(view, queryProvider);
+
+			let buttonContainer = view.modelBuilder.flexContainer()
+			.withLayout({
+				flexFlow: 'row',
+				justifyContent: 'space-between',
+				width: 420
+			}).withItems([this.openButton, this.parseButton, this.previousButton, this.nextButton], {
+				flex: '1 1 50%'
+			}).component();
+
+			let formModel = view.modelBuilder.formContainer()
+				.withFormItems([{
+					component: this.nameTextBox,
+					title: 'Step name'
+				}, {
+					component: this.typeDropdown,
+					title: 'Type'
+				}, {
+					component: this.runAsDropdown,
+					title: 'Run as'
+				}, {
+					component: this.databaseDropdown,
+					title: 'Database'
+				}, {
+					component: this.commandTextBox,
+					title: 'Command',
+					actions: [buttonContainer]
+				}], {
+						horizontal: false,
+						componentWidth: 420
+					}).component();
+			let formWrapper = view.modelBuilder.loadingComponent().withItem(formModel).component();
+			formWrapper.loading = false;
+			await view.initializeModel(formWrapper);
+		});
+	}
+
+	private createRunAsUserOptions(view) {
+		let userInputBox = view.modelBuilder.inputBox()
+			.withProperties({ inputType: 'text', width: '100px' }).component();
+		let viewButton = view.modelBuilder.button()
+			.withProperties({ label: '...', width: '20px' }).component();
+		let viewButtonContainer = view.modelBuilder.flexContainer()
+			.withLayout({ width: 100, textAlign: 'right' })
+			.withItems([viewButton], { flex: '1 1 50%' }).component();
+		let userInputBoxContainer = view.modelBuilder.flexContainer()
+			.withLayout({ width: 200, textAlign: 'left' })
+			.withItems([userInputBox], { flex: '1 1 50%' }).component();
+		let runAsUserContainer = view.modelBuilder.flexContainer()
+			.withLayout({ width: 200 })
+			.withItems([userInputBoxContainer, viewButtonContainer], { flex: '1 1 50%' })
+			.component();
+		let runAsUserForm = view.modelBuilder.formContainer()
+			.withFormItems([{
+				component: runAsUserContainer,
+				title: 'Run as user'
+			}], { horizontal: true, componentWidth: 200 }).component();
+		return runAsUserForm;
+	}
+
+	private createAdvancedTab() {
+		this.advancedTab.registerContent(async (view) => {
+			this.successActionDropdown = view.modelBuilder.dropDown()
+				.withProperties({
+					value: JobStepDialog.NextStep,
+					values: [JobStepDialog.NextStep, JobStepDialog.QuitJobReportingSuccess, JobStepDialog.QuitJobReportingFailure]
+				})
+				.component();
+			let retryFlexContainer = this.createRetryCounters(view);
+			this.failureActionDropdown = view.modelBuilder.dropDown()
+				.withProperties({
+					value: JobStepDialog.QuitJobReportingFailure,
+					values: [JobStepDialog.QuitJobReportingFailure, JobStepDialog.NextStep, JobStepDialog.QuitJobReportingSuccess]
+				})
+				.component();
+			let optionsGroup = this.createTSQLOptions(view);
+			let viewButton = view.modelBuilder.button()
+				.withProperties({ label: 'View', width: '50px' }).component();
+			viewButton.enabled = false;
+			this.logToTableCheckbox = view.modelBuilder.checkBox()
+				.withProperties({
+					label: 'Log to table'
+				}).component();
+			let appendToExistingEntryInTableCheckbox = view.modelBuilder.checkBox()
+				.withProperties({ label: 'Append output to existing entry in table' }).component();
+			appendToExistingEntryInTableCheckbox.enabled = false;
+			this.logToTableCheckbox.onChanged(e => {
+				viewButton.enabled = e;
+				appendToExistingEntryInTableCheckbox.enabled = e;
+			});
+			let appendCheckboxContainer = view.modelBuilder.groupContainer()
+				.withItems([appendToExistingEntryInTableCheckbox]).component();
+			let logToTableContainer = view.modelBuilder.flexContainer()
+				.withLayout({ flexFlow: 'row', justifyContent: 'space-between', width: 300 })
+				.withItems([this.logToTableCheckbox, viewButton]).component();
+			let logStepOutputHistoryCheckbox = view.modelBuilder.checkBox()
+				.withProperties({ label: 'Include step output in history' }).component();
+			let runAsUserOptions = this.createRunAsUserOptions(view);
+			let formModel = view.modelBuilder.formContainer()
+				.withFormItems(
+					[{
+						component: this.successActionDropdown,
+						title: JobStepDialog.SuccessAction
+					}, {
+						component: retryFlexContainer,
+						title: ''
+					}, {
+						component: this.failureActionDropdown,
+						title: JobStepDialog.FailureAction
+					}, {
+						component: optionsGroup,
+						title: 'Transact-SQL script (T-SQL)'
+					}, {
+						component: logToTableContainer,
+						title: ''
+					}, {
+						component: appendCheckboxContainer,
+						title: '                            '
+					}, {
+						component: logStepOutputHistoryCheckbox,
+						title: ''
+					}, {
+						component: runAsUserOptions,
+						title: ''
+					}], {
+						componentWidth: 400
+					}).component();
+
+			let formWrapper = view.modelBuilder.loadingComponent().withItem(formModel).component();
+			formWrapper.loading = false;
+			view.initializeModel(formWrapper);
+		});
+	}
+
+	private createRetryCounters(view) {
+		this.retryAttemptsBox = view.modelBuilder.inputBox()
+		.withValidation(component => component.value >= 0)
+		.withProperties({
+			inputType: 'number'
+		})
+		.component();
+		this.retryIntervalBox = view.modelBuilder.inputBox()
+			.withValidation(component => component.value >= 0)
+			.withProperties({
+				inputType: 'number'
+			}).component();
+
+		let retryAttemptsContainer = view.modelBuilder.formContainer()
+			.withFormItems(
+				[{
+					component: this.retryAttemptsBox,
+					title: 'Retry Attempts'
+				}], {
+					horizontal: false
+				})
+			.component();
+
+		let retryIntervalContainer = view.modelBuilder.formContainer()
+			.withFormItems(
+				[{
+					component: this.retryIntervalBox,
+					title: 'Retry Interval (minutes)'
+					}], {
+					horizontal: false
+				})
+			.component();
+
+		let retryFlexContainer = view.modelBuilder.flexContainer()
+			.withLayout({
+				flexFlow: 'row',
+			}).withItems([retryAttemptsContainer, retryIntervalContainer]).component();
+		return retryFlexContainer;
+	}
+
+	private openFileBrowserDialog() {
+		let fileBrowserTitle = JobStepDialog.FileBrowserDialogTitle + `${this.server}`;
+		this.fileBrowserDialog = sqlops.window.modelviewdialog.createDialog(fileBrowserTitle);
+		let fileBrowserTab = sqlops.window.modelviewdialog.createTab('File Browser');
+		this.fileBrowserDialog.content =  [fileBrowserTab];
+		fileBrowserTab.registerContent(async (view) => {
+			this.fileBrowserTree = view.modelBuilder.fileBrowserTree()
+				.withProperties({ ownerUri: this.ownerUri, width: 420, height: 700 })
+				.component();
+			this.selectedPathTextBox = view.modelBuilder.inputBox()
+				.withProperties({ inputType: 'text'})
+				.component();
+			this.fileBrowserTree.onDidChange((args) => {
+				this.selectedPathTextBox.value = args.fullPath;
+				this.fileBrowserNameBox.value = args.isFile ? path.win32.basename(args.fullPath) : '';
+			});
+			this.fileTypeDropdown = view.modelBuilder.dropDown()
+				.withProperties({
+					value: 'All Files (*)',
+					values: ['All Files (*)']
+				})
+				.component();
+			this.fileBrowserNameBox = view.modelBuilder.inputBox()
+				.withProperties({})
+				.component();
+			let fileBrowserContainer = view.modelBuilder.formContainer()
+				.withFormItems([{
+					component: this.fileBrowserTree,
+					title: ''
+				}, {
+					component: this.selectedPathTextBox,
+					title: 'Selected path:'
+				}, {
+					component: this.fileTypeDropdown,
+					title: 'Files of type:'
+				}, {
+					component: this.fileBrowserNameBox,
+					title: 'File name:'
+				}
+			]).component();
+			view.initializeModel(fileBrowserContainer);
+		});
+		this.fileBrowserDialog.okButton.onClick(() => {
+			this.outputFileNameBox.value = path.join(path.dirname(this.selectedPathTextBox.value), this.fileBrowserNameBox.value);
+		});
+		this.fileBrowserDialog.okButton.label = JobStepDialog.OkButtonText;
+		this.fileBrowserDialog.cancelButton.label = JobStepDialog.CancelButtonText;
+		sqlops.window.modelviewdialog.openDialog(this.fileBrowserDialog);
+	}
+
+	private createTSQLOptions(view) {
+		this.outputFileBrowserButton = view.modelBuilder.button()
+			.withProperties({ width: '20px', label: '...' }).component();
+		this.outputFileBrowserButton.onDidClick(() => this.openFileBrowserDialog());
+		this.outputFileNameBox = view.modelBuilder.inputBox()
+			.withProperties({
+				width: '150px',
+				inputType: 'text'
+			}).component();
+		let outputViewButton = view.modelBuilder.button()
+			.withProperties({
+				width: '50px',
+				label: 'View'
+			}).component();
+		outputViewButton.enabled = false;
+		let outputButtonContainer = view.modelBuilder.flexContainer()
+			.withLayout({
+				flexFlow: 'row',
+				textAlign: 'right',
+				width: 120
+			}).withItems([this.outputFileBrowserButton, outputViewButton], { flex: '1 1 50%' }).component();
+		let outputFlexBox = view.modelBuilder.flexContainer()
+			.withLayout({
+				flexFlow: 'row',
+				width: 350
+			}).withItems([this.outputFileNameBox, outputButtonContainer], {
+				flex: '1 1 50%'
+			}).component();
+		this.appendToExistingFileCheckbox = view.modelBuilder.checkBox()
+			.withProperties({
+				label: 'Append output to existing file'
+			}).component();
+		this.appendToExistingFileCheckbox.enabled = false;
+		this.outputFileNameBox.onTextChanged((input) => {
+			if (input !== '') {
+				this.appendToExistingFileCheckbox.enabled = true;
+			} else {
+				this.appendToExistingFileCheckbox.enabled = false;
+			}
+		});
+		let outputFileForm = view.modelBuilder.formContainer()
+			.withFormItems([{
+				component: outputFlexBox,
+				title: 'Output file'
+			}, {
+				component: this.appendToExistingFileCheckbox,
+				title: ''
+			}], { horizontal: true, componentWidth: 200 }).component();
+		return outputFileForm;
+	}
+
+	private async execute() {
+		this.model.jobName = this.jobName;
+		this.model.id = this.stepId;
+		this.model.server = this.server;
+		this.model.stepName = this.nameTextBox.value;
+		this.model.subSystem = this.typeDropdown.value as string;
+		this.model.databaseName = this.databaseDropdown.value as string;
+		this.model.script = this.commandTextBox.value;
+		this.model.successAction = this.successActionDropdown.value as string;
+		this.model.retryAttempts = +this.retryAttemptsBox.value;
+		this.model.retryInterval = +this.retryIntervalBox.value;
+		this.model.failureAction = this.failureActionDropdown.value as string;
+		this.model.outputFileName = this.outputFileNameBox.value;
+		this.model.appendToLogFile = this.appendToExistingFileCheckbox.checked;
+		await this.model.save();
+	}
+
+	public async openNewStepDialog() {
+		let databases = await AgentUtils.getDatabases(this.ownerUri);
+		let queryProvider = await AgentUtils.getQueryProvider();
+		this.initializeUIComponents();
+		this.createGeneralTab(databases, queryProvider);
+		this.createAdvancedTab();
+		sqlops.window.modelviewdialog.openDialog(this.dialog);
+	}
+}

extensions/agent/src/dialogs/operatorDialog.ts

@@ -0,0 +1,405 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 vscode from 'vscode';
+import { OperatorData } from '../data/operatorData';
+import * as nls from 'vscode-nls';
+import { AgentDialog } from './agentDialog';
+
+const localize = nls.loadMessageBundle();
+
+export class OperatorDialog extends AgentDialog<OperatorData> {
+
+	// Top level
+	private static readonly DialogTitle: string = localize('createOperator.createOperator', 'Create Operator');
+	private static readonly GeneralTabText: string = localize('createOperator.General', 'General');
+	private static readonly NotificationsTabText: string = localize('createOperator.Notifications', 'Notifications');
+
+	// General tab strings
+	private static readonly NameLabel: string = localize('createOperator.Name', 'Name');
+	private static readonly EnabledCheckboxLabel: string = localize('createOperator.Enabled', 'Enabled');
+	private static readonly EmailNameTextLabel: string = localize('createOperator.EmailName', 'E-mail Name');
+	private static readonly PagerEmailNameTextLabel: string = localize('createOperator.PagerEmailName', 'Pager E-mail Name');
+	private static readonly PagerMondayCheckBoxLabel: string = localize('createOperator.PagerMondayCheckBox', 'Monday');
+	private static readonly PagerTuesdayCheckBoxLabel: string = localize('createOperator.PagerTuesdayCheckBox', 'Tuesday');
+	private static readonly PagerWednesdayCheckBoxLabel: string = localize('createOperator.PagerWednesdayCheckBox', 'Wednesday');
+	private static readonly PagerThursdayCheckBoxLabel: string = localize('createOperator.PagerThursdayCheckBox', 'Thursday');
+	private static readonly PagerFridayCheckBoxLabel: string = localize('createOperator.PagerFridayCheckBox', 'Friday  ');
+	private static readonly PagerSaturdayCheckBoxLabel: string = localize('createOperator.PagerSaturdayCheckBox', 'Saturday');
+	private static readonly PagerSundayCheckBoxLabel: string = localize('createOperator.PagerSundayCheckBox', 'Sunday');
+
+	// Notifications tab strings
+	private static readonly AlertsTableLabel: string = localize('createOperator.AlertListHeading', 'Alert list');
+	private static readonly AlertNameColumnLabel: string = localize('createOperator.AlertNameColumnLabel', 'Alert name');
+	private static readonly AlertEmailColumnLabel: string = localize('createOperator.AlertEmailColumnLabel', 'E-mail');
+	private static readonly AlertPagerColumnLabel: string = localize('createOperator.AlertPagerColumnLabel', 'Pager');
+
+	// UI Components
+	private generalTab: sqlops.window.modelviewdialog.DialogTab;
+	private notificationsTab: sqlops.window.modelviewdialog.DialogTab;
+
+	// General tab controls
+	private nameTextBox: sqlops.InputBoxComponent;
+	private enabledCheckBox: sqlops.CheckBoxComponent;
+	private emailNameTextBox: sqlops.InputBoxComponent;
+	private pagerEmailNameTextBox: sqlops.InputBoxComponent;
+	private pagerMondayCheckBox: sqlops.CheckBoxComponent;
+	private pagerTuesdayCheckBox: sqlops.CheckBoxComponent;
+	private pagerWednesdayCheckBox: sqlops.CheckBoxComponent;
+	private pagerThursdayCheckBox: sqlops.CheckBoxComponent;
+	private pagerFridayCheckBox: sqlops.CheckBoxComponent;
+	private pagerSaturdayCheckBox: sqlops.CheckBoxComponent;
+	private pagerSundayCheckBox: sqlops.CheckBoxComponent;
+	private weekdayPagerStartTimeInput: sqlops.InputBoxComponent;
+	private weekdayPagerEndTimeInput: sqlops.InputBoxComponent;
+	private saturdayPagerStartTimeInput: sqlops.InputBoxComponent;
+	private saturdayPagerEndTimeInput: sqlops.InputBoxComponent;
+	private sundayPagerStartTimeInput: sqlops.InputBoxComponent;
+	private sundayPagerEndTimeInput: sqlops.InputBoxComponent;
+
+	// Notification tab controls
+	private alertsTable: sqlops.TableComponent;
+
+	constructor(ownerUri: string) {
+		super(ownerUri, new OperatorData(ownerUri), OperatorDialog.DialogTitle);
+	}
+
+	protected async initializeDialog(dialog: sqlops.window.modelviewdialog.Dialog) {
+		this.generalTab = sqlops.window.modelviewdialog.createTab(OperatorDialog.GeneralTabText);
+		this.notificationsTab = sqlops.window.modelviewdialog.createTab(OperatorDialog.NotificationsTabText);
+
+		this.initializeGeneralTab();
+		this.initializeNotificationTab();
+
+		this.dialog.content = [this.generalTab, this.notificationsTab];
+	}
+
+	private initializeGeneralTab() {
+		this.generalTab.registerContent(async view => {
+
+			this.nameTextBox = view.modelBuilder.inputBox().component();
+
+			this.enabledCheckBox = view.modelBuilder.checkBox()
+				.withProperties({
+					label: OperatorDialog.EnabledCheckboxLabel
+				}).component();
+			this.enabledCheckBox.checked = true;
+			this.emailNameTextBox = view.modelBuilder.inputBox().component();
+
+			this.pagerEmailNameTextBox = view.modelBuilder.inputBox().component();
+
+			this.enabledCheckBox = view.modelBuilder.checkBox()
+				.withProperties({
+					label: OperatorDialog.EnabledCheckboxLabel
+				}).component();
+
+			this.pagerMondayCheckBox = view.modelBuilder.checkBox()
+				.withProperties({
+					label: OperatorDialog.PagerMondayCheckBoxLabel
+				}).component();
+
+			this.pagerMondayCheckBox.onChanged(() => {
+				if (this.pagerMondayCheckBox.checked) {
+					this.weekdayPagerStartTimeInput.enabled = true;
+					this.weekdayPagerEndTimeInput.enabled = true;
+				} else {
+					if (!this.pagerTuesdayCheckBox.checked && !this.pagerWednesdayCheckBox.checked &&
+						!this.pagerThursdayCheckBox.checked && !this.pagerFridayCheckBox.checked) {
+						this.weekdayPagerStartTimeInput.enabled = false;
+						this.weekdayPagerEndTimeInput.enabled = false;
+					}
+				}
+			});
+
+			this.pagerTuesdayCheckBox = view.modelBuilder.checkBox()
+				.withProperties({
+					label: OperatorDialog.PagerTuesdayCheckBoxLabel
+				}).component();
+
+
+			this.pagerTuesdayCheckBox.onChanged(() => {
+				if (this.pagerTuesdayCheckBox .checked) {
+					this.weekdayPagerStartTimeInput.enabled = true;
+					this.weekdayPagerEndTimeInput.enabled = true;
+				} else {
+					if (!this.pagerMondayCheckBox.checked && !this.pagerWednesdayCheckBox.checked &&
+						!this.pagerThursdayCheckBox.checked && !this.pagerFridayCheckBox.checked) {
+						this.weekdayPagerStartTimeInput.enabled = false;
+						this.weekdayPagerEndTimeInput.enabled = false;
+					}
+				}
+			});
+
+			this.pagerWednesdayCheckBox = view.modelBuilder.checkBox()
+				.withProperties({
+					label: OperatorDialog.PagerWednesdayCheckBoxLabel
+				}).component();
+
+			this.pagerWednesdayCheckBox.onChanged(() => {
+				if (this.pagerWednesdayCheckBox .checked) {
+					this.weekdayPagerStartTimeInput.enabled = true;
+					this.weekdayPagerEndTimeInput.enabled = true;
+				} else {
+					if (!this.pagerMondayCheckBox.checked && !this.pagerTuesdayCheckBox.checked &&
+						!this.pagerThursdayCheckBox.checked && !this.pagerFridayCheckBox.checked) {
+						this.weekdayPagerStartTimeInput.enabled = false;
+						this.weekdayPagerEndTimeInput.enabled = false;
+					}
+				}
+			});
+
+			this.pagerThursdayCheckBox = view.modelBuilder.checkBox()
+				.withProperties({
+					label: OperatorDialog.PagerThursdayCheckBoxLabel
+				}).component();
+
+			this.pagerThursdayCheckBox.onChanged(() => {
+				if (this.pagerThursdayCheckBox .checked) {
+					this.weekdayPagerStartTimeInput.enabled = true;
+					this.weekdayPagerEndTimeInput.enabled = true;
+				} else {
+					if (!this.pagerMondayCheckBox.checked && !this.pagerWednesdayCheckBox.checked &&
+						!this.pagerTuesdayCheckBox.checked && !this.pagerFridayCheckBox.checked) {
+						this.weekdayPagerStartTimeInput.enabled = false;
+						this.weekdayPagerEndTimeInput.enabled = false;
+					}
+				}
+			});
+
+			this.weekdayPagerStartTimeInput = view.modelBuilder.inputBox()
+				.withProperties({
+					inputType: 'time',
+					placeHolder: '08:00:00'
+				}).component();
+			this.weekdayPagerStartTimeInput.enabled = false;
+			let weekdayStartInputContainer = view.modelBuilder.formContainer()
+				.withFormItems([{
+					component: this.weekdayPagerStartTimeInput,
+					title: 'Workday begin'
+				}]).component();
+
+			this.weekdayPagerEndTimeInput = view.modelBuilder.inputBox()
+				.withProperties({
+					inputType: 'time',
+					placeHolder: '06:00:00'
+				}).component();
+			this.weekdayPagerEndTimeInput.enabled = false;
+			let weekdayEndInputContainer = view.modelBuilder.formContainer()
+				.withFormItems([{
+					component: this.weekdayPagerEndTimeInput,
+					title: 'Workday end'
+				}]).component();
+
+			this.pagerFridayCheckBox = view.modelBuilder.checkBox()
+				.withProperties({
+					label: OperatorDialog.PagerFridayCheckBoxLabel,
+					width: 80
+				}).component();
+			this.pagerFridayCheckBox.onChanged(() => {
+				if (this.pagerFridayCheckBox.checked) {
+					this.weekdayPagerStartTimeInput.enabled = true;
+					this.weekdayPagerEndTimeInput.enabled = true;
+				} else {
+					if (!this.pagerMondayCheckBox.checked && !this.pagerWednesdayCheckBox.checked &&
+						!this.pagerThursdayCheckBox.checked && !this.pagerTuesdayCheckBox.checked) {
+						this.weekdayPagerStartTimeInput.enabled = false;
+						this.weekdayPagerEndTimeInput.enabled = false;
+					}
+				}
+			});
+
+			let pagerFridayCheckboxContainer = view.modelBuilder.flexContainer()
+				.withLayout({
+					flexFlow: 'row',
+					alignItems: 'baseline'
+				}).withItems([this.pagerFridayCheckBox, weekdayStartInputContainer, weekdayEndInputContainer])
+				.component();
+
+			this.pagerSaturdayCheckBox = view.modelBuilder.checkBox()
+				.withProperties({
+					label: OperatorDialog.PagerSaturdayCheckBoxLabel,
+					width: 80
+				}).component();
+
+			this.pagerSaturdayCheckBox.onChanged(() => {
+				if (this.pagerSaturdayCheckBox.checked) {
+					this.saturdayPagerStartTimeInput.enabled = true;
+					this.saturdayPagerEndTimeInput.enabled = true;
+				} else {
+					this.saturdayPagerStartTimeInput.enabled = false;
+					this.saturdayPagerEndTimeInput.enabled = false;
+				}
+			});
+
+			this.saturdayPagerStartTimeInput = view.modelBuilder.inputBox()
+				.withProperties({
+					inputType: 'time',
+					placeHolder: '08:00:00'
+				}).component();
+			this.saturdayPagerStartTimeInput.enabled = false;
+			let saturdayStartInputContainer = view.modelBuilder.formContainer()
+				.withFormItems([{
+					component: this.saturdayPagerStartTimeInput,
+					title: 'Workday begin'
+				}]).component();
+
+			this.saturdayPagerEndTimeInput = view.modelBuilder.inputBox()
+				.withProperties({
+					inputType: 'time',
+					placeHolder: '06:00:00'
+				}).component();
+			this.saturdayPagerEndTimeInput.enabled = false;
+			let saturdayEndInputContainer = view.modelBuilder.formContainer()
+				.withFormItems([{
+					component: this.saturdayPagerEndTimeInput,
+					title: 'Workday end'
+				}]).component();
+
+			let pagerSaturdayCheckboxContainer = view.modelBuilder.flexContainer()
+				.withLayout({
+					flexFlow: 'row',
+					alignItems: 'baseline'
+				}).withItems([this.pagerSaturdayCheckBox, saturdayStartInputContainer, saturdayEndInputContainer])
+				.component();
+
+			this.pagerSundayCheckBox = view.modelBuilder.checkBox()
+				.withProperties({
+					label: OperatorDialog.PagerSundayCheckBoxLabel,
+					width: 80
+				}).component();
+
+			this.pagerSundayCheckBox.onChanged(() => {
+				if (this.pagerSundayCheckBox.checked) {
+					this.sundayPagerStartTimeInput.enabled = true;
+					this.sundayPagerEndTimeInput.enabled = true;
+				} else {
+					this.sundayPagerStartTimeInput.enabled = false;
+					this.sundayPagerEndTimeInput.enabled = false;
+				}
+			});
+
+			this.sundayPagerStartTimeInput = view.modelBuilder.inputBox()
+				.withProperties({
+					inputType: 'time',
+					placeHolder: '08:00:00'
+				}).component();
+			this.sundayPagerStartTimeInput.enabled = false;
+			let sundayStartInputContainer = view.modelBuilder.formContainer()
+				.withFormItems([{
+					component: this.sundayPagerStartTimeInput,
+					title: 'Workday begin'
+				}]).component();
+
+			this.sundayPagerEndTimeInput = view.modelBuilder.inputBox()
+				.withProperties({
+					inputType: 'time',
+					placeHolder: '06:00:00'
+				}).component();
+			this.sundayPagerEndTimeInput.enabled = false;
+			let sundayEndInputContainer = view.modelBuilder.formContainer()
+				.withFormItems([{
+					component: this.sundayPagerEndTimeInput,
+					title: 'Workday end'
+				}]).component();
+
+			let pagerSundayCheckboxContainer = view.modelBuilder.flexContainer()
+				.withLayout({
+					flexFlow: 'row',
+					alignItems: 'baseline'
+				}).withItems([this.pagerSundayCheckBox, sundayStartInputContainer, sundayEndInputContainer])
+				.component();
+
+			let checkBoxContainer = view.modelBuilder.formContainer()
+				.withFormItems([{
+					component: this.pagerMondayCheckBox,
+					title: ''
+				}, {
+					component: this.pagerTuesdayCheckBox,
+					title: ''
+				}, {
+					component: this.pagerWednesdayCheckBox,
+					title: ''
+				}, {
+					component: this.pagerThursdayCheckBox,
+					title: ''
+				}, {
+					component: pagerFridayCheckboxContainer,
+					title: ''
+				}, {
+					component: pagerSaturdayCheckboxContainer,
+					title: ''
+				}, {
+					component: pagerSundayCheckboxContainer,
+					title: ''
+				}]).component();
+
+			let pagerContainer = view.modelBuilder.flexContainer()
+				.withLayout({
+					flexFlow: 'row'
+				}).withItems([checkBoxContainer])
+				.component();
+
+			let formModel = view.modelBuilder.formContainer()
+				.withFormItems([{
+					component: this.nameTextBox,
+					title: OperatorDialog.NameLabel
+				}, {
+					component: this.enabledCheckBox,
+					title: ''
+				}, {
+					component: this.emailNameTextBox,
+					title: OperatorDialog.EmailNameTextLabel
+				}, {
+					component: this.pagerEmailNameTextBox,
+					title: OperatorDialog.PagerEmailNameTextLabel
+				}, {
+					component: pagerContainer,
+					title: ''
+				}]).withLayout({ width: '100%' }).component();
+
+			await view.initializeModel(formModel);
+		});
+	}
+
+	private initializeNotificationTab() {
+		this.notificationsTab.registerContent(async view => {
+
+			this.alertsTable = view.modelBuilder.table()
+				.withProperties({
+					columns: [
+						OperatorDialog.AlertNameColumnLabel,
+						OperatorDialog.AlertEmailColumnLabel,
+						OperatorDialog.AlertPagerColumnLabel
+					],
+					data: [],
+					height: 500
+				}).component();
+
+			let formModel = view.modelBuilder.formContainer()
+				.withFormItems([{
+					component: this.alertsTable,
+					title: OperatorDialog.AlertsTableLabel
+				}]).withLayout({ width: '100%' }).component();
+
+			await view.initializeModel(formModel);
+		});
+	}
+
+	protected updateModel() {
+		this.model.name = this.nameTextBox.value;
+		this.model.enabled = this.enabledCheckBox.checked;
+		this.model.emailAddress = this.emailNameTextBox.value;
+		this.model.pagerAddress = this.pagerEmailNameTextBox.value;
+		this.model.weekdayPagerStartTime = this.weekdayPagerStartTimeInput.value;
+		this.model.weekdayPagerEndTime = this.weekdayPagerEndTimeInput.value;
+		this.model.saturdayPagerStartTime = this.saturdayPagerStartTimeInput.value;
+		this.model.saturdayPagerEndTime = this.saturdayPagerEndTimeInput.value;
+		this.model.sundayPagerStartTime = this.sundayPagerStartTimeInput.value;
+		this.model.sundayPagerEndTime = this.sundayPagerEndTimeInput.value;
+	}
+}

extensions/agent/src/dialogs/pickScheduleDialog.ts

@@ -0,0 +1,92 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 vscode from 'vscode';
+import { PickScheduleData } from '../data/pickScheduleData';
+
+export class PickScheduleDialog {
+
+	// TODO: localize
+	// Top level
+	private readonly DialogTitle: string = 'Job Schedules';
+	private readonly OkButtonText: string = 'OK';
+	private readonly CancelButtonText: string = 'Cancel';
+	private readonly SchedulesTabText: string = 'Schedules';
+
+	// UI Components
+	private dialog: sqlops.window.modelviewdialog.Dialog;
+	private schedulesTable: sqlops.TableComponent;
+
+	private model: PickScheduleData;
+
+	private _onSuccess: vscode.EventEmitter<PickScheduleData> = new vscode.EventEmitter<PickScheduleData>();
+	public readonly onSuccess: vscode.Event<PickScheduleData> = this._onSuccess.event;
+
+	constructor(ownerUri: string) {
+		this.model = new PickScheduleData(ownerUri);
+	}
+
+	public async showDialog() {
+		await this.model.initialize();
+		this.dialog = sqlops.window.modelviewdialog.createDialog(this.DialogTitle);
+		this.initializeContent();
+		this.dialog.okButton.onClick(async () => await this.execute());
+		this.dialog.cancelButton.onClick(async () => await this.cancel());
+		this.dialog.okButton.label = this.OkButtonText;
+		this.dialog.cancelButton.label = this.CancelButtonText;
+
+		sqlops.window.modelviewdialog.openDialog(this.dialog);
+	}
+
+	private initializeContent() {
+		this.dialog.registerContent(async view => {
+			this.schedulesTable = view.modelBuilder.table()
+				.withProperties({
+					columns: [
+						'Schedule Name'
+					],
+					data: [],
+					height: 600,
+					width: 400
+				}).component();
+
+			let formModel = view.modelBuilder.formContainer()
+				.withFormItems([{
+					component: this.schedulesTable,
+					title: 'Schedules'
+				}]).withLayout({ width: '100%' }).component();
+
+			await view.initializeModel(formModel);
+
+			if (this.model.schedules) {
+				let data: any[][] = [];
+				for (let i = 0; i < this.model.schedules.length; ++i) {
+					let schedule = this.model.schedules[i];
+					data[i] = [ schedule.name ];
+				}
+				this.schedulesTable.data = data;
+			}
+		});
+	}
+
+	private async execute() {
+		this.updateModel();
+		await this.model.save();
+		this._onSuccess.fire(this.model);
+	}
+
+	private async cancel() {
+	}
+
+	private updateModel() {
+		let selectedRows = this.schedulesTable.selectedRows;
+		if (selectedRows && selectedRows.length > 0) {
+			let selectedRow = selectedRows[0];
+			this.model.selectedSchedule = this.model.schedules[selectedRow];
+		}
+	}
+}

extensions/agent/src/dialogs/proxyDialog.ts

@@ -0,0 +1,91 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 nls from 'vscode-nls';
+import * as sqlops from 'sqlops';
+import { AgentDialog } from './agentDialog';
+import { ProxyData } from '../data/proxyData';
+
+const localize = nls.loadMessageBundle();
+
+export class ProxyDialog extends AgentDialog<ProxyData>  {
+
+	// Top level
+	private static readonly DialogTitle: string = localize('createProxy.createAlert', 'Create Alert');
+	private static readonly GeneralTabText: string = localize('createProxy.General', 'General');
+
+	// General tab strings
+	private static readonly ProxyNameTextBoxLabel: string = localize('createProxy.ProxyName', 'Proxy name');
+	private static readonly CredentialNameTextBoxLabel: string = localize('createProxy.CredentialName', 'Credential name');
+	private static readonly DescriptionTextBoxLabel: string = localize('createProxy.Description', 'Description');
+	private static readonly SubsystemsTableLabel: string = localize('createProxy.Subsystems', 'Subsystems');
+	private static readonly SubsystemNameColumnLabel: string = localize('createProxy.SubsystemName', 'Subsystem');
+
+	// UI Components
+	private generalTab: sqlops.window.modelviewdialog.DialogTab;
+
+	// General tab controls
+	private proxyNameTextBox: sqlops.InputBoxComponent;
+	private credentialNameTextBox: sqlops.InputBoxComponent;
+	private descriptionTextBox: sqlops.InputBoxComponent;
+	private subsystemsTable: sqlops.TableComponent;
+
+	constructor(ownerUri: string) {
+		super(ownerUri, new ProxyData(ownerUri), ProxyDialog.DialogTitle);
+	}
+
+	protected async initializeDialog(dialog: sqlops.window.modelviewdialog.Dialog) {
+		this.generalTab = sqlops.window.modelviewdialog.createTab(ProxyDialog.GeneralTabText);
+
+		this.initializeGeneralTab();
+
+		this.dialog.content = [this.generalTab];
+	}
+
+	private initializeGeneralTab() {
+		this.generalTab.registerContent(async view => {
+
+			this.proxyNameTextBox = view.modelBuilder.inputBox().component();
+
+			this.credentialNameTextBox = view.modelBuilder.inputBox().component();
+
+			this.descriptionTextBox = view.modelBuilder.inputBox().component();
+
+			this.subsystemsTable = view.modelBuilder.table()
+				.withProperties({
+					columns: [
+						ProxyDialog.SubsystemNameColumnLabel
+					],
+					data: [],
+					height: 500
+				}).component();
+
+			let formModel = view.modelBuilder.formContainer()
+				.withFormItems([{
+					component: this.proxyNameTextBox,
+					title: ProxyDialog.ProxyNameTextBoxLabel
+				}, {
+					component: this.credentialNameTextBox,
+					title: ProxyDialog.CredentialNameTextBoxLabel
+				}, {
+					component: this.descriptionTextBox,
+					title: ProxyDialog.DescriptionTextBoxLabel
+				}, {
+					component: this.subsystemsTable,
+					title: ProxyDialog.SubsystemsTableLabel
+				}]).withLayout({ width: '100%' }).component();
+
+			await view.initializeModel(formModel);
+		});
+	}
+
+	protected updateModel() {
+		this.model.accountName = this.proxyNameTextBox.value;
+		this.model.credentialName = this.credentialNameTextBox.value;
+		this.model.description = this.descriptionTextBox.value;
+	}
+}

extensions/agent/src/dialogs/scheduleDialog.ts

@@ -0,0 +1,91 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 vscode from 'vscode';
+import { ScheduleData } from '../data/scheduleData';
+
+export class ScheduleDialog {
+
+	// Top level
+	private readonly DialogTitle: string = 'New Schedule';
+	private readonly OkButtonText: string = 'OK';
+	private readonly CancelButtonText: string = 'Cancel';
+
+	// UI Components
+	private dialog: sqlops.window.modelviewdialog.Dialog;
+	private schedulesTable: sqlops.TableComponent;
+
+	private model: ScheduleData;
+
+	private _onSuccess: vscode.EventEmitter<ScheduleData> = new vscode.EventEmitter<ScheduleData>();
+	public readonly onSuccess: vscode.Event<ScheduleData> = this._onSuccess.event;
+
+	constructor(ownerUri: string) {
+		this.model = new ScheduleData(ownerUri);
+	}
+
+	public async showDialog() {
+		await this.model.initialize();
+		this.dialog = sqlops.window.modelviewdialog.createDialog(this.DialogTitle);
+		this.initializeContent();
+		this.dialog.okButton.onClick(async () => await this.execute());
+		this.dialog.cancelButton.onClick(async () => await this.cancel());
+		this.dialog.okButton.label = this.OkButtonText;
+		this.dialog.cancelButton.label = this.CancelButtonText;
+
+		sqlops.window.modelviewdialog.openDialog(this.dialog);
+	}
+
+	private initializeContent() {
+		this.dialog.registerContent(async view => {
+			this.schedulesTable = view.modelBuilder.table()
+				.withProperties({
+					columns: [
+						'Schedule Name'
+					],
+					data: [],
+					height: 600,
+					width: 400
+				}).component();
+
+			let formModel = view.modelBuilder.formContainer()
+				.withFormItems([{
+					component: this.schedulesTable,
+					title: 'Schedules'
+				}]).withLayout({ width: '100%' }).component();
+
+			await view.initializeModel(formModel);
+
+			if (this.model.schedules) {
+				let data: any[][] = [];
+				for (let i = 0; i < this.model.schedules.length; ++i) {
+					let schedule = this.model.schedules[i];
+					data[i] = [ schedule.name ];
+				}
+				this.schedulesTable.data = data;
+			}
+		});
+	}
+
+	private async execute() {
+		this.updateModel();
+		await this.model.save();
+		this._onSuccess.fire(this.model);
+	}
+
+	private async cancel() {
+	}
+
+	private updateModel() {
+		let selectedRows = this.schedulesTable.selectedRows;
+		if (selectedRows && selectedRows.length > 0) {
+			let selectedRow = selectedRows[0];
+			this.model.selectedSchedule = this.model.schedules[selectedRow];
+		}
+	}
+}

extensions/agent/src/interfaces.ts

@@ -2,7 +2,16 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
+'use strict';
 
-/// <reference path='../../../../../src/vs/vscode.d.ts'/>
-/// <reference path='../../../../../src/sql/sqlops.d.ts'/>
-/// <reference types='@types/node'/>
+export enum AgentDialogMode {
+	CREATE = 1,
+	EDIT = 2,
+	VIEW = 3
+}
+
+export interface IAgentDialogData {
+	dialogMode: AgentDialogMode;
+	initialize(): void;
+	save(): void;
+}

extensions/agent/src/main.ts

@@ -6,12 +6,10 @@
 
 import vscode = require('vscode');
 import { MainController } from './mainController';
-import { ApiWrapper } from './apiWrapper';
 export let controller: MainController;
 
 export function activate(context: vscode.ExtensionContext) {
-	let apiWrapper = new ApiWrapper();
-	controller = new MainController(context, apiWrapper);
+	controller = new MainController(context);
 	controller.activate();
 }
 

extensions/agent/src/mainController.ts

@@ -0,0 +1,61 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 vscode from 'vscode';
+import { AlertDialog } from './dialogs/alertDialog';
+import { JobDialog } from './dialogs/jobDialog';
+import { OperatorDialog } from './dialogs/operatorDialog';
+import { ProxyDialog } from './dialogs/proxyDialog';
+import { JobStepDialog } from './dialogs/jobStepDialog';
+import { PickScheduleDialog } from './dialogs/pickScheduleDialog';
+
+/**
+ * The main controller class that initializes the extension
+ */
+export class MainController {
+    protected _context: vscode.ExtensionContext;
+
+    // PUBLIC METHODS //////////////////////////////////////////////////////
+    public constructor(context: vscode.ExtensionContext) {
+        this._context = context;
+    }
+
+    /**
+     * Activates the extension
+     */
+    public activate(): void {
+        vscode.commands.registerCommand('agent.openCreateJobDialog', (ownerUri: string) => {
+            let dialog = new JobDialog(ownerUri);
+            dialog.openDialog();
+        });
+        vscode.commands.registerCommand('agent.openNewStepDialog', (ownerUri: string, jobId: string, server: string, stepId: number) => {
+			let dialog = new JobStepDialog(ownerUri, jobId, server, stepId);
+			dialog.openNewStepDialog();
+        });
+        vscode.commands.registerCommand('agent.openPickScheduleDialog', (ownerUri: string) => {
+            let dialog = new PickScheduleDialog(ownerUri);
+            dialog.showDialog();
+        });
+        vscode.commands.registerCommand('agent.openAlertDialog', (ownerUri: string, alertInfo: sqlops.AgentAlertInfo) => {
+            let dialog = new AlertDialog(ownerUri, alertInfo);
+            dialog.openDialog();
+        });
+        vscode.commands.registerCommand('agent.openCreateOperatorDialog', (ownerUri: string) => {
+            let dialog = new OperatorDialog(ownerUri);
+            dialog.openDialog();
+        });
+        vscode.commands.registerCommand('agent.openCreateProxyDialog', (ownerUri: string) => {
+            let dialog = new ProxyDialog(ownerUri);
+            dialog.openDialog();
+        });
+    }
+
+    /**
+     * Deactivates the extension
+     */
+    public deactivate(): void {
+    }
+}

extensions/agent/src/test/agent.test.ts

@@ -0,0 +1,21 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import 'mocha';
+import * as vscode from 'vscode';
+import * as sqlops from 'sqlops';
+import { JobData } from '../data/jobData';
+import { TestAgentService } from './testAgentService';
+
+const testOwnerUri = 'agent://testuri';
+
+suite('Agent extension', () => {
+	test('Create Job Data', async () => {
+		let testAgentService = new TestAgentService();
+		let data = new JobData(testOwnerUri, testAgentService);
+		data.save();
+	});
+});

extensions/agent/src/test/testAgentService.ts

@@ -0,0 +1,105 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+
+import * as sqlops from 'sqlops';
+
+export class TestAgentService implements sqlops.AgentServicesProvider {
+	handle?: number;
+	readonly providerId: string = 'Test Provider';
+
+	// Job management methods
+	getJobs(ownerUri: string): Thenable<sqlops.AgentJobsResult> {
+		return undefined;
+	}
+	getJobHistory(ownerUri: string, jobId: string): Thenable<sqlops.AgentJobHistoryResult> {
+		return undefined;
+	}
+	jobAction(ownerUri: string, jobName: string, action: string): Thenable<sqlops.ResultStatus> {
+		return undefined;
+	}
+	createJob(ownerUri: string, jobInfo: sqlops.AgentJobInfo): Thenable<sqlops.CreateAgentJobResult> {
+		return undefined;
+	}
+	updateJob(ownerUri: string, originalJobName: string, jobInfo: sqlops.AgentJobInfo): Thenable<sqlops.UpdateAgentJobResult> {
+		return undefined;
+	}
+	deleteJob(ownerUri: string, jobInfo: sqlops.AgentJobInfo): Thenable<sqlops.ResultStatus> {
+		return undefined;
+	}
+	getJobDefaults(ownerUri: string): Thenable<sqlops.AgentJobDefaultsResult> {
+		return undefined;
+	}
+
+	// Job Step management methods
+	createJobStep(ownerUri: string, jobInfo: sqlops.AgentJobStepInfo): Thenable<sqlops.CreateAgentJobStepResult> {
+		return undefined;
+	}
+	updateJobStep(ownerUri: string, originalJobStepName: string, jobInfo: sqlops.AgentJobStepInfo): Thenable<sqlops.UpdateAgentJobStepResult> {
+		return undefined;
+	}
+	deleteJobStep(ownerUri: string, jobInfo: sqlops.AgentJobStepInfo): Thenable<sqlops.ResultStatus> {
+		return undefined;
+	}
+
+	// Alert management methods
+	getAlerts(ownerUri: string): Thenable<sqlops.AgentAlertsResult> {
+		return undefined;
+	}
+	createAlert(ownerUri: string, alertInfo: sqlops.AgentAlertInfo): Thenable<sqlops.CreateAgentAlertResult> {
+		return undefined;
+	}
+	updateAlert(ownerUri: string, originalAlertName: string, alertInfo: sqlops.AgentAlertInfo): Thenable<sqlops.UpdateAgentAlertResult> {
+		return undefined;
+	}
+	deleteAlert(ownerUri: string, alertInfo: sqlops.AgentAlertInfo): Thenable<sqlops.ResultStatus> {
+		return undefined;
+	}
+
+	// Operator management methods
+	getOperators(ownerUri: string): Thenable<sqlops.AgentOperatorsResult> {
+		return undefined;
+	}
+	createOperator(ownerUri: string, operatorInfo: sqlops.AgentOperatorInfo): Thenable<sqlops.CreateAgentOperatorResult> {
+		return undefined;
+	}
+	updateOperator(ownerUri: string, originalOperatorName: string, operatorInfo: sqlops.AgentOperatorInfo): Thenable<sqlops.UpdateAgentOperatorResult> {
+		return undefined;
+	}
+	deleteOperator(ownerUri: string, operatorInfo: sqlops.AgentOperatorInfo): Thenable<sqlops.ResultStatus> {
+		return undefined;
+	}
+
+	// Proxy management methods
+	getProxies(ownerUri: string): Thenable<sqlops.AgentProxiesResult> {
+		return undefined;
+	}
+	createProxy(ownerUri: string, proxyInfo: sqlops.AgentProxyInfo): Thenable<sqlops.CreateAgentOperatorResult> {
+		return undefined;
+	}
+	updateProxy(ownerUri: string, originalProxyName: string, proxyInfo: sqlops.AgentProxyInfo): Thenable<sqlops.UpdateAgentOperatorResult> {
+		return undefined;
+	}
+	deleteProxy(ownerUri: string, proxyInfo: sqlops.AgentProxyInfo): Thenable<sqlops.ResultStatus> {
+		return undefined;
+	}
+
+	// Job Schedule management methods
+	getJobSchedules(ownerUri: string): Thenable<sqlops.AgentJobSchedulesResult> {
+		return undefined;
+	}
+	createJobSchedule(ownerUri: string, scheduleInfo: sqlops.AgentJobScheduleInfo): Thenable<sqlops.CreateAgentJobScheduleResult> {
+		return undefined;
+	}
+	updateJobSchedule(ownerUri: string, originalScheduleName: string, scheduleInfo: sqlops.AgentJobScheduleInfo): Thenable<sqlops.UpdateAgentJobScheduleResult> {
+		return undefined;
+	}
+	deleteJobSchedule(ownerUri: string, scheduleInfo: sqlops.AgentJobScheduleInfo): Thenable<sqlops.ResultStatus> {
+		return undefined;
+	}
+
+	registerOnUpdated(handler: () => any): void {
+	}
+}

extensions/agent/src/typings/ref.d.ts

@@ -0,0 +1,9 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/// <reference path='../../../../src/vs/vscode.d.ts'/>
+/// <reference path='../../../../src/sql/sqlops.d.ts'/>
+/// <reference path='../../../../src/sql/sqlops.proposed.d.ts'/>
+/// <reference types='@types/node'/>

extensions/merge-conflict/README.md

@@ -2,4 +2,4 @@
 
 See [documentation](https://code.visualstudio.com/docs/editor/versioncontrol#_merge-conflicts).
 
-**Notice** This is a an extension that is bundled with Visual Studio Code.
+**Notice** This is a an extension that is bundled with SQL Operations Studio.

extensions/mssql/snippets/mssql.json

@@ -8,9 +8,9 @@
 			"GO",
 			"-- Create the new database if it does not exist already",
 			"IF NOT EXISTS (",
-			"\tSELECT name",
+			"\tSELECT [name]",
 			"\t\tFROM sys.databases",
-			"\t\tWHERE name = N'${1:DatabaseName}'",
+			"\t\tWHERE [name] = N'${1:DatabaseName}'",
 			")",
 			"CREATE DATABASE ${1:DatabaseName}",
 			"GO"
@@ -29,9 +29,9 @@
 			"-- ALTER DATABASE ${1:DatabaseName} SET SINGLE_USER WITH ROLLBACK IMMEDIATE;",
 			"-- Drop the database if it exists",
 			"IF EXISTS (",
-			"  SELECT name",
+			"  SELECT [name]",
 			"   FROM sys.databases",
-			"   WHERE name = N'${1:DatabaseName}'",
+			"   WHERE [name] = N'${1:DatabaseName}'",
 			")",
 			"DROP DATABASE ${1:DatabaseName}",
 			"GO"
@@ -42,38 +42,33 @@
 	"Create a new Table": {
 		"prefix": "sqlCreateTable",
 		"body": [
-			"-- Create a new table called '${1:TableName}' in schema '${2:SchemaName}'",
+			"-- Create a new table called '[${1:TableName}]' in schema '[${2:SchemaName}]' in database '[${3:DatabaseName}]'",
 			"-- Drop the table if it already exists",
-			"IF OBJECT_ID('${2:SchemaName}.${1:TableName}', 'U') IS NOT NULL",
-			"DROP TABLE ${2:SchemaName}.${1:TableName}",
+			"IF OBJECT_ID('[${3:DatabaseName}].[${2:SchemaName}].[${1:TableName}]', 'U') IS NOT NULL",
+			"DROP TABLE [${3:DatabaseName}].[${2:SchemaName}].[${1:TableName}]",
 			"GO",
-			"-- Create the table in the specified schema",
-			"CREATE TABLE ${2:SchemaName}.${1:TableName}",
+			"-- Create the table in the specified database and schema",
+			"CREATE TABLE [${3:DatabaseName}].[${2:SchemaName}].[${1:TableName}]",
 			"(",
-			"\t${1:TableName}Id INT NOT NULL PRIMARY KEY, -- primary key column",
-			"\t$3Column1 [NVARCHAR](50) NOT NULL,",
-			"\t$4Column2 [NVARCHAR](50) NOT NULL",
-			"\t-- specify more columns here",
+			"\t[${4:ColumnName}]Id INT NOT NULL PRIMARY KEY, -- Primary Key column",
+			"\t[${5:ColumnName1}] [NVARCHAR](50) NOT NULL,",
+			"\t[${6:ColumnName2}] [NVARCHAR](50) NOT NULL",
+			"\t-- Specify more columns here",
 			");",
 			"GO"
 		],
 		"description": "Create a new Table"
 	},
 
+
 	"Drop a Table": {
 		"prefix": "sqlDropTable",
 		"body": [
-			"-- Drop the table '${1:TableName}' in schema '${2:SchemaName}'",
-			"IF EXISTS (",
-			"\tSELECT *",
-			"\t\tFROM sys.tables",
-			"\t\tJOIN sys.schemas",
-			"\t\t\tON sys.tables.schema_id = sys.schemas.schema_id",
-			"\tWHERE sys.schemas.name = N'${2:SchemaName}'",
-			"\t\tAND sys.tables.name = N'${1:TableName}'",
-			")",
-			"\tDROP TABLE ${2:SchemaName}.${1:TableName}",
-			"GO"
+				"-- Drop a table called '${3:TableName}' in schema '${2:SchemaName}' in Database '${1:DatabaseName}'",
+				"-- Drop the table if it already exists",
+				"IF OBJECT_ID('[${1:DatabaseName}].[${2:SchemaName}].[${3:TableName}]', 'U') IS NOT NULL",
+				"DROP TABLE [${1:DatabaseName}].[${2:SchemaName}].[${3:TableName}]",
+				"GO"
 		],
 		"description": "Drop a Table"
 	},
@@ -81,9 +76,9 @@
 	"Add a new column to a Table": {
 		"prefix": "sqlAddColumn",
 		"body": [
-			"-- Add a new column '${1:NewColumnName}' to table '${2:TableName}' in schema '${3:SchemaName}'",
-			"ALTER TABLE ${3:SchemaName}.${2:TableName}",
-			"\tADD ${1:NewColumnName} /*new_column_name*/ int /*new_column_datatype*/ NULL /*new_column_nullability*/",
+			"-- Add a new column '[${1:NewColumnName}]' to table '[${2:TableName}]' in schema '[${3:SchemaName}]' in database '[${4:DatabaseName}]'",
+			"ALTER TABLE [${4:DatabaseName}].[${3:SchemaName}].[${2:TableName}]",
+			"\tADD [${1:NewColumnName}] /*new_column_name*/ ${5:int} /*new_column_datatype*/ ${6:NULL} /*new_column_nullability*/",
 			"GO"
 		],
 		"description": "Add a new column to a Table"
@@ -92,9 +87,9 @@
 	"Drop a column from a Table": {
 		"prefix": "sqlDropColumn",
 		"body": [
-			"-- Drop '${1:ColumnName}' from table '${2:TableName}' in schema '${3:SchemaName}'",
-			"ALTER TABLE ${3:SchemaName}.${2:TableName}",
-			"\tDROP COLUMN ${1:ColumnName}",
+			"-- Drop '[${1:ColumnName}]' from table '[${2:TableName}]' in schema '[${3:SchemaName}]' in database '[${4:DatabaseName}]'",
+			"ALTER TABLE [${4:DatabaseName}].[${3:SchemaName}].[${2:TableName}]",
+			"\tDROP COLUMN [${1:ColumnName}]",
 			"GO"
 		],
 		"description": "Add a new column to a Table"
@@ -103,9 +98,9 @@
 	"Select rows from a Table or a View": {
 		"prefix": "sqlSelect",
 		"body": [
-			"-- Select rows from a Table or View '${1:TableOrViewName}' in schema '${2:SchemaName}'",
-			"SELECT * FROM ${2:SchemaName}.${1:TableOrViewName}",
-			"WHERE $3\t/* add search conditions here */",
+			"-- Select rows from a Table or View '[${1:TableOrViewName}]' in schema '[${2:SchemaName}]' in database '[${3:DatabaseName}]'",
+			"SELECT * FROM [${3:DatabaseName}].[${2:SchemaName}].[${1:TableOrViewName}]",
+			"WHERE ${4:/* add search conditions here */}",
 			"GO"
 		],
 		"description": "Select rows from a Table or a View"
@@ -114,19 +109,19 @@
 	"Insert rows into a Table": {
 		"prefix": "sqlInsertRows",
 		"body": [
-			"-- Insert rows into table '${1:TableName}'",
-			"INSERT INTO ${1:TableName}",
-			"( -- columns to insert data into",
-			" $2[Column1], [Column2], [Column3]",
+			"-- Insert rows into table '${1:TableName}' in schema '[${2:SchemaName}]' in database '[${3:DatabaseName}]'",
+			"INSERT INTO [${3:DatabaseName}].[${2:SchemaName}].[${1:TableName}]",
+			"( -- Columns to insert data into",
+			" ${4:[ColumnName1], [ColumnName2], [ColumnName3]}",
 			")",
 			"VALUES",
-			"( -- first row: values for the columns in the list above",
-			" $3Column1_Value, Column2_Value, Column3_Value",
+			"( -- First row: values for the columns in the list above",
+			" ${5:ColumnValue1, ColumnValue2, ColumnValue3}",
 			"),",
-			"( -- second row: values for the columns in the list above",
-			" $4Column1_Value, Column2_Value, Column3_Value",
+			"( -- Second row: values for the columns in the list above",
+			" ${6:ColumnValue1, ColumnValue2, ColumnValue3}",
 			")",
-			"-- add more rows here",
+			"-- Add more rows here",
 			"GO"
 		],
 		"description": "Insert rows into a Table"
@@ -135,9 +130,9 @@
 	"Delete rows from a Table": {
 		"prefix": "sqlDeleteRows",
 		"body": [
-			"-- Delete rows from table '${1:TableName}'",
-			"DELETE FROM ${1:TableName}",
-			"WHERE $2\t/* add search conditions here */",
+			"-- Delete rows from table '[${1:TableName}]' in schema '[${2:SchemaName}]' in database '[${3:DatabaseName}]'",
+			"DELETE FROM [${3:DatabaseName}].[${2:SchemaName}].[${1:TableName}]",
+			"WHERE ${4:/* add search conditions here */}",
 			"GO"
 		],
 		"description": "Delete rows from a Table"
@@ -146,13 +141,13 @@
 	"Update rows in a Table": {
 		"prefix": "sqlUpdateRows",
 		"body": [
-			"-- Update rows in table '${1:TableName}'",
-			"UPDATE ${1:TableName}",
+			"-- Update rows in table '[${1:TableName}]' in schema '[${2:SchemaName}]' in database '[${3:DatabaseName}]'",
+			"UPDATE [${3:DatabaseName}].[${2:SchemaName}].[${1:TableName}]",
 			"SET",
-			"\t$2[Colum1] = Colum1_Value,",
-			"\t$3[Colum2] = Colum2_Value",
-			"\t-- add more columns and values here",
-			"WHERE $4\t/* add search conditions here */",
+			"\t[${4:ColumnName1}] = ${5:ColumnValue1},",
+			"\t[${6:ColumnName2}] = ${7:ColumnValue2}",
+			"\t-- Add more columns and values here",
+			"WHERE ${8:/* add search conditions here */}",
 			"GO"
 		],
 		"description": "Update rows in a Table"
@@ -207,8 +202,8 @@
 		"prefix": "sqlListTablesAndViews",
 		"body": [
 			"-- Get a list of tables and views in the current database",
-			"SELECT table_catalog [database], table_schema [schema], table_name name, table_type type",
-			"FROM information_schema.tables",
+			"SELECT table_catalog [database], table_schema [schema], table_name [name], table_type [type]",
+			"FROM INFORMATION_SCHEMA.TABLES",
 			"GO"
 		],
 		"description": "List tables and vies in the current database"
@@ -218,7 +213,7 @@
 		"prefix": "sqlListDatabases",
 		"body": [
 			"-- Get a list of databases",
-			"SELECT name FROM sys.databases",
+			"SELECT [name] FROM sys.databases",
 			"GO"
 		],
 		"description": "List databases"
@@ -232,8 +227,8 @@
 			"\tTableName = tbl.table_schema + '.' + tbl.table_name, ",
 			"\tColumnName = col.column_name, ",
 			"\tColumnDataType = col.data_type",
-			"FROM information_schema.tables tbl",
-			"INNER JOIN information_schema.columns col ",
+			"FROM INFORMATION_SCHEMA.TABLES tbl",
+			"INNER JOIN INFORMATION_SCHEMA.COLUMNS col ",
 			"\tON col.table_name = tbl.table_name",
 			"\tAND col.table_schema = tbl.table_schema",
 			"",
@@ -247,20 +242,20 @@
 		"prefix": "sqlCursor",
 		"body": [
 			"-- Declare a cursor for a Table or a View '${1:TableOrViewName}' in schema '${2:SchemaName}'",
-			"DECLARE @Column1 NVARCHAR(50), @Column2 NVARCHAR(50)",
+			"DECLARE @ColumnName1 NVARCHAR(50), @ColumnName2 NVARCHAR(50)",
 			"",
 			"DECLARE db_cursor CURSOR FOR",
-			"SELECT Column1, Column2",
+			"SELECT ColumnName1, Column2",
 			"FROM $2.$1",
 			"",
 			"OPEN db_cursor",
-			"FETCH NEXT FROM db_cursor INTO @Column1, @Column2",
+			"FETCH NEXT FROM db_cursor INTO @ColumnName1, @ColumnName2",
 			"",
 			"WHILE @@FETCH_STATUS = 0",
 			"BEGIN",
 			"\t-- add instructions to be executed for every row",
 			"\t$3",
-			"\tFETCH NEXT FROM db_cursor INTO @Column1, @Column2",
+			"\tFETCH NEXT FROM db_cursor INTO @ColumnName1, @ColumnName2",
 			"END",
 			"",
 			"CLOSE db_cursor",
@@ -303,5 +298,34 @@
 			"GO"
 		],
 		"description": "Get Space Used by Tables"
-	}
+	},
+
+	"Create a new Index": {
+		"prefix": "sqlCreateIndex",
+		"body": [
+			"-- Create a nonclustered index with or without a unique constraint",
+			"-- Or create a clustered index on table '[${1:TableName}]' in schema '[${2:SchemaName}]' in database '[${3:DatabaseName}]'",
+			"CREATE ${5:/*UNIQUE or CLUSTERED*/} INDEX IX_${4:IndexName} ON [${3:DatabaseName}].[${2:SchemaName}].[${1:TableName}] ([${6:ColumnName1}] DESC /*Change sort order as needed*/",
+			"GO"
+		],
+		"description": "Create a new Index"
+	},
+
+	"Create a new Temporary Table": {
+		"prefix": "sqlCreateTempTable",
+		"body": [
+			"-- Drop a temporary table called '#${1:TableName}'",
+			"-- Drop the table if it already exists",
+			"IF OBJECT_ID('tempDB..#${1:TableName}', 'U') IS NOT NULL",
+			"DROP TABLE #${1:TableName}",
+			"GO",
+			"-- Create the temporary table from a physical table called '${4:TableName}' in schema '${3:SchemaName}' in database '${2:DatabaseName}'",
+			"SELECT *",
+			"INTO #${1:TableName}",
+			"FROM [${2:DatabaseName}].[${3:[SchemaName}].[${4:TableName}]",
+			"WHERE ${5:/* add search conditions here */}"
+		],
+		"description": "Create a new Temporary Table"
+	},
+
 }

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.4.0-alpha.46",
+	"version": "1.5.0-alpha.4",
 	"downloadFileNames": {
 		"Windows_86": "win-x86-netcoreapp2.1.zip",
 		"Windows_64": "win-x64-netcoreapp2.1.zip",
@@ -16,4 +16,4 @@
 	},
 	"installDirectory": "../sqltoolsservice/{#platform#}/{#version#}",
 	"executableFiles": ["MicrosoftSqlToolsServiceLayer.exe", "MicrosoftSqlToolsServiceLayer"]
-}
+}

extensions/mssql/src/contextProvider.ts

@@ -37,7 +37,7 @@ export default class ContextProvider {
 	public onDashboardOpen(e: sqlops.DashboardDocument): void {
 		let iscloud: boolean;
 		let edition: number;
-		if (e.profile.providerName.toLowerCase() === 'mssql' && !types.isUndefinedOrNull(e.serverInfo.engineEditionId)) {
+		if (e.profile.providerName.toLowerCase() === 'mssql' && !types.isUndefinedOrNull(e.serverInfo) && !types.isUndefinedOrNull(e.serverInfo.engineEditionId)) {
 			if (isCloudEditions.some(i => i === e.serverInfo.engineEditionId)) {
 				iscloud = true;
 			} else {

extensions/mssql/src/contracts.ts

@@ -64,6 +64,10 @@ export interface DeleteAgentJobParams {
 	job: sqlops.AgentJobInfo;
 }
 
+export interface AgentJobDefaultsParams {
+	ownerUri: string;
+}
+
 // Job Step management parameters
 export interface CreateAgentJobStepParams {
 	ownerUri: string;
@@ -144,6 +148,27 @@ export interface DeleteAgentProxyParams {
 	proxy: sqlops.AgentProxyInfo;
 }
 
+// Job Schedule management parameters
+export interface AgentJobScheduleParams {
+	ownerUri: string;
+}
+
+export interface CreateAgentJobScheduleParams {
+	ownerUri: string;
+	schedule: sqlops.AgentJobScheduleInfo;
+}
+
+export interface UpdateAgentJobScheduleParams {
+	ownerUri: string;
+	originalScheduleName: string;
+	schedule: sqlops.AgentJobScheduleInfo;
+}
+
+export interface DeleteAgentJobScheduleParams {
+	ownerUri: string;
+	schedule: sqlops.AgentJobScheduleInfo;
+}
+
 // Agent Job management requests
 export namespace AgentJobsRequest {
 	export const type = new RequestType<AgentJobsParams, sqlops.AgentJobsResult, void, void>('agent/jobs');
@@ -169,6 +194,10 @@ export namespace DeleteAgentJobRequest {
 	export const type = new RequestType<DeleteAgentJobParams, sqlops.ResultStatus, void, void>('agent/deletejob');
 }
 
+export namespace AgentJobDefaultsRequest {
+	export const type = new RequestType<AgentJobDefaultsParams, sqlops.AgentJobDefaultsResult, void, void>('agent/jobdefaults');
+}
+
 // Job Step requests
 export namespace CreateAgentJobStepRequest {
 	export const type = new RequestType<CreateAgentJobStepParams, sqlops.CreateAgentJobStepResult, void, void>('agent/createjobstep');
@@ -233,4 +262,21 @@ export namespace DeleteAgentProxyRequest {
 	export const type = new RequestType<DeleteAgentProxyParams, sqlops.ResultStatus, void, void>('agent/deleteproxy');
 }
 
+// Job Schedules requests
+export namespace AgentJobSchedulesRequest {
+	export const type = new RequestType<AgentJobScheduleParams, sqlops.AgentJobSchedulesResult, void, void>('agent/schedules');
+}
+
+export namespace CreateAgentJobScheduleRequest {
+	export const type = new RequestType<CreateAgentJobScheduleParams, sqlops.CreateAgentJobScheduleResult, void, void>('agent/createschedule');
+}
+
+export namespace UpdateAgentJobScheduleRequest {
+	export const type = new RequestType<UpdateAgentJobScheduleParams, sqlops.UpdateAgentJobScheduleResult, void, void>('agent/updateschedule');
+}
+
+export namespace DeleteAgentJobScheduleRequest {
+	export const type = new RequestType<DeleteAgentJobScheduleParams, sqlops.ResultStatus, void, void>('agent/deleteschedule');
+}
+
 // ------------------------------- < Agent Management > ------------------------------------

extensions/mssql/src/features.ts

@@ -35,6 +35,8 @@ export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 		contracts.AgentJobActionRequest.type
 	];
 
+	private onUpdatedHandler: () => any;
+
 	constructor(client: SqlOpsDataClient) {
 		super(client, AgentServicesFeature.messagesTypes);
 	}
@@ -53,6 +55,18 @@ export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 
 	protected registerProvider(options: undefined): Disposable {
 		const client = this._client;
+		let self = this;
+
+		// On updated registration
+		let registerOnUpdated = (handler: () => any): void => {
+			self.onUpdatedHandler = handler;
+		};
+
+		let fireOnUpdated = (): void => {
+			if (self.onUpdatedHandler) {
+				self.onUpdatedHandler();
+			}
+		};
 
 		// Job management methods
 		let getJobs = (ownerUri: string): Thenable<sqlops.AgentJobsResult> => {
@@ -96,7 +110,10 @@ export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 			};
 			let requestType = contracts.CreateAgentJobRequest.type;
 			return client.sendRequest(requestType, params).then(
-				r => r,
+				r => {
+					fireOnUpdated();
+					return r;
+				},
 				e => {
 					client.logFailedRequest(requestType, e);
 					return Promise.resolve(undefined);
@@ -112,7 +129,10 @@ export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 			};
 			let requestType = contracts.UpdateAgentJobRequest.type;
 			return client.sendRequest(requestType, params).then(
-				r => r,
+				r => {
+					fireOnUpdated();
+					return r;
+				},
 				e => {
 					client.logFailedRequest(requestType, e);
 					return Promise.resolve(undefined);
@@ -126,6 +146,23 @@ export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 				job: jobInfo
 			};
 			let requestType = contracts.DeleteAgentJobRequest.type;
+			return client.sendRequest(requestType, params).then(
+				r => {
+					fireOnUpdated();
+					return r;
+				},
+				e => {
+					client.logFailedRequest(requestType, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
+		let getJobDefaults = (ownerUri: string): Thenable<sqlops.AgentJobDefaultsResult> => {
+			let params: contracts.AgentJobDefaultsParams = {
+				ownerUri: ownerUri
+			};
+			let requestType = contracts.AgentJobDefaultsRequest.type;
 			return client.sendRequest(requestType, params).then(
 				r => r,
 				e => {
@@ -143,7 +180,10 @@ export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 			};
 			let requestType = contracts.CreateAgentJobStepRequest.type;
 			return client.sendRequest(requestType, params).then(
-				r => r,
+				r => {
+					fireOnUpdated();
+					return r;
+				},
 				e => {
 					client.logFailedRequest(requestType, e);
 					return Promise.resolve(undefined);
@@ -159,7 +199,10 @@ export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 			};
 			let requestType = contracts.UpdateAgentJobStepRequest.type;
 			return client.sendRequest(requestType, params).then(
-				r => r,
+				r => {
+					fireOnUpdated();
+					return r;
+				},
 				e => {
 					client.logFailedRequest(requestType, e);
 					return Promise.resolve(undefined);
@@ -174,7 +217,10 @@ export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 			};
 			let requestType = contracts.DeleteAgentJobStepRequest.type;
 			return client.sendRequest(requestType, params).then(
-				r => r,
+				r => {
+					fireOnUpdated();
+					return r;
+				},
 				e => {
 					client.logFailedRequest(requestType, e);
 					return Promise.resolve(undefined);
@@ -204,7 +250,10 @@ export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 			};
 			let requestType = contracts.CreateAgentAlertRequest.type;
 			return client.sendRequest(requestType, params).then(
-				r => r,
+				r => {
+					fireOnUpdated();
+					return r;
+				},
 				e => {
 					client.logFailedRequest(requestType, e);
 					return Promise.resolve(undefined);
@@ -220,7 +269,10 @@ export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 			};
 			let requestType = contracts.UpdateAgentAlertRequest.type;
 			return client.sendRequest(requestType, params).then(
-				r => r,
+				r => {
+					fireOnUpdated();
+					return r;
+				},
 				e => {
 					client.logFailedRequest(requestType, e);
 					return Promise.resolve(undefined);
@@ -235,7 +287,10 @@ export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 			};
 			let requestType = contracts.DeleteAgentAlertRequest.type;
 			return client.sendRequest(requestType, params).then(
-				r => r,
+				r => {
+					fireOnUpdated();
+					return r;
+				},
 				e => {
 					client.logFailedRequest(requestType, e);
 					return Promise.resolve(undefined);
@@ -265,7 +320,10 @@ export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 			};
 			let requestType = contracts.CreateAgentOperatorRequest.type;
 			return client.sendRequest(requestType, params).then(
-				r => r,
+				r => {
+					fireOnUpdated();
+					return r;
+				},
 				e => {
 					client.logFailedRequest(requestType, e);
 					return Promise.resolve(undefined);
@@ -281,7 +339,10 @@ export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 			};
 			let requestType = contracts.UpdateAgentOperatorRequest.type;
 			return client.sendRequest(requestType, params).then(
-				r => r,
+				r => {
+					fireOnUpdated();
+					return r;
+				},
 				e => {
 					client.logFailedRequest(requestType, e);
 					return Promise.resolve(undefined);
@@ -296,7 +357,10 @@ export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 			};
 			let requestType = contracts.DeleteAgentOperatorRequest.type;
 			return client.sendRequest(requestType, params).then(
-				r => r,
+				r => {
+					fireOnUpdated();
+					return r;
+				},
 				e => {
 					client.logFailedRequest(requestType, e);
 					return Promise.resolve(undefined);
@@ -326,7 +390,10 @@ export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 			};
 			let requestType = contracts.CreateAgentProxyRequest.type;
 			return client.sendRequest(requestType, params).then(
-				r => r,
+				r => {
+					fireOnUpdated();
+					return r;
+				},
 				e => {
 					client.logFailedRequest(requestType, e);
 					return Promise.resolve(undefined);
@@ -342,7 +409,10 @@ export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 			};
 			let requestType = contracts.UpdateAgentProxyRequest.type;
 			return client.sendRequest(requestType, params).then(
-				r => r,
+				r => {
+					fireOnUpdated();
+					return r;
+				},
 				e => {
 					client.logFailedRequest(requestType, e);
 					return Promise.resolve(undefined);
@@ -356,6 +426,24 @@ export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 				proxy: proxyInfo
 			};
 			let requestType = contracts.DeleteAgentProxyRequest.type;
+			return client.sendRequest(requestType, params).then(
+				r => {
+					fireOnUpdated();
+					return r;
+				},
+				e => {
+					client.logFailedRequest(requestType, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
+		// Job Schedule management methods
+		let  getJobSchedules = (ownerUri: string): Thenable<sqlops.AgentJobSchedulesResult>  => {
+			let params: contracts.AgentJobScheduleParams = {
+				ownerUri: ownerUri
+			};
+			let requestType = contracts.AgentJobSchedulesRequest.type;
 			return client.sendRequest(requestType, params).then(
 				r => r,
 				e => {
@@ -365,6 +453,61 @@ export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 			);
 		};
 
+		let createJobSchedule = (ownerUri: string, scheduleInfo: sqlops.AgentJobScheduleInfo): Thenable<sqlops.CreateAgentJobScheduleResult> => {
+			let params: contracts.CreateAgentJobScheduleParams = {
+				ownerUri: ownerUri,
+				schedule: scheduleInfo
+			};
+			let requestType = contracts.CreateAgentJobScheduleRequest.type;
+			return client.sendRequest(requestType, params).then(
+				r => {
+					fireOnUpdated();
+					return r;
+				},
+				e => {
+					client.logFailedRequest(requestType, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
+		let updateJobSchedule = (ownerUri: string, originalScheduleName: string, scheduleInfo: sqlops.AgentJobScheduleInfo): Thenable<sqlops.UpdateAgentJobScheduleResult> => {
+			let params: contracts.UpdateAgentJobScheduleParams = {
+				ownerUri: ownerUri,
+				originalScheduleName: originalScheduleName,
+				schedule: scheduleInfo
+			};
+			let requestType = contracts.UpdateAgentJobScheduleRequest.type;
+			return client.sendRequest(requestType, params).then(
+				r => {
+					fireOnUpdated();
+					return r;
+				},
+				e => {
+					client.logFailedRequest(requestType, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
+		let deleteJobSchedule = (ownerUri: string, scheduleInfo: sqlops.AgentJobScheduleInfo): Thenable<sqlops.ResultStatus> => {
+			let params: contracts.DeleteAgentJobScheduleParams = {
+				ownerUri: ownerUri,
+				schedule: scheduleInfo
+			};
+			let requestType = contracts.DeleteAgentJobScheduleRequest.type;
+			return client.sendRequest(requestType, params).then(
+				r => {
+					fireOnUpdated();
+					return r;
+				},
+				e => {
+					client.logFailedRequest(requestType, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
 		return sqlops.dataprotocol.registerAgentServicesProvider({
 			providerId: client.providerId,
 			getJobs,
@@ -373,6 +516,7 @@ export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 			createJob,
 			updateJob,
 			deleteJob,
+			getJobDefaults,
 			createJobStep,
 			updateJobStep,
 			deleteJobStep,
@@ -387,7 +531,12 @@ export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 			getProxies,
 			createProxy,
 			updateProxy,
-			deleteProxy
+			deleteProxy,
+			getJobSchedules,
+			createJobSchedule,
+			updateJobSchedule,
+			deleteJobSchedule,
+			registerOnUpdated
 		});
 	}
 }

extensions/mssql/yarn.lock

@@ -49,9 +49,9 @@ core-util-is@~1.0.0:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.2.tgz#b5fd54220aa2bc5ab57aab7140c940754503c1a7"
 
-"dataprotocol-client@github:Microsoft/sqlops-dataprotocolclient#0.1.7":
-  version "0.1.7"
-  resolved "https://codeload.github.com/Microsoft/sqlops-dataprotocolclient/tar.gz/d50285b03d0d5073c086362c5c96afb279320607"
+"dataprotocol-client@github:Microsoft/sqlops-dataprotocolclient#0.1.9":
+  version "0.1.9"
+  resolved "https://codeload.github.com/Microsoft/sqlops-dataprotocolclient/tar.gz/a1a79895cb79658b75d78aa5cfd745855019148d"
   dependencies:
     vscode-languageclient "3.5.0"
 

extensions/profiler/package.json

@@ -2,7 +2,7 @@
   "name": "profiler",
   "displayName": "SQL Server Profiler",
   "description": "SQL Server Profiler for SQL Operations Studio",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "publisher": "Microsoft",
   "preview": true,
   "license": "https://raw.githubusercontent.com/Microsoft/sqlopsstudio/master/LICENSE.txt",
@@ -32,6 +32,16 @@
         "command": "profiler.newProfiler",
         "title": "New Profiler",
         "category": "Profiler"
+      },
+      {
+        "command": "profiler.start",
+        "title": "Start",
+        "category": "Profiler"
+      },
+      {
+        "command": "profiler.stop",
+        "title": "Stop",
+        "category": "Profiler"
       }
     ],
     "outputChannels": [

package.json

@@ -1,6 +1,6 @@
 {
   "name": "sqlops",
-  "version": "0.30.6",
+  "version": "0.31.2",
   "distro": "8c3e97e3425cc9814496472ab73e076de2ba99ee",
   "author": {
     "name": "Microsoft Corporation"
@@ -60,7 +60,7 @@
     "reflect-metadata": "^0.1.8",
     "rxjs": "5.4.0",
     "semver": "4.3.6",
-    "slickgrid": "github:anthonydresser/SlickGrid#2.3.20",
+    "slickgrid": "github:anthonydresser/SlickGrid#2.3.22",
     "spdlog": "0.6.0",
     "sudo-prompt": "^8.0.0",
     "svg.js": "^2.2.5",

samples/serverReports/src/sql/all_db_space_used.sql

@@ -9,7 +9,7 @@ declare @dbsize table
     Free_Space_MB decimal(20,2) default (0))
 insert into @dbsize
     (Dbname,file_Size_MB,Space_Used_MB,Free_Space_MB)
-exec sp_msforeachdb
+exec sp_MSforeachdb
 'use [?];
   select DB_NAME() AS DbName,
 sum(size)/128.0 AS File_Size_MB,
@@ -24,7 +24,7 @@ declare @logsize table
     log_Free_Space_MB decimal(20,2)default (0))
 insert into @logsize
     (Dbname,Log_File_Size_MB,log_Space_Used_MB,log_Free_Space_MB)
-exec sp_msforeachdb
+exec sp_MSforeachdb
 'use [?];
   select DB_NAME() AS DbName,
 sum(size)/128.0 AS Log_File_Size_MB,
@@ -38,7 +38,7 @@ declare @dbfreesize table
     Freespace varchar(50)default (0.00))
 insert into @dbfreesize
     (name,database_size,Freespace)
-exec sp_msforeachdb
+exec sp_MSforeachdb
 'use [?];SELECT database_name = db_name()
     ,database_size = ltrim(str((convert(DECIMAL(15, 2), dbsize) + convert(DECIMAL(15, 2), logsize)) * 8192 / 1048576, 15, 2) + ''MB'')
     ,''unallocated space'' = ltrim(str((

samples/sqlservices/package.json

@@ -19,7 +19,7 @@
         "commands": [
             {
                 "command": "sqlservices.openDialog",
-                "title": "openDialog"
+                "title": "sqlservices.openDialog"
             },
             {
                 "command": "sqlservices.openEditor",
@@ -32,6 +32,10 @@
             {
                 "command": "sqlservices.openEditorWithWebView2",
                 "title": "sqlservices.openEditorWithWebView2"
+            },
+            {
+                "command": "sqlservices.openWizard",
+                "title": "sqlservices.openWizard"
             }
         ],
         "dashboard.tabs": [

samples/sqlservices/src/controllers/mainController.ts

@@ -60,9 +60,212 @@ export default class MainController implements vscode.Disposable {
 			this.openEditorWithWebview2();
 		});
 
+		vscode.commands.registerCommand('sqlservices.openWizard', () => {
+			this.openWizard();
+		});
+
 		return Promise.resolve(true);
 	}
 
+	private async getTabContent(view: sqlops.ModelView, customButton1: sqlops.window.modelviewdialog.Button, customButton2: sqlops.window.modelviewdialog.Button, componentWidth: number | string): Promise<void> {
+		let inputBox = view.modelBuilder.inputBox()
+		.withProperties({
+			multiline: true,
+			height: 100
+		}).component();
+		let inputBoxWrapper = view.modelBuilder.loadingComponent().withItem(inputBox).component();
+		inputBoxWrapper.loading = false;
+		customButton1.onClick(() => {
+			inputBoxWrapper.loading = true;
+			setTimeout(() => inputBoxWrapper.loading = false, 5000);
+		});
+		let inputBox2 = view.modelBuilder.inputBox().component();
+		let backupFilesInputBox = view.modelBuilder.inputBox().component();
+
+		let checkbox = view.modelBuilder.checkBox()
+			.withProperties({
+				label: 'Copy-only backup'
+			})
+			.component();
+		checkbox.onChanged(e => {
+			console.info("inputBox.enabled " + inputBox.enabled);
+			inputBox.enabled = !inputBox.enabled;
+		});
+		let button = view.modelBuilder.button()
+			.withProperties({
+				label: '+'
+			}).component();
+		let button3 = view.modelBuilder.button()
+			.withProperties({
+				label: '-'
+
+			}).component();
+		let button2 = view.modelBuilder.button()
+			.component();
+		button.onDidClick(e => {
+			backupFilesInputBox.value = 'Button clicked';
+		});
+		let dropdown = view.modelBuilder.dropDown()
+			.withProperties({
+				value: 'Full',
+				values: ['Full', 'Differential', 'Transaction Log']
+			})
+			.component();
+		let f = 0;
+		inputBox.onTextChanged((params) => {
+			vscode.window.showInformationMessage(inputBox.value);
+			f = f + 1;
+			inputBox2.value = f.toString();
+		});
+		dropdown.onValueChanged((params) => {
+			vscode.window.showInformationMessage(inputBox2.value);
+			inputBox.value = dropdown.value.toString();
+		});
+		let radioButton = view.modelBuilder.radioButton()
+			.withProperties({
+				value: 'option1',
+				name: 'radioButtonOptions',
+				label: 'Option 1',
+				checked: true
+				//width: 300
+			}).component();
+		let radioButton2 = view.modelBuilder.radioButton()
+			.withProperties({
+				value: 'option2',
+				name: 'radioButtonOptions',
+				label: 'Option 2'
+			}).component();
+		let inputBox3 = view.modelBuilder.inputBox().component();
+		let inputBox4 = view.modelBuilder.inputBox().component();
+		let form2Model = view.modelBuilder.formContainer()
+			.withFormItems([{
+				component: inputBox3,
+				title: 'inputBox3'
+			}, {
+				component: inputBox4,
+				title: 'inputBox4'
+			}], {
+				horizontal: true
+			}).component();
+		let groupModel1 = view.modelBuilder.groupContainer()
+			.withLayout({
+			}).withItems([
+				form2Model
+			]).component();
+		radioButton.onDidClick(() => {
+			inputBox.value = radioButton.value;
+			groupModel1.enabled = true;
+		});
+		radioButton2.onDidClick(() => {
+			inputBox.value = radioButton.value;
+			groupModel1.enabled = false;
+		});
+		let table = view.modelBuilder.table().withProperties({
+			data: [
+				['1', '2', '2'],
+				['4', '5', '6'],
+				['7', '8', '9']
+			], columns: ['c1', 'c2', 'c3'],
+			height: 250,
+			selectedRows: [0]
+		}).component();
+		table.onRowSelected(e => {
+			// TODO:
+		});
+		let listBox = view.modelBuilder.listBox().withProperties({
+			values: ['1', '2', '3'],
+			selectedRow: 2
+		}).component();
+
+		let declarativeTable = view.modelBuilder.declarativeTable()
+		.withProperties({
+			columns: [{
+					displayName: 'Column 1',
+					valueType: sqlops.DeclarativeDataType.string,
+					width: '20px',
+					isReadOnly: true
+				}, {
+					displayName: 'Column 2',
+					valueType: sqlops.DeclarativeDataType.string,
+					width: '100px',
+					isReadOnly: false
+				}, {
+					displayName: 'Column 3',
+					valueType: sqlops.DeclarativeDataType.boolean,
+					width: '20px',
+					isReadOnly: false
+				}, {
+					displayName: 'Column 4',
+					valueType: sqlops.DeclarativeDataType.category,
+					isReadOnly: false,
+					width: '120px',
+					categoryValues: [
+						{ name: 'options1', displayName: 'option 1' },
+						{ name: 'options2', displayName: 'option 2' }
+					]
+				}
+			],
+			data: [
+				['Data00', 'Data01', false, 'options2'],
+				['Data10', 'Data11', true, 'options1']
+			]
+		}).component();
+
+		declarativeTable.onDataChanged(e => {
+			inputBox2.value = e.row.toString() + ' ' + e.column.toString() + ' ' + e.value.toString();
+			inputBox3.value = declarativeTable.data[e.row][e.column];
+		});
+
+		let flexRadioButtonsModel = view.modelBuilder.flexContainer()
+			.withLayout({
+				flexFlow: 'column',
+				alignItems: 'left',
+				height: 150
+			}).withItems([
+				radioButton, groupModel1, radioButton2]
+			, { flex: '1 1 50%' }).component();
+		let formModel = view.modelBuilder.formContainer()
+			.withFormItems([{
+				component: inputBoxWrapper,
+				title: 'Backup name'
+			}, {
+				component: inputBox2,
+				title: 'Recovery model'
+			}, {
+				component: dropdown,
+				title: 'Backup type'
+			}, {
+				component: checkbox,
+				title: ''
+			}, {
+				component: backupFilesInputBox,
+				title: 'Backup files',
+				actions: [button, button3]
+			}, {
+				component: flexRadioButtonsModel,
+				title: 'Options'
+			}, {
+				component: declarativeTable,
+				title: 'Declarative Table'
+			}, {
+				component: table,
+				title: 'Table'
+			}, {
+				component: listBox,
+				title: 'List Box'
+			}], {
+				horizontal: false,
+				componentWidth: componentWidth
+			}).component();
+		let formWrapper = view.modelBuilder.loadingComponent().withItem(formModel).component();
+		formWrapper.loading = false;
+		customButton2.onClick(() => {
+			formWrapper.loading = true;
+			setTimeout(() => formWrapper.loading = false, 5000);
+		});
+		await view.initializeModel(formWrapper);
+	}
+
 	private openDialog(): void {
 		let dialog = sqlops.window.modelviewdialog.createDialog('Test dialog');
 		let tab1 = sqlops.window.modelviewdialog.createTab('Test tab 1');
@@ -80,207 +283,29 @@ export default class MainController implements vscode.Disposable {
 		customButton2.onClick(() => console.log('button 2 clicked!'));
 		dialog.customButtons = [customButton1, customButton2];
 		tab1.registerContent(async (view) => {
-			let inputBox = view.modelBuilder.inputBox()
-				.withProperties({
-					multiline: true,
-					height: 100
-				}).component();
-			let inputBoxWrapper = view.modelBuilder.loadingComponent().withItem(inputBox).component();
-			inputBoxWrapper.loading = false;
-			customButton1.onClick(() => {
-				inputBoxWrapper.loading = true;
-				setTimeout(() => inputBoxWrapper.loading = false, 5000);
-			});
-			let inputBox2 = view.modelBuilder.inputBox().component();
-			let backupFilesInputBox = view.modelBuilder.inputBox().component();
-
-			let checkbox = view.modelBuilder.checkBox()
-				.withProperties({
-					label: 'Copy-only backup'
-				})
-				.component();
-			checkbox.onChanged(e => {
-				console.info("inputBox.enabled " + inputBox.enabled);
-				inputBox.enabled = !inputBox.enabled;
-			});
-			let button = view.modelBuilder.button()
-				.withProperties({
-					label: '+'
-				}).component();
-			let button3 = view.modelBuilder.button()
-				.withProperties({
-					label: '-'
-
-				}).component();
-			let button2 = view.modelBuilder.button()
-				.component();
-			button.onDidClick(e => {
-				backupFilesInputBox.value = 'Button clicked';
-			});
-			let dropdown = view.modelBuilder.dropDown()
-				.withProperties({
-					value: 'Full',
-					values: ['Full', 'Differential', 'Transaction Log']
-				})
-				.component();
-			let f = 0;
-			inputBox.onTextChanged((params) => {
-				vscode.window.showInformationMessage(inputBox.value);
-				f = f + 1;
-				inputBox2.value = f.toString();
-			});
-			dropdown.onValueChanged((params) => {
-				vscode.window.showInformationMessage(inputBox2.value);
-				inputBox.value = dropdown.value;
-			});
-			let radioButton = view.modelBuilder.radioButton()
-				.withProperties({
-					value: 'option1',
-					name: 'radioButtonOptions',
-					label: 'Option 1',
-					checked: true
-					//width: 300
-				}).component();
-			let radioButton2 = view.modelBuilder.radioButton()
-				.withProperties({
-					value: 'option2',
-					name: 'radioButtonOptions',
-					label: 'Option 2'
-				}).component();
-			let inputBox3 = view.modelBuilder.inputBox().component();
-			let inputBox4 = view.modelBuilder.inputBox().component();
-			let form2Model = view.modelBuilder.formContainer()
-				.withFormItems([{
-					component: inputBox3,
-					title: 'inputBox3'
-				}, {
-					component: inputBox4,
-					title: 'inputBox4'
-				}], {
-					horizontal: true
-				}).component();
-			let groupModel1 = view.modelBuilder.groupContainer()
-				.withLayout({
-				}).withItems([
-					form2Model
-				]).component();
-			radioButton.onDidClick(() => {
-				inputBox.value = radioButton.value;
-				groupModel1.enabled = true;
-			});
-			radioButton2.onDidClick(() => {
-				inputBox.value = radioButton.value;
-				groupModel1.enabled = false;
-			});
-			let table = view.modelBuilder.table().withProperties({
-				data: [
-					['1', '2', '2'],
-					['4', '5', '6'],
-					['7', '8', '9']
-				], columns: ['c1', 'c2', 'c3'],
-				height: 250,
-				selectedRows: [0]
-			}).component();
-			table.onRowSelected(e => {
-				// TODO:
-			});
-			let listBox = view.modelBuilder.listBox().withProperties({
-				values: ['1', '2', '3'],
-				selectedRow: 2
-			}).component();
-
-			let declarativeTable = view.modelBuilder.declarativeTable()
-			.withProperties({
-				columns: [{
-						displayName: 'Column 1',
-						valueType: sqlops.DeclarativeDataType.string,
-						width: '20px',
-						isReadOnly: true
-					}, {
-						displayName: 'Column 2',
-						valueType: sqlops.DeclarativeDataType.string,
-						width: '100px',
-						isReadOnly: false
-					}, {
-						displayName: 'Column 3',
-						valueType: sqlops.DeclarativeDataType.boolean,
-						width: '20px',
-						isReadOnly: false
-					}, {
-						displayName: 'Column 4',
-						valueType: sqlops.DeclarativeDataType.category,
-						isReadOnly: false,
-						width: '120px',
-						categoryValues: [
-							{ name: 'options1', displayName: 'option 1' },
-							{ name: 'options2', displayName: 'option 2' }
-						]
-					}
-				],
-				data: [
-					['Data00', 'Data01', false, 'options2'],
-					['Data10', 'Data11', true, 'options1']
-				]
-			}).component();
-
-			declarativeTable.onDataChanged(e => {
-				inputBox2.value = e.row.toString() + ' ' + e.column.toString() + ' ' + e.value.toString();
-				inputBox3.value = declarativeTable.data[e.row][e.column];
-			});
-
-			let flexRadioButtonsModel = view.modelBuilder.flexContainer()
-				.withLayout({
-					flexFlow: 'column',
-					alignItems: 'left',
-					height: 150
-				}).withItems([
-					radioButton, groupModel1, radioButton2]
-				, { flex: '1 1 50%' }).component();
-			let formModel = view.modelBuilder.formContainer()
-				.withFormItems([{
-					component: inputBoxWrapper,
-					title: 'Backup name'
-				}, {
-					component: inputBox2,
-					title: 'Recovery model'
-				}, {
-					component: dropdown,
-					title: 'Backup type'
-				}, {
-					component: checkbox,
-					title: ''
-				}, {
-					component: backupFilesInputBox,
-					title: 'Backup files',
-					actions: [button, button3]
-				}, {
-					component: flexRadioButtonsModel,
-					title: 'Options'
-				}, {
-					component: declarativeTable,
-					title: 'Declarative Table'
-				}, {
-					component: table,
-					title: 'Table'
-				}, {
-					component: listBox,
-					title: 'List Box'
-				}], {
-					horizontal: false,
-					componentWidth: 400
-				}).component();
-			let formWrapper = view.modelBuilder.loadingComponent().withItem(formModel).component();
-			formWrapper.loading = false;
-			customButton2.onClick(() => {
-				formWrapper.loading = true;
-				setTimeout(() => formWrapper.loading = false, 5000);
-			});
-			await view.initializeModel(formWrapper);
+			await this.getTabContent(view, customButton1, customButton2, 400);
 		});
 
 		sqlops.window.modelviewdialog.openDialog(dialog);
 	}
 
+	private openWizard(): void {
+		let wizard = sqlops.window.modelviewdialog.createWizard('Test wizard');
+		let page1 = sqlops.window.modelviewdialog.createWizardPage('First wizard page');
+		let page2 = sqlops.window.modelviewdialog.createWizardPage('Second wizard page');
+		page2.content = 'sqlservices';
+		let customButton1 = sqlops.window.modelviewdialog.createButton('Load name');
+		customButton1.onClick(() => console.log('button 1 clicked!'));
+		let customButton2 = sqlops.window.modelviewdialog.createButton('Load all');
+		customButton2.onClick(() => console.log('button 2 clicked!'));
+		wizard.customButtons = [customButton1, customButton2];
+		page1.registerContent(async (view) => {
+			await this.getTabContent(view, customButton1, customButton2, 800);
+		});
+		wizard.pages = [page1, page2];
+		wizard.open();
+	}
+
 	private openEditor(): void {
 		let editor = sqlops.workspace.createModelViewEditor('Test Model View');
 		editor.registerContent(async view => {

src/sql/base/browser/ui/editableDropdown/actions.ts

@@ -11,7 +11,7 @@ export class ToggleDropdownAction extends Action {
 	private static readonly ID = 'dropdownAction.toggle';
 	private static readonly ICON = 'dropdown-arrow';
 
-	constructor(label, private _fn: () => any) {
+	constructor(private _fn: () => any, label: string) {
 		super(ToggleDropdownAction.ID, label, ToggleDropdownAction.ICON);
 	}
 

src/sql/base/browser/ui/editableDropdown/dropdown.ts

@@ -53,6 +53,10 @@ export interface IDropdownOptions extends IDropdownStyles {
 	 * Value to use as aria-label for the input box
 	 */
 	ariaLabel?: string;
+	/**
+	 * Label for the dropdown action
+	 */
+	actionLabel: string;
 }
 
 export interface IDropdownStyles {
@@ -66,7 +70,8 @@ const defaults: IDropdownOptions = {
 	strictSelection: true,
 	maxHeight: 300,
 	errorMessage: errorMessage,
-	contextBorder: Color.fromHex('#696969')
+	contextBorder: Color.fromHex('#696969'),
+	actionLabel: nls.localize('dropdownAction.toggle', "Toggle dropdown")
 };
 
 interface ListResource {
@@ -115,11 +120,11 @@ export class Dropdown extends Disposable {
 		this.$input = $('.dropdown-input').style('width', '100%').appendTo(this.$el);
 		this.$treeContainer = $('.dropdown-tree');
 
-		this._toggleAction = new ToggleDropdownAction(nls.localize('dropdown.toggle', '{0} Toggle Dropdown', this._options.ariaLabel), () => {
+		this._toggleAction = new ToggleDropdownAction(() => {
 			this._showList();
 			this._tree.domFocus();
 			this._tree.focusFirst();
-		});
+		}, opt.actionLabel);
 
 		this._input = new InputBox(this.$input.getHTMLElement(), contextViewService, {
 			validationOptions: {

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

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 'use strict';
-import { InputBox as vsInputBox, IInputOptions, IInputBoxStyles as vsIInputBoxStyles } from 'vs/base/browser/ui/inputbox/inputBox';
+import { InputBox as vsInputBox, IInputOptions, IInputBoxStyles as vsIInputBoxStyles, IMessage } from 'vs/base/browser/ui/inputbox/inputBox';
 import { IContextViewProvider } from 'vs/base/browser/ui/contextview/contextview';
 import { Color } from 'vs/base/common/color';
 import { Event, Emitter } from 'vs/base/common/event';
@@ -33,6 +33,7 @@ export class InputBox extends vsInputBox {
 	public onLoseFocus: Event<OnLoseFocusParams> = this._onLoseFocus.event;
 
 	private _isTextAreaInput: boolean;
+	private _hideErrors = false;
 
 	constructor(container: HTMLElement, contextViewProvider: IContextViewProvider, options?: IInputOptions) {
 		super(container, contextViewProvider, options);
@@ -103,4 +104,21 @@ export class InputBox extends vsInputBox {
 	public isEnabled(): boolean {
 		return !this.inputElement.hasAttribute('disabled');
 	}
+
+	public get hideErrors(): boolean {
+		return this._hideErrors;
+	}
+
+	public set hideErrors(hideErrors: boolean) {
+		this._hideErrors = hideErrors;
+		if (hideErrors) {
+			this.hideMessage();
+		}
+	}
+
+	public showMessage(message: IMessage, force?: boolean): void {
+		if (!this.hideErrors) {
+			super.showMessage(message, force);
+		}
+	}
 }

src/sql/base/browser/ui/modal/media/modal.css

@@ -172,4 +172,22 @@
 	margin-right: 10px;
 	width: 20px;
 	height: 20px;
+}
+
+.modal .modal-footer .dialogErrorMessage {
+	align-items: center;
+	max-height: 30px;
+	margin-right: 5px;
+}
+
+.modal .dialogErrorMessage .icon {
+	float: left;
+	margin-right: 10px;
+	width: auto;
+	height: 20px;
+}
+
+.modal .modal-footer .dialogErrorMessage .errorMessage {
+	max-height: 100%;
+	overflow-y: scroll;
 }

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

@@ -21,9 +21,13 @@ import { Button } from 'sql/base/browser/ui/button/button';
 import * as TelemetryUtils from 'sql/common/telemetryUtilities';
 import * as TelemetryKeys from 'sql/common/telemetryKeys';
 import { localize } from 'vs/nls';
+import { MessageLevel } from 'sql/workbench/api/common/sqlExtHostTypes';
 
 export const MODAL_SHOWING_KEY = 'modalShowing';
 export const MODAL_SHOWING_CONTEXT = new RawContextKey<Array<string>>(MODAL_SHOWING_KEY, []);
+const INFO_ALT_TEXT = localize('infoAltText', 'Info');
+const WARNING_ALT_TEXT = localize('warningAltText', 'Warning');
+const ERROR_ALT_TEXT = localize('errorAltText', 'Error');
 
 export interface IModalDialogStyles {
 	dialogForeground?: Color;
@@ -145,7 +149,7 @@ export abstract class Modal extends Disposable implements IThemable {
 	/**
 	 * Build and render the modal, will call {@link Modal#renderBody}
 	 */
-	public render() {
+	public render(errorMessagesInFooter: boolean = false) {
 		let modalBodyClass = (this._modalOptions.isAngular === false ? 'modal-body' : 'modal-body-and-footer');
 		let parts: Array<HTMLElement> = [];
 		// This modal header section refers to the header of of the dialog
@@ -182,17 +186,6 @@ export abstract class Modal extends Disposable implements IThemable {
 
 		this.renderBody(body.getHTMLElement());
 
-		if (this._modalOptions.isAngular === false && this._modalOptions.hasErrors) {
-			body.div({ class: 'dialogErrorMessage', id: 'dialogErrorMessage' }, (errorMessageContainer) => {
-				errorMessageContainer.div({ class: 'icon error' }, (iconContainer) => {
-					this._errorIconElement = iconContainer.getHTMLElement();
-					this._errorIconElement.style.visibility = 'hidden';
-				});
-				errorMessageContainer.div({ class: 'errorMessage' }, (messageContainer) => {
-					this._errorMessage = messageContainer;
-				});
-			});
-		}
 		// This modal footer section refers to the footer of of the dialog
 		if (this._modalOptions.isAngular === false) {
 			this._modalFooterSection = $().div({ class: 'modal-footer' }, (modelFooter) => {
@@ -221,6 +214,19 @@ export abstract class Modal extends Disposable implements IThemable {
 			builderClass += ' wide';
 		}
 
+		if (this._modalOptions.isAngular === false && this._modalOptions.hasErrors) {
+			let builder = errorMessagesInFooter ? this._leftFooter : body;
+			builder.div({ class: 'dialogErrorMessage', id: 'dialogErrorMessage' }, (errorMessageContainer) => {
+				errorMessageContainer.div({ class: 'icon error' }, (iconContainer) => {
+					this._errorIconElement = iconContainer.getHTMLElement();
+					this._errorIconElement.style.visibility = 'hidden';
+				});
+				errorMessageContainer.div({ class: 'errorMessage' }, (messageContainer) => {
+					this._errorMessage = messageContainer;
+				});
+			});
+		}
+
 		// The builder builds the dialog. It append header, body and footer sections.
 		this._builder = $().div({ class: builderClass, 'role': 'dialog' }, (dialogContainer) => {
 			this._modalDialog = dialogContainer.div({ class: 'modal-dialog ', role: 'document' }, (modalDialog) => {
@@ -355,14 +361,33 @@ export abstract class Modal extends Disposable implements IThemable {
 	 * Show an error in the error message element
 	 * @param err Text to show in the error message
 	 */
-	protected setError(err: string) {
+	protected setError(err: string, level: MessageLevel = MessageLevel.Error) {
 		if (this._modalOptions.hasErrors) {
 			if (err === '') {
 				this._errorIconElement.style.visibility = 'hidden';
 			} else {
+				const levelClasses = ['info', 'warning', 'error'];
+				let selectedLevel = levelClasses[2];
+				let altText = ERROR_ALT_TEXT;
+				if (level === MessageLevel.Information) {
+					selectedLevel = levelClasses[0];
+					altText = INFO_ALT_TEXT;
+				} else if (level === MessageLevel.Warning) {
+					selectedLevel = levelClasses[1];
+					altText = WARNING_ALT_TEXT;
+				}
+				levelClasses.forEach(level => {
+					if (selectedLevel === level) {
+						this._errorIconElement.classList.add(level);
+					} else {
+						this._errorIconElement.classList.remove(level);
+					}
+				});
+
+				this._errorIconElement.title = altText;
 				this._errorIconElement.style.visibility = 'visible';
 			}
-			this._errorMessage.innerHtml(err);
+			this._errorMessage.text(err);
 		}
 	}
 

src/sql/base/common/strings.ts

@@ -0,0 +1,21 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+/**
+ * Converts HTML characters inside the string to use entities instead. Makes the string safe from
+ * being used e.g. in HTMLElement.innerHTML.
+ */
+export function escape(html: string): string {
+	return html.replace(/[<|>|&|"]/g, function (match) {
+		switch (match) {
+			case '<': return '&lt;';
+			case '>': return '&gt;';
+			case '&': return '&amp;';
+			case '"': return '&quot;';
+			default: return match;
+		}
+	});
+}

src/sql/media/icons/common-icons.css

@@ -216,4 +216,19 @@
 
 .vs .icon.unpin {
 	background: url('unpin.svg') center center no-repeat;
+}
+
+.small {
+	width: 16px;
+	height: 16px;
+}
+
+.medium {
+	width: 24px;
+	height: 24px;
+}
+
+.large {
+	width: 32px;
+	height: 32px;
 }

src/sql/media/icons/status_info.svg

@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16"><style type="text/css">.icon-canvas-transparent{opacity:0;fill:#F6F6F6;} .icon-vs-out{fill:#F6F6F6;} .icon-vs-blue{fill:#1BA1E2;} .icon-white{fill:#FFFFFF;}</style><path class="icon-canvas-transparent" d="M16 16h-16v-16h16v16z" id="canvas"/><path class="icon-vs-out" d="M0 8c0-4.418 3.582-8 8-8s8 3.582 8 8-3.582 8-8 8-8-3.582-8-8z" id="outline"/><path class="icon-vs-blue" d="M8 1c-3.865 0-7 3.135-7 7s3.135 7 7 7 7-3.135 7-7-3.135-7-7-7zm1 12h-2v-7h2v7zm0-8h-2v-2h2v2z" id="iconBg"/><path class="icon-white" d="M7 6h2v7h-2v-7zm0-1h2v-2h-2v2z" id="iconFg"/></svg>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><style type="text/css">.icon-canvas-transparent{opacity:0;fill:#F6F6F6;} .icon-vs-out{fill:#F6F6F6;} .icon-vs-blue{fill:#1BA1E2;} .icon-white{fill:#FFFFFF;}</style><path class="icon-canvas-transparent" d="M16 16h-16v-16h16v16z" id="canvas"/><path class="icon-vs-out" d="M0 8c0-4.418 3.582-8 8-8s8 3.582 8 8-3.582 8-8 8-8-3.582-8-8z" id="outline"/><path class="icon-vs-blue" d="M8 1c-3.865 0-7 3.135-7 7s3.135 7 7 7 7-3.135 7-7-3.135-7-7-7zm1 12h-2v-7h2v7zm0-8h-2v-2h2v2z" id="iconBg"/><path class="icon-white" d="M7 6h2v7h-2v-7zm0-1h2v-2h-2v2z" id="iconFg"/></svg>

src/sql/parts/accountManagement/accountDialog/accountDialog.ts

@@ -130,7 +130,7 @@ export class AccountDialog extends Modal {
 
 		this._noaccountViewContainer = DOM.$('div.no-account-view');
 		let noAccountTitle = DOM.append(this._noaccountViewContainer, DOM.$('.no-account-view-label'));
-		let noAccountLabel = localize('accountDialog.noAccountLabel', 'There is no linked account. Please add an acount.');
+		let noAccountLabel = localize('accountDialog.noAccountLabel', 'There is no linked account. Please add an account.');
 		noAccountTitle.innerHTML = noAccountLabel;
 
 		// Show the add account button for the first provider

src/sql/parts/admin/security/createLogin.module.ts

@@ -6,12 +6,14 @@
 import { NgModule, Inject, forwardRef, ApplicationRef, ComponentFactoryResolver, Type } from '@angular/core';
 import { APP_BASE_HREF, CommonModule } from '@angular/common';
 import { BrowserModule } from '@angular/platform-browser';
-import { IBootstrapParams } from 'sql/services/bootstrap/bootstrapService';
 
-import { CreateLoginComponent, CREATELOGIN_SELECTOR } from 'sql/parts/admin/security/createLogin.component';
+import { IBootstrapParams, providerIterator } from 'sql/services/bootstrap/bootstrapService';
+import { CreateLoginComponent } from 'sql/parts/admin/security/createLogin.component';
+
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 
 // Connection Dashboard main angular module
-export const CreateLoginModule = (params: IBootstrapParams, selector: string): Type<any> => {
+export const CreateLoginModule = (params: IBootstrapParams, selector: string, instantiationService: IInstantiationService): Type<any> => {
 
 	@NgModule({
 		declarations: [
@@ -24,7 +26,8 @@ export const CreateLoginModule = (params: IBootstrapParams, selector: string): T
 		],
 		providers: [
 			{ provide: APP_BASE_HREF, useValue: '/' },
-			{ provide: IBootstrapParams, useValue: params }
+			{ provide: IBootstrapParams, useValue: params },
+			...providerIterator(instantiationService)
 		]
 	})
 	class ModuleClass {

src/sql/parts/common/customInputConverter.ts

@@ -38,13 +38,13 @@ export function convertEditorInput(input: EditorInput, options: IQueryEditorOpti
 		let uri: URI = getQueryEditorFileUri(input);
 		if (uri) {
 			const queryResultsInput: QueryResultsInput = instantiationService.createInstance(QueryResultsInput, uri.toString());
-			let queryInput: QueryInput = instantiationService.createInstance(QueryInput, input.getName(), '', input, queryResultsInput, undefined);
+			let queryInput: QueryInput = instantiationService.createInstance(QueryInput, '', input, queryResultsInput, undefined);
 			return queryInput;
 		}
 
 		//QueryPlanInput
 		uri = getQueryPlanEditorUri(input);
-		if(uri) {
+		if (uri) {
 			let queryPlanXml: string = fs.readFileSync(uri.fsPath);
 			let queryPlanInput: QueryPlanInput = instantiationService.createInstance(QueryPlanInput, queryPlanXml, 'aaa', undefined);
 			return queryPlanInput;
@@ -60,14 +60,14 @@ export function convertEditorInput(input: EditorInput, options: IQueryEditorOpti
  */
 export function getSupportedInputResource(input: IEditorInput): URI {
 	if (input instanceof UntitledEditorInput) {
-		let untitledCast: UntitledEditorInput = <UntitledEditorInput> input;
+		let untitledCast: UntitledEditorInput = <UntitledEditorInput>input;
 		if (untitledCast) {
 			return untitledCast.getResource();
 		}
 	}
 
 	if (input instanceof FileEditorInput) {
-		let fileCast: FileEditorInput  = <FileEditorInput> input;
+		let fileCast: FileEditorInput = <FileEditorInput>input;
 		if (fileCast) {
 			return fileCast.getResource();
 		}
@@ -99,7 +99,7 @@ function getQueryEditorFileUri(input: EditorInput): URI {
 		if (uri) {
 			let isValidUri: boolean = !!uri && !!uri.toString;
 
-			if (isValidUri && (hasFileExtension(sqlFileTypes, input, true) || hasSqlFileMode(input)) ) {
+			if (isValidUri && (hasFileExtension(sqlFileTypes, input, true) || hasSqlFileMode(input))) {
 				return uri;
 			}
 		}
@@ -120,7 +120,7 @@ function getQueryPlanEditorUri(input: EditorInput): URI {
 	// If this editor is not already of type queryinput
 	if (!(input instanceof QueryPlanInput)) {
 		let uri: URI = getSupportedInputResource(input);
-		if(uri) {
+		if (uri) {
 			if (hasFileExtension(sqlPlanFileTypes, input, false)) {
 				return uri;
 			}
@@ -136,7 +136,7 @@ function getQueryPlanEditorUri(input: EditorInput): URI {
  */
 function hasSqlFileMode(input: EditorInput): boolean {
 	if (input instanceof UntitledEditorInput) {
-		let untitledCast: UntitledEditorInput = <UntitledEditorInput> input;
+		let untitledCast: UntitledEditorInput = <UntitledEditorInput>input;
 		return untitledCast && (untitledCast.getModeId() === undefined || untitledCast.getModeId() === sqlModeId);
 	}
 

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

@@ -21,6 +21,8 @@ export const capabilitiesOptions = 'OPTIONS_METADATA';
 export const configMaxRecentConnections = 'maxRecentConnections';
 
 export const mssqlProviderName = 'MSSQL';
+export const anyProviderName = '*';
+export const connectionProviderContextKey = 'connectionProvider';
 
 export const applicationName = 'sqlops';
 

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

@@ -280,26 +280,23 @@ export class ConnectionDialogService implements IConnectionDialogService {
 
 		return new Promise<void>((resolve, reject) => {
 			// only create the provider maps first time the dialog gets called
-			let capabilitiesPromise: Promise<void> = Promise.resolve();
 			if (this._providerTypes.length === 0) {
 				entries(this._capabilitiesService.providers).forEach(p => {
 					this._providerTypes.push(p[1].connection.displayName);
 					this._providerNameToDisplayNameMap[p[0]] = p[1].connection.displayName;
 				});
 			}
-			capabilitiesPromise.then(s => {
-				this.updateModelServerCapabilities(model);
-				// If connecting from a query editor set "save connection" to false
-				if (params && params.input && params.connectionType === ConnectionType.editor) {
-					this._model.saveProfile = false;
-				}
+			this.updateModelServerCapabilities(model);
+			// If connecting from a query editor set "save connection" to false
+			if (params && params.input && params.connectionType === ConnectionType.editor) {
+				this._model.saveProfile = false;
+			}
 
-				resolve(this.showDialogWithModel().then(() => {
-					if (connectionResult && connectionResult.errorMessage) {
-						this.showErrorDialog(Severity.Error, this._connectionErrorTitle, connectionResult.errorMessage, connectionResult.callStack);
-					}
-				}));
-			}, e => reject(e));
+			resolve(this.showDialogWithModel().then(() => {
+				if (connectionResult && connectionResult.errorMessage) {
+					this.showErrorDialog(Severity.Error, this._connectionErrorTitle, connectionResult.errorMessage, connectionResult.callStack);
+				}
+			}));
 		});
 	}
 

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

@@ -172,7 +172,8 @@ export class ConnectionWidget {
 			strictSelection: false,
 			placeholder: this._defaultDatabaseName,
 			maxHeight: 125,
-			ariaLabel: databaseOption.displayName
+			ariaLabel: databaseOption.displayName,
+			actionLabel: localize('toggleDatabaseNameDropdown', 'Select Database Toggle Dropdown')
 		});
 
 		let serverGroupLabel = localize('serverGroup', 'Server group');

src/sql/parts/dashboard/common/dashboardHelper.ts

@@ -19,9 +19,9 @@ import { WEBVIEW_CONTAINER } from 'sql/parts/dashboard/containers/dashboardWebvi
 import { MODELVIEW_CONTAINER } from 'sql/parts/dashboard/containers/dashboardModelViewContainer.contribution';
 import { CONTROLHOST_CONTAINER } from 'sql/parts/dashboard/containers/dashboardControlHostContainer.contribution';
 import { NAV_SECTION } from 'sql/parts/dashboard/containers/dashboardNavSection.contribution';
-import { IDashboardContainerRegistry, Extensions as DashboardContainerExtensions, IDashboardContainer, registerContainerType } from 'sql/platform/dashboard/common/dashboardContainerRegistry';
-import { IDashboardTab } from 'sql/platform/dashboard/common/dashboardRegistry';
+import { IDashboardContainerRegistry, Extensions as DashboardContainerExtensions } from 'sql/platform/dashboard/common/dashboardContainerRegistry';
 import { SingleConnectionManagementService } from 'sql/services/common/commonServiceInterface.service';
+import * as Constants from 'sql/parts/connection/common/constants';
 
 const dashboardcontainerRegistry = Registry.as<IDashboardContainerRegistry>(DashboardContainerExtensions.dashboardContainerContributions);
 const containerTypes = [
@@ -136,13 +136,17 @@ export function addProvider<T extends { connectionManagementService: SingleConne
  */
 export function addEdition<T extends { connectionManagementService: SingleConnectionManagementService }>(config: WidgetConfig[], collection: DashboardServiceInterface): Array<WidgetConfig> {
 	let connectionInfo: ConnectionManagementInfo = collection.connectionManagementService.connectionInfo;
-	let edition = connectionInfo.serverInfo.engineEditionId;
-	return config.map((item) => {
-		if (item.edition === undefined) {
-			item.edition = edition;
-		}
-		return item;
-	});
+	if (connectionInfo.serverInfo) {
+		let edition = connectionInfo.serverInfo.engineEditionId;
+		return config.map((item) => {
+			if (item.edition === undefined) {
+				item.edition = edition;
+			}
+			return item;
+		});
+	} else {
+		return config;
+	}
 }
 
 /**
@@ -162,9 +166,11 @@ export function addContext(config: WidgetConfig[], collection: any, context: str
  * Returns a filtered version of the widgets passed based on edition and provider
  * @param config widgets to filter
  */
-export function filterConfigs<T extends { when?: string }, K extends { contextKeyService: IContextKeyService }>(config: T[], collection: K): Array<T> {
+export function filterConfigs<T extends { provider?: string | string[], when?: string }, K extends { contextKeyService: IContextKeyService }>(config: T[], collection: K): Array<T> {
 	return config.filter((item) => {
-		if (!item.when) {
+		if (!hasCompatibleProvider(item.provider, collection.contextKeyService)) {
+			return false;
+		} else if (!item.when) {
 			return true;
 		} else {
 			return collection.contextKeyService.contextMatchesRules(ContextKeyExpr.deserialize(item.when));
@@ -172,6 +178,21 @@ export function filterConfigs<T extends { when?: string }, K extends { contextKe
 	});
 }
 
+/**
+ * Check whether the listed providers contain '*' indicating any provider will do, or that they are a match
+ * for the currently scoped 'connectionProvider' context key.
+ */
+function hasCompatibleProvider(provider: string | string[], contextKeyService: IContextKeyService): boolean {
+	let isCompatible = true;
+	let connectionProvider = contextKeyService.getContextKeyValue<string>(Constants.connectionProviderContextKey);
+	if (connectionProvider) {
+		let providers = (provider instanceof Array) ? provider : [provider];
+		let matchingProvider = providers.find((p) => p === connectionProvider || p === Constants.anyProviderName);
+		isCompatible = (matchingProvider !== undefined);
+	}	// Else there's no connection context so skip the check
+	return isCompatible;
+}
+
 /**
  * Get registered container if it is specified as the key
  * @param container dashboard container

src/sql/parts/dashboard/common/dashboardPage.component.ts

@@ -17,11 +17,12 @@ import { IDashboardRegistry, Extensions as DashboardExtensions, IDashboardTab }
 import { PinUnpinTabAction, AddFeatureTabAction } from './actions';
 import { TabComponent, TabChild } from 'sql/base/browser/ui/panel/tab.component';
 import { AngularEventType, IAngularEventingService } from 'sql/services/angularEventing/angularEventingService';
-import { DashboardTab } from 'sql/parts/dashboard/common/interfaces';
+import { DashboardTab, IConfigModifierCollection } from 'sql/parts/dashboard/common/interfaces';
 import * as dashboardHelper from 'sql/parts/dashboard/common/dashboardHelper';
 import { WIDGETS_CONTAINER } from 'sql/parts/dashboard/containers/dashboardWidgetContainer.contribution';
 import { GRID_CONTAINER } from 'sql/parts/dashboard/containers/dashboardGridContainer.contribution';
 import { AngularDisposable } from 'sql/base/common/lifecycle';
+import * as Constants from 'sql/parts/connection/common/constants';
 
 import { Registry } from 'vs/platform/registry/common/platform';
 import * as types from 'vs/base/common/types';
@@ -38,16 +39,11 @@ import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
 
 const dashboardRegistry = Registry.as<IDashboardRegistry>(DashboardExtensions.DashboardContributions);
 
-interface IConfigModifierCollection {
-	connectionManagementService: SingleConnectionManagementService;
-	contextKeyService: IContextKeyService;
-}
-
 @Component({
 	selector: 'dashboard-page',
 	templateUrl: decodeURI(require.toUrl('sql/parts/dashboard/common/dashboardPage.component.html'))
 })
-export abstract class DashboardPage extends AngularDisposable {
+export abstract class DashboardPage extends AngularDisposable implements IConfigModifierCollection {
 
 	protected tabs: Array<TabConfig> = [];
 
@@ -137,22 +133,11 @@ export abstract class DashboardPage extends AngularDisposable {
 		this._tabsDispose.forEach(i => i.dispose());
 		this._tabsDispose = [];
 
-		// Create home tab
-		let homeTab: TabConfig = {
-			id: 'homeTab',
-			publisher: undefined,
-			title: this.homeTabTitle,
-			container: { 'widgets-container': homeWidgets },
-			context: this.context,
-			originalConfig: this._originalConfig,
-			editable: true,
-			canClose: false,
-			actions: []
-		};
-		this.addNewTab(homeTab);
-
 		let allTabs = dashboardHelper.filterConfigs(dashboardRegistry.tabs, this);
 
+		// Before separating tabs into pinned / shown, ensure that the home tab is always set up as expected
+		allTabs = this.setAndRemoveHomeTab(allTabs, homeWidgets);
+
 		// Load tab setting configs
 		this._tabSettingConfigs = this.dashboardService.getSettings<Array<TabSettingConfig>>([this.context, 'tabs'].join('.'));
 
@@ -199,6 +184,32 @@ export abstract class DashboardPage extends AngularDisposable {
 		}));
 	}
 
+	private setAndRemoveHomeTab(allTabs: IDashboardTab[], homeWidgets: WidgetConfig[]): IDashboardTab[] {
+		let homeTabConfig: TabConfig = {
+			id: 'homeTab',
+			provider: Constants.anyProviderName,
+			publisher: undefined,
+			title: this.homeTabTitle,
+			container: { 'widgets-container': homeWidgets },
+			context: this.context,
+			originalConfig: this._originalConfig,
+			editable: true,
+			canClose: false,
+			actions: []
+		};
+
+		let homeTabIndex = allTabs.findIndex((tab) => tab.isHomeTab === true);
+		if (homeTabIndex !== undefined && homeTabIndex > -1) {
+			// Have a tab: get its information and copy over to the home tab definition
+			let homeTab = allTabs.splice(homeTabIndex, 1)[0];
+			let tabConfig = this.initTabComponents(homeTab);
+			homeTabConfig.id = tabConfig.id;
+			homeTabConfig.container = tabConfig.container;
+		}
+		this.addNewTab(homeTabConfig);
+		return allTabs;
+	}
+
 	private rewriteConfig(): void {
 		let writeableConfig = objects.deepClone(this._tabSettingConfigs);
 
@@ -208,35 +219,12 @@ export abstract class DashboardPage extends AngularDisposable {
 
 	private loadNewTabs(dashboardTabs: IDashboardTab[], openLastTab: boolean = false) {
 		if (dashboardTabs && dashboardTabs.length > 0) {
-			let selectedTabs = dashboardTabs.map(v => {
-				let containerResult = dashboardHelper.getDashboardContainer(v.container);
-				if (!containerResult.result) {
-					return { id: v.id, title: v.title, container: { 'error-container': undefined }, alwaysShow: v.alwaysShow };
-				}
-
-				let key = Object.keys(containerResult.container)[0];
-				if (key === WIDGETS_CONTAINER || key === GRID_CONTAINER) {
-					let configs = <WidgetConfig[]>Object.values(containerResult.container)[0];
-					this._configModifiers.forEach(cb => {
-						configs = cb.apply(this, [configs, this.dashboardService, this.context]);
-					});
-					this._gridModifiers.forEach(cb => {
-						configs = cb.apply(this, [configs]);
-					});
-					if (key === WIDGETS_CONTAINER) {
-						return { id: v.id, title: v.title, container: { 'widgets-container': configs }, alwaysShow: v.alwaysShow };
-
-					} else {
-						return { id: v.id, title: v.title, container: { 'grid-container': configs }, alwaysShow: v.alwaysShow };
-					}
-				}
-				return { id: v.id, title: v.title, container: containerResult.container, alwaysShow: v.alwaysShow };
-			}).map(v => {
+			let selectedTabs = dashboardTabs.map(v => this.initTabComponents(v)).map(v => {
 				let actions = [];
-				let tabConfig = this._tabSettingConfigs.find(i => i.tabId === v.id);
+				let tabSettingConfig = this._tabSettingConfigs.find(i => i.tabId === v.id);
 				let isPinned = false;
-				if (tabConfig) {
-					isPinned = tabConfig.isPinned;
+				if (tabSettingConfig) {
+					isPinned = tabSettingConfig.isPinned;
 				} else if (v.alwaysShow) {
 					isPinned = true;
 				}
@@ -261,6 +249,30 @@ export abstract class DashboardPage extends AngularDisposable {
 		}
 	}
 
+	private initTabComponents(value: IDashboardTab): { id: string; title: string; container: object; alwaysShow: boolean; } {
+		let containerResult = dashboardHelper.getDashboardContainer(value.container);
+		if (!containerResult.result) {
+			return { id: value.id, title: value.title, container: { 'error-container': undefined }, alwaysShow: value.alwaysShow };
+		}
+		let key = Object.keys(containerResult.container)[0];
+		if (key === WIDGETS_CONTAINER || key === GRID_CONTAINER) {
+			let configs = <WidgetConfig[]>Object.values(containerResult.container)[0];
+			this._configModifiers.forEach(cb => {
+				configs = cb.apply(this, [configs, this, this.context]);
+			});
+			this._gridModifiers.forEach(cb => {
+				configs = cb.apply(this, [configs]);
+			});
+			if (key === WIDGETS_CONTAINER) {
+				return { id: value.id, title: value.title, container: { 'widgets-container': configs }, alwaysShow: value.alwaysShow };
+			}
+			else {
+				return { id: value.id, title: value.title, container: { 'grid-container': configs }, alwaysShow: value.alwaysShow };
+			}
+		}
+		return { id: value.id, title: value.title, container: containerResult.container, alwaysShow: value.alwaysShow };
+	}
+
 	private getContentType(tab: TabConfig): string {
 		return tab.container ? Object.keys(tab.container)[0] : '';
 	}

src/sql/parts/dashboard/common/dashboardPanelStyles.ts

@@ -5,8 +5,11 @@
 import 'vs/css!./dashboardPanel';
 
 import { registerThemingParticipant, ITheme, ICssStyleCollector } from 'vs/platform/theme/common/themeService';
-import { TAB_ACTIVE_BACKGROUND, TAB_ACTIVE_FOREGROUND, TAB_ACTIVE_BORDER, TAB_INACTIVE_BACKGROUND, TAB_INACTIVE_FOREGROUND, EDITOR_GROUP_HEADER_TABS_BACKGROUND, TAB_BORDER } from 'vs/workbench/common/theme';
-import { activeContrastBorder, focusBorder } from 'vs/platform/theme/common/colorRegistry';
+import {
+	TAB_ACTIVE_BACKGROUND, TAB_ACTIVE_FOREGROUND, TAB_ACTIVE_BORDER, TAB_INACTIVE_BACKGROUND,
+	TAB_INACTIVE_FOREGROUND, EDITOR_GROUP_HEADER_TABS_BACKGROUND, TAB_BORDER, EDITOR_GROUP_BORDER
+} from 'vs/workbench/common/theme';
+import { activeContrastBorder } from 'vs/platform/theme/common/colorRegistry';
 
 registerThemingParticipant((theme: ITheme, collector: ICssStyleCollector) => {
 
@@ -98,4 +101,14 @@ registerThemingParticipant((theme: ITheme, collector: ICssStyleCollector) => {
 			}
 		`);
 	}
+
+	const divider = theme.getColor(EDITOR_GROUP_BORDER);
+	if (divider) {
+		collector.addRule(`
+			panel.dashboard-panel > .tabbedPanel > .title .tabList .tab-header {
+				border-right-width: 1px;
+				border-right-style: solid;
+			}
+		`);
+	}
 });

src/sql/parts/dashboard/common/dashboardTab.contribution.ts

@@ -7,6 +7,7 @@ import { IJSONSchema } from 'vs/base/common/jsonSchema';
 import { localize } from 'vs/nls';
 import * as types from 'vs/base/common/types';
 
+import * as Constants from 'sql/parts/connection/common/constants';
 import { registerTab } from 'sql/platform/dashboard/common/dashboardRegistry';
 import { generateContainerTypeSchemaProperties } from 'sql/platform/dashboard/common/dashboardContainerRegistry';
 import { NAV_SECTION, validateNavSectionContributionAndRegisterIcon } from 'sql/parts/dashboard/containers/dashboardNavSection.contribution';
@@ -17,9 +18,11 @@ export interface IDashboardTabContrib {
 	id: string;
 	title: string;
 	container: object;
+	provider: string | string[];
 	when?: string;
 	description?: string;
 	alwaysShow?: boolean;
+	isHomeTab?: boolean;
 }
 
 const tabSchema: IJSONSchema = {
@@ -41,6 +44,11 @@ const tabSchema: IJSONSchema = {
 			description: localize('sqlops.extension.contributes.tab.when', 'Condition which must be true to show this item'),
 			type: 'string'
 		},
+		provider: {
+			description: localize('sqlops.extension.contributes.tab.provider', 'Defines the connection types this tab is compatible with. Defaults to "MSSQL" if not set'),
+			type: ['string', 'array']
+
+		},
 		container: {
 			description: localize('sqlops.extension.contributes.dashboard.tab.container', "The container that will be displayed in this tab."),
 			type: 'object',
@@ -49,6 +57,10 @@ const tabSchema: IJSONSchema = {
 		alwaysShow: {
 			description: localize('sqlops.extension.contributes.dashboard.tab.alwaysShow', "Whether or not this tab should always be shown or only when the user adds it."),
 			type: 'boolean'
+		},
+		isHomeTab: {
+			description: localize('sqlops.extension.contributes.dashboard.tab.isHomeTab', "Whether or not this tab should be used as the Home tab for a connection type."),
+			type: 'boolean'
 		}
 	}
 };
@@ -67,7 +79,7 @@ const tabContributionSchema: IJSONSchema = {
 ExtensionsRegistry.registerExtensionPoint<IDashboardTabContrib | IDashboardTabContrib[]>('dashboard.tabs', [], tabContributionSchema).setHandler(extensions => {
 
 	function handleCommand(tab: IDashboardTabContrib, extension: IExtensionPointUser<any>) {
-		let { description, container, title, when, id, alwaysShow } = tab;
+		let { description, container, provider, title, when, id, alwaysShow, isHomeTab } = tab;
 
 		// If always show is not specified, set it to true by default.
 		if (!types.isBoolean(alwaysShow)) {
@@ -88,6 +100,13 @@ ExtensionsRegistry.registerExtensionPoint<IDashboardTabContrib | IDashboardTabCo
 			return;
 		}
 
+		if (!provider) {
+			// Use a default. Consider warning extension developers about this in the future if in development mode
+			provider = Constants.mssqlProviderName;
+			// Cannot be a home tab if it did not specify a provider
+			isHomeTab = false;
+		}
+
 		if (Object.keys(container).length !== 1) {
 			extension.collector.error(localize('dashboardTab.contribution.moreThanOneDashboardContainersError', 'Exactly 1 dashboard container must be defined per space'));
 			return;
@@ -110,7 +129,7 @@ ExtensionsRegistry.registerExtensionPoint<IDashboardTabContrib | IDashboardTabCo
 		}
 
 		if (result) {
-			registerTab({ description, title, container, when, id, alwaysShow, publisher });
+			registerTab({ description, title, container, provider, when, id, alwaysShow, publisher, isHomeTab });
 		}
 	}
 

src/sql/parts/dashboard/common/interfaces.ts

@@ -7,9 +7,11 @@ import { OnDestroy } from '@angular/core';
 
 import { Event } from 'vs/base/common/event';
 import { IDisposable, dispose } from 'vs/base/common/lifecycle';
+import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
 
 import { AngularDisposable } from 'sql/base/common/lifecycle';
 import { TabChild } from 'sql/base/browser/ui/panel/tab.component';
+import { SingleConnectionManagementService } from 'sql/services/common/commonServiceInterface.service';
 
 export enum Conditional {
 	'equals',
@@ -50,3 +52,8 @@ export abstract class DashboardTab extends TabChild implements OnDestroy {
 		this.dispose();
 	}
 }
+
+export interface IConfigModifierCollection {
+	connectionManagementService: SingleConnectionManagementService;
+	contextKeyService: IContextKeyService;
+}

src/sql/parts/dashboard/containers/dashboardNavSection.component.ts

@@ -5,28 +5,27 @@
 
 import 'vs/css!./dashboardNavSection';
 
-import { Component, Inject, Input, forwardRef, ViewChild, ElementRef, ViewChildren, QueryList, OnDestroy, ChangeDetectorRef, EventEmitter, OnChanges, AfterContentInit } from '@angular/core';
+import { Component, Inject, Input, forwardRef, ViewChild, ElementRef, ViewChildren, QueryList, OnDestroy, ChangeDetectorRef, OnChanges, AfterContentInit } from '@angular/core';
 
-import { DashboardServiceInterface } from 'sql/parts/dashboard/services/dashboardServiceInterface.service';
-import { CommonServiceInterface } from 'sql/services/common/commonServiceInterface.service';
+import { CommonServiceInterface, SingleConnectionManagementService } from 'sql/services/common/commonServiceInterface.service';
 import { WidgetConfig, TabConfig, NavSectionConfig } from 'sql/parts/dashboard/common/dashboardWidget';
 import { PanelComponent, IPanelOptions, NavigationBarLayout } from 'sql/base/browser/ui/panel/panel.component';
-import { TabComponent, TabChild } from 'sql/base/browser/ui/panel/tab.component';
-import { DashboardTab } from 'sql/parts/dashboard/common/interfaces';
+import { TabChild } from 'sql/base/browser/ui/panel/tab.component';
+import { DashboardTab, IConfigModifierCollection } from 'sql/parts/dashboard/common/interfaces';
 import { WIDGETS_CONTAINER } from 'sql/parts/dashboard/containers/dashboardWidgetContainer.contribution';
 import { GRID_CONTAINER } from 'sql/parts/dashboard/containers/dashboardGridContainer.contribution';
 import * as dashboardHelper from 'sql/parts/dashboard/common/dashboardHelper';
 
-import { Registry } from 'vs/platform/registry/common/platform';
 import { Event, Emitter } from 'vs/base/common/event';
 import * as nls from 'vs/nls';
+import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
 
 @Component({
 	selector: 'dashboard-nav-section',
 	providers: [{ provide: TabChild, useExisting: forwardRef(() => DashboardNavSection) }],
 	templateUrl: decodeURI(require.toUrl('sql/parts/dashboard/containers/dashboardNavSection.component.html'))
 })
-export class DashboardNavSection extends DashboardTab implements OnDestroy, OnChanges, AfterContentInit {
+export class DashboardNavSection extends DashboardTab implements OnDestroy, OnChanges, AfterContentInit, IConfigModifierCollection {
 	@Input() private tab: TabConfig;
 	protected tabs: Array<TabConfig> = [];
 	private _onResize = new Emitter<void>();
@@ -38,7 +37,7 @@ export class DashboardNavSection extends DashboardTab implements OnDestroy, OnCh
 	};
 
 	// a set of config modifiers
-	private readonly _configModifiers: Array<(item: Array<WidgetConfig>, dashboardServer: DashboardServiceInterface, context: string) => Array<WidgetConfig>> = [
+	private readonly _configModifiers: Array<(item: Array<WidgetConfig>, collection: IConfigModifierCollection, context: string) => Array<WidgetConfig>> = [
 		dashboardHelper.removeEmpty,
 		dashboardHelper.initExtensionConfigs,
 		dashboardHelper.addProvider,
@@ -103,7 +102,7 @@ export class DashboardNavSection extends DashboardTab implements OnDestroy, OnCh
 				if (key === WIDGETS_CONTAINER || key === GRID_CONTAINER) {
 					let configs = <WidgetConfig[]>Object.values(containerResult.container)[0];
 					this._configModifiers.forEach(cb => {
-						configs = cb.apply(this, [configs, this.dashboardService, this.tab.context]);
+						configs = cb.apply(this, [configs, this, this.tab.context]);
 					});
 					this._gridModifiers.forEach(cb => {
 						configs = cb.apply(this, [configs]);
@@ -169,4 +168,12 @@ export class DashboardNavSection extends DashboardTab implements OnDestroy, OnCh
 			});
 		}
 	}
+
+	public get connectionManagementService(): SingleConnectionManagementService {
+		return this.dashboardService.connectionManagementService;
+	}
+
+	public get contextKeyService(): IContextKeyService {
+		return this.dashboardService.scopedContextKeyService;
+	}
 }

src/sql/parts/dashboard/dashboard.module.ts

@@ -3,7 +3,7 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { Inject, NgModule, forwardRef, ApplicationRef, ComponentFactoryResolver, NgModuleRef, NgModuleFactory } from '@angular/core';
+import { Inject, NgModule, forwardRef, ApplicationRef, ComponentFactoryResolver } from '@angular/core';
 import { CommonModule, APP_BASE_HREF } from '@angular/common';
 import { BrowserModule } from '@angular/platform-browser';
 import { RouterModule, Routes, UrlSerializer, Router, NavigationEnd } from '@angular/router';
@@ -14,7 +14,7 @@ import { ChartsModule } from 'ng2-charts/ng2-charts';
 import CustomUrlSerializer from 'sql/common/urlSerializer';
 import { Extensions, IInsightRegistry } from 'sql/platform/dashboard/common/insightRegistry';
 import { Extensions as ComponentExtensions, IComponentRegistry } from 'sql/platform/dashboard/common/modelComponentRegistry';
-import { IBootstrapParams } from 'sql/services/bootstrap/bootstrapService';
+import { IBootstrapParams, ISelector, providerIterator } from 'sql/services/bootstrap/bootstrapService';
 
 import { Registry } from 'vs/platform/registry/common/platform';
 
@@ -32,7 +32,7 @@ import { CommonServiceInterface } from 'sql/services/common/commonServiceInterfa
 import { ComponentHostDirective } from 'sql/parts/dashboard/common/componentHost.directive';
 
 /* Base Components */
-import { DashboardComponent, DASHBOARD_SELECTOR } from 'sql/parts/dashboard/dashboard.component';
+import { DashboardComponent } from 'sql/parts/dashboard/dashboard.component';
 import { DashboardWidgetWrapper } from 'sql/parts/dashboard/contents/dashboardWidgetWrapper.component';
 import { DashboardWidgetContainer } from 'sql/parts/dashboard/containers/dashboardWidgetContainer.component';
 import { DashboardGridContainer } from 'sql/parts/dashboard/containers/dashboardGridContainer.component';
@@ -51,7 +51,10 @@ import { ControlHostContent } from 'sql/parts/dashboard/contents/controlHostCont
 import { DashboardControlHostContainer } from 'sql/parts/dashboard/containers/dashboardControlHostContainer.component';
 import { JobsViewComponent } from 'sql/parts/jobManagement/views/jobsView.component';
 import { AgentViewComponent } from 'sql/parts/jobManagement/agent/agentView.component';
+import { AlertsViewComponent } from 'sql/parts/jobManagement/views/alertsView.component';
 import { JobHistoryComponent } from 'sql/parts/jobManagement/views/jobHistory.component';
+import { OperatorsViewComponent } from 'sql/parts/jobManagement/views/operatorsView.component';
+import { ProxiesViewComponent } from 'sql/parts/jobManagement/views/proxiesView.component';
 import { Checkbox } from 'sql/base/browser/ui/checkbox/checkbox.component';
 import { SelectBox } from 'sql/base/browser/ui/selectBox/selectBox.component';
 import { InputBox } from 'sql/base/browser/ui/inputBox/inputBox.component';
@@ -59,9 +62,8 @@ import { InputBox } from 'sql/base/browser/ui/inputBox/inputBox.component';
 let baseComponents = [DashboardHomeContainer, DashboardComponent, DashboardWidgetWrapper, DashboardWebviewContainer,
 	DashboardWidgetContainer, DashboardGridContainer, DashboardErrorContainer, DashboardNavSection, ModelViewContent, WebviewContent, WidgetContent,
 	ComponentHostDirective, BreadcrumbComponent, ControlHostContent, DashboardControlHostContainer,
-	JobsViewComponent, AgentViewComponent, JobHistoryComponent, JobStepsViewComponent, DashboardModelViewContainer, ModelComponentWrapper, Checkbox,
-	SelectBox,
-	InputBox,];
+	JobsViewComponent, AgentViewComponent, JobHistoryComponent, JobStepsViewComponent, AlertsViewComponent, ProxiesViewComponent, OperatorsViewComponent,
+	DashboardModelViewContainer, ModelComponentWrapper, Checkbox, SelectBox, InputBox,];
 
 /* Panel */
 import { PanelModule } from 'sql/base/browser/ui/panel/panel.module';
@@ -80,7 +82,8 @@ import { ExplorerWidget } from 'sql/parts/dashboard/widgets/explorer/explorerWid
 import { TasksWidget } from 'sql/parts/dashboard/widgets/tasks/tasksWidget.component';
 import { InsightsWidget } from 'sql/parts/dashboard/widgets/insights/insightsWidget.component';
 import { WebviewWidget } from 'sql/parts/dashboard/widgets/webview/webviewWidget.component';
-import { JobStepsViewComponent } from '../jobManagement/views/jobStepsView.component';
+import { JobStepsViewComponent } from 'sql/parts/jobManagement/views/jobStepsView.component';
+import { IInstantiationService, _util } from 'vs/platform/instantiation/common/instantiation';
 
 let widgetComponents = [
 	PropertiesWidgetComponent,
@@ -109,7 +112,7 @@ const appRoutes: Routes = [
 ];
 
 // Connection Dashboard main angular module
-export const DashboardModule = (params, selector: string): any => {
+export const DashboardModule = (params, selector: string, instantiationService: IInstantiationService): any => {
 	@NgModule({
 		declarations: [
 			...baseComponents,
@@ -140,31 +143,31 @@ export const DashboardModule = (params, selector: string): any => {
 			{ provide: IBreadcrumbService, useClass: BreadcrumbService },
 			{ provide: CommonServiceInterface, useClass: DashboardServiceInterface },
 			{ provide: UrlSerializer, useClass: CustomUrlSerializer },
-			{ provide: IBootstrapParams, useValue: params }
+			{ provide: IBootstrapParams, useValue: params },
+			{ provide: ISelector, useValue: selector },
+			...providerIterator(instantiationService)
 		]
 	})
 	class ModuleClass {
-		private _bootstrap: DashboardServiceInterface;
+		private navigations = 0;
 		constructor(
 			@Inject(forwardRef(() => ComponentFactoryResolver)) private _resolver: ComponentFactoryResolver,
-			@Inject(forwardRef(() => CommonServiceInterface)) bootstrap: CommonServiceInterface,
 			@Inject(forwardRef(() => Router)) private _router: Router,
-			@Inject(ITelemetryService) private telemetryService: ITelemetryService
+			@Inject(ITelemetryService) private telemetryService: ITelemetryService,
+			@Inject(ISelector) private selector: string
 		) {
-			this._bootstrap = bootstrap as DashboardServiceInterface;
 		}
 
 		ngDoBootstrap(appRef: ApplicationRef) {
 			const factory = this._resolver.resolveComponentFactory(DashboardComponent);
-			this._bootstrap.selector = selector;
-			(<any>factory).factory.selector = selector;
+			(<any>factory).factory.selector = this.selector;
 			appRef.bootstrap(factory);
 
 			this._router.events.subscribe(e => {
 				if (e instanceof NavigationEnd) {
-					this._bootstrap.handlePageNavigation();
+					this.navigations++;
 					TelemetryUtils.addTelemetry(this.telemetryService, TelemetryKeys.DashboardNavigated, {
-						numberOfNavigations: this._bootstrap.getNumberOfPageNavigations(),
+						numberOfNavigations: this.navigations,
 						routeUrl: e.url
 					});
 				}

src/sql/parts/dashboard/pages/serverDashboardPage.contribution.ts

@@ -96,16 +96,12 @@ let defaultVal = [
 	},
 	{
 		widget: {
-			'backup-history-server-insight': {
-				cacheId: '0c7cba8b-c87a-4bcc-ae54-2f40a5503a90'
-			}
+			'backup-history-server-insight': null
 		}
 	},
 	{
 		widget: {
-			'all-database-size-server-insight': {
-				cacheId: '1d7cba8b-c87a-4bcc-ae54-2f40a5503a90'
-			}
+			'all-database-size-server-insight': null
 		}
 	}
 ];
@@ -121,8 +117,7 @@ export const serverDashboardTabsSchema: IJSONSchema = {
 	type: ['array'],
 	description: nls.localize('dashboardServerTabs', 'Customizes the Server dashboard tabs'),
 	items: generateDashboardTabSchema('server'),
-	default: [
-	]
+	default: []
 };
 
 export const SERVER_DASHBOARD_SETTING = 'dashboard.server.widgets';

src/sql/parts/dashboard/services/dashboardServiceInterface.service.ts

@@ -4,50 +4,29 @@
  *--------------------------------------------------------------------------------------------*/
 
 /* Node Modules */
-import { Injectable, Inject, forwardRef, OnDestroy } from '@angular/core';
+import { Injectable, Inject, forwardRef } from '@angular/core';
 import { Router } from '@angular/router';
-import { Observable } from 'rxjs/Observable';
 
 /* SQL imports */
 import { IDashboardComponentParams } from 'sql/services/bootstrap/bootstrapParams';
 import { IBootstrapParams } from 'sql/services/bootstrap/bootstrapService';
 import { IMetadataService } from 'sql/services/metadata/metadataService';
 import { IConnectionManagementService } from 'sql/parts/connection/common/connectionManagement';
-import { ConnectionManagementInfo } from 'sql/parts/connection/common/connectionManagementInfo';
 import { IAdminService } from 'sql/parts/admin/common/adminService';
 import { IQueryManagementService } from 'sql/parts/query/common/queryManagement';
 import { toDisposableSubscription } from 'sql/parts/common/rxjsUtils';
-import { IInsightsDialogService } from 'sql/parts/insights/common/interfaces';
-import { ICapabilitiesService } from 'sql/services/capabilities/capabilitiesService';
-import { IConnectionProfile } from 'sql/parts/connection/common/interfaces';
 import { AngularEventType, IAngularEvent, IAngularEventingService } from 'sql/services/angularEventing/angularEventingService';
 import { IDashboardTab } from 'sql/platform/dashboard/common/dashboardRegistry';
 import { TabSettingConfig } from 'sql/parts/dashboard/common/dashboardWidget';
-import { IDashboardViewService } from 'sql/services/dashboard/common/dashboardViewService';
-import { AngularDisposable } from 'sql/base/common/lifecycle';
-import { ConnectionContextkey } from 'sql/parts/connection/common/connectionContextKey';
-import { SingleConnectionMetadataService, SingleConnectionManagementService, SingleAdminService, SingleQueryManagementService, CommonServiceInterface }
-from 'sql/services/common/commonServiceInterface.service';
-
-import { ProviderMetadata, DatabaseInfo, SimpleExecuteResult } from 'sqlops';
+import { CommonServiceInterface } from 'sql/services/common/commonServiceInterface.service';
 
 /* VS imports */
-import { IWorkbenchThemeService } from 'vs/workbench/services/themes/common/workbenchThemeService';
-import { IContextMenuService, IContextViewService } from 'vs/platform/contextview/browser/contextView';
-import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
-import { IDisposable } from 'vs/base/common/lifecycle';
 import { IConfigurationService, ConfigurationTarget } from 'vs/platform/configuration/common/configuration';
-import { ConfigurationEditingService, IConfigurationValue } from 'vs/workbench/services/configuration/node/configurationEditingService';
-import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace';
-import { IStorageService } from 'vs/platform/storage/common/storage';
 import { Event, Emitter } from 'vs/base/common/event';
 import Severity from 'vs/base/common/severity';
 import * as nls from 'vs/nls';
-import { IPartService } from 'vs/workbench/services/part/common/partService';
 import { deepClone } from 'vs/base/common/objects';
-import { ICommandService } from 'vs/platform/commands/common/commands';
-import { IContextKeyService, RawContextKey, IContextKey } from 'vs/platform/contextkey/common/contextkey';
-import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+import { RawContextKey, IContextKey } from 'vs/platform/contextkey/common/contextkey';
 import { INotificationService } from 'vs/platform/notification/common/notification';
 
 const DASHBOARD_SETTINGS = 'dashboard';
@@ -85,45 +64,22 @@ export class DashboardServiceInterface extends CommonServiceInterface {
 	private _numberOfPageNavigations = 0;
 
 	constructor(
-		@Inject(forwardRef(() => Router)) private _router: Router,
-		@Inject(INotificationService) private _notificationService: INotificationService,
 		@Inject(IMetadataService) metadataService: IMetadataService,
 		@Inject(IConnectionManagementService) connectionManagementService: IConnectionManagementService,
 		@Inject(IAdminService) adminService: IAdminService,
 		@Inject(IQueryManagementService) queryManagementService: IQueryManagementService,
+		@Inject(IBootstrapParams) params: IDashboardComponentParams,
+		@Inject(forwardRef(() => Router)) private _router: Router,
+		@Inject(INotificationService) private _notificationService: INotificationService,
 		@Inject(IAngularEventingService) private angularEventingService: IAngularEventingService,
-		@Inject(IConfigurationService) private _configService: IConfigurationService,
-		@Inject(IBootstrapParams) _params: IDashboardComponentParams
+		@Inject(IConfigurationService) private _configService: IConfigurationService
 	) {
-		super(_params, metadataService, connectionManagementService, adminService, queryManagementService);
-	}
-
-	private get params(): IDashboardComponentParams {
-		return this._params;
-	}
-
-	/**
-	 * Set the selector for this dashboard instance, should only be set once
-	 */
-	public set selector(selector: string) {
-		this._uniqueSelector = selector;
-		this._getbootstrapParams();
-	}
-
-	protected _getbootstrapParams(): void {
-		this.scopedContextKeyService = this.params.scopedContextService;
-		this._connectionContextKey = this.params.connectionContextKey;
-		this.dashboardContextKey = this._dashboardContextKey.bindTo(this.scopedContextKeyService);
-		this.uri = this.params.ownerUri;
-	}
-
-	/**
-	 * Set the uri for this dashboard instance, should only be set once
-	 * Inits all the services that depend on knowing a uri
-	 */
-	protected set uri(uri: string) {
-		super.setUri(uri);
-		this._register(toDisposableSubscription(this.angularEventingService.onAngularEvent(this._uri, (event) => this.handleDashboardEvent(event))));
+		super(params, metadataService, connectionManagementService, adminService, queryManagementService);
+		// during testing there may not be params
+		if (this._params) {
+			this.dashboardContextKey = this._dashboardContextKey.bindTo(this.scopedContextKeyService);
+			this._register(toDisposableSubscription(this.angularEventingService.onAngularEvent(this._uri, (event) => this.handleDashboardEvent(event))));
+		}
 	}
 
 	/**

src/sql/parts/dashboard/widgets/explorer/explorerWidget.component.ts

@@ -28,6 +28,7 @@ import { IContextViewService, IContextMenuService } from 'vs/platform/contextvie
 import { IWorkbenchThemeService } from 'vs/workbench/services/themes/common/workbenchThemeService';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { IProgressService } from 'vs/platform/progress/common/progress';
+import * as types from 'vs/base/common/types';
 
 @Component({
 	selector: 'explorer-widget',
@@ -120,6 +121,8 @@ export class ExplorerWidget extends DashboardWidget implements IDashboardWidget,
 			let currentProfile = this._bootstrap.connectionManagementService.connectionInfo.connectionProfile;
 			this._register(toDisposableSubscription(this._bootstrap.metadataService.databaseNames.subscribe(
 				data => {
+					// Handle the case where there is no metadata service
+					data = data || [];
 					let profileData = data.map(d => {
 						let profile = new ConnectionProfile(this.capabilitiesService, currentProfile);
 						profile.databaseName = d;

src/sql/parts/dashboard/widgets/tasks/tasksWidget.component.ts

@@ -166,7 +166,6 @@ export class TasksWidget extends DashboardWidget implements IDashboardWidget, On
 	}
 
 	public runTask(task: ICommandAction) {
-		let serverInfo = this._bootstrap.connectionManagementService.connectionInfo.serverInfo;
 		this.commandService.executeCommand(task.id, this._profile);
 	}
 

src/sql/parts/disasterRecovery/backup/backup.module.ts

@@ -4,20 +4,23 @@
 *--------------------------------------------------------------------------------------------*/
 
 import {
-	ApplicationRef, ComponentFactoryResolver, ModuleWithProviders, NgModule,
+	ApplicationRef, ComponentFactoryResolver, NgModule,
 	Inject, forwardRef, Type
 } from '@angular/core';
 import { APP_BASE_HREF, CommonModule } from '@angular/common';
 import { FormsModule } from '@angular/forms';
 import { BrowserModule } from '@angular/platform-browser';
-import { IBootstrapParams } from 'sql/services/bootstrap/bootstrapService';
-import { BackupComponent, BACKUP_SELECTOR } from 'sql/parts/disasterRecovery/backup/backup.component';
+
+import { IBootstrapParams, ISelector, providerIterator } from 'sql/services/bootstrap/bootstrapService';
+import { BackupComponent } from 'sql/parts/disasterRecovery/backup/backup.component';
+
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 
 // work around
 const BrowserAnimationsModule = (<any>require.__$__nodeRequire('@angular/platform-browser/animations')).BrowserAnimationsModule;
 
 // Backup wizard main angular module
-export const BackupModule = (params: IBootstrapParams, selector: string): Type<any> => {
+export const BackupModule = (params: IBootstrapParams, selector: string, instantiationService: IInstantiationService): Type<any> => {
 	@NgModule({
 		declarations: [
 			BackupComponent
@@ -31,19 +34,22 @@ export const BackupModule = (params: IBootstrapParams, selector: string): Type<a
 		],
 		providers: [
 			{ provide: APP_BASE_HREF, useValue: '/' },
-			{ provide: IBootstrapParams, useValue: params }
+			{ provide: IBootstrapParams, useValue: params },
+			{ provide: ISelector, useValue: selector },
+			...providerIterator(instantiationService)
 		]
 	})
 	class ModuleClass {
 
 		constructor(
-			@Inject(forwardRef(() => ComponentFactoryResolver)) private _resolver: ComponentFactoryResolver
+			@Inject(forwardRef(() => ComponentFactoryResolver)) private _resolver: ComponentFactoryResolver,
+			@Inject(ISelector) private selector: string
 		) {
 		}
 
 		ngDoBootstrap(appRef: ApplicationRef) {
 			const factory = this._resolver.resolveComponentFactory(BackupComponent);
-			(<any>factory).factory.selector = selector;
+			(<any>factory).factory.selector = this.selector;
 			appRef.bootstrap(factory);
 		}
 	}

src/sql/parts/disasterRecovery/restore/restoreDialog.ts

@@ -235,7 +235,8 @@ export class RestoreDialog extends Modal {
 					this._databaseDropdown = new Dropdown(inputCellContainer.getHTMLElement(), this._contextViewService, this._themeService,
 						{
 							strictSelection: false,
-							ariaLabel: LocalizedStrings.TARGETDATABASE
+							ariaLabel: LocalizedStrings.TARGETDATABASE,
+							actionLabel: localize('toggleDatabaseNameDropdown', 'Select Database Toggle Dropdown')
 						}
 					);
 					this._databaseDropdown.onValueChange(s => {

src/sql/parts/fileBrowser/fileBrowserTreeView.ts

@@ -23,7 +23,7 @@ import { ITree } from 'vs/base/parts/tree/browser/tree';
 /**
  * Implements tree view for file browser
  */
-export class FileBrowserTreeView {
+export class FileBrowserTreeView implements IDisposable {
 	private _tree: ITree;
 	private _toDispose: IDisposable[] = [];
 

src/sql/parts/grid/services/sharedServices.ts

@@ -3,7 +3,7 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import * as Strings from 'vs/base/common/strings';
+import { escape } from 'sql/base/common/strings';
 
 export class DBCellValue {
 	displayValue: string;
@@ -25,7 +25,7 @@ export function hyperLinkFormatter(row: number, cell: any, value: any, columnDef
 		valueToDisplay = 'NULL';
 		if (!value.isNull) {
 			cellClasses += ' xmlLink';
-			valueToDisplay = Strings.escape(value.displayValue);
+			valueToDisplay = escape(value.displayValue);
 			return `<a class="${cellClasses}" href="#" >${valueToDisplay}</a>`;
 		} else {
 			cellClasses += ' missing-value';
@@ -44,12 +44,12 @@ export function textFormatter(row: number, cell: any, value: any, columnDef: any
 	if (DBCellValue.isDBCellValue(value)) {
 		valueToDisplay = 'NULL';
 		if (!value.isNull) {
-			valueToDisplay = Strings.escape(value.displayValue.replace(/(\r\n|\n|\r)/g, ' '));
+			valueToDisplay = escape(value.displayValue.replace(/(\r\n|\n|\r)/g, ' '));
 		} else {
 			cellClasses += ' missing-value';
 		}
 	} else if (typeof value === 'string') {
-		valueToDisplay = Strings.escape(value);
+		valueToDisplay = escape(value);
 	}
 
 	return `<span title="${valueToDisplay}" class="${cellClasses}">${valueToDisplay}</span>`;

src/sql/parts/grid/views/editData/editData.module.ts

@@ -7,12 +7,14 @@
 import { ApplicationRef, ComponentFactoryResolver, NgModule, Inject, forwardRef, Type } from '@angular/core';
 import { CommonModule } from '@angular/common';
 import { BrowserModule } from '@angular/platform-browser';
-
-import { EditDataComponent, EDITDATA_SELECTOR } from 'sql/parts/grid/views/editData/editData.component';
 import { SlickGrid } from 'angular2-slickgrid';
-import { IBootstrapParams } from 'sql/services/bootstrap/bootstrapService';
 
-export const EditDataModule = (params: IBootstrapParams, selector: string): Type<any> => {
+import { EditDataComponent } from 'sql/parts/grid/views/editData/editData.component';
+import { IBootstrapParams, ISelector, providerIterator } from 'sql/services/bootstrap/bootstrapService';
+
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+
+export const EditDataModule = (params: IBootstrapParams, selector: string, instantiationService: IInstantiationService): Type<any> => {
 
 	@NgModule({
 
@@ -30,19 +32,22 @@ export const EditDataModule = (params: IBootstrapParams, selector: string): Type
 			EditDataComponent
 		],
 		providers: [
-			{ provide: IBootstrapParams, useValue: params }
+			{ provide: IBootstrapParams, useValue: params },
+			{ provide: ISelector, useValue: selector },
+			...providerIterator(instantiationService)
 		]
 	})
 	class ModuleClass {
 
 		constructor(
-			@Inject(forwardRef(() => ComponentFactoryResolver)) private _resolver: ComponentFactoryResolver
+			@Inject(forwardRef(() => ComponentFactoryResolver)) private _resolver: ComponentFactoryResolver,
+			@Inject(ISelector) private selector: string
 		) {
 		}
 
 		ngDoBootstrap(appRef: ApplicationRef) {
 			const factory = this._resolver.resolveComponentFactory(EditDataComponent);
-			(<any>factory).factory.selector = selector;
+			(<any>factory).factory.selector = this.selector;
 			appRef.bootstrap(factory);
 		}
 	}

src/sql/parts/grid/views/query/chartViewer.component.ts

@@ -5,13 +5,12 @@
 import 'vs/css!sql/parts/grid/views/query/chartViewer';
 
 import {
-	Component, Inject, ViewContainerRef, forwardRef, OnInit,
-	ComponentFactoryResolver, ViewChild, OnDestroy, Input, ElementRef, ChangeDetectorRef
+	Component, Inject, forwardRef, OnInit, ComponentFactoryResolver, ViewChild,
+	OnDestroy, Input, ElementRef, ChangeDetectorRef
 } from '@angular/core';
 import { NgGridItemConfig } from 'angular2-grid';
 
 import { Taskbar } from 'sql/base/browser/ui/taskbar/taskbar';
-import { Checkbox } from 'sql/base/browser/ui/checkbox/checkbox';
 import { ComponentHostDirective } from 'sql/parts/dashboard/common/componentHost.directive';
 import { IGridDataSet } from 'sql/parts/grid/common/interfaces';
 import { IInsightData, IInsightsView, IInsightsConfig } from 'sql/parts/dashboard/widgets/insights/interfaces';
@@ -32,7 +31,6 @@ import {
 } from 'sql/parts/dashboard/widgets/insights/views/charts/chartInsight.component';
 
 import { IDisposable } from 'vs/base/common/lifecycle';
-import { attachSelectBoxStyler } from 'vs/platform/theme/common/styler';
 import Severity from 'vs/base/common/severity';
 import URI from 'vs/base/common/uri';
 import * as nls from 'vs/nls';
@@ -87,21 +85,17 @@ export class ChartViewerComponent implements OnInit, OnDestroy, IChartViewAction
 	private _saveAction: SaveImageAction;
 	private _chartConfig: ILineConfig;
 	private _disposables: Array<IDisposable> = [];
-	private _dataSet: IGridDataSet;
 	private _executeResult: IInsightData;
 	private _chartComponent: ChartInsight;
 
-	private localizedStrings = LocalizedStrings;
-	private insightRegistry = insightRegistry;
+	protected localizedStrings = LocalizedStrings;
+	protected insightRegistry = insightRegistry;
 
 	@ViewChild(ComponentHostDirective) private componentHost: ComponentHostDirective;
 	@ViewChild('taskbarContainer', { read: ElementRef }) private taskbarContainer;
-	@ViewChild('chartTypesContainer', { read: ElementRef }) private chartTypesElement;
-	@ViewChild('legendContainer', { read: ElementRef }) private legendElement;
 
 	constructor(
 		@Inject(forwardRef(() => ComponentFactoryResolver)) private _componentFactoryResolver: ComponentFactoryResolver,
-		@Inject(forwardRef(() => ViewContainerRef)) private _viewContainerRef: ViewContainerRef,
 		@Inject(forwardRef(() => ChangeDetectorRef)) private _cd: ChangeDetectorRef,
 		@Inject(IInstantiationService) private instantiationService: IInstantiationService,
 		@Inject(INotificationService) private notificationService: INotificationService,
@@ -123,15 +117,25 @@ export class ChartViewerComponent implements OnInit, OnDestroy, IChartViewAction
 	}
 
 	private setDefaultChartConfig() {
-		this._chartConfig = <ILineConfig>{
-			dataDirection: 'vertical',
-			dataType: 'number',
-			legendPosition: 'none',
-			labelFirstColumn: false
-		};
+		let defaultChart = this.getDefaultChartType();
+		if (defaultChart === 'timeSeries') {
+			this._chartConfig = <ILineConfig>{
+				dataDirection: 'vertical',
+				dataType: 'point',
+				legendPosition: 'none',
+				labelFirstColumn: false
+			};
+		} else {
+			this._chartConfig = <ILineConfig>{
+				dataDirection: 'vertical',
+				dataType: 'number',
+				legendPosition: 'none',
+				labelFirstColumn: false
+			};
+		}
 	}
 
-	private getDefaultChartType(): string {
+	protected getDefaultChartType(): string {
 		let defaultChartType = Constants.chartTypeHorizontalBar;
 		if (this.configurationService) {
 			let chartSettings = WorkbenchUtils.getSqlConfigSection(this.configurationService, 'chart');
@@ -300,22 +304,18 @@ export class ChartViewerComponent implements OnInit, OnDestroy, IChartViewAction
 		return undefined;
 	}
 
-	private get showDataDirection(): boolean {
+	protected get showDataDirection(): boolean {
 		return ['pie', 'horizontalBar', 'bar', 'doughnut'].some(item => item === this.chartTypesSelectBox.value) || (this.chartTypesSelectBox.value === 'line' && this.dataType === 'number');
 	}
 
-	private get showLabelFirstColumn(): boolean {
+	protected get showLabelFirstColumn(): boolean {
 		return this.dataDirection === 'horizontal' && this.dataType !== 'point';
 	}
 
-	private get showColumnsAsLabels(): boolean {
+	protected get showColumnsAsLabels(): boolean {
 		return this.dataDirection === 'vertical' && this.dataType !== 'point';
 	}
 
-	private get showDataType(): boolean {
-		return this.chartTypesSelectBox.value === 'line';
-	}
-
 	public get dataDirection(): DataDirection {
 		return this._chartConfig.dataDirection;
 	}
@@ -326,7 +326,6 @@ export class ChartViewerComponent implements OnInit, OnDestroy, IChartViewAction
 
 	@Input() set dataSet(dataSet: IGridDataSet) {
 		// Setup the execute result
-		this._dataSet = dataSet;
 		this._executeResult = <IInsightData>{};
 		this._executeResult.columns = dataSet.columnDefinitions.map(def => def.name);
 		this._executeResult.rows = dataSet.dataRows.getRange(0, dataSet.dataRows.getLength()).map(gridRow => {
@@ -356,4 +355,4 @@ export class ChartViewerComponent implements OnInit, OnDestroy, IChartViewAction
 	ngOnDestroy() {
 		this._disposables.forEach(i => i.dispose());
 	}
-}
+}

src/sql/parts/grid/views/query/query.component.ts

@@ -27,8 +27,9 @@ import { error } from 'sql/base/common/log';
 import { TabChild } from 'sql/base/browser/ui/panel/tab.component';
 import { clone, mixin } from 'sql/base/common/objects';
 import { IQueryEditorService } from 'sql/parts/query/common/queryEditorService';
+import { escape } from 'sql/base/common/strings';
 
-import * as strings from 'vs/base/common/strings';
+import { format } from 'vs/base/common/strings';
 import * as DOM from 'vs/base/browser/dom';
 import { StandardKeyboardEvent } from 'vs/base/browser/keyboardEvent';
 import { KeyCode } from 'vs/base/common/keyCodes';
@@ -60,7 +61,7 @@ export class QueryComponent extends GridParentComponent implements OnInit, OnDes
 
 	// create a function alias to use inside query.component
 	// tslint:disable-next-line:no-unused-variable
-	private stringsFormat: any = strings.format;
+	private stringsFormat: any = format;
 
 	// tslint:disable-next-line:no-unused-variable
 	private dataIcons: IGridIcon[] = [
@@ -302,7 +303,7 @@ export class QueryComponent extends GridParentComponent implements OnInit, OnDes
 						// Push row values onto end of gridData for slickgrid
 						gridData.push({
 							values: rows.rows[row].map(c => {
-								return mixin({ ariaLabel: c.displayValue }, c);
+								return mixin({ ariaLabel: escape(c.displayValue) }, c);
 							})
 						});
 					}

src/sql/parts/jobManagement/agent/agentView.component.html

@@ -4,17 +4,42 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 -->
-
-<panel class="dashboard-panel" [options]="panelOpt">
-	<tab [title]="jobsComponentTitle" class="fullsize" [identifier]="jobsTabIdentifier"
-		 [iconClass]="jobsIconClass">
-		 <ng-template>
-			<div id="jobsDiv" class="fullsize" *ngIf="showHistory === false">
-				<jobsview-component></jobsview-component>
-			</div>
-			<div id="historyDiv" class="fullsize" *ngIf="showHistory === true">
-				<jobhistory-component></jobhistory-component>
-			</div>
-		</ng-template>
-	</tab>
-</panel>
+<div id="agentViewDiv" class="fullsize">
+	<panel class="dashboard-panel" [options]="panelOpt">
+		<tab [title]="jobsComponentTitle" class="fullsize" [identifier]="jobsTabIdentifier"
+			[iconClass]="jobsIconClass">
+			<ng-template>
+				<div id="jobsDiv" class="fullsize" *ngIf="showHistory === false">
+					<jobsview-component></jobsview-component>
+				</div>
+				<div id="historyDiv" class="fullsize" *ngIf="showHistory === true">
+					<jobhistory-component></jobhistory-component>
+				</div>
+			</ng-template>
+		</tab>
+		<tab [title]="alertsComponentTitle" class="fullsize" [identifier]="alertsTabIdentifier"
+			[iconClass]="alertsIconClass">
+			<ng-template>
+				<div id="alertsDiv" class="fullsize">
+					<jobalertsview-component></jobalertsview-component>
+				</div>
+			</ng-template>
+		</tab>
+		<tab [title]="operatorsComponentTitle" class="fullsize" [identifier]="operatorsTabIdentifier"
+			[iconClass]="operatorsIconClass">
+			<ng-template>
+				<div id="operatorsDiv" class="fullsize">
+					<joboperatorsview-component></joboperatorsview-component>
+				</div>
+			</ng-template>
+		</tab>
+		<tab [title]="proxiesComponentTitle" class="fullsize" [identifier]="proxiesTabIdentifier"
+			[iconClass]="proxiesIconClass">
+			<ng-template>
+				<div id="proxiesDiv" class="fullsize">
+					<jobproxiesview-component></jobproxiesview-component>
+				</div>
+			</ng-template>
+		</tab>
+	</panel>
+</div>

src/sql/parts/jobManagement/agent/agentView.component.ts

@@ -18,6 +18,7 @@ import { ActionBar } from 'vs/base/browser/ui/actionbar/actionbar';
 import { DashboardServiceInterface } from 'sql/parts/dashboard/services/dashboardServiceInterface.service';
 import { AgentJobInfo, AgentJobHistoryInfo } from 'sqlops';
 import { PanelComponent, IPanelOptions, NavigationBarLayout } from 'sql/base/browser/ui/panel/panel.component';
+import { IJobManagementService } from 'sql/parts/jobManagement/common/interfaces';
 
 
 export const DASHBOARD_SELECTOR: string = 'agentview-component';
@@ -33,6 +34,10 @@ export class AgentViewComponent {
 
 	// tslint:disable:no-unused-variable
 	private readonly jobsComponentTitle: string = nls.localize('jobview.Jobs', "Jobs");
+	private readonly alertsComponentTitle: string = nls.localize('jobview.Alerts', "Alerts");
+	private readonly proxiesComponentTitle: string = nls.localize('jobview.Proxies', "Proxies");
+	private readonly operatorsComponentTitle: string = nls.localize('jobview.Operators', "Operators");
+
 	private _showHistory: boolean = false;
 	private _jobId: string = null;
 	private _agentJobInfo: AgentJobInfo = null;
@@ -40,6 +45,9 @@ export class AgentViewComponent {
 	private _expanded: Map<string, string>;
 
 	public jobsIconClass: string = 'jobsview-icon';
+	public alertsIconClass: string = 'alertsview-icon';
+	public proxiesIconClass: string = 'proxiesview-icon';
+	public operatorsIconClass: string = 'operatorsview-icon';
 
 	// tslint:disable-next-line:no-unused-variable
 	private readonly panelOpt: IPanelOptions = {
@@ -49,8 +57,15 @@ export class AgentViewComponent {
 	};
 
 	constructor(
-		@Inject(forwardRef(() => ChangeDetectorRef)) private _cd: ChangeDetectorRef) {
+		@Inject(forwardRef(() => ChangeDetectorRef)) private _cd: ChangeDetectorRef,
+		@Inject(IJobManagementService) jobManagementService: IJobManagementService) {
 		this._expanded = new Map<string, string>();
+
+		let self = this;
+		jobManagementService.onDidChange((args) => {
+			self.refresh = true;
+			self._cd.detectChanges();
+		});
 	}
 
 	/**

src/sql/parts/jobManagement/common/interfaces.ts

@@ -7,8 +7,8 @@
 
 import * as sqlops from 'sqlops';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
-import { Table } from 'sql/base/browser/ui/table/table';
 import { JobCacheObject } from './jobManagementService';
+import { Event } from 'vs/base/common/event';
 
 export const SERVICE_ID = 'jobManagementService';
 
@@ -16,16 +16,25 @@ export const IJobManagementService = createDecorator<IJobManagementService>(SERV
 
 export interface IJobManagementService {
 	_serviceBrand: any;
+	onDidChange: Event<void>;
 
 	registerProvider(providerId: string, provider: sqlops.AgentServicesProvider): void;
+	fireOnDidChange(): void;
 
 	getJobs(connectionUri: string): Thenable<sqlops.AgentJobsResult>;
-
 	getJobHistory(connectionUri: string, jobID: string): Thenable<sqlops.AgentJobHistoryResult>;
+	deleteJob(connectionUri: string, job: sqlops.AgentJobInfo): Thenable<sqlops.ResultStatus>;
+
+	getAlerts(connectionUri: string): Thenable<sqlops.AgentAlertsResult>;
+	deleteAlert(connectionUri: string, alert: sqlops.AgentAlertInfo): Thenable<sqlops.ResultStatus>;
+
+	getOperators(connectionUri: string): Thenable<sqlops.AgentOperatorsResult>;
+	deleteOperator(connectionUri: string, operator: sqlops.AgentOperatorInfo): Thenable<sqlops.ResultStatus>;
+
+	getProxies(connectionUri: string): Thenable<sqlops.AgentProxiesResult>;
+	deleteProxy(connectionUri: string, proxy: sqlops.AgentProxyInfo): Thenable<sqlops.ResultStatus>;
 
 	jobAction(connectionUri: string, jobName: string, action: string): Thenable<sqlops.ResultStatus>;
-
 	addToCache(server: string, cache: JobCacheObject);
-
 	jobCacheObjectMap:  { [server: string]: JobCacheObject; };
 }

src/sql/parts/jobManagement/common/jobActions.ts

@@ -0,0 +1,445 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { TPromise } from 'vs/base/common/winjs.base';
+import { Action } from 'vs/base/common/actions';
+import * as nls from 'vs/nls';
+import * as sqlops from 'sqlops';
+import { INotificationService } from 'vs/platform/notification/common/notification';
+import Severity from 'vs/base/common/severity';
+import { JobHistoryComponent } from 'sql/parts/jobManagement/views/jobHistory.component';
+import { IJobManagementService } from '../common/interfaces';
+import { ICommandService } from 'vs/platform/commands/common/commands';
+import { JobsViewComponent } from '../views/jobsView.component';
+import { AlertsViewComponent } from 'sql/parts/jobManagement/views/alertsView.component';
+import { OperatorsViewComponent } from 'sql/parts/jobManagement/views/operatorsView.component';
+import { ProxiesViewComponent } from 'sql/parts/jobManagement/views/proxiesView.component';
+
+export enum JobActions {
+	Run = 'run',
+	Stop = 'stop'
+}
+
+export interface IJobActionInfo {
+	ownerUri: string;
+	targetObject: any;
+}
+
+// Job actions
+
+export class JobsRefreshAction extends Action {
+	public static ID = 'jobaction.refresh';
+	public static LABEL = nls.localize('jobaction.refresh', "Refresh");
+
+	constructor(
+	) {
+		super(JobsRefreshAction.ID, JobsRefreshAction.LABEL, 'refreshIcon');
+	}
+
+	public run(context: JobsViewComponent): TPromise<boolean> {
+		return new TPromise<boolean>((resolve, reject) => {
+			if (context) {
+				context.refreshJobs();
+				resolve(true);
+			} else {
+				reject(false);
+			}
+		});
+	}
+}
+
+export class NewJobAction extends Action {
+	public static ID = 'jobaction.newJob';
+	public static LABEL = nls.localize('jobaction.newJob', "New Job");
+
+	constructor(
+	) {
+		super(NewJobAction.ID, NewJobAction.LABEL, 'newStepIcon');
+	}
+
+	public run(context: JobsViewComponent): TPromise<boolean> {
+		return new TPromise<boolean>((resolve, reject) => {
+			try {
+				context.openCreateJobDialog();
+				resolve(true);
+			} catch (e) {
+				reject(e);
+			}
+		});
+	}
+}
+
+export class RunJobAction extends Action {
+	public static ID = 'jobaction.runJob';
+	public static LABEL = nls.localize('jobaction.run', "Run");
+
+	constructor(
+		@INotificationService private notificationService: INotificationService,
+		@IJobManagementService private jobManagementService: IJobManagementService
+	) {
+		super(RunJobAction.ID, RunJobAction.LABEL, 'runJobIcon');
+	}
+
+	public run(context: JobHistoryComponent): TPromise<boolean> {
+		let jobName = context.agentJobInfo.name;
+		let ownerUri = context.ownerUri;
+		return new TPromise<boolean>((resolve, reject) => {
+			this.jobManagementService.jobAction(ownerUri, jobName, JobActions.Run).then(result => {
+				if (result.success) {
+					var startMsg = nls.localize('jobSuccessfullyStarted', ': The job was successfully started.');
+					this.notificationService.notify({
+						severity: Severity.Info,
+						message: jobName+ startMsg
+					});
+					resolve(true);
+				} else {
+					this.notificationService.notify({
+						severity: Severity.Error,
+						message: result.errorMessage
+					});
+					resolve(false);
+				}
+			});
+		});
+	}
+}
+
+export class StopJobAction extends Action {
+	public static ID = 'jobaction.stopJob';
+	public static LABEL = nls.localize('jobaction.stop', "Stop");
+
+	constructor(
+		@INotificationService private notificationService: INotificationService,
+		@IJobManagementService private jobManagementService: IJobManagementService
+	) {
+		super(StopJobAction.ID, StopJobAction.LABEL, 'stopJobIcon');
+	}
+
+	public run(context: JobHistoryComponent): TPromise<boolean> {
+		let jobName = context.agentJobInfo.name;
+		let ownerUri = context.ownerUri;
+		return new TPromise<boolean>((resolve, reject) => {
+			this.jobManagementService.jobAction(ownerUri, jobName, JobActions.Stop).then(result => {
+				if (result.success) {
+						var stopMsg = nls.localize('jobSuccessfullyStopped', ': The job was successfully stopped.');
+						this.notificationService.notify({
+							severity: Severity.Info,
+							message: jobName+ stopMsg
+						});
+					resolve(true);
+				} else {
+					this.notificationService.notify({
+						severity: Severity.Error,
+						message: result.errorMessage
+					});
+					resolve(false);
+				}
+			});
+		});
+	}
+}
+
+export class EditJobAction extends Action {
+	public static ID = 'jobaction.editJob';
+	public static LABEL = nls.localize('jobaction.editJob', "Edit Job");
+
+	constructor() {
+		super(EditJobAction.ID, EditJobAction.LABEL);
+	}
+
+	public run(actionInfo: IJobActionInfo): TPromise<boolean> {
+		return TPromise.as(true);
+	}
+}
+
+export class DeleteJobAction extends Action {
+	public static ID = 'jobaction.deleteJob';
+	public static LABEL = nls.localize('jobaction.deleteJob', "Delete Job");
+
+	constructor(
+		@INotificationService private _notificationService: INotificationService,
+		@IJobManagementService private _jobService: IJobManagementService
+	) {
+		super(DeleteJobAction.ID, DeleteJobAction.LABEL);
+	}
+
+	public run(actionInfo: IJobActionInfo): TPromise<boolean> {
+		let self = this;
+		let job = actionInfo.targetObject as sqlops.AgentJobInfo;
+		self._notificationService.prompt(
+			Severity.Info,
+			nls.localize('jobaction.deleteJobConfirm,', "Are you sure you'd like to delete the job '{0}'?", job.name),
+			[{
+				label: DeleteJobAction.LABEL,
+				run: () => {
+					self._jobService.deleteJob(actionInfo.ownerUri, actionInfo.targetObject).then(result => {
+						if (!result || !result.success) {
+							let errorMessage = nls.localize("jobaction.failedToDeleteJob", "Could not delete job '{0}'.\nError: {1}",
+								job.name, result.errorMessage ? result.errorMessage : 'Unknown error');
+							self._notificationService.error(errorMessage);
+						}
+					});
+				}
+			}, {
+				label: DeleteAlertAction.CancelLabel,
+				run: () => { }
+			}]
+		);
+		return TPromise.as(true);
+	}
+}
+
+// Step Actions
+
+export class NewStepAction extends Action {
+	public static ID = 'jobaction.newStep';
+	public static LABEL = nls.localize('jobaction.newStep', "New Step");
+
+	constructor(
+		@ICommandService private _commandService: ICommandService
+	) {
+		super(NewStepAction.ID, NewStepAction.LABEL, 'newStepIcon');
+	}
+
+	public run(context: JobHistoryComponent): TPromise<boolean> {
+		let ownerUri = context.ownerUri;
+		let jobName = context.agentJobInfo.name;
+		let server = context.serverName;
+		let stepId = 0;
+		if (context.agentJobHistoryInfo && context.agentJobHistoryInfo.steps) {
+			stepId = context.agentJobHistoryInfo.steps.length + 1;
+		}
+		return new TPromise<boolean>((resolve, reject) => {
+			resolve(this._commandService.executeCommand('agent.openNewStepDialog', ownerUri, jobName, server, stepId));
+		});
+	}
+}
+
+// Alert Actions
+
+export class NewAlertAction extends Action {
+	public static ID = 'jobaction.newAlert';
+	public static LABEL = nls.localize('jobaction.newAlert', "New Alert");
+
+	constructor(
+	) {
+		super(NewAlertAction.ID, NewAlertAction.LABEL, 'newStepIcon');
+	}
+
+	public run(context: AlertsViewComponent): TPromise<boolean> {
+		return new TPromise<boolean>((resolve, reject) => {
+			try {
+				context.openCreateAlertDialog();
+				resolve(true);
+			} catch (e) {
+				reject(e);
+			}
+		});
+	}
+}
+
+export class EditAlertAction extends Action {
+	public static ID = 'jobaction.editAlert';
+	public static LABEL = nls.localize('jobaction.editAlert', "Edit Alert");
+
+	constructor(
+		@ICommandService private _commandService: ICommandService
+	) {
+		super(EditAlertAction.ID, EditAlertAction.LABEL);
+	}
+
+	public run(actionInfo: IJobActionInfo): TPromise<boolean> {
+		this._commandService.executeCommand(
+			'agent.openAlertDialog',
+			 actionInfo.ownerUri,
+			 actionInfo.targetObject);
+		return TPromise.as(true);
+	}
+}
+
+export class DeleteAlertAction extends Action {
+	public static ID = 'jobaction.deleteAlert';
+	public static LABEL = nls.localize('jobaction.deleteAlert', "Delete Alert");
+	public static CancelLabel = nls.localize('jobaction.Cancel', "Cancel");
+
+	constructor(
+		@INotificationService private _notificationService: INotificationService,
+		@IJobManagementService private _jobService: IJobManagementService
+	) {
+		super(DeleteAlertAction.ID, DeleteAlertAction.LABEL);
+	}
+
+	public run(actionInfo: IJobActionInfo): TPromise<boolean> {
+		let self = this;
+		let alert = actionInfo.targetObject as sqlops.AgentAlertInfo;
+		self._notificationService.prompt(
+			Severity.Info,
+			nls.localize('jobaction.deleteAlertConfirm,', "Are you sure you'd like to delete the alert '{0}'?", alert.name),
+			[{
+				label: DeleteAlertAction.LABEL,
+				run: () => {
+					self._jobService.deleteAlert(actionInfo.ownerUri, actionInfo.targetObject).then(result => {
+						if (!result || !result.success) {
+							let errorMessage = nls.localize("jobaction.failedToDeleteAlert", "Could not delete alert '{0}'.\nError: {1}",
+								alert.name, result.errorMessage ? result.errorMessage : 'Unknown error');
+							self._notificationService.error(errorMessage);
+						}
+					});
+				}
+			}, {
+				label: DeleteAlertAction.CancelLabel,
+				run: () => { }
+			}]
+		);
+		return TPromise.as(true);
+	}
+}
+
+// Operator Actions
+
+export class NewOperatorAction extends Action {
+	public static ID = 'jobaction.newOperator';
+	public static LABEL = nls.localize('jobaction.newOperator', "New Operator");
+
+	constructor(
+	) {
+		super(NewOperatorAction.ID, NewOperatorAction.LABEL, 'newStepIcon');
+	}
+
+	public run(context: OperatorsViewComponent): TPromise<boolean> {
+		return new TPromise<boolean>((resolve, reject) => {
+			try {
+				context.openCreateOperatorDialog();
+				resolve(true);
+			} catch (e) {
+				reject(e);
+			}
+		});
+	}
+}
+
+export class EditOperatorAction extends Action {
+	public static ID = 'jobaction.editAlert';
+	public static LABEL = nls.localize('jobaction.editOperator', "Edit Operator");
+
+	constructor() {
+		super(EditOperatorAction.ID, EditOperatorAction.LABEL);
+	}
+
+	public run(info: any): TPromise<boolean> {
+		return TPromise.as(true);
+	}
+}
+
+export class DeleteOperatorAction extends Action {
+	public static ID = 'jobaction.deleteOperator';
+	public static LABEL = nls.localize('jobaction.deleteOperator', "Delete Operator");
+
+	constructor(
+		@INotificationService private _notificationService: INotificationService,
+		@IJobManagementService private _jobService: IJobManagementService
+	) {
+		super(DeleteOperatorAction.ID, DeleteOperatorAction.LABEL);
+	}
+
+	public run(actionInfo: IJobActionInfo): TPromise<boolean> {
+		let self = this;
+		let operator = actionInfo.targetObject as sqlops.AgentOperatorInfo;
+		self._notificationService.prompt(
+			Severity.Info,
+			nls.localize('jobaction.deleteOperatorConfirm,', "Are you sure you'd like to delete the operator '{0}'?", operator.name),
+			[{
+				label: DeleteOperatorAction.LABEL,
+				run: () => {
+					self._jobService.deleteOperator(actionInfo.ownerUri, actionInfo.targetObject).then(result => {
+						if (!result || !result.success) {
+							let errorMessage = nls.localize("jobaction.failedToDeleteOperator", "Could not delete operator '{0}'.\nError: {1}",
+								operator.name, result.errorMessage ? result.errorMessage : 'Unknown error');
+							self._notificationService.error(errorMessage);
+						}
+					});
+				}
+			}, {
+				label: DeleteAlertAction.CancelLabel,
+				run: () => { }
+			}]
+		);
+		return TPromise.as(true);
+	}
+}
+
+
+// Proxy Actions
+
+export class NewProxyAction extends Action {
+	public static ID = 'jobaction.newProxy';
+	public static LABEL = nls.localize('jobaction.newProxy', "New Proxy");
+
+	constructor(
+	) {
+		super(NewProxyAction.ID, NewProxyAction.LABEL, 'newStepIcon');
+	}
+
+	public run(context: ProxiesViewComponent): TPromise<boolean> {
+		return new TPromise<boolean>((resolve, reject) => {
+			try {
+				context.openCreateProxyDialog();
+				resolve(true);
+			} catch (e) {
+				reject(e);
+			}
+		});
+	}
+}
+
+export class EditProxyAction extends Action {
+	public static ID = 'jobaction.editProxy';
+	public static LABEL = nls.localize('jobaction.editProxy', "Edit Proxy");
+
+	constructor() {
+		super(EditProxyAction.ID, EditProxyAction.LABEL);
+	}
+
+	public run(info: any): TPromise<boolean> {
+		return TPromise.as(true);
+	}
+}
+
+export class DeleteProxyAction extends Action {
+	public static ID = 'jobaction.deleteProxy';
+	public static LABEL = nls.localize('jobaction.deleteProxy', "Delete Proxy");
+
+	constructor(
+		@INotificationService private _notificationService: INotificationService,
+		@IJobManagementService private _jobService: IJobManagementService
+	) {
+		super(DeleteProxyAction.ID, DeleteProxyAction.LABEL);
+	}
+
+	public run(actionInfo: IJobActionInfo): TPromise<boolean> {
+		let self = this;
+		let proxy = actionInfo.targetObject as sqlops.AgentProxyInfo;
+		self._notificationService.prompt(
+			Severity.Info,
+			nls.localize('jobaction.deleteProxyConfirm,', "Are you sure you'd like to delete the proxy '{0}'?", proxy.accountName),
+			[{
+				label: DeleteProxyAction.LABEL,
+				run: () => {
+					self._jobService.deleteProxy(actionInfo.ownerUri, actionInfo.targetObject).then(result => {
+						if (!result || !result.success) {
+							let errorMessage = nls.localize("jobaction.failedToDeleteProxy", "Could not delete proxy '{0}'.\nError: {1}",
+								proxy.accountName, result.errorMessage ? result.errorMessage : 'Unknown error');
+								self._notificationService.error(errorMessage);
+						}
+					});
+				}
+			}, {
+				label: DeleteAlertAction.CancelLabel,
+				run: () => { }
+			}]
+		);
+		return TPromise.as(true);
+	}
+}

src/sql/parts/jobManagement/common/jobManagementService.ts

@@ -7,32 +7,77 @@
 
 import { localize } from 'vs/nls';
 import * as sqlops from 'sqlops';
-import * as vscode from 'vscode';
 import { TPromise } from 'vs/base/common/winjs.base';
-import { Injectable } from '@angular/core';
 import { IJobManagementService } from 'sql/parts/jobManagement/common/interfaces';
-import { ICapabilitiesService } from 'sql/services/capabilities/capabilitiesService';
 import { IConnectionManagementService } from 'sql/parts/connection/common/connectionManagement';
-
+import { Event, Emitter } from 'vs/base/common/event';
 
 export class JobManagementService implements IJobManagementService {
 	_serviceBrand: any;
 
+	private _onDidChange = new Emitter<void>();
+	public readonly onDidChange: Event<void> = this._onDidChange.event;
+
 	private _providers: { [handle: string]: sqlops.AgentServicesProvider; } = Object.create(null);
 	private _jobCacheObject : {[server: string]: JobCacheObject; } = {};
 
 	constructor(
-		@IConnectionManagementService private _connectionService: IConnectionManagementService,
-		@ICapabilitiesService private _capabilitiesService: ICapabilitiesService
+		@IConnectionManagementService private _connectionService: IConnectionManagementService
 	) {
 	}
 
+	public fireOnDidChange(): void {
+		this._onDidChange.fire(void 0);
+	}
+
 	public getJobs(connectionUri: string): Thenable<sqlops.AgentJobsResult> {
 		return this._runAction(connectionUri, (runner) => {
 			return runner.getJobs(connectionUri);
 		});
 	}
 
+	public deleteJob(connectionUri: string, job: sqlops.AgentJobInfo): Thenable<sqlops.ResultStatus> {
+		return this._runAction(connectionUri, (runner) => {
+			return runner.deleteJob(connectionUri, job);
+		});
+	}
+
+	public getAlerts(connectionUri: string): Thenable<sqlops.AgentAlertsResult> {
+		return this._runAction(connectionUri, (runner) => {
+			return runner.getAlerts(connectionUri);
+		});
+	}
+
+	public deleteAlert(connectionUri: string, alert: sqlops.AgentAlertInfo): Thenable<sqlops.ResultStatus> {
+		return this._runAction(connectionUri, (runner) => {
+			return runner.deleteAlert(connectionUri, alert);
+		});
+	}
+
+	public getOperators(connectionUri: string): Thenable<sqlops.AgentOperatorsResult> {
+		return this._runAction(connectionUri, (runner) => {
+			return runner.getOperators(connectionUri);
+		});
+	}
+
+	public deleteOperator(connectionUri: string, operator: sqlops.AgentOperatorInfo): Thenable<sqlops.ResultStatus> {
+		return this._runAction(connectionUri, (runner) => {
+			return runner.deleteOperator(connectionUri, operator);
+		});
+	}
+
+	public getProxies(connectionUri: string): Thenable<sqlops.AgentProxiesResult> {
+		return this._runAction(connectionUri, (runner) => {
+			return runner.getProxies(connectionUri);
+		});
+	}
+
+	public deleteProxy(connectionUri: string, proxy: sqlops.AgentProxyInfo): Thenable<sqlops.ResultStatus>  {
+		return this._runAction(connectionUri, (runner) => {
+			return runner.deleteProxy(connectionUri, proxy);
+		});
+	}
+
 	public getJobHistory(connectionUri: string, jobID: string): Thenable<sqlops.AgentJobHistoryResult> {
 		return this._runAction(connectionUri, (runner) => {
 			return runner.getJobHistory(connectionUri, jobID);
@@ -45,7 +90,6 @@ export class JobManagementService implements IJobManagementService {
 		});
 	}
 
-
 	private _runAction<T>(uri: string, action: (handler: sqlops.AgentServicesProvider) => Thenable<T>): Thenable<T> {
 		let providerId: string = this._connectionService.getProviderIdFromUri(uri);
 
@@ -79,7 +123,8 @@ export class JobManagementService implements IJobManagementService {
 export class JobCacheObject {
 	_serviceBrand: any;
 	private _jobs: sqlops.AgentJobInfo[] = [];
-	private _jobHistories: { [jobId: string]: sqlops.AgentJobHistoryInfo[]; } = {};
+	private _jobHistories: { [jobID: string]: sqlops.AgentJobHistoryInfo[]; } = {};
+	private _runCharts: { [jobID: string]: string[]; } = {};
 	private _prevJobID: string;
 	private _serverName: string;
 	private _dataView: Slick.Data.DataView<any>;
@@ -89,7 +134,7 @@ export class JobCacheObject {
 			return this._jobs;
 		}
 
-		public get jobHistories(): { [jobId: string]: sqlops.AgentJobHistoryInfo[] } {
+		public get jobHistories(): { [jobID: string]: sqlops.AgentJobHistoryInfo[] } {
 			return this._jobHistories;
 		}
 
@@ -109,12 +154,16 @@ export class JobCacheObject {
 			return this._dataView;
 		}
 
+		public getRunChart(jobID: string): string[] {
+			return this._runCharts[jobID];
+		}
+
 		/* Setters */
 		public set jobs(value: sqlops.AgentJobInfo[]) {
 			this._jobs = value;
 		}
 
-		public set jobHistories(value: { [jobId: string]: sqlops.AgentJobHistoryInfo[]; }) {
+		public set jobHistories(value: { [jobID: string]: sqlops.AgentJobHistoryInfo[]; }) {
 			this._jobHistories = value;
 		}
 
@@ -126,6 +175,10 @@ export class JobCacheObject {
 			this._jobHistories[jobID] = value;
 		}
 
+		public setRunChart(jobID: string, value: string[]) {
+			this._runCharts[jobID] = value;
+		}
+
 		public set serverName(value: string) {
 			this._serverName = value;
 		}

src/sql/parts/jobManagement/common/jobManagementUtilities.ts

@@ -7,7 +7,7 @@
 
 import * as nls from 'vs/nls';
 
-export class AgentJobUtilities {
+export class JobManagementUtilities {
 
 	public static startIconClass: string = 'action-label icon runJobIcon';
 	public static stopIconClass: string = 'action-label icon stopJobIcon';
@@ -63,8 +63,8 @@ export class AgentJobUtilities {
 	}
 
 	public static getActionIconClassName(startIcon: HTMLElement, stopIcon: HTMLElement, executionStatus: number) {
-		this.setRunnable(startIcon, AgentJobUtilities.startIconClass.length);
-		this.setRunnable(stopIcon, AgentJobUtilities.stopIconClass.length);
+		this.setRunnable(startIcon, JobManagementUtilities.startIconClass.length);
+		this.setRunnable(stopIcon, JobManagementUtilities.stopIconClass.length);
 		switch (executionStatus) {
 			case(1): // executing
 				startIcon.className += ' non-runnable';

src/sql/parts/jobManagement/common/media/alert.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>jobalert</title><path d="M16,2.24V7.58A5.38,5.38,0,0,0,15,6.5V4.3L12.8,5.39l-.64-.11a5,5,0,0,0-.65,0l-.36,0-.36,0,4.11-2.05H1.12L7.87,6.61,7.49,7a4.7,4.7,0,0,0-.34.39L1,4.3v6.94H6a4.64,4.64,0,0,0,.07.5c0,.17.07.33.11.5H0v-10Zm-4.5,4a4.35,4.35,0,0,1,1.75.36A4.53,4.53,0,0,1,15.64,9a4.49,4.49,0,0,1,0,3.5,4.53,4.53,0,0,1-2.39,2.39,4.49,4.49,0,0,1-3.5,0,4.53,4.53,0,0,1-2.39-2.39,4.49,4.49,0,0,1,0-3.5A4.53,4.53,0,0,1,9.75,6.59,4.35,4.35,0,0,1,11.5,6.24Zm0,8A3.38,3.38,0,0,0,12.86,14a3.53,3.53,0,0,0,1.86-1.86,3.49,3.49,0,0,0,0-2.73,3.53,3.53,0,0,0-1.86-1.86,3.49,3.49,0,0,0-2.73,0A3.53,3.53,0,0,0,8.28,9.37a3.49,3.49,0,0,0,0,2.73A3.53,3.53,0,0,0,10.14,14,3.38,3.38,0,0,0,11.5,14.24Zm-.5-6h1v3H11Zm0,4h1v1H11Z"/></svg>

src/sql/parts/jobManagement/common/media/alert_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>jobalert_inverse</title><path class="cls-1" d="M16,2.24V7.58A5.38,5.38,0,0,0,15,6.5V4.3L12.8,5.39l-.64-.11a5,5,0,0,0-.65,0l-.36,0-.36,0,4.11-2.05H1.12L7.87,6.61,7.49,7a4.7,4.7,0,0,0-.34.39L1,4.3v6.94H6a4.64,4.64,0,0,0,.07.5c0,.17.07.33.11.5H0v-10Zm-4.5,4a4.35,4.35,0,0,1,1.75.36A4.53,4.53,0,0,1,15.64,9a4.49,4.49,0,0,1,0,3.5,4.53,4.53,0,0,1-2.39,2.39,4.49,4.49,0,0,1-3.5,0,4.53,4.53,0,0,1-2.39-2.39,4.49,4.49,0,0,1,0-3.5A4.53,4.53,0,0,1,9.75,6.59,4.35,4.35,0,0,1,11.5,6.24Zm0,8A3.38,3.38,0,0,0,12.86,14a3.53,3.53,0,0,0,1.86-1.86,3.49,3.49,0,0,0,0-2.73,3.53,3.53,0,0,0-1.86-1.86,3.49,3.49,0,0,0-2.73,0A3.53,3.53,0,0,0,8.28,9.37a3.49,3.49,0,0,0,0,2.73A3.53,3.53,0,0,0,10.14,14,3.38,3.38,0,0,0,11.5,14.24Zm-.5-6h1v3H11Zm0,4h1v1H11Z"/></svg>

src/sql/parts/jobManagement/common/media/jobs.css

@@ -22,7 +22,7 @@ jobhistory-component {
 }
 
 .job-heading-container {
-    height: 49px;
+    height: 50px;
     border-bottom: 3px solid #f4f4f4;
     display: -webkit-box;
 }
@@ -31,7 +31,7 @@ jobhistory-component {
     border-bottom: 3px solid #444444;
 }
 
-#jobsDiv .jobview-grid {
+.jobview-grid {
     height: 94.7%;
 	width : 100%;
     display: block;
@@ -49,6 +49,18 @@ jobhistory-component {
     font-size: larger;
 }
 
+.vs-dark #agentViewDiv .slick-header-column {
+	background: #333333 !important;
+}
+
+#agentViewDiv .slick-header-column {
+	background-color: transparent !important;
+	background: white !important;
+    border: 0px !important;
+    font-weight: bold;
+    font-size: larger;
+}
+
 .vs-dark #jobsDiv jobsview-component .jobview-grid .grid-canvas .ui-widget-content.slick-row .slick-cell {
     background:#333333;
 }
@@ -97,7 +109,7 @@ jobhistory-component {
 
 #jobsDiv .jobview-grid .slick-cell.l1.r1 .jobview-jobnametext {
     text-overflow: ellipsis;
-    width: 200px;
+    width: 250px;
     overflow: hidden;
     white-space: nowrap;
     display: inline-block;
@@ -107,18 +119,14 @@ jobhistory-component {
     border-bottom: none;
 }
 
-#jobsDiv .jobview-grid > .monaco-table .slick-viewport > .grid-canvas > .ui-widget-content.slick-row .slick-cell.l1.r1.error-row {
+.jobview-grid > .monaco-table .slick-viewport > .grid-canvas > .ui-widget-content.slick-row .slick-cell.l1.r1.error-row {
     width: 100%;
     opacity: 1;
     font-weight: 700;
     color: orangered;
 }
 
-#jobsDiv .jobview-grid > .monaco-table .slick-viewport > .grid-canvas > .ui-widget-content.slick-row .slick-cell.error-row {
-    opacity: 0;
-}
-
-#jobsDiv .jobview-grid > .monaco-table .slick-viewport > .grid-canvas > .ui-widget-content.slick-row .slick-cell._detail_selector.error-row {
+.jobview-grid > .monaco-table .slick-viewport > .grid-canvas > .ui-widget-content.slick-row .slick-cell._detail_selector.error-row {
     opacity: 1;
 }
 
@@ -182,6 +190,30 @@ jobhistory-component {
 	background-image: url('./job_inverse.svg');
 }
 
+.alertsview-icon {
+    background-image: url('./alert.svg');
+}
+
+.vs-dark .alertsview-icon {
+	background-image: url('./alert_inverse.svg');
+}
+
+.proxiesview-icon {
+    background-image: url('./proxy.svg');
+}
+
+.vs-dark .proxiesview-icon {
+	background-image: url('./proxy_inverse.svg');
+}
+
+.operatorsview-icon {
+    background-image: url('./operator.svg');
+}
+
+.vs-dark .operatorsview-icon {
+	background-image: url('./operator_inverse.svg');
+}
+
 agentview-component .jobview-grid .grid-canvas > .ui-widget-content.slick-row.even > .slick-cell,
 agentview-component .jobview-grid .grid-canvas > .ui-widget-content.slick-row.odd > .slick-cell {
     cursor: pointer;
@@ -219,8 +251,8 @@ agentview-component .jobview-grid .grid-canvas > .ui-widget-content.slick-row.od
     background: #444444 !important;
 }
 
-table.jobprevruns div.bar1, table.jobprevruns div.bar2, table.jobprevruns div.bar3,
-table.jobprevruns div.bar4, table.jobprevruns div.bar5 {
+table.jobprevruns div.bar0, table.jobprevruns div.bar1, table.jobprevruns div.bar2,
+table.jobprevruns div.bar3, table.jobprevruns div.bar4, table.jobprevruns div.bar5 {
     padding-top: 3px;
     padding-left: 5px;
 	width: 10px;
@@ -232,10 +264,79 @@ table.jobprevruns div.bar4, table.jobprevruns div.bar5 {
 }
 
 table.jobprevruns {
-    margin: auto;
     height: 100%;
 }
 
 table.jobprevruns > tbody {
     vertical-align: bottom;
+}
+
+.jobs-view-toolbar{
+    display: flex;
+    flex-wrap: wrap;
+    align-items: flex-start;
+    padding: 15px 10px 15px 30px;
+    font-size: 16px;
+    border-bottom: 3px solid #f4f4f4;
+}
+
+.jobs-view-toolbar .vs-dark {
+    border-bottom: 3px solid #444444;
+}
+
+.jobs-view-toolbar > div{
+    display: flex;
+    flex-wrap: nowrap;
+    align-items: flex-start;
+    margin-right: 25px;
+    cursor: pointer;
+    padding: 2px;
+}
+
+.jobs-view-toolbar span{
+    padding-left: 5px;
+}
+
+
+#alertsDiv .jobalertsview-grid {
+    height: 94.7%;
+	width : 100%;
+    display: block;
+}
+
+#operatorsDiv .joboperatorsview-grid {
+    height: 94.7%;
+	width : 100%;
+    display: block;
+}
+
+#proxiesDiv .jobproxiesview-grid {
+    height: 94.7%;
+	width : 100%;
+    display: block;
+}
+
+.vs .action-label.icon.refreshIcon {
+	background-image: url('refresh.svg');
+}
+
+.vs-dark .action-label.icon.refreshIcon,
+.hc-black .action-label.icon.refreshIcon  {
+	background-image: url('refresh_inverse.svg');
+}
+
+.actionbar-container .monaco-action-bar > ul.actions-container {
+	padding-top: 10px;
+}
+
+jobsview-component .actionbar-container {
+    height: 40px;
+}
+
+.actionbar-container .monaco-action-bar > ul.actions-container > li.action-item {
+	padding-left: 20px;
+}
+
+jobsview-component .jobview-grid .slick-cell.error-row {
+    opacity: 0;
 }

src/sql/parts/jobManagement/common/media/new.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:#231f20;}.cls-2{fill:#212121;}</style></defs><title>new_16x16</title><polygon class="cls-1" points="13.59 2.21 13.58 2.22 13.58 2.2 13.59 2.21"/><path class="cls-2" d="M16,7.5v1H8.5V16h-1V8.5H0v-1H7.5V0h1V7.5Z"/></svg>

src/sql/parts/jobManagement/common/media/new_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>new_inverse_16x16</title><polygon class="cls-1" points="13.59 2.21 13.58 2.22 13.58 2.2 13.59 2.21"/><path class="cls-1" d="M16,7.5v1H8.5V16h-1V8.5H0v-1H7.5V0h1V7.5Z"/></svg>

src/sql/parts/jobManagement/common/media/operator.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>operator</title><path d="M10.36,9.41a7.54,7.54,0,0,1,1.9,1.05A7,7,0,0,1,13.73,12,6.9,6.9,0,0,1,15,16H14a5.79,5.79,0,0,0-.47-2.33,6.07,6.07,0,0,0-3.2-3.2A5.79,5.79,0,0,0,8,10a5.79,5.79,0,0,0-2.33.47,6.07,6.07,0,0,0-3.2,3.2A5.79,5.79,0,0,0,2,16H1a6.89,6.89,0,0,1,2.74-5.54,7.54,7.54,0,0,1,1.9-1.05A5.07,5.07,0,0,1,4,8a4.24,4.24,0,0,1-.73-.06,1.92,1.92,0,0,1-.64-.23,1.25,1.25,0,0,1-.45-.46A1.48,1.48,0,0,1,2,6.5v-3a1.47,1.47,0,0,1,.12-.59,1.49,1.49,0,0,1,.8-.8A1.47,1.47,0,0,1,3.5,2a1.4,1.4,0,0,1,.45.07,4.88,4.88,0,0,1,.8-.87,5.21,5.21,0,0,1,1-.65A4.95,4.95,0,0,1,8,0,4.88,4.88,0,0,1,9.95.39a5,5,0,0,1,2.66,2.66A4.88,4.88,0,0,1,13,5a4.93,4.93,0,0,1-.18,1.34,5,5,0,0,1-.53,1.23,5.12,5.12,0,0,1-.83,1A4.73,4.73,0,0,1,10.36,9.41ZM3,6.5a.51.51,0,0,0,.5.5H4V3.5a.5.5,0,0,0-.85-.35A.48.48,0,0,0,3,3.5ZM5.35,8a3.92,3.92,0,0,0,1.23.74A4,4,0,0,0,8,9a3.85,3.85,0,0,0,1.55-.32,4.05,4.05,0,0,0,2.13-2.13A3.85,3.85,0,0,0,12,5a3.85,3.85,0,0,0-.32-1.55A4.05,4.05,0,0,0,9.55,1.32,3.85,3.85,0,0,0,8,1a4,4,0,0,0-1.83.45A4,4,0,0,0,4.75,2.67a1.47,1.47,0,0,1,.18.51A5.75,5.75,0,0,1,5,3.91q0,.41,0,.85t0,.87q0,.42,0,.78T5,7H7.5a.5.5,0,0,1,0,1Z"/></svg>

src/sql/parts/jobManagement/common/media/operator_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>operator_inverse</title><path class="cls-1" d="M10.36,9.41a7.54,7.54,0,0,1,1.9,1.05A7,7,0,0,1,13.73,12,6.9,6.9,0,0,1,15,16H14a5.79,5.79,0,0,0-.47-2.33,6.07,6.07,0,0,0-3.2-3.2A5.79,5.79,0,0,0,8,10a5.79,5.79,0,0,0-2.33.47,6.07,6.07,0,0,0-3.2,3.2A5.79,5.79,0,0,0,2,16H1a6.89,6.89,0,0,1,2.74-5.54,7.54,7.54,0,0,1,1.9-1.05A5.07,5.07,0,0,1,4,8a4.24,4.24,0,0,1-.73-.06,1.92,1.92,0,0,1-.64-.23,1.25,1.25,0,0,1-.45-.46A1.48,1.48,0,0,1,2,6.5v-3a1.47,1.47,0,0,1,.12-.59,1.49,1.49,0,0,1,.8-.8A1.47,1.47,0,0,1,3.5,2a1.4,1.4,0,0,1,.45.07,4.88,4.88,0,0,1,.8-.87,5.21,5.21,0,0,1,1-.65A4.95,4.95,0,0,1,8,0,4.88,4.88,0,0,1,9.95.39a5,5,0,0,1,2.66,2.66A4.88,4.88,0,0,1,13,5a4.93,4.93,0,0,1-.18,1.34,5,5,0,0,1-.53,1.23,5.12,5.12,0,0,1-.83,1A4.73,4.73,0,0,1,10.36,9.41ZM3,6.5a.51.51,0,0,0,.5.5H4V3.5a.5.5,0,0,0-.85-.35A.48.48,0,0,0,3,3.5ZM5.35,8a3.92,3.92,0,0,0,1.23.74A4,4,0,0,0,8,9a3.85,3.85,0,0,0,1.55-.32,4.05,4.05,0,0,0,2.13-2.13A3.85,3.85,0,0,0,12,5a3.85,3.85,0,0,0-.32-1.55A4.05,4.05,0,0,0,9.55,1.32,3.85,3.85,0,0,0,8,1a4,4,0,0,0-1.83.45A4,4,0,0,0,4.75,2.67a1.47,1.47,0,0,1,.18.51A5.75,5.75,0,0,1,5,3.91q0,.41,0,.85t0,.87q0,.42,0,.78T5,7H7.5a.5.5,0,0,1,0,1Z"/></svg>

src/sql/parts/jobManagement/common/media/proxy.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>proxy_account</title><path d="M12.23,7a3,3,0,0,0-3.39-.77,3,3,0,0,0-1.6,1.6A2.93,2.93,0,0,0,7,9a3,3,0,0,1-1.23,2.41,4.31,4.31,0,0,1,.66.42,4.2,4.2,0,0,1,.57.53V15a2.93,2.93,0,0,0-.23-1.16,3,3,0,0,0-1.6-1.6,3,3,0,0,0-2.33,0,3,3,0,0,0-1.6,1.6A2.93,2.93,0,0,0,1,15H0a3.92,3.92,0,0,1,.16-1.11,4.11,4.11,0,0,1,.45-1,3.87,3.87,0,0,1,.7-.84,4.2,4.2,0,0,1,.92-.63,3,3,0,0,1-1-3.58,3,3,0,0,1,1.6-1.6A2.92,2.92,0,0,1,4,6,3,3,0,0,1,6.41,7.23,4.12,4.12,0,0,1,8.23,5.41,3,3,0,0,1,7,3a2.93,2.93,0,0,1,.23-1.16A3,3,0,0,1,8.83.23a3,3,0,0,1,2.33,0,3,3,0,0,1,1.6,1.6,3,3,0,0,1-.09,2.52,2.94,2.94,0,0,1-.9,1.06,4.07,4.07,0,0,1,1,.67,4,4,0,0,1,.73.92ZM4,11a1.94,1.94,0,0,0,.78-.16A2,2,0,0,0,5.84,9.78a2,2,0,0,0,0-1.55A2,2,0,0,0,4.78,7.16a2,2,0,0,0-1.55,0A2,2,0,0,0,2.16,8.22a2,2,0,0,0,0,1.55,2,2,0,0,0,1.07,1.07A1.94,1.94,0,0,0,4,11ZM8,3a1.94,1.94,0,0,0,.16.78A2,2,0,0,0,9.22,4.84a2,2,0,0,0,1.55,0,2,2,0,0,0,1.07-1.07,2,2,0,0,0,0-1.55,2,2,0,0,0-1.07-1.07,2,2,0,0,0-1.55,0A2,2,0,0,0,8.16,2.22,1.94,1.94,0,0,0,8,3Zm8,7v6H8V10h2V8h4v2Zm-1,1H9v1h6Zm0,2H14v1H13V13H11v1H10V13H9v2h6Zm-4-3h2V9H11Z"/></svg>

src/sql/parts/jobManagement/common/media/proxy_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>proxy_account_inverse</title><path class="cls-1" d="M12.23,7a3,3,0,0,0-3.39-.77,3,3,0,0,0-1.6,1.6A2.93,2.93,0,0,0,7,9a3,3,0,0,1-1.23,2.41,4.31,4.31,0,0,1,.66.42,4.2,4.2,0,0,1,.57.53V15a2.93,2.93,0,0,0-.23-1.16,3,3,0,0,0-1.6-1.6,3,3,0,0,0-2.33,0,3,3,0,0,0-1.6,1.6A2.93,2.93,0,0,0,1,15H0a3.92,3.92,0,0,1,.16-1.11,4.11,4.11,0,0,1,.45-1A3.87,3.87,0,0,1,1.3,12a4.2,4.2,0,0,1,.92-.63,3,3,0,0,1-1-3.58,3,3,0,0,1,1.6-1.6A2.92,2.92,0,0,1,4,6,3,3,0,0,1,6.41,7.23,4.12,4.12,0,0,1,8.23,5.41,3,3,0,0,1,7,3a2.93,2.93,0,0,1,.23-1.16A3,3,0,0,1,8.83.23a3,3,0,0,1,2.33,0,3,3,0,0,1,1.6,1.6,3,3,0,0,1-.09,2.52,2.94,2.94,0,0,1-.9,1.06,4.07,4.07,0,0,1,1,.67,4,4,0,0,1,.73.92ZM4,11a1.94,1.94,0,0,0,.78-.16A2,2,0,0,0,5.84,9.78a2,2,0,0,0,0-1.55A2,2,0,0,0,4.78,7.16a2,2,0,0,0-1.55,0A2,2,0,0,0,2.16,8.22a2,2,0,0,0,0,1.55,2,2,0,0,0,1.07,1.07A1.94,1.94,0,0,0,4,11ZM8,3a1.94,1.94,0,0,0,.16.78A2,2,0,0,0,9.22,4.84a2,2,0,0,0,1.55,0,2,2,0,0,0,1.07-1.07,2,2,0,0,0,0-1.55,2,2,0,0,0-1.07-1.07,2,2,0,0,0-1.55,0A2,2,0,0,0,8.16,2.22,1.94,1.94,0,0,0,8,3Zm8,7v6H8V10h2V8h4v2Zm-1,1H9v1h6Zm0,2H14v1H13V13H11v1H10V13H9v2h6Zm-4-3h2V9H11Z"/></svg>

src/sql/parts/jobManagement/common/media/refresh.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:#212121;}</style></defs><title>refresh</title><path class="cls-1" d="M12.51,1.59a8.06,8.06,0,0,1,3.06,4A7.83,7.83,0,0,1,16,8.2a7.91,7.91,0,0,1-.29,2.12,8.13,8.13,0,0,1-.8,1.91A8,8,0,0,1,12,15.11a8.1,8.1,0,0,1-1.91.8,8.06,8.06,0,0,1-4.25,0A8.08,8.08,0,0,1,4,15.11a8,8,0,0,1-2.87-2.87,8.07,8.07,0,0,1-.8-1.91,8,8,0,0,1,0-4.25,8.11,8.11,0,0,1,.82-1.94,7.86,7.86,0,0,1,1.3-1.66A8,8,0,0,1,4.14,1.2H2V.2H6v4H5V1.88A7,7,0,0,0,1.28,6.24a7,7,0,0,0,0,3.82,7,7,0,0,0,1.8,3.09A7,7,0,0,0,6.14,15a7,7,0,0,0,3.71,0,7,7,0,0,0,1.67-.71,7,7,0,0,0,3.22-4.18,7,7,0,0,0-.13-4.12,7.07,7.07,0,0,0-2.68-3.52,6.78,6.78,0,0,0-2.07-1l.27-1A7.67,7.67,0,0,1,12.51,1.59Z"/></svg>

src/sql/parts/jobManagement/common/media/refresh_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>refresh_inverse</title><path class="cls-1" d="M12.51,1.59a8.06,8.06,0,0,1,3.06,4A7.83,7.83,0,0,1,16,8.2a7.91,7.91,0,0,1-.29,2.12,8.13,8.13,0,0,1-.8,1.91A8,8,0,0,1,12,15.11a8.1,8.1,0,0,1-1.91.8,8.06,8.06,0,0,1-4.25,0A8.08,8.08,0,0,1,4,15.11a8,8,0,0,1-2.87-2.87,8.07,8.07,0,0,1-.8-1.91,8,8,0,0,1,0-4.25,8.11,8.11,0,0,1,.82-1.94,7.86,7.86,0,0,1,1.3-1.66A8,8,0,0,1,4.14,1.2H2V.2H6v4H5V1.88A7,7,0,0,0,1.28,6.24a7,7,0,0,0,0,3.82,7,7,0,0,0,1.8,3.09A7,7,0,0,0,6.14,15a7,7,0,0,0,3.71,0,7,7,0,0,0,1.67-.71,7,7,0,0,0,3.22-4.18,7,7,0,0,0-.13-4.12,7.07,7.07,0,0,0-2.68-3.52,6.78,6.78,0,0,0-2.07-1l.27-1A7.67,7.67,0,0,1,12.51,1.59Z"/></svg>

src/sql/parts/jobManagement/views/alertsView.component.html

@@ -0,0 +1,15 @@
+<!--
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+-->
+<div class="job-heading-container">
+	<h1 class="job-heading" *ngIf="_isCloud === false">Alerts</h1>
+	<h1 class="job-heading" *ngIf="_isCloud === true">No Alerts Available</h1>
+	<div class="icon in-progress" *ngIf="_showProgressWheel === true"></div>
+</div>
+
+<div #actionbarContainer class="actionbar-container"></div>
+
+<div #jobalertsgrid class="jobview-grid"></div>

src/sql/parts/jobManagement/views/alertsView.component.ts

@@ -0,0 +1,173 @@
+/*---------------------------------------------------------------------------------------------
+ *  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!sql/parts/grid/media/slickColorTheme';
+import 'vs/css!sql/parts/grid/media/flexbox';
+import 'vs/css!sql/parts/grid/media/styles';
+import 'vs/css!sql/parts/grid/media/slick.grid';
+import 'vs/css!sql/parts/grid/media/slickGrid';
+import 'vs/css!../common/media/jobs';
+import 'vs/css!sql/media/icons/common-icons';
+import 'vs/css!sql/base/browser/ui/table/media/table';
+
+import * as dom from 'vs/base/browser/dom';
+import * as nls from 'vs/nls';
+import * as sqlops from 'sqlops';
+import { Component, Inject, forwardRef, ElementRef, ChangeDetectorRef, ViewChild, OnInit } from '@angular/core';
+import { TabChild } from 'sql/base/browser/ui/panel/tab.component';
+import { Table } from 'sql/base/browser/ui/table/table';
+import { AgentViewComponent } from 'sql/parts/jobManagement/agent/agentView.component';
+import { IJobManagementService } from 'sql/parts/jobManagement/common/interfaces';
+import { EditAlertAction, DeleteAlertAction, NewAlertAction } from 'sql/parts/jobManagement/common/jobActions';
+import { JobManagementView } from 'sql/parts/jobManagement/views/jobManagementView';
+import { CommonServiceInterface } from 'sql/services/common/commonServiceInterface.service';
+import { ICommandService } from 'vs/platform/commands/common/commands';
+import { IContextMenuService } from 'vs/platform/contextview/browser/contextView';
+import { IAction } from 'vs/base/common/actions';
+import { TPromise } from 'vs/base/common/winjs.base';
+import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+
+export const VIEW_SELECTOR: string = 'jobalertsview-component';
+export const ROW_HEIGHT: number = 45;
+
+@Component({
+	selector: VIEW_SELECTOR,
+	templateUrl: decodeURI(require.toUrl('./alertsView.component.html')),
+	providers: [{ provide: TabChild, useExisting: forwardRef(() => AlertsViewComponent) }],
+})
+export class AlertsViewComponent extends JobManagementView implements OnInit {
+
+	private columns: Array<Slick.Column<any>> = [
+		{ name: nls.localize('jobAlertColumns.name', 'Name'), field: 'name', width: 200, id: 'name' },
+		{ name: nls.localize('jobAlertColumns.lastOccurrenceDate', 'Last Occurrence'), field: 'lastOccurrenceDate', width: 200, id: 'lastOccurrenceDate' },
+		{ name: nls.localize('jobAlertColumns.enabled', 'Enabled'), field: 'enabled', width: 200, id: 'enabled' },
+		{ name: nls.localize('jobAlertColumns.databaseName', 'Database Name'), field: 'databaseName', width: 200, id: 'databaseName' },
+		{ name: nls.localize('jobAlertColumns.categoryName', 'Category Name'), field: 'categoryName', width: 200, id: 'categoryName' },
+	];
+
+	private options: Slick.GridOptions<any> = {
+		syncColumnCellResize: true,
+		enableColumnReorder: false,
+		rowHeight: ROW_HEIGHT,
+		enableCellNavigation: true,
+		editable: false
+	};
+
+	private dataView: any;
+	private _isCloud: boolean;
+
+	@ViewChild('jobalertsgrid') _gridEl: ElementRef;
+
+	public alerts: sqlops.AgentAlertInfo[];
+	public contextAction = NewAlertAction;
+
+	constructor(
+		@Inject(forwardRef(() => ChangeDetectorRef)) private _cd: ChangeDetectorRef,
+		@Inject(forwardRef(() => ElementRef)) private _el: ElementRef,
+		@Inject(forwardRef(() => AgentViewComponent)) private _agentViewComponent: AgentViewComponent,
+		@Inject(IJobManagementService) private _jobManagementService: IJobManagementService,
+		@Inject(ICommandService) private _commandService: ICommandService,
+		@Inject(IInstantiationService) instantiationService: IInstantiationService,
+		@Inject(forwardRef(() => CommonServiceInterface)) commonService: CommonServiceInterface,
+		@Inject(IContextMenuService) contextMenuService: IContextMenuService,
+		@Inject(IKeybindingService)  keybindingService: IKeybindingService) {
+		super(commonService, contextMenuService, keybindingService, instantiationService);
+		this._isCloud = commonService.connectionManagementService.connectionInfo.serverInfo.isCloud;
+	}
+
+	ngOnInit(){
+		// set base class elements
+		this._visibilityElement = this._gridEl;
+		this._parentComponent = this._agentViewComponent;
+	 }
+
+	public layout() {
+		this._table.layout(new dom.Dimension(dom.getContentWidth(this._gridEl.nativeElement), dom.getContentHeight(this._gridEl.nativeElement)));
+	}
+
+	onFirstVisible() {
+		let self = this;
+		let columns = this.columns.map((column) => {
+			column.rerenderOnResize = true;
+			return column;
+		});
+		let options = <Slick.GridOptions<any>>{
+			syncColumnCellResize: true,
+			enableColumnReorder: false,
+			rowHeight: ROW_HEIGHT,
+			enableCellNavigation: true,
+			forceFitColumns: true
+		};
+
+		this.dataView = new Slick.Data.DataView();
+
+		$(this._gridEl.nativeElement).empty();
+		$(this.actionBarContainer.nativeElement).empty();
+		this.initActionBar();
+		this._table = new Table(this._gridEl.nativeElement, undefined, columns, this.options);
+		this._table.grid.setData(this.dataView, true);
+
+		this._register(this._table.onContextMenu((e: DOMEvent, data: Slick.OnContextMenuEventArgs<any>) => {
+			self.openContextMenu(e);
+		}));
+
+		let ownerUri: string = this._commonService.connectionManagementService.connectionInfo.ownerUri;
+		this._jobManagementService.getAlerts(ownerUri).then((result) => {
+			if (result && result.alerts) {
+				self.alerts = result.alerts;
+				self.onAlertsAvailable(result.alerts);
+			} else {
+				// TODO: handle error
+			}
+
+			this._showProgressWheel = false;
+			if (this.isVisible) {
+				this._cd.detectChanges();
+			}
+		});
+	}
+
+	private onAlertsAvailable(alerts: sqlops.AgentAlertInfo[]) {
+		let items: any = alerts.map((item) => {
+			return {
+				id: item.id,
+				name: item.name,
+				lastOccurrenceDate: item.lastOccurrenceDate,
+				enabled: item.isEnabled,
+				databaseName: item.databaseName,
+				categoryName: item.categoryName
+			};
+		});
+
+		this.dataView.beginUpdate();
+		this.dataView.setItems(items);
+		this.dataView.endUpdate();
+		this._table.autosizeColumns();
+		this._table.resizeCanvas();
+	}
+
+	protected getTableActions(): TPromise<IAction[]> {
+		let actions: IAction[] = [];
+		actions.push(this._instantiationService.createInstance(EditAlertAction));
+		actions.push(this._instantiationService.createInstance(DeleteAlertAction));
+		return TPromise.as(actions);
+	}
+
+	protected getCurrentTableObject(rowIndex: number): any {
+		return (this.alerts && this.alerts.length >= rowIndex)
+			? this.alerts[rowIndex]
+			: undefined;
+	}
+
+	public openCreateAlertDialog() {
+		let ownerUri: string = this._commonService.connectionManagementService.connectionInfo.ownerUri;
+		this._commandService.executeCommand('agent.openAlertDialog', ownerUri);
+	}
+
+	private refreshJobs() {
+		this._agentViewComponent.refresh = true;
+	}
+}

src/sql/parts/jobManagement/views/jobHistory.component.html

@@ -77,7 +77,7 @@
 <!-- Job History details -->
 <div class='history-details'>
 	<!-- Previous run list -->
-	<div style="min-width: 275px">
+	<div class="prev-run-list-container" style="min-width: 275px; height: 75vh">
 		<table *ngIf="_showPreviousRuns === true">
 			<tr>
 				<td class="date-column">

src/sql/parts/jobManagement/views/jobHistory.component.ts

@@ -5,18 +5,19 @@
 
 import 'vs/css!./jobHistory';
 import 'vs/css!sql/media/icons/common-icons';
-import { OnInit, OnChanges, Component, Inject, Input, forwardRef, ElementRef, ChangeDetectorRef, ViewChild, ChangeDetectionStrategy, Injectable } from '@angular/core';
-import { AgentJobHistoryInfo, AgentJobInfo } from 'sqlops';
+
+import * as sqlops from 'sqlops';
+import { OnInit, Component, Inject, Input, forwardRef, ElementRef, ChangeDetectorRef, ViewChild, ChangeDetectionStrategy, Injectable } from '@angular/core';
 import { Taskbar } from 'sql/base/browser/ui/taskbar/taskbar';
-import { RunJobAction, StopJobAction } from 'sql/parts/jobManagement/views/jobHistoryActions';
-import { JobCacheObject } from 'sql/parts/jobManagement/common/jobManagementService';
-import { AgentJobUtilities } from '../common/agentJobUtilities';
-import { IJobManagementService } from '../common/interfaces';
-import { CommonServiceInterface } from 'sql/services/common/commonServiceInterface.service';
 import { AgentViewComponent } from 'sql/parts/jobManagement/agent/agentView.component';
+import { CommonServiceInterface } from 'sql/services/common/commonServiceInterface.service';
+import { RunJobAction, StopJobAction, NewStepAction } from 'sql/parts/jobManagement/common/jobActions';
+import { JobCacheObject } from 'sql/parts/jobManagement/common/jobManagementService';
+import { JobManagementUtilities } from 'sql/parts/jobManagement/common/jobManagementUtilities';
+import { IJobManagementService } from 'sql/parts/jobManagement/common/interfaces';
 import { JobHistoryController, JobHistoryDataSource,
 	JobHistoryRenderer, JobHistoryFilter, JobHistoryModel, JobHistoryRow } from 'sql/parts/jobManagement/views/jobHistoryTree';
-import { JobStepsViewRow } from './jobStepsViewTree';
+import { JobStepsViewRow } from 'sql/parts/jobManagement/views/jobStepsViewTree';
 import { IWorkbenchThemeService } from 'vs/workbench/services/themes/common/workbenchThemeService';
 import { attachListStyler } from 'vs/platform/theme/common/styler';
 import { Tree } from 'vs/base/parts/tree/browser/treeImpl';
@@ -46,9 +47,9 @@ export class JobHistoryComponent extends Disposable implements OnInit {
 	@ViewChild('table') private _tableContainer: ElementRef;
 	@ViewChild('actionbarContainer') private _actionbarContainer: ElementRef;
 
-	@Input() public agentJobInfo: AgentJobInfo = undefined;
-	@Input() public agentJobHistories: AgentJobHistoryInfo[] = undefined;
-	public agentJobHistoryInfo: AgentJobHistoryInfo = undefined;
+	@Input() public agentJobInfo: sqlops.AgentJobInfo = undefined;
+	@Input() public agentJobHistories: sqlops.AgentJobHistoryInfo[] = undefined;
+	public agentJobHistoryInfo: sqlops.AgentJobHistoryInfo = undefined;
 
 	private _isVisible: boolean = false;
 	private _stepRows: JobStepsViewRow[] = [];
@@ -56,8 +57,12 @@ export class JobHistoryComponent extends Disposable implements OnInit {
 	private _showPreviousRuns: boolean = undefined;
 	private _runStatus: string = undefined;
 	private _jobCacheObject: JobCacheObject;
-	private _agentJobInfo: AgentJobInfo;
+	private _agentJobInfo: sqlops.AgentJobInfo;
 	private _noJobsAvailable: boolean = false;
+	private _serverName: string;
+
+	private static readonly INITIAL_TREE_HEIGHT: number = 780;
+	private static readonly HEADING_HEIGHT: number = 24;
 
 	constructor(
 		@Inject(forwardRef(() => ElementRef)) el: ElementRef,
@@ -76,14 +81,14 @@ export class JobHistoryComponent extends Disposable implements OnInit {
 		this._treeRenderer = new JobHistoryRenderer();
 		this._treeFilter =  new JobHistoryFilter();
 		let jobCacheObjectMap = this._jobManagementService.jobCacheObjectMap;
-		let serverName = _dashboardService.connectionManagementService.connectionInfo.connectionProfile.serverName;
-		let jobCache = jobCacheObjectMap[serverName];
+		this._serverName = _dashboardService.connectionManagementService.connectionInfo.connectionProfile.serverName;
+		let jobCache = jobCacheObjectMap[this._serverName];
 		if (jobCache) {
 			this._jobCacheObject = jobCache;
 		} else {
 			this._jobCacheObject = new JobCacheObject();
-			this._jobCacheObject.serverName = serverName;
-			this._jobManagementService.addToCache(serverName, this._jobCacheObject);
+			this._jobCacheObject.serverName = this._serverName;
+			this._jobManagementService.addToCache(this._serverName, this._jobCacheObject);
 		}
 	}
 
@@ -124,8 +129,17 @@ export class JobHistoryComponent extends Disposable implements OnInit {
 			renderer: this._treeRenderer
 		}, {verticalScrollMode: ScrollbarVisibility.Visible});
 		this._register(attachListStyler(this._tree, this.themeService));
-		this._tree.layout(1024);
+		this._tree.layout(JobHistoryComponent.INITIAL_TREE_HEIGHT);
 		this._initActionBar();
+		$(window).resize(() => {
+			let historyDetails = $('.overview-container').get(0);
+			let statusBar = $('.part.statusbar').get(0);
+			if (historyDetails && statusBar) {
+				let historyBottom = historyDetails.getBoundingClientRect().bottom;
+				let statusTop = statusBar.getBoundingClientRect().top;
+				this._tree.layout(statusTop - historyBottom - JobHistoryComponent.HEADING_HEIGHT);
+			}
+		});
 	}
 
 	ngAfterContentChecked() {
@@ -196,8 +210,8 @@ export class JobHistoryComponent extends Disposable implements OnInit {
 				self._stepRows = self.agentJobHistoryInfo.steps.map(step => {
 					let stepViewRow = new JobStepsViewRow();
 					stepViewRow.message = step.message;
-					stepViewRow.runStatus = AgentJobUtilities.convertToStatusString(step.runStatus);
-					self._runStatus = AgentJobUtilities.convertToStatusString(self.agentJobHistoryInfo.runStatus);
+					stepViewRow.runStatus = JobManagementUtilities.convertToStatusString(step.runStatus);
+					self._runStatus = JobManagementUtilities.convertToStatusString(self.agentJobHistoryInfo.runStatus);
 					stepViewRow.stepName = step.stepName;
 					stepViewRow.stepID = step.stepId.toString();
 					return stepViewRow;
@@ -210,7 +224,7 @@ export class JobHistoryComponent extends Disposable implements OnInit {
 		}
 	}
 
-	private buildHistoryTree(self: any, jobHistories: AgentJobHistoryInfo[]) {
+	private buildHistoryTree(self: any, jobHistories: sqlops.AgentJobHistoryInfo[]) {
 		self._treeController.jobHistories = jobHistories;
 		self._jobCacheObject.setJobHistory(self._agentViewComponent.jobId, jobHistories);
 		let jobHistoryRows = this._treeController.jobHistories.map(job => self.convertToJobHistoryRow(job));
@@ -237,10 +251,10 @@ export class JobHistoryComponent extends Disposable implements OnInit {
 		this._agentViewComponent.showHistory = false;
 	}
 
-	private convertToJobHistoryRow(historyInfo: AgentJobHistoryInfo): JobHistoryRow {
+	private convertToJobHistoryRow(historyInfo: sqlops.AgentJobHistoryInfo): JobHistoryRow {
 		let jobHistoryRow = new JobHistoryRow();
 		jobHistoryRow.runDate = this.formatTime(historyInfo.runDate);
-		jobHistoryRow.runStatus = AgentJobUtilities.convertToStatusString(historyInfo.runStatus);
+		jobHistoryRow.runStatus = JobManagementUtilities.convertToStatusString(historyInfo.runStatus);
 		jobHistoryRow.instanceID = historyInfo.instanceId;
 		return jobHistoryRow;
 	}
@@ -256,19 +270,21 @@ export class JobHistoryComponent extends Disposable implements OnInit {
 	private setActions(): void {
 		let startIcon: HTMLElement = $('.action-label.icon.runJobIcon').get(0);
 		let stopIcon: HTMLElement = $('.action-label.icon.stopJobIcon').get(0);
-		AgentJobUtilities.getActionIconClassName(startIcon, stopIcon, this.agentJobInfo.currentExecutionStatus);
+		JobManagementUtilities.getActionIconClassName(startIcon, stopIcon, this.agentJobInfo.currentExecutionStatus);
 	}
 
 
 	private _initActionBar() {
 		let runJobAction = this.instantiationService.createInstance(RunJobAction);
 		let stopJobAction = this.instantiationService.createInstance(StopJobAction);
+		let newStepAction = this.instantiationService.createInstance(NewStepAction);
 		let taskbar = <HTMLElement>this._actionbarContainer.nativeElement;
 		this._actionBar = new Taskbar(taskbar, this.contextMenuService);
 		this._actionBar.context = this;
 		this._actionBar.setContent([
 			{ action: runJobAction },
-			{ action: stopJobAction }
+			{ action: stopJobAction },
+			{ action: newStepAction }
 		]);
 	}
 
@@ -286,6 +302,10 @@ export class JobHistoryComponent extends Disposable implements OnInit {
 		return this._dashboardService.connectionManagementService.connectionInfo.ownerUri;
 	}
 
+	public get serverName(): string {
+		return this._serverName;
+	}
+
 	/** SETTERS */
 
 	public set showSteps(value: boolean) {

src/sql/parts/jobManagement/views/jobHistory.css

@@ -122,6 +122,15 @@ input#accordion:checked ~ .accordion-content {
 	background-image: url('../common/media/stop.svg');
 }
 
+.vs .action-label.icon.newStepIcon {
+	background-image: url('../common/media/new.svg');
+}
+
+.vs-dark .action-label.icon.newStepIcon,
+.hc-black .action-label.icon.newStepIcon {
+	background-image: url('../common/media/new_inverse.svg');
+}
+
 a.action-label.icon.runJobIcon.non-runnable {
 	opacity: 0.4;
 	cursor: default;
@@ -221,10 +230,6 @@ table.step-list tr.step-row td {
 	min-height: 40px !important;
 }
 
-jobhistory-component .history-details .step-table.prev-run-list .monaco-scrollable-element {
-	overflow-y: scroll !important;
-}
-
 jobhistory-component .jobhistory-heading-container {
 	display: -webkit-box;
 }
@@ -238,7 +243,6 @@ jobhistory-component > .jobhistory-heading-container > .icon.in-progress {
 
 jobhistory-component > .actionbar-container .monaco-action-bar > ul.actions-container {
 	border-top: 3px solid #f4f4f4;
-	padding-top: 10px;
 }
 
 .vs-dark jobhistory-component > .actionbar-container .monaco-action-bar > ul.actions-container {

src/sql/parts/jobManagement/views/jobHistoryActions.ts

@@ -1,86 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the Source EULA. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { TPromise } from 'vs/base/common/winjs.base';
-import { Action } from 'vs/base/common/actions';
-import * as nls from 'vs/nls';
-import { INotificationService } from 'vs/platform/notification/common/notification';
-import Severity from 'vs/base/common/severity';
-import { JobHistoryComponent } from 'sql/parts/jobManagement/views/jobHistory.component';
-import { IJobManagementService } from '../common/interfaces';
-
-export enum JobHistoryActions {
-	Run = 'run',
-	Stop = 'stop',
-}
-export class RunJobAction extends Action {
-	public static ID = 'jobaction.runJob';
-	public static LABEL = nls.localize('jobaction.run', "Run");
-
-	constructor(
-		@INotificationService private notificationService: INotificationService,
-		@IJobManagementService private jobManagementService: IJobManagementService
-	) {
-		super(RunJobAction.ID, RunJobAction.LABEL, 'runJobIcon');
-	}
-
-	public run(context: JobHistoryComponent): TPromise<boolean> {
-		let jobName = context.agentJobInfo.name;
-		let ownerUri = context.ownerUri;
-		return new TPromise<boolean>((resolve, reject) => {
-			this.jobManagementService.jobAction(ownerUri, jobName, JobHistoryActions.Run).then(result => {
-				if (result.success) {
-					var startMsg = nls.localize('jobSuccessfullyStarted', ': The job was successfully started.');
-					this.notificationService.notify({
-						severity: Severity.Info,
-						message: jobName+ startMsg
-					});
-					resolve(true);
-				} else {
-					this.notificationService.notify({
-						severity: Severity.Error,
-						message: result.errorMessage
-					});
-					resolve(false);
-				}
-			});
-		});
-	}
-}
-
-export class StopJobAction extends Action {
-	public static ID = 'jobaction.stopJob';
-	public static LABEL = nls.localize('jobaction.stop', "Stop");
-
-	constructor(
-		@INotificationService private notificationService: INotificationService,
-		@IJobManagementService private jobManagementService: IJobManagementService
-	) {
-		super(StopJobAction.ID, StopJobAction.LABEL, 'stopJobIcon');
-	}
-
-	public run(context: JobHistoryComponent): TPromise<boolean> {
-		let jobName = context.agentJobInfo.name;
-		let ownerUri = context.ownerUri;
-		return new TPromise<boolean>((resolve, reject) => {
-			this.jobManagementService.jobAction(ownerUri, jobName, JobHistoryActions.Stop).then(result => {
-				if (result.success) {
-						var stopMsg = nls.localize('jobSuccessfullyStopped', ': The job was successfully stopped.');
-						this.notificationService.notify({
-							severity: Severity.Info,
-							message: jobName+ stopMsg
-						});
-					resolve(true);
-				} else {
-					this.notificationService.notify({
-						severity: Severity.Error,
-						message: result.errorMessage
-					});
-					resolve(false);
-				}
-			});
-		});
-	}
-}

src/sql/parts/jobManagement/views/jobManagementView.ts

@@ -0,0 +1,110 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ElementRef, AfterContentChecked, ViewChild } from '@angular/core';
+import { Table } from 'sql/base/browser/ui/table/table';
+import { AgentViewComponent } from 'sql/parts/jobManagement/agent/agentView.component';
+import { CommonServiceInterface } from 'sql/services/common/commonServiceInterface.service';
+import { IAction, Action } from 'vs/base/common/actions';
+import { ResolvedKeybinding } from 'vs/base/common/keyCodes';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { TPromise } from 'vs/base/common/winjs.base';
+import { IContextMenuService } from 'vs/platform/contextview/browser/contextView';
+import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import { Taskbar } from '../../../base/browser/ui/taskbar/taskbar';
+import { JobsRefreshAction } from 'sql/parts/jobManagement/common/jobActions';
+
+export abstract class JobManagementView extends Disposable implements AfterContentChecked {
+	protected isVisible: boolean = false;
+	protected isInitialized: boolean = false;
+	protected isRefreshing: boolean = false;
+	protected _showProgressWheel: boolean;
+	protected _visibilityElement: ElementRef;
+	protected _parentComponent: AgentViewComponent;
+	protected _table: Table<any>;
+	protected _actionBar: Taskbar;
+	public contextAction: any;
+
+	@ViewChild('actionbarContainer') protected actionBarContainer: ElementRef;
+
+	constructor(
+		protected _commonService: CommonServiceInterface,
+		protected _contextMenuService: IContextMenuService,
+		protected _keybindingService: IKeybindingService,
+		protected _instantiationService: IInstantiationService) {
+		super();
+	}
+
+	ngAfterContentChecked() {
+		if (this._visibilityElement && this._parentComponent) {
+			if (this.isVisible === false && this._visibilityElement.nativeElement.offsetParent !== null) {
+				this.isVisible = true;
+				if (!this.isInitialized) {
+					this._showProgressWheel = true;
+					this.onFirstVisible();
+					this.isInitialized = true;
+				}
+			} else if (this.isVisible === true && this._parentComponent.refresh === true) {
+				this._showProgressWheel = true;
+				this.onFirstVisible();
+				this.isRefreshing = true;
+				this._parentComponent.refresh = false;
+			} else if (this.isVisible === true && this._visibilityElement.nativeElement.offsetParent === null) {
+				this.isVisible = false;
+			}
+		}
+	}
+
+	abstract onFirstVisible();
+
+	protected openContextMenu(event): void {
+		let grid = this._table.grid;
+		let rowIndex = grid.getCellFromEvent(event).row;
+
+		let targetObject = this.getCurrentTableObject(rowIndex);
+		let actions = this.getTableActions();
+		if (actions) {
+			let ownerUri: string = this._commonService.connectionManagementService.connectionInfo.ownerUri;
+			let actionContext= {
+				ownerUri: ownerUri,
+				targetObject: targetObject
+			};
+
+			let anchor = { x: event.pageX + 1, y: event.pageY };
+			this._contextMenuService.showContextMenu({
+				getAnchor: () => anchor,
+				getActions: () => actions,
+				getKeyBinding: (action) => this._keybindingFor(action),
+				getActionsContext: () => (actionContext)
+			});
+		}
+	}
+
+	protected _keybindingFor(action: IAction): ResolvedKeybinding {
+		var [kb] = this._keybindingService.lookupKeybindings(action.id);
+		return kb;
+	}
+
+	protected getTableActions(): TPromise<IAction[]> {
+		return undefined;
+	}
+
+	protected getCurrentTableObject(rowIndex: number): any {
+		return undefined;
+	}
+
+	protected initActionBar() {
+		let refreshAction = this._instantiationService.createInstance(JobsRefreshAction);
+		let newAction: Action = this._instantiationService.createInstance(this.contextAction);
+		let taskbar = <HTMLElement>this.actionBarContainer.nativeElement;
+		this._actionBar = new Taskbar(taskbar, this._contextMenuService);
+		this._actionBar.context = this;
+		this._actionBar.setContent([
+			{ action: refreshAction },
+			{ action: newAction }
+		]);
+	}
+}