Introduce Trust Book in Book Viewlet

extensions/notebook/package.json

@@ -41,6 +41,14 @@
           "type": "number",
           "default": 5000,
           "description": "%notebook.maxTableRows.description%"
+        },
+        "notebook.trustedBooks":{
+          "type": "array",
+          "default": [],
+          "description": "%notebook.trustedBooks.description%",
+          "items": {
+            "type": "string"
+          }
         }
       }
     },
@@ -154,6 +162,15 @@
           "light": "resources/light/save.svg"
         }
       },
+      {
+        "command": "notebook.command.trustBook",
+        "title": "%title.trustBook%",
+        "category": "%books-preview-category%",
+        "icon": {
+          "dark": "resources/dark/trust_inverse.svg",
+          "light": "resources/light/trust.svg"
+        }
+      },
       {
         "command": "notebook.command.searchBook",
         "title": "%title.searchJupyterBook%",
@@ -273,6 +290,10 @@
         {
           "command": "notebook.command.searchUntitledBook",
           "when": "false"
+        },
+        {
+          "command": "notebook.command.trustBook",
+          "when": "false"
         }
       ],
       "touchBar": [
@@ -300,6 +321,11 @@
         }
       ],
       "view/item/context": [
+        {
+          "command": "notebook.command.trustBook",
+          "when": "view == bookTreeView && viewItem == savedBook",
+          "group": "inline"
+        },
         {
           "command": "notebook.command.searchBook",
           "when": "view == bookTreeView && viewItem == savedBook || viewItem  == section",

extensions/notebook/package.nls.json

@@ -6,6 +6,7 @@
 	"notebook.useExistingPython.description": "Local path to a preexisting python installation used by Notebooks.",
 	"notebook.overrideEditorTheming.description": "Override editor default settings in the Notebook editor. Settings include background color, current line color and border",
 	"notebook.maxTableRows.description": "Maximum number of rows returned per table in the Notebook editor",
+	"notebook.trustedBooks.description": "Books to trust automatically.",
 	"notebook.maxBookSearchDepth.description": "Maximum depth of subdirectories to search for Books (Enter 0 for infinite)",
 	"notebook.command.new": "New Notebook",
 	"notebook.command.open": "Open Notebook",
@@ -30,6 +31,7 @@
 	"title.SQL19PreviewBook": "SQL Server 2019 Guide",
 	"books-preview-category": "Jupyter Books",
 	"title.saveJupyterBook": "Save Book",
+	"title.trustBook": "Trust Book",
 	"title.searchJupyterBook": "Search Book",
 	"title.SavedBooks": "Saved Books",
 	"title.UnsavedBooks": "Unsaved Books",

extensions/notebook/src/book/bookTreeView.ts

@@ -7,17 +7,21 @@ import * as azdata from 'azdata';
 import * as vscode from 'vscode';
 import * as path from 'path';
 import * as fs from 'fs-extra';
+import * as nls from 'vscode-nls';
 import { IPrompter, QuestionTypes, IQuestion } from '../prompts/question';
 import CodeAdapter from '../prompts/adapter';
 import { BookTreeItem } from './bookTreeItem';
 import { BookModel } from './bookModel';
 import { Deferred } from '../common/promise';
+import { IBookTrustManager, BookTrustManager } from './bookTrustManager';
 import * as loc from '../common/localizedConstants';
 
+const localize = nls.loadMessageBundle();
+const msgBookTrusted = localize('msgBookTrusted', "Book is now automatically trusted.");
+const msgBookAlreadyTrusted = localize('msgBookAlreadyTrusted', "Book is already trusted.");
 const Content = 'content';
 
 export class BookTreeViewProvider implements vscode.TreeDataProvider<BookTreeItem> {
-
 	private _onDidChangeTreeData: vscode.EventEmitter<BookTreeItem | undefined> = new vscode.EventEmitter<BookTreeItem | undefined>();
 	readonly onDidChangeTreeData: vscode.Event<BookTreeItem | undefined> = this._onDidChangeTreeData.event;
 	private _throttleTimer: any;
@@ -27,6 +31,9 @@ export class BookTreeViewProvider implements vscode.TreeDataProvider<BookTreeIte
 	private _initializeDeferred: Deferred<void> = new Deferred<void>();
 
 	private _openAsUntitled: boolean;
+	private _trustResourceCache: Record<string, boolean> = {};
+	private _bookTrustManager: IBookTrustManager;
+
 	public viewId: string;
 	public books: BookModel[];
 	public currentBook: BookModel;
@@ -38,7 +45,7 @@ export class BookTreeViewProvider implements vscode.TreeDataProvider<BookTreeIte
 		this.initialize(workspaceFolders).catch(e => console.error(e));
 		this.viewId = view;
 		this.prompter = new CodeAdapter();
-
+		this._bookTrustManager = new BookTrustManager(this.books);
 	}
 
 	private async initialize(workspaceFolders: vscode.WorkspaceFolder[]): Promise<void> {
@@ -57,6 +64,16 @@ export class BookTreeViewProvider implements vscode.TreeDataProvider<BookTreeIte
 		return this._initializeDeferred.promise;
 	}
 
+	trustBook(bookTreeItem: BookTreeItem): any {
+		let hasTrustedBook = this._bookTrustManager.setBookAsTrusted(bookTreeItem);
+
+		if (hasTrustedBook) {
+			vscode.window.showInformationMessage(msgBookTrusted);
+		} else {
+			vscode.window.showInformationMessage(msgBookAlreadyTrusted);
+		}
+	}
+
 	async openBook(bookPath: string, urlToOpen?: string): Promise<void> {
 		try {
 			let books: BookModel[] = this.books.filter(book => book.bookPath === bookPath) || [];
@@ -112,8 +129,18 @@ export class BookTreeViewProvider implements vscode.TreeDataProvider<BookTreeIte
 		try {
 			if (this._openAsUntitled) {
 				this.openNotebookAsUntitled(resource);
-			}
-			else {
+			} else {
+				// leave alone cached trusted statuses
+				let cache = this._trustResourceCache;
+				let normalizedResource = path.normalize(resource);
+				if (!cache[normalizedResource] && this._bookTrustManager.isNotebookTrustedByDefault(normalizedResource)) {
+					let openDocumentListenerUnsubscriber = azdata.nb.onDidOpenNotebookDocument(function (document: azdata.nb.NotebookDocument) {
+						document.setTrusted(true);
+						cache[normalizedResource] = true;
+						openDocumentListenerUnsubscriber.dispose();
+					});
+				}
+
 				let doc = await vscode.workspace.openTextDocument(resource);
 				vscode.window.showTextDocument(doc);
 			}
@@ -314,6 +341,4 @@ export class BookTreeViewProvider implements vscode.TreeDataProvider<BookTreeIte
 			default: false
 		});
 	}
-
-
 }

extensions/notebook/src/book/bookTrustManager.ts

@@ -0,0 +1,89 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import * as path from 'path';
+import * as vscode from 'vscode';
+import { BookTreeItem } from './bookTreeItem';
+import { BookModel } from './bookModel';
+
+export interface IBookTrustManager {
+	isNotebookTrustedByDefault(notebookUri: string): boolean;
+	setBookAsTrusted(bookTreeItem: BookTreeItem): boolean;
+}
+
+export class BookTrustManager implements IBookTrustManager {
+
+	private static notebookConfiguration: string = 'notebook';
+	private static notebookTrustedBooksConfiguration: string = 'trustedBooks';
+
+	constructor(private books: BookModel[]) { }
+
+	isNotebookTrustedByDefault(notebookUri: string): boolean {
+		let workspace = this.getNotebookWorkspaceFolder(notebookUri);
+		let normalizedWorkspacePath = path.normalize(workspace.uri.fsPath);
+		let trustedBookDirectory = this.getTrustedBookDirectory(notebookUri, workspace);
+
+		if (workspace && trustedBookDirectory) {
+			let trustedBook = this.getTrustedBook(normalizedWorkspacePath, trustedBookDirectory);
+
+			if (trustedBook) {
+				let fullBookBaseUri = path.join(normalizedWorkspacePath, trustedBookDirectory, 'content');
+				let requestingNotebookFormattedUri = notebookUri.substring(fullBookBaseUri.length).replace('.ipynb', '');
+				let notebookInTOC = trustedBook.tableOfContents.sections.find(jupyterSection => {
+					let normalizedJupyterSectionUrl = jupyterSection.url && path.normalize(jupyterSection.url);
+					return normalizedJupyterSectionUrl === requestingNotebookFormattedUri;
+				});
+				return !!notebookInTOC;
+			}
+		}
+
+		return false;
+	}
+
+	setBookAsTrusted(bookTreeItem: BookTreeItem): boolean {
+		// add this TOC to the configuration list
+		let workspacePathLength: number = path.resolve(vscode.workspace.rootPath).length;
+		let relativeBookPath: string = path.normalize(path.resolve(bookTreeItem.book.root).substring(workspacePathLength + 1));
+		let config: vscode.WorkspaceConfiguration = vscode.workspace.getConfiguration(BookTrustManager.notebookConfiguration);
+		let existingNotebooks: string[] = config[BookTrustManager.notebookTrustedBooksConfiguration];
+
+		// if no match found in the configuration, then add it
+		if (!existingNotebooks.find(notebookPath => path.normalize(notebookPath) === relativeBookPath)) {
+			existingNotebooks.push(relativeBookPath);
+
+			// update the configuration
+			config.update(BookTrustManager.notebookTrustedBooksConfiguration, existingNotebooks);
+			return true;
+		}
+		return false;
+	}
+
+	getTrustedBookDirectory(notebookUri: string, workspace: vscode.WorkspaceFolder): string {
+		let config: vscode.WorkspaceConfiguration = vscode.workspace.getConfiguration(BookTrustManager.notebookConfiguration);
+		let trustedBookDirectories: string[] = config.get(BookTrustManager.notebookTrustedBooksConfiguration);
+		let notebookUriWithoutBase: string = notebookUri.substring(path.normalize(workspace.uri.fsPath).length + 1);
+		return trustedBookDirectories.find(dir => notebookUriWithoutBase.startsWith(dir));
+	}
+
+	getTrustedBook(workspaceUri: string, baseBookUri: string): BookTreeItem {
+		let trustedBook = this.books
+			.map(book => book.bookItems) // select all the books
+			.reduce((accumulator, currentBookItemList) => accumulator.concat(currentBookItemList)) // flatten them to a single list
+			.find(bookTreeItem => {
+				let normalizedRootPath = path.normalize(bookTreeItem.root);
+				let fqnBookRootPath = path.join(workspaceUri, baseBookUri);
+				return normalizedRootPath.startsWith(fqnBookRootPath);
+			});
+		return trustedBook;
+	}
+
+	getNotebookWorkspaceFolder(notebookUri: string): vscode.WorkspaceFolder {
+		let workspace = vscode.workspace;
+		let workspaceFolder = workspace.workspaceFolders.find(wsFolder => {
+			let normalizedWsFolderUri = path.normalize(wsFolder.uri.fsPath);
+			return notebookUri.startsWith(normalizedWsFolderUri);
+		});
+		return workspaceFolder;
+	}
+}

extensions/notebook/src/extension.ts

@@ -34,6 +34,7 @@ export async function activate(extensionContext: vscode.ExtensionContext): Promi
 	extensionContext.subscriptions.push(vscode.commands.registerCommand('bookTreeView.openMarkdown', (resource) => bookTreeViewProvider.openMarkdown(resource)));
 	extensionContext.subscriptions.push(vscode.commands.registerCommand('bookTreeView.openExternalLink', (resource) => bookTreeViewProvider.openExternalLink(resource)));
 	extensionContext.subscriptions.push(vscode.commands.registerCommand('notebook.command.saveBook', () => untitledBookTreeViewProvider.saveJupyterBooks()));
+	extensionContext.subscriptions.push(vscode.commands.registerCommand('notebook.command.trustBook', (resource) => bookTreeViewProvider.trustBook(resource)));
 	extensionContext.subscriptions.push(vscode.commands.registerCommand('notebook.command.searchBook', (item) => bookTreeViewProvider.searchJupyterBooks(item)));
 	extensionContext.subscriptions.push(vscode.commands.registerCommand('notebook.command.searchUntitledBook', () => untitledBookTreeViewProvider.searchJupyterBooks()));
 	extensionContext.subscriptions.push(vscode.commands.registerCommand('notebook.command.openBook', () => bookTreeViewProvider.openNewBook()));

src/sql/azdata.d.ts

@@ -4314,6 +4314,11 @@ declare module 'azdata' {
 			 * @return The given range or a new, adjusted range.
 			 */
 			validateCellRange(range: CellRange): CellRange;
+
+			/**
+			 * Sets the notebook to trusted by default.
+			 */
+			setTrusted(state: boolean);
 		}
 
 		/**

src/sql/workbench/api/browser/mainThreadNotebookDocumentsAndEditors.ts

@@ -362,6 +362,17 @@ export class MainThreadNotebookDocumentsAndEditors extends Disposable implements
 		return Promise.resolve(this.doOpenEditor(resource, options));
 	}
 
+	$trySetTrusted(uri: UriComponents, isTrusted: boolean = true): Promise<boolean> {
+		let uriString = URI.revive(uri).toString();
+		let editor: MainThreadNotebookEditor = this._notebookEditors.get(uriString);
+		if (editor) {
+			editor.model.trustedMode = isTrusted;
+			return Promise.resolve(isTrusted);
+		} else {
+			return Promise.resolve(false);
+		}
+	}
+
 	$tryApplyEdits(id: string, modelVersionId: number, edits: ISingleNotebookEditOperation[], opts: IUndoStopOptions): Promise<boolean> {
 		let editor = this.getEditor(id);
 		if (!editor) {

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

@@ -50,6 +50,7 @@ export class ExtHostNotebookDocumentData implements IDisposable {
 				get cells() { return data._cells; },
 				get kernelSpec() { return data._kernelSpec; },
 				save() { return data._save(); },
+				setTrusted(isTrusted) { data._setTrusted(isTrusted); },
 				validateCellRange(range) { return data._validateRange(range); },
 			};
 		}
@@ -61,7 +62,13 @@ export class ExtHostNotebookDocumentData implements IDisposable {
 			return Promise.reject(new Error('Document has been closed'));
 		}
 		return this._proxy.$trySaveDocument(this._uri);
+	}
 
+	private _setTrusted(isTrusted: boolean): Thenable<boolean> {
+		if (this._isDisposed) {
+			return Promise.reject(new Error('Document has been closed'));
+		}
+		return this._proxy.$trySetTrusted(this._uri, isTrusted);
 	}
 
 	public onModelChanged(data: INotebookModelChangedData) {

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

@@ -82,6 +82,10 @@ export class NotebookEditorEdit {
 		return range;
 	}
 
+	setTrusted(isTrusted: boolean) {
+		this._document.setTrusted(isTrusted);
+	}
+
 	insertCell(value: Partial<azdata.nb.ICellContents>, index?: number, collapsed?: boolean): void {
 		if (index === null || index === undefined) {
 			// If not specified, assume adding to end of list

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

@@ -890,6 +890,7 @@ export interface ExtHostNotebookDocumentsAndEditorsShape {
 }
 
 export interface MainThreadNotebookDocumentsAndEditorsShape extends IDisposable {
+	$trySetTrusted(_uri: UriComponents, isTrusted: boolean): Thenable<boolean>;
 	$trySaveDocument(uri: UriComponents): Thenable<boolean>;
 	$tryShowNotebookDocument(resource: UriComponents, options: INotebookShowOptions): Promise<string>;
 	$tryApplyEdits(id: string, modelVersionId: number, edits: ISingleNotebookEditOperation[], opts: IUndoStopOptions): Promise<boolean>;

src/sql/workbench/services/notebook/browser/models/notebookModel.ts

@@ -233,6 +233,7 @@ export class NotebookModel extends Disposable implements INotebookModel {
 
 	public set trustedMode(isTrusted: boolean) {
 		this._trustedMode = isTrusted;
+
 		if (this._cells) {
 			this._cells.forEach(c => {
 				c.trustedMode = this._trustedMode;
@@ -290,6 +291,7 @@ export class NotebookModel extends Disposable implements INotebookModel {
 	public async loadContents(isTrusted: boolean = false): Promise<void> {
 		try {
 			this._trustedMode = isTrusted;
+
 			let contents = null;
 
 			if (this._notebookOptions && this._notebookOptions.contentManager) {