Merge with main

Author: MicroFish91

package.json

@@ -195,8 +195,8 @@
                 "category": "Azure Container Apps"
             },
             {
-                "command": "containerApps.editScalingRange",
-                "title": "%containerApps.editScalingRange%",
+                "command": "containerApps.editScaleRange",
+                "title": "%containerApps.editScaleRange%",
                 "category": "Azure Container Apps"
             },
             {
@@ -405,7 +405,7 @@
                     "group": "2@1"
                 },
                 {
-                    "command": "containerApps.editScalingRange",
+                    "command": "containerApps.editScaleRange",
                     "when": "view =~ /(azureResourceGroups|azureFocusView)/ && viewItem =~ /scaleItem/i",
                     "group": "1@1"
                 },

package.nls.json

@@ -35,7 +35,7 @@
     "containerApps.deleteConfirmation.ClickButton": "Prompts with a warning dialog where you click a button to delete.",
     "containerApps.openInPortal": "Open in Portal",
     "containerApps.openConsoleInPortal": "Open Console in Portal",
-    "containerApps.editScalingRange": "Edit Scaling Range...",
+    "containerApps.editScaleRange": "Edit Scaling Range...",
     "containerApps.addScaleRule": "Add Scale Rule...",
     "containerApps.deleteScaleRule": "Delete Scale Rule...",
     "containerApps.connectToGitHub": "Connect to GitHub Repository...",

src/commands/EXECUTE_PRIORITY.md

@@ -93,6 +93,7 @@ Reserved
 
 #### Steps
 
+- ScaleRangeUpdateStep: 1110
 - AddScaleRuleStep: 1120
 
 ### 10. Unallocated Space

src/commands/createContainerApp/ContainerAppCreateStep.ts

@@ -6,23 +6,23 @@
 import { ContainerAppsAPIClient, Ingress, KnownActiveRevisionsMode } from "@azure/arm-appcontainers";
 import { LocationListStep } from "@microsoft/vscode-azext-azureutils";
 import { GenericTreeItem, nonNullProp, nonNullValueAndProp } from "@microsoft/vscode-azext-utils";
-import { Progress } from "vscode";
+import type { Progress } from "vscode";
 import { activityFailContext, activityFailIcon, activitySuccessContext, activitySuccessIcon, containerAppsWebProvider } from "../../constants";
 import { ContainerAppItem } from "../../tree/ContainerAppItem";
 import { ExecuteActivityOutput, ExecuteActivityOutputStepBase } from "../../utils/activity/ExecuteActivityOutputStepBase";
 import { createActivityChildContext } from "../../utils/activity/activityUtils";
 import { createContainerAppsAPIClient } from "../../utils/azureClients";
 import { localize } from "../../utils/localize";
 import { getContainerNameForImage } from "../deployImage/imageSource/containerRegistry/getContainerNameForImage";
