feat(vscode): Logic App and Workflows As Menu Items

apps/vs-code-designer/src/app/commands/createNewCodeProject/CodeProjectBase/ConvertToWorkspace.ts

@@ -0,0 +1,71 @@
+import { extensionCommand, funcVersionSetting } from '../../../../constants';
+import { localize } from '../../../../localize';
+import { addLocalFuncTelemetry, tryGetLocalFuncVersion, tryParseFuncVersion } from '../../../utils/funcCoreTools/funcVersion';
+import { getGlobalSetting } from '../../../utils/vsCodeConfig/settings';
+import { FolderListStep } from '../../createNewProject/createProjectSteps/FolderListStep';
+import { OpenFolderStepCodeProject } from './OpenFolderStepCodeProject';
+import { AzureWizard, DialogResponses } from '@microsoft/vscode-azext-utils';
+import type { IActionContext } from '@microsoft/vscode-azext-utils';
+import { latestGAVersion } from '@microsoft/vscode-extension-logic-apps';
+import type { IFunctionWizardContext } from '@microsoft/vscode-extension-logic-apps';
+import * as vscode from 'vscode';
+import { window } from 'vscode';
+import { getWorkspaceFile, getWorkspaceFileInParentDirectory, getWorkspaceFolder, getWorkspaceRoot } from '../../../utils/workspace';
+import { SetWorkspaceName } from './SetWorkspaceName';
+import { SetWorkspaceContents } from './SetWorkspaceContents';
+import { isLogicAppProjectInRoot } from '../../../utils/verifyIsProject';
+
+export async function ConvertToWorkspace(context: IActionContext): Promise<boolean> {
+  const workspaceFolder = await getWorkspaceFolder(context, undefined, true);
+  if (await isLogicAppProjectInRoot(workspaceFolder)) {
+    addLocalFuncTelemetry(context);
+
+    const version: string = getGlobalSetting(funcVersionSetting) || (await tryGetLocalFuncVersion()) || latestGAVersion;
+    const wizardContext: Partial<IFunctionWizardContext> & IActionContext = Object.assign(context, {
+      version: tryParseFuncVersion(version),
+    });
+    context.telemetry.properties.isWorkspace = 'false';
+    wizardContext.workspaceCustomFilePath =
+      (await getWorkspaceFile(wizardContext)) ?? (await getWorkspaceFileInParentDirectory(wizardContext));
+    //save uri variable for open project folder command
+    wizardContext.customWorkspaceFolderPath = await getWorkspaceRoot(wizardContext);
+    if (wizardContext.workspaceCustomFilePath && !wizardContext.customWorkspaceFolderPath) {
+      const message = localize(
+        'openContainingWorkspace',
+        `Full functionality of the Azure Logic Apps (Standard) extension is available only when the workspace is opened. Workspace found at ${wizardContext.workspaceCustomFilePath} that contains the logic app project. Do you want to open the workspace before continuing?`
+      );
+      const result = await vscode.window.showInformationMessage(message, { modal: true }, DialogResponses.yes, DialogResponses.no);
+      if (result === DialogResponses.yes) {
+        await vscode.commands.executeCommand(extensionCommand.vscodeOpenFolder, vscode.Uri.file(wizardContext.workspaceCustomFilePath));
+        context.telemetry.properties.openContainingWorkspace = 'true';
+        return true;
+      }
+      context.telemetry.properties.openContainingWorkspace = 'false';
+      return false;
+    }
+    if (!wizardContext.workspaceCustomFilePath && !wizardContext.customWorkspaceFolderPath) {
+      const message = localize(
+        'createContainingWorkspace',
+        'Full functionality of the Azure Logic Apps (Standard) extension is available only when logic app project(s) are inside a workspace. Your project(s) will be copied over to the new workspace. Do you want to create the workspace before continuing?'
+      );
+      const result = await vscode.window.showInformationMessage(message, { modal: true }, DialogResponses.yes, DialogResponses.no);
+      if (result === DialogResponses.yes) {
+        const workspaceWizard: AzureWizard<IFunctionWizardContext> = new AzureWizard(wizardContext, {
+          title: localize('convertToWorkspace', 'Convert To Workspace'),
+          promptSteps: [new FolderListStep(), new SetWorkspaceName(), new SetWorkspaceContents()],
+          executeSteps: [new OpenFolderStepCodeProject()],
+        });
+
+        await workspaceWizard.prompt();
+        await workspaceWizard.execute();
+        context.telemetry.properties.createContainingWorkspace = 'true';
+        window.showInformationMessage(localize('finishedConvertingWorkspace', 'Finished converting to workspace.'));
+        return true;
+      }
+      context.telemetry.properties.createContainingWorkspace = 'false';
+      return false;
+    }
+    context.telemetry.properties.isWorkspace = 'true';
+    return true;
+  }
+}

