SQL Operations Studio Public Preview 1 (0.23) release source code

src/sql/parts/fileBrowser/common/fileBrowserService.ts

@@ -0,0 +1,235 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 data from 'data';
+import * as DialogHelper from 'sql/base/browser/ui/modal/dialogHelper';
+import { IConnectionManagementService, IErrorMessageService } from 'sql/parts/connection/common/connectionManagement';
+import { FileBrowserTree } from 'sql/parts/fileBrowser/common/fileBrowserTree';
+import { FileNode } from 'sql/parts/fileBrowser/common/fileNode';
+import { FileBrowserDialog } from 'sql/parts/fileBrowser/fileBrowserDialog';
+import { IFileBrowserService } from 'sql/parts/fileBrowser/common/interfaces';
+import * as Constants from 'sql/common/constants';
+import Event, { Emitter } from 'vs/base/common/event';
+import Severity from 'vs/base/common/severity';
+import { localize } from 'vs/nls';
+import { createDecorator, IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+
+export class FileBrowserService implements IFileBrowserService {
+	public _serviceBrand: any;
+	private _providers: { [handle: string]: data.FileBrowserProvider; } = Object.create(null);
+	private _onAddFileTree = new Emitter<FileBrowserTree>();
+	private _onExpandFolder = new Emitter<FileNode>();
+	private _onPathValidate = new Emitter<data.FileBrowserValidatedParams>();
+	private _pathToFileNodeMap: { [path: string]: FileNode } = {};
+	private _expandResolveMap: { [key: string]: any }  = {};
+	static fileNodeId: number = 0;
+
+	constructor(@IConnectionManagementService private _connectionService: IConnectionManagementService,
+		@IInstantiationService private _instantiationService: IInstantiationService,
+		@IErrorMessageService private _errorMessageService: IErrorMessageService) {
+	}
+
+	public registerProvider(providerId: string, provider: data.FileBrowserProvider): void {
+		this._providers[providerId] = provider;
+	}
+
+	public get onAddFileTree(): Event<FileBrowserTree> {
+		return this._onAddFileTree.event;
+	}
+
+	public get onExpandFolder(): Event<FileNode> {
+		return this._onExpandFolder.event;
+	}
+
+	public get onPathValidate(): Event<data.FileBrowserValidatedParams> {
+		return this._onPathValidate.event;
+	}
+
+	public openFileBrowser(ownerUri: string, expandPath: string, fileFilters: string[], changeFilter: boolean): Thenable<boolean> {
+		return new Promise<boolean>((resolve, reject) => {
+			let provider = this.getProvider(ownerUri);
+		    if (provider) {
+				provider.openFileBrowser(ownerUri, expandPath, fileFilters, changeFilter).then(result => {
+					resolve(result);
+				}, error => {
+					reject(error);
+				});
+			} else {
+				reject(Constants.InvalidProvider);
+			}
+		});
+	}
+
+	public onFileBrowserOpened(handle: number, fileBrowserOpenedParams: data.FileBrowserOpenedParams) {
+		if (fileBrowserOpenedParams.succeeded === true
+			&& fileBrowserOpenedParams.fileTree
+			&& fileBrowserOpenedParams.fileTree.rootNode
+			&& fileBrowserOpenedParams.fileTree.selectedNode
+		) {
+			var fileTree = this.convertFileTree(null, fileBrowserOpenedParams.fileTree.rootNode, fileBrowserOpenedParams.fileTree.selectedNode.fullPath, fileBrowserOpenedParams.ownerUri);
+			this._onAddFileTree.fire({rootNode: fileTree.rootNode, selectedNode: fileTree.selectedNode, expandedNodes: fileTree.expandedNodes});
+		} else {
+			let genericErrorMessage = localize('fileBrowserErrorMessage', 'An error occured while loading the file browser.');
+			let errorDialogTitle = localize('fileBrowserErrorDialogTitle', 'File Browser Error');
+			let errorMessage = DialogHelper.isNullOrWhiteSpace(fileBrowserOpenedParams.message) ? genericErrorMessage : fileBrowserOpenedParams.message;
+			this._errorMessageService.showDialog(Severity.Error, errorDialogTitle, errorMessage);
+		}
+	}
+
+	public expandFolderNode(fileNode: FileNode): Thenable<FileNode[]> {
+		this._pathToFileNodeMap[fileNode.fullPath] = fileNode;
+		let self = this;
+		return new Promise<FileNode[]>((resolve, reject) => {
+			let provider = this.getProvider(fileNode.ownerUri);
+		    if (provider) {
+				provider.expandFolderNode(fileNode.ownerUri, fileNode.fullPath).then(result => {
+					var mapKey = self.generateResolveMapKey(fileNode.ownerUri, fileNode.fullPath);
+					self._expandResolveMap[mapKey] = resolve;
+				}, error => {
+					reject(error);
+				});
+			} else {
+				reject(Constants.InvalidProvider);
+			}
+		});
+	}
+
+	public onFolderNodeExpanded(handle: number, fileBrowserExpandedParams: data.FileBrowserExpandedParams) {
+		var mapKey = this.generateResolveMapKey(fileBrowserExpandedParams.ownerUri, fileBrowserExpandedParams.expandPath);
+		var expandResolve = this._expandResolveMap[mapKey];
+		if (expandResolve) {
+			if (fileBrowserExpandedParams.succeeded === true)
+			{
+				// get the expanded folder node
+				var expandedNode = this._pathToFileNodeMap[fileBrowserExpandedParams.expandPath];
+				if (expandedNode) {
+					if (fileBrowserExpandedParams.children	&& fileBrowserExpandedParams.children.length > 0) {
+						expandedNode.children = this.convertChildren(expandedNode, fileBrowserExpandedParams.children, fileBrowserExpandedParams.ownerUri);
+					}
+					expandResolve(expandedNode.children ? expandedNode.children : []);
+					this._onExpandFolder.fire(expandedNode);
+				} else {
+					expandResolve([]);
+				}
+			} else {
+				expandResolve([]);
+			}
+		}
+	}
+
+	public validateFilePaths(ownerUri: string, serviceType: string, selectedFiles: string[]): Thenable<boolean> {
+		return new Promise<boolean>((resolve, reject) => {
+			let provider = this.getProvider(ownerUri);
+		    if (provider) {
+				provider.validateFilePaths(ownerUri, serviceType, selectedFiles).then(result => {
+					resolve(result);
+				}, error => {
+					reject(error);
+				});
+			} else {
+				reject(Constants.InvalidProvider);
+			}
+		});
+	}
+
+	public onFilePathsValidated(handle: number, fileBrowserValidatedParams: data.FileBrowserValidatedParams) {
+		this._onPathValidate.fire(fileBrowserValidatedParams);
+	}
+
+	public closeFileBrowser(ownerUri: string): Thenable<data.FileBrowserCloseResponse> {
+		let provider = this.getProvider(ownerUri);
+		if (provider) {
+			return provider.closeFileBrowser(ownerUri);
+		}
+		return Promise.resolve(undefined);
+	}
+
+	private generateResolveMapKey(ownerUri: string, expandPath: string): string {
+		return ownerUri + ':' + expandPath;
+	}
+	private getProvider(connectionUri: string): data.FileBrowserProvider {
+		let providerId: string = this._connectionService.getProviderIdFromUri(connectionUri);
+		if (providerId) {
+			return this._providers[providerId];
+		} else {
+			return undefined;
+		}
+	}
+
+	private convertFileTree(parentNode: FileNode, fileTreeNode: data.FileTreeNode, expandPath: string, ownerUri: string): FileBrowserTree {
+		FileBrowserService.fileNodeId += 1;
+		var expandedNodes: FileNode[] = [];
+		var selectedNode: FileNode;
+		var fileNode = new FileNode(FileBrowserService.fileNodeId.toString(),
+			fileTreeNode.name,
+			fileTreeNode.fullPath,
+			fileTreeNode.isFile,
+			fileTreeNode.isExpanded,
+			ownerUri,
+			parentNode
+		);
+
+		if (fileNode.isExpanded === true) {
+			expandedNodes.push(fileNode);
+		}
+
+		if (fileTreeNode.children) {
+			var convertedChildren = [];
+			for (var i = 0; i < fileTreeNode.children.length; i++) {
+				var convertedFileTree: FileBrowserTree = this.convertFileTree(fileNode, fileTreeNode.children[i], expandPath, ownerUri);
+				convertedChildren.push(convertedFileTree.rootNode);
+
+				if (convertedFileTree.expandedNodes.length > 0) {
+					expandedNodes = expandedNodes.concat(convertedFileTree.expandedNodes);
+				}
+
+				if (convertedFileTree.selectedNode) {
+					selectedNode = convertedFileTree.selectedNode;
+				}
+			}
+
+			if (convertedChildren.length > 0) {
+				fileNode.children = convertedChildren;
+			}
+		}
+
+		if (!selectedNode && fileTreeNode.fullPath === expandPath) {
+			selectedNode = fileNode;
+		}
+
+		// Assume every folder has children initially
+		if (fileTreeNode.isFile === false) {
+			fileNode.hasChildren = true;
+		}
+
+		return { rootNode: fileNode, selectedNode: selectedNode, expandedNodes: expandedNodes };
+	}
+
+	private convertChildren(expandedNode: FileNode, childrenToConvert: data.FileTreeNode[], ownerUri: string): FileNode[] {
+		var childrenNodes = [];
+
+		for (var i = 0; i < childrenToConvert.length; i++) {
+			FileBrowserService.fileNodeId += 1;
+			var childNode = new FileNode(FileBrowserService.fileNodeId.toString(),
+				childrenToConvert[i].name,
+				childrenToConvert[i].fullPath,
+				childrenToConvert[i].isFile,
+				childrenToConvert[i].isExpanded,
+				ownerUri,
+				expandedNode
+			);
+
+			// Assume every folder has children initially
+			if (childrenToConvert[i].isFile === false) {
+				childNode.hasChildren = true;
+			}
+			childrenNodes.push(childNode);
+		}
+
+		return childrenNodes;
+	}
+}

src/sql/parts/fileBrowser/common/fileBrowserTree.ts

@@ -0,0 +1,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';
+import { FileNode } from 'sql/parts/fileBrowser/common/fileNode';
+
+/**
+ * File tree info needed to render initially
+ */
+export class FileBrowserTree {
+	public rootNode: FileNode;
+	public selectedNode: FileNode;
+	public expandedNodes: FileNode[];
+}

src/sql/parts/fileBrowser/common/fileNode.ts

@@ -0,0 +1,72 @@
+/*---------------------------------------------------------------------------------------------
+*  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 { generateUuid } from 'vs/base/common/uuid';
+
+/**
+ * File/folder node in file browser
+ * FileTreeNode is converted to this FileNode for UI interactions
+ */
+export class FileNode {
+	/**
+     * Node id
+     */
+	public id: string;
+
+	/**
+     * Connection uri
+     */
+	public ownerUri: string;
+
+	/**
+     * File or folder name
+     */
+	public name: string;
+
+	/**
+     * Full path of file or folder
+     */
+	public fullPath: string;
+
+	/**
+     * Parent node
+     */
+	public parent: FileNode;
+
+	/**
+     * Children nodes
+     */
+	public children: FileNode[];
+
+	/**
+     * Is the node expanded
+     */
+	public isExpanded: boolean;
+
+	/**
+     * Is the node file or folder
+     */
+	public isFile: boolean;
+
+	/**
+     * Does this node have children
+     */
+	public hasChildren: boolean;
+
+	constructor(id: string, name: string, fullPath: string, isFile: boolean, isExpanded: boolean, ownerUri: string, parent:FileNode) {
+		if (id) {
+			this.id = id;
+		} else {
+			this.id = generateUuid();
+		}
+
+		this.name = name;
+		this.fullPath = fullPath;
+		this.isFile = isFile;
+		this.ownerUri = ownerUri;
+		this.isExpanded = isExpanded;
+		this.parent = parent;
+	}
+}

src/sql/parts/fileBrowser/common/fileValidationServiceConstants.ts

@@ -0,0 +1,11 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/*
+ * List of services that provide file validation callback to file browser service
+ */
+
+export const backup: string = "Backup";
+export const restore: string = "Restore";

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

@@ -0,0 +1,74 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 data from 'data';
+import { FileBrowserTree } from 'sql/parts/fileBrowser/common/fileBrowserTree';
+import { FileNode } from 'sql/parts/fileBrowser/common/fileNode';
+import Event from 'vs/base/common/event';
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+
+export const IFileBrowserDialogController = createDecorator<IFileBrowserDialogController>('fileBrowserDialogService');
+export interface IFileBrowserDialogController {
+	_serviceBrand: any;
+	/**
+	 * Show file browser dialog
+	 */
+	showDialog(ownerUri: string,
+		expandPath: string,
+		fileFilters: [{label: string, filters: string[]}],
+		fileValidationServiceType: string,
+		isWide: boolean,
+		handleOnOk: (path: string) => void): void;
+}
+
+export const IFileBrowserService = createDecorator<IFileBrowserService>('fileBrowserService');
+export interface IFileBrowserService {
+	_serviceBrand: any;
+	onAddFileTree: Event<FileBrowserTree>;
+	onExpandFolder: Event<FileNode>;
+	onPathValidate: Event<data.FileBrowserValidatedParams>;
+
+	/**
+	 * Register file browser provider
+	 */
+	registerProvider(providerId: string, provider: data.FileBrowserProvider): void;
+
+	/**
+	 * Open file browser
+	 */
+	openFileBrowser(ownerUri: string, expandPath: string, fileFilters: string[], changeFilter: boolean): Thenable<boolean>;
+
+	/**
+	 * Event called when file browser is opened
+	 */
+	onFileBrowserOpened(handle: number, fileBrowserOpenedParams: data.FileBrowserOpenedParams);
+
+	/**
+	 * Expand folder node
+	 */
+	expandFolderNode(fileNode: FileNode): Thenable<FileNode[]>;
+
+	/**
+	 * Event called when children nodes are retrieved
+	 */
+	onFolderNodeExpanded(handle: number, fileBrowserExpandedParams: data.FileBrowserExpandedParams);
+
+	/**
+	 * Validate selected file paths
+	 */
+	validateFilePaths(ownerUri: string, serviceType: string, selectedFiles: string[]): Thenable<boolean>;
+
+	/**
+	 * Event called when the validation is complete
+	 */
+	onFilePathsValidated(handle: number, fileBrowserValidatedParams: data.FileBrowserValidatedParams);
+
+	/**
+	 * Close file browser
+	 */
+	closeFileBrowser(ownerUri: string): Thenable<data.FileBrowserCloseResponse>;
+}