add api to open new project dialog with only one project type with filtered target platforms (#16315)

extensions/data-workspace/src/common/dataWorkspaceExtension.ts

@@ -4,9 +4,10 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
-import { IExtension } from 'dataworkspace';
+import { IExtension, IProjectType } from 'dataworkspace';
 import { WorkspaceService } from '../services/workspaceService';
 import { defaultProjectSaveLocation } from './projectLocationHelper';
+import { openSpecificProjectNewProjectDialog } from '../dialogs/newProjectDialog';
 
 export class DataWorkspaceExtension implements IExtension {
 	constructor(private workspaceService: WorkspaceService) {
@@ -31,4 +32,9 @@ export class DataWorkspaceExtension implements IExtension {
 	validateWorkspace(): Promise<boolean> {
 		return this.workspaceService.validateWorkspace();
 	}
+
+	openSpecificProjectNewProjectDialog(projectType: IProjectType): Promise<vscode.Uri | undefined> {
+		return openSpecificProjectNewProjectDialog(projectType, this.workspaceService);
+	}
+
 }

extensions/data-workspace/src/dataworkspace.d.ts

@@ -40,6 +40,13 @@ declare module 'dataworkspace' {
 		  * Verifies that a workspace is open or if it should be automatically created
 		  */
 		validateWorkspace(): Promise<boolean>;
+
+		/**
+		 * Opens the new project dialog with only the specified project type
+		 * @param projectType project type to open the dialog for
+		 * @returns the uri of the created the project or undefined if no project was created
+		 */
+		openSpecificProjectNewProjectDialog(projectType: IProjectType): Promise<vscode.Uri | undefined>;
 	}
 
 	/**

extensions/data-workspace/src/dialogs/dialogBase.ts

@@ -7,7 +7,7 @@ import type * as azdataType from 'azdata';
 import * as vscode from 'vscode';
 import { getAzdataApi } from '../common/utils';
 
-interface Deferred<T> {
+export interface Deferred<T> {
 	resolve: (result: T | Promise<T>) => void;
 	reject: (reason: any) => void;
 }
@@ -42,7 +42,7 @@ export abstract class DialogBase {
 		await this.initDialogPromise;
 	}
 
-	private onCancelButtonClicked(): void {
+	protected onCancelButtonClicked(): void {
 		this.dispose();
 	}
 

extensions/data-workspace/src/dialogs/newProjectDialog.ts

@@ -6,7 +6,7 @@
 import type * as azdataType from 'azdata';
 import * as vscode from 'vscode';
 import * as path from 'path';
-import { DialogBase } from './dialogBase';
+import { Deferred, DialogBase } from './dialogBase';
 import { IWorkspaceService } from '../common/interfaces';
 import * as constants from '../common/constants';
 import { IProjectType } from 'dataworkspace';
@@ -14,6 +14,7 @@ import { directoryExist } from '../common/utils';
 import { IconPathHelper } from '../common/iconHelper';
 import { defaultProjectSaveLocation } from '../common/projectLocationHelper';
 import { TelemetryActions, TelemetryReporter, TelemetryViews } from '../common/telemetry';
+import { WorkspaceService } from '../services/workspaceService';
 
 class NewProjectDialogModel {
 	projectTypeId: string = '';
@@ -23,12 +24,22 @@ class NewProjectDialogModel {
 	targetPlatform?: string;
 }
 
+export async function openSpecificProjectNewProjectDialog(projectType: IProjectType, workspaceService: WorkspaceService): Promise<vscode.Uri | undefined> {
+	const dialog = new NewProjectDialog(workspaceService, projectType);
+	await dialog.open();
+	await dialog.newDialogPromise;
+	return dialog.projectUri;
+}
+
 export class NewProjectDialog extends DialogBase {
 	public model: NewProjectDialogModel = new NewProjectDialogModel();
 	public formBuilder: azdataType.FormBuilder | undefined;
 	public targetPlatformDropdownFormComponent: azdataType.FormComponent | undefined;
+	public newProjectDialogComplete: Deferred<void> | undefined;
+	public newDialogPromise: Promise<void> = new Promise<void>((resolve, reject) => this.newProjectDialogComplete = { resolve, reject });
+	public projectUri: vscode.Uri | undefined;
 
-	constructor(private workspaceService: IWorkspaceService) {
+	constructor(private workspaceService: IWorkspaceService, private specificProjectType?: IProjectType) {
 		super(constants.NewProjectDialogTitle, 'NewProject', constants.CreateButtonText);
 
 		// dialog launched from Welcome message button (only visible when no current workspace) vs. "add project" button
@@ -64,6 +75,11 @@ export class NewProjectDialog extends DialogBase {
 		}
 	}
 
+	override onCancelButtonClicked(): void {
+		this.newProjectDialogComplete?.resolve();
+		this.dispose();
+	}
+
 	override async onComplete(): Promise<void> {
 		try {
 
@@ -71,7 +87,8 @@ export class NewProjectDialog extends DialogBase {
 				.withAdditionalProperties({ projectFileExtension: this.model.projectFileExtension, projectTemplateId: this.model.projectTypeId })
 				.send();
 
-			await this.workspaceService.createProject(this.model.name, vscode.Uri.file(this.model.location), this.model.projectTypeId, this.model.targetPlatform);
+			this.projectUri = await this.workspaceService.createProject(this.model.name, vscode.Uri.file(this.model.location), this.model.projectTypeId, this.model.targetPlatform);
+			this.newProjectDialogComplete?.resolve();
 		}
 		catch (err) {
 
@@ -84,7 +101,13 @@ export class NewProjectDialog extends DialogBase {
 	}
 
 	protected async initialize(view: azdataType.ModelView): Promise<void> {
-		const allProjectTypes = await this.workspaceService.getAllProjectTypes();
+		let allProjectTypes = await this.workspaceService.getAllProjectTypes();
+
+		// if a specific project type is specified, only show that one
+		if (this.specificProjectType && allProjectTypes.find(p => p.id === this.specificProjectType?.id)) {
+			allProjectTypes = [this.specificProjectType];
+		}
+
 		const projectTypeRadioCardGroup = view.modelBuilder.radioCardGroup().withProps({
 			cards: allProjectTypes.map((projectType: IProjectType) => {
 				return <azdataType.RadioCard>{

extensions/sql-database-projects/src/projectProvider/projectProvider.ts

@@ -9,6 +9,7 @@ import * as sqldbproj from 'sqldbproj';
 import * as vscode from 'vscode';
 import * as constants from '../common/constants';
 import { IconPathHelper } from '../common/iconHelper';
+import { getDataWorkspaceExtensionApi } from '../common/utils';
 import { SqlDatabaseProjectTreeViewProvider } from '../controllers/databaseProjectTreeViewProvider';
 import { ProjectsController } from '../controllers/projectController';
 import { Project } from '../models/project';
@@ -147,4 +148,24 @@ export class SqlDatabaseProjectProvider implements dataworkspace.IProjectProvide
 	get image(): ThemedIconPath {
 		return IconPathHelper.dashboardSqlProj;
 	}
+
+	async openSqlNewProjectDialog(allowedTargetPlatforms?: sqldbproj.SqlTargetPlatform[]): Promise<vscode.Uri | undefined> {
+		let targetPlatforms = Array.from(constants.targetPlatformToVersion.keys());
+		if (allowedTargetPlatforms) {
+			targetPlatforms = targetPlatforms.filter(p => allowedTargetPlatforms.toString().includes(p));
+		}
+
+		const projectType: dataworkspace.IProjectType = {
+			id: constants.emptySqlDatabaseProjectTypeId,
+			projectFileExtension: constants.sqlprojExtension.replace(/\./g, ''),
+			displayName: constants.emptyProjectTypeDisplayName,
+			description: constants.emptyProjectTypeDescription,
+			icon: IconPathHelper.colorfulSqlProject,
+			targetPlatforms: targetPlatforms,
+			defaultTargetPlatform: constants.defaultTargetPlatform
+		};
+
+		const projectUri = getDataWorkspaceExtensionApi().openSpecificProjectNewProjectDialog(projectType);
+		return projectUri;
+	}
 }

extensions/sql-database-projects/src/sqldbproj.d.ts

@@ -27,6 +27,13 @@ declare module 'sqldbproj' {
 		 * Opens and loads a .sqlproj file
 		 */
 		openProject(projectFilePath: string): Promise<ISqlProject>;
+
+		/**
+		 * Opens the data workspace new project dialog with only the sql database template
+		 * @param allowedTargetPlatforms specific target platforms to allow. If not specified, all target platforms for sql will be listed
+		 * @returns uri of the created the project or undefined if no project was created
+		 */
+		openSqlNewProjectDialog(allowedTargetPlatforms?: SqlTargetPlatform[]): Promise<vscode.Uri | undefined>;
 	}
 
 	export interface ISqlProject {