apps/vs-code-designer/src/app/commands/createNewCodeProject/CodeProjectBase/CreateNewProjectInternal.ts

@@ -0,0 +1,75 @@
+import { funcVersionSetting, projectLanguageSetting, projectOpenBehaviorSetting, projectTemplateKeySetting } from '../../../../constants';
+import { localize } from '../../../../localize';
+import { createArtifactsFolder } from '../../../utils/codeless/artifacts';
+import { addLocalFuncTelemetry, tryGetLocalFuncVersion, tryParseFuncVersion } from '../../../utils/funcCoreTools/funcVersion';
+import { getGlobalSetting, getWorkspaceSetting } from '../../../utils/vsCodeConfig/settings';
+import { FolderListStep } from '../../createNewProject/createProjectSteps/FolderListStep';
+import { OpenFolderStepCodeProject } from './OpenFolderStepCodeProject';
+import { AzureWizard } from '@microsoft/vscode-azext-utils';
+import type { IActionContext } from '@microsoft/vscode-azext-utils';
+import { latestGAVersion, OpenBehavior, ProjectType } from '@microsoft/vscode-extension-logic-apps';
+import type { ICreateFunctionOptions, IFunctionWizardContext, ProjectLanguage } from '@microsoft/vscode-extension-logic-apps';
+import * as fse from 'fs-extra';
+import * as path from 'path';
+import { window } from 'vscode';
+
+export async function createRulesFiles(context: IFunctionWizardContext): Promise<void> {
+  if (context.projectType === ProjectType.rulesEngine) {
+    const xmlTemplatePath = path.join(__dirname, 'assets', 'RuleSetProjectTemplate', 'SampleRuleSet');
+    const xmlRuleSetPath = path.join(context.projectPath, 'Artifacts', 'Rules', 'SampleRuleSet.xml');
+    const xmlTemplateContent = await fse.readFile(xmlTemplatePath, 'utf-8');
+    const xmlFileContent = xmlTemplateContent.replace(/<%= methodName %>/g, context.methodName);
+    await fse.writeFile(xmlRuleSetPath, xmlFileContent);
+  }
+}
+
+export async function createLibFolder(context: IFunctionWizardContext): Promise<void> {
+  fse.mkdirSync(path.join(context.projectPath, 'lib', 'builtinOperationSdks', 'JAR'), { recursive: true });
+  fse.mkdirSync(path.join(context.projectPath, 'lib', 'builtinOperationSdks', 'net472'), { recursive: true });
+  fse.mkdirSync(path.join(context.projectPath, 'lib', 'custom', 'net472'), { recursive: true });
+}
+
+export async function createNewProjectInternalBase(
+  context: IActionContext,
+  options: ICreateFunctionOptions,
+  title: string,
+  message: string,
+  promptSteps: any[]
+): Promise<void> {
+  addLocalFuncTelemetry(context);
+
+  const language: ProjectLanguage | string = (options.language as ProjectLanguage) || getGlobalSetting(projectLanguageSetting);
+  const version: string = options.version || getGlobalSetting(funcVersionSetting) || (await tryGetLocalFuncVersion()) || latestGAVersion;
+  const projectTemplateKey: string | undefined = getGlobalSetting(projectTemplateKeySetting);
+  const wizardContext: Partial<IFunctionWizardContext> & IActionContext = Object.assign(context, options, {
+    language,
+    version: tryParseFuncVersion(version),
+    projectTemplateKey,
+  });
+
+  if (options.folderPath) {
+    FolderListStep.setProjectPath(wizardContext, options.folderPath);
+  }
+
+  if (options.suppressOpenFolder) {
+    wizardContext.openBehavior = OpenBehavior.dontOpen;
+  } else if (!wizardContext.openBehavior) {
+    wizardContext.openBehavior = getWorkspaceSetting(projectOpenBehaviorSetting);
+    context.telemetry.properties.openBehaviorFromSetting = String(!!wizardContext.openBehavior);
+  }
+
+  const wizard: AzureWizard<IFunctionWizardContext> = new AzureWizard(wizardContext, {
+    title: localize(title, message),
+    promptSteps,
+    executeSteps: [new OpenFolderStepCodeProject()],
+  });
+
+  await wizard.prompt();
+  await wizard.execute();
+
+  await createArtifactsFolder(context as IFunctionWizardContext);
+  await createRulesFiles(context as IFunctionWizardContext);
+  await createLibFolder(context as IFunctionWizardContext);
+
+  window.showInformationMessage(localize('finishedCreating', 'Finished creating project.'));
+}