-import { ICreateContainerAppContext } from "./ICreateContainerAppContext";
+import type { ICreateContainerAppContext } from "./ICreateContainerAppContext";
 
 export class ContainerAppCreateStep extends ExecuteActivityOutputStepBase<ICreateContainerAppContext> {
     public priority: number = 750;
 
     protected async executeCore(context: ICreateContainerAppContext, progress: Progress<{ message?: string | undefined; increment?: number | undefined }>): Promise<void> {
         const appClient: ContainerAppsAPIClient = await createContainerAppsAPIClient(context);
 
-        const resourceGroupName: string = context.newResourceGroupName || nonNullValueAndProp(context.resourceGroup, 'name');
+        const resourceGroupName: string = nonNullValueAndProp(context.resourceGroup, 'name');
         const containerAppName: string = nonNullProp(context, 'newContainerAppName');
 
         const ingress: Ingress | undefined = context.enableIngress ? {
@@ -74,25 +74,25 @@ export class ContainerAppCreateStep extends ExecuteActivityOutputStepBase<ICreat
         return !context.containerApp;
     }
 
-    protected initSuccessOutput(context: ICreateContainerAppContext): ExecuteActivityOutput {
+    protected createSuccessOutput(context: ICreateContainerAppContext): ExecuteActivityOutput {
         return {
             item: new GenericTreeItem(undefined, {
                 contextValue: createActivityChildContext(['containerAppCreateStep', activitySuccessContext]),
                 label: localize('createContainerApp', 'Create container app "{0}"', context.newContainerAppName),
                 iconPath: activitySuccessIcon
             }),
-            output: localize('createContainerAppSuccess', 'Created container app "{0}".', context.newContainerAppName)
+            message: localize('createContainerAppSuccess', 'Created container app "{0}".', context.newContainerAppName)
         };
     }
 
-    protected initFailOutput(context: ICreateContainerAppContext): ExecuteActivityOutput {
+    protected createFailOutput(context: ICreateContainerAppContext): ExecuteActivityOutput {
         return {
             item: new GenericTreeItem(undefined, {
                 contextValue: createActivityChildContext(['containerAppCreateStep', activityFailContext]),
                 label: localize('createContainerApp', 'Create container app "{0}"', context.newContainerAppName),
                 iconPath: activityFailIcon
             }),
-            output: localize('createContainerAppFail', 'Failed to create container app "{0}".', context.newContainerAppName)
+            message: localize('createContainerAppFail', 'Failed to create container app "{0}".', context.newContainerAppName)
         };
     }
 }

src/commands/createContainerApp/createContainerApp.ts

@@ -3,8 +3,9 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { LocationListStep, VerifyProvidersStep } from "@microsoft/vscode-azext-azureutils";
-import { AzureWizard, AzureWizardExecuteStep, AzureWizardPromptStep, IActionContext, ICreateChildImplContext, createSubscriptionContext, nonNullProp } from "@microsoft/vscode-azext-utils";
+import type { ResourceGroup } from "@azure/arm-resources";
+import { LocationListStep, ResourceGroupListStep, VerifyProvidersStep } from "@microsoft/vscode-azext-azureutils";
+import { AzureWizard, AzureWizardExecuteStep, AzureWizardPromptStep, IActionContext, createSubscriptionContext, nonNullProp, nonNullValue, nonNullValueAndProp } from "@microsoft/vscode-azext-utils";
 import { webProvider } from "../../constants";
 import { ext } from "../../extensionVariables";
 import { ContainerAppItem } from "../../tree/ContainerAppItem";
@@ -19,21 +20,19 @@ import { ContainerAppNameStep } from "./ContainerAppNameStep";
 import type { ICreateContainerAppContext } from "./ICreateContainerAppContext";
 import { showContainerAppCreated } from "./showContainerAppCreated";
 
-export async function createContainerApp(context: IActionContext & Partial<ICreateChildImplContext> & Partial<ICreateContainerAppContext>, node?: ManagedEnvironmentItem): Promise<ContainerAppItem> {
-    node ??= await pickEnvironment(context, {
-        title: localize('createContainerApp', 'Create Container App'),
-    });
+export async function createContainerApp(context: IActionContext, node?: ManagedEnvironmentItem): Promise<ContainerAppItem> {
+    node ??= await pickEnvironment(context);
 
     const wizardContext: ICreateContainerAppContext = {
         ...context,
         ...createSubscriptionContext(node.subscription),
-        ...(await createActivityContext()),
+        ...await createActivityContext(),
         subscription: node.subscription,
         managedEnvironmentId: node.managedEnvironment.id,
         alwaysPromptIngress: true
     };
 
-    const title: string = localize('createContainerApp', 'Create Container App');
+    const title: string = localize('createContainerApp', 'Create container app');
 
     const promptSteps: AzureWizardPromptStep<ICreateContainerAppContext>[] = [
         new ContainerAppNameStep(),
@@ -46,7 +45,11 @@ export async function createContainerApp(context: IActionContext & Partial<ICrea
         new ContainerAppCreateStep(),
     ];
 
-    wizardContext.newResourceGroupName = node.resource.resourceGroup;
+    // Use the same resource group and location as the parent resource (managed environment)
+    const resourceGroupName: string = nonNullValueAndProp(node.resource, 'resourceGroup');
+    const resourceGroups: ResourceGroup[] = await ResourceGroupListStep.getResourceGroups(wizardContext);
+    wizardContext.resourceGroup = nonNullValue(resourceGroups.find(rg => rg.name === resourceGroupName));
+
     await LocationListStep.setLocation(wizardContext, nonNullProp(node.resource, 'location'));
 
     const wizard: AzureWizard<ICreateContainerAppContext> = new AzureWizard(wizardContext, {
@@ -64,9 +67,9 @@ export async function createContainerApp(context: IActionContext & Partial<ICrea
 
     await ext.state.showCreatingChild(
         node.managedEnvironment.id,
-        localize('creatingContainerApp', 'Creating Container App "{0}"...', newContainerAppName),
+        localize('creatingContainerApp', 'Creating container app "{0}"...', newContainerAppName),
         async () => {
-            wizardContext.activityTitle = localize('createNamedContainerApp', 'Create Container App "{0}"', newContainerAppName);
+            wizardContext.activityTitle = localize('createNamedContainerApp', 'Create container app "{0}"', newContainerAppName);
             await wizard.execute();
         });
 

src/commands/createManagedEnvironment/LogAnalyticsCreateStep.ts

@@ -5,14 +5,14 @@
 
 import { LocationListStep } from "@microsoft/vscode-azext-azureutils";
 import { GenericTreeItem } from "@microsoft/vscode-azext-utils";
-import { Progress } from "vscode";
+import type { Progress } from "vscode";
 import { activityFailContext, activityFailIcon, activitySuccessContext, activitySuccessIcon } from "../../constants";
 import { ExecuteActivityOutput, ExecuteActivityOutputStepBase } from "../../utils/activity/ExecuteActivityOutputStepBase";
 import { createActivityChildContext } from "../../utils/activity/activityUtils";
 import { createOperationalInsightsManagementClient } from "../../utils/azureClients";
 import { localize } from "../../utils/localize";
 import { nonNullProp } from "../../utils/nonNull";
-import { IManagedEnvironmentContext } from "./IManagedEnvironmentContext";
+import type { IManagedEnvironmentContext } from "./IManagedEnvironmentContext";
 
 export class LogAnalyticsCreateStep extends ExecuteActivityOutputStepBase<IManagedEnvironmentContext> {
     public priority: number = 220;
@@ -33,25 +33,25 @@ export class LogAnalyticsCreateStep extends ExecuteActivityOutputStepBase<IManag
         return !context.logAnalyticsWorkspace;
     }
 
-    protected initSuccessOutput(context: IManagedEnvironmentContext): ExecuteActivityOutput {
+    protected createSuccessOutput(context: IManagedEnvironmentContext): ExecuteActivityOutput {
         return {
             item: new GenericTreeItem(undefined, {
                 contextValue: createActivityChildContext(['logAnalyticsCreateStep', activitySuccessContext]),
                 label: localize('createWorkspace', 'Create log analytics workspace "{0}"', context.newManagedEnvironmentName),
                 iconPath: activitySuccessIcon
             }),
-            output: localize('createLogAnalyticsWorkspaceSuccess', 'Created log analytics workspace "{0}".', context.newManagedEnvironmentName)
+            message: localize('createLogAnalyticsWorkspaceSuccess', 'Created log analytics workspace "{0}".', context.newManagedEnvironmentName)
         };
     }
 
-    protected initFailOutput(context: IManagedEnvironmentContext): ExecuteActivityOutput {
+    protected createFailOutput(context: IManagedEnvironmentContext): ExecuteActivityOutput {
         return {
             item: new GenericTreeItem(undefined, {
                 contextValue: createActivityChildContext(['logAnalyticsCreateStep', activityFailContext]),
                 label: localize('createWorkspace', 'Create log analytics workspace "{0}"', context.newManagedEnvironmentName),
                 iconPath: activityFailIcon
             }),
-            output: localize('createLogAnalyticsWorkspaceFail', 'Failed to create log analytics workspace "{0}".', context.newManagedEnvironmentName)
+            message: localize('createLogAnalyticsWorkspaceFail', 'Failed to create log analytics workspace "{0}".', context.newManagedEnvironmentName)
         };
     }
 }

src/commands/createManagedEnvironment/ManagedEnvironmentCreateStep.ts

@@ -59,25 +59,25 @@ export class ManagedEnvironmentCreateStep extends ExecuteActivityOutputStepBase<
         return !context.managedEnvironment;
     }
 
-    protected initSuccessOutput(context: IManagedEnvironmentContext): ExecuteActivityOutput {
+    protected createSuccessOutput(context: IManagedEnvironmentContext): ExecuteActivityOutput {
         return {
             item: new GenericTreeItem(undefined, {
                 contextValue: createActivityChildContext(['managedEnvironmentCreateStep', activitySuccessContext]),
                 label: localize('createManagedEnvironment', 'Create container apps environment "{0}"', context.newManagedEnvironmentName),
                 iconPath: activitySuccessIcon
             }),
-            output: localize('createdManagedEnvironmentSuccess', 'Created container apps environment "{0}".', context.newManagedEnvironmentName)
+            message: localize('createdManagedEnvironmentSuccess', 'Created container apps environment "{0}".', context.newManagedEnvironmentName)
         };
     }
 
-    protected initFailOutput(context: IManagedEnvironmentContext): ExecuteActivityOutput {
+    protected createFailOutput(context: IManagedEnvironmentContext): ExecuteActivityOutput {
         return {
             item: new GenericTreeItem(undefined, {
                 contextValue: createActivityChildContext(['managedEnvironmentCreateStep', activityFailContext]),
                 label: localize('createManagedEnvironment', 'Create container apps environment "{0}"', context.newManagedEnvironmentName),
                 iconPath: activityFailIcon
             }),
-            output: localize('createdManagedEnvironmentFail', 'Failed to create container apps environment "{0}".', context.newManagedEnvironmentName)
+            message: localize('createdManagedEnvironmentFail', 'Failed to create container apps environment "{0}".', context.newManagedEnvironmentName)
         };
     }
 }

src/commands/createManagedEnvironment/createManagedEnvironment.ts

@@ -21,11 +21,11 @@ export async function createManagedEnvironment(context: IActionContext, node?: {
     const wizardContext: IManagedEnvironmentContext = {
         ...context,
         ...createSubscriptionContext(subscription),
-        ...(await createActivityContext()),
+        ...await createActivityContext(),
         subscription
     };
 
-    const title: string = localize('createManagedEnv', 'Create Container Apps environment');
+    const title: string = localize('createManagedEnv', 'Create container apps environment');
     const promptSteps: AzureWizardPromptStep<IManagedEnvironmentContext>[] = [];
     const executeSteps: AzureWizardExecuteStep<IManagedEnvironmentContext>[] = [];
 
@@ -44,7 +44,7 @@ export async function createManagedEnvironment(context: IActionContext, node?: {
     await wizard.prompt();
     const newManagedEnvName = nonNullProp(wizardContext, 'newManagedEnvironmentName');
     wizardContext.newResourceGroupName = newManagedEnvName;
-    wizardContext.activityTitle = localize('createNamedManagedEnv', 'Create Container Apps environment "{0}"', newManagedEnvName);
+    wizardContext.activityTitle = localize('createNamedManagedEnv', 'Create container apps environment "{0}"', newManagedEnvName);
     await wizard.execute();
 
     ext.branchDataProvider.refresh();

src/commands/deleteContainerApp/deleteContainerApp.ts

@@ -5,12 +5,9 @@
 
 import { IActionContext } from "@microsoft/vscode-azext-utils";
 import { ContainerAppItem } from "../../tree/ContainerAppItem";
-import { localize } from "../../utils/localize";
 import { pickContainerApp } from "../../utils/pickItem/pickContainerApp";
 
 export async function deleteContainerApp(context: IActionContext, node?: ContainerAppItem): Promise<void> {
-    node ??= await pickContainerApp(context, {
-        title: localize('deleteContainerApp', 'Delete Container App'),
-    });
+    node ??= await pickContainerApp(context);
     await node.delete(context);
 }

src/commands/deployImage/ContainerAppUpdateStep.ts

@@ -48,25 +48,25 @@ export class ContainerAppUpdateStep extends ExecuteActivityOutputStepBase<IDeplo
         return !!context.containerApp;
     }
 
-    protected initSuccessOutput(context: IDeployImageContext): ExecuteActivityOutput {
+    protected createSuccessOutput(context: IDeployImageContext): ExecuteActivityOutput {
         return {
             item: new GenericTreeItem(undefined, {
                 contextValue: createActivityChildContext(['containerAppUpdateStep', activitySuccessContext]),
                 label: localize('updateContainerAppLabel', 'Update container app "{0}"', context.containerApp?.name),
                 iconPath: activitySuccessIcon
             }),
-            output: localize('updateContainerAppSuccess', 'Updated container app "{0}".', context.containerApp?.name)
+            message: localize('updateContainerAppSuccess', 'Updated container app "{0}".', context.containerApp?.name)
         };
     }
 
-    protected initFailOutput(context: IDeployImageContext): ExecuteActivityOutput {
+    protected createFailOutput(context: IDeployImageContext): ExecuteActivityOutput {
         return {
             item: new GenericTreeItem(undefined, {
                 contextValue: createActivityChildContext(['containerAppUpdateStep', activityFailContext]),
                 label: localize('updateContainerAppLabel', 'Update container app "{0}"', context.containerApp?.name),
                 iconPath: activityFailIcon
             }),
-            output: localize('updateContainerAppFail', 'Failed to update container app "{0}".', context.containerApp?.name)
+            message: localize('updateContainerAppFail', 'Failed to update container app "{0}".', context.containerApp?.name)
         };
     }
 }