feat(vscode): Import Logic Apps from Cloud to Local VSCode

.vscode/extensions.json

@@ -1,6 +1,7 @@
 {
   "recommendations": [
     "biomejs.biome",
-    "dbaeumer.vscode-eslint"
+    "dbaeumer.vscode-eslint",
+    "ms-vscode.azure-account"
   ]
 }

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

@@ -21,16 +21,22 @@ export class NewCodeProjectTypeStep extends AzureWizardPromptStep<IProjectWizard
   public hideStepCount = true;
   private readonly templateId?: string;
   private readonly functionSettings?: { [key: string]: string | undefined };
+  private readonly skipWorkflowStateTypeStep?: boolean;
 
   /**
    * The constructor initializes the NewCodeProjectTypeStep object with optional templateId and functionSettings parameters.
    * @param templateId - The ID of the template for the code project.
    * @param functionSettings - The settings for the functions in the code project.
    */
-  public constructor(templateId: string | undefined, functionSettings: { [key: string]: string | undefined } | undefined) {
+  public constructor(
+    templateId: string | undefined,
+    functionSettings: { [key: string]: string | undefined } | undefined,
+    skipWorkflowStateTypeStep: any
+  ) {
     super();
     this.templateId = templateId;
     this.functionSettings = functionSettings;
+    this.skipWorkflowStateTypeStep = skipWorkflowStateTypeStep;
   }
 
   /**
@@ -153,13 +159,15 @@ export class NewCodeProjectTypeStep extends AzureWizardPromptStep<IProjectWizard
     executeSteps.push(new WorkflowProjectCreateStep());
     await addInitVSCodeSteps(context, executeSteps, false);
 
-    promptSteps.push(
-      await WorkflowStateTypeStep.create(context, {
-        isProjectWizard: true,
-        templateId: this.templateId,
-        triggerSettings: this.functionSettings,
-      })
-    );
+    if (!this.skipWorkflowStateTypeStep) {
+      promptSteps.push(
+        await WorkflowStateTypeStep.create(context, {
+          isProjectWizard: true,
+          templateId: this.templateId,
+          triggerSettings: this.functionSettings,
+        })
+      );
+    }
   }
 
   /**

apps/vs-code-designer/src/app/commands/createNewCodeProject/__test__/cloudToLocal.test.ts

@@ -0,0 +1,90 @@
+import { extractConnectionDetails, changeAuthTypeToRaw } from '../cloudToLocalHelper';
+import type { ConnectionReferenceModel } from '@microsoft/vscode-extension-logic-apps';
+import { describe, it, expect, vi } from 'vitest';
+import { beforeEach } from 'vitest';
+
+vi.mock('fs');
+describe('extractConnectionDetails and ChangAuthToRaw are being tested for cloudToLocal.', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('extractConnectionDetails for ConnectionReferenceModel', () => {
+    it('should extract connection details correctly', () => {
+      let connectionObject = {
+        managedApiConnections: {
+          connKey: {
+            api: {
+              id: '/subscriptions/346751b2-0de1-405c-ad29-acb7ba73797f/providers/Microsoft.Web/locations/eastus2/managedApis/applicationinsights',
+            },
+            connection: {
+              id: '/subscriptions/346751b2-0de1-405c-ad29-acb7ba73797f/resourceGroups/vs-code-debug/providers/Microsoft.Web/connections/applicationinsights',
+            },
+            authentication: {
+              type: 'ManagedServiceIdentity',
+            },
+            connectionRuntimeUrl: 'runtime-url',
+          },
+        },
+      };
+      const newconnection = JSON.stringify(connectionObject);
+      const parsedconnection: ConnectionReferenceModel = JSON.parse(newconnection);
+
+      const details = extractConnectionDetails(parsedconnection);
+
+      const expectedDetails = [
+        {
+          WORKFLOWS_LOCATION_NAME: 'eastus2',
+          WORKFLOWS_RESOURCE_GROUP_NAME: 'vs-code-debug',
+          WORKFLOWS_SUBSCRIPTION_ID: '346751b2-0de1-405c-ad29-acb7ba73797f',
+        },
+      ];
+
+      expect(details).toEqual(expectedDetails);
+    });
+  });
+
+  describe('ChangeAuthToRaw for ConnectionReferenceModel', () => {
+    it('should change authentication type to Raw', () => {
+      // Setup
+      let connectionsJsonContent = {
+        managedApiConnections: {
+          applicationinsights: {
+            api: {
+              id: '/subscriptions/346751b2-0de1-405c-ad29-acb7ba73797f/providers/Microsoft.Web/locations/eastus2/managedApis/applicationinsights',
+            },
+            connection: {
+              id: '/subscriptions/346751b2-0de1-405c-ad29-acb7ba73797f/resourceGroups/vs-code-debug/providers/Microsoft.Web/connections/applicationinsights',
+            },
+            authentication: {
+              type: 'ManagedServiceIdentity',
+            },
+          },
+        },
+      };
+      const jsonString = JSON.stringify(connectionsJsonContent);
+      const connection: ConnectionReferenceModel = JSON.parse(jsonString);
+
+      changeAuthTypeToRaw(connection);
+
+      const expectedConnection = JSON.stringify({
+        managedApiConnections: {
+          applicationinsights: {
+            api: {
+              id: '/subscriptions/346751b2-0de1-405c-ad29-acb7ba73797f/providers/Microsoft.Web/locations/eastus2/managedApis/applicationinsights',
+            },
+            connection: {
+              id: '/subscriptions/346751b2-0de1-405c-ad29-acb7ba73797f/resourceGroups/vs-code-debug/providers/Microsoft.Web/connections/applicationinsights',
+            },
+            authentication: {
+              type: 'Raw',
+              scheme: 'Key',
+              parameter: "@appsetting('applicationinsights-connectionKey')",
+            },
+          },
+        },
+      });
+      expect(JSON.stringify(connection)).toEqual(expectedConnection);
+    });
+  });
+});

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

@@ -0,0 +1,199 @@
+// Used createNewCodeProject.ts as a template to create this file
+// This file is used to take a zipped Logic App from the desktop and unzip to the local workspace
+// Reorganized file with constants at the top, grouped functions, and a main cloudToLocalInternal to call everything
+import {
+  extensionCommand,
+  funcVersionSetting,
+  projectLanguageSetting,
+  projectOpenBehaviorSetting,
+  projectTemplateKeySetting,
+  parameterizeConnectionsInProjectLoadSetting,
+} from '../../../constants';
+import { localize } from '../../../localize';
+import { addLocalFuncTelemetry, tryGetLocalFuncVersion, tryParseFuncVersion } from '../../utils/funcCoreTools/funcVersion';
+import { showPreviewWarning } from '../../utils/taskUtils';
+import { getGlobalSetting, getWorkspaceSetting } from '../../utils/vsCodeConfig/settings';
+import { OpenBehaviorStep } from '../createNewProject/OpenBehaviorStep';
+import { FolderListStep } from '../createNewProject/createProjectSteps/FolderListStep';
+import { NewCodeProjectTypeStep } from './CodeProjectBase/NewCodeProjectTypeStep';
+import { ZipFileStep } from '../createNewProject/createProjectSteps/ZipFileStep';
+import { OpenFolderStepCodeProject } from './CodeProjectBase/OpenFolderStepCodeProject';
+import { SetLogicAppName } from './CodeProjectBase/SetLogicAppNameStep';
+import { setWorkspaceName } from './CodeProjectBase/SetWorkspaceName';
+import { extend } from '@microsoft/logic-apps-shared';
+import { AzureWizard } from '@microsoft/vscode-azext-utils';
+import type { IActionContext } from '@microsoft/vscode-azext-utils';
+import { latestGAVersion, OpenBehavior } from '@microsoft/vscode-extension-logic-apps';
+import { extractConnectionDetails, changeAuthTypeToRaw, updateConnectionKeys, getConnectionsJsonContent } from './cloudToLocalHelper';
+import type { ICreateFunctionOptions, IFunctionWizardContext, ProjectLanguage } from '@microsoft/vscode-extension-logic-apps';
+import { window } from 'vscode';
+import * as path from 'path';
+import AdmZip = require('adm-zip');
+import * as fs from 'fs';
+import { SetLogicAppType } from './CodeProjectBase/setLogicAppType';
+import { writeFormattedJson } from '../../utils/fs';
+
+// Constants
+const openFolder = true;
+
+// Function to create an AdmZip instance
+function createAdmZipInstance(zipFilePath: string) {
+  return new AdmZip(zipFilePath);
+}
+
+// Function to get zip entries
+function getZipEntries(zipFilePath: string) {
+  const zip = createAdmZipInstance(zipFilePath);
+  return zip.getEntries();
+}
+
+async function cleanLocalSettings(localSettingsPath: string) {
+  const localSettings = JSON.parse(fs.readFileSync(localSettingsPath, 'utf8'));
+
+  if (localSettings.Values) {
+    Object.keys(localSettings.Values).forEach((key) => {
+      if (
+        key === 'WEBSITE_SITE_NAME' ||
+        key === 'WEBSITE_AUTH_ENABLED' ||
+        key === 'WEBSITE_SLOT_NAME' ||
+        key === 'ScmType' ||
+        key === 'FUNCTIONS_RUNTIME_SCALE_MONITORING_ENABLED'
+      ) {
+        delete localSettings.Values[key];
+      } else if (key === 'AzureWebJobsStorage') {
+        localSettings.Values[key] = 'UseDevelopmentStorage=true';
+      }
+    });
+
+    await writeFormattedJson(localSettingsPath, localSettings);
+  }
+}
+
+// Main function to orchestrate the cloud to local process
+export async function cloudToLocalInternal(
+  context: IActionContext,
+  options: ICreateFunctionOptions = {
+    folderPath: undefined,
+    language: undefined,
+    version: undefined,
+    templateId: undefined,
+    functionName: undefined,
+    functionSettings: undefined,
+    suppressOpenFolder: !openFolder,
+  }
+): Promise<void> {
+  addLocalFuncTelemetry(context);
+  showPreviewWarning(extensionCommand.cloudToLocal);
+
+  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,
+    projectPath: 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('cloudToLocal', 'Import zip into new Workspace'),
+    promptSteps: [
+      new FolderListStep(),
+      new setWorkspaceName(),
+      new SetLogicAppType(), // is it only supporting one type?
+      new SetLogicAppName(),
+      new ZipFileStep(),
+      new NewCodeProjectTypeStep(options.templateId, options.functionSettings, true),
+      new OpenBehaviorStep(),
+    ],
+    executeSteps: [new OpenFolderStepCodeProject()],
+    hideStepCount: true,
+  });
+  try {
+    await wizard.prompt();
+    await wizard.execute();
+  } catch (error) {
+    console.error('Error during wizard execution:', error);
+  }
+  const zipFilePath = ZipFileStep.zipFilePath;
+  const zipEntries = getZipEntries(zipFilePath);
+  const connectionspath = path.join(wizardContext.workspacePath, 'connections.json');
+  const localSettingsEntry = zipEntries.find((entry) => entry.entryName === 'local.settings.json');
+  const localSettingsPath = path.join(wizardContext.workspacePath, 'local.settings.json');
+  let localSettings: { Values?: any } = {};
+  let zipSettings = {};
+  const parametersEntry = zipEntries.find((entry) => entry.entryName === 'parameters.json');
+  const parametersPath = path.join(wizardContext.workspacePath, 'parameters.json');
+  let localParameters: any = {};
+  let zipParameters: any = {};
+  const connectionsData = await getConnectionsJsonContent(wizardContext as IFunctionWizardContext);
+  const parameterizeConnectionsSetting = getGlobalSetting(parameterizeConnectionsInProjectLoadSetting);
+
+  if (localSettingsEntry) {
+    const zipSettingsContent = localSettingsEntry.getData().toString('utf8');
+    zipSettings = JSON.parse(zipSettingsContent);
+  }
+
+  if (fs.existsSync(localSettingsPath)) {
+    const localSettingsContent = fs.readFileSync(localSettingsPath, 'utf8');
+    localSettings = JSON.parse(localSettingsContent);
+  }
+
+  if (parametersEntry) {
+    const parametersContent = parametersEntry.getData().toString('utf8');
+    zipParameters = JSON.parse(parametersContent);
+  }
+
+  if (fs.existsSync(parametersPath)) {
+    const localParametersContent = fs.readFileSync(parametersPath, 'utf8');
+    localParameters = JSON.parse(localParametersContent);
+  }
+
+  async function mergeSettings(): Promise<Record<string, any>> {
+    try {
+      const connectionsValues = await extractConnectionDetails(connectionsData);
+      const connectionDetail = connectionsValues[0];
+      const newValues = {
+        ...connectionDetail,
+        ...localSettings.Values,
+      };
+      const settings = {
+        ...localSettings,
+        Values: newValues,
+      };
+
+      return settings;
+    } catch (error) {
+      console.error('Error writing file:', error);
+    }
+  }
+
+  extend(localParameters, zipParameters);
+  extend(localSettings, zipSettings);
+
+  if (connectionsData.managedApiConnections) {
+    const [convertedConnections, convertedParameters] = await changeAuthTypeToRaw(
+      connectionsData,
+      localParameters,
+      parameterizeConnectionsSetting
+    );
+    const mergedSettings = await mergeSettings();
+
+    await writeFormattedJson(connectionspath, convertedConnections);
+    await writeFormattedJson(parametersPath, convertedParameters);
+    await writeFormattedJson(localSettingsPath, mergedSettings);
+
+    await updateConnectionKeys(wizardContext as IFunctionWizardContext);
+  }
+
+  await cleanLocalSettings(localSettingsPath);
+
+  window.showInformationMessage(localize('finishedCreating', 'Finished creating project.'));
+}