apps/vs-code-designer/src/app/commands/createNewCodeProject/CodeProjectBase/NewCodeProjectTypeStep.ts

@@ -21,7 +21,7 @@ export class NewCodeProjectTypeStep extends AzureWizardPromptStep<IProjectWizard
   public hideStepCount = true;
   private readonly templateId?: string;
   private readonly functionSettings?: { [key: string]: string | undefined };
-  private readonly skipWorkflowStateTypeStep?: boolean;
+  private readonly skipWorkflowStateTypeStep: boolean;
 
   /**
    * The constructor initializes the NewCodeProjectTypeStep object with optional templateId and functionSettings parameters.
@@ -31,7 +31,7 @@ export class NewCodeProjectTypeStep extends AzureWizardPromptStep<IProjectWizard
   public constructor(
     templateId: string | undefined,
     functionSettings: { [key: string]: string | undefined } | undefined,
-    skipWorkflowStateTypeStep: any
+    skipWorkflowStateTypeStep: boolean
   ) {
     super();
     this.templateId = templateId;
@@ -47,10 +47,8 @@ export class NewCodeProjectTypeStep extends AzureWizardPromptStep<IProjectWizard
     // Set default project type and language
     context.workflowProjectType = WorkflowProjectType.Bundle;
     context.language = ProjectLanguage.JavaScript;
-
-    // Create directories based on user choices
-    const { workspacePath, isWorkspaceWithFunctions } = context;
-    await this.createDirectories(context, workspacePath, isWorkspaceWithFunctions);
+    const { workspacePath } = context;
+    await this.setPaths(context, workspacePath);
   }
 
   /**
@@ -76,46 +74,25 @@ export class NewCodeProjectTypeStep extends AzureWizardPromptStep<IProjectWizard
     } else {
       await this.setupRegularLogicApp(context, executeSteps, promptSteps);
     }
-
     return { promptSteps, executeSteps };
   }
 
   /**
-   * Creates required directories for the project
+   * Sets the paths required for the project
    * @param context - Project wizard context
    * @param workspacePath - Root path of the workspace
    * @param isWorkspaceWithFunctions - Flag to check if it's a workspace with functions
    */
