Add children for create new project and create new function (#4490)

* Convert execute activity steps to v2 children

* Delete extra code causing npm lint to fail

* Fix build errors for activity Children

* Add children for create new project and create new function

* Minor edits

* Local changes for deployment activity children

* Update appservice package for deploy changes

* Fix package-lock.json

* Missed merge conflict

* Lock it up

Author: nturinski

package-lock.json

@@ -1410,7 +1410,7 @@
         "@azure/core-client": "^1.7.3",
         "@azure/core-rest-pipeline": "^1.11.0",
         "@azure/storage-blob": "^12.5.0",
-        "@microsoft/vscode-azext-azureappservice": "^3.6.0",
+        "@microsoft/vscode-azext-azureappservice": "^3.6.1",
         "@microsoft/vscode-azext-azureappsettings": "^0.2.8",
         "@microsoft/vscode-azext-azureutils": "^3.2.1",
         "@microsoft/vscode-azext-utils": "^3.0.1",

package.json

@@ -3,18 +3,36 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { AzureWizardExecuteStep } from "@microsoft/vscode-azext-utils";
+import { AzureWizardExecuteStepWithActivityOutput } from "@microsoft/vscode-azext-utils";
 import { Uri, window, workspace, type Progress } from "vscode";
 import { type IFunctionBinding, type IFunctionJson } from "../../funcConfig/function";
+import { localize } from "../../localize";
 import { type IBindingTemplate } from "../../templates/IBindingTemplate";
 import { confirmEditJsonFile } from '../../utils/fs';
 import { nonNullProp } from "../../utils/nonNull";
 import { verifyExtensionBundle } from "../../utils/verifyExtensionBundle";
 import { getBindingSetting } from "../createFunction/IFunctionWizardContext";
 import { type IBindingWizardContext } from "./IBindingWizardContext";
 
-export class BindingCreateStep extends AzureWizardExecuteStep<IBindingWizardContext> {
+export class BindingCreateStep extends AzureWizardExecuteStepWithActivityOutput<IBindingWizardContext> {
     public priority: number = 220;
+    stepName = 'bindingCreateStep';
+    public getTreeItemLabel(context: IBindingWizardContext): string {
+        const bindingTemplate: IBindingTemplate = nonNullProp(context, 'bindingTemplate');
+        return localize('addBinding', 'Add {0} binding', bindingTemplate.type);
+    }
+    public getOutputLogSuccess(context: IBindingWizardContext): string {
+        const bindingTemplate: IBindingTemplate = nonNullProp(context, 'bindingTemplate');
+        return localize('addBindingSuccess', 'Successfully added {0} binding.', bindingTemplate.type);
+    }
+    public getOutputLogFail(context: IBindingWizardContext): string {
+        const bindingTemplate: IBindingTemplate = nonNullProp(context, 'bindingTemplate');
+        return localize('addBindingFail', 'Failed to add {0} binding.', bindingTemplate.type);
+    }
+    public getOutputLogProgress(context: IBindingWizardContext): string {
+        const bindingTemplate: IBindingTemplate = nonNullProp(context, 'bindingTemplate');
+        return localize('addingBinding', 'Adding {0} binding...', bindingTemplate.type);
+    }
 
     public async execute(context: IBindingWizardContext, _progress: Progress<{ message?: string | undefined; increment?: number | undefined }>): Promise<void> {
         const bindingTemplate: IBindingTemplate = nonNullProp(context, 'bindingTemplate');

src/commands/addBinding/BindingCreateStep.ts

@@ -11,6 +11,7 @@ import { ext } from "../../extensionVariables";
 import { localize } from "../../localize";
 import { type LocalFunctionTreeItem } from "../../tree/localProject/LocalFunctionTreeItem";
 import { type LocalProjectTreeItem } from "../../tree/localProject/LocalProjectTreeItem";
+import { createActivityContext } from "../../utils/activityUtils";
 import { nonNullValue } from "../../utils/nonNull";
 import { getContainingWorkspace } from "../../utils/workspace";
 import { getWorkspaceSetting } from "../../vsCodeConfig/settings";
@@ -55,7 +56,7 @@ export async function addBinding(context: IActionContext, data: Uri | LocalFunct
     }
 
     const projectTemplateKey: string | undefined = getWorkspaceSetting(projectTemplateKeySetting, projectPath);
-    const wizardContext: IBindingWizardContext = Object.assign(context, { functionJsonPath, workspacePath, projectPath, workspaceFolder, language, version, projectTemplateKey });
+    const wizardContext: IBindingWizardContext = Object.assign(context, await createActivityContext(), { functionJsonPath, workspacePath, projectPath, workspaceFolder, language, version, projectTemplateKey });
     const wizard: AzureWizard<IBindingWizardContext> = createBindingWizard(wizardContext);
     await wizard.prompt();
     await wizard.execute();

src/commands/addBinding/addBinding.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { AzureWizardExecuteStep } from '@microsoft/vscode-azext-utils';
+import { AzureWizardExecuteStepWithActivityOutput } from '@microsoft/vscode-azext-utils';
 import { type Progress } from 'vscode';
 import { setLocalAppSetting } from '../../../funcConfig/local.settings';
 import { localize } from '../../../localize';
@@ -16,8 +16,21 @@ export interface IConnection {
     connectionString: string;
 }
 
-export abstract class AzureConnectionCreateStepBase<T extends IFunctionWizardContext> extends AzureWizardExecuteStep<T> {
+export abstract class AzureConnectionCreateStepBase<T extends IFunctionWizardContext> extends AzureWizardExecuteStepWithActivityOutput<T> {
     public priority: number = 200;
+    stepName = 'azureConnectionCreateStepBase';
+    public getTreeItemLabel(_context: T): string {
+        return localize('azureConnection', 'Add connection string');
+    }
+    public getOutputLogSuccess(_context: T): string {
+        return localize('azureConnectionSuccess', 'Successfully added connection string.');
+    }
+    public getOutputLogFail(_context: T): string {
+        return localize('azureConnectionFail', 'Failed to add connection string.');
+    }
+    public getOutputLogProgress(_context: T): string {
+        return localize('addingConnectionString', 'Adding connection string...');
+    }
 
     private readonly _setting: IBindingSetting | ParsedInput;
     private readonly _resourceType: string;

src/commands/addBinding/settingSteps/AzureConnectionCreateStepBase.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { AzureWizardExecuteStep } from '@microsoft/vscode-azext-utils';
+import { AzureWizardExecuteStepWithActivityOutput } from '@microsoft/vscode-azext-utils';
 import { type Progress } from 'vscode';
 import { localSettingsFileName } from '../../../constants';
 import { setLocalAppSetting } from '../../../funcConfig/local.settings';
@@ -14,8 +14,21 @@ import { nonNullProp, nonNullValue } from '../../../utils/nonNull';
 import { getBindingSetting, setBindingSetting } from '../../createFunction/IFunctionWizardContext';
 import { type IBindingWizardContext } from '../IBindingWizardContext';
 
-export class LocalAppSettingCreateStep extends AzureWizardExecuteStep<IBindingWizardContext> {
+export class LocalAppSettingCreateStep extends AzureWizardExecuteStepWithActivityOutput<IBindingWizardContext> {
     public priority: number = 210;
+    stepName = 'localAppSettingCreateStep';
+    public getTreeItemLabel(_context: IBindingWizardContext): string {
+        return localize('localAppSetting', 'Update {0}', localSettingsFileName);
+    }
+    public getOutputLogSuccess(_context: IBindingWizardContext): string {
+        return localize('localAppSettingSuccess', 'Successfully updated {0}.', localSettingsFileName);
+    }
+    public getOutputLogFail(_context: IBindingWizardContext): string {
+        return localize('localAppSettingFail', 'Failed to update {0}.', localSettingsFileName);
+    }
+    public getOutputLogProgress(_context: IBindingWizardContext): string {
+        return localize('updatingLocalSettings', 'Updating {0}...', localSettingsFileName);
+    }
 
     private readonly _setting: IBindingSetting | ParsedInput;
     private readonly _valueKey: string;
@@ -26,8 +39,7 @@ export class LocalAppSettingCreateStep extends AzureWizardExecuteStep<IBindingWi
         this._valueKey = valueKey;
     }
 
-    public async execute(context: IBindingWizardContext, progress: Progress<{ message?: string | undefined; increment?: number | undefined }>): Promise<void> {
-        progress.report({ message: localize('updatingLocalSettings', 'Updating {0}...', localSettingsFileName) });
+    public async execute(context: IBindingWizardContext, _progress: Progress<{ message?: string | undefined; increment?: number | undefined }>): Promise<void> {
         const appSettingName = String(nonNullValue(getBindingSetting(context, this._setting), this._setting.name));
         await setLocalAppSetting(context, context.projectPath, appSettingName, nonNullProp(context, this._valueKey as keyof IBindingWizardContext) as string);
         // if the binding isn't already set then a new one was created

src/commands/addBinding/settingSteps/LocalAppSettingCreateStep.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { AzExtFsExtra, AzureWizardExecuteStep, callWithTelemetryAndErrorHandling, nonNullValue, type IActionContext } from '@microsoft/vscode-azext-utils';
+import { AzExtFsExtra, AzureWizardExecuteStepWithActivityOutput, callWithTelemetryAndErrorHandling, nonNullValue, type IActionContext } from '@microsoft/vscode-azext-utils';
 import * as path from 'path';
 import { Uri, window, workspace, type Progress } from 'vscode';
 import { hostFileName } from '../../constants';
@@ -35,9 +35,25 @@ export async function runPostFunctionCreateStepsFromCache(): Promise<void> {
     }
 }
 
-export abstract class FunctionCreateStepBase<T extends IFunctionWizardContext> extends AzureWizardExecuteStep<T> {
+export abstract class FunctionCreateStepBase<T extends IFunctionWizardContext> extends AzureWizardExecuteStepWithActivityOutput<T> {
     public priority: number = 220;
-
+    public stepName: string = 'FunctionCreateStepBase';
+    public getTreeItemLabel(context: T): string {
+        const template: FunctionTemplateBase = nonNullValue(context.functionTemplate);
+        return localize('creatingFunction', 'Create new {0} "{1}"', template.name, context.functionName);
+    }
+    public getOutputLogSuccess(context: T): string {
+        const template: FunctionTemplateBase = nonNullValue(context.functionTemplate);
+        return localize('createdFunction', 'Successfully created new {0} "{1}".', template.name, context.functionName);
+    }
+    public getOutputLogFail(context: T): string {
+        const template: FunctionTemplateBase = nonNullValue(context.functionTemplate);
+        return localize('failedToCreateFunction', 'Failed to create new {0} "{1}".', template.name, context.functionName);
+    }
+    public getOutputLogProgress(context: T): string {
+        const template: FunctionTemplateBase = nonNullValue(context.functionTemplate);
+        return localize('creatingFunction', 'Creating new {0} "{1}"...', template.name, context.functionName);
+    }
     /**
      * Returns the full path to the new function file
      */

src/commands/createFunction/FunctionCreateStepBase.ts

@@ -3,15 +3,15 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { type ISubscriptionContext } from "@microsoft/vscode-azext-utils";
+import { type ExecuteActivityContext, type ISubscriptionContext } from "@microsoft/vscode-azext-utils";
 import { type DurableBackendValues } from "../../constants";
 import { type BindingSettingValue } from "../../funcConfig/function";
 import { type IBindingSetting } from "../../templates/IBindingTemplate";
 import { type FunctionTemplateBase } from "../../templates/IFunctionTemplate";
 import { type ParsedInput, type ParsedJob } from "../../templates/script/parseScriptTemplatesV2";
 import { type IProjectWizardContext } from "../createNewProject/IProjectWizardContext";
 
-export interface IFunctionWizardContext extends Partial<ISubscriptionContext>, IProjectWizardContext {
+export interface IFunctionWizardContext extends Partial<ISubscriptionContext>, IProjectWizardContext, ExecuteActivityContext {
     functionTemplate?: FunctionTemplateBase;
     functionName?: string;
 

src/commands/createFunction/IFunctionWizardContext.ts

@@ -9,6 +9,7 @@ import { JobType, type ParsedJob } from '../../templates/script/parseScriptTempl
 import { assertTemplateIsV2 } from '../../utils/templateVersionUtils';
 import { isFunctionProject } from '../createNewProject/verifyIsProject';
 import { type FunctionV2WizardContext, type IFunctionWizardContext } from './IFunctionWizardContext';
+import { JobNameExecuteStep } from './actionStepsV2/JobNameExecuteStep';
 import { actionStepFactory } from './actionStepsV2/actionStepFactory';
 import { promptStepFactory } from './promptStepsV2/promptStepFactory';
 
@@ -34,9 +35,10 @@ export class JobsListStep extends AzureWizardPromptStep<IFunctionWizardContext>
             });
 
             const executeSteps: AzureWizardExecuteStep<FunctionV2WizardContext>[] = [];
+            executeSteps.push(new JobNameExecuteStep(context.job.name));
             context.job.parsedActions.map((pa, index) => {
                 // add index to increment the priority number; start at 500 so other execute steps can be injected
-                executeSteps.push(actionStepFactory(pa, index + 500));
+                executeSteps.push(actionStepFactory(pa, index + 1 + 500));
             });
 
             return { promptSteps, executeSteps };

src/commands/createFunction/JobsListStep.ts

@@ -12,6 +12,7 @@ export abstract class ActionSchemaStepBase<T extends FunctionV2WizardContext> ex
         super();
     }
 
+    public stepName = `${this.action.name}ActionSchemaStep`;
     public async execute(context: T): Promise<void> {
         try {
             await this.executeAction(context);