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

* Initial port of release/0.24 source code

* Fix additional headers

* Fix a typo in launch.json

src/sql/workbench/common/actions.contribution.ts

@@ -10,7 +10,7 @@ import * as nls from 'vs/nls';
 
 import { SyncActionDescriptor } from 'vs/platform/actions/common/actions';
 import { Registry } from 'vs/platform/registry/common/platform';
-import { IWorkbenchActionRegistry, Extensions as ActionExtensions } from 'vs/workbench/common/actionRegistry';
+import { IWorkbenchActionRegistry, Extensions as ActionExtensions } from 'vs/workbench/common/actions';
 import { IWorkbenchContributionsRegistry, Extensions as WorkbenchExtensions } from 'vs/workbench/common/contributions';
 import { ShowCurrentReleaseNotesAction, ProductContribution } from 'sql/workbench/update/releaseNotes';
 
@@ -41,6 +41,7 @@ const configureDashboardSchema: IJSONSchema = {
 registerTask('backup', '', backupSchema, Actions.BackupAction);
 registerTask('restore', '', restoreSchema, Actions.RestoreAction);
 registerTask('new-query', '', newQuerySchema, Actions.NewQueryAction);
+
 registerTask('configure-dashboard', '', configureDashboardSchema, Actions.ConfigureDashboardAction);
 
 // add product update and release notes contributions

src/sql/workbench/common/actions.ts

@@ -7,7 +7,6 @@ import { IConnectionManagementService, IErrorMessageService } from 'sql/parts/co
 import * as TaskUtilities from './taskUtilities';
 import { IQueryEditorService } from 'sql/parts/query/common/queryEditorService';
 import { IConnectionProfile } from 'sql/parts/connection/common/interfaces';
-import { ConnectionManagementInfo } from 'sql/parts/connection/common/connectionManagementInfo';
 import { IInsightsConfig } from 'sql/parts/dashboard/widgets/insights/interfaces';
 import { IScriptingService } from 'sql/services/scripting/scriptingService';
 import { IDisasterRecoveryUiService, IRestoreDialogController } from 'sql/parts/disasterRecovery/common/interfaces';
@@ -17,6 +16,7 @@ import { IAdminService } from 'sql/parts/admin/common/adminService';
 import * as Constants from 'sql/common/constants';
 import { ObjectMetadata } from 'data';
 import { ScriptOperation } from 'sql/workbench/common/taskUtilities';
+import { TaskAction } from 'sql/platform/tasks/taskRegistry';
 
 import { TPromise } from 'vs/base/common/winjs.base';
 import { Action } from 'vs/base/common/actions';
@@ -24,30 +24,19 @@ import { IWindowsService } from 'vs/platform/windows/common/windows';
 
 import * as nls from 'vs/nls';
 
-export class TaskAction extends Action {
-	constructor(id: string, label: string, private _icon: string) {
-		super(id, label);
-	}
-
-	get icon(): string {
-		return this._icon;
-	}
-}
-
-export interface BaseActionContext extends ITaskActionContext {
-	uri?: string;
+export interface BaseActionContext {
 	object?: ObjectMetadata;
-	connInfo?: ConnectionManagementInfo;
-}
-
-export interface ITaskActionContext {
-	profile: IConnectionProfile;
+	profile?: IConnectionProfile;
 }
 
 export interface InsightActionContext extends BaseActionContext {
 	insight: IInsightsConfig;
 }
 
+export interface ManageActionContext extends BaseActionContext {
+	uri: string;
+}
+
 // --- actions
 export class NewQueryAction extends TaskAction {
 	public static ID = 'newQuery';
@@ -62,7 +51,7 @@ export class NewQueryAction extends TaskAction {
 		super(id, label, icon);
 	}
 
-	public run(actionContext: ITaskActionContext): TPromise<boolean> {
+	public run(actionContext: BaseActionContext): TPromise<boolean> {
 		return new TPromise<boolean>((resolve, reject) => {
 			TaskUtilities.newQuery(
 				actionContext.profile,
@@ -98,7 +87,6 @@ export class ScriptSelectAction extends Action {
 			TaskUtilities.scriptSelect(
 				actionContext.profile,
 				actionContext.object,
-				actionContext.uri,
 				this._connectionManagementService,
 				this._queryEditorService,
 				this._scriptingService
@@ -113,6 +101,78 @@ export class ScriptSelectAction extends Action {
 	}
 }
 
+export class ScriptExecuteAction extends Action {
+	public static ID = 'scriptExecute';
+	public static LABEL = nls.localize('scriptExecute', 'Script As Execute');
+
+	constructor(
+		id: string, label: string,
+		@IQueryEditorService protected _queryEditorService: IQueryEditorService,
+		@IConnectionManagementService protected _connectionManagementService: IConnectionManagementService,
+		@IScriptingService protected _scriptingService: IScriptingService,
+		@IErrorMessageService protected _errorMessageService: IErrorMessageService
+	) {
+		super(id, label);
+	}
+
+	public run(actionContext: BaseActionContext): TPromise<boolean> {
+		return new TPromise<boolean>((resolve, reject) => {
+			TaskUtilities.script(
+				actionContext.profile,
+				actionContext.object,
+				this._connectionManagementService,
+				this._queryEditorService,
+				this._scriptingService,
+				ScriptOperation.Execute,
+				this._errorMessageService
+			).then(
+				result => {
+					resolve(true);
+				},
+				error => {
+					resolve(false);
+				}
+				);
+		});
+	}
+}
+
+export class ScriptAlterAction extends Action {
+	public static ID = 'scriptAlter';
+	public static LABEL = nls.localize('scriptAlter', 'Script As Alter');
+
+	constructor(
+		id: string, label: string,
+		@IQueryEditorService protected _queryEditorService: IQueryEditorService,
+		@IConnectionManagementService protected _connectionManagementService: IConnectionManagementService,
+		@IScriptingService protected _scriptingService: IScriptingService,
+		@IErrorMessageService protected _errorMessageService: IErrorMessageService
+	) {
+		super(id, label);
+	}
+
+	public run(actionContext: BaseActionContext): TPromise<boolean> {
+		return new TPromise<boolean>((resolve, reject) => {
+			TaskUtilities.script(
+				actionContext.profile,
+				actionContext.object,
+				this._connectionManagementService,
+				this._queryEditorService,
+				this._scriptingService,
+				ScriptOperation.Alter,
+				this._errorMessageService
+			).then(
+				result => {
+					resolve(true);
+				},
+				error => {
+					resolve(false);
+				}
+				);
+		});
+	}
+}
+
 export class EditDataAction extends Action {
 	public static ID = 'editData';
 	public static LABEL = nls.localize('editData', 'Edit Data');
@@ -164,7 +224,6 @@ export class ScriptCreateAction extends Action {
 			TaskUtilities.script(
 				actionContext.profile,
 				actionContext.object,
-				actionContext.uri,
 				this._connectionManagementService,
 				this._queryEditorService,
 				this._scriptingService,
@@ -201,7 +260,6 @@ export class ScriptDeleteAction extends Action {
 			TaskUtilities.script(
 				actionContext.profile,
 				actionContext.object,
-				actionContext.uri,
 				this._connectionManagementService,
 				this._queryEditorService,
 				this._scriptingService,
@@ -231,7 +289,7 @@ export class BackupAction extends TaskAction {
 		super(id, label, icon);
 	}
 
-	run(actionContext: ITaskActionContext): TPromise<boolean> {
+	run(actionContext: BaseActionContext): TPromise<boolean> {
 		return new TPromise<boolean>((resolve, reject) => {
 			TaskUtilities.showBackup(
 				actionContext.profile,
@@ -260,7 +318,7 @@ export class RestoreAction extends TaskAction {
 		super(id, label, icon);
 	}
 
-	run(actionContext: ITaskActionContext): TPromise<boolean> {
+	run(actionContext: BaseActionContext): TPromise<boolean> {
 		return new TPromise<boolean>((resolve, reject) => {
 			TaskUtilities.showRestore(
 				actionContext.profile,
@@ -289,7 +347,7 @@ export class ManageAction extends Action {
 		super(id, label);
 	}
 
-	run(actionContext: BaseActionContext): TPromise<boolean> {
+	run(actionContext: ManageActionContext): TPromise<boolean> {
 		let self = this;
 		return new TPromise<boolean>((resolve, reject) => {
 			self._connectionManagementService.connect(actionContext.profile, actionContext.uri, { showDashboard: true, saveTheConnection: false, params: undefined, showConnectionDialogOnError: false, showFirewallRuleOnError: true }).then(
@@ -338,7 +396,7 @@ export class NewDatabaseAction extends TaskAction {
 		super(id, label, icon);
 	}
 
-	run(actionContext: ITaskActionContext): TPromise<boolean> {
+	run(actionContext: BaseActionContext): TPromise<boolean> {
 		return new TPromise<boolean>((resolve, reject) => {
 			TaskUtilities.showCreateDatabase(actionContext.profile, this._adminService, this._errorMessageService);
 		});
@@ -357,7 +415,7 @@ export class ConfigureDashboardAction extends TaskAction {
 		super(id, label, icon);
 	}
 
-	run(actionContext: ITaskActionContext): TPromise<boolean> {
+	run(actionContext: BaseActionContext): TPromise<boolean> {
 		return new TPromise<boolean>((resolve, reject) => {
 			this._windowsService.openExternal(ConfigureDashboardAction.configHelpUri).then((result) => {
 				resolve(result);

src/sql/workbench/common/sqlWorkbenchUtils.ts

@@ -30,31 +30,10 @@ export function getSqlConfigValue<T>(workspaceConfigService: IWorkspaceConfigura
 	return config[configName];
 }
 
-/**
- * Executes a copy operation for an arbitrary string, by creating a temp div, copying
- * the text to it, and calling copy on the document. This will clear any existing selection
- * so if being called where selection state needs to be preserved, it's recommended to
- * cache the existing selection first and re-set it after this method is called
- *
- * @export
- * @param {string} text
- */
-export function executeCopy(text: string): void {
-	let input = document.createElement('textarea');
-	document.body.appendChild(input);
-	input.value = text;
-	input.style.position = 'absolute';
-	input.style.bottom = '100%';
-	input.focus();
-	input.select();
-	document.execCommand('copy');
-	input.remove();
-}
-
-export function getEditorUri(input: IEditorInput): string{
+export function getEditorUri(input: IEditorInput): string {
 	let uri: URI;
 	if (input instanceof QueryInput) {
-		let queryCast: QueryInput = <QueryInput> input;
+		let queryCast: QueryInput = <QueryInput>input;
 		if (queryCast) {
 			uri = queryCast.getResource();
 		}

src/sql/workbench/common/taskUtilities.ts

@@ -25,61 +25,66 @@ import os = require('os');
 import path = require('path');
 
 // map for the version of SQL Server (default is 140)
-let scriptCompatibilityOptionMap = new Map<number, string>();
-scriptCompatibilityOptionMap.set(90, "Script90Compat");
-scriptCompatibilityOptionMap.set(100, "Script100Compat");
-scriptCompatibilityOptionMap.set(105, "Script105Compat");
-scriptCompatibilityOptionMap.set(110, "Script110Compat");
-scriptCompatibilityOptionMap.set(120, "Script120Compat");
-scriptCompatibilityOptionMap.set(130, "Script130Compat");
-scriptCompatibilityOptionMap.set(140, "Script140Compat");
+const scriptCompatibilityOptionMap = {
+	90: 'Script90Compat',
+	100: 'Script100Compat',
+	105: 'Script105Compat',
+	110: 'Script110Compat',
+	120: 'Script120Compat',
+	130: 'Script130Compat',
+	140: 'Script140Compat'
+};
 
 // map for the target database engine edition (default is Enterprise)
-let targetDatabaseEngineEditionMap = new Map<number, string>();
-targetDatabaseEngineEditionMap.set(0, "SqlServerEnterpriseEdition");
-targetDatabaseEngineEditionMap.set(1, "SqlServerPersonalEdition");
-targetDatabaseEngineEditionMap.set(2, "SqlServerStandardEdition");
-targetDatabaseEngineEditionMap.set(3, "SqlServerEnterpriseEdition");
-targetDatabaseEngineEditionMap.set(4, "SqlServerExpressEdition");
-targetDatabaseEngineEditionMap.set(5, "SqlAzureDatabaseEdition");
-targetDatabaseEngineEditionMap.set(6, "SqlDatawarehouseEdition");
-targetDatabaseEngineEditionMap.set(7, "SqlServerStretchEdition");
+const targetDatabaseEngineEditionMap = {
+	0: 'SqlServerEnterpriseEdition',
+	1: 'SqlServerPersonalEdition',
+	2: 'SqlServerStandardEdition',
+	3: 'SqlServerEnterpriseEdition',
+	4: 'SqlServerExpressEdition',
+	5: 'SqlAzureDatabaseEdition',
+	6: 'SqlDatawarehouseEdition',
+	7: 'SqlServerStretchEdition'
+};
 
 // map for object types for scripting
-let objectScriptMap = new Map<string, string>();
-objectScriptMap.set("Table", "Table");
-objectScriptMap.set("View", "View");
-objectScriptMap.set("StoredProcedure", "Procedure");
-objectScriptMap.set("UserDefinedFunction", "Function");
-objectScriptMap.set("UserDefinedDataType", "Type");
-objectScriptMap.set("User", "User");
-objectScriptMap.set("Default", "Default");
-objectScriptMap.set("Rule", "Rule");
-objectScriptMap.set("DatabaseRole", "Role");
-objectScriptMap.set("ApplicationRole", "Application Role");
-objectScriptMap.set("SqlAssembly", "Assembly");
-objectScriptMap.set("DdlTrigger", "Trigger");
-objectScriptMap.set("Synonym", "Synonym");
-objectScriptMap.set("XmlSchemaCollection", "Xml Schema Collection");
-objectScriptMap.set("Schema", "Schema");
-objectScriptMap.set("PlanGuide", "sp_create_plan_guide");
-objectScriptMap.set("UserDefinedType", "Type");
-objectScriptMap.set("UserDefinedAggregate", "Aggregate");
-objectScriptMap.set("FullTextCatalog", "Fulltext Catalog");
-objectScriptMap.set("UserDefinedTableType", "Type");
-objectScriptMap.set("MaterializedView", "Materialized View");
+const objectScriptMap = {
+	Table: 'Table',
+	View: 'View',
+	StoredProcedure: 'Procedure',
+	UserDefinedFunction: 'Function',
+	UserDefinedDataType: 'Type',
+	User: 'User',
+	Default: 'Default',
+	Rule: 'Rule',
+	DatabaseRole: 'Role',
+	ApplicationRole: 'Application Role',
+	SqlAssembly: 'Assembly',
+	DdlTrigger: 'Trigger',
+	Synonym: 'Synonym',
+	XmlSchemaCollection: 'Xml Schema Collection',
+	Schema: 'Schema',
+	PlanGuide: 'sp_create_plan_guide',
+	UserDefinedType: 'Type',
+	UserDefinedAggregate: 'Aggregate',
+	FullTextCatalog: 'Fulltext Catalog',
+	UserDefinedTableType: 'Type',
+	MaterializedView: 'Materialized View'
+};
 
 export enum ScriptOperation {
 	Select = 0,
 	Create = 1,
 	Insert = 2,
 	Update = 3,
-	Delete = 4
+	Delete = 4,
+	Execute = 5,
+	Alter = 6
 }
 
 export function GetScriptOperationName(operation: ScriptOperation) {
 	let defaultName: string = ScriptOperation[operation];
-	switch(operation) {
+	switch (operation) {
 		case ScriptOperation.Select:
 			return nls.localize('selectOperationName', 'Select');
 		case ScriptOperation.Create:
@@ -124,11 +129,11 @@ export function connectIfNotAlreadyConnected(connectionProfile: IConnectionProfi
 /**
  * Select the top rows from an object
  */
-export function scriptSelect(connectionProfile: IConnectionProfile, metadata: data.ObjectMetadata, ownerUri: string, connectionService: IConnectionManagementService, queryEditorService: IQueryEditorService, scriptingService: IScriptingService): Promise<void> {
+export function scriptSelect(connectionProfile: IConnectionProfile, metadata: data.ObjectMetadata, connectionService: IConnectionManagementService, queryEditorService: IQueryEditorService, scriptingService: IScriptingService): Promise<void> {
 	return new Promise<void>((resolve, reject) => {
-		connectIfNotAlreadyConnected(connectionProfile, connectionService).then(connectionResult => {
-			let paramDetails: data.ScriptingParamDetails = getScriptingParamDetails(connectionService, ownerUri, metadata);
-			scriptingService.script(ownerUri, metadata, ScriptOperation.Select, paramDetails).then(result => {
+		connectionService.connectIfNotConnected(connectionProfile).then(connectionResult => {
+			let paramDetails: data.ScriptingParamDetails = getScriptingParamDetails(connectionService, connectionResult, metadata);
+			scriptingService.script(connectionResult, metadata, ScriptOperation.Select, paramDetails).then(result => {
 				if (result.script) {
 					queryEditorService.newSqlEditor(result.script).then((owner: IConnectableInput) => {
 						// Connect our editor to the input connection
@@ -151,7 +156,7 @@ export function scriptSelect(connectionProfile: IConnectionProfile, metadata: da
 				}
 			}, scriptError => {
 				reject(scriptError);
-			})
+			});
 		});
 	});
 }
@@ -180,24 +185,20 @@ export function editData(connectionProfile: IConnectionProfile, tableName: strin
 /**
  * Script the object as a statement based on the provided action (except Select)
  */
-export function script(connectionProfile: IConnectionProfile, metadata: data.ObjectMetadata, ownerUri: string,
+export function script(connectionProfile: IConnectionProfile, metadata: data.ObjectMetadata,
 	connectionService: IConnectionManagementService,
 	queryEditorService: IQueryEditorService,
 	scriptingService: IScriptingService,
 	operation: ScriptOperation,
 	errorMessageService: IErrorMessageService): Promise<void> {
 	return new Promise<void>((resolve, reject) => {
-		connectIfNotAlreadyConnected(connectionProfile, connectionService).then(connectionResult => {
-			let paramDetails = getScriptingParamDetails(connectionService, ownerUri, metadata);
-			scriptingService.script(ownerUri, metadata, operation, paramDetails).then(result => {
+		connectionService.connectIfNotConnected(connectionProfile).then(connectionResult => {
+			let paramDetails = getScriptingParamDetails(connectionService, connectionResult, metadata);
+			scriptingService.script(connectionResult, metadata, operation, paramDetails).then(result => {
 				if (result) {
 					let script: string = result.script;
-					let startPos: number = 0;
-					if (connectionProfile.providerName === "MSSQL") {
-						startPos = getStartPos(script, operation, metadata.metadataTypeName);
-					}
-					if (startPos >= 0) {
-						script = script.substring(startPos);
+
+					if (script) {
 						queryEditorService.newSqlEditor(script, connectionProfile.providerName).then(() => {
 							resolve();
 						}).catch(editorError => {
@@ -206,14 +207,16 @@ export function script(connectionProfile: IConnectionProfile, metadata: data.Obj
 					}
 					else {
 						let scriptNotFoundMsg = nls.localize('scriptNotFoundForObject', 'No script was returned when scripting as {0} on object {1}',
-													GetScriptOperationName(operation), metadata.metadataTypeName);
+							GetScriptOperationName(operation), metadata.metadataTypeName);
+						let messageDetail = '';
 						let operationResult = scriptingService.getOperationFailedResult(result.operationId);
 						if (operationResult && operationResult.hasError && operationResult.errorMessage) {
 							scriptNotFoundMsg = operationResult.errorMessage;
+							messageDetail = operationResult.errorDetails;
 						}
 						if (errorMessageService) {
 							let title = nls.localize('scriptingFailed', 'Scripting Failed');
-							errorMessageService.showDialog(Severity.Error, title, scriptNotFoundMsg);
+							errorMessageService.showDialog(Severity.Error, title, scriptNotFoundMsg, messageDetail);
 						}
 						reject(scriptNotFoundMsg);
 					}
@@ -258,7 +261,8 @@ export function replaceConnection(oldUri: string, newUri: string, connectionServ
 		let defaultResult: IConnectionResult = {
 			connected: false,
 			errorMessage: undefined,
-			errorCode: undefined
+			errorCode: undefined,
+			callStack: undefined
 		};
 		if (connectionService) {
 			let connectionProfile = connectionService.getConnectionProfile(oldUri);
@@ -328,7 +332,7 @@ export function openInsight(query: IInsightsConfig, profile: IConnectionProfile,
 
 /* Helper Methods */
 function getStartPos(script: string, operation: ScriptOperation, typeName: string): number {
-	let objectTypeName = objectScriptMap.get(typeName);
+	let objectTypeName = objectScriptMap[typeName];
 	if (objectTypeName && script) {
 		let scriptTypeName = objectTypeName.toLowerCase();
 		switch (operation) {
@@ -353,7 +357,7 @@ function getScriptingParamDetails(connectionService: IConnectionManagementServic
 		scriptCompatibilityOption: scriptCompatibilityOptionMap[serverInfo.serverMajorVersion],
 		targetDatabaseEngineEdition: targetDatabaseEngineEditionMap[serverInfo.engineEditionId],
 		targetDatabaseEngineType: serverInfo.isCloud ? 'SqlAzure' : 'SingleInstance'
-	}
+	};
 	return paramDetails;
 }