-  private async createDirectories(context: IProjectWizardContext, workspacePath: string, isWorkspaceWithFunctions: boolean): Promise<void> {
+  private async setPaths(context: IProjectWizardContext, workspacePath: string): Promise<void> {
     await fs.ensureDir(workspacePath);
-    context.customWorkspaceFolderPath = workspacePath;
 
-    let logicAppFolderName = 'LogicApp';
-    if (!isWorkspaceWithFunctions && context.logicAppName) {
-      logicAppFolderName = context.logicAppName;
-    }
+    const logicAppFolderName = context.logicAppName;
 
     const logicAppFolderPath = path.join(workspacePath, logicAppFolderName);
     await fs.ensureDir(logicAppFolderPath);
     context.logicAppFolderPath = logicAppFolderPath;
 
     context.projectPath = logicAppFolderPath;
-    context.workspacePath = logicAppFolderPath;
-
-    if (isWorkspaceWithFunctions) {
-      await this.setupCustomDirectories(context, workspacePath);
-    }
-    await this.createWorkspaceFile(context);
-  }
-  /**
-   * Setup directories and configs for custom code logic app
-   * @param context - Project wizard context
-   * @param workspacePath - Root path of the workspace
-   */
-  private async setupCustomDirectories(context: IProjectWizardContext, workspacePath: string): Promise<void> {
-    const functionFolderPath = path.join(workspacePath, 'Function');
-    await fs.ensureDir(functionFolderPath);
-    context.functionFolderPath = functionFolderPath;
   }
 
   /**
@@ -169,31 +146,4 @@ export class NewCodeProjectTypeStep extends AzureWizardPromptStep<IProjectWizard
       );
     }
   }
-
-  /**
-   * Creates a .code-workspace file to group project directories in VS Code
-   * @param context - Project wizard context
-   */
-  private async createWorkspaceFile(context: IProjectWizardContext): Promise<void> {
-    // Start with an empty folders array
-    const workspaceFolders = [];
-
-    // Add Functions folder first if it's a custom code code Logic App
-    if (context.isWorkspaceWithFunctions) {
-      workspaceFolders.push({ name: 'Functions', path: './Function' });
-    }
-
-    // Use context.logicAppName for the folder name; default to 'LogicApp' if not available
-    const logicAppName = context.logicAppName || 'LogicApp';
-    workspaceFolders.push({ name: logicAppName, path: `./${logicAppName}` });
-
-    const workspaceData = {
-      folders: workspaceFolders,
-    };
-
-    const workspaceFilePath = path.join(context.customWorkspaceFolderPath, `${context.workspaceName}.code-workspace`);
-    context.customWorkspaceFolderPath = workspaceFilePath;
-
-    await fs.writeJSON(workspaceFilePath, workspaceData, { spaces: 2 });
-  }
 }

apps/vs-code-designer/src/app/commands/createNewCodeProject/CodeProjectBase/OpenFolderStepCodeProject.ts

@@ -23,7 +23,7 @@ export class OpenFolderStepCodeProject extends AzureWizardExecuteStep<IProjectWi
     let uri: Uri;
 
     // Check if .code-workspace file exists in project path
-    const workspaceFilePath = context.customWorkspaceFolderPath;
+    const workspaceFilePath = context.workspaceCustomFilePath;
     context.workspaceFolder = getContainingWorkspace(workspaceFilePath);
     if (fs.existsSync(workspaceFilePath)) {
       uri = Uri.file(workspaceFilePath);
@@ -37,7 +37,9 @@ export class OpenFolderStepCodeProject extends AzureWizardExecuteStep<IProjectWi
     }
 
     if (context.openBehavior === OpenBehavior.addToWorkspace) {
-      workspace.updateWorkspaceFolders(openFolders.length, 0, { uri: uri });
+      if (!uri.path.endsWith('.code-workspace')) {
+        workspace.updateWorkspaceFolders(openFolders.length, 0, { uri: uri });
+      }
     } else {
       // Open folder using executeCommand method of commands object with vscode.openFolder command
       await commands.executeCommand(