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',
+        `You must open your workspace to use the full functionality in the Azure Logic Apps (Standard) extension. You can find the workspace with your logic app project at the following location: ${wizardContext.workspaceCustomFilePath}. Do you want to open this workspace now?`
+      );
+      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',
+        'Your logic app projects must exist inside a workspace to use the full functionality in the Azure Logic Apps (Standard) extension. Visual Studio Code will copy your projects to a new workspace. Do you want to create the workspace now?'
+      );
+      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(